@contractkit/plugin-csharp 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,10 +1,16 @@
-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";
+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";
@@ -89,18 +95,10 @@ var CSHARP_KEYWORDS = /* @__PURE__ */ new Set([
   "volatile",
   "while"
 ]);
-var RESERVED_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "Equals",
-  "GetHashCode",
-  "GetType",
-  "ToString",
-  "EqualityContract",
-  "PrintMembers"
-]);
+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 "_";
@@ -108,7 +106,6 @@ function toCSharpPropertyName(name) {
   if (/^\d/.test(result)) result = `_${result}`;
   return result;
 }
-__name(toCSharpPropertyName, "toCSharpPropertyName");
 function toCSharpParameterName(name) {
   const words = splitWords(name);
   if (words.length === 0) return "_";
@@ -118,12 +115,10 @@ function toCSharpParameterName(name) {
   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 "_";
@@ -131,7 +126,6 @@ function toCSharpTypeName(name) {
   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 "_";
@@ -139,7 +133,6 @@ function sanitizeCSharpTypeName(name) {
   if (/^\d/.test(result)) result = `_${result}`;
   return result;
 }
-__name(sanitizeCSharpTypeName, "sanitizeCSharpTypeName");
 function toCSharpEnumMemberName(value) {
   const words = splitWords(value);
   if (words.length === 0) return "_";
@@ -147,43 +140,30 @@ function toCSharpEnumMemberName(value) {
   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}>`
-  ];
+  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 = [
@@ -205,27 +185,18 @@ function generateCSharpModels(root, opts) {
     warn: opts.warn
   };
   const bodies = [];
-  const append = /* @__PURE__ */ __name((lines) => {
+  const append = (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);
+  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");
+  return /* @__PURE__ */ new Set([...seed, ...computeModelsWithInput([...models], seed)]);
+}
 function createRenderContext(opts) {
   return {
     namespace: opts.namespace,
@@ -236,18 +207,10 @@ function createRenderContext(opts) {
     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",
-    ""
-  ];
+  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(...[...globalAliases].sort());
     lines.push("");
   }
   lines.push(...usings);
@@ -257,7 +220,6 @@ function renderFile(namespaceName, globalAliases, usings, 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);
@@ -273,7 +235,9 @@ function renderCSharpType(type, ctx, forInput = false) {
       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.`);
+        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}>`;
     }
@@ -302,25 +266,20 @@ function renderCSharpType(type, ctx, forInput = false) {
       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":
@@ -365,14 +324,13 @@ function renderScalar(name, ctx) {
     }
   }
 }
-__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) {
+function renderDefault(value, type, ctx, memberNames = /* @__PURE__ */ new Set()) {
+  const enumType = (name) => memberNames.has(name) ? `global::${ctx.namespace}.Models.${name}` : name;
   const inner = type.kind === "lazy" ? type.inner : type;
   if (typeof value === "boolean") return String(value);
   if (typeof value === "number") {
@@ -393,13 +351,13 @@ function renderDefault(value, type, ctx) {
   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)}`;
+    return `${enumType(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)}`;
+    return `${enumType(inner.name)}.${enumMemberNames(targetType.values).get(value)}`;
   }
   if (inner.kind === "scalar") {
     switch (inner.name) {
@@ -418,28 +376,26 @@ function renderDefault(value, type, ctx) {
   }
   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.`);
+    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) {
@@ -461,13 +417,13 @@ function containsInlineObject(type) {
       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.`);
+  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);
@@ -481,7 +437,6 @@ function generateModel(model, ctx) {
     ...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);
@@ -490,7 +445,6 @@ function effectiveFieldsFor(model, ctx) {
   }
   return fields;
 }
-__name(effectiveFieldsFor, "effectiveFieldsFor");
 function generateAliasModel(model, ctx) {
   const type = model.type;
   const inner = type.kind === "lazy" ? type.inner : type;
@@ -504,40 +458,47 @@ function generateAliasModel(model, ctx) {
     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,
+        fields.filter((f) => f.visibility !== "writeonly"),
+        ctx,
+        false,
+        model,
+        true
+      ),
       "",
-      ...generateRecordForModel(`${model.name}Input`, fields.filter((f) => f.visibility !== "readonly"), ctx, true, 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);
+  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.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));
+  return VALUE_TYPES.has(renderCSharpType(nonNull[0], { ...ctx, qualify: false }, false));
 }
-__name(isNullableValueType, "isNullableValueType");
 var VALUE_TYPES = /* @__PURE__ */ new Set([
   "bool",
   "byte",
@@ -558,7 +519,6 @@ function enumMemberNames(values) {
   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 = [];
@@ -575,7 +535,6 @@ function generateEnum(name, values, ctx, description, deprecated) {
   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) => {
@@ -583,14 +542,12 @@ function supertypesFor(readName, ctx, forInput) {
     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, ""));
@@ -599,25 +556,28 @@ function renderRecord(name, fields, ctx, forInput, supertypes, description, depr
     lines.push(`public sealed record ${name}${implementsClause};`);
     return lines;
   }
+  const memberNames = new Set(fields.map((field) => memberName(field, name)));
   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(...renderField(field, ctx, forInput, name, memberNames, wireCase));
   });
   lines.push("}");
   return lines;
 }
-__name(renderRecord, "renderRecord");
-function renderField(field, ctx, forInput, ownerTypeName, wireCase) {
-  const propName = safeMemberName(toCSharpPropertyName(field.name), ownerTypeName);
+function memberName(field, ownerTypeName) {
+  return safeMemberName(toCSharpPropertyName(field.name), ownerTypeName);
+}
+function renderField(field, ctx, forInput, ownerTypeName, memberNames, wireCase) {
+  const propName = memberName(field, 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;
+  let initializer = field.default !== void 0 ? renderDefault(field.default, field.type, ctx, memberNames) : 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);
+    if (inner.kind === "literal") initializer = renderDefault(inner.value, inner, ctx, memberNames);
   }
   const isRequired = !field.optional && initializer === void 0;
   const lines = [];
@@ -628,24 +588,25 @@ function renderField(field, ctx, forInput, ownerTypeName, wireCase) {
   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)
-  ];
+  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);
+      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":
@@ -654,11 +615,9 @@ function generateHoistedVariant(decl, ctx, forInput) {
       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`;
@@ -697,7 +656,6 @@ function generateTupleRecord(decl, name, ctx, forInput) {
   lines.push("}");
   return lines;
 }
-__name(generateTupleRecord, "generateTupleRecord");
 function generatePlainUnion(decl, name, ctx, forInput) {
   const converterName = `${name}Converter`;
   const members = decl.members ?? [];
@@ -751,13 +709,9 @@ function generatePlainUnion(decl, name, ctx, forInput) {
   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 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, ""));
@@ -773,7 +727,9 @@ function generateDiscriminatedUnion(decl, name, ctx, forInput) {
   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(
+    `        var tag = element.TryGetProperty(${quoteCSharpString(discriminator)}, out var tagElement) && tagElement.ValueKind == JsonValueKind.String`
+  );
   lines.push("            ? tagElement.GetString()");
   lines.push("            : null;");
   lines.push("");
@@ -802,21 +758,18 @@ function generateDiscriminatedUnion(decl, name, ctx, forInput) {
   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);
@@ -827,7 +780,6 @@ function uniqueName(name, used) {
   used.add(`${name}${n}`);
   return `${name}${n}`;
 }
-__name(uniqueName, "uniqueName");
 
 // src/codegen-client.ts
 import { classifyContentType, observableResponses, resolveModifiers } from "@contractkit/core";
@@ -847,7 +799,6 @@ function clientUsings(namespaceName) {
     `using ${namespaceName}.Runtime;`
   ];
 }
-__name(clientUsings, "clientUsings");
 function hasPublicOperations(root, includeInternal = false) {
   for (const route of root.routes) {
     for (const op of route.operations) {
@@ -856,15 +807,12 @@ function hasPublicOperations(root, includeInternal = false) {
   }
   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;
@@ -873,29 +821,22 @@ function generateCSharpClient(root, opts) {
   for (const route of root.routes) {
     for (const op of route.operations) {
       if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
-      publicOps.push({
-        route,
-        op
-      });
+      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"
-      }
+      { 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(
+        ...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) => {
@@ -918,7 +859,9 @@ function generateCSharpClient(root, opts) {
     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.`);
+      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("");
@@ -934,39 +877,23 @@ function generateCSharpClient(root, opts) {
   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
-  };
+  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
-  };
+  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
-  ] : [];
+  return shape.response ? [shape.response] : [];
 }
-__name(observableOf, "observableOf");
 function generateMethod(route, op, ctx, methodName) {
   const base = methodBase(methodName);
   const shape = responseShape(op);
@@ -974,19 +901,15 @@ function generateMethod(route, op, ctx, methodName) {
   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 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)
-  ];
+  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);
@@ -1002,7 +925,6 @@ function generateMethod(route, op, ctx, methodName) {
   lines.push("}");
   return lines;
 }
-__name(generateMethod, "generateMethod");
 function returnTypeFor(shape, base, ctx) {
   if (shape.kind !== "simple") return `${base}Response`;
   const response = shape.response;
@@ -1012,7 +934,6 @@ function returnTypeFor(shape, base, ctx) {
   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":
@@ -1023,7 +944,6 @@ function bodyCSharpType(body, ctx) {
       return renderCSharpType(body.bodyType, ctx, false);
   }
 }
-__name(bodyCSharpType, "bodyCSharpType");
 function bodyReadExpr(body, ctx) {
   switch (classifyContentType(body.contentType)) {
     case "text":
@@ -1034,23 +954,14 @@ function bodyReadExpr(body, ctx) {
       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)};`
-    ] : [];
+    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;"
-    ];
+    return body ? [...lines2, `    return new ${base}Result(${bodyReadExpr(body, ctx)}, headers);`] : [...lines2, "    return headers;"];
   }
   if (shape.kind === "multiMime") {
     const headers = shape.response.headers ?? [];
@@ -1059,10 +970,7 @@ function returnStatements(shape, base, ctx, place) {
     return lines2;
   }
   const [fallback, ...rest] = shape.responses;
-  const lines = [
-    "    switch (response.Status)",
-    "    {"
-  ];
+  const lines = ["    switch (response.Status)", "    {"];
   for (const response of rest) {
     lines.push(`        case ${response.statusCode}:`);
     lines.push("        {");
@@ -1077,7 +985,6 @@ function returnStatements(shape, base, ctx, place) {
   lines.push("    }");
   return lines;
 }
-__name(returnStatements, "returnStatements");
 function statusBranch(response, base, statusCode, ctx, place, indent) {
   const lines = [];
   const headers = response.headers ?? [];
@@ -1085,23 +992,17 @@ function statusBranch(response, 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 construct = (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])};`
-  ];
+  };
+  if (bodies.length <= 1) return [`${indent}return ${construct(bodies[0])};`];
   const [fallback, ...rest] = bodies;
-  const lines = [
-    `${indent}switch (response.ContentType)`,
-    `${indent}{`
-  ];
+  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)};`);
@@ -1111,7 +1012,6 @@ function mimeSwitch(response, base, statusCode, ctx, indent, hasHeaders) {
   lines.push(`${indent}}`);
   return lines;
 }
-__name(mimeSwitch, "mimeSwitch");
 function bodyArgument(op) {
   const body = op.request?.bodies[0];
   if (!body) return void 0;
@@ -1129,23 +1029,20 @@ function bodyArgument(op) {
       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 headerRecord = (headers, name) => {
     const parameters = headers.map((header) => {
       const reader = headerReader(header, place);
       const type = header.optional ? `${reader.type}?` : reader.type;
@@ -1154,7 +1051,7 @@ function responseDeclarations(route, op, ctx) {
     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 ?? [];
@@ -1175,18 +1072,21 @@ function responseDeclarations(route, op, ctx) {
     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(
+    ...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
-    ];
+    const bodies = response.bodies.length > 0 ? response.bodies : [void 0];
     for (const body of bodies) {
       const name = leafRecordName(response, body, statusCode);
       const parameters = [];
@@ -1199,7 +1099,6 @@ function responseDeclarations(route, op, ctx) {
   lines.push("}");
   return lines;
 }
-__name(responseDeclarations, "responseDeclarations");
 function headerReader(header, place) {
   const scalar = header.type.kind === "scalar" ? header.type.name : void 0;
   switch (scalar) {
@@ -1208,66 +1107,36 @@ function headerReader(header, place) {
     case "url":
     case "interval":
     case "unknown":
-      return {
-        type: "string",
-        read: /* @__PURE__ */ __name((raw) => raw, "read")
-      };
+      return { type: "string", read: (raw) => raw };
     case "number":
-      return {
-        type: "double",
-        read: /* @__PURE__ */ __name((raw) => `double.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "double", read: (raw) => `double.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "int":
-      return {
-        type: "long",
-        read: /* @__PURE__ */ __name((raw) => `long.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "long", read: (raw) => `long.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "bigint":
-      return {
-        type: "BigInteger",
-        read: /* @__PURE__ */ __name((raw) => `BigInteger.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "BigInteger", read: (raw) => `BigInteger.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "boolean":
-      return {
-        type: "bool",
-        read: /* @__PURE__ */ __name((raw) => `${raw} == "true"`, "read")
-      };
+      return { type: "bool", read: (raw) => `${raw} == "true"` };
     case "uuid":
-      return {
-        type: "Guid",
-        read: /* @__PURE__ */ __name((raw) => `Guid.Parse(${raw})`, "read")
-      };
+      return { type: "Guid", read: (raw) => `Guid.Parse(${raw})` };
     case "date":
-      return {
-        type: "DateOnly",
-        read: /* @__PURE__ */ __name((raw) => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "DateOnly", read: (raw) => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "time":
-      return {
-        type: "TimeOnly",
-        read: /* @__PURE__ */ __name((raw) => `TimeOnly.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "TimeOnly", read: (raw) => `TimeOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "datetime":
-      return {
-        type: "DateTimeOffset",
-        read: /* @__PURE__ */ __name((raw) => `DateTimeOffset.Parse(${raw}, CultureInfo.InvariantCulture)`, "read")
-      };
+      return { type: "DateTimeOffset", read: (raw) => `DateTimeOffset.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "duration":
-      return {
-        type: "TimeSpan",
-        read: /* @__PURE__ */ __name((raw) => `XmlConvert.ToTimeSpan(${raw})`, "read")
-      };
+      return { type: "TimeSpan", read: (raw) => `XmlConvert.ToTimeSpan(${raw})` };
     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.`);
+      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);
@@ -1276,13 +1145,10 @@ function readHeaderLines(headers, typeName, ctx, place, indent) {
     const local = toCSharpParameterName(header.name);
     return `response.Header(${name}) is { } ${local} ? ${reader.read(local)} : null`;
   });
-  const lines = [
-    `${indent}var headers = new ${typeName}(`
-  ];
+  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 = [];
@@ -1294,12 +1160,10 @@ function methodDoc(route, op, observable) {
   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) => {
@@ -1311,65 +1175,36 @@ function buildPathExpression(path, params) {
   });
   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
-        });
+        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
-      });
+      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
-        });
+        params.push({ name: "body", type: "IEnumerable<SdkPart>", optional: false });
         break;
       case "binary":
-        params.push({
-          name: "body",
-          type: "byte[]",
-          optional: false
-        });
+        params.push({ name: "body", type: "byte[]", optional: false });
         break;
       case "text":
-        params.push({
-          name: "body",
-          type: "string",
-          optional: false
-        });
+        params.push({ name: "body", type: "string", optional: false });
         break;
       default:
-        params.push({
-          name: "body",
-          type: renderCSharpType(body.bodyType, ctx, true),
-          optional: false
-        });
+        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)
-    });
+    params.push({ name: "query", type: renderParamSourceType(op.query, ctx, `${base}Query`), optional: allFieldsOptional(op.query) });
   }
   if (op.headers) {
     params.push({
@@ -1378,63 +1213,47 @@ function buildMethodParams(route, op, ctx) {
       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)
-  ];
+  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 === "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)
-  ];
+  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",
-    ""
-  ];
+  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(
+    ...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)`);
@@ -1457,7 +1276,6 @@ function generateSdkCs(namespaceName, sdkName, clients) {
   lines.push("");
   return lines.join("\n");
 }
-__name(generateSdkCs, "generateSdkCs");
 
 // src/hoist.ts
 import { collectTypeRefs, resolveEffectiveFields as resolveEffectiveFields2 } from "@contractkit/core";
@@ -1480,14 +1298,8 @@ function collectHoistedTypes(roots, opts) {
       }
     }
   }
-  return {
-    byNode: state.byNode,
-    byName: state.byName,
-    byFile: state.byFile,
-    memberships: state.memberships
-  };
+  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":
@@ -1498,14 +1310,11 @@ function walkType(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);
+        hoist(
+          type,
+          { kind: "enum", name: claimFor(path, state, false), ownerFile, needsInput: false, values: type.values, description },
+          state
+        );
       }
       return;
     case "inlineObject":
@@ -1523,14 +1332,18 @@ function walkType(type, path, ownerFile, state, atAliasRoot, description) {
     }
     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);
+      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);
@@ -1545,20 +1358,22 @@ function walkType(type, path, ownerFile, state, atAliasRoot, description) {
       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);
+  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"));
@@ -1568,15 +1383,7 @@ function hoistPlainUnion(type, path, ownerFile, state, atAliasRoot, description)
   }
   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);
+    hoist(type, { kind: "enum", name: claimFor(path, state, atAliasRoot), ownerFile, needsInput: false, nullable, values, description }, state);
     return;
   }
   const name = claimFor(path, state, atAliasRoot);
@@ -1585,23 +1392,22 @@ function hoistPlainUnion(type, path, ownerFile, state, atAliasRoot, description)
   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
-    });
+    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);
+  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 = [];
@@ -1610,17 +1416,16 @@ function hoistDiscriminatedUnion(type, path, ownerFile, state, atAliasRoot, desc
     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);
+      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
-      });
+      members.push({ typeName: member.name, tag, type: member });
     } else {
       const memberPath = `${name}${toCSharpTypeName(tag)}`;
       hoistRecord(member, fields, memberPath, ownerFile, state, void 0);
@@ -1629,11 +1434,7 @@ function hoistDiscriminatedUnion(type, path, ownerFile, state, atAliasRoot, desc
         release(name, state, atAliasRoot);
         return;
       }
-      members.push({
-        typeName: decl2.name,
-        tag,
-        type: member
-      });
+      members.push({ typeName: decl2.name, tag, type: member });
     }
   }
   if (members.length === 0) {
@@ -1656,7 +1457,6 @@ function hoistDiscriminatedUnion(type, path, ownerFile, state, atAliasRoot, desc
     state.memberships.set(member.typeName, list);
   }
 }
-__name(hoistDiscriminatedUnion, "hoistDiscriminatedUnion");
 function memberLabel(type, state) {
   switch (type.kind) {
     case "ref":
@@ -1677,23 +1477,18 @@ function memberLabel(type, state) {
     }
   }
 }
-__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;
+  if ([...refs].some((r) => state.modelsWithInput.has(r))) return true;
   return hasVisibilityField(type);
 }
-__name(typeNeedsInput, "typeNeedsInput");
 function hasVisibilityField(type) {
   switch (type.kind) {
     case "inlineObject":
@@ -1714,7 +1509,6 @@ function hasVisibilityField(type) {
       return false;
   }
 }
-__name(hasVisibilityField, "hasVisibilityField");
 function hoist(node, decl, state) {
   state.byNode.set(node, decl);
   state.byName.set(decl.name, decl);
@@ -1722,16 +1516,13 @@ function hoist(node, decl, state) {
   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);
@@ -1742,7 +1533,6 @@ function uniqueIn(base, taken) {
   taken.add(`${base}${n}`);
   return `${base}${n}`;
 }
-__name(uniqueIn, "uniqueIn");
 
 // src/runtime.ts
 function generateRuntimeCs(namespaceName) {
@@ -2117,7 +1907,6 @@ public sealed class SdkHttp : IDisposable
 }
 `;
 }
-__name(generateRuntimeCs, "generateRuntimeCs");
 
 // src/runtime-converters.ts
 function generateConvertersCs(namespaceName) {
@@ -2253,7 +2042,6 @@ public sealed class IsoTimeSpanConverter : JsonConverter<TimeSpan>
 }
 `;
 }
-__name(generateConvertersCs, "generateConvertersCs");
 
 // src/scaffold.ts
 var SCAFFOLD_VERSIONS = {
@@ -2274,7 +2062,6 @@ function generateCsproj(namespaceName, sdkName) {
 </Project>
 `;
 }
-__name(generateCsproj, "generateCsproj");
 
 // src/index.ts
 var CSHARP_CODEGEN_VERSION = "1";
@@ -2298,14 +2085,15 @@ function createCSharpSdkPlugin(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'.`);
+      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) {
@@ -2320,17 +2108,13 @@ function assertValidConfig(config) {
       throw new Error(`plugin-csharp: sdkName '${sdkName}' is a C# keyword.`);
     }
   }
-  for (const key of [
-    "includeInternal",
-    "scaffold"
-  ]) {
+  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;
@@ -2341,13 +2125,11 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
   const allModels = contractRoots.flatMap((root) => root.models);
   const modelIndex = buildModelIndex2(allModels);
   const modelsWithInput = resolveModelsWithInput(allModels, inputs.modelsWithInput);
-  const modelsWithInputArray = [
-    ...modelsWithInput
-  ].sort();
+  const modelsWithInputArray = [...modelsWithInput].sort();
   const hoisted = collectHoistedTypes(contractRoots, {
     modelIndex,
     modelsWithInput,
-    warn: /* @__PURE__ */ __name((message, file) => ctx.warn?.(message, file), "warn")
+    warn: (message, file) => ctx.warn?.(message, file)
   });
   const prevManifest = ctx.cacheEnabled ? readManifest(manifestPath) : emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
   const units = [];
@@ -2357,20 +2139,9 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
     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 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,
@@ -2385,7 +2156,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
     units.push({
       key: `models::${relPath}`,
       fingerprint,
-      render: /* @__PURE__ */ __name(() => [
+      render: () => [
         {
           relativePath: relPath,
           content: generateCSharpModels(root, {
@@ -2393,24 +2164,19 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
             modelsWithInput,
             modelIndex,
             hoisted,
-            warn: /* @__PURE__ */ __name((message) => ctx.warn?.(message, root.file), "warn")
+            warn: (message) => ctx.warn?.(message, root.file)
           })
         }
-      ], "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)
-    });
+    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 referencedModels = [...referenced].sort().map((name) => modelIndex.get(name)).filter((m) => m !== void 0);
     const fingerprint = hashFingerprint({
       kind: "client",
       v: CSHARP_CODEGEN_VERSION,
@@ -2424,7 +2190,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
     units.push({
       key: `client::${relPath}`,
       fingerprint,
-      render: /* @__PURE__ */ __name(() => [
+      render: () => [
         {
           relativePath: relPath,
           content: generateCSharpClient(root, {
@@ -2433,60 +2199,41 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
             modelIndex,
             hoisted,
             includeInternal: config.includeInternal,
-            warn: /* @__PURE__ */ __name((message) => ctx.warn?.(message, root.file), "warn")
+            warn: (message) => ctx.warn?.(message, root.file)
           })
         }
-      ], "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)
-    }
+    { 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
-    });
+    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")
+    fileExists: (relPath) => existsSync(resolve(outDir, relPath))
   });
   deleteStalePaths(outDir, result.deletedPaths);
   for (const { relativePath, content, ifAbsent } of result.filesToWrite) {
-    ctx.emitFile(resolve(outDir, relativePath), content, ifAbsent ? {
-      ifAbsent: true
-    } : void 0);
+    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) => {
+  const addParamSource = (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 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) {
@@ -2501,7 +2248,6 @@ function referencedOpModels(root, modelIndex) {
   }
   return collectTransitiveModelRefs(seeds, modelIndex);
 }
-__name(referencedOpModels, "referencedOpModels");
 function referencedModelNames(root) {
   const refs = /* @__PURE__ */ new Set();
   for (const model of root.models) {
@@ -2511,7 +2257,6 @@ function referencedModelNames(root) {
   }
   return refs;
 }
-__name(referencedModelNames, "referencedModelNames");
 function readManifest(manifestPath) {
   if (!existsSync(manifestPath)) return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
   try {
@@ -2520,26 +2265,20 @@ function readManifest(manifestPath) {
     return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
   }
 }
-__name(readManifest, "readManifest");
 function writeManifest(manifestPath, manifest) {
   try {
-    mkdirSync(dirname(manifestPath), {
-      recursive: true
-    });
+    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
-      });
+      rmSync(abs, { force: true });
       removedDirs.add(join(abs, ".."));
     }
   }
@@ -2559,7 +2298,6 @@ function deleteStalePaths(outDir, relPaths) {
     }
   }
 }
-__name(deleteStalePaths, "deleteStalePaths");
 export {
   CSHARP_CODEGEN_VERSION,
   assertValidConfig,