@atomic-ehr/codegen 0.0.1-canary.20251007145120.703d8ab → 0.0.1-canary.20251008092936.b434b77

package/dist/index.js

@@ -1414,7 +1414,7 @@ function isBindingSchema(schema) {
 }
 
 // src/typeschema/register.ts
-var registerFromManager = async (manager, logger2) => {
+var registerFromManager = async (manager, logger) => {
   const packages = await manager.packages();
   const flatRawIndex = {};
   const indexByPackages = [];
@@ -1450,7 +1450,7 @@ var registerFromManager = async (manager, logger2) => {
           nameToCanonical[rfs.name] = rfs.url;
           fsSuccess++;
         } catch (error) {
-          logger2?.warn(
+          logger?.warn(
             `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
           );
           fsFailed++;
@@ -1463,7 +1463,7 @@ var registerFromManager = async (manager, logger2) => {
         vsIndex[resource.url] = resource;
       }
     }
-    logger2?.success(
+    logger?.success(
       `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
   }
@@ -1484,6 +1484,9 @@ var registerFromManager = async (manager, logger2) => {
     }
     return genealogy;
   };
+  const resolveFsSpecializations = (canonicalUrl) => {
+    return resolveFsGenealogy(canonicalUrl).filter((fs2) => fs2.derivation === "specialization");
+  };
   return {
     ...manager,
     appendFs(fs2) {
@@ -1493,6 +1496,7 @@ var registerFromManager = async (manager, logger2) => {
     },
     resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
     resolveFsGenealogy,
+    resolveFsSpecializations,
     ensureCanonicalUrl: (name) => nameToCanonical[name] || name,
     allSd: () => Object.values(sdIndex),
     resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
@@ -1546,16 +1550,6 @@ function mkIdentifier(fhirSchema) {
     url: fhirSchema.url
   };
 }
-function mkNestedIdentifier(fhirSchema, path) {
-  const nestedName = path.join(".");
-  return {
-    kind: "nested",
-    package: fhirSchema.package_meta.name,
-    version: fhirSchema.package_meta.version,
-    name: nestedName,
-    url: `${fhirSchema.url}#${nestedName}`
-  };
-}
 var getValueSetName = (url) => {
   const urlParts = url.split("/");
   const lastSegment = urlParts[urlParts.length - 1];
@@ -1595,172 +1589,99 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
   };
 }
 
-// src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema, logger2) {
-  const identifier = mkIdentifier(fhirSchema);
-  if (identifier.kind !== "profile") {
-    throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
-  }
-  let base;
-  if (fhirSchema.base) {
-    const baseUrl = fhirSchema.base.includes("/") ? fhirSchema.base : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
-    const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
-    const baseKind = await determineBaseKind(baseUrl, register);
-    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",
-      name: baseName,
-      url: baseUrl
-    };
-  }
-  const profileSchema = {
-    identifier,
-    base,
-    dependencies: base ? [base] : []
-  };
-  if (fhirSchema.description) {
-    profileSchema.description = fhirSchema.description;
-  }
-  const metadata = extractProfileMetadata(fhirSchema);
-  if (Object.keys(metadata).length > 0) {
-    profileSchema.metadata = metadata;
-  }
-  if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
-    if (fields && Object.keys(fields).length > 0) {
-      profileSchema.fields = fields;
+// src/typeschema/core/nested-types.ts
+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();
+    for (const nt of nestedTypeGenealogy.reverse()) {
+      nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
   }
-  const constraints = await processProfileConstraints(fhirSchema);
-  if (Object.keys(constraints).length > 0) {
-    profileSchema.constraints = constraints;
-  }
-  const extensions = await processProfileExtensions(fhirSchema);
-  if (extensions.length > 0) {
-    profileSchema.extensions = extensions;
-  }
-  const validationRules = extractValidationRules(fhirSchema);
-  if (validationRules.length > 0) {
-    profileSchema.validation = validationRules;
-  }
-  return profileSchema;
+  const nestedName = path.join(".");
+  const url = nestedTypeOrigins[nestedName] ?? `${fhirSchema.url}#${nestedName}`;
+  return {
+    kind: "nested",
+    package: fhirSchema.package_meta.name,
+    version: fhirSchema.package_meta.version,
+    name: nestedName,
+    url
+  };
 }
-async function determineBaseKind(baseUrl, register) {
-  try {
-    const baseSchema = register.resolveFs(baseUrl);
-    if (!baseSchema) return "resource";
-    if (baseSchema) {
-      if (baseSchema.derivation === "constraint") {
-        return "profile";
-      }
-      if (baseSchema.kind === "resource") return "resource";
-      if (baseSchema.kind === "complex-type") return "complex-type";
+function collectNestedElements(fhirSchema, parentPath, elements) {
+  const nested = [];
+  for (const [key, element] of Object.entries(elements)) {
+    const path = [...parentPath, key];
+    if (isNestedElement(element)) {
+      nested.push([path, element]);
+    }
+    if (element.elements) {
+      nested.push(...collectNestedElements(fhirSchema, path, element.elements));
     }
-  } catch (error) {
-    console.warn(`Could not resolve base schema ${baseUrl}:`, error);
-  }
-  if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
-    return "profile";
   }
-  return "resource";
-}
-function extractProfileMetadata(fhirSchema) {
-  const metadata = {};
-  const packageInfo = fhirSchema.package_meta;
-  if (fhirSchema.publisher) metadata.publisher = fhirSchema.publisher;
-  if (fhirSchema.contact) metadata.contact = fhirSchema.contact;
-  if (fhirSchema.copyright) metadata.copyright = fhirSchema.copyright;
-  if (fhirSchema.purpose) metadata.purpose = fhirSchema.purpose;
-  if (fhirSchema.experimental !== void 0) {
-    metadata.experimental = fhirSchema.experimental;
-  }
-  if (fhirSchema.date) metadata.date = fhirSchema.date;
-  if (fhirSchema.jurisdiction) metadata.jurisdiction = fhirSchema.jurisdiction;
-  if (packageInfo?.name) {
-    metadata.package = packageInfo.name;
-  } else if (fhirSchema.package_meta.name) {
-    metadata.package = fhirSchema.package_meta.name;
-  }
-  return metadata;
+  return nested;
 }
-async function processProfileConstraints(fhirSchema, _manager) {
-  const constraints = {};
-  if (!fhirSchema.elements) return constraints;
-  for (const [path, element] of Object.entries(fhirSchema.elements)) {
-    const elementConstraints = {};
-    if (element.min !== void 0) elementConstraints.min = element.min;
-    if (element.max !== void 0) elementConstraints.max = String(element.max);
-    if (element.mustSupport) elementConstraints.mustSupport = true;
-    if (element.fixedValue !== void 0)
-      elementConstraints.fixedValue = element.fixedValue;
-    if (element.patternValue !== void 0)
-      elementConstraints.patternValue = element.patternValue;
-    if (element.binding) {
-      elementConstraints.binding = {
-        strength: element.binding.strength,
-        valueSet: element.binding.valueSet ?? ""
-      };
-    }
-    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) typeConstraint.profile = t.profile;
-        if (t.targetProfile) typeConstraint.targetProfile = t.targetProfile;
-        return typeConstraint;
-      });
-    }
-    if (element.slicing) {
-      elementConstraints.slicing = {
-        discriminator: element.slicing.discriminator ?? [],
-        rules: String(element.slicing),
-        ordered: element.slicing.ordered
-      };
-    }
-    if (Object.keys(elementConstraints).length > 0) {
-      constraints[path] = elementConstraints;
+function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
+  const fields = {};
+  for (const [key, element] of Object.entries(elements)) {
+    const path = [...parentPath, key];
+    if (isNestedElement(element)) {
+      fields[key] = mkNestedField(register, fhirSchema, path, element, logger);
+    } else {
+      fields[key] = mkField(register, fhirSchema, path, element, logger);
     }
   }
-  return constraints;
+  return fields;
 }
-async function processProfileExtensions(fhirSchema, _manager) {
-  const extensions = [];
-  if (!fhirSchema.elements) return extensions;
-  for (const [path, element] of Object.entries(fhirSchema.elements)) {
-    if (path.includes("extension") && element.type && Array.isArray(element.type)) {
-      for (const type of element.type) {
-        if (type.code === "Extension" && type.profile) {
-          extensions.push({
-            path,
-            profile: type.profile,
-            min: element.min,
-            max: String(element.max),
-            mustSupport: element.mustSupport
-          });
-        }
-      }
+function mkNestedTypes(register, fhirSchema, logger) {
+  if (!fhirSchema.elements) return void 0;
+  const nested = collectNestedElements(fhirSchema, [], fhirSchema.elements).filter(
+    ([_, element]) => element.elements && Object.keys(element.elements).length > 0
+  );
+  const nestedTypes = [];
+  for (const [path, element] of nested) {
+    const identifier = mkNestedIdentifier(register, fhirSchema, path, logger);
+    let baseName;
+    if (element.type === "BackboneElement" || !element.type) {
+      baseName = "BackboneElement";
+    } else {
+      baseName = element.type;
     }
+    const base = {
+      kind: "complex-type",
+      package: fhirSchema.package_meta.name,
+      version: fhirSchema.package_meta.version,
+      name: baseName,
+      url: register.ensureCanonicalUrl(baseName)
+    };
+    const fields = transformNestedElements(register, fhirSchema, path, element.elements, logger);
+    const nestedType = {
+      identifier,
+      base,
+      fields
+    };
+    nestedTypes.push(nestedType);
   }
-  return extensions;
+  nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
+  return nestedTypes.length === 0 ? void 0 : nestedTypes;
 }
-function extractValidationRules(fhirSchema) {
-  const rules = [];
-  if (!fhirSchema.elements) return rules;
-  for (const [path, element] of Object.entries(fhirSchema.elements)) {
-    if (element.constraint && Array.isArray(element.constraint)) {
-      for (const constraint of element.constraint) {
-        rules.push({
-          path,
-          key: constraint.key,
-          severity: constraint.severity,
-          human: constraint.human,
-          expression: constraint.expression
-        });
+function extractNestedDependencies(nestedTypes) {
+  const deps = [];
+  for (const nested of nestedTypes) {
+    if (nested.base) {
+      deps.push(nested.base);
+    }
+    for (const field of Object.values(nested.fields || {})) {
+      if ("type" in field && field.type) {
+        deps.push(field.type);
+      }
+      if ("binding" in field && field.binding) {
+        deps.push(field.binding);
       }
     }
   }
-  return rules;
+  return deps;
 }
 
 // src/typeschema/core/field-builder.ts
@@ -1801,11 +1722,11 @@ var buildReferences = (element, register, _packageInfo) => {
     return mkIdentifier(fs2);
   });
 };
-function buildFieldType(register, fhirSchema, element) {
+function buildFieldType(register, fhirSchema, element, logger) {
   if (element.elementReference) {
     const refPath = element.elementReference.filter((_, i) => i % 2 === 1).map((p) => p).filter((p) => p !== "elements");
     if (refPath.length > 0) {
-      return mkNestedIdentifier(fhirSchema, refPath);
+      return mkNestedIdentifier(register, fhirSchema, refPath, logger);
     }
   }
   if (element.type) {
@@ -1825,17 +1746,17 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element, logger2) => {
+var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element, logger2);
+      enumValues = buildEnum(register, element, logger);
     }
   }
   return {
-    type: buildFieldType(register, fhirSchema, element),
+    type: buildFieldType(register, fhirSchema, element, logger),
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
     reference: buildReferences(element, register, fhirSchema.package_meta),
@@ -1854,9 +1775,9 @@ function isNestedElement(element) {
   const elementsWithoutType = element.type === void 0 && element.choiceOf === void 0 && element.elements !== void 0 && Object.keys(element.elements).length > 0;
   return isBackbone || isElement || elementsWithoutType;
 }
-function mkNestedField(register, fhirSchema, path, element) {
+function mkNestedField(register, fhirSchema, path, element, logger) {
   return {
-    type: mkNestedIdentifier(fhirSchema, path),
+    type: mkNestedIdentifier(register, fhirSchema, path, logger),
     array: element.array || false,
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path)
@@ -1864,7 +1785,7 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl, logger2) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
@@ -1909,7 +1830,7 @@ function extractValueSetConcepts(register, valueSet, _logger) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element, logger2) {
+function buildEnum(register, element, logger) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -1920,24 +1841,24 @@ function buildEnum(register, element, logger2) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    logger2?.dry_warn(
+    logger?.dry_warn(
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element, logger2) {
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-  const fieldType = buildFieldType(register, fhirSchema, element);
+  const fieldType = buildFieldType(register, fhirSchema, element, logger);
   const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
   const dependencies = [];
   if (fieldType) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element, logger2);
+  const enumValues = buildEnum(register, element, logger);
   return {
     identifier,
     type: fieldType,
@@ -1947,7 +1868,7 @@ function generateBindingSchema(register, fhirSchema, path, element, logger2) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema, logger2) {
+function collectBindingSchemas(register, fhirSchema, logger) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -1958,7 +1879,7 @@ function collectBindingSchemas(register, fhirSchema, logger2) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element, logger2);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
         if (binding) {
           bindings.push(binding);
         }
@@ -1981,90 +1902,8 @@ function collectBindingSchemas(register, fhirSchema, logger2) {
   return uniqueBindings;
 }
 
-// src/typeschema/core/nested-types.ts
-function collectNestedElements(fhirSchema, parentPath, elements) {
-  const nested = [];
-  for (const [key, element] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    if (isNestedElement(element)) {
-      nested.push([path, element]);
-    }
-    if (element.elements) {
-      nested.push(...collectNestedElements(fhirSchema, path, element.elements));
-    }
-  }
-  return nested;
-}
-function transformNestedElements(fhirSchema, parentPath, elements, register, logger2) {
-  const fields = {};
-  for (const [key, element] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    if (isNestedElement(element)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, element);
-    } else {
-      fields[key] = mkField(register, fhirSchema, path, element, logger2);
-    }
-  }
-  return fields;
-}
-function mkNestedTypes(register, fhirSchema, logger2) {
-  if (!fhirSchema.elements) return void 0;
-  const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
-  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);
-    let base;
-    if (element.type === "BackboneElement" || !element.type) {
-      base = {
-        kind: "complex-type",
-        package: fhirSchema.package_meta.name,
-        version: fhirSchema.package_meta.version,
-        name: "BackboneElement",
-        url: "http://hl7.org/fhir/StructureDefinition/BackboneElement"
-      };
-    } else {
-      base = {
-        kind: "complex-type",
-        package: fhirSchema.package_meta.name,
-        version: fhirSchema.package_meta.version,
-        name: element.type,
-        url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
-      };
-    }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger2);
-    const nestedType = {
-      identifier,
-      base,
-      fields
-    };
-    nestedTypes.push(nestedType);
-  }
-  nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
-  return nestedTypes.length === 0 ? void 0 : nestedTypes;
-}
-function extractNestedDependencies(nestedTypes) {
-  const deps = [];
-  for (const nested of nestedTypes) {
-    if (nested.base) {
-      deps.push(nested.base);
-    }
-    for (const field of Object.values(nested.fields || {})) {
-      if ("type" in field && field.type) {
-        deps.push(field.type);
-      }
-      if ("binding" in field && field.binding) {
-        deps.push(field.binding);
-      }
-    }
-  }
-  return deps;
-}
-
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements, logger2) {
+function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2087,9 +1926,9 @@ function mkFields(register, fhirSchema, parentPath, elements, logger2) {
   const fields = {};
   for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
     if (isNestedElement(elemSnapshot)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
+      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger2);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -2134,7 +1973,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet, logger2) {
+async function transformValueSet(register, valueSet, logger) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2145,7 +1984,7 @@ async function transformValueSet(register, valueSet, logger2) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, logger2) {
+async function transformExtension(fhirSchema, register, logger) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2182,13 +2021,13 @@ async function transformExtension(fhirSchema, register, logger2) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema, logger2);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2215,7 +2054,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
   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, logger2) {
+function transformFhirSchemaResource(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
@@ -2225,8 +2064,8 @@ function transformFhirSchemaResource(register, fhirSchema, logger2) {
     }
     base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
-  const nested = mkNestedTypes(register, fhirSchema, logger2);
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const nested = mkNestedTypes(register, fhirSchema, logger);
   const dependencies = extractDependencies(identifier, base, fields, nested);
   const typeSchema = {
     identifier,
@@ -2236,27 +2075,20 @@ function transformFhirSchemaResource(register, fhirSchema, logger2) {
     description: fhirSchema.description,
     dependencies
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
   return [typeSchema, ...bindingSchemas];
 }
-async function transformFhirSchema(register, fhirSchema, logger2) {
+async function transformFhirSchema(register, fhirSchema, logger) {
   const results = [];
-  const identifier = mkIdentifier(fhirSchema);
-  if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema, logger2);
-    results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
-    results.push(...bindingSchemas);
-    return results;
-  }
+  mkIdentifier(fhirSchema);
   if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, logger2);
+    const extensionSchema = await transformExtension(fhirSchema, register, logger);
     if (extensionSchema) {
       results.push(extensionSchema);
     }
     return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema, logger2);
+  return transformFhirSchemaResource(register, fhirSchema, logger);
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2476,224 +2308,6 @@ var TypeSchemaCache = class {
     }
   }
 };
-
-// src/logger.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
-  return LogLevel2;
-})(LogLevel || {});
-var ConsoleOutput = class {
-  constructor(useStderr = false) {
-    this.useStderr = useStderr;
-  }
-  write(entry, formatted) {
-    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
-    output(formatted);
-  }
-};
-var Logger = class _Logger {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      level: 1 /* INFO */,
-      format: "pretty",
-      includeTimestamp: true,
-      includeContext: true,
-      colorize: true,
-      outputs: [new ConsoleOutput()],
-      ...config
-    };
-  }
-  /**
-   * Update logger configuration
-   */
-  configure(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * Check if a log level should be output
-   */
-  shouldLog(level) {
-    return level >= this.config.level;
-  }
-  /**
-   * Create a log entry
-   */
-  createEntry(level, message, context, error, operation) {
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      levelName: LogLevel[level],
-      message,
-      component: this.config.component
-    };
-    if (context && this.config.includeContext) {
-      entry.context = context;
-    }
-    if (operation) {
-      entry.operation = operation;
-    }
-    if (error) {
-      entry.error = {
-        name: error.name,
-        message: error.message,
-        stack: error.stack
-      };
-    }
-    return entry;
-  }
-  /**
-   * Format log entry for output
-   */
-  formatEntry(entry) {
-    switch (this.config.format) {
-      case "json":
-        return JSON.stringify(entry);
-      case "compact":
-        return this.formatCompact(entry);
-      default:
-        return this.formatPretty(entry);
-    }
-  }
-  /**
-   * Format entry in compact format
-   */
-  formatCompact(entry) {
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName, entry.level);
-    return `${timestamp}${level} ${component}${operation}${entry.message}`;
-  }
-  /**
-   * Format entry in pretty format
-   */
-  formatPretty(entry) {
-    let formatted = "";
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
-    formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
-    if (entry.context && Object.keys(entry.context).length > 0) {
-      formatted += `
-  Context: ${JSON.stringify(entry.context, null, 2).split("\n").join("\n  ")}`;
-    }
-    if (entry.error) {
-      formatted += `
-  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
-      if (entry.error.context && Object.keys(entry.error.context).length > 0) {
-        formatted += `
-  Error Context: ${JSON.stringify(entry.error.context, null, 2).split("\n").join("\n  ")}`;
-      }
-      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
-        formatted += `
-  Suggestions:
-${entry.error.suggestions.map((s) => `    \u2022 ${s}`).join("\n")}`;
-      }
-      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
-        formatted += `
-  Stack: ${entry.error.stack.split("\n").join("\n  ")}`;
-      }
-    }
-    return formatted;
-  }
-  /**
-   * Colorize log level if enabled
-   */
-  colorizeLevel(levelName, level) {
-    if (!this.config.colorize) {
-      return levelName;
-    }
-    const colors = {
-      [0 /* DEBUG */]: "\x1B[36m",
-      // Cyan
-      [1 /* INFO */]: "\x1B[32m",
-      // Green
-      [2 /* WARN */]: "\x1B[33m",
-      // Yellow
-      [3 /* ERROR */]: "\x1B[31m"
-      // Red
-    };
-    const reset = "\x1B[0m";
-    const color = colors[level] || "";
-    return `${color}${levelName}${reset}`;
-  }
-  /**
-   * Write log entry to all outputs
-   */
-  async writeEntry(entry) {
-    if (!this.shouldLog(entry.level)) {
-      return;
-    }
-    const formatted = this.formatEntry(entry);
-    for (const output of this.config.outputs) {
-      try {
-        await output.write(entry, formatted);
-      } catch (error) {
-        console.error("Logger output failed:", error);
-        console.error(formatted);
-      }
-    }
-  }
-  /**
-   * Log debug message
-   */
-  async debug(message, context, operation) {
-    const entry = this.createEntry(0 /* DEBUG */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log info message
-   */
-  async info(message, context, operation) {
-    const entry = this.createEntry(1 /* INFO */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log warning message
-   */
-  async warn(message, context, operation) {
-    const entry = this.createEntry(2 /* WARN */, message, context, void 0, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Log error message
-   */
-  async error(message, error, context, operation) {
-    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
-    await this.writeEntry(entry);
-  }
-  /**
-   * Create a child logger with additional context
-   */
-  child(component, context) {
-    const childLogger = new _Logger({
-      ...this.config,
-      component: this.config.component ? `${this.config.component}.${component}` : component
-    });
-    if (context) {
-      const originalMethods = {
-        debug: childLogger.debug.bind(childLogger),
-        info: childLogger.info.bind(childLogger),
-        warn: childLogger.warn.bind(childLogger),
-        error: childLogger.error.bind(childLogger)
-      };
-      childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
-      childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
-      childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
-      childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
-    }
-    return childLogger;
-  }
-};
-new Logger();
-
-// src/utils/codegen-logger.ts
 var CodegenLogger = class _CodegenLogger {
   options;
   dryWarnSet = /* @__PURE__ */ new Set();
@@ -2869,11 +2483,11 @@ var TypeSchemaGenerator = class {
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets, logger2) {
+  async generateValueSetSchemas(valueSets, logger) {
     if (valueSets.length > 0) {
       this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager, logger2);
+    const register = await registerFromManager(this.manager, logger);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -2881,7 +2495,7 @@ var TypeSchemaGenerator = class {
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(register, vs, logger2);
+          const valueSetSchema = await transformValueSet(register, vs, logger);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
@@ -2900,7 +2514,7 @@ var TypeSchemaGenerator = class {
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion, logger2) {
+  async generateFromPackage(packageName, packageVersion, logger) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
@@ -2916,8 +2530,8 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger2);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger2)))).flat();
+    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 allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -3286,10 +2900,10 @@ var TypeSchemaParser = class {
 };
 
 // src/typeschema/index.ts
-var generateTypeSchemas = async (register, logger2) => {
+var generateTypeSchemas = async (register, logger) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger2));
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
   }
   for (const vsSchema of register.allVs()) {
     fhirSchemas.push(await transformValueSet(register, vsSchema));
@@ -5401,9 +5015,12 @@ var Writer = class extends FileSystemWriter {
     this.write(" ".repeat(this.currentIndent));
   }
   line(...tokens) {
-    this.writeIndent();
-    this.write(`${tokens.join(" ")}
+    if (tokens.length === 0) {
+      this.write("\n");
+    } else {
+      this.write(`${tokens.join(" ")}
 `);
+    }
   }
   lineSM(...tokens) {
     this.writeIndent();
@@ -5572,7 +5189,7 @@ var normalizeTsName = (n) => {
 var TypeScript = class extends Writer {
   resourceRelatives = [];
   tsImportType(tsPackageName, ...entities) {
-    this.lineSM(`import type { ${entities.join(", ")} } from '${tsPackageName}'`);
+    this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
   generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
@@ -5586,7 +5203,7 @@ var TypeScript = class extends Writer {
       );
       for (const exp of exports) {
         this.debugComment(exp.identifier);
-        this.lineSM(`export type { ${exp.resourceName} } from './${exp.tsPackageName}'`);
+        this.lineSM(`export type { ${exp.resourceName} } from "./${exp.tsPackageName}"`);
       }
     });
   }
@@ -5615,7 +5232,7 @@ var TypeScript = class extends Writer {
     }));
     if (complexTypeDeps && complexTypeDeps.length > 0) {
       for (const dep of complexTypeDeps) {
-        this.lineSM(`export type { ${dep.name} }from '${dep.tsPackage}';`);
+        this.lineSM(`export type { ${dep.name} } from "${dep.tsPackage}"`);
       }
       this.line();
     }
@@ -5642,7 +5259,7 @@ var TypeScript = class extends Writer {
       if (schema.identifier.kind === "resource") {
         const possibleResourceTypes = [schema.identifier];
         possibleResourceTypes.push(...resourceChildren(this.resourceRelatives, schema.identifier));
-        this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `'${e.name}'`).join(" | ")}`);
+        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]));
@@ -5667,11 +5284,11 @@ var TypeScript = class extends Writer {
           type = "`${T}/${string}`";
         }
         if (field.reference?.length) {
-          const references = field.reference.map((ref) => `'${ref.name}'`).join(" | ");
+          const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
           type = `Reference<${references}>`;
         }
         if (field.enum) {
-          type = field.enum.map((e) => `'${e}'`).join(" | ");
+          type = field.enum.map((e) => `"${e}"`).join(" | ");
         }
         this.lineSM(`${fieldNameFixed}${optionalSymbol}:`, `${type}${arraySymbol}`);
         if (["resource", "complex-type"].includes(schema.identifier.kind)) {
@@ -5679,11 +5296,9 @@ var TypeScript = class extends Writer {
         }
       }
     });
-    this.line();
   }
   generateNestedTypes(schema) {
     if (schema.nested) {
-      this.line();
       for (const subtype of schema.nested) {
         this.generateType(subtype);
       }
@@ -5827,7 +5442,7 @@ var APIBuilder = class {
   typescript2(opts) {
     const writerOpts = {
       outputDir: Path2.join(this.options.outputDir, "/types"),
-      tabSize: 2,
+      tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//"
     };