@contractkit/plugin-csharp 0.0.0

package/dist/index.js

@@ -0,0 +1,2569 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { dirname, join, resolve } from "path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "fs";
+import { buildModelIndex as buildModelIndex2, collectTransitiveModelRefs, collectTypeRefs as collectTypeRefs2, emptyIncrementalManifest, hashFingerprint, parseIncrementalManifest, runIncrementalCodegen, serializeIncrementalManifest } from "@contractkit/core";
+
+// src/codegen-models.ts
+import { buildModelIndex, computeModelsWithInput, resolveEffectiveFields, topoSortModels } from "@contractkit/core";
+
+// src/naming.ts
+var CSHARP_KEYWORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while"
+]);
+var RESERVED_MEMBER_NAMES = /* @__PURE__ */ new Set([
+  "Equals",
+  "GetHashCode",
+  "GetType",
+  "ToString",
+  "EqualityContract",
+  "PrintMembers"
+]);
+function escapeCSharpIdentifier(name) {
+  return CSHARP_KEYWORDS.has(name) ? `@${name}` : name;
+}
+__name(escapeCSharpIdentifier, "escapeCSharpIdentifier");
+function toCSharpPropertyName(name) {
+  const words = splitWords(name);
+  if (words.length === 0) return "_";
+  let result = words.map(capitalize).join("");
+  if (/^\d/.test(result)) result = `_${result}`;
+  return result;
+}
+__name(toCSharpPropertyName, "toCSharpPropertyName");
+function toCSharpParameterName(name) {
+  const words = splitWords(name);
+  if (words.length === 0) return "_";
+  const head = words[0].toLowerCase();
+  const rest = words.slice(1).map(capitalize);
+  let result = head + rest.join("");
+  if (/^\d/.test(result)) result = `_${result}`;
+  return escapeCSharpIdentifier(result);
+}
+__name(toCSharpParameterName, "toCSharpParameterName");
+function safeMemberName(propertyName, ownerTypeName) {
+  if (propertyName === ownerTypeName || RESERVED_MEMBER_NAMES.has(propertyName)) return `${propertyName}Value`;
+  return propertyName;
+}
+__name(safeMemberName, "safeMemberName");
+function toCSharpTypeName(name) {
+  const words = splitWords(name);
+  if (words.length === 0) return "_";
+  let result = words.map(capitalize).join("");
+  if (/^\d/.test(result)) result = `_${result}`;
+  return result;
+}
+__name(toCSharpTypeName, "toCSharpTypeName");
+function sanitizeCSharpTypeName(name) {
+  let result = name.replace(/[^a-zA-Z0-9]/g, "");
+  if (result.length === 0) return "_";
+  result = result.charAt(0).toUpperCase() + result.slice(1);
+  if (/^\d/.test(result)) result = `_${result}`;
+  return result;
+}
+__name(sanitizeCSharpTypeName, "sanitizeCSharpTypeName");
+function toCSharpEnumMemberName(value) {
+  const words = splitWords(value);
+  if (words.length === 0) return "_";
+  let result = words.map(capitalize).join("");
+  if (/^\d/.test(result)) result = `_${result}`;
+  return result;
+}
+__name(toCSharpEnumMemberName, "toCSharpEnumMemberName");
+function deriveCSharpFileBase(file) {
+  const base = file.split("/").pop()?.replace(/\.(op\.)?ck$/, "") ?? "models";
+  return toCSharpTypeName(base);
+}
+__name(deriveCSharpFileBase, "deriveCSharpFileBase");
+function xmlDocLines(text, indent, tag = "summary") {
+  if (text.length === 0) return [];
+  const safe = escapeXml(text);
+  const sourceLines = safe.split("\n");
+  if (sourceLines.length === 1) return [
+    `${indent}/// <${tag}>${sourceLines[0]}</${tag}>`
+  ];
+  return [
+    `${indent}/// <${tag}>`,
+    ...sourceLines.map((line) => `${indent}/// ${line}`.trimEnd()),
+    `${indent}/// </${tag}>`
+  ];
+}
+__name(xmlDocLines, "xmlDocLines");
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeXml, "escapeXml");
+function quoteCSharpString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\0/g, "\\0");
+  return `"${escaped}"`;
+}
+__name(quoteCSharpString, "quoteCSharpString");
+function splitWords(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean);
+}
+__name(splitWords, "splitWords");
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+__name(capitalize, "capitalize");
+
+// src/codegen-models.ts
+var MODEL_USINGS = [
+  "using System;",
+  "using System.Collections.Generic;",
+  "using System.Numerics;",
+  "using System.Text.Json;",
+  "using System.Text.Json.Serialization;"
+];
+function generateCSharpModels(root, opts) {
+  const modelsWithInput = resolveModelsWithInput(root.models, opts.modelsWithInput);
+  const modelIndex = opts.modelIndex ?? buildModelIndex(root.models);
+  const ctx = {
+    namespace: opts.namespace,
+    modelsWithInput,
+    modelIndex,
+    hoisted: opts.hoisted,
+    globalAliases: [],
+    warn: opts.warn
+  };
+  const bodies = [];
+  const append = /* @__PURE__ */ __name((lines) => {
+    if (lines.length === 0) return;
+    bodies.push("", ...lines);
+  }, "append");
+  for (const model of topoSortModels(root.models)) append(generateModel(model, ctx));
+  for (const decl of opts.hoisted?.byFile.get(root.file) ?? []) append(generateHoisted(decl, ctx));
+  return renderFile(`${opts.namespace}.Models`, ctx.globalAliases, [
+    ...MODEL_USINGS
+  ], bodies);
+}
+__name(generateCSharpModels, "generateCSharpModels");
+function resolveModelsWithInput(models, external = /* @__PURE__ */ new Set()) {
+  const seed = new Set(external);
+  return /* @__PURE__ */ new Set([
+    ...seed,
+    ...computeModelsWithInput([
+      ...models
+    ], seed)
+  ]);
+}
+__name(resolveModelsWithInput, "resolveModelsWithInput");
+function createRenderContext(opts) {
+  return {
+    namespace: opts.namespace,
+    modelsWithInput: opts.modelsWithInput,
+    modelIndex: opts.modelIndex ?? /* @__PURE__ */ new Map(),
+    hoisted: opts.hoisted,
+    globalAliases: [],
+    warn: opts.warn
+  };
+}
+__name(createRenderContext, "createRenderContext");
+function renderFile(namespaceName, globalAliases, usings, bodies) {
+  const lines = [
+    "// <auto-generated/>",
+    "// Generated by @contractkit/plugin-csharp. Do not edit manually.",
+    "#nullable enable",
+    ""
+  ];
+  if (globalAliases.length > 0) {
+    lines.push(...[
+      ...globalAliases
+    ].sort());
+    lines.push("");
+  }
+  lines.push(...usings);
+  lines.push("");
+  lines.push(`namespace ${namespaceName};`);
+  lines.push(...bodies);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(renderFile, "renderFile");
+function renderCSharpType(type, ctx, forInput = false) {
+  const decl = ctx.hoisted?.byNode.get(type);
+  if (decl) return hoistedTypeName(decl, ctx, forInput);
+  switch (type.kind) {
+    case "scalar":
+      return renderScalar(type.name, ctx);
+    case "literal":
+      return literalCSharpType(type.value, ctx);
+    case "array":
+      return `${qualify("List", "System.Collections.Generic.List", ctx)}<${renderCSharpType(type.item, ctx, forInput)}>`;
+    case "record": {
+      const key = renderCSharpType(type.key, ctx, forInput);
+      const value = renderCSharpType(type.value, ctx, forInput);
+      const stringType = qualify("string", "System.String", ctx);
+      if (key !== stringType) {
+        ctx.warn?.(`A record key of type '${key}' is not representable as a JSON object key; emitting Dictionary<string, ${value}>. Parse the key yourself, or declare the key as a string.`);
+      }
+      return `${qualify("Dictionary", "System.Collections.Generic.Dictionary", ctx)}<${stringType}, ${value}>`;
+    }
+    case "tuple":
+      return jsonElement(ctx);
+    case "ref": {
+      const name = forInput && ctx.modelsWithInput.has(type.name) ? `${type.name}Input` : type.name;
+      return ctx.qualify ? `${ctx.namespace}.Models.${name}` : name;
+    }
+    case "lazy":
+      return renderCSharpType(type.inner, ctx, forInput);
+    case "union": {
+      const nonNull = type.members.filter((m) => !isNullScalar(m));
+      const nullable = nonNull.length !== type.members.length;
+      if (nonNull.length === 0) return `${qualify("object", "System.Object", ctx)}?`;
+      if (nonNull.length === 1) {
+        const inner = renderCSharpType(nonNull[0], ctx, forInput);
+        return nullable && !inner.endsWith("?") ? `${inner}?` : inner;
+      }
+      return jsonElement(ctx);
+    }
+    case "enum":
+    case "inlineObject":
+    case "intersection":
+    case "discriminatedUnion":
+      return jsonElement(ctx);
+  }
+}
+__name(renderCSharpType, "renderCSharpType");
+function hoistedTypeName(decl, ctx, forInput) {
+  const bare = forInput && decl.needsInput ? `${decl.name}Input` : decl.name;
+  const name = ctx.qualify ? `${ctx.namespace}.Models.${bare}` : bare;
+  return decl.nullable ? `${name}?` : name;
+}
+__name(hoistedTypeName, "hoistedTypeName");
+function qualify(short, full, ctx) {
+  return ctx.qualify ? full : short;
+}
+__name(qualify, "qualify");
+function jsonElement(ctx) {
+  return qualify("JsonElement", "System.Text.Json.JsonElement", ctx);
+}
+__name(jsonElement, "jsonElement");
+function isNullScalar(type) {
+  return type.kind === "scalar" && type.name === "null";
+}
+__name(isNullScalar, "isNullScalar");
+function renderScalar(name, ctx) {
+  switch (name) {
+    case "string":
+    case "email":
+    case "url":
+    case "interval":
+      return qualify("string", "System.String", ctx);
+    case "number":
+      return qualify("double", "System.Double", ctx);
+    // `int` is a JS safe integer in the source language, which overflows C#'s 32-bit int.
+    case "int":
+      return qualify("long", "System.Int64", ctx);
+    case "bigint":
+      return qualify("BigInteger", "System.Numerics.BigInteger", ctx);
+    // Carried as a quoted string by DecimalStringConverter, never as a JSON number.
+    case "decimal":
+      return qualify("decimal", "System.Decimal", ctx);
+    case "boolean":
+      return qualify("bool", "System.Boolean", ctx);
+    case "date":
+      return qualify("DateOnly", "System.DateOnly", ctx);
+    case "time":
+      return qualify("TimeOnly", "System.TimeOnly", ctx);
+    case "datetime":
+      return qualify("DateTimeOffset", "System.DateTimeOffset", ctx);
+    // Carried as ISO 8601 by IsoTimeSpanConverter, not the BCL's own `d.hh:mm:ss`.
+    case "duration":
+      return qualify("TimeSpan", "System.TimeSpan", ctx);
+    case "uuid":
+      return qualify("Guid", "System.Guid", ctx);
+    case "binary":
+      return qualify("byte[]", "System.Byte[]", ctx);
+    case "null":
+      return `${qualify("object", "System.Object", ctx)}?`;
+    case "unknown":
+    case "json":
+    case "object":
+      return jsonElement(ctx);
+    default: {
+      const _exhaustive = name;
+      throw new Error(`plugin-csharp: unmapped scalar '${String(_exhaustive)}' \u2014 add a case`);
+    }
+  }
+}
+__name(renderScalar, "renderScalar");
+function literalCSharpType(value, ctx) {
+  if (typeof value === "string") return qualify("string", "System.String", ctx);
+  if (typeof value === "boolean") return qualify("bool", "System.Boolean", ctx);
+  return Number.isInteger(value) ? qualify("long", "System.Int64", ctx) : qualify("double", "System.Double", ctx);
+}
+__name(literalCSharpType, "literalCSharpType");
+function renderDefault(value, type, ctx) {
+  const inner = type.kind === "lazy" ? type.inner : type;
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") {
+    if (inner.kind === "scalar") {
+      switch (inner.name) {
+        case "int":
+          return `${value}L`;
+        case "number":
+          return `${value}d`;
+        case "decimal":
+          return `${value}m`;
+        case "bigint":
+          return Number.isSafeInteger(value) ? `new BigInteger(${value})` : `BigInteger.Parse("${value}")`;
+      }
+    }
+    return Number.isInteger(value) ? `${value}L` : `${value}d`;
+  }
+  if (inner.kind === "enum") {
+    const decl = ctx.hoisted?.byNode.get(inner);
+    if (!decl || !inner.values.includes(value)) return void 0;
+    return `${decl.name}.${enumMemberNames(inner.values).get(value)}`;
+  }
+  if (inner.kind === "ref") {
+    const target = ctx.modelIndex.get(inner.name);
+    const targetType = target?.type?.kind === "lazy" ? target.type.inner : target?.type;
+    if (targetType?.kind !== "enum" || !targetType.values.includes(value)) return void 0;
+    return `${inner.name}.${enumMemberNames(targetType.values).get(value)}`;
+  }
+  if (inner.kind === "scalar") {
+    switch (inner.name) {
+      case "decimal":
+        return /^-?\d+(\.\d+)?$/.test(value) ? `${value}m` : void 0;
+      case "bigint":
+        return /^-?\d+$/.test(value) ? `BigInteger.Parse(${quoteCSharpString(value)})` : void 0;
+      case "string":
+      case "email":
+      case "url":
+      case "interval":
+        return quoteCSharpString(value);
+      default:
+        return void 0;
+    }
+  }
+  return quoteCSharpString(value);
+}
+__name(renderDefault, "renderDefault");
+function applyWireCase(name, wireCase) {
+  if (!wireCase || wireCase === "camel") return name;
+  if (wireCase === "snake") return name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+__name(applyWireCase, "applyWireCase");
+function renamingCase(wireCase) {
+  return wireCase && wireCase !== "camel" ? wireCase : void 0;
+}
+__name(renamingCase, "renamingCase");
+function wireCaseFor(model, forInput, split, ctx) {
+  const input = renamingCase(model.inputCase);
+  const output = renamingCase(model.outputCase);
+  if (split) return forInput ? input : output;
+  if (input && output && input !== output) {
+    ctx.warn?.(`Contract '${model.name}' sets format(input=${input}) and format(output=${output}), but nothing about it splits into an Input variant, so one C# record carries both directions and can only spell one set of keys. The generated keys follow the output casing; a request built from this record will send the wrong ones.`);
+    return output;
+  }
+  return output ?? input;
+}
+__name(wireCaseFor, "wireCaseFor");
+function containsInlineObject(type) {
+  if (!type) return false;
+  switch (type.kind) {
+    case "inlineObject":
+      return true;
+    case "lazy":
+      return containsInlineObject(type.inner);
+    case "array":
+      return containsInlineObject(type.item);
+    case "record":
+      return containsInlineObject(type.value);
+    case "tuple":
+      return type.items.some(containsInlineObject);
+    case "union":
+    case "discriminatedUnion":
+    case "intersection":
+      return (type.members ?? []).some(containsInlineObject);
+    default:
+      return false;
+  }
+}
+__name(containsInlineObject, "containsInlineObject");
+function warnUncasedNesting(model, fields, wireCase, ctx) {
+  if (!wireCase) return;
+  if (!fields.some((f) => containsInlineObject(f.type)) && !containsInlineObject(model.type)) return;
+  ctx.warn?.(`Contract '${model.name}' is declared format(${model.outputCase ? "output" : "input"}=${wireCase}) and holds an anonymous object. The record hoisted out of that object keeps its declared key names, so its keys will not be ${wireCase}-cased. Name the shape as its own contract to fix it.`);
+}
+__name(warnUncasedNesting, "warnUncasedNesting");
+function generateModel(model, ctx) {
+  if (model.type) return generateAliasModel(model, ctx);
+  const effective = effectiveFieldsFor(model, ctx);
+  const needsSplit = ctx.modelsWithInput.has(model.name) || effective.some((f) => f.visibility !== "normal");
+  if (!needsSplit) return generateRecordForModel(model.name, effective, ctx, false, model, false);
+  const readFields = effective.filter((f) => f.visibility !== "writeonly");
+  const inputFields = effective.filter((f) => f.visibility !== "readonly");
+  return [
+    ...generateRecordForModel(model.name, readFields, ctx, false, model, true),
+    "",
+    ...generateRecordForModel(`${model.name}Input`, inputFields, ctx, true, model, true)
+  ];
+}
+__name(generateModel, "generateModel");
+function effectiveFieldsFor(model, ctx) {
+  if (!model.bases || model.bases.length === 0) return model.fields;
+  const { fields, unresolved } = resolveEffectiveFields(model.name, ctx.modelIndex);
+  for (const name of unresolved) {
+    ctx.warn?.(`Contract '${model.name}' extends '${name}', which is not defined; its fields are missing from the generated record.`);
+  }
+  return fields;
+}
+__name(effectiveFieldsFor, "effectiveFieldsFor");
+function generateAliasModel(model, ctx) {
+  const type = model.type;
+  const inner = type.kind === "lazy" ? type.inner : type;
+  if (ctx.hoisted?.byNode.has(inner)) return [];
+  if (inner.kind === "enum") return generateEnum(model.name, inner.values, ctx, model.description, model.deprecated);
+  if (inner.kind === "intersection" || inner.kind === "inlineObject") {
+    const { fields, unresolved } = resolveEffectiveFields(inner, ctx.modelIndex);
+    for (const name of unresolved) {
+      ctx.warn?.(`Contract '${model.name}' references '${name}', which is not defined; its fields are missing from the generated record.`);
+    }
+    const needsSplit = ctx.modelsWithInput.has(model.name) || fields.some((f) => f.visibility !== "normal");
+    if (!needsSplit) return generateRecordForModel(model.name, fields, ctx, false, model, false);
+    return [
+      ...generateRecordForModel(model.name, fields.filter((f) => f.visibility !== "writeonly"), ctx, false, model, true),
+      "",
+      ...generateRecordForModel(`${model.name}Input`, fields.filter((f) => f.visibility !== "readonly"), ctx, true, model, true)
+    ];
+  }
+  addAlias(model.name, type, ctx, false);
+  if (ctx.modelsWithInput.has(model.name)) addAlias(`${model.name}Input`, type, ctx, true);
+  return [];
+}
+__name(generateAliasModel, "generateAliasModel");
+function addAlias(name, type, ctx, forInput) {
+  const target = renderCSharpType(type, {
+    ...ctx,
+    qualify: true
+  }, forInput);
+  let aliased = target;
+  if (aliased.endsWith("?") && !isNullableValueType(type, ctx)) {
+    aliased = aliased.slice(0, -1);
+    ctx.warn?.(`Contract '${name}' aliases a nullable type, which C# cannot express as a using alias; '${name}' is generated as '${aliased}'. Declare the nullability at each use site instead.`);
+  }
+  ctx.globalAliases.push(`global using ${name} = ${aliased};`);
+}
+__name(addAlias, "addAlias");
+function isNullableValueType(type, ctx) {
+  const inner = type.kind === "lazy" ? type.inner : type;
+  if (inner.kind !== "union") return false;
+  const nonNull = inner.members.filter((m) => !isNullScalar(m));
+  if (nonNull.length !== 1) return false;
+  return VALUE_TYPES.has(renderCSharpType(nonNull[0], {
+    ...ctx,
+    qualify: false
+  }, false));
+}
+__name(isNullableValueType, "isNullableValueType");
+var VALUE_TYPES = /* @__PURE__ */ new Set([
+  "bool",
+  "byte",
+  "decimal",
+  "double",
+  "long",
+  "BigInteger",
+  "DateOnly",
+  "TimeOnly",
+  "DateTimeOffset",
+  "TimeSpan",
+  "Guid",
+  "JsonElement"
+]);
+function enumMemberNames(values) {
+  const out = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const value of values) out.set(value, uniqueName(toCSharpEnumMemberName(value), used));
+  return out;
+}
+__name(enumMemberNames, "enumMemberNames");
+function generateEnum(name, values, ctx, description, deprecated) {
+  const entries = enumMemberNames(values);
+  const lines = [];
+  lines.push(...docLines(description, deprecated, ""));
+  lines.push(`[JsonConverter(typeof(JsonStringEnumConverter<${name}>))]`);
+  lines.push(`public enum ${name}`);
+  lines.push("{");
+  values.forEach((value, index) => {
+    if (index > 0) lines.push("");
+    lines.push(`    [JsonStringEnumMemberName(${quoteCSharpString(value)})]`);
+    lines.push(`    ${entries.get(value)},`);
+  });
+  lines.push("}");
+  if (ctx.modelsWithInput.has(name)) ctx.globalAliases.push(`global using ${name}Input = ${ctx.namespace}.Models.${name};`);
+  return lines;
+}
+__name(generateEnum, "generateEnum");
+function supertypesFor(readName, ctx, forInput) {
+  const unions = ctx.hoisted?.memberships.get(readName) ?? [];
+  return unions.map((union) => {
+    const decl = ctx.hoisted?.byName.get(union);
+    return forInput && decl?.needsInput ? `${union}Input` : union;
+  });
+}
+__name(supertypesFor, "supertypesFor");
+function generateRecordForModel(name, fields, ctx, forInput, model, split) {
+  const readName = forInput && name.endsWith("Input") ? name.slice(0, -"Input".length) : name;
+  const wireCase = wireCaseFor(model, forInput, split, ctx);
+  if (!forInput) warnUncasedNesting(model, fields, wireCase, ctx);
+  return renderRecord(name, fields, ctx, forInput, supertypesFor(readName, ctx, forInput), model.description, model.deprecated, wireCase);
+}
+__name(generateRecordForModel, "generateRecordForModel");
+function renderRecord(name, fields, ctx, forInput, supertypes, description, deprecated, wireCase) {
+  const lines = [];
+  lines.push(...docLines(description, deprecated, ""));
+  const implementsClause = supertypes.length > 0 ? ` : ${supertypes.join(", ")}` : "";
+  if (fields.length === 0) {
+    lines.push(`public sealed record ${name}${implementsClause};`);
+    return lines;
+  }
+  lines.push(`public sealed record ${name}${implementsClause}`);
+  lines.push("{");
+  fields.forEach((field, index) => {
+    if (index > 0) lines.push("");
+    lines.push(...renderField(field, ctx, forInput, name, wireCase));
+  });
+  lines.push("}");
+  return lines;
+}
+__name(renderRecord, "renderRecord");
+function renderField(field, ctx, forInput, ownerTypeName, wireCase) {
+  const propName = safeMemberName(toCSharpPropertyName(field.name), ownerTypeName);
+  const wireName = applyWireCase(field.name, wireCase);
+  let typeStr = renderCSharpType(field.type, ctx, forInput);
+  if ((field.optional || field.nullable) && !typeStr.endsWith("?")) typeStr += "?";
+  let initializer = field.default !== void 0 ? renderDefault(field.default, field.type, ctx) : void 0;
+  if (initializer === void 0 && !field.optional && !field.nullable) {
+    const inner = field.type.kind === "lazy" ? field.type.inner : field.type;
+    if (inner.kind === "literal") initializer = renderDefault(inner.value, inner, ctx);
+  }
+  const isRequired = !field.optional && initializer === void 0;
+  const lines = [];
+  lines.push(...docLines(field.description, field.deprecated, "    "));
+  lines.push(`    [JsonPropertyName(${quoteCSharpString(wireName)})]`);
+  if (field.optional) lines.push("    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]");
+  const suffix = initializer !== void 0 ? ` = ${initializer};` : "";
+  lines.push(`    public ${isRequired ? "required " : ""}${typeStr} ${propName} { get; init; }${suffix}`);
+  return lines;
+}
+__name(renderField, "renderField");
+function generateHoisted(decl, ctx) {
+  const read = generateHoistedVariant(decl, ctx, false);
+  if (!decl.needsInput) return read;
+  return [
+    ...read,
+    "",
+    ...generateHoistedVariant(decl, ctx, true)
+  ];
+}
+__name(generateHoisted, "generateHoisted");
+function generateHoistedVariant(decl, ctx, forInput) {
+  const name = forInput ? `${decl.name}Input` : decl.name;
+  switch (decl.kind) {
+    case "enum":
+      return generateEnum(name, decl.values ?? [], ctx, decl.description);
+    case "record":
+      return renderRecord(name, (decl.fields ?? []).filter((f) => forInput ? f.visibility !== "readonly" : f.visibility !== "writeonly"), ctx, forInput, supertypesFor(decl.name, ctx, forInput), decl.description);
+    case "tuple":
+      return generateTupleRecord(decl, name, ctx, forInput);
+    case "plainUnion":
+      return generatePlainUnion(decl, name, ctx, forInput);
+    case "discriminatedUnion":
+      return generateDiscriminatedUnion(decl, name, ctx, forInput);
+  }
+}
+__name(generateHoistedVariant, "generateHoistedVariant");
+function deserializeExpr(type, ctx, forInput) {
+  return `element.Deserialize<${renderCSharpType(type, ctx, forInput)}>(options)!`;
+}
+__name(deserializeExpr, "deserializeExpr");
+function generateTupleRecord(decl, name, ctx, forInput) {
+  const items = decl.items ?? [];
+  const converterName = `${name}Converter`;
+  const parameters = items.map((item, index) => `${renderCSharpType(item, ctx, forInput)} Item${index}`).join(", ");
+  const lines = [];
+  lines.push(...docLines(decl.description, void 0, ""));
+  lines.push(`[JsonConverter(typeof(${converterName}))]`);
+  lines.push(`public sealed record ${name}(${parameters});`);
+  lines.push("");
+  lines.push(`/// <summary>Reads and writes <see cref="${name}"/> as a JSON array.</summary>`);
+  lines.push(`public sealed class ${converterName} : JsonConverter<${name}>`);
+  lines.push("{");
+  lines.push(`    public override ${name} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        using var document = JsonDocument.ParseValue(ref reader);");
+  lines.push("        var array = document.RootElement;");
+  lines.push(`        if (array.ValueKind != JsonValueKind.Array || array.GetArrayLength() != ${items.length})`);
+  lines.push("        {");
+  lines.push(`            throw new JsonException("Expected a JSON array of ${items.length} elements for ${name}.");`);
+  lines.push("        }");
+  lines.push("");
+  lines.push(`        return new ${name}(`);
+  items.forEach((item, index) => {
+    const expr = `array[${index}].Deserialize<${renderCSharpType(item, ctx, forInput)}>(options)!`;
+    lines.push(`            ${expr}${index === items.length - 1 ? "" : ","}`);
+  });
+  lines.push("        );");
+  lines.push("    }");
+  lines.push("");
+  lines.push(`    public override void Write(Utf8JsonWriter writer, ${name} value, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        writer.WriteStartArray();");
+  items.forEach((_, index) => lines.push(`        JsonSerializer.Serialize(writer, value.Item${index}, options);`));
+  lines.push("        writer.WriteEndArray();");
+  lines.push("    }");
+  lines.push("}");
+  return lines;
+}
+__name(generateTupleRecord, "generateTupleRecord");
+function generatePlainUnion(decl, name, ctx, forInput) {
+  const converterName = `${name}Converter`;
+  const members = decl.members ?? [];
+  const lines = [];
+  lines.push(...docLines(decl.description, void 0, ""));
+  lines.push(`[JsonConverter(typeof(${converterName}))]`);
+  lines.push(`public abstract record ${name}`);
+  lines.push("{");
+  lines.push(`    private ${name}() { }`);
+  for (const member of members) {
+    lines.push("");
+    lines.push(`    public sealed record ${member.wrapperName}(${renderCSharpType(member.type, ctx, forInput)} Value) : ${name};`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push(`/// <summary>Reads <see cref="${name}"/> by trying each member in declaration order.</summary>`);
+  lines.push(`public sealed class ${converterName} : JsonConverter<${name}>`);
+  lines.push("{");
+  lines.push(`    public override ${name} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        using var document = JsonDocument.ParseValue(ref reader);");
+  lines.push("        var element = document.RootElement;");
+  lines.push("");
+  for (const member of members) {
+    lines.push("        try");
+    lines.push("        {");
+    lines.push(`            return new ${name}.${member.wrapperName}(${deserializeExpr(member.type, ctx, forInput)});`);
+    lines.push("        }");
+    lines.push("        catch (JsonException)");
+    lines.push("        {");
+    lines.push("            // Not this member; fall through to the next.");
+    lines.push("        }");
+    lines.push("");
+  }
+  lines.push(`        throw new JsonException("No ${name} member matched the payload.");`);
+  lines.push("    }");
+  lines.push("");
+  lines.push(`    public override void Write(Utf8JsonWriter writer, ${name} value, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        switch (value)");
+  lines.push("        {");
+  for (const member of members) {
+    lines.push(`            case ${name}.${member.wrapperName} member:`);
+    lines.push("                JsonSerializer.Serialize(writer, member.Value, options);");
+    lines.push("                break;");
+  }
+  lines.push("            default:");
+  lines.push(`                throw new JsonException($"Unknown ${name} member {value.GetType().Name}.");`);
+  lines.push("        }");
+  lines.push("    }");
+  lines.push("}");
+  return lines;
+}
+__name(generatePlainUnion, "generatePlainUnion");
+function generateDiscriminatedUnion(decl, name, ctx, forInput) {
+  const converterName = `${name}Converter`;
+  const members = (decl.members ?? []).map((member) => ({
+    ...member,
+    recordName: memberRecordName(member.typeName, ctx, forInput)
+  }));
+  const discriminator = decl.discriminator ?? "";
+  const lines = [];
+  lines.push(...docLines(decl.description, void 0, ""));
+  lines.push(`[JsonConverter(typeof(${converterName}))]`);
+  lines.push(`public interface ${name}`);
+  lines.push("{");
+  lines.push("}");
+  lines.push("");
+  lines.push(`/// <summary>Reads <see cref="${name}"/> by dispatching on its '${discriminator}' tag.</summary>`);
+  lines.push(`public sealed class ${converterName} : JsonConverter<${name}>`);
+  lines.push("{");
+  lines.push(`    public override ${name} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        using var document = JsonDocument.ParseValue(ref reader);");
+  lines.push("        var element = document.RootElement;");
+  lines.push(`        var tag = element.TryGetProperty(${quoteCSharpString(discriminator)}, out var tagElement) && tagElement.ValueKind == JsonValueKind.String`);
+  lines.push("            ? tagElement.GetString()");
+  lines.push("            : null;");
+  lines.push("");
+  lines.push("        return tag switch");
+  lines.push("        {");
+  for (const member of members) {
+    lines.push(`            ${quoteCSharpString(member.tag ?? "")} => element.Deserialize<${member.recordName}>(options)!,`);
+  }
+  lines.push(`            _ => throw new JsonException($"Unknown ${name} ${discriminator}: {tag}"),`);
+  lines.push("        };");
+  lines.push("    }");
+  lines.push("");
+  lines.push(`    public override void Write(Utf8JsonWriter writer, ${name} value, JsonSerializerOptions options)`);
+  lines.push("    {");
+  lines.push("        switch (value)");
+  lines.push("        {");
+  for (const member of members) {
+    lines.push(`            case ${member.recordName} member:`);
+    lines.push("                JsonSerializer.Serialize(writer, member, options);");
+    lines.push("                break;");
+  }
+  lines.push("            default:");
+  lines.push(`                throw new JsonException($"Unknown ${name} member {value.GetType().Name}.");`);
+  lines.push("        }");
+  lines.push("    }");
+  lines.push("}");
+  return lines;
+}
+__name(generateDiscriminatedUnion, "generateDiscriminatedUnion");
+function memberRecordName(typeName, ctx, forInput) {
+  if (!forInput) return typeName;
+  const decl = ctx.hoisted?.byName.get(typeName);
+  if (decl) return decl.needsInput ? `${typeName}Input` : typeName;
+  return ctx.modelsWithInput.has(typeName) ? `${typeName}Input` : typeName;
+}
+__name(memberRecordName, "memberRecordName");
+function docLines(description, deprecated, indent) {
+  const lines = [];
+  if (description) lines.push(...xmlDocLines(description, indent));
+  if (deprecated) lines.push(...xmlDocLines("Deprecated in the contract.", indent, "remarks"));
+  return lines;
+}
+__name(docLines, "docLines");
+function uniqueName(name, used) {
+  if (!used.has(name)) {
+    used.add(name);
+    return name;
+  }
+  let n = 2;
+  while (used.has(`${name}${n}`)) n++;
+  used.add(`${name}${n}`);
+  return `${name}${n}`;
+}
+__name(uniqueName, "uniqueName");
+
+// src/codegen-client.ts
+import { classifyContentType, observableResponses, resolveModifiers } from "@contractkit/core";
+function clientUsings(namespaceName) {
+  return [
+    "using System;",
+    "using System.Collections.Generic;",
+    "using System.Globalization;",
+    "using System.Net.Http;",
+    "using System.Numerics;",
+    "using System.Text.Json;",
+    "using System.Text.Json.Serialization;",
+    "using System.Threading;",
+    "using System.Threading.Tasks;",
+    "using System.Xml;",
+    `using ${namespaceName}.Models;`,
+    `using ${namespaceName}.Runtime;`
+  ];
+}
+__name(clientUsings, "clientUsings");
+function hasPublicOperations(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (includeInternal || !resolveModifiers(route, op).includes("internal")) return true;
+    }
+  }
+  return false;
+}
+__name(hasPublicOperations, "hasPublicOperations");
+function deriveClientClassName(file) {
+  return `${deriveCSharpFileBase(file)}Client`;
+}
+__name(deriveClientClassName, "deriveClientClassName");
+function deriveClientPropertyName(file) {
+  return deriveCSharpFileBase(file);
+}
+__name(deriveClientPropertyName, "deriveClientPropertyName");
+function generateCSharpClient(root, opts) {
+  const className = deriveClientClassName(root.file);
+  const includeInternal = opts.includeInternal ?? false;
+  const ctx = createRenderContext(opts);
+  const publicOps = [];
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+      publicOps.push({
+        route,
+        op
+      });
+    }
+  }
+  const shapeLines = [];
+  for (const { route, op } of publicOps) {
+    const base = methodBase(deriveMethodName(op, route));
+    for (const { source, suffix } of [
+      {
+        source: op.query,
+        suffix: "Query"
+      },
+      {
+        source: op.headers,
+        suffix: "Headers"
+      }
+    ]) {
+      if (source?.kind !== "params" || source.nodes.length === 0) continue;
+      const shapeName = `${base}${suffix}`;
+      shapeLines.push("");
+      shapeLines.push(...xmlDocLines(`The ${suffix === "Query" ? "query parameters" : "request headers"} declared on ${where(route, op)}.`, ""));
+      shapeLines.push(`public sealed record ${shapeName}`);
+      shapeLines.push("{");
+      source.nodes.forEach((node, index) => {
+        if (index > 0) shapeLines.push("");
+        const propName = safeMemberName(toCSharpPropertyName(node.name), shapeName);
+        let type = renderCSharpType(node.type, ctx, true);
+        const optional = Boolean(node.optional) || node.default !== void 0;
+        if (optional && !type.endsWith("?")) type += "?";
+        shapeLines.push(`    [JsonPropertyName(${quoteCSharpString(node.name)})]`);
+        if (optional) shapeLines.push("    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]");
+        shapeLines.push(`    public ${optional ? "" : "required "}${type} ${propName} { get; init; }`);
+      });
+      shapeLines.push("}");
+    }
+    shapeLines.push(...responseDeclarations(route, op, ctx));
+  }
+  const methodLines = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const { route, op } of publicOps) {
+    const methodName = deriveMethodName(op, route);
+    const clash = seen.get(methodName);
+    if (clash) {
+      throw new Error(`plugin-csharp: ${where(route, op)} and ${clash} both generate the client method '${methodName}' on ${className}. Give one of them a distinct 'sdk:' name.`);
+    }
+    seen.set(methodName, where(route, op));
+    methodLines.push("");
+    methodLines.push(...generateMethod(route, op, ctx, methodName));
+  }
+  const body = [];
+  body.push("");
+  body.push(...xmlDocLines(`Operations declared in <c>${root.file.split("/").pop()}</c>.`, ""));
+  body.push(`public sealed class ${className}(SdkHttp http)`);
+  body.push("{");
+  body.push(...methodLines.slice(1).map((l) => l === "" ? "" : `    ${l}`));
+  body.push("}");
+  body.push(...shapeLines);
+  return renderFile(`${opts.namespace}.Clients`, ctx.globalAliases, clientUsings(opts.namespace), body);
+}
+__name(generateCSharpClient, "generateCSharpClient");
+function where(route, op) {
+  return `${op.method.toUpperCase()} ${route.path}`;
+}
+__name(where, "where");
+function methodBase(methodName) {
+  return methodName.endsWith("Async") ? methodName.slice(0, -"Async".length) : methodName;
+}
+__name(methodBase, "methodBase");
+function responseShape(op) {
+  const observable = observableResponses(op);
+  if (observable.length > 1) return {
+    kind: "multiStatus",
+    responses: observable
+  };
+  const response = observable[0];
+  if (response && response.bodies.length > 1) return {
+    kind: "multiMime",
+    response
+  };
+  return {
+    kind: "simple",
+    response
+  };
+}
+__name(responseShape, "responseShape");
+function observableOf(shape) {
+  if (shape.kind === "multiStatus") return shape.responses;
+  return shape.response ? [
+    shape.response
+  ] : [];
+}
+__name(observableOf, "observableOf");
+function generateMethod(route, op, ctx, methodName) {
+  const base = methodBase(methodName);
+  const shape = responseShape(op);
+  const returnType = returnTypeFor(shape, base, ctx);
+  const observable = observableOf(shape);
+  const expectStatuses = observable.filter((r) => r.statusCode < 200 || r.statusCode >= 300).map((r) => r.statusCode);
+  const params = buildMethodParams(route, op, ctx);
+  const signature = [
+    ...params.map((p) => `${p.type} ${p.name}${p.optional ? " = null" : ""}`),
+    "CancellationToken cancellationToken = default"
+  ].join(", ");
+  const lines = [];
+  lines.push(...methodDoc(route, op, observable));
+  if (resolveModifiers(route, op).includes("deprecated")) lines.push('[Obsolete("Deprecated in the contract")]');
+  lines.push(`public async ${returnType === "void" ? "Task" : `Task<${returnType}>`} ${methodName}(${signature})`);
+  lines.push("{");
+  const callArgs = [
+    `HttpMethod.${httpMethodConstant(op.method)}`,
+    buildPathExpression(route.path, route.params)
+  ];
+  if (op.query) callArgs.push("query: http.Params(query)");
+  if (op.headers) callArgs.push("headers: http.Params(customHeaders)");
+  const content = bodyArgument(op);
+  if (content) callArgs.push(content);
+  if (expectStatuses.length > 0) callArgs.push(`expectStatuses: new[] { ${expectStatuses.join(", ")} }`);
+  callArgs.push("cancellationToken: cancellationToken");
+  const assignment = returnType === "void" ? "await " : "var response = await ";
+  lines.push(`    ${assignment}http.ExecuteAsync(`);
+  callArgs.forEach((arg, index) => {
+    lines.push(`        ${arg}${index === callArgs.length - 1 ? ").ConfigureAwait(false);" : ","}`);
+  });
+  lines.push(...returnStatements(shape, base, ctx, where(route, op)));
+  lines.push("}");
+  return lines;
+}
+__name(generateMethod, "generateMethod");
+function returnTypeFor(shape, base, ctx) {
+  if (shape.kind !== "simple") return `${base}Response`;
+  const response = shape.response;
+  const body = response?.bodies[0];
+  const headers = response?.headers ?? [];
+  if (!body) return headers.length > 0 ? `${base}Headers` : "void";
+  const dataType = bodyCSharpType(body, ctx);
+  return headers.length > 0 ? `${base}Result` : dataType;
+}
+__name(returnTypeFor, "returnTypeFor");
+function bodyCSharpType(body, ctx) {
+  switch (classifyContentType(body.contentType)) {
+    case "text":
+      return "string";
+    case "binary":
+      return "byte[]";
+    default:
+      return renderCSharpType(body.bodyType, ctx, false);
+  }
+}
+__name(bodyCSharpType, "bodyCSharpType");
+function bodyReadExpr(body, ctx) {
+  switch (classifyContentType(body.contentType)) {
+    case "text":
+      return "response.Text";
+    case "binary":
+      return "response.Bytes";
+    default:
+      return `http.ReadJson<${renderCSharpType(body.bodyType, ctx, false)}>(response)`;
+  }
+}
+__name(bodyReadExpr, "bodyReadExpr");
+function returnStatements(shape, base, ctx, place) {
+  if (shape.kind === "simple") {
+    const response = shape.response;
+    const body = response?.bodies[0];
+    const headers = response?.headers ?? [];
+    if (headers.length === 0) return body ? [
+      `    return ${bodyReadExpr(body, ctx)};`
+    ] : [];
+    const lines2 = readHeaderLines(headers, `${base}Headers`, ctx, place, "    ");
+    return body ? [
+      ...lines2,
+      `    return new ${base}Result(${bodyReadExpr(body, ctx)}, headers);`
+    ] : [
+      ...lines2,
+      "    return headers;"
+    ];
+  }
+  if (shape.kind === "multiMime") {
+    const headers = shape.response.headers ?? [];
+    const lines2 = headers.length > 0 ? readHeaderLines(headers, `${base}Headers`, ctx, place, "    ") : [];
+    lines2.push(...mimeSwitch(shape.response, base, void 0, ctx, "    ", headers.length > 0));
+    return lines2;
+  }
+  const [fallback, ...rest] = shape.responses;
+  const lines = [
+    "    switch (response.Status)",
+    "    {"
+  ];
+  for (const response of rest) {
+    lines.push(`        case ${response.statusCode}:`);
+    lines.push("        {");
+    lines.push(...statusBranch(response, base, response.statusCode, ctx, place, "            "));
+    lines.push("        }");
+    lines.push("");
+  }
+  lines.push("        default:");
+  lines.push("        {");
+  lines.push(...statusBranch(fallback, base, fallback.statusCode, ctx, place, "            "));
+  lines.push("        }");
+  lines.push("    }");
+  return lines;
+}
+__name(returnStatements, "returnStatements");
+function statusBranch(response, base, statusCode, ctx, place, indent) {
+  const lines = [];
+  const headers = response.headers ?? [];
+  if (headers.length > 0) lines.push(...readHeaderLines(headers, headersRecordName(base, statusCode), ctx, place, indent));
+  lines.push(...mimeSwitch(response, base, statusCode, ctx, indent, headers.length > 0));
+  return lines;
+}
+__name(statusBranch, "statusBranch");
+function mimeSwitch(response, base, statusCode, ctx, indent, hasHeaders) {
+  const bodies = response.bodies;
+  const construct = /* @__PURE__ */ __name((body) => {
+    const args = [];
+    if (body) args.push(bodyReadExpr(body, ctx));
+    if (hasHeaders) args.push("headers");
+    return `new ${base}Response.${leafRecordName(response, body, statusCode)}(${args.join(", ")})`;
+  }, "construct");
+  if (bodies.length <= 1) return [
+    `${indent}return ${construct(bodies[0])};`
+  ];
+  const [fallback, ...rest] = bodies;
+  const lines = [
+    `${indent}switch (response.ContentType)`,
+    `${indent}{`
+  ];
+  for (const body of rest) {
+    lines.push(`${indent}    case ${quoteCSharpString(body.contentType)}:`);
+    lines.push(`${indent}        return ${construct(body)};`);
+  }
+  lines.push(`${indent}    default:`);
+  lines.push(`${indent}        return ${construct(fallback)};`);
+  lines.push(`${indent}}`);
+  return lines;
+}
+__name(mimeSwitch, "mimeSwitch");
+function bodyArgument(op) {
+  const body = op.request?.bodies[0];
+  if (!body) return void 0;
+  const mime = quoteCSharpString(body.contentType);
+  switch (classifyContentType(body.contentType)) {
+    case "multipart":
+      return "content: http.MultipartContent(body)";
+    case "urlencoded":
+      return "content: http.FormContent(body)";
+    case "text":
+      return `content: http.TextContent(body, ${mime})`;
+    case "binary":
+      return `content: http.BinaryContent(body, ${mime})`;
+    default:
+      return `content: http.JsonContent(body, ${mime})`;
+  }
+}
+__name(bodyArgument, "bodyArgument");
+function headersRecordName(base, statusCode) {
+  return statusCode === void 0 ? `${base}Headers` : `${base}${statusCode}Headers`;
+}
+__name(headersRecordName, "headersRecordName");
+function leafRecordName(response, body, statusCode) {
+  const statusPart = statusCode === void 0 ? "" : `Status${statusCode}`;
+  if (response.bodies.length <= 1 || !body) return statusPart || "Body";
+  return `${statusPart}${toCSharpTypeName(body.contentType.replace(/[+/.]/g, " "))}`;
+}
+__name(leafRecordName, "leafRecordName");
+function responseDeclarations(route, op, ctx) {
+  const shape = responseShape(op);
+  const base = methodBase(deriveMethodName(op, route));
+  const place = where(route, op);
+  const lines = [];
+  const headerRecord = /* @__PURE__ */ __name((headers, name) => {
+    const parameters = headers.map((header) => {
+      const reader = headerReader(header, place);
+      const type = header.optional ? `${reader.type}?` : reader.type;
+      return `${type} ${safeMemberName(toCSharpPropertyName(header.name), name)}`;
+    }).join(", ");
+    lines.push("");
+    lines.push(...xmlDocLines(`Response headers declared on ${place}.`, ""));
+    lines.push(`public sealed record ${name}(${parameters});`);
+  }, "headerRecord");
+  if (shape.kind === "simple") {
+    const response = shape.response;
+    const headers = response?.headers ?? [];
+    if (headers.length === 0) return lines;
+    headerRecord(headers, headersRecordName(base));
+    const body = response?.bodies[0];
+    if (body) {
+      lines.push("");
+      lines.push(...xmlDocLines(`The body of ${place}, with the response headers the contract declares.`, ""));
+      lines.push(`public sealed record ${base}Result(${bodyCSharpType(body, ctx)} Data, ${headersRecordName(base)} Headers);`);
+    }
+    return lines;
+  }
+  const responses = observableOf(shape);
+  const withStatus = shape.kind === "multiStatus";
+  for (const response of responses) {
+    const headers = response.headers ?? [];
+    if (headers.length > 0) headerRecord(headers, headersRecordName(base, withStatus ? response.statusCode : void 0));
+  }
+  lines.push("");
+  lines.push(...xmlDocLines(`What ${place} returned.
+
+` + (withStatus ? "The operation declares several statuses the service produces, so the status is part of the value." : "The status declares several content types, so which one arrived is part of the value."), ""));
+  lines.push(`public abstract record ${base}Response`);
+  lines.push("{");
+  lines.push(`    private ${base}Response() { }`);
+  for (const response of responses) {
+    const statusCode = withStatus ? response.statusCode : void 0;
+    const headers = response.headers ?? [];
+    const bodies = response.bodies.length > 0 ? response.bodies : [
+      void 0
+    ];
+    for (const body of bodies) {
+      const name = leafRecordName(response, body, statusCode);
+      const parameters = [];
+      if (body) parameters.push(`${bodyCSharpType(body, ctx)} Data`);
+      if (headers.length > 0) parameters.push(`${headersRecordName(base, statusCode)} Headers`);
+      lines.push("");
+      lines.push(`    public sealed record ${name}(${parameters.join(", ")}) : ${base}Response;`);
+    }
+  }
+  lines.push("}");
+  return lines;
+}
+__name(responseDeclarations, "responseDeclarations");
+function headerReader(header, place) {
+  const scalar = header.type.kind === "scalar" ? header.type.name : void 0;
+  switch (scalar) {
+    case "string":
+    case "email":
+    case "url":
+    case "interval":
+    case "unknown":
+      return {
+        type: "string",
+        read: /* @__PURE__ */ __name((raw) => raw, "read")
+      };
+    case "number":
+      return {
+        type: "double",
+        read: /* @__PURE__ */ __name((raw) => `double.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "int":
+      return {
+        type: "long",
+        read: /* @__PURE__ */ __name((raw) => `long.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "bigint":
+      return {
+        type: "BigInteger",
+        read: /* @__PURE__ */ __name((raw) => `BigInteger.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "boolean":
+      return {
+        type: "bool",
+        read: /* @__PURE__ */ __name((raw) => `${raw} == "true"`, "read")
+      };
+    case "uuid":
+      return {
+        type: "Guid",
+        read: /* @__PURE__ */ __name((raw) => `Guid.Parse(${raw})`, "read")
+      };
+    case "date":
+      return {
+        type: "DateOnly",
+        read: /* @__PURE__ */ __name((raw) => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "time":
+      return {
+        type: "TimeOnly",
+        read: /* @__PURE__ */ __name((raw) => `TimeOnly.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "datetime":
+      return {
+        type: "DateTimeOffset",
+        read: /* @__PURE__ */ __name((raw) => `DateTimeOffset.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
+      };
+    case "duration":
+      return {
+        type: "TimeSpan",
+        read: /* @__PURE__ */ __name((raw) => `XmlConvert.ToTimeSpan(${raw})`, "read")
+      };
+    default:
+      throw new Error(`plugin-csharp: response header '${header.name}' on ${place} is declared as ${describeHeaderType(header.type)}, which cannot be read from an HTTP header. Header values arrive as strings \u2014 declare it as string, email, url, uuid, date, time, datetime, duration, interval, int, number, boolean or bigint.`);
+  }
+}
+__name(headerReader, "headerReader");
+function describeHeaderType(type) {
+  if (type.kind === "scalar") return `the '${type.name}' scalar`;
+  if (type.kind === "ref") return `the contract '${type.name}'`;
+  return `${type.kind === "array" || type.kind === "inlineObject" ? "an" : "a"} ${type.kind}`;
+}
+__name(describeHeaderType, "describeHeaderType");
+function readHeaderLines(headers, typeName, ctx, place, indent) {
+  const args = headers.map((header) => {
+    const reader = headerReader(header, place);
+    const name = quoteCSharpString(header.name);
+    if (!header.optional) return reader.read(`http.RequireHeader(response, ${name})`);
+    const local = toCSharpParameterName(header.name);
+    return `response.Header(${name}) is { } ${local} ? ${reader.read(local)} : null`;
+  });
+  const lines = [
+    `${indent}var headers = new ${typeName}(`
+  ];
+  args.forEach((arg, index) => lines.push(`${indent}    ${arg}${index === args.length - 1 ? ");" : ","}`));
+  return lines;
+}
+__name(readHeaderLines, "readHeaderLines");
+function methodDoc(route, op, observable) {
+  const lines = [];
+  const parts = [];
+  if (op.name) parts.push(op.name);
+  const description = op.description ?? route.description;
+  if (description) parts.push(description);
+  if (parts.length > 0) lines.push(...xmlDocLines(parts.join("\n"), ""));
+  const thrown = op.responses.filter((r) => !observable.includes(r)).map((r) => r.statusCode);
+  if (thrown.length > 0) lines.push(`/// <exception cref="SdkException">On ${thrown.join(", ")}.</exception>`);
+  return lines;
+}
+__name(methodDoc, "methodDoc");
+function httpMethodConstant(method) {
+  const lower = method.toLowerCase();
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+__name(httpMethodConstant, "httpMethodConstant");
+var PATH_PLACEHOLDER = /\{([a-zA-Z_$][a-zA-Z0-9_$.-]*)\}/g;
+function buildPathExpression(path, params) {
+  const args = path.split("/").filter(Boolean).map((raw) => {
+    PATH_PLACEHOLDER.lastIndex = 0;
+    const match = PATH_PLACEHOLDER.exec(raw);
+    if (!match || match[0] !== raw) return quoteCSharpString(raw);
+    const value = params && params.kind !== "params" ? `pathParams.${toCSharpPropertyName(match[1])}` : toCSharpParameterName(match[1]);
+    return `http.Segment(${value})`;
+  });
+  return `http.Path(${args.join(", ")})`;
+}
+__name(buildPathExpression, "buildPathExpression");
+function buildMethodParams(route, op, ctx) {
+  const params = [];
+  if (route.params) {
+    if (route.params.kind === "params") {
+      for (const node of route.params.nodes) {
+        params.push({
+          name: toCSharpParameterName(node.name),
+          type: renderCSharpType(node.type, ctx, true),
+          optional: false
+        });
+      }
+    } else {
+      params.push({
+        name: "pathParams",
+        type: renderParamSourceType(route.params, ctx, ""),
+        optional: false
+      });
+    }
+  }
+  const body = op.request?.bodies[0];
+  if (body) {
+    switch (classifyContentType(body.contentType)) {
+      case "multipart":
+        params.push({
+          name: "body",
+          type: "IEnumerable<SdkPart>",
+          optional: false
+        });
+        break;
+      case "binary":
+        params.push({
+          name: "body",
+          type: "byte[]",
+          optional: false
+        });
+        break;
+      case "text":
+        params.push({
+          name: "body",
+          type: "string",
+          optional: false
+        });
+        break;
+      default:
+        params.push({
+          name: "body",
+          type: renderCSharpType(body.bodyType, ctx, true),
+          optional: false
+        });
+    }
+  }
+  const base = methodBase(deriveMethodName(op, route));
+  if (op.query) {
+    params.push({
+      name: "query",
+      type: renderParamSourceType(op.query, ctx, `${base}Query`),
+      optional: allFieldsOptional(op.query)
+    });
+  }
+  if (op.headers) {
+    params.push({
+      name: "customHeaders",
+      type: renderParamSourceType(op.headers, ctx, `${base}Headers`),
+      optional: allFieldsOptional(op.headers)
+    });
+  }
+  const widened = params.map((p) => p.optional && !p.type.endsWith("?") ? {
+    ...p,
+    type: `${p.type}?`
+  } : p);
+  return [
+    ...widened.filter((p) => !p.optional),
+    ...widened.filter((p) => p.optional)
+  ];
+}
+__name(buildMethodParams, "buildMethodParams");
+function allFieldsOptional(source) {
+  if (source.kind !== "params") return true;
+  return source.nodes.every((node) => Boolean(node.optional) || node.default !== void 0);
+}
+__name(allFieldsOptional, "allFieldsOptional");
+function renderParamSourceType(source, ctx, generatedName) {
+  if (source.kind === "ref") return renderCSharpType({
+    kind: "ref",
+    name: source.name
+  }, ctx, true);
+  if (source.kind === "type") return renderCSharpType(source.node, ctx, true);
+  return source.nodes.length > 0 ? generatedName : "IReadOnlyDictionary<string, string>";
+}
+__name(renderParamSourceType, "renderParamSourceType");
+function deriveMethodName(op, route) {
+  if (op.sdk) return `${toCSharpTypeName(op.sdk)}Async`;
+  if (op.name) return `${toCSharpTypeName(op.name)}Async`;
+  return `${inferMethodName(op.method, route.path)}Async`;
+}
+__name(deriveMethodName, "deriveMethodName");
+function inferMethodName(method, path) {
+  const parts = [
+    toCSharpTypeName(method)
+  ];
+  for (const segment of path.split("/").filter(Boolean)) {
+    if (segment.startsWith("{")) parts.push(`By${toCSharpTypeName(segment.slice(1, -1))}`);
+    else parts.push(toCSharpTypeName(segment));
+  }
+  return parts.join("");
+}
+__name(inferMethodName, "inferMethodName");
+
+// src/codegen-sdk.ts
+function generateSdkCs(namespaceName, sdkName, clients) {
+  const lines = [
+    "// <auto-generated/>",
+    "// Generated by @contractkit/plugin-csharp. Do not edit manually.",
+    "#nullable enable",
+    ""
+  ];
+  lines.push("using System;");
+  if (clients.length > 0) lines.push(`using ${namespaceName}.Clients;`);
+  lines.push(`using ${namespaceName}.Runtime;`);
+  lines.push("");
+  lines.push(`namespace ${namespaceName};`);
+  lines.push("");
+  lines.push(...xmlDocLines("Entry point to the generated SDK.\n\nHolds one SdkHttp, shared by every client, so the SDK keeps a single connection pool.\nDisposing it disposes the underlying HttpClient, unless you supplied your own.", ""));
+  lines.push(`public sealed class ${sdkName} : IDisposable`);
+  lines.push("{");
+  lines.push(`    public ${sdkName}(SdkOptions options)`);
+  lines.push("    {");
+  lines.push("        Http = new SdkHttp(options);");
+  for (const client of clients) lines.push(`        ${client.propertyName} = new ${client.className}(Http);`);
+  lines.push("    }");
+  lines.push("");
+  lines.push("    public SdkHttp Http { get; }");
+  for (const client of clients) {
+    lines.push("");
+    lines.push(`    public ${client.className} ${client.propertyName} { get; }`);
+  }
+  lines.push("");
+  lines.push("    public void Dispose()");
+  lines.push("    {");
+  lines.push("        Http.Dispose();");
+  lines.push("    }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generateSdkCs, "generateSdkCs");
+
+// src/hoist.ts
+import { collectTypeRefs, resolveEffectiveFields as resolveEffectiveFields2 } from "@contractkit/core";
+function collectHoistedTypes(roots, opts) {
+  const state = {
+    ...opts,
+    byNode: /* @__PURE__ */ new Map(),
+    byName: /* @__PURE__ */ new Map(),
+    byFile: /* @__PURE__ */ new Map(),
+    memberships: /* @__PURE__ */ new Map(),
+    taken: new Set(roots.flatMap((r) => r.models.map((m) => m.name)))
+  };
+  for (const root of roots) {
+    for (const model of root.models) {
+      if (model.type) {
+        walkType(model.type, model.name, root.file, state, true, model.description);
+      }
+      for (const field of model.fields) {
+        walkType(field.type, `${model.name}${toCSharpTypeName(field.name)}`, root.file, state, false, field.description);
+      }
+    }
+  }
+  return {
+    byNode: state.byNode,
+    byName: state.byName,
+    byFile: state.byFile,
+    memberships: state.memberships
+  };
+}
+__name(collectHoistedTypes, "collectHoistedTypes");
+function walkType(type, path, ownerFile, state, atAliasRoot, description) {
+  switch (type.kind) {
+    case "union":
+      hoistPlainUnion(type, path, ownerFile, state, atAliasRoot, description);
+      return;
+    case "discriminatedUnion":
+      hoistDiscriminatedUnion(type, path, ownerFile, state, atAliasRoot, description);
+      return;
+    case "enum":
+      if (!atAliasRoot) {
+        hoist(type, {
+          kind: "enum",
+          name: claimFor(path, state, false),
+          ownerFile,
+          needsInput: false,
+          values: type.values,
+          description
+        }, state);
+      }
+      return;
+    case "inlineObject":
+      if (!atAliasRoot) hoistRecord(type, type.fields, path, ownerFile, state, description);
+      else type.fields.forEach((f) => walkType(f.type, `${path}${toCSharpTypeName(f.name)}`, ownerFile, state, false, f.description));
+      return;
+    case "intersection": {
+      if (atAliasRoot) {
+        type.members.forEach((m) => walkType(m, path, ownerFile, state, true));
+        return;
+      }
+      const { fields } = resolveEffectiveFields2(type, state.modelIndex);
+      hoistRecord(type, fields, path, ownerFile, state, description);
+      return;
+    }
+    case "tuple":
+      type.items.forEach((item, i) => walkType(item, `${path}Item${i}`, ownerFile, state, false));
+      hoist(type, {
+        kind: "tuple",
+        name: claimFor(path, state, false),
+        ownerFile,
+        needsInput: type.items.some((t) => typeNeedsInput(t, state)),
+        items: type.items,
+        description
+      }, state);
+      return;
+    case "array":
+      walkType(type.item, path, ownerFile, state, false);
+      return;
+    case "record":
+      walkType(type.value, path, ownerFile, state, false);
+      return;
+    case "lazy":
+      walkType(type.inner, path, ownerFile, state, atAliasRoot, description);
+      return;
+    default:
+      return;
+  }
+}
+__name(walkType, "walkType");
+function hoistRecord(node, fields, path, ownerFile, state, description) {
+  const name = claimFor(path, state, false);
+  for (const f of fields) walkType(f.type, `${name}${toCSharpTypeName(f.name)}`, ownerFile, state, false, f.description);
+  hoist(node, {
+    kind: "record",
+    name,
+    ownerFile,
+    needsInput: fields.some((f) => f.visibility !== "normal" || typeNeedsInput(f.type, state)),
+    fields,
+    description
+  }, state);
+}
+__name(hoistRecord, "hoistRecord");
+function hoistPlainUnion(type, path, ownerFile, state, atAliasRoot, description) {
+  const nullable = type.members.some((m) => m.kind === "scalar" && m.name === "null");
+  const members = type.members.filter((m) => !(m.kind === "scalar" && m.name === "null"));
+  if (members.length <= 1) {
+    if (members[0]) walkType(members[0], path, ownerFile, state, false);
+    return;
+  }
+  if (members.every((m) => m.kind === "literal" && typeof m.value === "string")) {
+    const values = members.map((m) => String(m.value));
+    hoist(type, {
+      kind: "enum",
+      name: claimFor(path, state, atAliasRoot),
+      ownerFile,
+      needsInput: false,
+      nullable,
+      values,
+      description
+    }, state);
+    return;
+  }
+  const name = claimFor(path, state, atAliasRoot);
+  const used = /* @__PURE__ */ new Set();
+  const hoisted = [];
+  for (const member of members) {
+    walkType(member, `${name}${toCSharpTypeName(memberLabel(member, state))}`, ownerFile, state, false);
+    const typeName = memberTypeName(member, state);
+    hoisted.push({
+      typeName,
+      wrapperName: uniqueIn(`Of${toCSharpTypeName(memberLabel(member, state))}`, used),
+      type: member
+    });
+  }
+  hoist(type, {
+    kind: "plainUnion",
+    name,
+    ownerFile,
+    needsInput: members.some((m) => typeNeedsInput(m, state)),
+    nullable,
+    members: hoisted,
+    description
+  }, state);
+}
+__name(hoistPlainUnion, "hoistPlainUnion");
+function hoistDiscriminatedUnion(type, path, ownerFile, state, atAliasRoot, description) {
+  const name = claimFor(path, state, atAliasRoot);
+  const members = [];
+  for (const member of type.members) {
+    const { fields } = resolveEffectiveFields2(member, state.modelIndex);
+    const discriminatorField = fields.find((f) => f.name === type.discriminator);
+    const tagType = discriminatorField?.type.kind === "lazy" ? discriminatorField.type.inner : discriminatorField?.type;
+    if (!tagType || tagType.kind !== "literal") {
+      state.warn?.(`Discriminated union '${name}' has a member whose '${type.discriminator}' is not a literal, so its tag is not known at build time; emitting a raw JSON value instead of an interface.`, ownerFile);
+      release(name, state, atAliasRoot);
+      return;
+    }
+    const tag = String(tagType.value);
+    if (member.kind === "ref") {
+      members.push({
+        typeName: member.name,
+        tag,
+        type: member
+      });
+    } else {
+      const memberPath = `${name}${toCSharpTypeName(tag)}`;
+      hoistRecord(member, fields, memberPath, ownerFile, state, void 0);
+      const decl2 = state.byNode.get(member);
+      if (!decl2) {
+        release(name, state, atAliasRoot);
+        return;
+      }
+      members.push({
+        typeName: decl2.name,
+        tag,
+        type: member
+      });
+    }
+  }
+  if (members.length === 0) {
+    release(name, state, atAliasRoot);
+    return;
+  }
+  const decl = {
+    kind: "discriminatedUnion",
+    name,
+    ownerFile,
+    needsInput: type.members.some((m) => typeNeedsInput(m, state)),
+    members,
+    discriminator: type.discriminator,
+    description
+  };
+  hoist(type, decl, state);
+  for (const member of members) {
+    const list = state.memberships.get(member.typeName) ?? [];
+    if (!list.includes(name)) list.push(name);
+    state.memberships.set(member.typeName, list);
+  }
+}
+__name(hoistDiscriminatedUnion, "hoistDiscriminatedUnion");
+function memberLabel(type, state) {
+  switch (type.kind) {
+    case "ref":
+      return type.name;
+    case "scalar":
+      return type.name;
+    case "array":
+      return `${memberLabel(type.item, state)}List`;
+    case "record":
+      return `${memberLabel(type.value, state)}Map`;
+    case "literal":
+      return typeof type.value === "string" ? type.value : String(type.value);
+    case "lazy":
+      return memberLabel(type.inner, state);
+    default: {
+      const decl = state.byNode.get(type);
+      return decl ? decl.name : "Member";
+    }
+  }
+}
+__name(memberLabel, "memberLabel");
+function memberTypeName(type, state) {
+  const decl = state.byNode.get(type);
+  if (decl) return decl.name;
+  if (type.kind === "ref") return type.name;
+  return "";
+}
+__name(memberTypeName, "memberTypeName");
+function typeNeedsInput(type, state) {
+  const refs = /* @__PURE__ */ new Set();
+  collectTypeRefs(type, refs);
+  if ([
+    ...refs
+  ].some((r) => state.modelsWithInput.has(r))) return true;
+  return hasVisibilityField(type);
+}
+__name(typeNeedsInput, "typeNeedsInput");
+function hasVisibilityField(type) {
+  switch (type.kind) {
+    case "inlineObject":
+      return type.fields.some((f) => f.visibility !== "normal" || hasVisibilityField(f.type));
+    case "array":
+      return hasVisibilityField(type.item);
+    case "record":
+      return hasVisibilityField(type.value);
+    case "lazy":
+      return hasVisibilityField(type.inner);
+    case "tuple":
+      return type.items.some(hasVisibilityField);
+    case "union":
+    case "intersection":
+    case "discriminatedUnion":
+      return type.members.some(hasVisibilityField);
+    default:
+      return false;
+  }
+}
+__name(hasVisibilityField, "hasVisibilityField");
+function hoist(node, decl, state) {
+  state.byNode.set(node, decl);
+  state.byName.set(decl.name, decl);
+  const list = state.byFile.get(decl.ownerFile) ?? [];
+  list.push(decl);
+  state.byFile.set(decl.ownerFile, list);
+}
+__name(hoist, "hoist");
+function claimFor(path, state, atAliasRoot) {
+  if (atAliasRoot) return path;
+  return uniqueIn(sanitizeCSharpTypeName(path), state.taken);
+}
+__name(claimFor, "claimFor");
+function release(name, state, atAliasRoot) {
+  if (!atAliasRoot) state.taken.delete(name);
+}
+__name(release, "release");
+function uniqueIn(base, taken) {
+  if (!taken.has(base)) {
+    taken.add(base);
+    return base;
+  }
+  let n = 2;
+  while (taken.has(`${base}${n}`)) n++;
+  taken.add(`${base}${n}`);
+  return `${base}${n}`;
+}
+__name(uniqueIn, "uniqueIn");
+
+// src/runtime.ts
+function generateRuntimeCs(namespaceName) {
+  return `// <auto-generated/>
+// Generated by @contractkit/plugin-csharp. Do not edit manually.
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ${namespaceName}.Runtime;
+
+/// <summary>
+/// How to reach the service.
+/// </summary>
+public sealed class SdkOptions
+{
+    /// <summary>Origin, optionally with a path prefix. Operation paths are appended to it.</summary>
+    public required string BaseUrl { get; init; }
+
+    /// <summary>
+    /// Called once per request. Authentication belongs here: returning a fresh map each time lets a
+    /// token be refreshed without rebuilding the SDK.
+    /// </summary>
+    public Func<CancellationToken, ValueTask<IReadOnlyDictionary<string, string>>>? Headers { get; init; }
+
+    /// <summary>
+    /// Supply your own client to control handlers, proxies or retries. When you do, the SDK never
+    /// disposes it. Leave it null and the SDK creates and owns one.
+    /// </summary>
+    public HttpClient? HttpClient { get; init; }
+
+    /// <summary>
+    /// How bodies, query values and headers are serialized. Defaults to <see cref="SdkJson.Options"/>,
+    /// which carries the converters the contract's scalar types need.
+    /// </summary>
+    public JsonSerializerOptions Json { get; init; } = SdkJson.Options;
+}
+
+/// <summary>
+/// A status the contract does not account for.
+/// </summary>
+/// <remarks>
+/// Derives from <see cref="HttpRequestException"/>, so it can be caught alongside any other client
+/// failure, and passes the status through to <c>StatusCode</c> for callers that catch the base type.
+/// </remarks>
+public class SdkException : HttpRequestException
+{
+    public SdkException(int status, string body, HttpResponseHeaders? responseHeaders = null, string? message = null)
+        : base(message ?? $"Request failed with status {status}", null, ToStatusCode(status))
+    {
+        Status = status;
+        Body = body;
+        ResponseHeaders = responseHeaders;
+    }
+
+    /// <summary>The HTTP status the service returned.</summary>
+    public int Status { get; }
+
+    /// <summary>The raw response body, read as UTF-8 text.</summary>
+    public string Body { get; }
+
+    /// <summary>The response headers, when the failure came from a response rather than a missing header.</summary>
+    public HttpResponseHeaders? ResponseHeaders { get; }
+
+    private bool _jsonParsed;
+    private JsonElement? _json;
+
+    /// <summary>
+    /// The body parsed as JSON, or null when it is not JSON. Error contracts usually are.
+    /// </summary>
+    public JsonElement? Json
+    {
+        get
+        {
+            if (_jsonParsed) return _json;
+            _jsonParsed = true;
+            try
+            {
+                using var document = JsonDocument.Parse(Body);
+                // Clone detaches the element from the document being disposed here.
+                _json = document.RootElement.Clone();
+            }
+            catch (JsonException)
+            {
+                _json = null;
+            }
+            return _json;
+        }
+    }
+
+    /// <summary>
+    /// Read the error body as <typeparamref name="T"/>, or null when it does not parse. Operations
+    /// whose thrown statuses declare a body generate an alias naming the type to use here.
+    /// </summary>
+    public T? TryReadBody<T>(JsonSerializerOptions? options = null)
+        where T : class
+    {
+        try
+        {
+            return JsonSerializer.Deserialize<T>(Body, options ?? SdkJson.Options);
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+    }
+
+    private static HttpStatusCode? ToStatusCode(int status) =>
+        status is >= 100 and <= 599 ? (HttpStatusCode)status : null;
+}
+
+/// <summary>
+/// One response, with its body already read.
+/// </summary>
+/// <remarks>
+/// Reading the body eagerly is what allows a generated method to check the status, then the content
+/// type, then decode, which is exactly what an operation declaring several statuses or several
+/// mimes has to do.
+/// </remarks>
+public sealed class SdkResponse
+{
+    private string? _text;
+
+    public SdkResponse(HttpResponseMessage message, byte[] bytes)
+    {
+        Message = message;
+        Bytes = bytes;
+    }
+
+    public HttpResponseMessage Message { get; }
+
+    /// <summary>The body as raw bytes.</summary>
+    public byte[] Bytes { get; }
+
+    public int Status => (int)Message.StatusCode;
+
+    /// <summary>The response mime without its parameters, so <c>application/json; charset=utf-8</c> matches.</summary>
+    public string ContentType => Message.Content.Headers.ContentType?.MediaType ?? string.Empty;
+
+    /// <summary>The body decoded as UTF-8.</summary>
+    public string Text => _text ??= Encoding.UTF8.GetString(Bytes);
+
+    /// <summary>
+    /// The first value of a response or content header, or null when the service did not send it.
+    /// </summary>
+    public string? Header(string name)
+    {
+        if (Message.Headers.TryGetValues(name, out var values)) return values.FirstOrDefault();
+        if (Message.Content.Headers.TryGetValues(name, out var contentValues)) return contentValues.FirstOrDefault();
+        return null;
+    }
+}
+
+/// <summary>
+/// One part of a multipart request body.
+/// </summary>
+public sealed record SdkPart(string Name, HttpContent Content, string? FileName = null)
+{
+    /// <summary>A plain text field.</summary>
+    public static SdkPart Text(string name, string value) => new(name, new StringContent(value, Encoding.UTF8));
+
+    /// <summary>A file field, sent with a filename and its own content type.</summary>
+    public static SdkPart File(string name, byte[] bytes, string fileName, string contentType = "application/octet-stream")
+    {
+        var content = new ByteArrayContent(bytes);
+        content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+        return new SdkPart(name, content, fileName);
+    }
+}
+
+/// <summary>
+/// Issues requests and turns anything the contract does not describe into an <see cref="SdkException"/>.
+/// </summary>
+/// <remarks>
+/// Every value bound for a path, query, header or form field is turned into text by serializing it
+/// the same way it would be serialized into a JSON body. That is what keeps a <c>Guid</c>, a
+/// <c>DateTimeOffset</c>, a <c>TimeSpan</c> or an enum spelled identically wherever it appears in a
+/// request, without a line of per-type code in the generator.
+/// </remarks>
+public sealed class SdkHttp : IDisposable
+{
+    private readonly SdkOptions _options;
+    private readonly bool _ownsClient;
+
+    public SdkHttp(SdkOptions options)
+    {
+        _options = options;
+        _ownsClient = options.HttpClient is null;
+        Client = options.HttpClient ?? new HttpClient();
+        Json = options.Json;
+    }
+
+    public HttpClient Client { get; }
+
+    public JsonSerializerOptions Json { get; }
+
+    /// <summary>
+    /// Send one request and read its body.
+    /// </summary>
+    /// <remarks>
+    /// <c>expectStatuses</c> carries the statuses the operation declares as outcomes rather than
+    /// failures, such as a 404 the contract gives a meaning. Everything outside 2xx and that set
+    /// throws.
+    /// </remarks>
+    /// <exception cref="SdkException">On a status the contract does not declare.</exception>
+    public async Task<SdkResponse> ExecuteAsync(
+        HttpMethod method,
+        string path,
+        IEnumerable<KeyValuePair<string, string>>? query = null,
+        IEnumerable<KeyValuePair<string, string>>? headers = null,
+        HttpContent? content = null,
+        IReadOnlyCollection<int>? expectStatuses = null,
+        CancellationToken cancellationToken = default)
+    {
+        using var request = new HttpRequestMessage(method, BuildUrl(path, query));
+        if (content is not null) request.Content = content;
+
+        if (_options.Headers is not null)
+        {
+            foreach (var entry in await _options.Headers(cancellationToken).ConfigureAwait(false))
+            {
+                request.Headers.TryAddWithoutValidation(entry.Key, entry.Value);
+            }
+        }
+
+        if (headers is not null)
+        {
+            foreach (var entry in headers)
+            {
+                request.Headers.TryAddWithoutValidation(entry.Key, entry.Value);
+            }
+        }
+
+        var message = await Client.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken).ConfigureAwait(false);
+        var bytes = await message.Content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
+        var response = new SdkResponse(message, bytes);
+
+        var status = response.Status;
+        if ((status < 200 || status > 299) && (expectStatuses is null || !expectStatuses.Contains(status)))
+        {
+            throw new SdkException(status, response.Text, message.Headers);
+        }
+
+        return response;
+    }
+
+    /// <summary>Decode a JSON response body.</summary>
+    /// <exception cref="SdkException">When the body is JSON null.</exception>
+    public T ReadJson<T>(SdkResponse response)
+    {
+        var value = JsonSerializer.Deserialize<T>(response.Bytes, Json);
+        if (value is null)
+        {
+            throw new SdkException(response.Status, response.Text, response.Message.Headers, "Response body was null");
+        }
+
+        return value;
+    }
+
+    /// <summary>
+    /// Read a response header the contract declares as required.
+    /// </summary>
+    /// <exception cref="SdkException">When the service did not send it, since the caller was promised a value.</exception>
+    public string RequireHeader(SdkResponse response, string name) =>
+        response.Header(name)
+        ?? throw new SdkException(response.Status, response.Text, response.Message.Headers, $"Response is missing the required header '{name}'");
+
+    /// <summary>Join path segments onto the base URL. Each segment is already escaped.</summary>
+    public string Path(params string[] segments) => segments.Length == 0 ? string.Empty : "/" + string.Join("/", segments);
+
+    /// <summary>The escaped text form of a single value, for use as a path segment.</summary>
+    public string Segment<T>(T value) => Uri.EscapeDataString(ScalarText(JsonSerializer.SerializeToElement(value, Json)) ?? string.Empty);
+
+    /// <summary>
+    /// Every property of <paramref name="value"/> as a key and value pair. A list property repeats
+    /// its key; a null property is omitted.
+    /// </summary>
+    public IEnumerable<KeyValuePair<string, string>> Params<T>(T value)
+    {
+        if (value is null) yield break;
+
+        var element = JsonSerializer.SerializeToElement(value, Json);
+        if (element.ValueKind != JsonValueKind.Object) yield break;
+
+        foreach (var property in element.EnumerateObject())
+        {
+            if (property.Value.ValueKind == JsonValueKind.Array)
+            {
+                foreach (var item in property.Value.EnumerateArray())
+                {
+                    if (ScalarText(item) is { } itemText) yield return new KeyValuePair<string, string>(property.Name, itemText);
+                }
+            }
+            else if (ScalarText(property.Value) is { } text)
+            {
+                yield return new KeyValuePair<string, string>(property.Name, text);
+            }
+        }
+    }
+
+    /// <summary>A JSON body. Sent as a buffered string so the request carries a Content-Length.</summary>
+    public HttpContent JsonContent<T>(T value, string mediaType) =>
+        new StringContent(JsonSerializer.Serialize(value, Json), Encoding.UTF8, mediaType);
+
+    /// <summary>A form-encoded body, built from the same property walk as the query string.</summary>
+    public HttpContent FormContent<T>(T value) => new FormUrlEncodedContent(Params(value));
+
+    /// <summary>A multipart body.</summary>
+    public HttpContent MultipartContent(IEnumerable<SdkPart> parts)
+    {
+        var content = new MultipartFormDataContent();
+        foreach (var part in parts)
+        {
+            if (part.FileName is null) content.Add(part.Content, part.Name);
+            else content.Add(part.Content, part.Name, part.FileName);
+        }
+
+        return content;
+    }
+
+    /// <summary>A text body with an explicit mime.</summary>
+    public HttpContent TextContent(string value, string mediaType) => new StringContent(value, Encoding.UTF8, mediaType);
+
+    /// <summary>A binary body with an explicit mime.</summary>
+    public HttpContent BinaryContent(byte[] value, string mediaType)
+    {
+        var content = new ByteArrayContent(value);
+        content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
+        return content;
+    }
+
+    /// <summary>The text a scalar JSON value travels as outside a body, or null when it is absent.</summary>
+    public static string? ScalarText(JsonElement element) =>
+        element.ValueKind switch
+        {
+            JsonValueKind.Null or JsonValueKind.Undefined => null,
+            JsonValueKind.String => element.GetString(),
+            JsonValueKind.True => "true",
+            JsonValueKind.False => "false",
+            _ => element.GetRawText(),
+        };
+
+    public void Dispose()
+    {
+        if (_ownsClient) Client.Dispose();
+    }
+
+    private string BuildUrl(string path, IEnumerable<KeyValuePair<string, string>>? query)
+    {
+        var builder = new StringBuilder(_options.BaseUrl.TrimEnd('/')).Append(path);
+        if (query is null) return builder.ToString();
+
+        var first = true;
+        foreach (var entry in query)
+        {
+            builder.Append(first ? '?' : '&');
+            first = false;
+            builder.Append(Uri.EscapeDataString(entry.Key)).Append('=').Append(Uri.EscapeDataString(entry.Value));
+        }
+
+        return builder.ToString();
+    }
+}
+`;
+}
+__name(generateRuntimeCs, "generateRuntimeCs");
+
+// src/runtime-converters.ts
+function generateConvertersCs(namespaceName) {
+  return `// <auto-generated/>
+// Generated by @contractkit/plugin-csharp. Do not edit manually.
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Xml;
+
+namespace ${namespaceName}.Runtime;
+
+/// <summary>
+/// How the SDK reads and writes JSON.
+/// </summary>
+/// <remarks>
+/// Unknown properties are skipped, which is the default, so a service adding a field does not break
+/// an older client. Serialize a generated model with these options: three of the contract's scalar
+/// types need the converters registered here.
+/// </remarks>
+public static class SdkJson
+{
+    public static readonly JsonSerializerOptions Options = CreateOptions();
+
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new BigIntegerConverter());
+        options.Converters.Add(new DecimalStringConverter());
+        options.Converters.Add(new IsoTimeSpanConverter());
+        return options;
+    }
+}
+
+/// <summary>
+/// An arbitrary-precision integer. Written as a plain digit string.
+/// </summary>
+/// <remarks>
+/// Reading accepts a digit string, the <c>123n</c> form the TypeScript SDK writes, and a JSON
+/// number, so a body written by any ContractKit client reads back here.
+/// </remarks>
+public sealed class BigIntegerConverter : JsonConverter<BigInteger>
+{
+    public override BigInteger Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var text = reader.GetString() ?? throw new JsonException("Expected a digit string for a bigint.");
+            return BigInteger.Parse(text.TrimEnd('n'), NumberStyles.Integer, CultureInfo.InvariantCulture);
+        }
+
+        if (reader.TokenType == JsonTokenType.Number)
+        {
+            // Read the raw token rather than a long: the value may be wider than any BCL integer,
+            // which is the whole reason the contract called it a bigint.
+            var raw = Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan);
+            return BigInteger.Parse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture);
+        }
+
+        throw new JsonException($"Expected a JSON string or number for a bigint, got {reader.TokenType}.");
+    }
+
+    public override void Write(Utf8JsonWriter writer, BigInteger value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// An exact decimal number. Travels as a quoted JSON string, never as a JSON number.
+/// </summary>
+/// <remarks>
+/// A JSON number has already been through a double by the time it reaches this converter, so the
+/// precision the contract asked for is gone. Reading an unquoted number is rejected for that
+/// reason, which matches the Kotlin SDK and the server's own schema.
+/// </remarks>
+public sealed class DecimalStringConverter : JsonConverter<decimal>
+{
+    public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a quoted decimal string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a decimal string.");
+        return decimal.Parse(text, NumberStyles.Float, CultureInfo.InvariantCulture);
+    }
+
+    public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// A duration, as an ISO 8601 string such as <c>PT1H30M</c>.
+/// </summary>
+/// <remarks>
+/// System.Text.Json writes a <c>TimeSpan</c> as <c>d.hh:mm:ss</c> by default, which no other
+/// ContractKit SDK would read, so this converter is not optional.
+/// </remarks>
+public sealed class IsoTimeSpanConverter : JsonConverter<TimeSpan>
+{
+    public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected an ISO 8601 duration string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected an ISO 8601 duration string.");
+        try
+        {
+            return XmlConvert.ToTimeSpan(text);
+        }
+        catch (FormatException error)
+        {
+            throw new JsonException($"'{text}' is not an ISO 8601 duration.", error);
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(XmlConvert.ToString(value));
+    }
+}
+`;
+}
+__name(generateConvertersCs, "generateConvertersCs");
+
+// src/scaffold.ts
+var SCAFFOLD_VERSIONS = {
+  targetFramework: "net10.0"
+};
+function generateCsproj(namespaceName, sdkName) {
+  return `<!-- Created once by @contractkit/plugin-csharp. Yours to edit: it is never regenerated. -->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>${SCAFFOLD_VERSIONS.targetFramework}</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <RootNamespace>${namespaceName}</RootNamespace>
+    <AssemblyName>${sdkName}</AssemblyName>
+  </PropertyGroup>
+
+</Project>
+`;
+}
+__name(generateCsproj, "generateCsproj");
+
+// src/index.ts
+var CSHARP_CODEGEN_VERSION = "1";
+var CACHE_MANIFEST_FILENAME = "csharp-manifest.json";
+var DEFAULT_BASE_DIR = "csharp-sdk";
+var DEFAULT_NAMESPACE = "ContractKit.Sdk";
+var DEFAULT_SDK_NAME = "Sdk";
+var plugin = {
+  name: "csharp-sdk",
+  async generateTargets(inputs, ctx) {
+    const config = ctx.options;
+    await runCSharpCodegen(inputs, ctx, config, ctx.rootDir);
+  }
+};
+var index_default = plugin;
+function createCSharpSdkPlugin(config, rootDir) {
+  return {
+    name: "csharp-sdk",
+    async generateTargets(inputs, ctx) {
+      await runCSharpCodegen(inputs, ctx, config, rootDir);
+    }
+  };
+}
+__name(createCSharpSdkPlugin, "createCSharpSdkPlugin");
+var NAMESPACE_RE = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+var SDK_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertValidConfig(config) {
+  const { namespace, sdkName } = config;
+  if (namespace !== void 0) {
+    if (typeof namespace !== "string" || !NAMESPACE_RE.test(namespace)) {
+      throw new Error(`plugin-csharp: namespace '${String(namespace)}' is not a valid C# namespace \u2014 expected dot-separated identifiers, e.g. 'Acme.Sdk'.`);
+    }
+    const keyword = namespace.split(".").find((segment) => CSHARP_KEYWORDS.has(segment));
+    if (keyword) {
+      throw new Error(`plugin-csharp: namespace '${namespace}' contains the C# keyword '${keyword}', which cannot appear in a namespace.`);
+    }
+  }
+  if (sdkName !== void 0) {
+    if (typeof sdkName !== "string" || !SDK_NAME_RE.test(sdkName)) {
+      throw new Error(`plugin-csharp: sdkName '${String(sdkName)}' is not a valid C# class name.`);
+    }
+    if (CSHARP_KEYWORDS.has(sdkName)) {
+      throw new Error(`plugin-csharp: sdkName '${sdkName}' is a C# keyword.`);
+    }
+  }
+  for (const key of [
+    "includeInternal",
+    "scaffold"
+  ]) {
+    const value = config[key];
+    if (value !== void 0 && typeof value !== "boolean") {
+      throw new Error(`plugin-csharp: ${key} must be a boolean \u2014 got ${JSON.stringify(value)}.`);
+    }
+  }
+}
+__name(assertValidConfig, "assertValidConfig");
+async function runCSharpCodegen(inputs, ctx, config, rootDir) {
+  assertValidConfig(config);
+  const { contractRoots } = inputs;
+  const namespaceName = config.namespace ?? DEFAULT_NAMESPACE;
+  const sdkName = config.sdkName ?? DEFAULT_SDK_NAME;
+  const outDir = resolve(rootDir, config.baseDir ?? DEFAULT_BASE_DIR);
+  const manifestPath = resolve(ctx.cacheDir, CACHE_MANIFEST_FILENAME);
+  const allModels = contractRoots.flatMap((root) => root.models);
+  const modelIndex = buildModelIndex2(allModels);
+  const modelsWithInput = resolveModelsWithInput(allModels, inputs.modelsWithInput);
+  const modelsWithInputArray = [
+    ...modelsWithInput
+  ].sort();
+  const hoisted = collectHoistedTypes(contractRoots, {
+    modelIndex,
+    modelsWithInput,
+    warn: /* @__PURE__ */ __name((message, file) => ctx.warn?.(message, file), "warn")
+  });
+  const prevManifest = ctx.cacheEnabled ? readManifest(manifestPath) : emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+  const units = [];
+  const clients = [];
+  for (const root of contractRoots) {
+    const relPath = `Models/${deriveCSharpFileBase(root.file)}.cs`;
+    const ownNames = new Set(root.models.map((m) => m.name));
+    const referenced = referencedModelNames(root);
+    const relevantInputModels = modelsWithInputArray.filter((name) => ownNames.has(name) || referenced.has(name));
+    const externalBases = [
+      ...referenced
+    ].filter((name) => !ownNames.has(name)).sort().map((name) => modelIndex.get(name)).filter((m) => m !== void 0);
+    const ownedDeclarations = (hoisted.byFile.get(root.file) ?? []).map((d) => ({
+      kind: d.kind,
+      name: d.name,
+      needsInput: d.needsInput
+    }));
+    const declaredMemberships = [
+      ...ownNames
+    ].sort().map((name) => [
+      name,
+      hoisted.memberships.get(name) ?? []
+    ]).filter(([, unions]) => unions.length > 0);
+    const fingerprint = hashFingerprint({
+      kind: "models",
+      v: CSHARP_CODEGEN_VERSION,
+      relPath,
+      namespace: namespaceName,
+      root,
+      externalBases,
+      modelsWithInput: relevantInputModels,
+      ownedDeclarations,
+      declaredMemberships
+    });
+    units.push({
+      key: `models::${relPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: relPath,
+          content: generateCSharpModels(root, {
+            namespace: namespaceName,
+            modelsWithInput,
+            modelIndex,
+            hoisted,
+            warn: /* @__PURE__ */ __name((message) => ctx.warn?.(message, root.file), "warn")
+          })
+        }
+      ], "render")
+    });
+  }
+  for (const root of inputs.opRoots) {
+    if (!hasPublicOperations(root, config.includeInternal)) continue;
+    const relPath = `Clients/${deriveClientClassName(root.file)}.cs`;
+    clients.push({
+      className: deriveClientClassName(root.file),
+      propertyName: deriveClientPropertyName(root.file)
+    });
+    const referenced = referencedOpModels(root, modelIndex);
+    const relevantInputModels = modelsWithInputArray.filter((name) => referenced.has(name));
+    const referencedModels = [
+      ...referenced
+    ].sort().map((name) => modelIndex.get(name)).filter((m) => m !== void 0);
+    const fingerprint = hashFingerprint({
+      kind: "client",
+      v: CSHARP_CODEGEN_VERSION,
+      relPath,
+      namespace: namespaceName,
+      root,
+      referencedModels,
+      modelsWithInput: relevantInputModels,
+      includeInternal: config.includeInternal ?? false
+    });
+    units.push({
+      key: `client::${relPath}`,
+      fingerprint,
+      render: /* @__PURE__ */ __name(() => [
+        {
+          relativePath: relPath,
+          content: generateCSharpClient(root, {
+            namespace: namespaceName,
+            modelsWithInput,
+            modelIndex,
+            hoisted,
+            includeInternal: config.includeInternal,
+            warn: /* @__PURE__ */ __name((message) => ctx.warn?.(message, root.file), "warn")
+          })
+        }
+      ], "render")
+    });
+  }
+  const globalFiles = [
+    {
+      relativePath: "Runtime/Converters.cs",
+      content: generateConvertersCs(namespaceName)
+    },
+    {
+      relativePath: "Runtime/SdkRuntime.cs",
+      content: generateRuntimeCs(namespaceName)
+    },
+    {
+      relativePath: `${sdkName}.cs`,
+      content: generateSdkCs(namespaceName, sdkName, clients)
+    }
+  ];
+  if (config.scaffold) {
+    globalFiles.push({
+      relativePath: `${sdkName}.csproj`,
+      content: generateCsproj(namespaceName, sdkName),
+      ifAbsent: true
+    });
+  }
+  const result = runIncrementalCodegen({
+    codegenVersion: CSHARP_CODEGEN_VERSION,
+    prevManifest,
+    globalFiles,
+    units,
+    fileExists: /* @__PURE__ */ __name((relPath) => existsSync(resolve(outDir, relPath)), "fileExists")
+  });
+  deleteStalePaths(outDir, result.deletedPaths);
+  for (const { relativePath, content, ifAbsent } of result.filesToWrite) {
+    ctx.emitFile(resolve(outDir, relativePath), content, ifAbsent ? {
+      ifAbsent: true
+    } : void 0);
+  }
+  writeManifest(manifestPath, result.manifest);
+}
+__name(runCSharpCodegen, "runCSharpCodegen");
+function referencedOpModels(root, modelIndex) {
+  const seeds = [];
+  const addParamSource = /* @__PURE__ */ __name((source) => {
+    if (!source) return;
+    if (source.kind === "params") seeds.push(...source.nodes.map((n) => n.type));
+    else if (source.kind === "ref") seeds.push({
+      kind: "ref",
+      name: source.name
+    });
+    else seeds.push(source.node);
+  }, "addParamSource");
+  for (const route of root.routes) {
+    addParamSource(route.params);
+    for (const op of route.operations) {
+      addParamSource(op.query);
+      addParamSource(op.headers);
+      for (const body of op.request?.bodies ?? []) seeds.push(body.bodyType);
+      for (const response of op.responses) {
+        for (const body of response.bodies) seeds.push(body.bodyType);
+        for (const header of response.headers ?? []) seeds.push(header.type);
+      }
+    }
+  }
+  return collectTransitiveModelRefs(seeds, modelIndex);
+}
+__name(referencedOpModels, "referencedOpModels");
+function referencedModelNames(root) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const model of root.models) {
+    if (model.type) collectTypeRefs2(model.type, refs);
+    for (const f of model.fields) collectTypeRefs2(f.type, refs);
+    if (model.bases) for (const base of model.bases) refs.add(base);
+  }
+  return refs;
+}
+__name(referencedModelNames, "referencedModelNames");
+function readManifest(manifestPath) {
+  if (!existsSync(manifestPath)) return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+  try {
+    return parseIncrementalManifest(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+  }
+}
+__name(readManifest, "readManifest");
+function writeManifest(manifestPath, manifest) {
+  try {
+    mkdirSync(dirname(manifestPath), {
+      recursive: true
+    });
+    writeFileSync(manifestPath, serializeIncrementalManifest(manifest), "utf-8");
+  } catch {
+  }
+}
+__name(writeManifest, "writeManifest");
+function deleteStalePaths(outDir, relPaths) {
+  if (relPaths.length === 0) return;
+  const removedDirs = /* @__PURE__ */ new Set();
+  for (const rel of relPaths) {
+    const abs = resolve(outDir, rel);
+    if (existsSync(abs)) {
+      rmSync(abs, {
+        force: true
+      });
+      removedDirs.add(join(abs, ".."));
+    }
+  }
+  for (const dir of removedDirs) {
+    let current = dir;
+    while (current.startsWith(outDir) && current !== outDir) {
+      try {
+        if (readdirSync(current).length === 0) {
+          rmdirSync(current);
+          current = join(current, "..");
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+}
+__name(deleteStalePaths, "deleteStalePaths");
+export {
+  CSHARP_CODEGEN_VERSION,
+  assertValidConfig,
+  createCSharpSdkPlugin,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map