@atomic-ehr/codegen 0.0.1-canary.20251008121245.8324bc2 → 0.0.1-canary.20251009074815.3e20aa6

package/dist/index.js

@@ -1409,21 +1409,37 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
+var isNestedIdentifier = (id) => {
+  return id?.kind === "nested";
+};
+var isProfileIdentifier = (id) => {
+  return id?.kind === "profile";
+};
 var isFhirSchemaBased = (schema) => {
-  return schema.identifier.kind !== "value-set";
+  return schema?.identifier.kind !== "value-set";
 };
-var isSpecialization = (schema) => {
-  return schema.identifier.kind === "resource" || schema.identifier.kind === "complex-type" || schema.identifier.kind === "logical";
+var isSpecializationTypeSchema = (schema) => {
+  return schema?.identifier.kind === "resource" || schema?.identifier.kind === "complex-type" || schema?.identifier.kind === "logical";
 };
-var isProfile = (schema) => {
-  return schema.identifier.kind === "profile";
+var isComplexTypeTypeSchema = (schema) => {
+  return schema?.identifier.kind === "complex-type";
 };
-var isNotChoiceFieldDeclaration = (field) => {
-  return field.choices === void 0;
+var isResourceTypeSchema = (schema) => {
+  return schema?.identifier.kind === "resource";
+};
+var isLogicalTypeSchema = (schema) => {
+  return schema?.identifier.kind === "logical";
+};
+var isProfileTypeSchema = (schema) => {
+  return schema?.identifier.kind === "profile";
 };
 function isBindingSchema(schema) {
-  return schema.identifier.kind === "binding";
+  return schema?.identifier.kind === "binding";
 }
+var isNotChoiceDeclarationField = (field) => {
+  if (!field) return false;
+  return field.choices === void 0;
+};
 
 // src/typeschema/register.ts
 var registerFromManager = async (manager, logger) => {
@@ -1480,29 +1496,29 @@ var registerFromManager = async (manager, logger) => {
     );
   }
   const complexTypes = {};
-  for (const fs2 of Object.values(fsIndex)) {
-    if (fs2.kind === "complex-type") {
-      complexTypes[fs2.url] = fs2;
+  for (const fs3 of Object.values(fsIndex)) {
+    if (fs3.kind === "complex-type") {
+      complexTypes[fs3.url] = fs3;
     }
   }
   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}'`);
+    let fs3 = fsIndex[canonicalUrl];
+    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs3];
+    while (fs3?.base) {
+      fs3 = fsIndex[fs3.base] || fsIndex[nameToCanonical[fs3.base]];
+      genealogy.push(fs3);
+      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
     }
     return genealogy;
   };
   const resolveFsSpecializations = (canonicalUrl) => {
-    return resolveFsGenealogy(canonicalUrl).filter((fs2) => fs2.derivation === "specialization");
+    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
   };
   return {
     ...manager,
-    appendFs(fs2) {
-      const rfs = enrichFHIRSchema(fs2);
+    appendFs(fs3) {
+      const rfs = enrichFHIRSchema(fs3);
       fsIndex[rfs.url] = rfs;
       nameToCanonical[rfs.name] = rfs.url;
     },
@@ -1522,9 +1538,9 @@ var registerFromManager = async (manager, logger) => {
 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];
+  return genealogy.map((fs3) => {
+    if (!fs3.elements) return void 0;
+    let elem = fs3.elements?.[top];
     for (const k of rest) {
       elem = elem?.elements?.[k];
     }
@@ -1606,7 +1622,7 @@ function mkNestedIdentifier(register, fhirSchema, path, logger) {
   var nestedTypeOrigins = {};
   if (fhirSchema.derivation === "constraint") {
     const specializations = register.resolveFsSpecializations(fhirSchema.url);
-    const nestedTypeGenealogy = specializations.map((fs2) => mkNestedTypes(register, fs2, logger)).filter((e) => e !== void 0).flat();
+    const nestedTypeGenealogy = specializations.map((fs3) => mkNestedTypes(register, fs3, logger)).filter((e) => e !== void 0).flat();
     for (const nt of nestedTypeGenealogy.reverse()) {
       nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
@@ -1700,10 +1716,10 @@ function extractNestedDependencies(nestedTypes) {
 function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
-    if (parentPath.length === 0) return fs2.required || [];
-    if (!fs2.elements) return [];
-    let elem = fs2;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs3) => {
+    if (parentPath.length === 0) return fs3.required || [];
+    if (!fs3.elements) return [];
+    let elem = fs3;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1715,10 +1731,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((fs2) => {
-    if (parentPath.length === 0) return fs2.excluded || [];
-    if (!fs2.elements) return [];
-    let elem = fs2;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs3) => {
+    if (parentPath.length === 0) return fs3.excluded || [];
+    if (!fs3.elements) return [];
+    let elem = fs3;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1730,8 +1746,8 @@ var buildReferences = (element, register, _packageInfo) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureCanonicalUrl(ref);
-    const fs2 = register.resolveFs(curl);
-    return mkIdentifier(fs2);
+    const fs3 = register.resolveFs(curl);
+    return mkIdentifier(fs3);
   });
 };
 function buildFieldType(register, fhirSchema, element, logger) {
@@ -2063,7 +2079,11 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
     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));
+  const result = Object.values(uniqDeps).filter((e) => {
+    if (isProfileIdentifier(identifier)) return true;
+    if (!isNestedIdentifier(e)) return true;
+    return !localNestedTypeUrls.has(e.url);
+  }).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
 function transformFhirSchemaResource(register, fhirSchema, logger) {
@@ -2543,7 +2563,7 @@ var TypeSchemaGenerator = class {
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
     const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger)))).flat();
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs3) => await transformFhirSchema(register, fs3, logger)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -2923,6 +2943,143 @@ var generateTypeSchemas = async (register, logger) => {
   return fhirSchemas;
 };
 
+// src/typeschema/utils.ts
+var groupByPackages = (typeSchemas) => {
+  const grouped = {};
+  for (const ts of typeSchemas) {
+    const packageName = ts.identifier.package;
+    if (!grouped[packageName]) {
+      grouped[packageName] = [];
+    }
+    grouped[packageName].push(ts);
+  }
+  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
+    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  }
+  return grouped;
+};
+var resourceRelatives = (schemas) => {
+  const regularSchemas = schemas.filter(isResourceTypeSchema);
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
+    }
+  }
+  const allPairs = [...directPairs];
+  const findTransitiveRelatives = (parentRef) => {
+    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
+    const transitiveChildren = [];
+    for (const child of directChildren) {
+      transitiveChildren.push(...findTransitiveRelatives(child));
+    }
+    return [...directChildren, ...transitiveChildren];
+  };
+  for (const pair of directPairs) {
+    const transitiveChildren = findTransitiveRelatives(pair.child);
+    for (const transitiveChild of transitiveChildren) {
+      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+        allPairs.push({ parent: pair.parent, child: transitiveChild });
+      }
+    }
+  }
+  return allPairs;
+};
+var mkTypeSchemaIndex = (schemas) => {
+  const index = {};
+  const append = (schema) => {
+    const url = schema.identifier.url;
+    if (!index[url]) {
+      index[url] = {};
+    }
+    index[url][schema.identifier.package] = schema;
+  };
+  for (const schema of schemas) {
+    append(schema);
+  }
+  const relations = resourceRelatives(schemas);
+  const resolve2 = (id) => index[id.url]?.[id.package];
+  const resourceChildren = (id) => {
+    return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+  };
+  const hierarchy = (schema) => {
+    const res = [];
+    let cur = schema;
+    while (cur) {
+      res.push(cur);
+      const base = cur.base;
+      if (base === void 0) break;
+      const resolved = resolve2(base);
+      if (!resolved) {
+        throw new Error(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
+      }
+      cur = resolved;
+    }
+    return res;
+  };
+  const findLastSpecialization = (id) => {
+    const schema = resolve2(id);
+    if (!schema) return id;
+    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema) {
+      throw new Error(`No non-constraint schema found in hierarchy for ${id.name}`);
+    }
+    return nonConstraintSchema.identifier;
+  };
+  const flatProfile = (schema) => {
+    const hierarchySchemas = hierarchy(schema);
+    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
+    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema)
+      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+    const mergedFields = {};
+    for (const anySchema of constraintSchemas.slice().reverse()) {
+      const schema2 = anySchema;
+      if (!schema2.fields) continue;
+      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
+        if (mergedFields[fieldName]) {
+          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
+        } else {
+          mergedFields[fieldName] = { ...fieldConstraints };
+        }
+      }
+    }
+    const deps = {};
+    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
+      deps[e.url] = e;
+    }
+    const dependencies = Object.values(deps);
+    return {
+      ...schema,
+      base: nonConstraintSchema.identifier,
+      fields: mergedFields,
+      dependencies
+    };
+  };
+  const isWithMetaField = (profile) => {
+    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
+      console.log(schema.fields?.meta);
+      return schema.fields?.meta !== void 0;
+    });
+  };
+  return {
+    _schemaIndex: index,
+    _relations: relations,
+    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
+    collectResources: () => schemas.filter(isResourceTypeSchema),
+    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
+    collectProfiles: () => schemas.filter(isProfileTypeSchema),
+    resolve: resolve2,
+    resourceChildren,
+    hierarchy,
+    findLastSpecialization,
+    flatProfile,
+    isWithMetaField
+  };
+};
+
 // src/api/generators/base/error-handler.ts
 init_errors();
 var ErrorHandler = class {
@@ -5008,7 +5165,7 @@ var FileSystemWriter = class {
     if (!this.currentFileDescriptor) throw new Error("No file opened");
     fs.writeSync(this.currentFileDescriptor, str);
   }
-  generate(_schemas) {
+  generate(_tsIndex) {
     throw new Error("Not implemented");
   }
   writtenFiles() {
@@ -5030,6 +5187,7 @@ var Writer = class extends FileSystemWriter {
     if (tokens.length === 0) {
       this.write("\n");
     } else {
+      this.writeIndent();
       this.write(`${tokens.join(" ")}
 `);
     }
@@ -5068,6 +5226,11 @@ var Writer = class extends FileSystemWriter {
     this.disclaimer().forEach((e) => this.comment(e));
     this.line();
   }
+  indentBlock(gencontent) {
+    this.indent();
+    gencontent();
+    this.deindent();
+  }
   curlyBlock(tokens, gencontent, endTokens) {
     this.line(`${tokens.filter(Boolean).join(" ")} {`);
     this.indent();
@@ -5084,132 +5247,6 @@ var Writer = class extends FileSystemWriter {
   }
 };
 
-// src/typeschema/utils.ts
-var groupByPackages = (typeSchemas) => {
-  const grouped = {};
-  for (const ts of typeSchemas) {
-    const packageName = ts.identifier.package;
-    if (!grouped[packageName]) {
-      grouped[packageName] = [];
-    }
-    grouped[packageName].push(ts);
-  }
-  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
-    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-  }
-  return grouped;
-};
-var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
-var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
-var resourceRelatives = (schemas) => {
-  const regularSchemas = collectResources(schemas);
-  const directPairs = [];
-  for (const schema of regularSchemas) {
-    if (schema.base) {
-      directPairs.push({ parent: schema.base, child: schema.identifier });
-    }
-  }
-  const allPairs = [...directPairs];
-  const findTransitiveRelatives = (parentRef) => {
-    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
-    const transitiveChildren = [];
-    for (const child of directChildren) {
-      transitiveChildren.push(...findTransitiveRelatives(child));
-    }
-    return [...directChildren, ...transitiveChildren];
-  };
-  for (const pair of directPairs) {
-    const transitiveChildren = findTransitiveRelatives(pair.child);
-    for (const transitiveChild of transitiveChildren) {
-      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
-        allPairs.push({ parent: pair.parent, child: transitiveChild });
-      }
-    }
-  }
-  return allPairs;
-};
-var mkTypeSchemaIndex = (schemas) => {
-  const index = {};
-  const append = (schema) => {
-    const url = schema.identifier.url;
-    if (!index[url]) {
-      index[url] = {};
-    }
-    index[url][schema.identifier.package] = schema;
-  };
-  for (const schema of schemas) {
-    append(schema);
-  }
-  const relations = resourceRelatives(schemas);
-  const resolve2 = (id) => index[id.url]?.[id.package];
-  const resourceChildren = (id) => {
-    return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
-  };
-  const hierarchy = (schema) => {
-    const res = [];
-    let cur = schema;
-    while (cur) {
-      res.push(cur);
-      const base = cur.base;
-      if (base === void 0) break;
-      const resolved = resolve2(base);
-      if (!resolved) {
-        throw new Error(`Failed to resolve base type: ${JSON.stringify(base)}`);
-      }
-      cur = resolved;
-    }
-    return res;
-  };
-  const findLastSpecialization = (id) => {
-    const schema = resolve2(id);
-    if (!schema) return id;
-    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema) {
-      throw new Error(`No non-constraint schema found in hierarchy for ${id.name}`);
-    }
-    return nonConstraintSchema.identifier;
-  };
-  const flatProfile = (schema) => {
-    const hierarchySchemas = hierarchy(schema);
-    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
-    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema)
-      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
-    const mergedFields = {};
-    for (const anySchema of constraintSchemas.slice().reverse()) {
-      const schema2 = anySchema;
-      if (!schema2.fields) continue;
-      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
-        if (mergedFields[fieldName]) {
-          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
-        } else {
-          mergedFields[fieldName] = { ...fieldConstraints };
-        }
-      }
-    }
-    const deps = {};
-    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
-      deps[e.url] = e;
-    }
-    const dependencies = Object.values(deps);
-    return {
-      ...schema,
-      base: nonConstraintSchema.identifier,
-      fields: mergedFields,
-      dependencies
-    };
-  };
-  return {
-    schemaIndex: index,
-    relations,
-    resolve: resolve2,
-    resourceChildren,
-    hierarchy,
-    findLastSpecialization,
-    flatProfile
-  };
-};
-
 // src/api/writer-generator/typescript.ts
 var primitiveType2tsType = {
   boolean: "boolean",
@@ -5270,10 +5307,11 @@ var tsResourceName = (id) => {
 };
 var tsFieldName = (n) => normalizeTsName(n);
 var normalizeTsName = (n) => {
+  const tsKeywords = /* @__PURE__ */ new Set(["abstract", "any", "as", "async", "await", "boolean", "bigint", "break", "case", "catch", "class", "const", "constructor", "continue", "debugger", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "extern", "false", "finally", "for", "function", "from", "get", "goto", "if", "implements", "import", "in", "infer", "instanceof", "interface", "keyof", "let", "module", "namespace", "never", "new", "null", "number", "object", "of", "override", "private", "protected", "public", "readonly", "return", "satisfies", "set", "static", "string", "super", "switch", "this", "throw", "true", "try", "type", "typeof", "unknown", "var", "void", "while"]);
+  if (tsKeywords.has(n)) n = `${n}_`;
   return n.replace(/[- ]/g, "_");
 };
 var TypeScript = class extends Writer {
-  tsIndex = mkTypeSchemaIndex([]);
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
@@ -5295,19 +5333,30 @@ var TypeScript = class extends Writer {
   }
   generateDependenciesImports(schema) {
     if (schema.dependencies) {
-      const deps = [
-        ...schema.dependencies.filter((dep) => ["complex-type", "resource", "logical"].includes(dep.kind)).map((dep) => ({
-          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
-          name: uppercaseFirstLetter(dep.name)
-        })),
-        ...schema.dependencies.filter((dep) => ["nested"].includes(dep.kind)).map((dep) => ({
-          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
-          name: tsResourceName(dep)
-        }))
-      ].sort((a, b) => a.name.localeCompare(b.name));
-      for (const dep of deps) {
+      const imports = [];
+      const skipped = [];
+      for (const dep of schema.dependencies) {
+        if (["complex-type", "resource", "logical"].includes(dep.kind)) {
+          imports.push({
+            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+            name: uppercaseFirstLetter(dep.name)
+          });
+        } else if (isNestedIdentifier(dep)) {
+          imports.push({
+            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+            name: tsResourceName(dep)
+          });
+        } else {
+          skipped.push(dep);
+        }
+      }
+      imports.sort((a, b) => a.name.localeCompare(b.name));
+      for (const dep of imports) {
         this.tsImportType(dep.tsPackage, dep.name);
       }
+      for (const dep of skipped) {
+        this.debugComment("skip:", dep);
+      }
       this.line();
     }
   }
@@ -5328,7 +5377,7 @@ var TypeScript = class extends Writer {
       this.lineSM(`_${tsFieldName(fieldName)}?: Element`);
     }
   }
-  generateType(schema) {
+  generateType(tsIndex, schema) {
     var name;
     if (schema.identifier.name === "Reference") {
       name = "Reference<T extends string = string>";
@@ -5344,13 +5393,13 @@ var TypeScript = class extends Writer {
       if (!schema.fields) return;
       if (schema.identifier.kind === "resource") {
         const possibleResourceTypes = [schema.identifier];
-        possibleResourceTypes.push(...this.tsIndex.resourceChildren(schema.identifier));
+        possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
         this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `"${e.name}"`).join(" | ")}`);
         this.line();
       }
       const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
       for (const [fieldName, field] of fields) {
-        if (!isNotChoiceFieldDeclaration(field)) continue;
+        if (!isNotChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
         const optionalSymbol = field.required ? "" : "?";
@@ -5380,22 +5429,23 @@ var TypeScript = class extends Writer {
       }
     });
   }
-  generateNestedTypes(schema) {
+  generateNestedTypes(tsIndex, schema) {
     if (schema.nested) {
       for (const subtype of schema.nested) {
-        this.generateType(subtype);
+        this.generateType(tsIndex, subtype);
       }
     }
   }
-  generateProfileType(schema) {
+  generateProfileType(tsIndex, schema) {
     const name = tsResourceName(schema.identifier);
-    this.debugComment(schema.identifier);
+    this.debugComment("identifier", schema.identifier);
+    this.debugComment("base", schema.base);
     this.curlyBlock(["export", "interface", name], () => {
       this.lineSM(`__profileUrl: "${schema.identifier.url}"`);
       this.line();
       if (!isFhirSchemaBased(schema)) return;
       for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
-        if (!isNotChoiceFieldDeclaration(field)) continue;
+        if (!isNotChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, field);
         const tsName = tsFieldName(fieldName);
         let tsType;
@@ -5404,16 +5454,16 @@ var TypeScript = class extends Writer {
         } else if (field.enum) {
           tsType = field.enum.map((e) => `'${e}'`).join(" | ");
         } else if (field.reference && field.reference.length > 0) {
-          const specializationId = this.tsIndex.findLastSpecialization(schema.identifier);
-          const specialization = this.tsIndex.resolve(specializationId);
-          if (specialization === void 0 || !isSpecialization(specialization))
+          const specializationId = tsIndex.findLastSpecialization(schema.identifier);
+          const specialization = tsIndex.resolve(specializationId);
+          if (!isSpecializationTypeSchema(specialization))
             throw new Error(`Invalid specialization for ${schema.identifier}`);
           const sField = specialization.fields?.[fieldName];
-          if (sField === void 0 || !isNotChoiceFieldDeclaration(sField))
+          if (sField === void 0 || !isNotChoiceDeclarationField(sField))
             throw new Error(`Invalid field declaration for ${fieldName}`);
           const sRefs = (sField.reference ?? []).map((e) => e.name);
           const references = field.reference.map((ref) => {
-            const resRef = this.tsIndex.findLastSpecialization(ref);
+            const resRef = tsIndex.findLastSpecialization(ref);
             if (resRef.name !== ref.name) {
               return `"${resRef.name}" /*${ref.name}*/`;
             }
@@ -5432,39 +5482,135 @@ var TypeScript = class extends Writer {
     });
     this.line();
   }
-  generateResourceModule(schema) {
+  generateAttachProfile(flatProfile) {
+    const tsBaseResourceName = tsResourceName(flatProfile.base);
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
+      return field && isNotChoiceDeclarationField(field) && field.type !== void 0;
+    }).map(([fieldName]) => tsFieldName(fieldName));
+    this.curlyBlock(
+      [
+        `export const attach_${tsProfileName} =`,
+        `(resource: ${tsBaseResourceName}, profile: ${tsProfileName}): ${tsBaseResourceName}`,
+        "=>"
+      ],
+      () => {
+        this.curlyBlock(["return"], () => {
+          this.line("...resource,");
+          this.curlyBlock(["meta:"], () => {
+            this.line(`profile: ['${flatProfile.identifier.url}']`);
+          }, [","]);
+          profileFields.forEach((fieldName) => {
+            this.line(`${fieldName}:`, `profile.${fieldName},`);
+          });
+        });
+      }
+    );
+    this.line();
+  }
+  generateExtractProfile(tsIndex, flatProfile) {
+    const tsBaseResourceName = tsResourceName(flatProfile.base);
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
+      return isNotChoiceDeclarationField(field) && field.type !== void 0;
+    }).map(([fieldName]) => fieldName);
+    const specialization = tsIndex.resolve(tsIndex.findLastSpecialization(flatProfile.identifier));
+    if (!isSpecializationTypeSchema(specialization))
+      throw new Error(`Specialization not found for ${flatProfile.identifier.url}`);
+    const shouldCast = {};
+    this.curlyBlock(
+      [
+        `export const extract_${tsBaseResourceName} =`,
+        `(resource: ${tsBaseResourceName}): ${tsProfileName}`,
+        "=>"
+      ],
+      () => {
+        profileFields.forEach((fieldName) => {
+          const tsField = tsFieldName(fieldName);
+          const pField = flatProfile.fields?.[fieldName];
+          const rField = specialization.fields?.[fieldName];
+          if (!isNotChoiceDeclarationField(pField) || !isNotChoiceDeclarationField(rField)) return;
+          if (pField.required && !rField.required) {
+            this.curlyBlock(
+              [`if (resource.${tsField} === undefined)`],
+              () => this.lineSM(
+                `throw new Error("'${tsField}' is required for ${flatProfile.identifier.url}")`
+              )
+            );
+          }
+          const pRefs = pField?.reference?.map((ref) => ref.name);
+          const rRefs = rField?.reference?.map((ref) => ref.name);
+          if (pRefs && rRefs && pRefs.length !== rRefs.length) {
+            const predName = `reference_pred_${tsField}`;
+            this.curlyBlock(["const", predName, "=", "(ref?: Reference)", "=>"], () => {
+              this.line("return !ref");
+              this.indentBlock(() => {
+                rRefs.forEach((ref) => {
+                  this.line(`|| ref.reference?.startsWith('${ref}/')`);
+                });
+                this.line(";");
+              });
+            });
+            let cond = !pField?.required ? `!resource.${tsField} || ` : "";
+            if (pField.array) {
+              cond += `resource.${tsField}.every( (ref) => ${predName}(ref) )`;
+            } else {
+              cond += `${predName}(resource.${tsField})`;
+            }
+            this.curlyBlock(["if (", cond, ")"], () => {
+              this.lineSM(
+                `throw new Error("'${fieldName}' has different references in profile and specialization")`
+              );
+            });
+            this.line();
+            shouldCast[fieldName] = true;
+          }
+        });
+        this.curlyBlock(["return"], () => {
+          this.line(`__profileUrl: '${flatProfile.identifier.url}',`);
+          profileFields.forEach((fieldName) => {
+            const tsField = tsFieldName(fieldName);
+            if (shouldCast[fieldName]) {
+              this.line(`${tsField}:`, `resource.${tsField} as ${tsProfileName}['${tsField}'],`);
+            } else {
+              this.line(`${tsField}:`, `resource.${tsField},`);
+            }
+          });
+        });
+      }
+    );
+  }
+  generateResourceModule(tsIndex, schema) {
     this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
       this.generateDisclaimer();
-      if (["complex-type", "resource", "logical", "nested"].includes(schema.identifier.kind)) {
+      if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
         this.generateDependenciesImports(schema);
         this.generateComplexTypeReexports(schema);
-        this.generateNestedTypes(schema);
-        this.generateType(schema);
-      } else if (isProfile(schema)) {
-        const flatProfile = this.tsIndex.flatProfile(schema);
-        this.debugComment(flatProfile.dependencies);
+        this.generateNestedTypes(tsIndex, schema);
+        this.generateType(tsIndex, schema);
+      } else if (isProfileTypeSchema(schema)) {
+        const flatProfile = tsIndex.flatProfile(schema);
         this.generateDependenciesImports(flatProfile);
-        this.generateProfileType(flatProfile);
-      } else {
-        throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
-      }
+        this.generateProfileType(tsIndex, flatProfile);
+        this.generateAttachProfile(flatProfile);
+        this.generateExtractProfile(tsIndex, flatProfile);
+      } else throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
     });
   }
-  generate(schemas) {
+  generate(tsIndex) {
     const typesToGenerate = [
-      ...collectComplexTypes(schemas),
-      ...collectResources(schemas)
-      // ...collectLogicalModels(schemas),
-      // ...collectProfiles(schemas),
+      ...tsIndex.collectComplexTypes(),
+      ...tsIndex.collectResources(),
+      // ...tsIndex.collectLogicalModels(),
+      ...tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p))
     ];
-    this.tsIndex = mkTypeSchemaIndex(typesToGenerate);
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const tsPackageDir = tsFhirPackageDir(packageName);
         this.cd(tsPackageDir, () => {
           for (const schema of packageSchemas) {
-            this.generateResourceModule(schema);
+            this.generateResourceModule(tsIndex, schema);
           }
           this.generateFhirPackageIndexFile(packageSchemas);
         });
@@ -5489,7 +5635,8 @@ var writerToGenerator = (writerGen) => {
   };
   return {
     generate: async (schemas) => {
-      writerGen.generate(schemas);
+      const tsIndex = mkTypeSchemaIndex(schemas);
+      writerGen.generate(tsIndex);
       return getGeneratedFiles();
     },
     setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
@@ -5513,6 +5660,7 @@ var APIBuilder = class {
       verbose: options.verbose ?? false,
       overwrite: options.overwrite ?? true,
       cache: options.cache ?? true,
+      cleanOutput: options.cleanOutput ?? true,
       typeSchemaConfig: options.typeSchemaConfig,
       manager: options.manager || null,
       throwException: options.throwException || false
@@ -5614,6 +5762,10 @@ var APIBuilder = class {
     this.options.throwException = enabled;
     return this;
   }
+  cleanOutput(enabled = true) {
+    this.options.cleanOutput = enabled;
+    return this;
+  }
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -5625,6 +5777,17 @@ var APIBuilder = class {
       duration: 0
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
+    if (this.options.cleanOutput) {
+      this.logger.info(`Cleaning output directory: ${this.options.outputDir}`);
+      try {
+        fs.rmSync(this.options.outputDir, { recursive: true, force: true });
+        fs.mkdirSync(this.options.outputDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn(
+          `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
     try {
       this.logger.info("Initialize Canonical Manager");
       const manager = CanonicalManager({
@@ -5726,6 +5889,7 @@ function createAPIFromConfig(config) {
     verbose: config.verbose,
     overwrite: config.overwrite,
     cache: config.cache,
+    cleanOutput: config.cleanOutput,
     typeSchemaConfig: config.typeSchema
   });
   if (config.packages && config.packages.length > 0) {
@@ -5759,6 +5923,7 @@ var DEFAULT_CONFIG = {
   overwrite: true,
   validate: true,
   cache: true,
+  cleanOutput: true,
   typescript: {
     moduleFormat: "esm",
     generateIndex: true,