@atomic-ehr/codegen 0.0.1-canary.20250930151649.b68ce8a → 0.0.1-canary.20251001124254.ddbda7d

package/dist/typeschema/core/field-builder.d.ts

@@ -6,31 +6,14 @@
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField } from "../types";
-/**
- * Get the full element hierarchy for a given path
- */
-export declare function getElementHierarchy(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): FHIRSchemaElement[];
-/**
- * Merge element hierarchy into a snapshot
- */
-export declare function mergeElementHierarchy(hierarchy: FHIRSchemaElement[]): FHIRSchemaElement;
-/**
- * Check if a field is required based on parent required arrays
- */
-export declare function isRequired(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
-/**
- * Check if a field is excluded
- */
-export declare function isExcluded(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
+import type { Field, Identifier, PackageMeta, RegularField, RichFHIRSchema } from "../types";
+export declare function isRequired(fhirSchema: FHIRSchema, path: string[]): boolean;
+export declare function isExcluded(fhirSchema: FHIRSchema, path: string[]): boolean;
 export declare const buildReferences: (element: FHIRSchemaElement, register: Register, _packageInfo?: PackageMeta) => Identifier[] | undefined;
 /**
  * Build field type identifier
  */
 export declare function buildFieldType(fhirSchema: RichFHIRSchema, _path: string[], element: FHIRSchemaElement, _manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Identifier | undefined;
-export declare const buildField: (fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, register: Register, packageInfo?: PackageMeta) => TypeSchemaField;
-/**
- * Check if an element represents a nested type (BackboneElement)
- */
+export declare const buildField: (fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, register: Register, packageInfo?: PackageMeta) => Field;
 export declare function isNestedElement(element: FHIRSchemaElement): boolean;
-export declare function mkNestedField(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, _packageInfo?: PackageMeta): TypeSchemaField;
+export declare function mkNestedField(_register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;

package/dist/typeschema/core/field-builder.js

@@ -5,76 +5,7 @@
  */
 import { buildEnum } from "./binding";
 import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-/**
- * Get the full element hierarchy for a given path
- */
-export function getElementHierarchy(fhirSchema, path, _manager) {
-    const hierarchy = [];
-    // Get element at path from current schema
-    let element = fhirSchema.elements;
-    for (const key of path) {
-        element = element?.[key];
-        if (!element)
-            break;
-    }
-    if (element) {
-        hierarchy.push(element);
-    }
-    // For now, we only use the current schema's element
-    // TODO: Implement base schema traversal when we have proper schema loading
-    return hierarchy;
-}
-/**
- * Merge element hierarchy into a snapshot
- */
-export function mergeElementHierarchy(hierarchy) {
-    // Handle empty hierarchy
-    if (hierarchy.length === 0) {
-        return {};
-    }
-    // Start with the most specific (first) element
-    const snapshot = { ...hierarchy[0] };
-    // Merge properties from base elements (reverse order to apply from base to specific)
-    for (let i = hierarchy.length - 1; i >= 0; i--) {
-        const element = hierarchy[i];
-        // Properties that should be taken from the most specific element
-        const specificProps = [
-            "choices",
-            "short",
-            "index",
-            "elements",
-            "required",
-            "excluded",
-            "binding",
-            "refers",
-            "elementReference",
-            "mustSupport",
-            "slices",
-            "slicing",
-            "url",
-            "extensions",
-        ];
-        // Merge non-specific properties
-        for (const [key, value] of Object.entries(element)) {
-            if (!specificProps.includes(key) && value !== undefined) {
-                snapshot[key] = value;
-            }
-        }
-    }
-    // Override with specific properties from the first element
-    for (const prop of ["choices", "binding", "refers", "elementReference"]) {
-        // @ts-ignore
-        if (hierarchy[0] && hierarchy[0][prop] !== undefined) {
-            // @ts-ignore
-            snapshot[prop] = hierarchy[0][prop];
-        }
-    }
-    return snapshot;
-}
-/**
- * Check if a field is required based on parent required arrays
- */
-export function isRequired(fhirSchema, path, _manager) {
+export function isRequired(fhirSchema, path) {
     if (path.length === 0)
         return false;
     const fieldName = path[path.length - 1];
@@ -96,10 +27,7 @@ export function isRequired(fhirSchema, path, _manager) {
     }
     return false;
 }
-/**
- * Check if a field is excluded
- */
-export function isExcluded(fhirSchema, path, _manager) {
+export function isExcluded(fhirSchema, path) {
     if (path.length === 0)
         return false;
     const fieldName = path[path.length - 1];
@@ -174,8 +102,8 @@ export const buildField = (fhirSchema, path, element, register, packageInfo) =>
     }
     return {
         type: buildFieldType(fhirSchema, path, element, register, packageInfo),
-        required: isRequired(fhirSchema, path, register),
-        excluded: isExcluded(fhirSchema, path, register),
+        required: isRequired(fhirSchema, path),
+        excluded: isExcluded(fhirSchema, path),
         reference: buildReferences(element, register, packageInfo),
         array: element.array || false,
         min: element.min,
@@ -185,29 +113,24 @@ export const buildField = (fhirSchema, path, element, register, packageInfo) =>
         binding: binding,
     };
 };
-function _removeEmptyValues(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== undefined && value !== null) {
-            if (Array.isArray(value) && value.length === 0) {
-                continue;
-            }
-            result[key] = value;
-        }
-    }
-    return result;
-}
-/**
- * Check if an element represents a nested type (BackboneElement)
- */
 export function isNestedElement(element) {
-    return (element.type === "BackboneElement" || (element.elements && Object.keys(element.elements).length > 0) || false);
+    const isBackbone = element.type === "BackboneElement";
+    const isElement = element.type === "Element" && element.elements !== undefined && Object.keys(element.elements).length > 0;
+    //     ;; TODO: Observation <- vitalsigns <- bodyweight
+    //     ;; In Observation we have value[x] with choices
+    //     ;; In bodyweight we have valueQuantity with additional constaraints on it's elements
+    //     ;; So we need to build nested type from Quantity for here, but don't do that right now.
+    const elementsWithoutType = element.type === undefined &&
+        element.choiceOf === undefined &&
+        element.elements !== undefined &&
+        Object.keys(element.elements).length > 0;
+    return isBackbone || isElement || elementsWithoutType;
 }
-export function mkNestedField(fhirSchema, path, element, manager, _packageInfo) {
+export function mkNestedField(_register, fhirSchema, path, element) {
     return {
         type: mkNestedIdentifier(fhirSchema, path),
         array: element.array || false,
-        required: isRequired(fhirSchema, path, manager),
-        excluded: isExcluded(fhirSchema, path, manager),
+        required: isRequired(fhirSchema, path),
+        excluded: isExcluded(fhirSchema, path),
     };
 }

package/dist/typeschema/core/identifier.d.ts

@@ -9,4 +9,4 @@ export declare function dropVersionFromUrl(url: string | undefined): string | un
 export declare function mkIdentifier(fhirSchema: RichFHIRSchema): Identifier;
 export declare function mkNestedIdentifier(fhirSchema: RichFHIRSchema, path: string[]): NestedIdentifier;
 export declare function mkValueSetIdentifier(valueSetUrl: string, valueSet: any, packageInfo?: PackageMeta): TypeSchemaForValueSet["identifier"];
-export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, packageInfo?: PackageMeta): BindingIdentifier;
+export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, _packageInfo?: PackageMeta): BindingIdentifier;

package/dist/typeschema/core/identifier.js

@@ -65,7 +65,7 @@ export function mkValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
         url: cleanUrl,
     };
 }
-export function mkBindingIdentifier(fhirSchema, path, bindingName, packageInfo) {
+export function mkBindingIdentifier(fhirSchema, path, bindingName, _packageInfo) {
     const pathStr = path.join(".");
     const [name, url] = bindingName
         ? [bindingName, `urn:fhir:binding:${bindingName}`]

package/dist/typeschema/core/nested-types.d.ts

@@ -5,17 +5,8 @@
  */
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField, TypeSchemaNestedType } from "../types";
-/**
- * Collect all nested elements from a FHIRSchema
- */
+import type { Field, Identifier, NestedType, PackageMeta, RichFHIRSchema } from "../types";
 export declare function collectNestedElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>): Array<[string[], FHIRSchemaElement]>;
-export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, packageInfo?: PackageMeta): Promise<Record<string, TypeSchemaField>>;
-/**
- * Build TypeSchema for all nested types in a FHIRSchema
- */
-export declare function buildNestedTypes(fhirSchema: RichFHIRSchema, register: Register, packageInfo?: PackageMeta): Promise<any[] | undefined>;
-/**
- * Extract dependencies from nested types
- */
-export declare function extractNestedDependencies(nestedTypes: TypeSchemaNestedType[]): Identifier[];
+export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, packageInfo?: PackageMeta): Promise<Record<string, Field>>;
+export declare function mkNestedTypes(register: Register, fhirSchema: RichFHIRSchema): Promise<NestedType[] | undefined>;
+export declare function extractNestedDependencies(nestedTypes: NestedType[]): Identifier[];

package/dist/typeschema/core/nested-types.js

@@ -5,18 +5,13 @@
  */
 import { buildField, isNestedElement, mkNestedField } from "./field-builder";
 import { mkNestedIdentifier } from "./identifier";
-/**
- * Collect all nested elements from a FHIRSchema
- */
 export function collectNestedElements(fhirSchema, parentPath, elements) {
     const nested = [];
     for (const [key, element] of Object.entries(elements)) {
         const path = [...parentPath, key];
-        // Add this element if it's nested (BackboneElement or has elements)
         if (isNestedElement(element)) {
             nested.push([path, element]);
         }
-        // Recursively collect from child elements
         if (element.elements) {
             nested.push(...collectNestedElements(fhirSchema, path, element.elements));
         }
@@ -29,7 +24,7 @@ export async function transformNestedElements(fhirSchema, parentPath, elements,
         const path = [...parentPath, key];
         if (isNestedElement(element)) {
             // Reference to another nested type
-            fields[key] = mkNestedField(fhirSchema, path, element, register, packageInfo);
+            fields[key] = mkNestedField(register, fhirSchema, path, element);
         }
         else {
             // Regular field
@@ -38,16 +33,12 @@ export async function transformNestedElements(fhirSchema, parentPath, elements,
     }
     return fields;
 }
-/**
- * Build TypeSchema for all nested types in a FHIRSchema
- */
-export async function buildNestedTypes(fhirSchema, register, packageInfo) {
+export async function mkNestedTypes(register, fhirSchema) {
     if (!fhirSchema.elements)
         return undefined;
-    const nestedTypes = [];
     const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
-    // Filter to only include elements that have sub-elements (actual nested types)
     const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
+    const nestedTypes = [];
     for (const [path, element] of actualNested) {
         const identifier = mkNestedIdentifier(fhirSchema, path);
         // Base is usually BackboneElement - ensure all nested types have a base
@@ -57,8 +48,8 @@ export async function buildNestedTypes(fhirSchema, register, packageInfo) {
             // For BackboneElement or undefined type, always use BackboneElement as base
             base = {
                 kind: "complex-type",
-                package: packageInfo?.name || "hl7.fhir.r4.core",
-                version: packageInfo?.version || "4.0.1",
+                package: fhirSchema.package_meta.name,
+                version: fhirSchema.package_meta.version,
                 name: "BackboneElement",
                 url: "http://hl7.org/fhir/StructureDefinition/BackboneElement",
             };
@@ -67,17 +58,17 @@ export async function buildNestedTypes(fhirSchema, register, packageInfo) {
             // Use the specified type as base
             base = {
                 kind: "complex-type",
-                package: packageInfo?.name || "hl7.fhir.r4.core",
-                version: packageInfo?.version || "4.0.1",
+                package: fhirSchema.package_meta.name,
+                version: fhirSchema.package_meta.version,
                 name: element.type,
                 url: `http://hl7.org/fhir/StructureDefinition/${element.type}`,
             };
         }
         // Transform sub-elements into fields
-        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, packageInfo);
+        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, fhirSchema.package_meta);
         const nestedType = {
             identifier,
-            base, // Always include base
+            base,
             fields,
         };
         nestedTypes.push(nestedType);
@@ -86,19 +77,12 @@ export async function buildNestedTypes(fhirSchema, register, packageInfo) {
     nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
     return nestedTypes;
 }
-/**
- * Extract dependencies from nested types
- */
 export function extractNestedDependencies(nestedTypes) {
     const deps = [];
     for (const nested of nestedTypes) {
-        // Add the nested type itself as a dependency
-        deps.push(nested.identifier);
-        // Add base dependency
         if (nested.base) {
             deps.push(nested.base);
         }
-        // Add field type dependencies
         for (const field of Object.values(nested.fields || {})) {
             if ("type" in field && field.type) {
                 deps.push(field.type);

package/dist/typeschema/core/transformer.d.ts

@@ -4,7 +4,7 @@
  * Core transformation logic for converting FHIRSchema to TypeSchema format
  */
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { Register } from "@typeschema/register";
-import type { RichFHIRSchema, TypeSchema, TypeSchemaField } from "@typeschema/types";
-export declare function transformElements(register: Register, fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement> | undefined): Promise<Record<string, TypeSchemaField> | undefined>;
+import { type Register } from "@typeschema/register";
+import type { Field, RichFHIRSchema, TypeSchema } from "@typeschema/types";
+export declare function mkFields(register: Register, fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement> | undefined): Promise<Record<string, Field> | undefined>;
 export declare function transformFHIRSchema(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -3,24 +3,26 @@
  *
  * Core transformation logic for converting FHIRSchema to TypeSchema format
  */
+import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
 import { transformProfile } from "../profile/processor";
 import { collectBindingSchemas } from "./binding";
-import { buildField, getElementHierarchy, isNestedElement, mergeElementHierarchy, mkNestedField, } from "./field-builder";
+import { buildField, isNestedElement, mkNestedField } from "./field-builder";
 import { mkIdentifier } from "./identifier";
-import { buildNestedTypes, extractNestedDependencies } from "./nested-types";
-export async function transformElements(register, fhirSchema, parentPath, elements) {
+import { extractNestedDependencies, mkNestedTypes } from "./nested-types";
+export async function mkFields(register, fhirSchema, parentPath, elements) {
     if (!elements)
         return undefined;
+    const geneology = register.resolveFsGenealogy(fhirSchema.url);
     const fields = {};
-    for (const [key, element] of Object.entries(elements)) {
+    for (const [key, _element] of Object.entries(elements)) {
         const path = [...parentPath, key];
-        const hierarchy = getElementHierarchy(fhirSchema, path, register);
-        const snapshot = hierarchy.length > 0 ? mergeElementHierarchy(hierarchy) : element;
-        if (isNestedElement(snapshot)) {
-            fields[key] = mkNestedField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
+        const elemGeneology = resolveFsElementGenealogy(geneology, path);
+        const elemSnapshot = fsElementSnapshot(elemGeneology);
+        if (isNestedElement(elemSnapshot)) {
+            fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
         }
         else {
-            fields[key] = buildField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
+            fields[key] = buildField(fhirSchema, path, elemSnapshot, register, fhirSchema.package_meta);
         }
     }
     return fields;
@@ -113,7 +115,7 @@ async function transformValueSet(fhirSchema, _register, _packageInfo) {
 /**
  * Transform an Extension FHIRSchema to TypeSchema with extension metadata
  */
-async function transformExtension(fhirSchema, register, packageInfo) {
+async function transformExtension(fhirSchema, register, _packageInfo) {
     try {
         const identifier = mkIdentifier(fhirSchema);
         // Build base identifier if present
@@ -156,14 +158,14 @@ async function transformExtension(fhirSchema, register, packageInfo) {
         }
         // Transform elements into fields if present
         if (fhirSchema.elements) {
-            const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+            const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
             if (fields && Object.keys(fields).length > 0) {
                 extensionSchema.fields = fields;
                 extensionSchema.dependencies.push(...extractFieldDependencies(fields));
             }
         }
         // Build nested types
-        const nestedTypes = await buildNestedTypes(fhirSchema, register, packageInfo);
+        const nestedTypes = await mkNestedTypes(register, fhirSchema);
         if (nestedTypes && nestedTypes.length > 0) {
             extensionSchema.nested = nestedTypes;
             extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -193,18 +195,29 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
             continue;
         uniqDeps[dep.url] = dep;
     }
-    const result = Object.values(uniqDeps).sort((a, b) => a.name.localeCompare(b.name));
+    const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
+    console.log(1, Object.values(uniqDeps));
+    console.log(2, localNestedTypeUrls);
+    const result = Object.values(uniqDeps)
+        .filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url)))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    console.log(3, result);
     return result.length > 0 ? result : undefined;
 }
 async function transformResource(register, fhirSchema) {
     const identifier = mkIdentifier(fhirSchema);
+    console.log(6, fhirSchema.name);
     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 = await transformElements(register, fhirSchema, [], fhirSchema.elements);
-    const nested = await buildNestedTypes(fhirSchema, register, fhirSchema.package_meta);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
+    console.log(0, fields);
+    const nested = await mkNestedTypes(register, fhirSchema);
     const dependencies = extractDependencies(identifier, base, fields, nested);
     const typeSchema = {
         identifier,
@@ -220,6 +233,7 @@ async function transformResource(register, fhirSchema) {
 export async function transformFHIRSchema(register, fhirSchema) {
     const results = [];
     const identifier = mkIdentifier(fhirSchema);
+    console.log(5, fhirSchema.name);
     // Handle profiles with specialized processor
     if (identifier.kind === "profile") {
         const profileSchema = await transformProfile(register, fhirSchema);

package/dist/typeschema/profile/processor.js

@@ -5,7 +5,7 @@
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
 import { mkIdentifier } from "../core/identifier";
-import { transformElements } from "../core/transformer";
+import { mkFields } from "../core/transformer";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
@@ -13,7 +13,7 @@ import { transformElements } from "../core/transformer";
 export async function transformProfile(register, fhirSchema) {
     // Build profile identifier
     const identifier = mkIdentifier(fhirSchema);
-    const packageInfo = fhirSchema.package_meta;
+    const _packageInfo = fhirSchema.package_meta;
     // Ensure this is recognized as a profile
     if (identifier.kind !== "profile") {
         throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -54,7 +54,7 @@ export async function transformProfile(register, fhirSchema) {
     }
     // Process profile fields from differential elements
     if (fhirSchema.elements) {
-        const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+        const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
         if (fields && Object.keys(fields).length > 0) {
             profileSchema.fields = fields;
         }
@@ -79,10 +79,12 @@ export async function transformProfile(register, fhirSchema) {
 /**
  * Determine the kind of the base type for a profile
  */
-async function determineBaseKind(baseUrl, manager) {
+async function determineBaseKind(baseUrl, register) {
     try {
         // Try to resolve the base schema
-        const baseSchema = await manager.resolve(baseUrl);
+        const baseSchema = register.resolveFs(baseUrl);
+        if (!baseSchema)
+            return "resource";
         if (baseSchema) {
             // If it's also a constraint, it's likely another profile
             if (baseSchema.derivation === "constraint") {

package/dist/typeschema/register.d.ts

@@ -7,7 +7,7 @@ export type Register = {
     ensureCanonicalUrl(name: Name | CanonicalUrl): CanonicalUrl;
     resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
     resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
-    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[] | undefined;
+    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
     allSd(): StructureDefinition[];
     allFs(): RichFHIRSchema[];
     allVs(): any[];

package/dist/typeschema/register.js

@@ -40,12 +40,14 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
     }
     const resolveFsGenealogy = (canonicalUrl) => {
         let fs = fhirSchemas[canonicalUrl];
-        if (!fs)
-            return undefined;
+        if (fs === undefined)
+            throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
         const genealogy = [fs];
-        while (fs && fs.base) {
-            fs = fhirSchemas[fs.base];
+        while (fs?.base) {
+            fs = fhirSchemas[fs.base] || fhirSchemas[nameDict[fs.base]];
             genealogy.push(fs);
+            if (fs === undefined)
+                throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
         }
         return genealogy;
     };
@@ -54,6 +56,7 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
         appendFs(fs) {
             const rfs = enrichFHIRSchema(fs);
             fhirSchemas[rfs.url] = rfs;
+            nameDict[rfs.name] = rfs.url;
         },
         resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
         resolveFsGenealogy: resolveFsGenealogy,
@@ -94,5 +97,8 @@ export const resolveFsElementGenealogy = (genealogy, path) => {
 };
 export function fsElementSnapshot(genealogy) {
     // FIXME: nested elements will break it
-    return genealogy.reverse().reduce((snapshot, elem) => ({ ...snapshot, ...elem }), {});
+    const snapshot = genealogy.reverse().reduce((snapshot, elem) => ({ ...snapshot, ...elem }), {});
+    // NOTE: to avoid regeneration nested types
+    snapshot.elements = undefined;
+    return snapshot;
 }

package/dist/typeschema/types.d.ts

@@ -62,13 +62,13 @@ interface TypeSchemaForPrimitiveType {
 export interface NestedType {
     identifier: NestedIdentifier;
     base: Identifier;
-    fields: Record<string, TypeSchemaField>;
+    fields: Record<string, Field>;
 }
 export interface TypeSchemaForProfile {
     identifier: ProfileIdentifier;
     base: Identifier;
     description?: string;
-    fields?: Record<string, TypeSchemaField>;
+    fields?: Record<string, Field>;
     constraints?: Record<string, ProfileConstraint>;
     extensions?: ProfileExtension[];
     validation?: ValidationRule[];
@@ -121,21 +121,14 @@ export interface ProfileMetadata {
     jurisdiction?: any[];
     package?: string;
 }
-export interface TypeSchemaNestedType {
-    identifier: NestedIdentifier;
-    base: Identifier;
-    fields?: {
-        [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
-    };
-}
 export interface TypeSchemaForResourceComplexTypeLogical {
     identifier: Identifier;
     base?: Identifier;
     description?: string;
     fields?: {
-        [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
+        [k: string]: Field;
     };
-    nested?: TypeSchemaNestedType[];
+    nested?: NestedType[];
     dependencies?: Identifier[];
 }
 export interface RegularField {
@@ -149,7 +142,7 @@ export interface RegularField {
     min?: number;
     max?: number;
 }
-export interface PolymorphicValueXFieldDeclaration {
+export interface PolymorphicDeclarationField {
     choices: string[];
     required?: boolean;
     excluded?: boolean;
@@ -157,7 +150,7 @@ export interface PolymorphicValueXFieldDeclaration {
     min?: number;
     max?: number;
 }
-export interface PolymorphicValueXFieldInstance {
+export interface PolymorphicInstanceField {
     choiceOf: string;
     type: Identifier;
     required?: boolean;
@@ -190,7 +183,7 @@ export interface TypeSchemaForBinding {
     valueset?: ValueSetIdentifier;
     dependencies?: Identifier[];
 }
-export type TypeSchemaField = RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
+export type Field = RegularField | PolymorphicDeclarationField | PolymorphicInstanceField;
 export interface TypeschemaGeneratorOptions {
     verbose?: boolean;
     logger?: import("../utils/codegen-logger").CodegenLogger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250930151649.b68ce8a",
+  "version": "0.0.1-canary.20251001124254.ddbda7d",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",