@atomic-ehr/codegen 0.0.16 → 0.0.17-canary.20260727063227.c50c42b

package/dist/index.js

@@ -383,6 +383,9 @@ var isPrimitiveIdentifier = (id) => {
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
+var isProfileIdentifier = (id) => {
+  return id?.kind === "profile";
+};
 var isSnapshotProfileIdentifier = (id) => {
   return id?.kind === "profile-snapshot";
 };
@@ -426,6 +429,7 @@ var isValueSetTypeSchema = (schema) => {
 var isSnapshotProfileTypeSchema = (s) => {
   return s?.identifier.kind === "profile-snapshot";
 };
+var isTypeDiscriminated = (slicing) => slicing?.discriminator?.some((d) => d.type === "type") ?? false;
 var extractExtensionDeps = (ext) => [
   ...ext.valueFieldTypes ?? [],
   ...ext.profile ? [ext.profile] : [],
@@ -892,6 +896,18 @@ var pyTypeFromIdentifier = (id) => {
   if (prim !== void 0) return prim;
   return deriveResourceName(id);
 };
+var pyReferenceTypeParam = (field, tsIndex) => {
+  if (!field.reference || field.reference.resource.length === 0) return void 0;
+  const isFamilyType = (ref) => {
+    const schema = tsIndex.resolveType(ref);
+    if (!schema || !("typeFamily" in schema)) return false;
+    return (schema.typeFamily?.resources?.length ?? 0) > 0;
+  };
+  const resolved = field.reference.resource.map((ref) => tsIndex.findLastSpecializationByIdentifier(ref));
+  if (resolved.some(isFamilyType)) return void 0;
+  const names = [...new Set(resolved.map((ref) => ref.name))];
+  return `Literal[${names.map((n) => JSON.stringify(n)).join(", ")}]`;
+};
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
   for (const ts of typeSchemas) {
@@ -1083,6 +1099,54 @@ var populateGeneric = (schemas, resolveType) => {
     schema.dependencies = concatIdentifiers(schema.dependencies, constraints) ?? schema.dependencies;
   }
 };
+var choiceInstances = (fields, declName) => Object.entries(fields).filter(
+  (e) => isChoiceInstanceField(e[1]) && e[1].choiceOf === declName
+);
+var choiceUniverse = (fields, baseFields, declName, declField) => {
+  const baseDecl = baseFields[declName];
+  const baseChoices = isChoiceDeclarationField(baseDecl) ? baseDecl.choices : [];
+  return [
+    .../* @__PURE__ */ new Set([...baseChoices, ...declField.choices, ...choiceInstances(fields, declName).map(([name]) => name)])
+  ];
+};
+var declaredChoiceVariants = (fields, declName) => {
+  const declaration = fields[declName];
+  const fromDeclaration = isChoiceDeclarationField(declaration) && !declaration.excluded ? declaration.choices : [];
+  const fromInstances = choiceInstances(fields, declName).filter(([, field]) => !field.excluded).map(([name]) => name);
+  return [.../* @__PURE__ */ new Set([...fromDeclaration, ...fromInstances])];
+};
+var resolvePermittedChoiceVariants = (universe, baseDeclaration, constraintSchemas, declName, logger) => {
+  let permitted = new Set(isChoiceDeclarationField(baseDeclaration) ? baseDeclaration.choices : universe);
+  for (const schema of constraintSchemas.slice().reverse()) {
+    const fields = schema.fields;
+    if (!fields) continue;
+    const reintroduced = declaredChoiceVariants(fields, declName).filter((name) => !permitted.has(name));
+    if (reintroduced.length > 0)
+      logger?.dryWarn(
+        "#nonMonotonicChoice",
+        `Profile '${schema.identifier.name}' declares choice variant(s) ${reintroduced.join(", ")} of '${declName}' that an ancestor prohibits; they stay prohibited`
+      );
+    permitted = applyChoiceConstraints(permitted, fields, declName);
+  }
+  return permitted;
+};
+var applyChoiceConstraints = (permitted, fields, declName) => {
+  const result = new Set(permitted);
+  const instances = choiceInstances(fields, declName);
+  for (const [name, field] of instances) {
+    if (field.excluded) result.delete(name);
+  }
+  const declaration = fields[declName];
+  if (isChoiceDeclarationField(declaration)) {
+    if (declaration.excluded) return /* @__PURE__ */ new Set();
+    const declared2 = new Set(declaration.choices);
+    return new Set([...result].filter((name) => declared2.has(name)));
+  }
+  const declared = instances.filter(([, field]) => !field.excluded).map(([name]) => name);
+  if (declared.length === 0) return result;
+  const declaredSet = new Set(declared);
+  return new Set([...result].filter((name) => declaredSet.has(name)));
+};
 var mkTypeSchemaIndex = (schemas, {
   register,
   logger,
@@ -1196,28 +1260,29 @@ var mkTypeSchemaIndex = (schemas, {
     if (isNestedTypeSchema(resolved)) return findLastSpecializationByIdentifier(resolved.base);
     return findLastSpecialization(resolved).identifier;
   };
-  const narrowMergedChoiceDeclarations = (mergedFields, constraintSchemas) => {
+  const narrowMergedChoiceDeclarations = (mergedFields, constraintSchemas, baseFields = {}) => {
     const result = { ...mergedFields };
-    for (const [declName, declField] of Object.entries(result)) {
-      if (!isChoiceDeclarationField(declField) || declField.excluded) continue;
-      for (const cSchema of constraintSchemas) {
-        const sFields = cSchema.fields;
-        if (!sFields) continue;
-        if (sFields[declName] && isChoiceDeclarationField(sFields[declName])) continue;
-        const instancesInSchema = Object.entries(sFields).filter(([_, f]) => isChoiceInstanceField(f) && f.choiceOf === declName).map(([name]) => name);
-        if (instancesInSchema.length === 0) continue;
-        const allowed = new Set(instancesInSchema);
-        result[declName] = { ...declField, choices: declField.choices.filter((c) => allowed.has(c)) };
-        break;
-      }
-    }
-    for (const [declName, declField] of Object.entries(result)) {
+    const declNames = /* @__PURE__ */ new Set([...Object.keys(result), ...Object.keys(baseFields)]);
+    for (const declName of declNames) {
+      const declField = result[declName] ?? baseFields[declName];
       if (!isChoiceDeclarationField(declField)) continue;
-      const permitted = new Set(declField.excluded ? [] : declField.choices);
-      const prohibited = Object.entries(result).filter(
-        (e) => isChoiceInstanceField(e[1]) && e[1].choiceOf === declName
-      ).filter(([name]) => !permitted.has(name)).map(([name]) => name);
-      if (prohibited.length > 0) result[declName] = { ...declField, prohibited };
+      const restated = result[declName] !== void 0;
+      if (!restated && choiceInstances(result, declName).length === 0) continue;
+      const universe = choiceUniverse(result, baseFields, declName, declField);
+      const permitted = resolvePermittedChoiceVariants(
+        universe,
+        baseFields[declName],
+        constraintSchemas,
+        declName,
+        logger
+      );
+      const prohibited = universe.filter((name) => !permitted.has(name));
+      if (!restated && prohibited.length === 0) continue;
+      result[declName] = {
+        ...declField,
+        choices: universe.filter((name) => permitted.has(name)),
+        ...prohibited.length > 0 ? { prohibited } : {}
+      };
     }
     return result;
   };
@@ -1228,8 +1293,10 @@ var mkTypeSchemaIndex = (schemas, {
     if (!nonConstraintSchema)
       throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
     const mergedFields = {};
+    const mergedSlicing = {};
     for (const anySchema of constraintSchemas.slice().reverse()) {
       const schema2 = anySchema;
+      if (schema2.slicing) Object.assign(mergedSlicing, schema2.slicing);
       if (!schema2.fields) continue;
       for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
         const merged = mergedFields[fieldName] ? { ...mergedFields[fieldName], ...fieldConstraints } : { ...fieldConstraints };
@@ -1239,7 +1306,11 @@ var mkTypeSchemaIndex = (schemas, {
         mergedFields[fieldName] = merged;
       }
     }
-    const narrowedFields = narrowMergedChoiceDeclarations(mergedFields, constraintSchemas);
+    const narrowedFields = narrowMergedChoiceDeclarations(
+      mergedFields,
+      constraintSchemas,
+      nonConstraintSchema.fields
+    );
     const dependencies = Object.values(
       Object.fromEntries(
         constraintSchemas.flatMap((s) => s.dependencies ?? []).map((dep) => [dep.url, dep])
@@ -1256,6 +1327,7 @@ var mkTypeSchemaIndex = (schemas, {
       ...schema,
       base: nonConstraintSchema.identifier,
       fields: narrowedFields,
+      slicing: Object.keys(mergedSlicing).length > 0 ? mergedSlicing : void 0,
       dependencies,
       extensions: mergedExtensions.length > 0 ? mergedExtensions : void 0
     };
@@ -1281,6 +1353,7 @@ var mkTypeSchemaIndex = (schemas, {
       base: flat.base,
       description: flat.description,
       fields: flatFields,
+      slicing: flat.slicing,
       inheritedRequiredFields: inheritedRequiredFields.length > 0 ? inheritedRequiredFields : void 0,
       extensions: flat.extensions,
       dependencies: flat.dependencies,
@@ -1459,7 +1532,16 @@ var generateExtensionMethods = (w, tsIndex, flatProfile, className, extensionBas
       const valueField = pyValueFieldName(valueType, w.nameFormatFunction);
       const pyType = pyTypeFromIdentifier(valueType);
       generateSingleValueExtensionGetter(w, ext, baseName, targetPath, valueField, pyType, extProfileInfo);
-      generateSingleValueExtensionSetter(w, ext, className, baseName, targetPath, valueField, extProfileInfo);
+      generateSingleValueExtensionSetter(
+        w,
+        ext,
+        className,
+        baseName,
+        targetPath,
+        valueField,
+        pyType,
+        extProfileInfo
+      );
     } else {
       generateGenericExtensionGetter(w, ext, baseName, targetPath, extProfileInfo);
       generateGenericExtensionSetter(w, ext, className, baseName, targetPath, extProfileInfo);
@@ -1566,6 +1648,7 @@ var generateExtensionSetter = (w, ext, className, baseName, flatParamType, targe
 };
 var generateComplexExtensionSetter = (w, ext, className, baseName, targetPath, extProfileInfo) => {
   generateExtensionSetter(w, ext, className, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    w.line("assert is_record(value)");
     w.line("sub_extensions = []");
     for (const sub of ext.subExtensions ?? []) {
       const valueField = sub.valueFieldType ? pyValueFieldName(sub.valueFieldType, w.nameFormatFunction) : "value";
@@ -1594,8 +1677,9 @@ var generateSingleValueExtensionGetter = (w, ext, baseName, targetPath, valueFie
     w.line(`return cast('${pyType} | None', get_extension_value(ext, ${JSON.stringify(valueField)}))`);
   });
 };
-var generateSingleValueExtensionSetter = (w, ext, className, baseName, targetPath, valueField, extProfileInfo) => {
-  generateExtensionSetter(w, ext, className, baseName, "Any", targetPath, extProfileInfo, () => {
+var generateSingleValueExtensionSetter = (w, ext, className, baseName, targetPath, valueField, pyType, extProfileInfo) => {
+  generateExtensionSetter(w, ext, className, baseName, pyType, targetPath, extProfileInfo, () => {
+    w.line("assert not isinstance(value, Extension)");
     emitExtPush(w, targetPath, `Extension(url=${JSON.stringify(ext.url)}, ${valueField}=value)`);
   });
 };
@@ -1608,15 +1692,16 @@ var generateGenericExtensionGetter = (w, ext, baseName, targetPath, extProfileIn
 };
 var generateGenericExtensionSetter = (w, ext, className, baseName, targetPath, extProfileInfo) => {
   generateExtensionSetter(w, ext, className, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    w.line("assert is_record(value)");
     emitExtPush(w, targetPath, `{"url": ${JSON.stringify(ext.url)}, **value}`);
   });
 };
 
 // src/api/writer-generator/python/profile-slices.ts
-var collectRequiredSliceNames = (field) => {
-  if (!field.array || !field.slicing?.slices) return void 0;
-  if (field.slicing.discriminator?.some((d) => d.type === "type")) 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);
+var collectRequiredSliceNames = (field, fieldSlicing) => {
+  if (!field.array || !fieldSlicing?.slices) return void 0;
+  if (isTypeDiscriminated(fieldSlicing)) return void 0;
+  const names = Object.entries(fieldSlicing.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 generateStaticSliceFields = (w, sliceDefs) => {
@@ -1648,8 +1733,8 @@ var normalizeMatchForPython = (tsIndex, match, schema) => {
   }
   return result;
 };
-var extractTypeDiscriminatorResource = (isTypeDiscriminated, rawMatch) => {
-  if (!isTypeDiscriminated || !rawMatch) return void 0;
+var extractTypeDiscriminatorResource = (isTypeDiscriminated2, rawMatch) => {
+  if (!isTypeDiscriminated2 || !rawMatch) return void 0;
   for (const val of Object.values(rawMatch)) {
     if (val !== null && typeof val === "object" && !Array.isArray(val)) {
       const rt = val.resourceType;
@@ -1660,8 +1745,9 @@ var extractTypeDiscriminatorResource = (isTypeDiscriminated, rawMatch) => {
 };
 var collectSliceDefs = (tsIndex, flatProfile) => {
   const pkgName = flatProfile.identifier.package;
-  return Object.entries(flatProfile.fields).flatMap(([fieldName, field]) => {
-    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
+  return Object.entries(flatProfile.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
+    const field = flatProfile.fields[fieldName];
+    if (!isNotChoiceDeclarationField(field) || !fieldSlicing.slices || !field.type) return [];
     const choiceBaseNames = /* @__PURE__ */ new Set();
     const baseSchema = tsIndex.resolveType(field.type);
     if (baseSchema && "fields" in baseSchema && baseSchema.fields) {
@@ -1669,16 +1755,16 @@ var collectSliceDefs = (tsIndex, flatProfile) => {
         if (isChoiceDeclarationField(f)) choiceBaseNames.add(n);
       }
     }
-    return Object.entries(field.slicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
+    return Object.entries(fieldSlicing.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;
-      const isTypeDiscriminated = field.slicing?.discriminator?.some((d) => d.type === "type") ?? false;
+      const typeDiscriminated = isTypeDiscriminated(fieldSlicing);
       const typeDiscriminatorResource = extractTypeDiscriminatorResource(
-        isTypeDiscriminated,
+        typeDiscriminated,
         slice.match
       );
       return {
@@ -1691,7 +1777,7 @@ var collectSliceDefs = (tsIndex, flatProfile) => {
         constrainedChoice,
         elementTypeName: field.type && !isPrimitiveIdentifier(field.type) ? pyTypeFromIdentifier(field.type) : void 0,
         elementTypeId: field.type && !isPrimitiveIdentifier(field.type) ? field.type : void 0,
-        isTypeDiscriminated,
+        isTypeDiscriminated: typeDiscriminated,
         typeDiscriminatorResource,
         nameCandidates: slice.nameCandidates
       };
@@ -1808,15 +1894,17 @@ var generateSliceSetters = (w, className, sliceDefs, sliceBaseNames) => {
         } else {
           w.line(`merged = apply_slice_match(${inputExpr}, match)`);
         }
+        let elementExpr = "merged";
         if (sliceDef.elementTypeName) {
-          w.line(`merged = ${sliceDef.elementTypeName}(**merged)`);
+          w.line(`element = ${sliceDef.elementTypeName}(**merged)`);
+          elementExpr = "element";
         }
         if (sliceDef.array) {
           w.line(`items = getattr(self._resource, ${JSON.stringify(fieldName)}, None) or []`);
-          w.line("set_array_slice(items, match, merged)");
+          w.line(`set_array_slice(items, match, ${elementExpr})`);
           w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, items)`);
         } else {
-          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, merged)`);
+          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, ${elementExpr})`);
         }
         w.line("return self");
       });
@@ -1826,25 +1914,46 @@ var generateSliceSetters = (w, className, sliceDefs, sliceBaseNames) => {
 };
 
 // src/api/writer-generator/python/profile-factory.ts
-var fieldPyType = (field, resolveRef) => {
+var fieldPyType = (field, resolveRef, tsIndex) => {
   const resolved = resolveRef ? resolveRef(field.type) : field.type;
-  const base = pyTypeFromIdentifier(resolved);
+  let base = pyTypeFromIdentifier(resolved);
   if (base === "str" && field.enum && !field.enum.isOpen && field.enum.values.length > 0) {
     const literal = `Literal[${field.enum.values.map((v) => JSON.stringify(v)).join(", ")}]`;
     return field.array ? `list[${literal}]` : literal;
   }
+  if (base === "Reference" && tsIndex) {
+    const typeParam = pyReferenceTypeParam(field, tsIndex);
+    if (typeParam) base = `Reference[${typeParam}]`;
+  }
   return field.array ? `list[${base}]` : base;
 };
-var tryPromoteChoice = (field, fields, params, promotedChoices) => {
+var pyReferenceComment = (field) => {
+  const urls = (field.reference?.profiles ?? []).map((profile) => profile.url);
+  return urls.length > 0 ? `  # ${urls.join(", ")}` : void 0;
+};
+var tryPromoteChoice = (field, fields, params, promotedChoices, tsIndex) => {
   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 pyType = pyTypeFromIdentifier(choiceField.type) + (choiceField.array ? "[]" : "");
-  params.push({ name: choiceName, pyType, typeId: choiceField.type });
+  const pyType = pyChoiceInstanceType(choiceField, tsIndex);
+  params.push({
+    name: choiceName,
+    pyType,
+    typeId: choiceField.type,
+    refComment: pyReferenceComment(choiceField)
+  });
   promotedChoices.add(choiceName);
 };
+var pyChoiceInstanceType = (field, tsIndex) => {
+  let base = pyTypeFromIdentifier(field.type);
+  if (base === "Reference") {
+    const typeParam = pyReferenceTypeParam(field, tsIndex);
+    if (typeParam) base = `Reference[${typeParam}]`;
+  }
+  return base + (field.array ? "[]" : "");
+};
 var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames) => {
   const covered = new Set(coveredNames);
   const baseSchema = tsIndex.resolveType(flatProfile.base);
@@ -1855,8 +1964,8 @@ var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, cover
     if (isChoiceInstanceField(field)) continue;
     if (isChoiceDeclarationField(field)) continue;
     if (isNotChoiceDeclarationField(field) && field.type) {
-      const pyType = fieldPyType(field, resolveRef);
-      params.push({ name, pyType, typeId: field.type });
+      const pyType = fieldPyType(field, resolveRef, tsIndex);
+      params.push({ name, pyType, typeId: field.type, refComment: pyReferenceComment(field) });
     }
   }
 };
@@ -1885,32 +1994,32 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
       continue;
     }
     if (isChoiceDeclarationField(field)) {
-      tryPromoteChoice(field, fields, params, promotedChoices);
+      tryPromoteChoice(field, fields, params, promotedChoices, tsIndex);
       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 pyType = fieldPyType(field, resolveRef);
-        autoAccessors.push({ name, pyType, typeId: field.type });
+        const pyType = fieldPyType(field, resolveRef, tsIndex);
+        autoAccessors.push({ name, pyType, typeId: field.type, refComment: pyReferenceComment(field) });
       }
       continue;
     }
     if (isNotChoiceDeclarationField(field)) {
-      const sliceNames = collectRequiredSliceNames(field);
+      const sliceNames = collectRequiredSliceNames(field, flatProfile.slicing?.[name]);
       if (sliceNames) {
         if (field.type) {
-          const pyType = fieldPyType(field, resolveRef);
+          const pyType = fieldPyType(field, resolveRef, tsIndex);
           sliceAutoFields.push({ name, pyType, typeId: field.type, sliceNames });
-          autoAccessors.push({ name, pyType, typeId: field.type });
+          autoAccessors.push({ name, pyType, typeId: field.type, refComment: pyReferenceComment(field) });
         }
         continue;
       }
     }
     if (field.required) {
-      const pyType = fieldPyType(field, resolveRef);
-      params.push({ name, pyType, typeId: field.type });
+      const pyType = fieldPyType(field, resolveRef, tsIndex);
+      params.push({ name, pyType, typeId: field.type, refComment: pyReferenceComment(field) });
     }
   }
   collectBaseRequiredParams(tsIndex, flatProfile, resolveRef, params, [
@@ -1922,9 +2031,15 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
   const choiceAccessors = [];
   for (const [name, field] of pendingChoiceInstances) {
     if (promotedChoices.has(name)) continue;
-    const pyType = pyTypeFromIdentifier(field.type) + (field.array ? "[]" : "");
+    const pyType = pyChoiceInstanceType(field, tsIndex);
     const choiceSiblings = (choiceGroups.get(name) ?? []).filter((s) => s !== name && !promotedChoices.has(s));
-    choiceAccessors.push({ name, pyType, typeId: field.type, choiceSiblings });
+    choiceAccessors.push({
+      name,
+      pyType,
+      typeId: field.type,
+      choiceSiblings,
+      refComment: pyReferenceComment(field)
+    });
   }
   return { autoFields, sliceAutoFields, params, accessors: [...autoAccessors, ...choiceAccessors] };
 };
@@ -2007,12 +2122,12 @@ var generateFieldAccessors = (w, className, factoryInfo, extSliceMethodBaseNames
   for (const p of factoryInfo.params) {
     const fieldName = pyFieldName(p.name, fmt);
     const methodSuffix = pySnakeName(p.name);
-    w.line(`def get_${methodSuffix}(self) -> ${p.pyType} | None:`);
+    w.line(`def get_${methodSuffix}(self) -> ${p.pyType} | None:${p.refComment ?? ""}`);
     w.indentBlock(() => {
       w.line(`return cast('${p.pyType} | None', getattr(self._resource, ${JSON.stringify(fieldName)}, None))`);
     });
     w.line();
-    w.line(`def set_${methodSuffix}(self, value: ${p.pyType}) -> "${className}":`);
+    w.line(`def set_${methodSuffix}(self, value: ${p.pyType}) -> "${className}":${p.refComment ?? ""}`);
     w.indentBlock(() => {
       w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, value)`);
       w.line("return self");
@@ -2023,12 +2138,12 @@ var generateFieldAccessors = (w, className, factoryInfo, extSliceMethodBaseNames
     const methodSuffix = pySnakeName(a.name);
     if (extSliceMethodBaseNames.has(methodSuffix)) continue;
     const fieldName = pyFieldName(a.name, fmt);
-    w.line(`def get_${methodSuffix}(self) -> ${a.pyType} | None:`);
+    w.line(`def get_${methodSuffix}(self) -> ${a.pyType} | None:${a.refComment ?? ""}`);
     w.indentBlock(() => {
       w.line(`return cast('${a.pyType} | None', getattr(self._resource, ${JSON.stringify(fieldName)}, None))`);
     });
     w.line();
-    w.line(`def set_${methodSuffix}(self, value: ${a.pyType}) -> "${className}":`);
+    w.line(`def set_${methodSuffix}(self, value: ${a.pyType}) -> "${className}":${a.refComment ?? ""}`);
     w.indentBlock(() => {
       if (a.choiceSiblings?.length) {
         for (const sibling of a.choiceSiblings) {
@@ -2043,94 +2158,125 @@ var generateFieldAccessors = (w, className, factoryInfo, extSliceMethodBaseNames
 };
 
 // src/api/writer-generator/python/profile-validation.ts
-var collectValidateBody = (flatProfile, resolveRef, errorLines, warningLines, formatName2) => {
+var pushListValidation = (lines, target, fn, args, items) => {
+  const argList = ["self._resource", "profile_name", ...args].join(", ");
+  lines.push(
+    `${target}.extend(`,
+    `    ${fn}(${argList}, [`,
+    `        ${items.map((i) => JSON.stringify(i)).join(",")}`,
+    "]))"
+  );
+};
+var collectValidateBody = (flatProfile, tsIndex, errorLines, warningLines, formatName2) => {
   const helpers = /* @__PURE__ */ new Set();
   const fields = flatProfile.fields;
   for (const [name, field] of Object.entries(fields)) {
     const pyName = pyFieldName(name, formatName2);
-    if (isChoiceInstanceField(field)) {
-      collectProhibitedChoiceValidation(fields, name, pyName, helpers, errorLines);
-      continue;
-    }
+    if (isChoiceInstanceField(field)) continue;
     if (isChoiceDeclarationField(field)) {
       if (field.required) {
         helpers.add("validate_choice_required");
         const pyChoices = field.choices.map((c) => pyFieldName(c, formatName2));
-        errorLines.push(
-          `errors.extend(validate_choice_required(self._resource, profile_name, ${JSON.stringify(pyChoices)}))`
-        );
+        pushListValidation(errorLines, "errors", "validate_choice_required", [], pyChoices);
+      }
+      if (field.prohibited?.length) {
+        helpers.add("validate_choice_prohibited");
+        const pyProhibited = field.prohibited.map((c) => pyFieldName(c, formatName2));
+        pushListValidation(errorLines, "errors", "validate_choice_prohibited", [], pyProhibited);
       }
       continue;
     }
-    if (field.excluded) {
-      helpers.add("validate_excluded");
-      errorLines.push(
-        `errors.extend(validate_excluded(self._resource, profile_name, ${JSON.stringify(pyName)}))`
-      );
-      continue;
-    }
-    if (field.required) {
-      helpers.add("validate_required");
-      errorLines.push(
-        `errors.extend(validate_required(self._resource, profile_name, ${JSON.stringify(pyName)}))`
+    collectRegularFieldValidation(
+      field,
+      flatProfile.slicing?.[name],
+      pyName,
+      helpers,
+      errorLines,
+      warningLines,
+      tsIndex,
+      formatName2
+    );
+  }
+  for (const inheritedName of flatProfile.inheritedRequiredFields ?? []) {
+    helpers.add("validate_required");
+    errorLines.push(
+      `errors.extend(validate_required(self._resource, profile_name, ${JSON.stringify(pyFieldName(inheritedName, formatName2))}))`
+    );
+  }
+  return helpers;
+};
+var collectRegularFieldValidation = (field, fieldSlicing, pyName, helpers, errorLines, warningLines, tsIndex, formatName2) => {
+  if (field.excluded) {
+    helpers.add("validate_excluded");
+    errorLines.push(`errors.extend(validate_excluded(self._resource, profile_name, ${JSON.stringify(pyName)}))`);
+    return;
+  }
+  if (field.required) {
+    helpers.add("validate_required");
+    errorLines.push(`errors.extend(validate_required(self._resource, profile_name, ${JSON.stringify(pyName)}))`);
+  }
+  if (field.valueConstraint) {
+    helpers.add("validate_fixed_value");
+    const value = JSON.stringify(field.valueConstraint.value);
+    errorLines.push(
+      `errors.extend(validate_fixed_value(self._resource, profile_name, ${JSON.stringify(pyName)}, ${value}))`
+    );
+  }
+  if (isNotChoiceDeclarationField(field)) {
+    if (field.enum) {
+      helpers.add("validate_enum");
+      const target = field.enum.isOpen ? warningLines : errorLines;
+      const listName = field.enum.isOpen ? "warnings" : "errors";
+      pushListValidation(target, listName, "validate_enum", [JSON.stringify(pyName)], field.enum.values);
+    }
+    if (field.mustSupport && !field.required) {
+      helpers.add("validate_must_support");
+      warningLines.push(
+        `warnings.extend(validate_must_support(self._resource, profile_name, ${JSON.stringify(pyName)}))`
       );
     }
-    if (field.valueConstraint) {
-      helpers.add("validate_fixed_value");
-      const value = JSON.stringify(field.valueConstraint.value);
-      errorLines.push(
-        `errors.extend(validate_fixed_value(self._resource, profile_name, ${JSON.stringify(pyName)}, ${value}))`
-      );
+    if (field.reference && field.reference.resource.length > 0) {
+      helpers.add("validate_reference");
+      const allowed = field.reference.resource.map((ref) => tsIndex.findLastSpecializationByIdentifier(ref).name);
+      pushListValidation(errorLines, "errors", "validate_reference", [JSON.stringify(pyName)], allowed);
     }
-    if (isNotChoiceDeclarationField(field)) {
-      if (field.enum) {
-        helpers.add("validate_enum");
-        const target = field.enum.isOpen ? warningLines : errorLines;
-        const listName = field.enum.isOpen ? "warnings" : "errors";
-        target.push(
-          `${listName}.extend(validate_enum(self._resource, profile_name, ${JSON.stringify(pyName)}, ${JSON.stringify(field.enum.values)}))`
-        );
-      }
-      if (field.mustSupport && !field.required) {
-        helpers.add("validate_must_support");
-        warningLines.push(
-          `warnings.extend(validate_must_support(self._resource, profile_name, ${JSON.stringify(pyName)}))`
-        );
-      }
-      if (field.reference && field.reference.length > 0) {
-        helpers.add("validate_reference");
-        const allowed = field.reference.map((ref) => resolveRef(ref).name);
-        errorLines.push(
-          `errors.extend(validate_reference(self._resource, profile_name, ${JSON.stringify(pyName)}, ${JSON.stringify(allowed)}))`
-        );
-      }
-      if (field.slicing?.slices) {
-        collectSliceCardinalityValidation(field, pyName, helpers, errorLines);
-      }
+    if (fieldSlicing?.slices) {
+      collectSliceValidation(field, fieldSlicing, pyName, helpers, errorLines, tsIndex, formatName2);
     }
   }
-  return helpers;
 };
-var collectProhibitedChoiceValidation = (fields, name, pyName, helpers, errorLines) => {
-  const field = fields[name];
-  if (!field || !isChoiceInstanceField(field)) return;
-  const decl = fields[field.choiceOf];
-  if (!decl || !isChoiceDeclarationField(decl) || !decl.prohibited?.includes(name)) return;
-  helpers.add("validate_excluded");
-  errorLines.push(`errors.extend(validate_excluded(self._resource, profile_name, ${JSON.stringify(pyName)}))`);
-};
-var collectSliceCardinalityValidation = (field, name, helpers, errorLines) => {
-  if (!field.slicing?.slices) return;
-  for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
-    if (slice.min === void 0 && slice.max === void 0) continue;
+var collectSliceValidation = (field, fieldSlicing, name, helpers, errorLines, tsIndex, formatName2) => {
+  if (!fieldSlicing.slices) return;
+  for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
     const match = slice.match ?? {};
     if (Object.keys(match).length === 0) continue;
-    const min = slice.min ?? 0;
-    const max = slice.max ?? 0;
-    helpers.add("validate_slice_cardinality");
-    errorLines.push(
-      `errors.extend(validate_slice_cardinality(self._resource, profile_name, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max}))`
-    );
+    if (slice.min !== void 0 || slice.max !== void 0) {
+      const min = slice.min ?? 0;
+      const max = slice.max ?? 0;
+      helpers.add("validate_slice_cardinality");
+      errorLines.push(
+        `errors.extend(validate_slice_cardinality(self._resource, profile_name, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max}))`
+      );
+    }
+    const sliceRequiredFields = [];
+    const matchKeys = new Set(Object.keys(match));
+    for (const rf of slice.required ?? []) {
+      if (!matchKeys.has(rf)) sliceRequiredFields.push(pyFieldName(rf, formatName2));
+    }
+    if (field.type && slice.elements) {
+      const cc = tsIndex.constrainedChoice(field.type.package, field.type, slice.elements);
+      if (cc) sliceRequiredFields.push(pyFieldName(cc.variant, formatName2));
+    }
+    if (sliceRequiredFields.length > 0) {
+      helpers.add("validate_slice_fields");
+      pushListValidation(
+        errorLines,
+        "errors",
+        "validate_slice_fields",
+        [JSON.stringify(name), JSON.stringify(match), JSON.stringify(sliceName)],
+        sliceRequiredFields
+      );
+    }
   }
 };
 
@@ -2188,6 +2334,10 @@ var collectHelperImports = (isResourceBase, factoryInfo, sliceDefs, extensions,
     imports.push("_get_key", "is_extension", "get_extension_value", "push_extension");
     if (extensions.some((ext) => ext.isComplex && ext.subExtensions)) imports.push("extract_complex_extension");
     if (extensions.some((ext) => ext.path.split(".").some((s) => s !== "extension"))) imports.push("ensure_path");
+    const hasDictFormSetter = extensions.some(
+      (ext) => ext.isComplex && ext.subExtensions || !(ext.valueFieldTypes?.length === 1 && ext.valueFieldTypes[0])
+    );
+    if (hasDictFormSetter) imports.push("is_record");
   }
   imports.push(...validationHelpers);
   imports.sort();
@@ -2369,13 +2519,7 @@ var generateProfileModule = (w, tsIndex, flatProfile) => {
   const resolvedNames = resolveProfileMethodBaseNames(extensions, sliceDefs);
   const errorLines = [];
   const warningLines = [];
-  const validationHelpers = collectValidateBody(
-    flatProfile,
-    tsIndex.findLastSpecializationByIdentifier,
-    errorLines,
-    warningLines,
-    w.nameFormatFunction
-  );
+  const validationHelpers = collectValidateBody(flatProfile, tsIndex, errorLines, warningLines, w.nameFormatFunction);
   const helperImports = collectHelperImports(isResourceBase, factoryInfo, sliceDefs, extensions, validationHelpers);
   const typeImports = collectTypeImports(
     w.opts.rootPackageName,
@@ -2482,7 +2626,8 @@ var AVAILABLE_STRING_FORMATS = {
 var MAX_IMPORT_LINE_LENGTH = 100;
 var GENERIC_FIELD_REWRITES = {
   Coding: { code: "T" },
-  CodeableConcept: { coding: "Coding[T]" }
+  CodeableConcept: { coding: "Coding[T]" },
+  Reference: { type: "T" }
 };
 var leafOf2 = (path) => path[path.length - 1] ?? "";
 var collectResourceGenericTypeVars = (schema) => {
@@ -2789,13 +2934,9 @@ var Python = class extends Writer {
   }
   generateResourceTypeField(schema) {
     const hasChildren = (schema.typeFamily?.resources?.length ?? 0) > 0;
-    if (hasChildren) {
-      this.line(`${this.nameFormatFunction("resourceType")}: str = Field(`);
-    } else {
-      this.line(`${this.nameFormatFunction("resourceType")}: Literal['${schema.identifier.name}'] = Field(`);
-    }
+    this.line(`${this.nameFormatFunction("resourceType")}: str = Field(`);
     this.indentBlock(() => {
-      this.line(`default='${schema.identifier.name}',`);
+      if (!hasChildren) this.line(`default='${schema.identifier.name}',`);
       this.line(`alias='resourceType',`);
       this.line(`serialization_alias='resourceType',`);
       if (!this.forFhirpyClient) {
@@ -2883,6 +3024,11 @@ var Python = class extends Writer {
         fieldType = `Literal[${s}]`;
       }
     }
+    if (fieldType === "Reference" && "reference" in field && field.reference) {
+      assert4(this.tsIndex !== void 0);
+      const typeParam = pyReferenceTypeParam(field, this.tsIndex);
+      if (typeParam) fieldType = `Reference[${typeParam}]`;
+    }
     if (field.array) {
       fieldType = `PyList[${fieldType}]`;
     }
@@ -3034,6 +3180,18 @@ var Python = class extends Writer {
   }
 };
 
+// src/typeschema/collision-order.ts
+var compareStrings = (left, right) => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+var compareCollisionSources = (left, right) => compareStrings(left.sourcePackage, right.sourcePackage) || compareStrings(left.sourceCanonical, right.sourceCanonical);
+var collisionSourcesKey = (sources) => JSON.stringify(
+  [...sources].sort(compareCollisionSources).map(({ sourcePackage, sourceCanonical }) => [sourcePackage, sourceCanonical])
+);
+var compareCollisionVariants = (left, right) => right.sources.length - left.sources.length || compareStrings(collisionSourcesKey(left.sources), collisionSourcesKey(right.sources)) || compareStrings(left.schemaHash, right.schemaHash);
+
 // src/typeschema/skip-hack.ts
 var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
 var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
@@ -3346,9 +3504,9 @@ var assignRecommendedBaseNames = (profile) => {
     key: `ext:${ext.url}:${ext.path}`,
     candidates: ext.nameCandidates.candidates
   }));
-  const sliceEntries = Object.entries(profile.fields ?? {}).flatMap(([fieldName, field]) => {
-    if (!("slicing" in field) || !field.slicing?.slices) return [];
-    return Object.entries(field.slicing.slices).map(([sliceName, slice]) => ({
+  const sliceEntries = Object.entries(profile.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
+    if (!fieldSlicing.slices) return [];
+    return Object.entries(fieldSlicing.slices).map(([sliceName, slice]) => ({
       key: `slice:${fieldName}:${sliceName}`,
       candidates: slice.nameCandidates.candidates
     }));
@@ -3362,9 +3520,9 @@ var assignRecommendedBaseNames = (profile) => {
     const key = `ext:${ext.url}:${ext.path}`;
     if (resolved[key]) ext.nameCandidates.recommended = resolved[key];
   }
-  for (const [fieldName, field] of Object.entries(profile.fields ?? {})) {
-    if (!("slicing" in field) || !field.slicing?.slices) continue;
-    for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
+  for (const [fieldName, fieldSlicing] of Object.entries(profile.slicing ?? {})) {
+    if (!fieldSlicing.slices) continue;
+    for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
       const key = `slice:${fieldName}:${sliceName}`;
       if (resolved[key]) slice.nameCandidates.recommended = resolved[key];
     }
@@ -3571,8 +3729,8 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
           if (!sd.package_name) {
             return {
               ...sd,
-              package_name: pkgIndex.pkg.name,
-              package_version: pkgIndex.pkg.version
+              package_name: r.pkg.name,
+              package_version: r.pkg.version
             };
           }
           return sd;
@@ -3701,6 +3859,7 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
 }
 function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
   const fields = {};
+  const slicing = {};
   const genealogy = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
   const elemGenealogy = resolveFsElementGenealogy(genealogy, parentPath);
   const allKeys = /* @__PURE__ */ new Set();
@@ -3719,8 +3878,10 @@ function transformNestedElements(register, fhirSchema, parentPath, elements, log
     } else {
       fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
+    const fieldSlicing = buildSlicing(key, elemSnapshot);
+    if (fieldSlicing) slicing[key] = fieldSlicing;
   }
-  return fields;
+  return { fields, slicing: Object.keys(slicing).length > 0 ? slicing : void 0 };
 }
 function mkNestedTypes(register, fhirSchema, logger) {
   if (!fhirSchema.elements) return void 0;
@@ -3750,11 +3911,12 @@ function mkNestedTypes(register, fhirSchema, logger) {
       name: baseName,
       url: baseUrl
     };
-    const fields = transformNestedElements(register, fhirSchema, path, element.elements ?? {}, logger);
+    const { fields, slicing } = transformNestedElements(register, fhirSchema, path, element.elements ?? {}, logger);
     const nestedType = {
       identifier,
       base,
-      fields
+      fields,
+      slicing
     };
     nestedTypes.push(nestedType);
   }
@@ -3837,12 +3999,27 @@ function isExcluded(register, fhirSchema, path) {
 }
 var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
-  return element.refers.map((ref) => {
+  const resource = [];
+  const profiles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of element.refers) {
     const curl = register.ensureSpecializationCanonicalUrl(ref);
     const fs6 = register.resolveFs(fhirSchema.package_meta, curl);
     if (!fs6) throw new Error(`Failed to resolve fs for ${curl}`);
-    return mkIdentifier(fs6);
-  });
+    const id = mkIdentifier(fs6);
+    let resolved = id;
+    if (isProfileIdentifier(id)) {
+      profiles.push(id);
+      const baseFs = register.resolveFsSpecializations(fs6.package_meta, fs6.url)[0];
+      if (!baseFs) throw new Error(`Failed to resolve base specialization for ${curl}`);
+      resolved = mkIdentifier(baseFs);
+    }
+    if (!seen.has(resolved.url)) {
+      seen.add(resolved.url);
+      resource.push(resolved);
+    }
+  }
+  return { resource, profiles: profiles.length > 0 ? profiles : void 0 };
 };
 var extractSliceFieldNames = (schema) => {
   const required = /* @__PURE__ */ new Set();
@@ -4068,7 +4245,6 @@ var mkField = (register, fhirSchema, path, element, logger, rawElement) => {
     array: element.array || false,
     min: element.min,
     max: element.max,
-    slicing: buildSlicing(path[path.length - 1] ?? "", element),
     choices: element.choices,
     choiceOf: element.choiceOf,
     binding,
@@ -4083,8 +4259,7 @@ function mkNestedField(register, fhirSchema, path, element) {
     type: nestedIdentifier,
     array: element.array || false,
     required: isRequired(register, fhirSchema, path),
-    excluded: isExcluded(register, fhirSchema, path),
-    slicing: buildSlicing(path[path.length - 1] ?? "", element)
+    excluded: isExcluded(register, fhirSchema, path)
   };
 }
 
@@ -4223,8 +4398,9 @@ var extractProfileExtensions = (register, fhirSchema, logger) => {
 
 // src/typeschema/core/transformer.ts
 function mkFields(register, fhirSchema, parentPath, elements, logger) {
-  if (!elements) return void 0;
+  if (!elements) return {};
   const fields = {};
+  const slicing = {};
   for (const key of register.getAllElementKeys(elements)) {
     const path = [...parentPath, key];
     const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
@@ -4241,8 +4417,10 @@ function mkFields(register, fhirSchema, parentPath, elements, logger) {
     } else {
       fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger, elements[key]);
     }
+    const fieldSlicing = buildSlicing(key, elemSnapshot);
+    if (fieldSlicing) slicing[key] = fieldSlicing;
   }
-  return fields;
+  return { fields, slicing: Object.keys(slicing).length > 0 ? slicing : void 0 };
 }
 function extractFieldDependencies(fields) {
   const deps = [];
@@ -4303,7 +4481,7 @@ function transformFhirSchema(register, fhirSchema, logger) {
     assert4(!isNestedIdentifier(baseId), `Unexpected nested base for ${fhirSchema.url}`);
     base = baseId;
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const { fields, slicing } = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
   const nested = mkNestedTypes(register, fhirSchema, logger);
   const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
   if (fhirSchema.derivation === "constraint") {
@@ -4316,6 +4494,7 @@ function transformFhirSchema(register, fhirSchema, logger) {
       identifier: identifier2,
       base,
       fields,
+      slicing,
       nested,
       description: fhirSchema.description,
       dependencies: concatIdentifiers(rawDeps, extensionDeps),
@@ -4342,6 +4521,7 @@ function transformFhirSchema(register, fhirSchema, logger) {
     identifier,
     base,
     fields,
+    slicing,
     nested,
     description: fhirSchema.description,
     dependencies: extractDependencies(identifier, base, fields, nested),
@@ -4363,7 +4543,11 @@ var deduplicateSchemas = (schemasWithSources, resolveCollisions, logger) => {
   const schemas = [];
   const collisions = {};
   for (const versions of Object.values(groups)) {
-    const sorted = Object.values(versions).sort((a, b) => b.sources.length - a.sources.length);
+    const sorted = Object.entries(versions).map(([schemaHash, version]) => ({
+      ...version,
+      schemaHash,
+      sources: [...version.sources].sort(compareCollisionSources)
+    })).sort(compareCollisionVariants);
     const best = sorted[0];
     if (!best) continue;
     if (sorted.length > 1) {
@@ -4588,6 +4772,10 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
   if (isProfileTypeSchema(schema) && rule.ignoreExtensions) {
     mutableIgnoreExtensions(schema, rule.ignoreExtensions);
   }
+  if (schema.slicing) {
+    const kept = Object.fromEntries(Object.entries(schema.slicing).filter(([name]) => schema.fields?.[name]));
+    schema.slicing = Object.keys(kept).length > 0 ? kept : void 0;
+  }
   if (schema.nested) {
     const usedTypes = /* @__PURE__ */ new Set();
     const collectUsedNestedTypes = (s) => {
@@ -4616,16 +4804,36 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
   }
   return schema;
 };
-var treeShake = (tsIndex, treeShake2) => {
+var collectReferenceTargets = (schema) => {
+  if (!isSpecializationTypeSchema(schema) && !isProfileTypeSchema(schema)) return [];
+  const fieldSets = [schema.fields, ...(schema.nested ?? []).map((n) => n.fields)];
+  return fieldSets.flatMap(
+    (fields) => Object.values(fields ?? {}).filter(isNotChoiceDeclarationField).flatMap((f) => [...f.reference?.resource ?? [], ...f.reference?.profiles ?? []]).filter((id) => !isNestedIdentifier(id))
+  );
+};
+var treeShake = (tsIndex, treeShake2, defaults) => {
   const focusedSchemas = [];
+  const followedSchemas = [];
   for (const [pkgId, requires] of Object.entries(treeShake2)) {
     for (const [url, rule] of Object.entries(requires)) {
       const schema = tsIndex.resolveByUrl(pkgId, url);
       if (!schema || isNestedTypeSchema(schema)) throw new Error(`Schema not found for ${pkgId} ${url}`);
       const shaked2 = treeShakeTypeSchema(schema, rule);
       focusedSchemas.push(shaked2);
+      if (rule.followReferences ?? defaults?.followReferences) {
+        for (const refId of collectReferenceTargets(shaked2)) {
+          const refSchema = tsIndex.resolve(refId);
+          if (!refSchema)
+            throw new Error(`Reference target ${JSON.stringify(refId)} not found for ${pkgId} ${url}`);
+          followedSchemas.push(refSchema);
+        }
+      }
     }
   }
+  const rootIds = new Set(focusedSchemas.map((s) => JSON.stringify(s.identifier)));
+  for (const schema of followedSchemas) {
+    if (!rootIds.has(JSON.stringify(schema.identifier))) focusedSchemas.push(schema);
+  }
   const collectDeps = (schemas, acc) => {
     if (schemas.length === 0) return Object.values(acc);
     for (const schema of schemas) {
@@ -4664,7 +4872,8 @@ var normalizeFileName = (str) => {
 };
 var typeSchemaToJson = (ts, pretty) => {
   const pkgPath = normalizeFileName(ts.identifier.package);
-  const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`);
+  const suffix = isSnapshotProfileTypeSchema(ts) ? ".snapshot" : "";
+  const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`) + suffix;
   const baseName = Path5.join(pkgPath, name);
   return {
     filename: baseName,
@@ -4698,17 +4907,19 @@ var IntrospectionWriter = class extends FileSystemWriter {
       this.logger()?.info(`IntrospectionWriter: Type tree written to ${this.opts.typeTree}`);
     }
     if (this.opts.typeSchemas) {
-      if (Path5.extname(this.opts.typeSchemas) === ".ndjson") {
-        await this.writeNdjson(tsIndex.schemas, this.opts.typeSchemas, typeSchemaToJson);
+      const tsOpts = typeof this.opts.typeSchemas === "string" ? { target: this.opts.typeSchemas } : this.opts.typeSchemas;
+      const schemas = tsOpts.profileSnapshots ? [...tsIndex.schemas, ...tsIndex.collectSnapshotProfiles()] : tsIndex.schemas;
+      if (Path5.extname(tsOpts.target) === ".ndjson") {
+        await this.writeNdjson(schemas, tsOpts.target, typeSchemaToJson);
       } else {
-        const items = tsIndex.schemas.map((ts) => typeSchemaToJson(ts, true));
+        const items = schemas.map((ts) => typeSchemaToJson(ts, true));
         const seenFilenames = /* @__PURE__ */ new Set();
         const dedupedItems = items.filter((item) => {
           if (seenFilenames.has(item.filename)) return false;
           seenFilenames.add(item.filename);
           return true;
         });
-        this.cd(this.opts.typeSchemas, () => {
+        this.cd(tsOpts.target, () => {
           for (const { filename, genContent } of dedupedItems) {
             const fileName = `${filename}.json`;
             this.cd(Path5.dirname(fileName), () => {
@@ -4739,15 +4950,15 @@ var IntrospectionWriter = class extends FileSystemWriter {
           }
         });
       }
-      this.logger()?.info(
-        `IntrospectionWriter: ${tsIndex.schemas.length} TypeSchema written to ${this.opts.typeSchemas}`
-      );
+      this.logger()?.info(`IntrospectionWriter: ${schemas.length} TypeSchema written to ${tsOpts.target}`);
     }
+    const indexUrls = new Set(tsIndex.schemas.map((ts) => ts.identifier.url));
     if (this.opts.fhirSchemas && tsIndex.register) {
       const outputPath = this.opts.fhirSchemas;
       const allFs = tsIndex.register.allFs();
       const seenUrls = /* @__PURE__ */ new Set();
       const fhirSchemas = allFs.filter((fs6) => {
+        if (!indexUrls.has(fs6.url)) return false;
         if (seenUrls.has(fs6.url)) return false;
         seenUrls.add(fs6.url);
         return true;
@@ -4767,6 +4978,7 @@ var IntrospectionWriter = class extends FileSystemWriter {
       const allSd = tsIndex.register.allSd();
       const seenUrls = /* @__PURE__ */ new Set();
       const structureDefinitions = allSd.filter((sd) => {
+        if (!indexUrls.has(sd.url)) return false;
         if (seenUrls.has(sd.url)) return false;
         seenUrls.add(sd.url);
         return true;
@@ -4865,11 +5077,15 @@ var generatePackageSection = (lines, pkgName, treeShakePkg, promotedCanonicals)
 var groupCollisionVersions = (entries, resolution) => {
   const uniqueSchemas = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    const key = JSON.stringify(entry.typeSchema);
+    const key = hashSchema(entry.typeSchema);
     if (!uniqueSchemas.has(key)) uniqueSchemas.set(key, []);
     uniqueSchemas.get(key)?.push(entry);
   }
-  const sorted = [...uniqueSchemas.values()].sort((a, b) => b.length - a.length);
+  const sorted = [...uniqueSchemas.entries()].map(([schemaHash, group]) => ({
+    entries: [...group].sort(compareCollisionSources),
+    schemaHash,
+    sources: group
+  })).sort(compareCollisionVariants).map((group) => group.entries);
   const markVersion = (group, i) => {
     if (resolution)
       return group.some(
@@ -5769,9 +5985,21 @@ var resolveFieldTsType = (schemaName, tsName, field, resolveRef, genericFieldMap
     if (field.type.name === "CodeableConcept") return `CodeableConcept<${tsEnumType(field.enum)}>`;
     return tsEnumType(field.enum);
   }
-  if (field.reference && field.reference.length > 0) {
-    const resolved = field.reference.map((ref) => resolveRef ? resolveRef(ref) : ref);
-    const references = resolved.map((ref) => isFamilyType?.(ref) ? `string /* ${ref.name} */` : `"${ref.name}"`).join(" | ");
+  if (field.reference && field.reference.resource.length > 0) {
+    const profilesByResource = {};
+    if (resolveRef) {
+      for (const profile of field.reference.profiles ?? []) {
+        const base = resolveRef(profile).name;
+        (profilesByResource[base] ??= []).push(profile.url);
+      }
+    }
+    const references = field.reference.resource.map((original) => {
+      const ref = resolveRef ? resolveRef(original) : original;
+      if (isFamilyType?.(ref)) return `string /* ${ref.name} */`;
+      const profiles = profilesByResource[ref.name];
+      if (profiles) return `"${ref.name}" /* ${profiles.join(", ")} */`;
+      return `"${ref.name}"`;
+    }).join(" | ");
     return `Reference<${references}>`;
   }
   if (isPrimitiveIdentifier(field.type)) return resolvePrimitiveType(field.type.name);
@@ -5820,9 +6048,10 @@ var valueFieldToTsType = (valueField) => {
 };
 var collectSubExtensionSlices = (extProfile) => {
   const extensionField = extProfile.fields.extension;
-  if (!extensionField || isChoiceDeclarationField(extensionField) || !extensionField.slicing?.slices) return [];
+  const extensionSlicing = extProfile.slicing?.extension;
+  if (!extensionField || isChoiceDeclarationField(extensionField) || !extensionSlicing?.slices) return [];
   const result = [];
-  for (const [sliceName, slice] of Object.entries(extensionField.slicing.slices)) {
+  for (const [sliceName, slice] of Object.entries(extensionSlicing.slices)) {
     const valueField = extractValueField(slice.elements);
     if (!valueField) continue;
     const tsType = valueFieldToTsType(valueField);
@@ -6160,10 +6389,11 @@ var extractResourceTypeFromMatch = (match) => {
 };
 var collectTypesFromSlices = (tsIndex, snapshot, addType) => {
   const pkgName = snapshot.identifier.package;
-  for (const field of Object.values(snapshot.fields)) {
-    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) continue;
-    const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
-    for (const slice of Object.values(field.slicing.slices)) {
+  for (const [fieldName, fieldSlicing] of Object.entries(snapshot.slicing ?? {})) {
+    const field = snapshot.fields[fieldName];
+    if (!isNotChoiceDeclarationField(field) || !fieldSlicing.slices || !field.type) continue;
+    const isTypeDisc = isTypeDiscriminated(fieldSlicing);
+    for (const slice of Object.values(fieldSlicing.slices)) {
       if (Object.keys(slice.match ?? {}).length > 0) {
         addType(field.type);
         const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
@@ -6181,11 +6411,10 @@ var collectTypesFromSlices = (tsIndex, snapshot, addType) => {
     }
   }
 };
-var collectRequiredSliceNames2 = (field) => {
-  if (!field.array || !field.slicing?.slices) return void 0;
-  const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
-  if (isTypeDisc) return void 0;
-  const names = Object.entries(field.slicing.slices).filter(([_, s]) => {
+var collectRequiredSliceNames2 = (field, fieldSlicing) => {
+  if (!field.array || !fieldSlicing?.slices) return void 0;
+  if (isTypeDiscriminated(fieldSlicing)) return void 0;
+  const names = Object.entries(fieldSlicing.slices).filter(([_, s]) => {
     if (s.min === void 0 || s.min < 1 || !s.match || Object.keys(s.match).length === 0) return false;
     const matchKeys = new Set(Object.keys(s.match));
     const requiredBeyondMatch = (s.required ?? []).filter((name) => !matchKeys.has(name));
@@ -6193,13 +6422,14 @@ var collectRequiredSliceNames2 = (field) => {
   }).map(([name]) => name);
   return names.length > 0 ? names : void 0;
 };
-var collectSliceDefs2 = (tsIndex, snapshot) => Object.entries(snapshot.fields).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
-  if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
+var collectSliceDefs2 = (tsIndex, snapshot) => Object.entries(snapshot.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
+  const field = snapshot.fields[fieldName];
+  if (!isNotChoiceDeclarationField(field) || !fieldSlicing.slices || !field.type) return [];
   const baseType = tsTypeFromIdentifier(field.type);
   const pkgName = snapshot.identifier.package;
   const choiceBaseNames = collectChoiceBaseNames(tsIndex, field.type);
-  const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
-  return Object.entries(field.slicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
+  const isTypeDisc = isTypeDiscriminated(fieldSlicing);
+  return Object.entries(fieldSlicing.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)
@@ -6373,7 +6603,7 @@ var generateSliceGetters2 = (w, sliceDefs, snapshot) => {
 };
 
 // src/api/writer-generator/typescript/profile-validation.ts
-var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef, canonicalUrlExpr, tsIndex) => {
+var collectRegularFieldValidation2 = (errors, warnings, name, field, resolveRef, canonicalUrlExpr, tsIndex, fieldSlicing) => {
   if (field.excluded) {
     errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
     return;
@@ -6389,12 +6619,12 @@ var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef,
   }
   if (field.mustSupport && !field.required)
     warnings.push(`...validateMustSupport(res, profileName, ${JSON.stringify(name)})`);
-  if (field.reference && field.reference.length > 0)
+  if (field.reference && field.reference.resource.length > 0)
     errors.push(
-      `...validateReference(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.reference.map((ref) => resolveRef(ref).name))})`
+      `...validateReference(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.reference.resource.map((ref) => resolveRef(ref).name))})`
     );
-  if (field.slicing?.slices) {
-    for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
+  if (fieldSlicing?.slices) {
+    for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
       const match = slice.match ?? {};
       if (Object.keys(match).length === 0) continue;
       if (slice.min !== void 0 || slice.max !== void 0) {
@@ -6432,25 +6662,23 @@ var generateValidateMethod2 = (w, tsIndex, snapshot) => {
     const errors = [];
     const warnings = [];
     for (const [name, field] of Object.entries(fields)) {
-      if (isChoiceInstanceField(field)) {
-        const decl = fields[field.choiceOf];
-        if (decl && isChoiceDeclarationField(decl) && decl.prohibited?.includes(name))
-          errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
-        continue;
-      }
+      if (isChoiceInstanceField(field)) continue;
       if (isChoiceDeclarationField(field)) {
         if (field.required)
           errors.push(`...validateChoiceRequired(res, profileName, ${JSON.stringify(field.choices)})`);
+        if (field.prohibited?.length)
+          errors.push(`...validateChoiceProhibited(res, profileName, ${JSON.stringify(field.prohibited)})`);
         continue;
       }
-      collectRegularFieldValidation(
+      collectRegularFieldValidation2(
         errors,
         warnings,
         name,
         field,
         tsIndex.findLastSpecializationByIdentifier,
         canonicalUrlExpr,
-        tsIndex
+        tsIndex,
+        snapshot.slicing?.[name]
       );
     }
     for (const inheritedName of snapshot.inheritedRequiredFields ?? []) {
@@ -6544,7 +6772,7 @@ var collectProfileFactoryInfo2 = (tsIndex, snapshot) => {
       continue;
     }
     if (isNotChoiceDeclarationField(field)) {
-      const sliceNames = collectRequiredSliceNames2(field);
+      const sliceNames = collectRequiredSliceNames2(field, snapshot.slicing?.[name]);
       if (sliceNames) {
         if (field.type) {
           const tsType = fieldTsType(field, resolveRef, isFamilyType);
@@ -6644,6 +6872,7 @@ var generateProfileHelpersImport = (w, tsIndex, snapshot, sliceDefs, factoryInfo
       "validateEnum",
       "validateReference",
       "validateChoiceRequired",
+      "validateChoiceProhibited",
       "validateMustSupport"
     );
   if (imports.length > 0) {
@@ -7666,6 +7895,10 @@ var APIBuilder = class {
       assert4(this.options.typeSchema.treeShake === void 0, "treeShake option is already set");
       this.options.typeSchema.treeShake = cfg.treeShake;
     }
+    if (cfg.treeShakeDefaults) {
+      assert4(this.options.typeSchema.treeShakeDefaults === void 0, "treeShakeDefaults option is already set");
+      this.options.typeSchema.treeShakeDefaults = cfg.treeShakeDefaults;
+    }
     if (cfg.promoteLogical) {
       assert4(this.options.typeSchema.promoteLogical === void 0, "promoteLogical option is already set");
       this.options.typeSchema.promoteLogical = cfg.promoteLogical;
@@ -7740,7 +7973,12 @@ var APIBuilder = class {
       };
       const tsIndexOpts = { register, irReport, logger: tsLogger };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
-      if (this.options.typeSchema?.treeShake) tsIndex = treeShake(tsIndex, this.options.typeSchema.treeShake);
+      if (this.options.typeSchema?.treeShake)
+        tsIndex = treeShake(
+          tsIndex,
+          this.options.typeSchema.treeShake,
+          this.options.typeSchema.treeShakeDefaults
+        );
       if (this.options.typeSchema?.promoteLogical)
         tsIndex = promoteLogical(tsIndex, this.options.typeSchema.promoteLogical);
       tsLogger.printTagSummary();