@atomic-ehr/codegen 0.0.1-canary.20250929141928.699688c → 0.0.1-canary.20250930124137.175bd5f

package/dist/typeschema/parser.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * TypeSchema Parser
  *
@@ -27,9 +26,7 @@ export class TypeSchemaParser {
      */
     async parseFromFile(filePath) {
         const content = await readFile(filePath, "utf-8");
-        const format = this.options.format === "auto"
-            ? this.detectFormat(content, filePath)
-            : this.options.format;
+        const format = this.options.format === "auto" ? this.detectFormat(content, filePath) : this.options.format;
         return this.parseFromString(content, format);
     }
     /**
@@ -102,73 +99,75 @@ export class TypeSchemaParser {
     /**
      * Get all dependencies from a schema
      */
-    getDependencies(schema) {
-        const dependencies = [];
-        // Add base dependency
-        if ("base" in schema && schema.base) {
-            dependencies.push(schema.base);
-        }
-        // Add explicit dependencies
-        if ("dependencies" in schema && schema.dependencies) {
-            dependencies.push(...schema.dependencies);
-        }
-        // Add field type dependencies
-        if ("fields" in schema && schema.fields) {
-            for (const field of Object.values(schema.fields)) {
-                if ("type" in field && field.type) {
-                    dependencies.push(field.type);
-                }
-                if ("binding" in field && field.binding) {
-                    dependencies.push(field.binding);
-                }
-                if ("reference" in field && field.reference) {
-                    dependencies.push(...field.reference);
-                }
-            }
-        }
-        // Add nested type dependencies
-        if ("nested" in schema && schema.nested) {
-            for (const nested of schema.nested) {
-                dependencies.push(nested.identifier);
-                dependencies.push(nested.base);
-                for (const field of Object.values(nested.fields)) {
-                    if ("type" in field && field.type) {
-                        dependencies.push(field.type);
-                    }
-                    if ("binding" in field && field.binding) {
-                        dependencies.push(field.binding);
-                    }
-                    if ("reference" in field && field.reference) {
-                        dependencies.push(...field.reference);
-                    }
-                }
-            }
-        }
-        // Add binding dependencies
-        if ("valueset" in schema) {
-            const bindingSchema = schema;
-            dependencies.push(bindingSchema.valueset);
-            if (bindingSchema.type) {
-                dependencies.push(bindingSchema.type);
-            }
-        }
-        // Remove duplicates
-        return this.deduplicateDependencies(dependencies);
-    }
+    // getDependencies(schema: TypeSchema): Identifier[] {
+    //   const dependencies: Identifier[] = [];
+    //   // Add base dependency
+    //   if ("base" in schema && schema.base) {
+    //     dependencies.push(schema.base);
+    //   }
+    //   // Add explicit dependencies
+    //   if ("dependencies" in schema && schema.dependencies) {
+    //     dependencies.push(...schema.dependencies);
+    //   }
+    //   // Add field type dependencies
+    //   if ("fields" in schema && schema.fields) {
+    //     for (const field of Object.values(schema.fields)) {
+    //       if ("type" in field && field.type) {
+    //         dependencies.push(field.type);
+    //       }
+    //       if ("binding" in field && field.binding) {
+    //         dependencies.push(field.binding);
+    //       }
+    //       if ("reference" in field && field.reference) {
+    //         dependencies.push(...field.reference);
+    //       }
+    //     }
+    //   }
+    //   if ("nested" in schema && schema.nested) {
+    //     for (const nested of schema.nested) {
+    //       dependencies.push(nested.identifier);
+    //       dependencies.push(nested.base);
+    //       for (const field of Object.values(nested.fields)) {
+    //         if ("type" in field && field.type) {
+    //           dependencies.push(field.type);
+    //         }
+    //         if ("binding" in field && field.binding) {
+    //           dependencies.push(field.binding);
+    //         }
+    //         if ("reference" in field && field.reference) {
+    //           dependencies.push(...field.reference);
+    //         }
+    //       }
+    //     }
+    //   }
+    //   // Add binding dependencies
+    //   if ("valueset" in schema) {
+    //     const bindingSchema = schema as any;
+    //     dependencies.push(bindingSchema.valueset);
+    //     if (bindingSchema.type) {
+    //       dependencies.push(bindingSchema.type);
+    //     }
+    //   }
+    //   // Remove duplicates
+    //   return this.deduplicateDependencies(dependencies);
+    // }
     /**
      * Resolve schema dependencies
      */
-    resolveDependencies(schemas, targetSchema) {
-        const dependencies = this.getDependencies(targetSchema);
-        const resolved = [];
-        for (const dep of dependencies) {
-            const depSchema = this.findByUrl(schemas, dep.url);
-            if (depSchema) {
-                resolved.push(depSchema);
-            }
-        }
-        return resolved;
-    }
+    // resolveDependencies(
+    //   schemas: TypeSchema[],
+    //   targetSchema: TypeSchema,
+    // ): TypeSchema[] {
+    //   const dependencies = this.getDependencies(targetSchema);
+    //   const resolved: TypeSchema[] = [];
+    //   for (const dep of dependencies) {
+    //     const depSchema = this.findByUrl(schemas, dep.url);
+    //     if (depSchema) {
+    //       resolved.push(depSchema);
+    //     }
+    //   }
+    //   return resolved;
+    // }
     /**
      * Detect format from content or filename
      */
@@ -272,20 +271,6 @@ export class TypeSchemaParser {
             (!criteria.name || identifier.name === criteria.name) &&
             (!criteria.url || identifier.url === criteria.url));
     }
-    /**
-     * Remove duplicate dependencies
-     */
-    deduplicateDependencies(deps) {
-        const seen = new Set();
-        const unique = [];
-        for (const dep of deps) {
-            if (!seen.has(dep.url)) {
-                seen.add(dep.url);
-                unique.push(dep);
-            }
-        }
-        return unique.sort((a, b) => a.name.localeCompare(b.name));
-    }
 }
 /**
  * Convenience function to parse TypeSchema from file

package/dist/typeschema/profile/processor.d.ts

@@ -4,10 +4,11 @@
  * Handles transformation of FHIR profiles to TypeSchema format
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
+import type { Register } from "@root/typeschema/register";
+import type { RichFHIRSchema } from "@typeschema/types";
 import type { TypeSchemaForProfile } from "../types";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
  */
-export declare function transformProfile(fhirSchema: RichFHIRSchema, manager: ReturnType<typeof CanonicalManager>): Promise<TypeSchemaForProfile>;
+export declare function transformProfile(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchemaForProfile>;

package/dist/typeschema/profile/processor.js

@@ -1,19 +1,18 @@
-// @ts-nocheck
 /**
  * Profile Processor (DEPRECATED - Profiles not in core TypeSchema spec)
  *
  * Handles transformation of FHIR profiles to TypeSchema format
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
-import { buildSchemaIdentifier } from "../core/identifier";
+import { mkIdentifier } from "../core/identifier";
 import { transformElements } from "../core/transformer";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
  */
-export async function transformProfile(fhirSchema, manager) {
+export async function transformProfile(register, fhirSchema) {
     // Build profile identifier
-    const identifier = buildSchemaIdentifier(fhirSchema);
+    const identifier = mkIdentifier(fhirSchema);
     const packageInfo = fhirSchema.package_meta;
     // Ensure this is recognized as a profile
     if (identifier.kind !== "profile") {
@@ -27,17 +26,13 @@ export async function transformProfile(fhirSchema, manager) {
             : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
         const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
         // Determine base kind - could be another profile or a base resource
-        const baseKind = await determineBaseKind(baseUrl, manager);
+        const baseKind = await determineBaseKind(baseUrl, register);
         // For standard FHIR types, use the standard package
         const isStandardFhir = baseUrl.startsWith("http://hl7.org/fhir/");
         base = {
             kind: baseKind,
-            package: isStandardFhir
-                ? "hl7.fhir.r4.core"
-                : fhirSchema.package_meta.name || "undefined",
-            version: isStandardFhir
-                ? "4.0.1"
-                : fhirSchema.package_meta.version || "undefined",
+            package: isStandardFhir ? "hl7.fhir.r4.core" : fhirSchema.package_meta.name || "undefined",
+            version: isStandardFhir ? "4.0.1" : fhirSchema.package_meta.version || "undefined",
             name: baseName,
             url: baseUrl,
         };
@@ -59,18 +54,18 @@ export async function transformProfile(fhirSchema, manager) {
     }
     // Process profile fields from differential elements
     if (fhirSchema.elements) {
-        const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
-        if (Object.keys(fields).length > 0) {
+        const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+        if (fields && Object.keys(fields).length > 0) {
             profileSchema.fields = fields;
         }
     }
     // Process profile constraints
-    const constraints = await processProfileConstraints(fhirSchema, manager);
+    const constraints = await processProfileConstraints(fhirSchema, register);
     if (Object.keys(constraints).length > 0) {
         profileSchema.constraints = constraints;
     }
     // Process extensions
-    const extensions = await processProfileExtensions(fhirSchema, manager);
+    const extensions = await processProfileExtensions(fhirSchema, register);
     if (extensions.length > 0) {
         profileSchema.extensions = extensions;
     }
@@ -107,8 +102,7 @@ async function determineBaseKind(baseUrl, manager) {
     // Check if the URL suggests it's a profile from any implementation guide
     // Non-standard FHIR StructureDefinition URLs (not from base FHIR) are likely profiles
     // Check if it's any other profile URL pattern
-    if (baseUrl.includes("StructureDefinition/") &&
-        !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
+    if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
         // Non-standard FHIR StructureDefinition URLs are likely profiles
         return "profile";
     }
@@ -192,9 +186,7 @@ async function processProfileConstraints(fhirSchema, _manager) {
             };
         }
         // Type constraints
-        if (element.type &&
-            Array.isArray(element.type) &&
-            element.type.length > 0) {
+        if (element.type && Array.isArray(element.type) && element.type.length > 0) {
             elementConstraints.types = element.type.map((t) => {
                 const typeConstraint = { code: t.code };
                 if (t.profile)
@@ -227,9 +219,7 @@ async function processProfileExtensions(fhirSchema, _manager) {
         return extensions;
     // Look for extension elements
     for (const [path, element] of Object.entries(fhirSchema.elements)) {
-        if (path.includes("extension") &&
-            element.type &&
-            Array.isArray(element.type)) {
+        if (path.includes("extension") && element.type && Array.isArray(element.type)) {
             for (const type of element.type) {
                 if (type.code === "Extension" && type.profile) {
                     extensions.push({

package/dist/typeschema/register.d.ts

@@ -0,0 +1,17 @@
+import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
+import type { FHIRSchema, StructureDefinition } from "@atomic-ehr/fhirschema";
+import type { CodegenLogger } from "@root/utils/codegen-logger";
+import { type PackageMeta, type RichFHIRSchema } from "@typeschema/types";
+export type Register = {
+    appendFs(fs: FHIRSchema): void;
+    ensureCanonicalUrl(canonicalUrl: string): string;
+    resolveSd(canonicalUrl: string): StructureDefinition | undefined;
+    resolveFs(canonicalUrl: string): RichFHIRSchema | undefined;
+    resolveFSGenealogy(canonicalUrl: string): RichFHIRSchema[] | undefined;
+    allSd(): StructureDefinition[];
+    allFs(): RichFHIRSchema[];
+    allVs(): any[];
+    complexTypeDict(): Record<string, RichFHIRSchema>;
+} & ReturnType<typeof CanonicalManager>;
+export declare const registerFromManager: (manager: ReturnType<typeof CanonicalManager>, logger?: CodegenLogger, packageInfo?: PackageMeta) => Promise<Register>;
+export declare const registerFromPackageMetas: (packageMetas: PackageMeta[], logger?: CodegenLogger) => Promise<Register>;

package/dist/typeschema/register.js

@@ -0,0 +1,77 @@
+import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
+import * as fhirschema from "@atomic-ehr/fhirschema";
+import { enrichFHIRSchema } from "@typeschema/types";
+export const registerFromManager = async (manager, logger, packageInfo) => {
+    const resources = await manager.search({});
+    const structureDefinitions = {};
+    for (const resource of resources) {
+        if (resource.resourceType === "StructureDefinition") {
+            structureDefinitions[resource.url] = resource;
+        }
+    }
+    const fhirSchemas = {};
+    const nameDict = {};
+    let [success, failed] = [0, 0];
+    for (const sd of Object.values(structureDefinitions)) {
+        try {
+            const fs = fhirschema.translate(sd);
+            const rfs = enrichFHIRSchema(fs, packageInfo);
+            fhirSchemas[rfs.url] = rfs;
+            nameDict[rfs.name] = rfs.url;
+            success++;
+        }
+        catch (error) {
+            logger?.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`);
+            failed++;
+        }
+        logger?.success(`FHIR Schema conversion completed: ${success}/${structureDefinitions.length} successful, ${failed} failed`);
+    }
+    const valueSets = {};
+    for (const resource of resources) {
+        if (resource.resourceType === "ValueSet") {
+            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)
+            return undefined;
+        const genealogy = [fs];
+        while (fs && fs.base) {
+            fs = fhirSchemas[fs.base];
+            genealogy.push(fs);
+        }
+        return genealogy;
+    };
+    return {
+        ...manager,
+        appendFs(fs) {
+            fhirSchemas[fs.url] = enrichFHIRSchema(fs);
+        },
+        resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
+        resolveFSGenealogy: resolveFSGenealogy,
+        ensureCanonicalUrl: (canonicalUrl) => nameDict[canonicalUrl] || canonicalUrl,
+        allSd: () => Object.values(structureDefinitions),
+        resolveSd: (canonicalUrl) => structureDefinitions[canonicalUrl],
+        allFs: () => Object.values(fhirSchemas),
+        allVs: () => Object.values(valueSets),
+        complexTypeDict: () => complexTypes,
+    };
+};
+export const registerFromPackageMetas = async (packageMetas, logger) => {
+    const packageNames = packageMetas.map((meta) => `${meta.name}@${meta.version}`);
+    logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+    const manager = CanonicalManager({
+        packages: packageNames,
+        workingDir: "tmp/fhir",
+    });
+    await manager.init();
+    // Pass package info from the first package (assuming single package for now)
+    return await registerFromManager(manager, logger, packageMetas[0]);
+};

package/dist/typeschema/types.d.ts

@@ -2,16 +2,16 @@
  * A code generation friendly representation of FHIR StructureDefinition and
  * FHIR Schema designed to simplify SDK resource classes/types generation.
  */
-import type * as FS from "@atomic-ehr/fhirschema";
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-export interface PackageInfo {
+import type * as FS from "@atomic-ehr/fhirschema";
+export interface PackageMeta {
     name: string;
     version: string;
 }
 export type RichFHIRSchema = Omit<FS.FHIRSchema, "package_meta"> & {
-    package_meta: PackageInfo;
+    package_meta: PackageMeta;
 };
-export declare const enrichFHIRSchema: (schema: FS.FHIRSchema) => RichFHIRSchema;
+export declare const enrichFHIRSchema: (schema: FS.FHIRSchema, packageMeta?: PackageMeta) => RichFHIRSchema;
 type IdentifierBase = {
     name: string;
     package: string;
@@ -27,13 +27,13 @@ type ComplexTypeIdentifier = {
 type ResourceIdentifier = {
     kind: "resource";
 } & IdentifierBase;
-type ValueSetIdentifier = {
+export type ValueSetIdentifier = {
     kind: "value-set";
 } & IdentifierBase;
-type NestedIdentifier = {
+export type NestedIdentifier = {
     kind: "nested";
 } & IdentifierBase;
-type BindingIdentifier = {
+export type BindingIdentifier = {
     kind: "binding";
 } & IdentifierBase;
 type ProfileIdentifier = {
@@ -50,7 +50,12 @@ interface TypeSchemaForPrimitiveType {
     base: Identifier;
     dependencies?: Identifier[];
 }
-interface TypeSchemaForProfile {
+export interface NestedType {
+    identifier: NestedIdentifier;
+    base: Identifier;
+    fields: Record<string, TypeSchemaField>;
+}
+export interface TypeSchemaForProfile {
     identifier: ProfileIdentifier;
     base: Identifier;
     description?: string;
@@ -60,9 +65,9 @@ interface TypeSchemaForProfile {
     validation?: ValidationRule[];
     dependencies?: Identifier[];
     metadata?: ProfileMetadata;
-    nested?: any[];
+    nested?: NestedType[];
 }
-interface ProfileConstraint {
+export interface ProfileConstraint {
     min?: number;
     max?: string;
     mustSupport?: boolean;
@@ -83,21 +88,21 @@ interface ProfileConstraint {
         ordered?: boolean;
     };
 }
-interface ProfileExtension {
+export interface ProfileExtension {
     path: string;
     profile: string | string[];
     min?: number;
     max?: string;
     mustSupport?: boolean;
 }
-interface ValidationRule {
+export interface ValidationRule {
     path: string;
     key: string;
     severity: "error" | "warning" | "information";
     human: string;
     expression?: string;
 }
-interface ProfileMetadata {
+export interface ProfileMetadata {
     publisher?: string;
     contact?: any[];
     copyright?: string;
@@ -107,20 +112,21 @@ interface ProfileMetadata {
     jurisdiction?: any[];
     package?: string;
 }
+export interface TypeSchemaNestedType {
+    identifier: NestedIdentifier;
+    base: Identifier;
+    fields?: {
+        [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
+    };
+}
 export interface TypeSchemaForResourceComplexTypeLogical {
-    identifier: ResourceIdentifier | ComplexTypeIdentifier | LogicalIdentifier;
+    identifier: Identifier;
     base?: Identifier;
     description?: string;
     fields?: {
         [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
     };
-    nested?: {
-        identifier: NestedIdentifier;
-        base: Identifier;
-        fields?: {
-            [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
-        };
-    }[];
+    nested?: TypeSchemaNestedType[];
     dependencies?: Identifier[];
 }
 export interface RegularField {
@@ -183,4 +189,9 @@ export interface TypeschemaGeneratorOptions {
     manager?: ReturnType<typeof CanonicalManager> | null;
 }
 export declare function isBindingSchema(schema: TypeSchema): schema is TypeSchemaForBinding;
+export type TypeschemaParserOptions = {
+    format?: "auto" | "ndjson" | "json";
+    validate?: boolean;
+    strict?: boolean;
+};
 export {};

package/dist/typeschema/types.js

@@ -2,13 +2,13 @@
  * A code generation friendly representation of FHIR StructureDefinition and
  * FHIR Schema designed to simplify SDK resource classes/types generation.
  */
-export const enrichFHIRSchema = (schema) => {
+export const enrichFHIRSchema = (schema, packageMeta) => {
+    if (!packageMeta) {
+        packageMeta = { name: "undefined", version: "undefined" };
+    }
     return {
         ...schema,
-        package_meta: {
-            name: schema.package_name || schema.package_meta?.name || "undefined",
-            version: schema.package_version || schema.package_meta?.version || "undefined",
-        },
+        package_meta: schema.package_meta || packageMeta,
     };
 };
 export function isBindingSchema(schema) {

package/dist/typeschema/value-set/processor.d.ts

@@ -4,7 +4,7 @@
  * Functions for transforming FHIR ValueSets into TypeSchema format
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { PackageInfo, TypeSchemaForValueSet } from "../types";
+import type { PackageMeta, TypeSchemaForValueSet } from "../types";
 /**
  * Extract all concepts from a ValueSet
  */
@@ -16,4 +16,4 @@ export declare function extractValueSetConcepts(valueSet: any, manager: ReturnTy
 /**
  * Transform a FHIR ValueSet to TypeSchema format
  */
-export declare function transformValueSet(valueSet: any, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchemaForValueSet>;
+export declare function transformValueSet(valueSet: any, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Promise<TypeSchemaForValueSet>;

package/dist/typeschema/value-set/processor.js

@@ -3,7 +3,7 @@
  *
  * Functions for transforming FHIR ValueSets into TypeSchema format
  */
-import { buildValueSetIdentifier } from "../core/identifier";
+import { mkValueSetIdentifier } from "../core/identifier";
 /**
  * Extract concepts from a CodeSystem
  */
@@ -117,7 +117,7 @@ export async function extractValueSetConcepts(valueSet, manager) {
  * Transform a FHIR ValueSet to TypeSchema format
  */
 export async function transformValueSet(valueSet, manager, packageInfo) {
-    const identifier = buildValueSetIdentifier(valueSet.url, valueSet, packageInfo);
+    const identifier = mkValueSetIdentifier(valueSet.url, valueSet, packageInfo);
     const typeSchemaValueSet = {
         identifier,
     };
@@ -152,7 +152,7 @@ export async function transformValueSet(valueSet, manager, packageInfo) {
                 }
                 if (item.valueSet) {
                     for (const vsUrl of item.valueSet) {
-                        deps.push(buildValueSetIdentifier(vsUrl, undefined, packageInfo));
+                        deps.push(mkValueSetIdentifier(vsUrl, undefined, packageInfo));
                     }
                 }
             }

package/dist/utils/codegen-logger.js

@@ -17,12 +17,8 @@ export class CodegenLogger {
         };
     }
     formatMessage(level, message, color) {
-        const timestamp = this.options.timestamp
-            ? `${pc.gray(new Date().toLocaleTimeString())} `
-            : "";
-        const prefix = this.options.prefix
-            ? `${pc.cyan(`[${this.options.prefix}]`)} `
-            : "";
+        const timestamp = this.options.timestamp ? `${pc.gray(new Date().toLocaleTimeString())} ` : "";
+        const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
         return `${timestamp}${color(level)} ${prefix}${message}`;
     }
     /**
@@ -79,12 +75,8 @@ export class CodegenLogger {
      * Plain message (no icon, just colored text)
      */
     plain(message, color = (s) => s) {
-        const timestamp = this.options.timestamp
-            ? `${pc.gray(new Date().toLocaleTimeString())} `
-            : "";
-        const prefix = this.options.prefix
-            ? `${pc.cyan(`[${this.options.prefix}]`)} `
-            : "";
+        const timestamp = this.options.timestamp ? `${pc.gray(new Date().toLocaleTimeString())} ` : "";
+        const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
         console.log(`${timestamp}${prefix}${color(message)}`);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250929141928.699688c",
+  "version": "0.0.1-canary.20250930124137.175bd5f",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",
@@ -64,7 +64,7 @@
   "homepage": "https://github.com/atomic-ehr/codegen#readme",
   "devDependencies": {
     "@biomejs/biome": "^2.1.4",
-    "@types/bun": "latest",
+    "@types/bun": "^1.2.23",
     "@types/handlebars": "^4.1.0",
     "@types/node": "^22.17.1",
     "@types/yargs": "^17.0.33",