@atomic-ehr/codegen 0.0.8 → 0.0.9-canary.20260312182458.1c26a02

package/dist/index.js

@@ -16,170 +16,99 @@ import { spawn } from 'child_process';
 import * as util from 'util';
 import Mustache from 'mustache';
 
-// src/utils/codegen-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 parseLogLevel = (level) => {
-  switch (level.toUpperCase()) {
-    case "DEBUG":
-      return 0 /* DEBUG */;
-    case "INFO":
-      return 1 /* INFO */;
-    case "WARN":
-      return 2 /* WARN */;
-    case "ERROR":
-      return 3 /* ERROR */;
-    case "SILENT":
-      return 4 /* SILENT */;
-    default:
-      throw new Error(`Invalid log level: ${level}`);
-  }
-};
-var CodegenLogger = class _CodegenLogger {
-  options;
-  dryWarnSet = /* @__PURE__ */ new Set();
-  constructor(options = {}) {
-    this.options = {
-      timestamp: false,
-      level: 1 /* INFO */,
-      ...options
+// src/utils/common-log.ts
+var LEVEL_PRIORITY = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, SILENT: 4 };
+function mkLogger(opts = {}) {
+  const prefix = opts.prefix ?? "";
+  const suppressedSet = new Set(opts.suppressTags ?? []);
+  const tagCounts = {};
+  const entries = [];
+  const drySet = /* @__PURE__ */ new Set();
+  const currentLevel = opts.level ?? "INFO";
+  const shouldLog = (level) => LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
+  const colorize = {
+    DEBUG: (s) => s,
+    INFO: (s) => s,
+    WARN: pc.yellow,
+    ERROR: pc.red,
+    SILENT: (s) => s
+  };
+  const fmt = (level, icon, msg, tag) => {
+    const pfx = prefix ? `${prefix}: ` : "";
+    const tagSuffix = tag ? ` ${pc.dim(`(${tag})`)}` : "";
+    return colorize[level](`${icon} ${pfx}${msg}`) + tagSuffix;
+  };
+  const pushEntry = (level, msg, tag, suppressed = false) => {
+    entries.push({ level, tag, message: msg, suppressed, prefix, timestamp: Date.now() });
+  };
+  const mkLogFn = (level, icon, consoleFn, dedupe = false) => {
+    return (...args) => {
+      const tag = args.length === 2 ? args[0] : void 0;
+      const msg = args.length === 2 ? args[1] : args[0];
+      if (tag) tagCounts[tag] = (tagCounts[tag] ?? 0) + 1;
+      const isSuppressed = tag !== void 0 && suppressedSet.has(tag);
+      pushEntry(level, msg, tag, isSuppressed);
+      if (isSuppressed) return;
+      if (!shouldLog(level)) return;
+      if (dedupe) {
+        const key = `${level}::${tag ?? ""}::${msg}`;
+        if (drySet.has(key)) return;
+        drySet.add(key);
+      }
+      consoleFn(fmt(level, icon, msg, tag));
     };
-  }
-  /**
-   * Check if a message at the given level should be logged
-   */
-  shouldLog(messageLevel) {
-    const currentLevel = this.options.level ?? 1 /* INFO */;
-    return messageLevel >= currentLevel;
-  }
-  static consoleLevelsMap = {
-    [1 /* INFO */]: console.log,
-    [2 /* WARN */]: console.warn,
-    [3 /* ERROR */]: console.error,
-    [0 /* DEBUG */]: console.log,
-    [4 /* SILENT */]: () => {
-    }
   };
-  formatMessage(level, message, color) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    return `${timestamp}${color(level)} ${prefix}${message}`;
-  }
-  isSuppressed(level) {
-    return this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false;
-  }
-  tryWriteToConsole(level, formattedMessage) {
-    if (this.isSuppressed(level)) return;
-    if (!this.shouldLog(level)) return;
-    const logFn = _CodegenLogger.consoleLevelsMap[level] || console.log;
-    logFn(formattedMessage);
-  }
-  /**
-   * Success message with checkmark
-   */
-  success(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("", message, pc.green));
-  }
-  /**
-   * Error message with X mark
-   */
-  error(message, error) {
-    if (this.isSuppressed(3 /* ERROR */)) return;
-    if (!this.shouldLog(3 /* ERROR */)) return;
-    console.error(this.formatMessage("X", message, pc.red));
-    const showDetails = this.options.level === 0 /* DEBUG */;
-    if (error && showDetails) {
-      console.error(pc.red(`   ${error.message}`));
-      if (error.stack) {
-        console.error(pc.gray(error.stack));
+  const logger = {
+    warn: mkLogFn("WARN", "!", console.warn),
+    dryWarn: mkLogFn("WARN", "!", console.warn, true),
+    info: mkLogFn("INFO", "i", console.log),
+    error: mkLogFn("ERROR", "X", console.error),
+    debug: mkLogFn("DEBUG", "D", console.log),
+    fork(childPrefix, childOpts) {
+      const fullPrefix = prefix ? `${prefix}/${childPrefix}` : childPrefix;
+      const merged = [...suppressedSet, ...childOpts?.suppressTags ?? []];
+      return mkLogger({
+        prefix: fullPrefix,
+        suppressTags: merged,
+        level: childOpts?.level ?? currentLevel
+      });
+    },
+    as() {
+      return logger;
+    },
+    tagCounts() {
+      return tagCounts;
+    },
+    printTagSummary() {
+      const allTags = Object.entries(tagCounts);
+      if (allTags.length === 0) return;
+      const pfx = prefix ? `${prefix}: ` : "";
+      const emitted = allTags.filter(([tag]) => !suppressedSet.has(tag));
+      const suppressed = allTags.filter(([tag]) => suppressedSet.has(tag));
+      if (emitted.length > 0) {
+        const total = emitted.reduce((sum, [, c]) => sum + c, 0);
+        const detail = emitted.map(([tag, c]) => `${tag}: ${c}`).join(", ");
+        console.warn(pc.yellow(`! ${pfx}${total} warnings (${detail})`));
       }
+      if (suppressed.length > 0) {
+        const total = suppressed.reduce((sum, [, c]) => sum + c, 0);
+        const detail = suppressed.map(([tag, c]) => `${tag}: ${c}`).join(", ");
+        console.log(pc.dim(`i ${pfx}${total} suppressed (${detail})`));
+      }
+    },
+    buffer() {
+      return entries;
+    },
+    bufferClear() {
+      entries.length = 0;
     }
-  }
-  /**
-   * Warning message with warning sign
-   */
-  warn(message) {
-    this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
-  }
-  dryWarn(message) {
-    if (!this.dryWarnSet.has(message)) {
-      this.warn(message);
-      this.dryWarnSet.add(message);
-    }
-  }
-  /**
-   * Info message with info icon
-   */
-  info(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("i", message, pc.blue));
-  }
-  /**
-   * Debug message (only shows when log level is DEBUG or verbose is true)
-   */
-  debug(message) {
-    if (this.shouldLog(0 /* DEBUG */)) {
-      this.tryWriteToConsole(0 /* DEBUG */, this.formatMessage("\u{1F41B}", message, pc.magenta));
-    }
-  }
-  /**
-   * Step message with rocket
-   */
-  step(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u{1F680}", message, pc.cyan));
-  }
-  /**
-   * Progress message with clock
-   */
-  progress(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u23F3", message, pc.blue));
-  }
-  /**
-   * Plain message (no icon, just colored text)
-   */
-  plain(message, color = (s) => s) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    this.tryWriteToConsole(1 /* INFO */, `${timestamp}${prefix}${color(message)}`);
-  }
-  /**
-   * Dimmed/gray text for less important info
-   */
-  dim(message) {
-    this.plain(message, pc.gray);
-  }
-  /**
-   * Create a child logger with a prefix
-   */
-  child(prefix) {
-    return new _CodegenLogger({
-      ...this.options,
-      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
-    });
-  }
-  /**
-   * Update options
-   */
-  configure(options) {
-    this.options = { ...this.options, ...options };
-  }
-  getLevel() {
-    return this.options.level ?? 1 /* INFO */;
-  }
-  setLevel(level) {
-    this.options.level = level;
-  }
-};
-new CodegenLogger();
-function createLogger(options = {}) {
-  return new CodegenLogger(options);
+  };
+  return logger;
 }
 
+// src/utils/log.ts
+var mkCodegenLogger = (opts = {}) => mkLogger(opts);
+
 // src/api/writer-generator/utils.ts
 var words = (s) => {
   return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
@@ -982,7 +911,7 @@ var mkTypeSchemaIndex = (schemas, {
     append(schema);
   }
   const relations = resourceRelatives(schemas);
-  const resolve5 = (id) => {
+  const resolve6 = (id) => {
     if (id.kind === "nested") return nestedIndex[id.url]?.[id.package];
     return index[id.url]?.[id.package];
   };
@@ -1015,9 +944,10 @@ var mkTypeSchemaIndex = (schemas, {
       res.push(cur);
       const base = cur.base;
       if (base === void 0) break;
-      const resolved = resolve5(base);
+      const resolved = resolve6(base);
       if (!resolved) {
         logger?.warn(
+          "#resolveBase",
           `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
         );
         return void 0;
@@ -1041,7 +971,7 @@ var mkTypeSchemaIndex = (schemas, {
     return nonConstraintSchema;
   };
   const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve5(id);
+    const schema = resolve6(id);
     if (!schema) return id;
     return findLastSpecialization(schema).identifier;
   };
@@ -1086,6 +1016,25 @@ var mkTypeSchemaIndex = (schemas, {
       extensions: mergedExtensions.length > 0 ? mergedExtensions : void 0
     };
   };
+  const constrainedChoice = (pkgName, baseTypeId, sliceElements) => {
+    const baseSchema = resolveByUrl(pkgName, baseTypeId.url);
+    if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return void 0;
+    for (const [fieldName, field] of Object.entries(baseSchema.fields)) {
+      if (!isChoiceDeclarationField(field)) continue;
+      const matchingVariants = field.choices.filter((c) => sliceElements.includes(c));
+      if (matchingVariants.length !== 1) continue;
+      const variantName = matchingVariants[0];
+      const variantField = baseSchema.fields[variantName];
+      if (!variantField || !isChoiceInstanceField(variantField)) continue;
+      return {
+        choiceBase: fieldName,
+        variant: variantName,
+        variantType: variantField.type,
+        allChoiceNames: field.choices
+      };
+    }
+    return void 0;
+  };
   const isWithMetaField = (profile) => {
     const genealogy = tryHierarchy(profile);
     if (!genealogy) return false;
@@ -1128,7 +1077,7 @@ var mkTypeSchemaIndex = (schemas, {
     collectResources: () => schemas.filter(isResourceTypeSchema),
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    resolve: resolve5,
+    resolve: resolve6,
     resolveByUrl,
     resourceChildren,
     tryHierarchy,
@@ -1136,6 +1085,7 @@ var mkTypeSchemaIndex = (schemas, {
     findLastSpecialization,
     findLastSpecializationByIdentifier,
     flatProfile,
+    constrainedChoice,
     isWithMetaField,
     entityTree,
     exportTree,
@@ -1212,6 +1162,14 @@ var PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
   "List"
 ]);
 var MAX_IMPORT_LINE_LENGTH = 100;
+var GENERIC_FIELD_REWRITES = {
+  Coding: { code: "T" },
+  CodeableConcept: { coding: "Coding[T]" }
+};
+var pyEnumType = (enumDef) => {
+  const values = enumDef.values.map((e) => `"${e}"`).join(", ");
+  return enumDef.isOpen ? `Literal[${values}] | str` : `Literal[${values}]`;
+};
 var fixReservedWords = (name) => {
   return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
 };
@@ -1334,9 +1292,14 @@ var Python = class extends Writer {
     }
   }
   generateBasePy(packageComplexTypes) {
+    const hasGenericTypes = packageComplexTypes.some((s) => s.identifier.name in GENERIC_FIELD_REWRITES);
     this.cat("base.py", () => {
       this.generateDisclaimer();
-      this.generateDefaultImports();
+      this.generateDefaultImports(hasGenericTypes);
+      if (hasGenericTypes) {
+        this.line();
+        this.line("T = TypeVar('T', bound=str, default=str)");
+      }
       this.line();
       this.generateComplexTypes(packageComplexTypes);
       this.line();
@@ -1427,7 +1390,7 @@ var Python = class extends Writer {
   generateResourceModule(schema) {
     this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
       this.generateDisclaimer();
-      this.generateDefaultImports();
+      this.generateDefaultImports(false);
       this.generateFhirBaseModelImport();
       this.line();
       this.generateDependenciesImports(schema);
@@ -1451,7 +1414,11 @@ var Python = class extends Writer {
     this.line();
   }
   getSuperClasses(schema) {
-    return [...schema.base ? [schema.base.name] : [], ...this.injectSuperClasses(schema.identifier.url)];
+    const bases = [];
+    if (schema.base) bases.push(schema.base.name);
+    bases.push(...this.injectSuperClasses(schema.identifier.url));
+    if (schema.identifier.name in GENERIC_FIELD_REWRITES) bases.push("Generic[T]");
+    return bases;
   }
   generateClassBody(schema) {
     this.generateModelConfig();
@@ -1462,7 +1429,7 @@ var Python = class extends Writer {
     if (schema.identifier.kind === "resource") {
       this.generateResourceTypeField(schema);
     }
-    this.generateFields(schema);
+    this.generateFields(schema, schema.identifier.name);
     if (schema.identifier.kind === "resource") {
       this.generateResourceMethods(schema);
     }
@@ -1490,17 +1457,17 @@ var Python = class extends Writer {
     });
     this.line(")");
   }
-  generateFields(schema) {
+  generateFields(schema, schemaName) {
     const sortedFields = Object.entries(schema.fields ?? []).sort(([a], [b]) => a.localeCompare(b));
     for (const [fieldName, field] of sortedFields) {
       if ("choices" in field && field.choices) continue;
-      const fieldInfo = this.buildFieldInfo(fieldName, field);
+      const fieldInfo = this.buildFieldInfo(fieldName, field, schemaName);
       this.line(`${fieldInfo.name}: ${fieldInfo.type}${fieldInfo.defaultValue}`);
     }
   }
-  buildFieldInfo(fieldName, field) {
+  buildFieldInfo(fieldName, field, schemaName) {
     const pyFieldName = fixReservedWords(this.nameFormatFunction(fieldName));
-    const fieldType = this.determineFieldType(field);
+    const fieldType = this.determineFieldType(field, fieldName, schemaName);
     const defaultValue = this.getFieldDefaultValue(field, fieldName);
     return {
       name: pyFieldName,
@@ -1508,11 +1475,23 @@ var Python = class extends Writer {
       defaultValue
     };
   }
-  determineFieldType(field) {
+  determineFieldType(field, fieldName, schemaName) {
     let fieldType = field ? this.getBaseFieldType(field) : "";
-    if ("enum" in field && field.enum && !field.enum.isOpen) {
-      const s = field.enum.values.map((e) => `"${e}"`).join(", ");
-      fieldType = `Literal[${s}]`;
+    const rewrite = GENERIC_FIELD_REWRITES[schemaName]?.[fieldName];
+    if (rewrite) {
+      fieldType = rewrite;
+      if (field.array) fieldType = `PyList[${fieldType}]`;
+      if (!field.required) fieldType = `${fieldType} | None`;
+      return fieldType;
+    }
+    if ("enum" in field && field.enum) {
+      const baseTypeName = "type" in field ? field.type.name : "";
+      if (baseTypeName in GENERIC_FIELD_REWRITES) {
+        fieldType = `${fieldType}[${pyEnumType(field.enum)}]`;
+      } else if (!field.enum.isOpen) {
+        const s = field.enum.values.map((e) => `"${e}"`).join(", ");
+        fieldType = `Literal[${s}]`;
+      }
     }
     if (field.array) {
       fieldType = `PyList[${fieldType}]`;
@@ -1553,10 +1532,17 @@ var Python = class extends Writer {
       this.generateType(subtype);
     }
   }
-  generateDefaultImports() {
+  generateDefaultImports(includeGenericImports) {
     this.pyImportFrom("__future__", "annotations");
     this.pyImportFrom("pydantic", "BaseModel", "ConfigDict", "Field", "PositiveInt");
-    this.pyImportFrom("typing", "List as PyList", "Literal");
+    const typingImports = ["List as PyList", "Literal"];
+    if (includeGenericImports) {
+      typingImports.push("Generic");
+    }
+    this.pyImportFrom("typing", ...typingImports.sort());
+    if (includeGenericImports) {
+      this.pyImportFrom("typing_extensions", "TypeVar");
+    }
   }
   generateDependenciesImports(schema) {
     if (!schema.dependencies || schema.dependencies.length === 0) return;
@@ -1872,7 +1858,10 @@ function buildEnum(register, fhirSchema, element, logger) {
   const valueSetUrl = element.binding.valueSet;
   if (!valueSetUrl) return void 0;
   if (!BINDABLE_TYPES.has(element.type ?? "")) {
-    logger?.dryWarn(`eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`);
+    logger?.dryWarn(
+      "#binding",
+      `eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`
+    );
     return void 0;
   }
   const shouldGenerateEnum = strength === "required" || strength === "extensible" || strength === "preferred";
@@ -1882,6 +1871,7 @@ function buildEnum(register, fhirSchema, element, logger) {
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
     logger?.dryWarn(
+      "#largeValueSet",
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
@@ -1981,7 +1971,8 @@ var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
     if (!rawUrl) continue;
     if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
     const url = rawUrl;
-    if (index.canonicalResolution[url]) logger?.dryWarn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
+    if (index.canonicalResolution[url])
+      logger?.dryWarn("#duplicateCanonical", `Duplicate canonical URL: ${url} at ${pkgId}.`);
     index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
   }
   const deps = await readPackageDependencies(manager, pkg);
@@ -2002,6 +1993,8 @@ var enrichResolver = (resolver, logger) => {
   for (const { pkg, canonicalResolution } of Object.values(resolver)) {
     const pkgId = packageMetaToFhir(pkg);
     if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
+    let counter = 0;
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
     for (const [_url, options] of Object.entries(canonicalResolution)) {
       const resolition = options[0];
       if (!resolition) throw new Error(`Resource not found`);
@@ -2010,6 +2003,7 @@ var enrichResolver = (resolver, logger) => {
       if (isStructureDefinition(resource)) {
         const fs7 = fhirschema.translate(resource);
         const rfs = enrichFHIRSchema(fs7, resourcePkg);
+        counter++;
         resolver[pkgId].fhirSchemas[rfs.url] = rfs;
       }
       if (isValueSet(resource)) {
@@ -2017,6 +2011,7 @@ var enrichResolver = (resolver, logger) => {
         resolver[pkgId].valueSets[rvs.url] = rvs;
       }
     }
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
   }
 };
 var packageAgnosticResolveCanonical = (resolver, url, _logger) => {
@@ -2030,7 +2025,7 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
   for (const pkg of packages) {
     await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
   }
-  enrichResolver(resolver);
+  enrichResolver(resolver, logger);
   const resolveFs = (pkg, canonicalUrl) => {
     const pkgIndex = resolver[packageMetaToFhir(pkg)];
     if (pkgIndex) {
@@ -2171,10 +2166,10 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
 };
 var registerFromPackageMetas = async (packageMetas, conf) => {
   const packageNames = packageMetas.map(packageMetaToNpm);
-  conf?.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+  conf?.logger?.info(`Loading FHIR packages: ${packageNames.join(", ")}`);
   const manager = CanonicalManager({
     packages: packageNames,
-    workingDir: "tmp/fhir",
+    workingDir: ".codegen-cache/canonical-manager-cache",
     registry: conf.registry || void 0
   });
   await manager.init();
@@ -2510,6 +2505,7 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
     return void 0;
   } else {
     logger?.dryWarn(
+      "#fieldTypeNotFound",
       `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): missing type info`
     );
     return void 0;
@@ -2526,7 +2522,10 @@ var mkField = (register, fhirSchema, path, element, logger, rawElement) => {
   }
   const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
   if (!fieldType)
-    logger?.dryWarn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
+    logger?.dryWarn(
+      "#fieldTypeNotFound",
+      `Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`
+    );
   let valueConstraint;
   if (element.pattern) {
     valueConstraint = { kind: "pattern", type: element.pattern.type, value: element.pattern.value };
@@ -2564,7 +2563,8 @@ var mkField = (register, fhirSchema, path, element, logger, rawElement) => {
     choiceOf: element.choiceOf,
     binding,
     enum: enumResult,
-    valueConstraint
+    valueConstraint,
+    mustSupport: element.mustSupport
   };
 };
 function mkNestedField(register, fhirSchema, path, element) {
@@ -2709,7 +2709,14 @@ var extractProfileExtensions = (register, fhirSchema, logger) => {
     }
   };
   walkElement([], fhirSchema);
-  return extensions.length === 0 ? void 0 : extensions;
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = extensions.filter((ext) => {
+    const key = `${ext.url}:${ext.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return deduped.length === 0 ? void 0 : deduped;
 };
 
 // src/typeschema/core/transformer.ts
@@ -2722,6 +2729,7 @@ function mkFields(register, fhirSchema, parentPath, elements, logger) {
     const fcurl = elemSnapshot.type ? register.ensureSpecializationCanonicalUrl(elemSnapshot.type) : void 0;
     if (fcurl && shouldSkipCanonical(fhirSchema.package_meta, fcurl).shouldSkip) {
       logger?.warn(
+        "#skipCanonical",
         `Skipping field ${path} for ${fcurl} due to skip hack ${shouldSkipCanonical(fhirSchema.package_meta, fcurl).reason}`
       );
       continue;
@@ -2826,7 +2834,7 @@ var deduplicateSchemas = (schemasWithSources, logger) => {
     if (sorted.length > 1) {
       const pkg = best.typeSchema.identifier.package;
       const url = best.typeSchema.identifier.url;
-      logger?.dryWarn(`'${url}' from '${pkg}'' has ${sorted.length} versions`);
+      logger?.dryWarn("#duplicateSchema", `'${url}' from '${pkg}' has ${sorted.length} versions`);
       collisions[pkg] ??= {};
       collisions[pkg][url] = sorted.flatMap(
         (v) => v.sources.map((s) => ({
@@ -2845,7 +2853,7 @@ var generateTypeSchemas = async (register, logger) => {
     const pkgId = packageMetaToFhir(fhirSchema.package_meta);
     const skipCheck = shouldSkipCanonical(fhirSchema.package_meta, fhirSchema.url);
     if (skipCheck.shouldSkip) {
-      logger?.dryWarn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
+      logger?.dryWarn("#skipCanonical", `Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
       continue;
     }
     for (const schema of await transformFhirSchema(register, fhirSchema, logger)) {
@@ -3897,14 +3905,14 @@ var createGenerator = (templatePath, apiOpts) => {
   return new MustacheGenerator(mustacheOptions);
 };
 function runCommand(cmd, args = [], options = {}) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = spawn(cmd, args, {
       stdio: "inherit",
       ...options
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve5(code);
+      if (code === 0) resolve6(code);
       else reject(new Error(`Prozess beendet mit Fehlercode ${code}`));
     });
   });
@@ -4074,32 +4082,31 @@ var tsProfileModuleFileName = (tsIndex, schema) => {
   return `${tsProfileModuleName(tsIndex, schema)}.ts`;
 };
 var tsProfileClassName = (schema) => {
-  return `${normalizeTsName(schema.identifier.name)}Profile`;
+  const name = normalizeTsName(schema.identifier.name);
+  return name.endsWith("Profile") ? name : `${name}Profile`;
 };
-var tsSliceInputTypeName = (profileName, fieldName, sliceName) => {
-  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceInput`;
+var tsSliceFlatTypeName = (profileName, fieldName, sliceName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceFlat`;
 };
-var tsExtensionInputTypeName = (profileName, extensionName) => {
-  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Input`;
+var tsExtensionFlatTypeName = (profileName, extensionName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Flat`;
 };
-var tsSliceMethodName = (sliceName) => {
-  return `set${uppercaseFirstLetter(normalizeTsName(sliceName) || "Slice")}`;
-};
-var tsExtensionMethodName = (name) => {
-  const normalized = tsCamelCase(name);
-  return `set${uppercaseFirstLetter(normalized || "Extension")}`;
-};
-var tsQualifiedExtensionMethodName = (name, path) => {
+var tsSliceStaticName = (name) => name.replace(/\[x\]/g, "").replace(/[^a-zA-Z0-9_$]/g, "_");
+var tsSliceMethodBaseName = (sliceName) => uppercaseFirstLetter(normalizeTsName(sliceName) || "Slice");
+var tsExtensionMethodBaseName = (name) => uppercaseFirstLetter(tsCamelCase(name) || "Extension");
+var tsQualifiedExtensionMethodBaseName = (name, path) => {
   const rawPath = path?.split(".").filter((p) => p && p !== "extension").join("_") ?? "";
   const pathPart = rawPath ? uppercaseFirstLetter(tsCamelCase(rawPath)) : "";
-  const normalized = tsCamelCase(name);
-  return `setExtension${pathPart}${uppercaseFirstLetter(normalized || "Extension")}`;
+  return `${pathPart}${uppercaseFirstLetter(tsCamelCase(name) || "Extension")}`;
 };
-var tsQualifiedSliceMethodName = (fieldName, sliceName) => {
+var tsQualifiedSliceMethodBaseName = (fieldName, sliceName) => {
   const fieldPart = uppercaseFirstLetter(tsCamelCase(fieldName) || "Field");
   const slicePart = uppercaseFirstLetter(normalizeTsName(sliceName) || "Slice");
-  return `setSlice${fieldPart}${slicePart}`;
+  return `${fieldPart}${slicePart}`;
 };
+var tsResolvedExtensionBaseName = (extensionBaseNames, url, path, fallbackName) => extensionBaseNames[`${url}:${path}`] ?? fallbackName;
+var tsResolvedSliceBaseName = (sliceBaseNames, fieldName, sliceName) => sliceBaseNames[`${fieldName}:${sliceName}`] ?? sliceName;
+var tsValueFieldName = (id) => `value${uppercaseFirstLetter(id.name)}`;
 
 // src/api/writer-generator/typescript/utils.ts
 var primitiveType2tsType = {
@@ -4144,7 +4151,7 @@ var rewriteFieldTypeDefs = {
   Reference: { reference: () => "`${T}/${string}`" },
   CodeableConcept: { coding: () => "Coding<T>" }
 };
-var resolveFieldTsType = (schemaName, tsName, field) => {
+var resolveFieldTsType = (schemaName, tsName, field, resolveRef) => {
   const rewriteFieldType = rewriteFieldTypeDefs[schemaName]?.[tsName];
   if (rewriteFieldType) return rewriteFieldType();
   if (field.enum) {
@@ -4153,13 +4160,14 @@ var resolveFieldTsType = (schemaName, tsName, field) => {
     return tsEnumType(field.enum);
   }
   if (field.reference && field.reference.length > 0) {
-    const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
+    const references = field.reference.map((ref) => resolveRef ? resolveRef(ref) : ref).map((ref) => `"${ref.name}"`).join(" | ");
     return `Reference<${references}>`;
   }
   if (isPrimitiveIdentifier(field.type)) return resolvePrimitiveType(field.type.name);
   if (isNestedIdentifier(field.type)) return tsResourceName(field.type);
   return field.type.name;
 };
+var fieldTsType = (field, resolveRef) => resolveFieldTsType("", "", field, resolveRef) + (field.array ? "[]" : "");
 var tsTypeFromIdentifier = (id) => {
   if (isNestedIdentifier(id)) return tsResourceName(id);
   if (isPrimitiveIdentifier(id)) return resolvePrimitiveType(id.name);
@@ -4168,514 +4176,302 @@ var tsTypeFromIdentifier = (id) => {
   return id.name;
 };
 
-// src/api/writer-generator/typescript/profile.ts
-var collectChoiceAccessors = (flatProfile, promotedChoices) => {
-  const accessors = [];
-  for (const [name, field] of Object.entries(flatProfile.fields ?? {})) {
-    if (field.excluded) continue;
-    if (!isChoiceInstanceField(field)) continue;
-    if (promotedChoices.has(name)) continue;
-    const tsType = tsTypeFromIdentifier(field.type) + (field.array ? "[]" : "");
-    accessors.push({ name, tsType, typeId: field.type });
+// src/api/writer-generator/typescript/profile-extensions.ts
+var extractValueField = (elements) => {
+  if (!elements) return void 0;
+  return elements.find((e) => e.startsWith("value") && e !== "value");
+};
+var valueFieldToTsType = (valueField) => {
+  const fhirName = valueField.replace(/^value/, "");
+  const primitives = {
+    String: "string",
+    Boolean: "boolean",
+    Integer: "number",
+    Decimal: "number",
+    Date: "string",
+    DateTime: "string",
+    Time: "string",
+    Instant: "string",
+    Uri: "string",
+    Url: "string",
+    Canonical: "string",
+    Code: "string",
+    Oid: "string",
+    Id: "string",
+    Markdown: "string",
+    UnsignedInt: "number",
+    PositiveInt: "number",
+    Uuid: "string",
+    Base64Binary: "string"
+  };
+  return primitives[fhirName] ?? fhirName;
+};
+var collectSubExtensionSlices = (extProfile) => {
+  const extensionField = extProfile.fields?.extension;
+  if (!extensionField || isChoiceDeclarationField(extensionField) || !extensionField.slicing?.slices) return [];
+  const result = [];
+  for (const [sliceName, slice] of Object.entries(extensionField.slicing.slices)) {
+    const valueField = extractValueField(slice.elements);
+    if (!valueField) continue;
+    const tsType = valueFieldToTsType(valueField);
+    const isArray = slice.max === void 0;
+    const isRequired2 = slice.min !== void 0 && slice.min >= 1;
+    result.push({
+      name: tsCamelCase(sliceName) || sliceName,
+      url: sliceName,
+      valueField,
+      tsType,
+      isArray,
+      isRequired: isRequired2
+    });
   }
-  return accessors;
+  return result;
 };
-var tryPromoteChoice = (field, fields, params, promotedChoices) => {
-  if (!isChoiceDeclarationField(field) || !field.required || field.choices.length !== 1) return;
-  const choiceName = field.choices[0];
-  if (!choiceName) return;
-  const choiceField = fields[choiceName];
-  if (!choiceField || !isChoiceInstanceField(choiceField)) return;
-  const tsType = tsTypeFromIdentifier(choiceField.type) + (choiceField.array ? "[]" : "");
-  params.push({ name: choiceName, tsType, typeId: choiceField.type });
-  promotedChoices.add(choiceName);
+var resolveExtensionProfile = (tsIndex, pkgName, url) => {
+  const schema = tsIndex.resolveByUrl(pkgName, url);
+  if (!schema || !isProfileTypeSchema(schema)) return void 0;
+  if (schema.identifier.package !== pkgName) return void 0;
+  const className = tsProfileClassName(schema);
+  const modulePath = `./${tsProfileModuleName(tsIndex, schema)}`;
+  const flatProfile = tsIndex.flatProfile(schema);
+  return { className, modulePath, flatProfile };
 };
-var collectRequiredSliceMatches = (field) => {
-  if (!field.array || !field.slicing?.slices) return void 0;
-  const matches = Object.values(field.slicing.slices).filter((s) => s.min !== void 0 && s.min >= 1 && s.match && Object.keys(s.match).length > 0).map((s) => s.match);
-  return matches.length > 0 ? matches : void 0;
+var generateRawExtensionBody = (w, ext, targetPath, paramName = "input") => {
+  w.line(
+    `if (${paramName}.url !== ${JSON.stringify(ext.url)}) throw new Error(\`Expected extension url '${ext.url}', got '\${${paramName}.url}'\`)`
+  );
+  generateExtensionPush(w, targetPath, paramName);
 };
-var collectProfileFactoryInfo = (flatProfile) => {
-  const autoFields = [];
-  const sliceAutoFields = [];
-  const params = [];
-  const autoAccessors = [];
-  const fields = flatProfile.fields ?? {};
-  const promotedChoices = /* @__PURE__ */ new Set();
-  if (isResourceIdentifier(flatProfile.base)) {
-    autoFields.push({ name: "resourceType", value: JSON.stringify(flatProfile.base.name) });
+var generateExtensionPush = (w, targetPath, extExpr) => {
+  if (targetPath.length === 0) {
+    w.line(`pushExtension(this.resource, ${extExpr})`);
+  } else {
+    w.line(
+      `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+    );
+    w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
+    w.line(`pushExtension(target as unknown as { extension?: Extension[] }, ${extExpr})`);
   }
-  for (const [name, field] of Object.entries(fields)) {
-    if (field.excluded) continue;
-    if (isChoiceInstanceField(field)) continue;
-    if (isChoiceDeclarationField(field)) {
-      tryPromoteChoice(field, fields, params, promotedChoices);
-      continue;
-    }
-    if (field.valueConstraint) {
-      const value = JSON.stringify(field.valueConstraint.value);
-      autoFields.push({ name, value: field.array ? `[${value}]` : value });
-      if (isNotChoiceDeclarationField(field) && field.type) {
-        const tsType = resolveFieldTsType("", "", field) + (field.array ? "[]" : "");
-        autoAccessors.push({ name, tsType, typeId: field.type });
+};
+var generateExtLookup = (w, ext, targetPath) => {
+  if (targetPath.length === 0) {
+    w.line(`const ext = this.resource.extension?.find(e => e.url === "${ext.url}")`);
+  } else {
+    w.line(
+      `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+    );
+    w.line(`const ext = (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`);
+  }
+};
+var effectiveGetterDefault = (w, hasProfile) => {
+  const configured = w.opts.extensionGetterDefault ?? "flat";
+  if (configured === "profile" && !hasProfile) return "flat";
+  return configured;
+};
+var returnTypeForMode = (mode, inputType, profileClassName) => {
+  if (mode === "profile" && profileClassName) return profileClassName;
+  if (mode === "raw") return "Extension";
+  return inputType;
+};
+var generateExtensionGetterOverloads = (w, ext, targetPath, methodName, inputType, extProfileInfo, generateInputBody) => {
+  const hasProfile = !!extProfileInfo;
+  const defaultMode = effectiveGetterDefault(w, hasProfile);
+  const modes = hasProfile ? ["flat", "profile", "raw"] : ["flat", "raw"];
+  for (const mode of modes) {
+    const rt = returnTypeForMode(mode, inputType, extProfileInfo?.className);
+    w.lineSM(`public ${methodName}(mode: '${mode}'): ${rt} | undefined`);
+  }
+  const defaultReturn = returnTypeForMode(defaultMode, inputType, extProfileInfo?.className);
+  w.lineSM(`public ${methodName}(): ${defaultReturn} | undefined`);
+  const allReturns = [...new Set(modes.map((m) => returnTypeForMode(m, inputType, extProfileInfo?.className)))];
+  const modesUnion = modes.map((m) => `'${m}'`).join(" | ");
+  w.curlyBlock(
+    ["public", methodName, `(mode: ${modesUnion} = '${defaultMode}'): ${allReturns.join(" | ")} | undefined`],
+    () => {
+      generateExtLookup(w, ext, targetPath);
+      w.line("if (!ext) return undefined");
+      w.line("if (mode === 'raw') return ext");
+      if (hasProfile) {
+        w.line(`if (mode === 'profile') return ${extProfileInfo?.className}.apply(ext)`);
       }
-      continue;
+      generateInputBody();
     }
-    if (isNotChoiceDeclarationField(field)) {
-      const requiredMatches = collectRequiredSliceMatches(field);
-      if (requiredMatches) {
-        const defaultValue = `[${requiredMatches.map((m) => JSON.stringify(m)).join(",")}]`;
-        if (field.type) {
-          const tsType = resolveFieldTsType("", "", field) + (field.array ? "[]" : "");
-          sliceAutoFields.push({
-            name,
-            tsType,
-            typeId: field.type,
-            defaultValue,
-            matches: requiredMatches.map((m) => JSON.stringify(m))
+  );
+};
+var generateComplexExtensionSetter = (w, info) => {
+  const { ext, flatProfile, setMethodName, targetPath, extProfileInfo } = info;
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
+  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+  if (extProfileInfo && extProfileHasFlatInput) {
+    const paramType = `${extProfileInfo.className}Flat | ${extProfileInfo.className} | Extension`;
+    w.curlyBlock(["public", setMethodName, `(input: ${paramType}): this`], () => {
+      w.ifElseChain(
+        [
+          {
+            cond: `input instanceof ${extProfileInfo.className}`,
+            body: () => generateExtensionPush(w, targetPath, "input.toResource()")
+          },
+          {
+            cond: "isExtension<Extension>(input)",
+            body: () => generateRawExtensionBody(w, ext, targetPath)
+          }
+        ],
+        () => generateExtensionPush(w, targetPath, `${extProfileInfo.className}.createResource(input)`)
+      );
+      w.line("return this");
+    });
+  } else {
+    w.curlyBlock(["public", setMethodName, `(input: ${inputTypeName}): this`], () => {
+      w.line("const subExtensions: Extension[] = []");
+      for (const sub of ext.subExtensions ?? []) {
+        const valueField = sub.valueType ? tsValueFieldName(sub.valueType) : "value";
+        if (sub.max === "*") {
+          w.curlyBlock(["if", `(input.${sub.name})`], () => {
+            w.curlyBlock(["for", `(const item of input.${sub.name})`], () => {
+              w.line(`subExtensions.push({ url: "${sub.url}", ${valueField}: item } as Extension)`);
+            });
+          });
+        } else {
+          w.curlyBlock(["if", `(input.${sub.name} !== undefined)`], () => {
+            w.line(
+              `subExtensions.push({ url: "${sub.url}", ${valueField}: input.${sub.name} } as Extension)`
+            );
           });
-          autoAccessors.push({ name, tsType, typeId: field.type });
         }
-        continue;
       }
-    }
-    if (field.required) {
-      const tsType = resolveFieldTsType("", "", field) + (field.array ? "[]" : "");
-      params.push({ name, tsType, typeId: field.type });
-    }
+      if (targetPath.length === 0) {
+        w.line("const list = (this.resource.extension ??= [])");
+        w.line(`list.push({ url: "${ext.url}", extension: subExtensions })`);
+      } else {
+        w.line(
+          `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+        );
+        w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
+        w.line(`(target.extension as Extension[]).push({ url: "${ext.url}", extension: subExtensions })`);
+      }
+      w.line("return this");
+    });
   }
-  const accessors = [...autoAccessors, ...collectChoiceAccessors(flatProfile, promotedChoices)];
-  return { autoFields, sliceAutoFields, params, accessors };
 };
-var generateProfileIndexFile = (w, tsIndex, initialProfiles) => {
-  if (initialProfiles.length === 0) return;
-  w.cd("profiles", () => {
-    w.cat("index.ts", () => {
-      const profiles = initialProfiles.map((profile) => {
-        const className = tsProfileClassName(profile);
-        const resourceName = tsResourceName(profile.identifier);
-        const overrides = detectFieldOverrides(w, tsIndex, profile);
-        let typeExport;
-        if (overrides.size > 0) typeExport = resourceName;
-        return [profile, className, typeExport];
-      });
-      if (profiles.length === 0) return;
-      const classExports = /* @__PURE__ */ new Map();
-      const typeExports = /* @__PURE__ */ new Map();
-      for (const [profile, className, typeName] of profiles) {
-        const moduleName = tsProfileModuleName(tsIndex, profile);
-        if (!classExports.has(className)) {
-          classExports.set(className, `export { ${className} } from "./${moduleName}"`);
-        }
-        if (typeName && !typeExports.has(typeName)) {
-          typeExports.set(typeName, `export type { ${typeName} } from "./${moduleName}"`);
-        }
-      }
-      const allExports = [...classExports.values(), ...typeExports.values()].sort();
-      for (const exp of allExports) {
-        w.lineSM(exp);
-      }
+var generateComplexExtensionGetter = (w, info) => {
+  const { ext, flatProfile, getMethodName, targetPath, extProfileInfo } = info;
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
+  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+  const inputType = extProfileHasFlatInput && extProfileInfo ? `${extProfileInfo.className}Flat` : inputTypeName;
+  generateExtensionGetterOverloads(w, ext, targetPath, getMethodName, inputType, extProfileInfo, () => {
+    const configItems = (ext.subExtensions ?? []).map((sub) => {
+      const valueField = sub.valueType ? tsValueFieldName(sub.valueType) : "value";
+      const isArray = sub.max === "*";
+      return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
     });
+    w.line(`const config = [${configItems.join(", ")}]`);
+    w.line(`return extractComplexExtension<${inputType}>(ext, config)`);
   });
 };
-var tsTypeForProfileField = (_w, tsIndex, flatProfile, fieldName, field) => {
-  if (!isNotChoiceDeclarationField(field)) {
-    throw new Error(`Choice declaration fields not supported for '${fieldName}'`);
-  }
-  let tsType;
-  if (field.enum) {
-    if (field.type?.name === "Coding") {
-      tsType = `Coding<${tsEnumType(field.enum)}>`;
-    } else if (field.type?.name === "CodeableConcept") {
-      tsType = `CodeableConcept<${tsEnumType(field.enum)}>`;
-    } else {
-      tsType = tsEnumType(field.enum);
-    }
-  } else if (field.reference && field.reference.length > 0) {
-    const specialization = tsIndex.findLastSpecialization(flatProfile);
-    if (!isSpecializationTypeSchema(specialization))
-      throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
-    const sField = specialization.fields?.[fieldName];
-    if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
-      throw new Error(`Invalid field declaration for ${fieldName}`);
-    const sRefs = sField.reference.map((e) => e.name);
-    const references = field.reference.map((ref) => {
-      const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
-      if (resRef.name !== ref.name) {
-        return `"${resRef.name}" /*${ref.name}*/`;
-      }
-      return `'${ref.name}'`;
-    }).join(" | ");
-    if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
-      const cleanRefs = references.replace(/\/\*[^*]*\*\//g, "").trim();
-      tsType = `Reference<"Resource" /* ${cleanRefs} */ >`;
-    } else {
-      tsType = `Reference<${references}>`;
-    }
-  } else if (isPrimitiveIdentifier(field.type)) {
-    tsType = resolvePrimitiveType(field.type.name);
-  } else if (isNestedIdentifier(field.type)) {
-    tsType = tsResourceName(field.type);
-  } else if (field.type === void 0) {
-    throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
+var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
+  const { ext, setMethodName, targetPath, extProfileInfo } = info;
+  const firstValueType = ext.valueTypes?.[0];
+  if (!firstValueType) return;
+  const valueType = tsTypeFromIdentifier(firstValueType);
+  const valueField = tsValueFieldName(firstValueType);
+  if (extProfileInfo) {
+    const paramType = `${extProfileInfo.className} | Extension | ${valueType}`;
+    const extHasValueParam = collectProfileFactoryInfo(tsIndex, extProfileInfo.flatProfile).params.some(
+      (p) => p.name === valueField
+    );
+    const elseExpr = extHasValueParam ? `${extProfileInfo.className}.createResource({ ${valueField}: value as ${valueType} })` : `{ url: "${ext.url}", ${valueField}: value as ${valueType} } as Extension`;
+    w.curlyBlock(["public", setMethodName, `(value: ${paramType}): this`], () => {
+      w.ifElseChain(
+        [
+          {
+            cond: `value instanceof ${extProfileInfo.className}`,
+            body: () => generateExtensionPush(w, targetPath, "value.toResource()")
+          },
+          {
+            cond: "isExtension(value)",
+            body: () => generateRawExtensionBody(w, ext, targetPath, "value")
+          }
+        ],
+        () => generateExtensionPush(w, targetPath, elseExpr)
+      );
+      w.line("return this");
+    });
   } else {
-    tsType = field.type.name;
+    w.curlyBlock(["public", setMethodName, `(value: ${valueType}): this`], () => {
+      const extLiteral = `{ url: "${ext.url}", ${valueField}: value } as Extension`;
+      generateExtensionPush(w, targetPath, extLiteral);
+      w.line("return this");
+    });
   }
-  return tsType;
 };
-var generateProfileHelpersModule = (w) => {
-  w.cat("profile-helpers.ts", () => {
-    w.generateDisclaimer();
-    w.curlyBlock(
-      ["export const", "isRecord", "=", "(value: unknown): value is Record<string, unknown>", "=>"],
-      () => {
-        w.lineSM('return value !== null && typeof value === "object" && !Array.isArray(value)');
-      }
-    );
-    w.line();
-    w.curlyBlock(
+var generateSingleValueExtensionGetter = (w, info) => {
+  const { ext, getMethodName, targetPath, extProfileInfo } = info;
+  const firstValueType = ext.valueTypes?.[0];
+  if (!firstValueType) return;
+  const valueType = tsTypeFromIdentifier(firstValueType);
+  const valueField = tsValueFieldName(firstValueType);
+  generateExtensionGetterOverloads(w, ext, targetPath, getMethodName, valueType, extProfileInfo, () => {
+    w.line(`return getExtensionValue<${valueType}>(ext, "${valueField}")`);
+  });
+};
+var generateGenericExtensionSetter = (w, info) => {
+  const { ext, setMethodName, targetPath } = info;
+  w.curlyBlock(["public", setMethodName, `(value: Omit<Extension, "url"> | Extension): this`], () => {
+    w.ifElseChain(
       [
-        "export const",
-        "getOrCreateObjectAtPath",
-        "=",
-        "(root: Record<string, unknown>, path: string[]): Record<string, unknown>",
-        "=>"
+        {
+          cond: "isExtension(value)",
+          body: () => generateRawExtensionBody(w, ext, targetPath, "value")
+        }
       ],
-      () => {
-        w.lineSM("let current: Record<string, unknown> = root");
-        w.curlyBlock(["for (const", "segment", "of", "path)"], () => {
-          w.curlyBlock(["if", "(Array.isArray(current[segment]))"], () => {
-            w.lineSM("const list = current[segment] as unknown[]");
-            w.curlyBlock(["if", "(list.length === 0)"], () => {
-              w.lineSM("list.push({})");
-            });
-            w.lineSM("current = list[0] as Record<string, unknown>");
-          });
-          w.curlyBlock(["else"], () => {
-            w.curlyBlock(["if", "(!isRecord(current[segment]))"], () => {
-              w.lineSM("current[segment] = {}");
-            });
-            w.lineSM("current = current[segment] as Record<string, unknown>");
-          });
-        });
-        w.lineSM("return current");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "mergeMatch",
-        "=",
-        "(target: Record<string, unknown>, match: Record<string, unknown>): void",
-        "=>"
-      ],
-      () => {
-        w.curlyBlock(["for (const", "[key, matchValue]", "of", "Object.entries(match))"], () => {
-          w.curlyBlock(
-            ["if", '(key === "__proto__" || key === "constructor" || key === "prototype")'],
-            () => {
-              w.lineSM("continue");
-            }
-          );
-          w.curlyBlock(["if", "(isRecord(matchValue))"], () => {
-            w.curlyBlock(["if", "(isRecord(target[key]))"], () => {
-              w.lineSM("mergeMatch(target[key] as Record<string, unknown>, matchValue)");
-            });
-            w.curlyBlock(["else"], () => {
-              w.lineSM("target[key] = { ...matchValue }");
-            });
-          });
-          w.curlyBlock(["else"], () => {
-            w.lineSM("target[key] = matchValue");
-          });
-        });
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "applySliceMatch",
-        "=",
-        "<T extends Record<string, unknown>>(input: T, match: Record<string, unknown>): T",
-        "=>"
-      ],
-      () => {
-        w.lineSM("const result = { ...input } as Record<string, unknown>");
-        w.lineSM("mergeMatch(result, match)");
-        w.lineSM("return result as T");
-      }
-    );
-    w.line();
-    w.curlyBlock(["export const", "matchesValue", "=", "(value: unknown, match: unknown): boolean", "=>"], () => {
-      w.curlyBlock(["if", "(Array.isArray(match))"], () => {
-        w.curlyBlock(["if", "(!Array.isArray(value))"], () => w.lineSM("return false"));
-        w.lineSM("return match.every((matchItem) => value.some((item) => matchesValue(item, matchItem)))");
-      });
-      w.curlyBlock(["if", "(isRecord(match))"], () => {
-        w.curlyBlock(["if", "(!isRecord(value))"], () => w.lineSM("return false"));
-        w.curlyBlock(["for (const", "[key, matchValue]", "of", "Object.entries(match))"], () => {
-          w.curlyBlock(["if", "(!matchesValue((value as Record<string, unknown>)[key], matchValue))"], () => {
-            w.lineSM("return false");
-          });
-        });
-        w.lineSM("return true");
-      });
-      w.lineSM("return value === match");
-    });
-    w.line();
-    w.curlyBlock(
-      ["export const", "matchesSlice", "=", "(value: unknown, match: Record<string, unknown>): boolean", "=>"],
-      () => {
-        w.lineSM("return matchesValue(value, match)");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "extractComplexExtension",
-        "=",
-        "(extension: { extension?: Array<{ url?: string; [key: string]: unknown }> } | undefined, config: Array<{ name: string; valueField: string; isArray: boolean }>): Record<string, unknown> | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM("if (!extension?.extension) return undefined");
-        w.lineSM("const result: Record<string, unknown> = {}");
-        w.curlyBlock(["for (const", "{ name, valueField, isArray }", "of", "config)"], () => {
-          w.lineSM("const subExts = extension.extension.filter(e => e.url === name)");
-          w.curlyBlock(["if", "(isArray)"], () => {
-            w.lineSM("result[name] = subExts.map(e => (e as Record<string, unknown>)[valueField])");
-          });
-          w.curlyBlock(["else if", "(subExts[0])"], () => {
-            w.lineSM("result[name] = (subExts[0] as Record<string, unknown>)[valueField]");
-          });
-        });
-        w.lineSM("return result");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "extractSliceSimplified",
-        "=",
-        "<T extends Record<string, unknown>>(slice: T, matchKeys: string[]): Partial<T>",
-        "=>"
-      ],
-      () => {
-        w.lineSM("const result = { ...slice } as Record<string, unknown>");
-        w.curlyBlock(["for (const", "key", "of", "matchKeys)"], () => {
-          w.lineSM("delete result[key]");
-        });
-        w.lineSM("return result as Partial<T>");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "wrapSliceChoice",
-        "=",
-        "(input: Record<string, unknown>, choiceVariant: string): Record<string, unknown>",
-        "=>"
-      ],
-      () => {
-        w.lineSM("if (Object.keys(input).length === 0) return input");
-        w.lineSM("return { [choiceVariant]: input }");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "flattenSliceChoice",
-        "=",
-        "(slice: Record<string, unknown>, matchKeys: string[], choiceVariant: string): Record<string, unknown>",
-        "=>"
-      ],
-      () => {
-        w.lineSM("const result = { ...slice } as Record<string, unknown>");
-        w.curlyBlock(["for (const", "key", "of", "matchKeys)"], () => {
-          w.lineSM("delete result[key]");
-        });
-        w.lineSM("const variantValue = result[choiceVariant]");
-        w.lineSM("delete result[choiceVariant]");
-        w.curlyBlock(["if", "(isRecord(variantValue))"], () => {
-          w.lineSM("Object.assign(result, variantValue)");
-        });
-        w.lineSM("return result");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateRequired",
-        "=",
-        "(r: Record<string, unknown>, field: string, path: string): string | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM(
-          "return r[field] === undefined || r[field] === null ? `${path}: required field '${field}' is missing` : undefined"
-        );
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateExcluded",
-        "=",
-        "(r: Record<string, unknown>, field: string, path: string): string | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM("return r[field] !== undefined ? `${path}: field '${field}' must not be present` : undefined");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateFixedValue",
-        "=",
-        "(r: Record<string, unknown>, field: string, expected: unknown, path: string): string | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM(
-          "return matchesValue(r[field], expected) ? undefined : `${path}: field '${field}' does not match expected fixed value`"
-        );
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateSliceCardinality",
-        "=",
-        "(items: unknown[] | undefined, match: Record<string, unknown>, sliceName: string, min: number, max: number, path: string): string[]",
-        "=>"
-      ],
-      () => {
-        w.lineSM("const count = (items ?? []).filter(item => matchesSlice(item, match)).length");
-        w.lineSM("const errors: string[] = []");
-        w.curlyBlock(["if", "(count < min)"], () => {
-          w.lineSM(
-            "errors.push(`${path}: slice '${sliceName}' requires at least ${min} item(s), found ${count}`)"
-          );
-        });
-        w.curlyBlock(["if", "(max > 0 && count > max)"], () => {
-          w.lineSM(
-            "errors.push(`${path}: slice '${sliceName}' allows at most ${max} item(s), found ${count}`)"
-          );
-        });
-        w.lineSM("return errors");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateEnum",
-        "=",
-        "(value: unknown, allowed: string[], field: string, path: string): string | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM("if (value === undefined || value === null) return undefined");
-        w.curlyBlock(["if", "(typeof value === 'string')"], () => {
-          w.lineSM(
-            "return allowed.includes(value) ? undefined : `${path}: field '${field}' value '${value}' is not in allowed values`"
-          );
-        });
-        w.lineSM("const rec = value as Record<string, unknown>");
-        w.comment("Coding");
-        w.curlyBlock(["if", "(typeof rec.code === 'string' && rec.system !== undefined)"], () => {
-          w.lineSM(
-            "return allowed.includes(rec.code) ? undefined : `${path}: field '${field}' code '${rec.code}' is not in allowed values`"
-          );
-        });
-        w.comment("CodeableConcept");
-        w.curlyBlock(["if", "(Array.isArray(rec.coding))"], () => {
-          w.lineSM(
-            "const codes = (rec.coding as Array<Record<string, unknown>>).map(c => c.code as string).filter(Boolean)"
-          );
-          w.lineSM("const hasValid = codes.some(c => allowed.includes(c))");
-          w.lineSM(
-            "return hasValid ? undefined : `${path}: field '${field}' has no coding with an allowed code`"
-          );
-        });
-        w.lineSM("return undefined");
-      }
-    );
-    w.line();
-    w.curlyBlock(
-      [
-        "export const",
-        "validateReference",
-        "=",
-        "(value: unknown, allowed: string[], field: string, path: string): string | undefined",
-        "=>"
-      ],
-      () => {
-        w.lineSM("if (value === undefined || value === null) return undefined");
-        w.lineSM("const ref = (value as Record<string, unknown>).reference as string | undefined");
-        w.lineSM("if (!ref) return undefined");
-        w.lineSM("const slashIdx = ref.indexOf('/')");
-        w.lineSM("if (slashIdx === -1) return undefined");
-        w.lineSM("const refType = ref.slice(0, slashIdx)");
-        w.lineSM(
-          "return allowed.includes(refType) ? undefined : `${path}: field '${field}' references '${refType}' but only ${allowed.join(', ')} are allowed`"
-        );
-      }
+      () => generateExtensionPush(w, targetPath, `{ url: "${ext.url}", ...value } as Extension`)
     );
+    w.line("return this");
   });
 };
-var generateProfileHelpersImport = (w, options) => {
-  const imports = [];
-  if (options.needsSliceHelpers) {
-    imports.push("applySliceMatch", "matchesSlice");
-  }
-  if (options.needsGetOrCreateObjectAtPath) {
-    imports.push("getOrCreateObjectAtPath");
-  }
-  if (options.needsExtensionExtraction) {
-    imports.push("extractComplexExtension");
-  }
-  if (options.needsSliceExtraction) {
-    imports.push("extractSliceSimplified");
-  }
-  if (options.needsSliceChoiceHelpers) {
-    imports.push("wrapSliceChoice", "flattenSliceChoice");
-  }
-  if (options.needsValidation) {
-    imports.push(
-      "validateRequired",
-      "validateExcluded",
-      "validateFixedValue",
-      "validateSliceCardinality",
-      "validateEnum",
-      "validateReference"
-    );
-  }
-  if (imports.length > 0) {
-    w.lineSM(`import { ${imports.join(", ")} } from "../../profile-helpers"`);
-  }
+var generateGenericExtensionGetter = (w, info) => {
+  const { ext, getMethodName, targetPath } = info;
+  w.curlyBlock(["public", getMethodName, "(): Extension | undefined"], () => {
+    if (targetPath.length === 0) {
+      w.line(`return this.resource.extension?.find(e => e.url === "${ext.url}")`);
+    } else {
+      w.line(
+        `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+      );
+      w.line(`return (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`);
+    }
+  });
 };
-var collectTypesFromSlices = (tsIndex, flatProfile, addType) => {
-  for (const field of Object.values(flatProfile.fields ?? {})) {
-    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) continue;
-    for (const slice of Object.values(field.slicing.slices)) {
-      if (Object.keys(slice.match ?? {}).length > 0) {
-        addType(field.type);
-        const cc = detectConstrainedChoice(tsIndex, flatProfile, field.type, slice.elements);
-        if (cc) addType(cc.variantTypeId);
-      }
+var generateExtensionMethods = (w, tsIndex, flatProfile, extensionBaseNames) => {
+  for (const ext of flatProfile.extensions ?? []) {
+    if (!ext.url) continue;
+    const baseName = tsResolvedExtensionBaseName(extensionBaseNames, ext.url, ext.path, ext.name);
+    const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
+    const extProfileInfo = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
+    const info = {
+      ext,
+      flatProfile,
+      setMethodName: `set${baseName}`,
+      getMethodName: `get${baseName}`,
+      targetPath,
+      extProfileInfo
+    };
+    if (ext.isComplex && ext.subExtensions) {
+      generateComplexExtensionSetter(w, info);
+      w.line();
+      generateComplexExtensionGetter(w, info);
+    } else if (ext.valueTypes?.length === 1 && ext.valueTypes[0]) {
+      generateSingleValueExtensionSetter(w, tsIndex, info);
+      w.line();
+      generateSingleValueExtensionGetter(w, info);
+    } else {
+      generateGenericExtensionSetter(w, info);
+      w.line();
+      generateGenericExtensionGetter(w, info);
     }
+    w.line();
   }
 };
 var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
@@ -4706,23 +4502,438 @@ var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
   }
   return needsExtensionType;
 };
-var collectTypesFromFieldOverrides = (tsIndex, flatProfile, addType) => {
-  const referenceUrl = "http://hl7.org/fhir/StructureDefinition/Reference";
-  const referenceSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, referenceUrl);
-  const specialization = tsIndex.findLastSpecialization(flatProfile);
-  if (!isSpecializationTypeSchema(specialization)) return;
-  for (const [fieldName, pField] of Object.entries(flatProfile.fields ?? {})) {
-    if (!isNotChoiceDeclarationField(pField)) continue;
+var collectTypesFromFlatInput = (tsIndex, flatProfile, addType) => {
+  if (flatProfile.base.name !== "Extension") return;
+  const subSlices = collectSubExtensionSlices(flatProfile);
+  for (const sub of subSlices) {
+    const tsType = sub.tsType;
+    if (["string", "boolean", "number"].includes(tsType)) continue;
+    const fhirUrl = `http://hl7.org/fhir/StructureDefinition/${tsType}`;
+    const schema = tsIndex.resolveByUrl(flatProfile.identifier.package, fhirUrl);
+    if (schema) addType(schema.identifier);
+  }
+};
+
+// src/api/writer-generator/typescript/profile-slices.ts
+var collectChoiceBaseNames = (tsIndex, typeId) => {
+  const names = /* @__PURE__ */ new Set();
+  const schema = tsIndex.resolve(typeId);
+  if (schema && "fields" in schema && schema.fields) {
+    for (const [name, f] of Object.entries(schema.fields)) {
+      if (isChoiceDeclarationField(f)) names.add(name);
+    }
+  }
+  return names;
+};
+var collectTypesFromSlices = (tsIndex, flatProfile, addType) => {
+  const pkgName = flatProfile.identifier.package;
+  for (const field of Object.values(flatProfile.fields ?? {})) {
+    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) continue;
+    for (const slice of Object.values(field.slicing.slices)) {
+      if (Object.keys(slice.match ?? {}).length > 0) {
+        addType(field.type);
+        const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
+        if (cc) addType(cc.variantType);
+      }
+    }
+  }
+};
+var collectRequiredSliceNames = (field) => {
+  if (!field.array || !field.slicing?.slices) return void 0;
+  const names = Object.entries(field.slicing.slices).filter(([_, s]) => s.min !== void 0 && s.min >= 1 && s.match && Object.keys(s.match).length > 0).map(([name]) => name);
+  return names.length > 0 ? names : void 0;
+};
+var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fields ?? {}).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
+  if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
+  const baseType = tsTypeFromIdentifier(field.type);
+  const pkgName = flatProfile.identifier.package;
+  const choiceBaseNames = collectChoiceBaseNames(tsIndex, field.type);
+  return Object.entries(field.slicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
+    const matchFields = Object.keys(slice.match ?? {});
+    const required = (slice.required ?? []).filter(
+      (name) => !matchFields.includes(name) && !choiceBaseNames.has(name)
+    );
+    const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
+    const constrainedChoice = cc && !isPrimitiveIdentifier(cc.variantType) ? cc : void 0;
+    return {
+      fieldName,
+      baseType,
+      sliceName,
+      match: slice.match ?? {},
+      required,
+      excluded: slice.excluded ?? [],
+      array: Boolean(field.array),
+      constrainedChoice
+    };
+  });
+});
+var generateSliceSetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
+  const profileClassName = tsProfileClassName(flatProfile);
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  for (const sliceDef of sliceDefs) {
+    const baseName = tsResolvedSliceBaseName(sliceBaseNames, sliceDef.fieldName, sliceDef.sliceName);
+    const methodName = `set${baseName}`;
+    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const matchRef = `${profileClassName}.${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
+    const tsField = tsFieldName(sliceDef.fieldName);
+    const fieldAccess = tsGet("this.resource", tsField);
+    const baseType = sliceDef.baseType;
+    const inputOptional = sliceDef.required.length === 0;
+    const unionType = `${typeName} | ${baseType}`;
+    const paramSignature = inputOptional ? `(input?: ${unionType}): this` : `(input: ${unionType}): this`;
+    w.curlyBlock(["public", methodName, paramSignature], () => {
+      w.line(`const match = ${matchRef}`);
+      w.curlyBlock(["if", "(input && matchesValue(input, match))"], () => {
+        if (sliceDef.array) {
+          w.line(`setArraySlice(${fieldAccess} ??= [], match, input as ${baseType})`);
+        } else {
+          w.line(`${fieldAccess} = input as ${baseType}`);
+        }
+        w.line("return this");
+      });
+      const inputExpr = inputOptional ? "input ?? {}" : "input";
+      if (sliceDef.constrainedChoice) {
+        const cc = sliceDef.constrainedChoice;
+        w.line(`const wrapped = wrapSliceChoice<${baseType}>(${inputExpr}, ${JSON.stringify(cc.variant)})`);
+        w.line(`const value = applySliceMatch<${baseType}>(wrapped, match)`);
+      } else {
+        w.line(`const value = applySliceMatch<${baseType}>(${inputExpr}, match)`);
+      }
+      if (sliceDef.array) {
+        w.line(`setArraySlice(${fieldAccess} ??= [], match, value)`);
+      } else {
+        w.line(`${fieldAccess} = value`);
+      }
+      w.line("return this");
+    });
+    w.line();
+  }
+};
+var generateSliceGetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
+  const profileClassName = tsProfileClassName(flatProfile);
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const defaultMode = w.opts.sliceGetterDefault ?? "flat";
+  for (const sliceDef of sliceDefs) {
+    const baseName = tsResolvedSliceBaseName(sliceBaseNames, sliceDef.fieldName, sliceDef.sliceName);
+    const getMethodName = `get${baseName}`;
+    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const matchRef = `${profileClassName}.${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
+    const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
+    const tsField = tsFieldName(sliceDef.fieldName);
+    const fieldAccess = tsGet("this.resource", tsField);
+    const baseType = sliceDef.baseType;
+    const defaultReturn = defaultMode === "raw" ? baseType : typeName;
+    w.lineSM(`public ${getMethodName}(mode: 'flat'): ${typeName} | undefined`);
+    w.lineSM(`public ${getMethodName}(mode: 'raw'): ${baseType} | undefined`);
+    w.lineSM(`public ${getMethodName}(): ${defaultReturn} | undefined`);
+    w.curlyBlock(
+      [
+        "public",
+        getMethodName,
+        `(mode: 'flat' | 'raw' = '${defaultMode}'): ${typeName} | ${baseType} | undefined`
+      ],
+      () => {
+        w.line(`const match = ${matchRef}`);
+        if (sliceDef.array) {
+          w.line(`const item = getArraySlice(${fieldAccess}, match)`);
+          w.line("if (!item) return undefined");
+        } else {
+          w.line(`const item = ${fieldAccess}`);
+          w.line("if (!item || !matchesValue(item, match)) return undefined");
+        }
+        w.line("if (mode === 'raw') return item");
+        if (sliceDef.constrainedChoice) {
+          const cc = sliceDef.constrainedChoice;
+          w.line(`return unwrapSliceChoice<${typeName}>(item, ${matchKeys}, ${JSON.stringify(cc.variant)})`);
+        } else {
+          w.line(`return stripMatchKeys<${typeName}>(item, ${matchKeys})`);
+        }
+      }
+    );
+    w.line();
+  }
+};
+
+// src/api/writer-generator/typescript/profile-validation.ts
+var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef, canonicalUrlExpr) => {
+  if (field.excluded) {
+    errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
+    return;
+  }
+  if (field.required) errors.push(`...validateRequired(res, profileName, ${JSON.stringify(name)})`);
+  if (field.valueConstraint) {
+    const valueExpr = canonicalUrlExpr && name === "url" && field.valueConstraint.value === canonicalUrlExpr.url ? canonicalUrlExpr.expr : JSON.stringify(field.valueConstraint.value);
+    errors.push(`...validateFixedValue(res, profileName, ${JSON.stringify(name)}, ${valueExpr})`);
+  }
+  if (field.enum) {
+    const target = field.enum.isOpen ? warnings : errors;
+    target.push(`...validateEnum(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.enum.values)})`);
+  }
+  if (field.mustSupport && !field.required)
+    warnings.push(`...validateMustSupport(res, profileName, ${JSON.stringify(name)})`);
+  if (field.reference && field.reference.length > 0)
+    errors.push(
+      `...validateReference(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.reference.map((ref) => resolveRef(ref).name))})`
+    );
+  if (field.slicing?.slices) {
+    for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
+      if (slice.min === void 0 && slice.max === void 0) continue;
+      const match = slice.match ?? {};
+      if (Object.keys(match).length === 0) continue;
+      const min = slice.min ?? 0;
+      const max = slice.max ?? 0;
+      errors.push(
+        `...validateSliceCardinality(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max})`
+      );
+    }
+  }
+};
+var generateValidateMethod = (w, tsIndex, flatProfile) => {
+  const fields = flatProfile.fields ?? {};
+  const profileName = flatProfile.identifier.name;
+  const canonicalUrl = flatProfile.identifier.url;
+  const canonicalUrlExpr = canonicalUrl ? { url: canonicalUrl, expr: `${tsProfileClassName(flatProfile)}.canonicalUrl` } : void 0;
+  w.curlyBlock(["validate(): { errors: string[]; warnings: string[] }"], () => {
+    w.line(`const profileName = "${profileName}"`);
+    w.line("const res = this.resource");
+    const errors = [];
+    const warnings = [];
+    for (const [name, field] of Object.entries(fields)) {
+      if (isChoiceInstanceField(field)) continue;
+      if (isChoiceDeclarationField(field)) {
+        if (field.required)
+          errors.push(`...validateChoiceRequired(res, profileName, ${JSON.stringify(field.choices)})`);
+        continue;
+      }
+      collectRegularFieldValidation(
+        errors,
+        warnings,
+        name,
+        field,
+        tsIndex.findLastSpecializationByIdentifier,
+        canonicalUrlExpr
+      );
+    }
+    const emitArray = (label, exprs) => {
+      if (exprs.length === 0) {
+        w.line(`${label}: [],`);
+      } else {
+        w.squareBlock([`${label}:`], () => {
+          for (const expr of exprs) w.line(`${expr},`);
+        }, [","]);
+      }
+    };
+    w.curlyBlock(["return"], () => {
+      emitArray("errors", errors);
+      emitArray("warnings", warnings);
+    });
+  });
+  w.line();
+};
+
+// src/api/writer-generator/typescript/profile.ts
+var collectChoiceAccessors = (flatProfile, promotedChoices) => {
+  const accessors = [];
+  for (const [name, field] of Object.entries(flatProfile.fields ?? {})) {
+    if (field.excluded) continue;
+    if (!isChoiceInstanceField(field)) continue;
+    if (promotedChoices.has(name)) continue;
+    const tsType = tsTypeFromIdentifier(field.type) + (field.array ? "[]" : "");
+    accessors.push({ name, tsType, typeId: field.type });
+  }
+  return accessors;
+};
+var tryPromoteChoice = (field, fields, params, promotedChoices) => {
+  if (!isChoiceDeclarationField(field) || !field.required || field.choices.length !== 1) return;
+  const choiceName = field.choices[0];
+  if (!choiceName) return;
+  const choiceField = fields[choiceName];
+  if (!choiceField || !isChoiceInstanceField(choiceField)) return;
+  const tsType = tsTypeFromIdentifier(choiceField.type) + (choiceField.array ? "[]" : "");
+  params.push({ name: choiceName, tsType, typeId: choiceField.type });
+  promotedChoices.add(choiceName);
+};
+var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
+  const autoFields = [];
+  const sliceAutoFields = [];
+  const params = [];
+  const autoAccessors = [];
+  const fields = flatProfile.fields ?? {};
+  const promotedChoices = /* @__PURE__ */ new Set();
+  const resolveRef = tsIndex.findLastSpecializationByIdentifier;
+  if (isResourceIdentifier(flatProfile.base)) {
+    autoFields.push({ name: "resourceType", value: JSON.stringify(flatProfile.base.name) });
+  }
+  for (const [name, field] of Object.entries(fields)) {
+    if (field.excluded) continue;
+    if (isChoiceInstanceField(field)) continue;
+    if (isChoiceDeclarationField(field)) {
+      tryPromoteChoice(field, fields, params, promotedChoices);
+      continue;
+    }
+    if (field.valueConstraint) {
+      const value = JSON.stringify(field.valueConstraint.value);
+      autoFields.push({ name, value: field.array ? `[${value}]` : value });
+      if (isNotChoiceDeclarationField(field) && field.type) {
+        const tsType = fieldTsType(field, resolveRef);
+        autoAccessors.push({ name, tsType, typeId: field.type });
+      }
+      continue;
+    }
+    if (isNotChoiceDeclarationField(field)) {
+      const sliceNames = collectRequiredSliceNames(field);
+      if (sliceNames) {
+        if (field.type) {
+          const tsType = fieldTsType(field, resolveRef);
+          sliceAutoFields.push({
+            name,
+            tsType,
+            typeId: field.type,
+            sliceNames
+          });
+          autoAccessors.push({ name, tsType, typeId: field.type });
+        }
+        continue;
+      }
+    }
+    if (field.required) {
+      const tsType = fieldTsType(field, resolveRef);
+      params.push({ name, tsType, typeId: field.type });
+    }
+  }
+  collectBaseRequiredParams(tsIndex, flatProfile, resolveRef, params, [
+    ...autoFields.map((f) => f.name),
+    ...sliceAutoFields.map((f) => f.name),
+    ...params.map((f) => f.name),
+    ...promotedChoices
+  ]);
+  const accessors = [...autoAccessors, ...collectChoiceAccessors(flatProfile, promotedChoices)];
+  return { autoFields, sliceAutoFields, params, accessors };
+};
+var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames) => {
+  const covered = new Set(coveredNames);
+  const baseSchema = tsIndex.resolve(flatProfile.base);
+  if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
+  for (const [name, field] of Object.entries(baseSchema.fields)) {
+    if (covered.has(name)) continue;
+    if (!field.required) continue;
+    if (isChoiceInstanceField(field)) continue;
+    if (isChoiceDeclarationField(field)) continue;
+    if (isNotChoiceDeclarationField(field) && field.type) {
+      const tsType = fieldTsType(field, resolveRef);
+      params.push({ name, tsType, typeId: field.type });
+    }
+  }
+};
+var generateProfileIndexFile = (w, tsIndex, initialProfiles) => {
+  if (initialProfiles.length === 0) return;
+  w.cd("profiles", () => {
+    w.cat("index.ts", () => {
+      const profiles = initialProfiles.map((profile) => {
+        const className = tsProfileClassName(profile);
+        const resourceName = tsResourceName(profile.identifier);
+        const overrides = detectFieldOverrides(tsIndex, profile);
+        let typeExport;
+        if (overrides.size > 0) typeExport = resourceName;
+        return [profile, className, typeExport];
+      });
+      if (profiles.length === 0) return;
+      const classExports = /* @__PURE__ */ new Map();
+      const typeExports = /* @__PURE__ */ new Map();
+      for (const [profile, className, typeName] of profiles) {
+        const moduleName = tsProfileModuleName(tsIndex, profile);
+        if (!classExports.has(className)) {
+          classExports.set(className, `export { ${className} } from "./${moduleName}"`);
+        }
+        if (typeName && !typeExports.has(typeName) && !classExports.has(typeName)) {
+          typeExports.set(typeName, `export type { ${typeName} } from "./${moduleName}"`);
+        }
+      }
+      const allExports = [...classExports.values(), ...typeExports.values()].sort();
+      for (const exp of allExports) {
+        w.lineSM(exp);
+      }
+    });
+  });
+};
+var tsTypeForProfileField = (tsIndex, flatProfile, fieldName, field) => {
+  if (!isNotChoiceDeclarationField(field)) {
+    throw new Error(`Choice declaration fields not supported for '${fieldName}'`);
+  }
+  let tsType;
+  if (field.enum) {
+    if (field.type?.name === "Coding") {
+      tsType = `Coding<${tsEnumType(field.enum)}>`;
+    } else if (field.type?.name === "CodeableConcept") {
+      tsType = `CodeableConcept<${tsEnumType(field.enum)}>`;
+    } else {
+      tsType = tsEnumType(field.enum);
+    }
+  } else if (field.reference && field.reference.length > 0) {
+    const specialization = tsIndex.findLastSpecialization(flatProfile);
+    if (!isSpecializationTypeSchema(specialization))
+      throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
     const sField = specialization.fields?.[fieldName];
-    if (!sField || isChoiceDeclarationField(sField)) continue;
-    if (pField.reference && sField.reference && pField.reference.length < sField.reference.length) {
-      if (referenceSchema) addType(referenceSchema.identifier);
-    } else if (pField.required && !sField.required && pField.type) {
-      addType(pField.type);
+    if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
+      throw new Error(`Invalid field declaration for ${fieldName}`);
+    const sRefs = sField.reference.map((e) => e.name);
+    const references = field.reference.map((ref) => {
+      const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
+      if (resRef.name !== ref.name) {
+        return `"${resRef.name}" /*${ref.name}*/`;
+      }
+      return `'${ref.name}'`;
+    }).join(" | ");
+    if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
+      const cleanRefs = references.replace(/\/\*[^*]*\*\//g, "").trim();
+      tsType = `Reference<"Resource" /* ${cleanRefs} */ >`;
+    } else {
+      tsType = `Reference<${references}>`;
     }
+  } else if (isPrimitiveIdentifier(field.type)) {
+    tsType = resolvePrimitiveType(field.type.name);
+  } else if (isNestedIdentifier(field.type)) {
+    tsType = tsResourceName(field.type);
+  } else if (field.type === void 0) {
+    throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
+  } else {
+    tsType = field.type.name;
+  }
+  return tsType;
+};
+var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryInfo) => {
+  const extensions = flatProfile.extensions ?? [];
+  const hasMeta = tsIndex.isWithMetaField(flatProfile);
+  const canonicalUrl = flatProfile.identifier.url;
+  const imports = [];
+  if (!isPrimitiveIdentifier(flatProfile.base)) imports.push("buildResource");
+  if (flatProfile.base.name === "Extension" && !!canonicalUrl && collectSubExtensionSlices(flatProfile).length > 0)
+    imports.push("isRawExtensionInput");
+  if (canonicalUrl && hasMeta) imports.push("ensureProfile");
+  if (sliceDefs.length > 0 || factoryInfo.sliceAutoFields.length > 0)
+    imports.push("applySliceMatch", "matchesValue", "setArraySlice", "getArraySlice", "ensureSliceDefaults");
+  if (extensions.some((ext) => ext.path.split(".").some((s) => s !== "extension"))) imports.push("ensurePath");
+  if (extensions.some((ext) => ext.isComplex && ext.subExtensions)) imports.push("extractComplexExtension");
+  if (sliceDefs.length > 0) imports.push("stripMatchKeys");
+  if (sliceDefs.some((s) => s.constrainedChoice)) imports.push("wrapSliceChoice", "unwrapSliceChoice");
+  if (extensions.some((ext) => ext.url)) imports.push("isExtension", "getExtensionValue", "pushExtension");
+  if (Object.keys(flatProfile.fields ?? {}).length > 0)
+    imports.push(
+      "validateRequired",
+      "validateExcluded",
+      "validateFixedValue",
+      "validateSliceCardinality",
+      "validateEnum",
+      "validateReference",
+      "validateChoiceRequired",
+      "validateMustSupport"
+    );
+  if (imports.length > 0) {
+    w.tsImport("../../profile-helpers", ...imports);
+    w.line();
   }
 };
-var generateProfileImports = (w, tsIndex, flatProfile) => {
+var generateProfileImports = (w, tsIndex, flatProfile, overrides) => {
   const usedTypes = /* @__PURE__ */ new Map();
   const getModulePath = (typeId) => {
     if (isNestedIdentifier(typeId)) {
@@ -4741,8 +4952,9 @@ var generateProfileImports = (w, tsIndex, flatProfile) => {
   addType(flatProfile.base);
   collectTypesFromSlices(tsIndex, flatProfile, addType);
   const needsExtensionType = collectTypesFromExtensions(tsIndex, flatProfile, addType);
-  collectTypesFromFieldOverrides(tsIndex, flatProfile, addType);
-  const factoryInfo = collectProfileFactoryInfo(flatProfile);
+  for (const { typeId } of overrides.values()) addType(typeId);
+  collectTypesFromFlatInput(tsIndex, flatProfile, addType);
+  const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
   for (const param of factoryInfo.params) addType(param.typeId);
   for (const f of factoryInfo.sliceAutoFields) addType(f.typeId);
   for (const accessor of factoryInfo.accessors) addType(accessor.typeId);
@@ -4751,616 +4963,398 @@ var generateProfileImports = (w, tsIndex, flatProfile) => {
     const extensionSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, extensionUrl);
     if (extensionSchema) addType(extensionSchema.identifier);
   }
-  const sortedImports = Array.from(usedTypes.values()).sort((a, b) => a.tsName.localeCompare(b.tsName));
-  for (const { importPath, tsName } of sortedImports) {
-    w.tsImportType(importPath, tsName);
-  }
-  if (sortedImports.length > 0) w.line();
-};
-var collectExtSliceMethodSuffixes = (extensions, extensionMethodNames) => {
-  const suffixes = /* @__PURE__ */ new Set();
-  for (const name of extensionMethodNames.values()) {
-    suffixes.add(name.replace(/^set/, ""));
-  }
-  for (const ext of extensions) {
-    if (ext.url) suffixes.add(uppercaseFirstLetter(tsCamelCase(ext.name)));
-  }
-  return suffixes;
-};
-var detectConstrainedChoice = (tsIndex, flatProfile, sliceBaseTypeId, sliceElements) => {
-  if (!sliceElements) return void 0;
-  const baseSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, sliceBaseTypeId.url);
-  if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return void 0;
-  for (const [fieldName, field] of Object.entries(baseSchema.fields)) {
-    if (!isChoiceDeclarationField(field)) continue;
-    const matchingVariants = field.choices.filter((c) => sliceElements.includes(c));
-    if (matchingVariants.length !== 1) continue;
-    const variantName = matchingVariants[0];
-    const variantField = baseSchema.fields[variantName];
-    if (!variantField || !isChoiceInstanceField(variantField)) continue;
-    return {
-      choiceBase: fieldName,
-      variant: variantName,
-      variantType: tsTypeFromIdentifier(variantField.type),
-      variantTypeId: variantField.type,
-      allChoiceNames: field.choices
-    };
-  }
-  return void 0;
-};
-var generateProfileClass = (w, tsIndex, flatProfile, schema) => {
-  const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
-  const tsProfileName = tsResourceName(flatProfile.identifier);
-  const profileClassName = tsProfileClassName(flatProfile);
-  const polymorphicBaseNames = /* @__PURE__ */ new Set([
-    "value",
-    "effective",
-    "onset",
-    "abatement",
-    "occurrence",
-    "timing",
-    "deceased",
-    "born",
-    "age",
-    "medication",
-    "performed",
-    "serviced",
-    "collected",
-    "item",
-    "subject",
-    "bounds",
-    "amount",
-    "content",
-    "product",
-    "rate",
-    "dose",
-    "asNeeded"
-  ]);
-  const sliceDefs = Object.entries(flatProfile.fields ?? {}).filter(([_fieldName, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
-    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
-    const baseType = tsTypeFromIdentifier(field.type);
-    return Object.entries(field.slicing.slices).filter(([_sliceName, slice]) => {
-      const match = slice.match ?? {};
-      return Object.keys(match).length > 0;
-    }).map(([sliceName, slice]) => {
-      const matchFields = Object.keys(slice.match ?? {});
-      const required = slice.required ?? [];
-      const filteredRequired = required.filter(
-        (name) => !matchFields.includes(name) && !polymorphicBaseNames.has(name)
-      );
-      const constrainedChoice = detectConstrainedChoice(tsIndex, flatProfile, field.type, slice.elements);
-      return {
-        fieldName,
-        baseType,
-        sliceName,
-        match: slice.match ?? {},
-        required,
-        excluded: slice.excluded ?? [],
-        array: Boolean(field.array),
-        // Input is optional when there are no required fields after filtering
-        inputOptional: filteredRequired.length === 0,
-        constrainedChoice
-      };
-    });
-  });
-  const extensions = flatProfile.extensions ?? [];
-  const complexExtensions = extensions.filter((ext) => ext.isComplex && ext.subExtensions);
-  for (const ext of complexExtensions) {
-    const typeName = tsExtensionInputTypeName(tsProfileName, ext.name);
-    w.curlyBlock(["export", "type", typeName, "="], () => {
-      for (const sub of ext.subExtensions ?? []) {
-        const tsType = sub.valueType ? tsTypeFromIdentifier(sub.valueType) : "unknown";
-        const isArray = sub.max === "*";
-        const isRequired2 = sub.min !== void 0 && sub.min > 0;
-        w.lineSM(`${sub.name}${isRequired2 ? "" : "?"}: ${tsType}${isArray ? "[]" : ""}`);
-      }
-    });
-    w.line();
-  }
-  if (sliceDefs.length > 0) {
-    for (const sliceDef of sliceDefs) {
-      const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
-      const matchFields = Object.keys(sliceDef.match);
-      const allExcluded = [.../* @__PURE__ */ new Set([...sliceDef.excluded, ...matchFields])];
-      if (sliceDef.constrainedChoice) {
-        const cc = sliceDef.constrainedChoice;
-        allExcluded.push(cc.choiceBase);
-        for (const name of cc.allChoiceNames) {
-          if (!allExcluded.includes(name)) allExcluded.push(name);
-        }
-      }
-      const excludedNames = allExcluded.map((name) => JSON.stringify(name));
-      const filteredRequired = sliceDef.required.filter(
-        (name) => !matchFields.includes(name) && !polymorphicBaseNames.has(name)
-      );
-      const requiredNames = filteredRequired.map((name) => JSON.stringify(name));
-      let typeExpr = sliceDef.baseType;
-      if (excludedNames.length > 0) {
-        typeExpr = `Omit<${typeExpr}, ${excludedNames.join(" | ")}>`;
-      }
-      if (requiredNames.length > 0) {
-        typeExpr = `${typeExpr} & Required<Pick<${sliceDef.baseType}, ${requiredNames.join(" | ")}>>`;
-      }
-      if (sliceDef.constrainedChoice) {
-        typeExpr = `${typeExpr} & ${sliceDef.constrainedChoice.variantType}`;
-      }
-      w.lineSM(`export type ${typeName} = ${typeExpr}`);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const { importPath, tsName } of usedTypes.values()) {
+    let names = grouped.get(importPath);
+    if (!names) {
+      names = [];
+      grouped.set(importPath, names);
+    }
+    names.push(tsName);
+  }
+  const sortedModules = [...grouped.entries()].sort(([a], [b]) => a.localeCompare(b));
+  for (const [importPath, names] of sortedModules) {
+    w.tsImport(importPath, ...names.sort(), { typeOnly: true });
+  }
+  if (sortedModules.length > 0) w.line();
+  const extProfileImports = /* @__PURE__ */ new Map();
+  for (const ext of flatProfile.extensions ?? []) {
+    if (!ext.url) continue;
+    const info = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
+    if (!info) continue;
+    if (!extProfileImports.has(info.className)) {
+      const hasFlatInput = collectSubExtensionSlices(info.flatProfile).length > 0;
+      extProfileImports.set(info.className, { modulePath: info.modulePath, hasFlatInput });
     }
-    w.line();
   }
-  const hasOverrideInterface = detectFieldOverrides(w, tsIndex, flatProfile).size > 0;
-  const factoryInfo = collectProfileFactoryInfo(flatProfile);
-  const needsSliceHelpers = sliceDefs.length > 0 || factoryInfo.sliceAutoFields.length > 0;
-  const extensionsWithNestedPath = extensions.filter((ext) => {
-    const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
-    return targetPath.length > 0;
-  });
-  const needsGetOrCreateObjectAtPath = extensionsWithNestedPath.length > 0;
-  const needsExtensionExtraction = complexExtensions.length > 0;
-  const needsSliceExtraction = sliceDefs.length > 0;
-  const needsSliceChoiceHelpers = sliceDefs.some((s) => s.constrainedChoice);
-  const needsValidation = Object.keys(flatProfile.fields ?? {}).length > 0;
-  if (needsSliceHelpers || needsGetOrCreateObjectAtPath || needsExtensionExtraction || needsSliceExtraction || needsSliceChoiceHelpers || needsValidation) {
-    generateProfileHelpersImport(w, {
-      needsGetOrCreateObjectAtPath,
-      needsSliceHelpers,
-      needsExtensionExtraction,
-      needsSliceExtraction,
-      needsSliceChoiceHelpers,
-      needsValidation
-    });
-    w.line();
+  for (const [className, { modulePath, hasFlatInput }] of [...extProfileImports.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const imports = [className, ...hasFlatInput ? [`type ${className}Flat`] : []];
+    w.tsImport(modulePath, ...imports);
+  }
+  if (extProfileImports.size > 0) w.line();
+};
+var generateStaticSliceFields = (w, sliceDefs) => {
+  for (const sliceDef of sliceDefs) {
+    const staticName = `${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
+    w.lineSM(`private static readonly ${staticName}: Record<string, unknown> = ${JSON.stringify(sliceDef.match)}`);
   }
+  if (sliceDefs.length > 0) w.line();
+};
+var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
+  const profileClassName = tsProfileClassName(flatProfile);
+  const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
+  const hasMeta = tsIndex.isWithMetaField(flatProfile);
   const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
-  const createArgsTypeName = `${profileClassName}Params`;
+  const createArgsTypeName = `${profileClassName}Raw`;
   const paramSignature = hasParams ? `args: ${createArgsTypeName}` : "";
   const allFields = [
     ...factoryInfo.autoFields.map((f) => ({ name: f.name, value: f.value })),
     ...factoryInfo.sliceAutoFields.map((f) => ({ name: f.name, value: `${f.name}WithDefaults` })),
     ...factoryInfo.params.map((p) => ({ name: p.name, value: `args.${p.name}` }))
   ];
-  if (hasParams) {
-    w.curlyBlock(["export", "type", createArgsTypeName, "="], () => {
-      for (const p of factoryInfo.params) {
-        w.lineSM(`${p.name}: ${p.tsType}`);
-      }
-      for (const f of factoryInfo.sliceAutoFields) {
-        w.lineSM(`${f.name}?: ${f.tsType}`);
-      }
-    });
-    w.line();
-  }
-  const canonicalUrl = schema?.identifier.url;
-  if (schema) {
-    w.comment("CanonicalURL:", schema.identifier.url, `(pkg: ${packageMetaToFhir(packageMeta(schema))})`);
-  }
-  w.curlyBlock(["export", "class", profileClassName], () => {
-    if (canonicalUrl) {
-      w.line(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
-      w.line();
-    }
-    w.line(`private resource: ${tsBaseResourceName}`);
-    w.line();
-    w.curlyBlock(["constructor", `(resource: ${tsBaseResourceName})`], () => {
-      w.line("this.resource = resource");
-      if (canonicalUrl && isResourceIdentifier(flatProfile.base)) {
-        w.line(`const r = resource as unknown as Record<string, unknown>`);
-        w.line(`const meta = (r.meta ??= {}) as Record<string, unknown>`);
-        w.line(`const profiles = (meta.profile ??= []) as string[]`);
+  w.curlyBlock(["constructor", `(resource: ${tsBaseResourceName})`], () => {
+    w.lineSM("this.resource = resource");
+  });
+  w.line();
+  w.curlyBlock(["static", "from", `(resource: ${tsBaseResourceName})`, `: ${profileClassName}`], () => {
+    if (hasMeta) {
+      w.curlyBlock(["if", `(!resource.meta?.profile?.includes(${profileClassName}.canonicalUrl))`], () => {
         w.line(
-          `if (!profiles.includes(${JSON.stringify(canonicalUrl)})) profiles.push(${JSON.stringify(canonicalUrl)})`
+          `throw new Error(\`${profileClassName}: meta.profile must include \${${profileClassName}.canonicalUrl}\`)`
+        );
+      });
+    }
+    w.lineSM(`const profile = new ${profileClassName}(resource)`);
+    w.lineSM("const { errors } = profile.validate()");
+    w.line(`if (errors.length > 0) throw new Error(errors.join("; "))`);
+    w.lineSM("return profile");
+  });
+  w.line();
+  w.curlyBlock(["static", "apply", `(resource: ${tsBaseResourceName})`, `: ${profileClassName}`], () => {
+    if (hasMeta) {
+      w.lineSM(`ensureProfile(resource, ${profileClassName}.canonicalUrl)`);
+    }
+    w.lineSM(`return new ${profileClassName}(resource)`);
+  });
+  w.line();
+  const subSlicesForInput = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+  const hasInputHelper = subSlicesForInput.length > 0;
+  if (hasInputHelper) {
+    const rawInputTypeName = `${profileClassName}Raw`;
+    const inputTypeName = `${profileClassName}Flat`;
+    w.curlyBlock(
+      ["private static", "resolveInput", `(args: ${rawInputTypeName} | ${inputTypeName})`, ": Extension[]"],
+      () => {
+        w.ifElseChain(
+          [
+            {
+              cond: `isRawExtensionInput<${rawInputTypeName}>(args)`,
+              body: () => w.lineSM("return args.extension ?? []")
+            }
+          ],
+          () => {
+            w.lineSM("const result: Extension[] = []");
+            for (const sub of subSlicesForInput) {
+              if (sub.isArray) {
+                w.curlyBlock(["if", `(args.${sub.name})`], () => {
+                  w.curlyBlock(["for", `(const item of args.${sub.name})`], () => {
+                    w.lineSM(
+                      `result.push({ url: "${sub.url}", ${sub.valueField}: item } as Extension)`
+                    );
+                  });
+                });
+              } else {
+                w.curlyBlock(["if", `(args.${sub.name} !== undefined)`], () => {
+                  w.lineSM(
+                    `result.push({ url: "${sub.url}", ${sub.valueField}: args.${sub.name} } as Extension)`
+                  );
+                });
+              }
+            }
+            w.lineSM("return result");
+          }
         );
       }
-    });
-    w.line();
-    w.curlyBlock(["static", "from", `(resource: ${tsBaseResourceName})`, `: ${profileClassName}`], () => {
-      w.line(`return new ${profileClassName}(resource)`);
-    });
+    );
     w.line();
-    w.curlyBlock(["static", "createResource", `(${paramSignature})`, `: ${tsBaseResourceName}`], () => {
-      for (const f of factoryInfo.sliceAutoFields) {
-        const matchExprs = f.matches.map((m) => `${m} as Record<string, unknown>`);
-        w.line(`const ${f.name}Defaults = ${f.defaultValue} as unknown[]`);
-        w.line(`const ${f.name}WithDefaults = [...(args.${f.name} ?? [])] as unknown[]`);
-        for (let i = 0; i < matchExprs.length; i++) {
-          w.line(
-            `if (!${f.name}WithDefaults.some(item => matchesSlice(item, ${matchExprs[i]}))) ${f.name}WithDefaults.push(${f.name}Defaults[${i}]!)`
-          );
-        }
+    const createResourceSig = hasParams ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
+    w.curlyBlock(["static", "createResource", `(${createResourceSig})`, `: ${tsBaseResourceName}`], () => {
+      w.lineSM(`const resolvedExtensions = ${profileClassName}.resolveInput(args ?? {})`);
+      const extSliceField = factoryInfo.sliceAutoFields.find((f) => f.name === "extension");
+      if (extSliceField) {
+        const matchRefs = extSliceField.sliceNames.map(
+          (s) => `${profileClassName}.${tsSliceStaticName(s)}SliceMatch`
+        );
+        w.line("const extensionWithDefaults = ensureSliceDefaults(");
+        w.indentBlock(() => {
+          w.line("resolvedExtensions,");
+          for (const ref of matchRefs) {
+            w.line(`${ref},`);
+          }
+        });
+        w.lineSM(")");
       }
-      w.curlyBlock([`const resource: ${tsBaseResourceName} =`], () => {
+      w.line();
+      const extensionVar = extSliceField ? "extensionWithDefaults" : "resolvedExtensions";
+      w.curlyBlock([`const resource = buildResource<${tsBaseResourceName}>(`], () => {
         for (const f of allFields) {
+          if (f.name === "extension") continue;
           w.line(`${f.name}: ${f.value},`);
         }
-        if (canonicalUrl && isResourceIdentifier(flatProfile.base)) {
-          w.line(`meta: { profile: [${JSON.stringify(canonicalUrl)}] },`);
+        w.line(`extension: ${extensionVar},`);
+        if (hasMeta) {
+          w.line(`meta: { profile: [${profileClassName}.canonicalUrl] },`);
         }
-      }, [` as unknown as ${tsBaseResourceName}`]);
-      w.line("return resource");
-    });
-    w.line();
-    w.curlyBlock(["static", "create", `(${paramSignature})`, `: ${profileClassName}`], () => {
-      w.line(`return ${profileClassName}.from(${profileClassName}.createResource(${hasParams ? "args" : ""}))`);
+      }, [")"]);
+      w.lineSM("return resource");
     });
     w.line();
-    w.curlyBlock(["toResource", "()", `: ${tsBaseResourceName}`], () => {
-      w.line("return this.resource");
+    const createSig = hasParams ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
+    w.curlyBlock(["static", "create", `(${createSig})`, `: ${profileClassName}`], () => {
+      w.lineSM(`return ${profileClassName}.apply(${profileClassName}.createResource(args))`);
     });
-    w.line();
-    for (const p of factoryInfo.params) {
-      const methodSuffix = uppercaseFirstLetter(p.name);
-      w.curlyBlock([`get${methodSuffix}`, "()", `: ${p.tsType} | undefined`], () => {
-        w.line(`return this.resource.${p.name} as ${p.tsType} | undefined`);
-      });
-      w.line();
-      w.curlyBlock([`set${methodSuffix}`, `(value: ${p.tsType})`, ": this"], () => {
-        w.line(`Object.assign(this.resource, { ${p.name}: value })`);
-        w.line("return this");
-      });
-      w.line();
-    }
-    const extensionMethods = extensions.filter((ext) => ext.url).map((ext) => ({
-      ext,
-      baseName: tsExtensionMethodName(ext.name),
-      fallbackName: tsQualifiedExtensionMethodName(ext.name, ext.path)
-    }));
-    const sliceMethodBases = sliceDefs.map((slice) => tsSliceMethodName(slice.sliceName));
-    const methodCounts = /* @__PURE__ */ new Map();
-    for (const name of [...sliceMethodBases, ...extensionMethods.map((m) => m.baseName)]) {
-      methodCounts.set(name, (methodCounts.get(name) ?? 0) + 1);
-    }
-    const extensionMethodNames = new Map(
-      extensionMethods.map((entry) => [
-        entry.ext,
-        (methodCounts.get(entry.baseName) ?? 0) > 1 ? entry.fallbackName : entry.baseName
-      ])
-    );
-    const sliceMethodNames = new Map(
-      sliceDefs.map((slice) => {
-        const baseName = tsSliceMethodName(slice.sliceName);
-        const needsFallback = (methodCounts.get(baseName) ?? 0) > 1;
-        const fallback = tsQualifiedSliceMethodName(slice.fieldName, slice.sliceName);
-        return [slice, needsFallback ? fallback : baseName];
-      })
-    );
-    const extSliceMethodSuffixes = collectExtSliceMethodSuffixes(extensions, extensionMethodNames);
-    for (const a of factoryInfo.accessors) {
-      const methodSuffix = uppercaseFirstLetter(tsCamelCase(a.name));
-      if (extSliceMethodSuffixes.has(methodSuffix)) continue;
-      const fieldAccess = tsFieldName(a.name);
-      w.curlyBlock([`get${methodSuffix}`, "()", `: ${a.tsType} | undefined`], () => {
-        w.line(`return ${tsGet("this.resource", fieldAccess)} as ${a.tsType} | undefined`);
-      });
-      w.line();
-      w.curlyBlock([`set${methodSuffix}`, `(value: ${a.tsType})`, ": this"], () => {
-        w.line(`Object.assign(this.resource, { ${fieldAccess}: value })`);
-        w.line("return this");
-      });
-      w.line();
-    }
-    if (hasOverrideInterface) {
-      w.curlyBlock(["toProfile", "()", `: ${tsProfileName}`], () => {
-        w.line(`return this.resource as ${tsProfileName}`);
-      });
-      w.line();
-    }
-    generateExtensionSetterMethods(w, extensions, extensionMethodNames, tsProfileName);
-    for (const sliceDef of sliceDefs) {
-      const methodName = sliceMethodNames.get(sliceDef) ?? tsQualifiedSliceMethodName(sliceDef.fieldName, sliceDef.sliceName);
-      const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
-      const matchLiteral = JSON.stringify(sliceDef.match);
-      const tsField = tsFieldName(sliceDef.fieldName);
-      const fieldAccess = tsGet("this.resource", tsField);
-      const paramSignature2 = sliceDef.inputOptional ? `(input?: ${typeName}): this` : `(input: ${typeName}): this`;
-      w.curlyBlock(["public", methodName, paramSignature2], () => {
-        w.line(`const match = ${matchLiteral} as Record<string, unknown>`);
-        const inputExpr = sliceDef.inputOptional ? "(input ?? {}) as Record<string, unknown>" : "input as Record<string, unknown>";
-        if (sliceDef.constrainedChoice) {
-          const cc = sliceDef.constrainedChoice;
-          w.line(
-            `const value = applySliceMatch(wrapSliceChoice(${inputExpr}, ${JSON.stringify(cc.variant)}), match) as unknown as ${sliceDef.baseType}`
-          );
-        } else {
-          w.line(`const value = applySliceMatch(${inputExpr}, match) as unknown as ${sliceDef.baseType}`);
-        }
-        if (sliceDef.array) {
-          w.line(`const list = (${fieldAccess} ??= [])`);
-          w.line("const index = list.findIndex((item) => matchesSlice(item, match))");
-          w.line("if (index === -1) {");
-          w.indentBlock(() => {
-            w.line("list.push(value)");
-          });
-          w.line("} else {");
-          w.indentBlock(() => {
-            w.line("list[index] = value");
-          });
-          w.line("}");
-        } else {
-          w.line(`${fieldAccess} = value`);
-        }
-        w.line("return this");
-      });
-      w.line();
-    }
-    const generatedGetMethods = /* @__PURE__ */ new Set();
-    for (const ext of extensions) {
-      if (!ext.url) continue;
-      const baseName = uppercaseFirstLetter(tsCamelCase(ext.name));
-      const getMethodName = `get${baseName}`;
-      const getExtensionMethodName = `get${baseName}Extension`;
-      if (generatedGetMethods.has(getMethodName)) continue;
-      generatedGetMethods.add(getMethodName);
-      const valueTypes = ext.valueTypes ?? [];
-      const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
-      const generateExtLookup = () => {
-        if (targetPath.length === 0) {
-          w.line(`const ext = this.resource.extension?.find(e => e.url === "${ext.url}")`);
-        } else {
-          w.line(
-            `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
-          );
-          w.line(
-            `const ext = (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`
-          );
-        }
-      };
-      if (ext.isComplex && ext.subExtensions) {
-        const inputTypeName = tsExtensionInputTypeName(tsProfileName, ext.name);
-        w.curlyBlock(["public", getMethodName, `(): ${inputTypeName} | undefined`], () => {
-          generateExtLookup();
-          w.line("if (!ext) return undefined");
-          const configItems = (ext.subExtensions ?? []).map((sub) => {
-            const valueField = sub.valueType ? `value${uppercaseFirstLetter(sub.valueType.name)}` : "value";
-            const isArray = sub.max === "*";
-            return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
-          });
-          w.line(`const config = [${configItems.join(", ")}]`);
-          w.line(
-            `return extractComplexExtension(ext as unknown as { extension?: Array<{ url?: string; [key: string]: unknown }> }, config) as ${inputTypeName}`
-          );
-        });
-        w.line();
-        w.curlyBlock(["public", getExtensionMethodName, "(): Extension | undefined"], () => {
-          generateExtLookup();
-          w.line("return ext");
-        });
-      } else if (valueTypes.length === 1 && valueTypes[0]) {
-        const firstValueType = valueTypes[0];
-        const valueType = tsTypeFromIdentifier(firstValueType);
-        const valueField = `value${uppercaseFirstLetter(firstValueType.name)}`;
-        w.curlyBlock(["public", getMethodName, `(): ${valueType} | undefined`], () => {
-          generateExtLookup();
-          w.line(
-            `return (ext as Record<string, unknown> | undefined)?.${valueField} as ${valueType} | undefined`
-          );
+  } else {
+    w.curlyBlock(["static", "createResource", `(${paramSignature})`, `: ${tsBaseResourceName}`], () => {
+      for (const f of factoryInfo.sliceAutoFields) {
+        const matchRefs = f.sliceNames.map((s) => `${profileClassName}.${tsSliceStaticName(s)}SliceMatch`);
+        w.line(`const ${f.name}WithDefaults = ensureSliceDefaults(`);
+        w.indentBlock(() => {
+          w.line(`[...(args.${f.name} ?? [])],`);
+          for (const ref of matchRefs) {
+            w.line(`${ref},`);
+          }
         });
+        w.lineSM(")");
+      }
+      if (factoryInfo.sliceAutoFields.length > 0) {
         w.line();
-        w.curlyBlock(["public", getExtensionMethodName, "(): Extension | undefined"], () => {
-          generateExtLookup();
-          w.line("return ext");
-        });
+      }
+      if (isPrimitiveIdentifier(flatProfile.base)) {
+        w.lineSM(`const resource = undefined as unknown as ${tsBaseResourceName}`);
       } else {
-        w.curlyBlock(["public", getMethodName, "(): Extension | undefined"], () => {
-          if (targetPath.length === 0) {
-            w.line(`return this.resource.extension?.find(e => e.url === "${ext.url}")`);
-          } else {
-            w.line(
-              `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
-            );
-            w.line(
-              `return (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`
-            );
+        w.curlyBlock([`const resource = buildResource<${tsBaseResourceName}>(`], () => {
+          for (const f of allFields) {
+            w.line(`${f.name}: ${f.value},`);
           }
-        });
+          if (hasMeta) {
+            w.line(`meta: { profile: [${profileClassName}.canonicalUrl] },`);
+          }
+        }, [")"]);
       }
-      w.line();
-    }
-    for (const sliceDef of sliceDefs) {
-      const baseName = uppercaseFirstLetter(normalizeTsName(sliceDef.sliceName));
-      const getMethodName = `get${baseName}`;
-      const getRawMethodName = `get${baseName}Raw`;
-      if (generatedGetMethods.has(getMethodName)) continue;
-      generatedGetMethods.add(getMethodName);
-      const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
-      const matchLiteral = JSON.stringify(sliceDef.match);
-      const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
-      const tsField = tsFieldName(sliceDef.fieldName);
-      const fieldAccess = tsGet("this.resource", tsField);
-      const baseType = sliceDef.baseType;
-      const generateSliceLookup = () => {
-        w.line(`const match = ${matchLiteral} as Record<string, unknown>`);
-        if (sliceDef.array) {
-          w.line(`const list = ${fieldAccess}`);
-          w.line("if (!list) return undefined");
-          w.line("const item = list.find((item) => matchesSlice(item, match))");
-        } else {
-          w.line(`const item = ${fieldAccess}`);
-          w.line("if (!item || !matchesSlice(item, match)) return undefined");
-        }
-      };
-      w.curlyBlock(["public", getMethodName, `(): ${typeName} | undefined`], () => {
-        generateSliceLookup();
-        if (sliceDef.array) {
-          w.line("if (!item) return undefined");
-        }
-        if (sliceDef.constrainedChoice) {
-          const cc = sliceDef.constrainedChoice;
-          w.line(
-            `return flattenSliceChoice(item as unknown as Record<string, unknown>, ${matchKeys}, ${JSON.stringify(cc.variant)}) as ${typeName}`
-          );
-        } else {
-          w.line(
-            `return extractSliceSimplified(item as unknown as Record<string, unknown>, ${matchKeys}) as ${typeName}`
-          );
-        }
-      });
-      w.line();
-      w.curlyBlock(["public", getRawMethodName, `(): ${baseType} | undefined`], () => {
-        generateSliceLookup();
-        if (sliceDef.array) {
-          w.line("return item");
-        } else {
-          w.line("return item");
-        }
-      });
-      w.line();
-    }
-    generateValidateMethod(w, flatProfile);
+      w.lineSM("return resource");
+    });
+    w.line();
+    w.curlyBlock(["static", "create", `(${paramSignature})`, `: ${profileClassName}`], () => {
+      w.lineSM(
+        `return ${profileClassName}.apply(${profileClassName}.createResource(${hasParams ? "args" : ""}))`
+      );
+    });
+  }
+  w.line();
+  w.curlyBlock(["toResource", "()", `: ${tsBaseResourceName}`], () => {
+    w.lineSM("return this.resource");
   });
   w.line();
 };
-var emitRegularFieldValidation = (w, name, field, profileName) => {
-  if (field.excluded) {
-    w.line(`{ const e = validateExcluded(r, ${JSON.stringify(name)}, "${profileName}"); if (e) errors.push(e) }`);
-    return;
-  }
-  if (field.required) {
-    w.line(`{ const e = validateRequired(r, ${JSON.stringify(name)}, "${profileName}"); if (e) errors.push(e) }`);
-  }
-  if (field.valueConstraint) {
-    const expected = JSON.stringify(field.valueConstraint.value);
-    w.line(
-      `{ const e = validateFixedValue(r, ${JSON.stringify(name)}, ${expected}, "${profileName}"); if (e) errors.push(e) }`
-    );
+var generateFieldAccessors = (w, factoryInfo, extSliceMethodBaseNames) => {
+  w.line("// Field accessors");
+  for (const p of factoryInfo.params) {
+    const methodBaseName = uppercaseFirstLetter(p.name);
+    w.curlyBlock([`get${methodBaseName}`, "()", `: ${p.tsType} | undefined`], () => {
+      w.lineSM(`return this.resource.${p.name} as ${p.tsType} | undefined`);
+    });
+    w.line();
+    w.curlyBlock([`set${methodBaseName}`, `(value: ${p.tsType})`, ": this"], () => {
+      w.lineSM(`Object.assign(this.resource, { ${p.name}: value })`);
+      w.lineSM("return this");
+    });
+    w.line();
   }
-  if (field.enum && !field.enum.isOpen) {
-    const values = JSON.stringify(field.enum.values);
-    w.line(
-      `{ const e = validateEnum(r[${JSON.stringify(name)}], ${values}, ${JSON.stringify(name)}, "${profileName}"); if (e) errors.push(e) }`
-    );
+  for (const a of factoryInfo.accessors) {
+    const methodBaseName = uppercaseFirstLetter(tsCamelCase(a.name));
+    if (extSliceMethodBaseNames.has(methodBaseName)) continue;
+    const fieldAccess = tsFieldName(a.name);
+    w.curlyBlock([`get${methodBaseName}`, "()", `: ${a.tsType} | undefined`], () => {
+      w.lineSM(`return ${tsGet("this.resource", fieldAccess)} as ${a.tsType} | undefined`);
+    });
+    w.line();
+    w.curlyBlock([`set${methodBaseName}`, `(value: ${a.tsType})`, ": this"], () => {
+      w.lineSM(`Object.assign(this.resource, { ${fieldAccess}: value })`);
+      w.lineSM("return this");
+    });
+    w.line();
   }
-  if (field.reference && field.reference.length > 0) {
-    const refNames = JSON.stringify(field.reference.map((ref) => ref.name));
-    w.line(
-      `{ const e = validateReference(r[${JSON.stringify(name)}], ${refNames}, ${JSON.stringify(name)}, "${profileName}"); if (e) errors.push(e) }`
-    );
+};
+var generateInlineExtensionInputTypes = (w, tsIndex, flatProfile) => {
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const complexExtensions = (flatProfile.extensions ?? []).filter((ext) => ext.isComplex && ext.subExtensions);
+  for (const ext of complexExtensions) {
+    if (!ext.url) continue;
+    const extProfileInfo = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
+    const hasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+    if (hasFlatInput) continue;
+    const typeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
+    w.curlyBlock(["export", "type", typeName, "="], () => {
+      for (const sub of ext.subExtensions ?? []) {
+        const tsType = sub.valueType ? tsTypeFromIdentifier(sub.valueType) : "unknown";
+        const isArray = sub.max === "*";
+        const isRequired2 = sub.min !== void 0 && sub.min > 0;
+        w.lineSM(`${sub.name}${isRequired2 ? "" : "?"}: ${tsType}${isArray ? "[]" : ""}`);
+      }
+    });
+    w.line();
   }
-  if (field.slicing?.slices) {
-    for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
-      if (slice.min === void 0 && slice.max === void 0) continue;
-      const match = slice.match ?? {};
-      if (Object.keys(match).length === 0) continue;
-      const min = slice.min ?? 0;
-      const max = slice.max ?? 0;
-      w.line(
-        `errors.push(...validateSliceCardinality(r[${JSON.stringify(name)}] as unknown[] | undefined, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max}, "${profileName}.${name}"))`
-      );
+};
+var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
+  if (sliceDefs.length === 0) return;
+  const tsProfileName = tsResourceName(flatProfile.identifier);
+  for (const sliceDef of sliceDefs) {
+    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const matchFields = Object.keys(sliceDef.match);
+    const allExcluded = [.../* @__PURE__ */ new Set([...sliceDef.excluded, ...matchFields])];
+    if (sliceDef.constrainedChoice) {
+      const cc = sliceDef.constrainedChoice;
+      allExcluded.push(cc.choiceBase);
+      for (const name of cc.allChoiceNames) {
+        if (!allExcluded.includes(name)) allExcluded.push(name);
+      }
+    }
+    const excludedNames = allExcluded.map((name) => JSON.stringify(name));
+    const requiredNames = sliceDef.required.map((name) => JSON.stringify(name));
+    let typeExpr = sliceDef.baseType;
+    if (excludedNames.length > 0) {
+      typeExpr = `Omit<${typeExpr}, ${excludedNames.join(" | ")}>`;
     }
+    if (requiredNames.length > 0) {
+      typeExpr = `${typeExpr} & Required<Pick<${sliceDef.baseType}, ${requiredNames.join(" | ")}>>`;
+    }
+    if (sliceDef.constrainedChoice) {
+      typeExpr = `${typeExpr} & ${tsTypeFromIdentifier(sliceDef.constrainedChoice.variantType)}`;
+    }
+    w.lineSM(`export type ${typeName} = ${typeExpr}`);
   }
+  w.line();
 };
-var generateValidateMethod = (w, flatProfile) => {
-  const fields = flatProfile.fields ?? {};
-  const profileName = flatProfile.identifier.name;
-  w.curlyBlock(["validate", "()", ": string[]"], () => {
-    w.line("const errors: string[] = []");
-    w.line("const r = this.resource as unknown as Record<string, unknown>");
-    for (const [name, field] of Object.entries(fields)) {
-      if (isChoiceInstanceField(field)) continue;
-      if (isChoiceDeclarationField(field)) {
-        if (field.required) {
-          const choiceNames = field.choices;
-          const checks = choiceNames.map((c) => `r[${JSON.stringify(c)}] !== undefined`).join(" || ");
-          w.curlyBlock(["if", `(!(${checks}))`], () => {
-            w.line(`errors.push("${name}: at least one of ${choiceNames.join(", ")} is required")`);
-          });
-        }
-        continue;
-      }
-      emitRegularFieldValidation(w, name, field, profileName);
+var generateRawType = (w, flatProfile, factoryInfo) => {
+  const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
+  const subSlices = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+  if (!hasParams && subSlices.length === 0) return;
+  const createArgsTypeName = `${tsProfileClassName(flatProfile)}Raw`;
+  w.curlyBlock(["export", "type", createArgsTypeName, "="], () => {
+    for (const p of factoryInfo.params) {
+      w.lineSM(`${p.name}: ${p.tsType}`);
+    }
+    for (const f of factoryInfo.sliceAutoFields) {
+      w.lineSM(`${f.name}?: ${f.tsType}`);
+    }
+    const extensionCovered = factoryInfo.params.some((p) => p.name === "extension") || factoryInfo.sliceAutoFields.some((f) => f.name === "extension");
+    if (subSlices.length > 0 && !extensionCovered) {
+      w.lineSM("extension?: Extension[]");
     }
-    w.line("return errors");
   });
   w.line();
 };
-var generateExtensionSetterMethods = (w, extensions, extensionMethodNames, tsProfileName) => {
-  for (const ext of extensions) {
-    if (!ext.url) continue;
-    const methodName = extensionMethodNames.get(ext) ?? tsQualifiedExtensionMethodName(ext.name, ext.path);
-    const valueTypes = ext.valueTypes ?? [];
-    const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
-    if (ext.isComplex && ext.subExtensions) {
-      const inputTypeName = tsExtensionInputTypeName(tsProfileName, ext.name);
-      w.curlyBlock(["public", methodName, `(input: ${inputTypeName}): this`], () => {
-        w.line("const subExtensions: Extension[] = []");
-        for (const sub of ext.subExtensions ?? []) {
-          const valueField = sub.valueType ? `value${uppercaseFirstLetter(sub.valueType.name)}` : "value";
-          const needsCast = !sub.valueType;
-          const pushSuffix = needsCast ? " as Extension" : "";
-          if (sub.max === "*") {
-            w.curlyBlock(["if", `(input.${sub.name})`], () => {
-              w.curlyBlock(["for", `(const item of input.${sub.name})`], () => {
-                w.line(`subExtensions.push({ url: "${sub.url}", ${valueField}: item }${pushSuffix})`);
-              });
-            });
-          } else {
-            w.curlyBlock(["if", `(input.${sub.name} !== undefined)`], () => {
-              w.line(
-                `subExtensions.push({ url: "${sub.url}", ${valueField}: input.${sub.name} }${pushSuffix})`
-              );
-            });
-          }
-        }
-        if (targetPath.length === 0) {
-          w.line("const list = (this.resource.extension ??= [])");
-          w.line(`list.push({ url: "${ext.url}", extension: subExtensions })`);
-        } else {
-          w.line(
-            `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
-          );
-          w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
-          w.line(`(target.extension as Extension[]).push({ url: "${ext.url}", extension: subExtensions })`);
-        }
-        w.line("return this");
-      });
-    } else if (valueTypes.length === 1 && valueTypes[0]) {
-      const firstValueType = valueTypes[0];
-      const valueType = tsTypeFromIdentifier(firstValueType);
-      const valueField = `value${uppercaseFirstLetter(firstValueType.name)}`;
-      w.curlyBlock(["public", methodName, `(value: ${valueType}): this`], () => {
-        const extLiteral = `{ url: "${ext.url}", ${valueField}: value } as Extension`;
-        if (targetPath.length === 0) {
-          w.line("const list = (this.resource.extension ??= [])");
-          w.line(`list.push(${extLiteral})`);
-        } else {
-          w.line(
-            `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(
-              targetPath
-            )})`
-          );
-          w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
-          w.line(`(target.extension as Extension[]).push(${extLiteral})`);
-        }
-        w.line("return this");
-      });
-    } else {
-      w.curlyBlock(["public", methodName, `(value: Omit<Extension, "url">): this`], () => {
-        if (targetPath.length === 0) {
-          w.line("const list = (this.resource.extension ??= [])");
-          w.line(`list.push({ url: "${ext.url}", ...value })`);
-        } else {
-          w.line(
-            `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(
-              targetPath
-            )})`
-          );
-          w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
-          w.line(`(target.extension as Extension[]).push({ url: "${ext.url}", ...value })`);
-        }
-        w.line("return this");
-      });
+var generateFlatInputType = (w, flatProfile) => {
+  const subSlices = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+  if (subSlices.length === 0) return;
+  const flatInputTypeName = `${tsProfileClassName(flatProfile)}Flat`;
+  w.curlyBlock(["export", "type", flatInputTypeName, "="], () => {
+    for (const sub of subSlices) {
+      const opt = sub.isRequired ? "" : "?";
+      const arr = sub.isArray ? "[]" : "";
+      w.lineSM(`${sub.name}${opt}: ${sub.tsType}${arr}`);
     }
+  });
+  w.line();
+};
+var countBy = (entries, level) => entries.reduce(
+  (counts, e) => {
+    const name = e.candidates[level] ?? "";
+    counts[name] = (counts[name] ?? 0) + 1;
+    return counts;
+  },
+  {}
+);
+var resolveNameCollisions = (entries) => {
+  const levels = entries[0]?.candidates.length ?? 0;
+  const resolve6 = (unresolved, level) => {
+    if (unresolved.length === 0 || level >= levels) return {};
+    const counts = countBy(unresolved, level);
+    const isLastLevel = level >= levels - 1;
+    const [resolved, colliding] = unresolved.reduce(
+      ([res, col], e) => {
+        const name = e.candidates[level] ?? "";
+        return (counts[name] ?? 0) > 1 && !isLastLevel ? [res, [...col, e]] : [{ ...res, [e.key]: name }, col];
+      },
+      [{}, []]
+    );
+    return { ...resolved, ...resolve6(colliding, level + 1) };
+  };
+  return resolve6(entries, 0);
+};
+var toRecord = (entries, resolved) => Object.fromEntries(entries.map((e) => [e.key, resolved[e.key] ?? e.candidates[0] ?? ""]));
+var resolveProfileMethodBaseNames = (extensions, sliceDefs) => {
+  const extensionEntries = extensions.filter((ext) => ext.url).map((ext) => {
+    const base = tsExtensionMethodBaseName(ext.name);
+    const qualified = tsQualifiedExtensionMethodBaseName(ext.name, ext.path);
+    return { key: `${ext.url}:${ext.path}`, candidates: [base, qualified, `${qualified}Extension`] };
+  });
+  const sliceEntries = sliceDefs.map((slice) => {
+    const base = tsSliceMethodBaseName(slice.sliceName);
+    const qualified = tsQualifiedSliceMethodBaseName(slice.fieldName, slice.sliceName);
+    return { key: `${slice.fieldName}:${slice.sliceName}`, candidates: [base, qualified, `${qualified}Slice`] };
+  });
+  const resolved = resolveNameCollisions([...extensionEntries, ...sliceEntries]);
+  const extensionsRecords = toRecord(extensionEntries, resolved);
+  const slicesRecords = toRecord(sliceEntries, resolved);
+  const allBaseNames = /* @__PURE__ */ new Set([...Object.values(extensionsRecords), ...Object.values(slicesRecords)]);
+  return { extensions: extensionsRecords, slices: slicesRecords, allBaseNames };
+};
+var generateProfileClass = (w, tsIndex, flatProfile) => {
+  const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
+  const profileClassName = tsProfileClassName(flatProfile);
+  const sliceDefs = collectSliceDefs(tsIndex, flatProfile);
+  const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
+  generateInlineExtensionInputTypes(w, tsIndex, flatProfile);
+  generateSliceInputTypes(w, flatProfile, sliceDefs);
+  generateProfileHelpersImport(w, tsIndex, flatProfile, sliceDefs, factoryInfo);
+  generateRawType(w, flatProfile, factoryInfo);
+  generateFlatInputType(w, flatProfile);
+  const canonicalUrl = flatProfile.identifier.url;
+  w.comment("CanonicalURL:", canonicalUrl, `(pkg: ${packageMetaToFhir(packageMeta(flatProfile))})`);
+  const resolvedMethodNames = resolveProfileMethodBaseNames(flatProfile.extensions ?? [], sliceDefs);
+  w.curlyBlock(["export", "class", profileClassName], () => {
+    w.lineSM(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
     w.line();
-  }
+    generateStaticSliceFields(w, sliceDefs);
+    w.lineSM(`private resource: ${tsBaseResourceName}`);
+    w.line();
+    generateFactoryMethods(w, tsIndex, flatProfile, factoryInfo);
+    generateFieldAccessors(w, factoryInfo, resolvedMethodNames.allBaseNames);
+    w.line("// Extensions");
+    generateExtensionMethods(w, tsIndex, flatProfile, resolvedMethodNames.extensions);
+    w.line("// Slices");
+    generateSliceSetters(w, sliceDefs, flatProfile, resolvedMethodNames.slices);
+    generateSliceGetters(w, sliceDefs, flatProfile, resolvedMethodNames.slices);
+    w.line("// Validation");
+    generateValidateMethod(w, tsIndex, flatProfile);
+  });
+  w.line();
 };
-var detectFieldOverrides = (w, tsIndex, flatProfile) => {
+var detectFieldOverrides = (tsIndex, flatProfile) => {
   const overrides = /* @__PURE__ */ new Map();
   const specialization = tsIndex.findLastSpecialization(flatProfile);
   if (!isSpecializationTypeSchema(specialization)) return overrides;
+  const referenceUrl = "http://hl7.org/fhir/StructureDefinition/Reference";
+  const referenceSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, referenceUrl);
   for (const [fieldName, pField] of Object.entries(flatProfile.fields ?? {})) {
     if (!isNotChoiceDeclarationField(pField)) continue;
     const sField = specialization.fields?.[fieldName];
     if (!sField || isChoiceDeclarationField(sField)) continue;
     if (pField.reference && sField.reference && pField.reference.length < sField.reference.length) {
+      if (!referenceSchema) continue;
       const references = pField.reference.map((ref) => {
         const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
         if (resRef.name !== ref.name) {
@@ -5371,21 +5365,22 @@ var detectFieldOverrides = (w, tsIndex, flatProfile) => {
       overrides.set(fieldName, {
         profileType: `Reference<${references}>`,
         required: pField.required ?? false,
-        array: pField.array ?? false
+        array: pField.array ?? false,
+        typeId: referenceSchema.identifier
       });
     } else if (pField.required && !sField.required) {
-      const tsType = tsTypeForProfileField(w, tsIndex, flatProfile, fieldName, pField);
+      const tsType = tsTypeForProfileField(tsIndex, flatProfile, fieldName, pField);
       overrides.set(fieldName, {
         profileType: tsType,
         required: true,
-        array: pField.array ?? false
+        array: pField.array ?? false,
+        typeId: pField.type
       });
     }
   }
   return overrides;
 };
-var generateProfileOverrideInterface = (w, tsIndex, flatProfile) => {
-  const overrides = detectFieldOverrides(w, tsIndex, flatProfile);
+var generateProfileOverrideInterface = (w, flatProfile, overrides) => {
   if (overrides.size === 0) return;
   const tsProfileName = tsResourceName(flatProfile.identifier);
   const tsBaseResourceName = tsResourceName(flatProfile.base);
@@ -5401,9 +5396,49 @@ var generateProfileOverrideInterface = (w, tsIndex, flatProfile) => {
 };
 
 // src/api/writer-generator/typescript/writer.ts
+var resolveTsAssets = (fn) => {
+  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
+  const __filename = fileURLToPath(import.meta.url);
+  if (__filename.endsWith("dist/index.js")) {
+    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "typescript", fn);
+  }
+  return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "typescript", fn);
+};
 var TypeScript = class extends Writer {
-  tsImportType(tsPackageName, ...entities) {
-    this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
+  constructor(options) {
+    super({ lineWidth: 120, ...options, resolveAssets: options.resolveAssets ?? resolveTsAssets });
+  }
+  ifElseChain(branches, elseBody) {
+    branches.forEach((branch, i) => {
+      const prefix = i === 0 ? "if" : "} else if";
+      this.line(`${prefix} (${branch.cond}) {`);
+      this.indent();
+      branch.body();
+      this.deindent();
+    });
+    if (elseBody) {
+      this.line("} else {");
+      this.indent();
+      elseBody();
+      this.deindent();
+    }
+    this.line("}");
+  }
+  tsImport(tsPackageName, ...rest) {
+    const last = rest[rest.length - 1];
+    const typeOnly = typeof last === "object" ? last.typeOnly : false;
+    const entities = typeof last === "object" ? rest.slice(0, -1) : rest;
+    const keyword = typeOnly ? "import type" : "import";
+    const singleLine = `${keyword} { ${entities.join(", ")} } from "${tsPackageName}"`;
+    if (singleLine.length <= (this.opts.lineWidth ?? 120)) {
+      this.lineSM(singleLine);
+    } else {
+      this.curlyBlock([keyword], () => {
+        for (const entity of entities) {
+          this.line(`${entity},`);
+        }
+      }, [` from "${tsPackageName}";`]);
+    }
   }
   generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
@@ -5468,7 +5503,7 @@ var TypeScript = class extends Writer {
       imports.sort((a, b) => a.name.localeCompare(b.name));
       for (const dep of imports) {
         this.debugComment(dep.dep);
-        this.tsImportType(dep.tsPackage, dep.name);
+        this.tsImport(dep.tsPackage, dep.name, { typeOnly: true });
       }
       for (const dep of skipped) {
         this.debugComment("skip:", dep);
@@ -5478,7 +5513,7 @@ var TypeScript = class extends Writer {
         const elementUrl = "http://hl7.org/fhir/StructureDefinition/Element";
         const element = tsIndex.resolveByUrl(schema.identifier.package, elementUrl);
         if (!element) throw new Error(`'${elementUrl}' not found for ${schema.identifier.package}.`);
-        this.tsImportType(`${importPrefix}${tsModulePath(element.identifier)}`, "Element");
+        this.tsImport(`${importPrefix}${tsModulePath(element.identifier)}`, "Element", { typeOnly: true });
       }
     }
   }
@@ -5575,9 +5610,10 @@ var TypeScript = class extends Writer {
         this.cat(`${tsProfileModuleFileName(tsIndex, schema)}`, () => {
           this.generateDisclaimer();
           const flatProfile = tsIndex.flatProfile(schema);
-          generateProfileImports(this, tsIndex, flatProfile);
-          generateProfileOverrideInterface(this, tsIndex, flatProfile);
-          generateProfileClass(this, tsIndex, flatProfile, schema);
+          const overrides = detectFieldOverrides(tsIndex, flatProfile);
+          generateProfileImports(this, tsIndex, flatProfile, overrides);
+          generateProfileOverrideInterface(this, flatProfile, overrides);
+          generateProfileClass(this, tsIndex, flatProfile);
         });
       });
     } else if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
@@ -5609,7 +5645,7 @@ var TypeScript = class extends Writer {
     const hasProfiles = this.opts.generateProfile && typesToGenerate.some(isProfileTypeSchema);
     this.cd("/", () => {
       if (hasProfiles) {
-        generateProfileHelpersModule(this);
+        this.cp("profile-helpers.ts", "profile-helpers.ts");
       }
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const packageDir = tsPackageDir(packageName);
@@ -5674,7 +5710,6 @@ var APIBuilder = class {
       treeShake: void 0,
       promoteLogical: void 0,
       registry: void 0,
-      logLevel: parseLogLevel("INFO"),
       dropCanonicalManagerCache: false
     };
     const opts = {
@@ -5701,7 +5736,7 @@ var APIBuilder = class {
       dropCache: userOpts.dropCanonicalManagerCache,
       preprocessPackage: userOpts.preprocessPackage
     });
-    this.logger = userOpts.logger ?? createLogger({ prefix: "API", level: opts.logLevel });
+    this.logger = userOpts.logger ?? mkLogger({ prefix: "api" });
     this.options = opts;
   }
   fromPackage(packageName, version) {
@@ -5841,10 +5876,6 @@ var APIBuilder = class {
     }
     return this;
   }
-  setLogLevel(level) {
-    this.logger?.setLevel(typeof level === "string" ? parseLogLevel(level) : level);
-    return this;
-  }
   throwException(enabled = true) {
     this.options.throwException = enabled;
     return this;
@@ -5912,26 +5943,28 @@ var APIBuilder = class {
         const ref2meta = await this.manager.init();
         const packageMetas = Object.values(ref2meta);
         register = await registerFromManager(this.manager, {
-          logger: this.logger,
+          logger: this.logger.fork("reg"),
           focusedPackages: packageMetas
         });
       }
-      const { schemas: typeSchemas, collisions } = await generateTypeSchemas(register, this.logger);
+      const tsLogger = this.logger.fork("ts");
+      const { schemas: typeSchemas, collisions } = await generateTypeSchemas(register, tsLogger);
       const tsIndexOpts = {
         register,
-        logger: this.logger,
+        logger: tsLogger,
         irReport: Object.keys(collisions).length > 0 ? { collisions } : {}
       };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
       if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake);
       if (this.options.promoteLogical) tsIndex = promoteLogical(tsIndex, this.options.promoteLogical);
+      tsLogger.printTagSummary();
       this.logger.debug(`Executing ${this.generators.length} generators`);
       await this.executeGenerators(result, tsIndex);
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
     } catch (error) {
-      this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
+      this.logger.error(`Code generation failed: ${error instanceof Error ? error.message : String(error)}`);
       result.errors.push(error instanceof Error ? error.message : String(error));
       if (this.options.throwException) throw error;
     }
@@ -5974,6 +6007,6 @@ var APIBuilder = class {
   }
 };
 
-export { APIBuilder, LogLevel, prettyReport, registerFromPackageMetas };
+export { APIBuilder, mkCodegenLogger, prettyReport, registerFromManager, registerFromPackageMetas };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map