@contractkit/plugin-csharp 0.1.6 → 0.2.0

package/dist/runtime-converters.d.ts

@@ -10,6 +10,12 @@
  * own, so it serializes correctly under any options. These three are options-level, which is why
  * anything serializing a generated model by hand has to pass `SdkJson.Options`.
  */
-/** Generate `Runtime/Converters.cs` for `namespaceName`. Content depends on nothing but the namespace. */
-export declare function generateConvertersCs(namespaceName: string): string;
+import type { CSharpDateTypes } from './codegen-models.js';
+/**
+ * Generate `Runtime/Converters.cs`.
+ *
+ * Which date converter is registered follows `dateTypes`, since that decides the CLR type a `date`
+ * arrives as and serialization dispatches on nothing else.
+ */
+export declare function generateConvertersCs(namespaceName: string, dateTypes?: CSharpDateTypes): string;
 //# sourceMappingURL=runtime-converters.d.ts.map

package/dist/runtime-converters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-converters.d.ts","sourceRoot":"","sources":["../src/runtime-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0GAA0G;AAC1G,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAoIlE"}
+{"version":3,"file":"runtime-converters.d.ts","sourceRoot":"","sources":["../src/runtime-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAmF3D;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,GAAE,eAA4B,GAAG,MAAM,CA+K3G"}

package/dist/runtime-polyfills.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The `Runtime/Polyfills.cs` file: what .NET Standard 2.0 does not carry.
+ *
+ * Emitted only when the SDK targets netstandard2.0, and compiled only on that leg of a multi-target
+ * build, so a project on net10.0 alone never sees any of it. Two groups, for two different reasons:
+ *
+ * - The attributes the C# compiler looks for before it will accept an `init` accessor, a `required`
+ *   member, or the records built on them. The compiler asks for these by full name and does not care
+ *   which assembly declares them, so `internal` copies are enough and cannot collide with a
+ *   consumer's own.
+ * - `DateOnly` and `TimeOnly`, which arrived in .NET 6. These are declared in the SDK's own runtime
+ *   namespace rather than in `System`, because a consumer is free to reference a package that
+ *   backfills `System.DateOnly` for their own code and two declarations of one full name are
+ *   ambiguous wherever they meet. Generated files import the runtime namespace, so `DateOnly`
+ *   resolves to the polyfill here on netstandard2.0 and to the framework's type on net10.0 without a
+ *   line of conditional code in a model.
+ */
+/** Generate `Runtime/Polyfills.cs` for `namespaceName`. Content depends on nothing but the namespace. */
+export declare function generatePolyfillsCs(namespaceName: string): string;
+//# sourceMappingURL=runtime-polyfills.d.ts.map

package/dist/runtime-polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-polyfills.d.ts","sourceRoot":"","sources":["../src/runtime-polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,yGAAyG;AACzG,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CA4UjE"}

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0GAA0G;AAC1G,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAmX/D"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0GAA0G;AAC1G,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CA2Y/D"}

package/dist/scaffold.d.ts

@@ -3,24 +3,38 @@
  *
  * Emitted with `ifAbsent`, so it is created once and then belongs to the user: a project will add a
  * package id, a version, an analyzer set and a signing key of its own, and regenerating over that
- * would throw the work away. Generated C# sources are rewritten every run; this is not.
+ * would throw the work away. Generated C# sources are rewritten every run; this is not. A project
+ * created before a scaffold change therefore keeps its own file — the README carries the snippet to
+ * paste when the change is one the project wants.
  */
+/** The frameworks a generated SDK can be built for. */
+export type CSharpTargetFramework = 'netstandard2.0' | 'net10.0';
 /**
  * What the scaffold pins. One object so a bump is one edit.
  *
- * There is deliberately no dependency list to go with it: the generated SDK uses only
+ * A single-framework SDK on `net10.0` has no dependency list to go with it: it uses only
  * `System.Text.Json` and `HttpClient` from the shared framework, so `dotnet build` restores with no
- * NuGet feed reachable at all.
+ * NuGet feed reachable at all. `netstandard2.0` is the exception — `System.Text.Json` is a package
+ * there, and one that brings `System.Memory` and `System.Threading.Tasks.Extensions` with it.
  */
 export declare const SCAFFOLD_VERSIONS: {
     readonly targetFramework: "net10.0";
+    readonly systemTextJson: "10.0.12";
+    /** The oldest language version the generated sources compile under: records, `required`, primary constructors. */
+    readonly netstandardLangVersion: "12.0";
 };
+/** The framework the scaffold targets when the config names none. */
+export declare const DEFAULT_TARGET_FRAMEWORKS: readonly CSharpTargetFramework[];
 /**
  * Generate `<SdkName>.csproj`.
  *
  * `ImplicitUsings` is off because generated files carry an explicit `using` block of their own, and
  * leaving it on would make the output depend on the SDK's implicit set rather than on what the
  * generator wrote.
+ *
+ * Only a build that includes `netstandard2.0` pins `LangVersion` or references a package. On its own,
+ * `net10.0` defaults to the newest language version the SDK knows, and pinning one here would hold a
+ * project back rather than help it.
  */
-export declare function generateCsproj(namespaceName: string, sdkName: string): string;
+export declare function generateCsproj(namespaceName: string, sdkName: string, targetFrameworks?: readonly CSharpTargetFramework[]): string;
 //# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;CAEpB,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAc7E"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,SAAS,CAAC;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;IAG1B,kHAAkH;;CAE5G,CAAC;AAEX,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,EAAE,SAAS,qBAAqB,EAAwC,CAAC;AAE/G;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC1B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,gBAAgB,GAAE,SAAS,qBAAqB,EAA8B,GAC/E,MAAM,CAiCR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-csharp",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "ContractKit built-in plugin: C#/.NET SDK client generation (System.Text.Json + HttpClient, no NuGet dependencies)",
   "license": "MIT",
   "author": {

package/src/codegen-client.ts

@@ -10,7 +10,7 @@ import type {
 } from '@contractkit/core';
 import { classifyContentType, observableResponses, resolveModifiers } from '@contractkit/core';
 import type { HoistResult } from './hoist.js';
-import { createRenderContext, renderCSharpType, renderFile, type RenderContext } from './codegen-models.js';
+import { createRenderContext, renderCSharpType, renderFile, type CSharpDateTypes, type RenderContext } from './codegen-models.js';
 import {
     bindCSharpParameterNames,
     deriveCSharpFileBase,
@@ -24,6 +24,8 @@ import {
 
 export interface CSharpClientCodegenOptions {
     namespace: string;
+    /** Which C# type a `date` maps to (default: `dateonly`). Applies to response headers too. */
+    dateTypes?: CSharpDateTypes;
     modelsWithInput: ReadonlySet<string>;
     modelIndex?: ReadonlyMap<string, ModelNode>;
     hoisted?: HoistResult;
@@ -213,7 +215,7 @@ function generateMethod(route: OpRouteNode, op: OpOperationNode, ctx: RenderCont
     lines.push(`public async ${returnType === 'void' ? 'Task' : `Task<${returnType}>`} ${methodName}(${signature})`);
     lines.push('{');
 
-    const callArgs: string[] = [`HttpMethod.${httpMethodConstant(op.method)}`, buildPathExpression(route.path, route.params, pathBindings)];
+    const callArgs: string[] = [httpMethodExpression(op.method), buildPathExpression(route.path, route.params, pathBindings)];
     if (op.query) callArgs.push('query: http.Params(query)');
     if (op.headers) callArgs.push('headers: http.Params(customHeaders)');
     const content = bodyArgument(op);
@@ -435,7 +437,7 @@ function responseDeclarations(route: OpRouteNode, op: OpOperationNode, ctx: Rend
     const headerRecord = (headers: OpResponseHeaderNode[], name: string): void => {
         const parameters = headers
             .map(header => {
-                const reader = headerReader(header, place);
+                const reader = headerReader(header, place, ctx.dateTypes);
                 const type = header.optional ? `${reader.type}?` : reader.type;
                 return `${type} ${safeMemberName(toCSharpPropertyName(header.name), name)}`;
             })
@@ -505,7 +507,7 @@ function responseDeclarations(route: OpRouteNode, op: OpOperationNode, ctx: Rend
  *
  * @throws {Error} When the header's declared type cannot be read from an HTTP header.
  */
-function headerReader(header: OpResponseHeaderNode, place: string): { type: string; read: (raw: string) => string } {
+function headerReader(header: OpResponseHeaderNode, place: string, dateTypes: CSharpDateTypes): { type: string; read: (raw: string) => string } {
     const scalar = header.type.kind === 'scalar' ? header.type.name : undefined;
     switch (scalar) {
         case 'string':
@@ -525,7 +527,9 @@ function headerReader(header: OpResponseHeaderNode, place: string): { type: stri
         case 'uuid':
             return { type: 'Guid', read: raw => `Guid.Parse(${raw})` };
         case 'date':
-            return { type: 'DateOnly', read: raw => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
+            return dateTypes === 'datetime'
+                ? { type: 'DateTime', read: raw => `DateTime.Parse(${raw}, CultureInfo.InvariantCulture)` }
+                : { type: 'DateOnly', read: raw => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
         case 'time':
             return { type: 'TimeOnly', read: raw => `TimeOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
         case 'datetime':
@@ -564,7 +568,7 @@ function readHeaderLines(
         bound,
     );
     const args = headers.map(header => {
-        const reader = headerReader(header, place);
+        const reader = headerReader(header, place, ctx.dateTypes);
         const name = quoteCSharpString(header.name);
         // A required header the service omitted is a broken contract, not a null the caller has to
         // handle; an optional one simply stays absent.
@@ -590,10 +594,16 @@ function methodDoc(route: OpRouteNode, op: OpOperationNode, observable: OpRespon
     return lines;
 }
 
-/** `System.Net.Http.HttpMethod` spells its verbs as `HttpMethod.Get`, `HttpMethod.Delete`, and so on. */
-function httpMethodConstant(method: string): string {
+/**
+ * How a verb is spelled at the call site.
+ *
+ * `System.Net.Http.HttpMethod` carries a static for every verb the grammar allows except PATCH,
+ * which netstandard2.0 does not have, so PATCH goes through the runtime's own `SdkHttp.Patch`.
+ */
+function httpMethodExpression(method: string): string {
     const lower = method.toLowerCase();
-    return lower.charAt(0).toUpperCase() + lower.slice(1);
+    if (lower === 'patch') return 'SdkHttp.Patch';
+    return `HttpMethod.${lower.charAt(0).toUpperCase()}${lower.slice(1)}`;
 }
 
 // ─── Path building ─────────────────────────────────────────────────────────

package/src/codegen-models.ts

@@ -5,9 +5,24 @@ import { quoteCSharpString, safeMemberName, toCSharpEnumMemberName, toCSharpProp
 
 // ─── Public entry point ────────────────────────────────────────────────────
 
+/**
+ * Which C# type a contract's `date` maps to.
+ *
+ * `dateonly` is `DateOnly`, the type the framework added for exactly this. `datetime` is `DateTime`
+ * at midnight with an unspecified kind, for a UI stack whose date controls bind to that and nothing
+ * else — XAML's `DatePicker` among them. The choice applies to every framework the SDK is built for,
+ * so the public surface never differs between them.
+ *
+ * `time` is `TimeOnly` either way: `duration` already maps to `TimeSpan`, and serialization dispatches
+ * on the CLR type, so a `time` carried as a `TimeSpan` would go out as `PT9H30M`.
+ */
+export type CSharpDateTypes = 'dateonly' | 'datetime';
+
 export interface CSharpModelCodegenOptions {
     /** Root namespace the SDK is generated into. Models land in `<namespace>.Models`. */
     namespace: string;
+    /** Which C# type a `date` maps to (default: `dateonly`). */
+    dateTypes?: CSharpDateTypes;
     /** Model names that have a distinct `Input` variant, including ones declared in other files. */
     modelsWithInput?: ReadonlySet<string>;
     /**
@@ -26,6 +41,11 @@ export interface CSharpModelCodegenOptions {
  * There is no import tracker, unlike the Kotlin plugin: every type the models can name is in the
  * base class library, so the set is fixed. An unused `using` is not a compiler warning, and pinning
  * the block keeps the output stable and free of the ordering churn a tracker would produce.
+ *
+ * The SDK's own runtime namespace is added to this list per file, because it needs the namespace
+ * name. It is where `DateOnly` and `TimeOnly` come from on a framework too old to have them: the
+ * polyfills are declared there and nowhere else, so the same short spelling resolves to the
+ * framework's type wherever the framework has one, with no conditional code in a model.
  */
 const MODEL_USINGS = [
     'using System;',
@@ -50,6 +70,7 @@ export function generateCSharpModels(root: ContractRootNode, opts: CSharpModelCo
 
     const ctx: RenderContext = {
         namespace: opts.namespace,
+        dateTypes: opts.dateTypes ?? 'dateonly',
         modelsWithInput,
         modelIndex,
         hoisted: opts.hoisted,
@@ -67,7 +88,7 @@ export function generateCSharpModels(root: ContractRootNode, opts: CSharpModelCo
     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, `using ${opts.namespace}.Runtime;`], bodies);
 }
 
 /**
@@ -86,6 +107,7 @@ export function resolveModelsWithInput(models: readonly ModelNode[], external: R
 
 interface RenderContext {
     namespace: string;
+    dateTypes: CSharpDateTypes;
     modelsWithInput: ReadonlySet<string>;
     modelIndex: ReadonlyMap<string, ModelNode>;
     hoisted?: HoistResult;
@@ -100,6 +122,7 @@ interface RenderContext {
 export function createRenderContext(opts: CSharpModelCodegenOptions & { modelsWithInput: ReadonlySet<string> }): RenderContext {
     return {
         namespace: opts.namespace,
+        dateTypes: opts.dateTypes ?? 'dateonly',
         modelsWithInput: opts.modelsWithInput,
         modelIndex: opts.modelIndex ?? new Map(),
         hoisted: opts.hoisted,
@@ -238,8 +261,9 @@ export function renderScalar(name: ScalarTypeNode['name'], ctx: RenderContext):
             return qualify('decimal', 'System.Decimal', ctx);
         case 'boolean':
             return qualify('bool', 'System.Boolean', ctx);
+        // Both carried as the wire form by a converter: `yyyy-MM-dd` and `HH:mm:ss`.
         case 'date':
-            return qualify('DateOnly', 'System.DateOnly', ctx);
+            return ctx.dateTypes === 'datetime' ? qualify('DateTime', 'System.DateTime', ctx) : qualify('DateOnly', 'System.DateOnly', ctx);
         case 'time':
             return qualify('TimeOnly', 'System.TimeOnly', ctx);
         case 'datetime':
@@ -541,9 +565,35 @@ function addAlias(name: string, type: ContractTypeNode, ctx: RenderContext, forI
                 `'${name}' is generated as '${aliased}'. Declare the nullability at each use site instead.`,
         );
     }
+    const polyfilled = polyfillAliasTarget(aliased, ctx);
+    if (polyfilled) {
+        // A using alias has to name its target in full, which is the one place the short spelling
+        // cannot do the work: `System.DateOnly` does not exist on netstandard2.0, so the alias is
+        // written per framework rather than resolved by the file's imports.
+        ctx.globalAliases.push(`#if NETSTANDARD2_0\nglobal using ${name} = ${polyfilled};\n#else\nglobal using ${name} = ${aliased};\n#endif`);
+        return;
+    }
+
     ctx.globalAliases.push(`global using ${name} = ${aliased};`);
 }
 
+/** The framework types the SDK carries a polyfill for, by their fully-qualified spelling. */
+const POLYFILLED_TYPES: readonly string[] = ['System.DateOnly', 'System.TimeOnly'];
+
+/**
+ * The netstandard2.0 spelling of an alias target, or undefined when it names no polyfilled type.
+ *
+ * Substring replacement rather than a lookup, because the target may be a container: `array(date)`
+ * aliases to `System.Collections.Generic.List<System.DateOnly>`.
+ */
+function polyfillAliasTarget(target: string, ctx: RenderContext): string | undefined {
+    let out = target;
+    for (const full of POLYFILLED_TYPES) {
+        out = out.split(full).join(`${ctx.namespace}.Runtime.${full.slice('System.'.length)}`);
+    }
+    return out === target ? undefined : out;
+}
+
 /** Whether `type` renders as a nullable *value* type, which is a legal alias target. */
 function isNullableValueType(type: ContractTypeNode, ctx: RenderContext): boolean {
     const inner = type.kind === 'lazy' ? type.inner : type;
@@ -563,6 +613,7 @@ const VALUE_TYPES: ReadonlySet<string> = new Set([
     'BigInteger',
     'DateOnly',
     'TimeOnly',
+    'DateTime',
     'DateTimeOffset',
     'TimeSpan',
     'Guid',

package/src/index.ts

@@ -22,13 +22,14 @@ import {
     runIncrementalCodegen,
     serializeIncrementalManifest,
 } from '@contractkit/core';
-import { generateCSharpModels, resolveModelsWithInput } from './codegen-models.js';
+import { generateCSharpModels, resolveModelsWithInput, type CSharpDateTypes } from './codegen-models.js';
 import { deriveClientClassName, deriveClientPropertyName, generateCSharpClient, hasPublicOperations } from './codegen-client.js';
 import { generateSdkCs, type SdkAggregatorClient } from './codegen-sdk.js';
 import { collectHoistedTypes } from './hoist.js';
 import { generateRuntimeCs } from './runtime.js';
 import { generateConvertersCs } from './runtime-converters.js';
-import { generateCsproj } from './scaffold.js';
+import { generatePolyfillsCs } from './runtime-polyfills.js';
+import { DEFAULT_TARGET_FRAMEWORKS, generateCsproj, type CSharpTargetFramework } from './scaffold.js';
 import { CSHARP_KEYWORDS, deriveCSharpFileBase } from './naming.js';
 
 export interface CSharpSdkPluginConfig {
@@ -45,18 +46,41 @@ export interface CSharpSdkPluginConfig {
     includeInternal?: boolean;
     /** Emit `<SdkName>.csproj` once, as a user-owned file. Never overwritten. */
     scaffold?: boolean;
+    /**
+     * The frameworks the SDK is built for (default: `["net10.0"]`).
+     *
+     * Naming `netstandard2.0` is what makes the output usable from a UWP or .NET Framework project:
+     * `Runtime/Polyfills.cs` is emitted alongside the rest, and a scaffolded `.csproj` multi-targets
+     * and references `System.Text.Json` on that leg. Convention puts the oldest framework first.
+     */
+    targetFrameworks?: CSharpTargetFramework[];
+    /**
+     * Which C# type a contract's `date` maps to (default: `"dateonly"`).
+     *
+     * `"datetime"` maps it to `DateTime` at midnight with an unspecified kind, for a UI stack whose
+     * date controls bind to that and nothing else — XAML's `DatePicker` among them. It applies to
+     * every framework the SDK is built for, so the public surface never differs between them.
+     *
+     * `time` is `TimeOnly` either way, because `duration` already maps to `TimeSpan` and a `time`
+     * carried as one would go out as `PT9H30M`.
+     */
+    dateTypes?: CSharpDateTypes;
 }
 
 /**
  * Bumped when the C# codegen output shape changes in a way that should invalidate every per-file
  * fingerprint, so a plugin upgrade forces full regeneration even when no `.ck` file has changed.
  */
-export const CSHARP_CODEGEN_VERSION = '1';
+export const CSHARP_CODEGEN_VERSION = '2';
+
+export type { CSharpTargetFramework } from './scaffold.js';
+export type { CSharpDateTypes } from './codegen-models.js';
 
 const CACHE_MANIFEST_FILENAME = 'csharp-manifest.json';
 const DEFAULT_BASE_DIR = 'csharp-sdk';
 const DEFAULT_NAMESPACE = 'ContractKit.Sdk';
 const DEFAULT_SDK_NAME = 'Sdk';
+const DEFAULT_DATE_TYPES: CSharpDateTypes = 'dateonly';
 
 const plugin: ContractKitPlugin = {
     name: 'csharp-sdk',
@@ -111,6 +135,35 @@ export function assertValidConfig(config: CSharpSdkPluginConfig): void {
             throw new Error(`plugin-csharp: ${key} must be a boolean — got ${JSON.stringify(value)}.`);
         }
     }
+    assertValidTargetFrameworks(config.targetFrameworks);
+    if (config.dateTypes !== undefined && !DATE_TYPES.includes(config.dateTypes)) {
+        throw new Error(`plugin-csharp: dateTypes ${JSON.stringify(config.dateTypes)} is not supported — expected one of ${DATE_TYPES.join(', ')}.`);
+    }
+}
+
+/** The C# types a contract's `date` can map to. */
+const DATE_TYPES: readonly CSharpDateTypes[] = ['dateonly', 'datetime'];
+
+/** Every framework the scaffold knows how to write a project file for. */
+const TARGET_FRAMEWORKS: readonly CSharpTargetFramework[] = ['netstandard2.0', 'net10.0'];
+
+function assertValidTargetFrameworks(frameworks: CSharpSdkPluginConfig['targetFrameworks']): void {
+    if (frameworks === undefined) return;
+    if (!Array.isArray(frameworks) || frameworks.length === 0) {
+        throw new Error(`plugin-csharp: targetFrameworks must be a non-empty array — got ${JSON.stringify(frameworks)}.`);
+    }
+    const seen = new Set<string>();
+    for (const framework of frameworks) {
+        if (typeof framework !== 'string' || !TARGET_FRAMEWORKS.includes(framework)) {
+            throw new Error(
+                `plugin-csharp: targetFrameworks entry ${JSON.stringify(framework)} is not supported — expected one of ${TARGET_FRAMEWORKS.join(', ')}.`,
+            );
+        }
+        if (seen.has(framework)) {
+            throw new Error(`plugin-csharp: targetFrameworks lists '${framework}' twice.`);
+        }
+        seen.add(framework);
+    }
 }
 
 /**
@@ -131,6 +184,8 @@ async function runCSharpCodegen(
     const { contractRoots } = inputs;
     const namespaceName = config.namespace ?? DEFAULT_NAMESPACE;
     const sdkName = config.sdkName ?? DEFAULT_SDK_NAME;
+    const targetFrameworks = config.targetFrameworks ?? DEFAULT_TARGET_FRAMEWORKS;
+    const dateTypes = config.dateTypes ?? DEFAULT_DATE_TYPES;
     const outDir = resolve(rootDir, config.baseDir ?? DEFAULT_BASE_DIR);
     const manifestPath = resolve(ctx.cacheDir, CACHE_MANIFEST_FILENAME);
 
@@ -182,6 +237,7 @@ async function runCSharpCodegen(
             v: CSHARP_CODEGEN_VERSION,
             relPath,
             namespace: namespaceName,
+            dateTypes,
             root,
             externalBases,
             modelsWithInput: relevantInputModels,
@@ -197,6 +253,7 @@ async function runCSharpCodegen(
                     relativePath: relPath,
                     content: generateCSharpModels(root, {
                         namespace: namespaceName,
+                        dateTypes,
                         modelsWithInput,
                         modelIndex,
                         hoisted,
@@ -227,6 +284,7 @@ async function runCSharpCodegen(
             v: CSHARP_CODEGEN_VERSION,
             relPath,
             namespace: namespaceName,
+            dateTypes,
             root,
             referencedModels,
             modelsWithInput: relevantInputModels,
@@ -241,6 +299,7 @@ async function runCSharpCodegen(
                     relativePath: relPath,
                     content: generateCSharpClient(root, {
                         namespace: namespaceName,
+                        dateTypes,
                         modelsWithInput,
                         modelIndex,
                         hoisted,
@@ -255,15 +314,25 @@ async function runCSharpCodegen(
     // The runtime is a constant, and the aggregator depends only on the list of public clients.
     // Both are small enough that rewriting them every run beats a cache entry.
     const globalFiles: IncrementalOutputFile[] = [
-        { relativePath: 'Runtime/Converters.cs', content: generateConvertersCs(namespaceName) },
+        { relativePath: 'Runtime/Converters.cs', content: generateConvertersCs(namespaceName, dateTypes) },
         { relativePath: 'Runtime/SdkRuntime.cs', content: generateRuntimeCs(namespaceName) },
         { relativePath: `${sdkName}.cs`, content: generateSdkCs(namespaceName, sdkName, clients) },
     ];
 
+    // Only a build that includes netstandard2.0 has anything to fill in. Dropping the framework from
+    // the config drops the file, which the incremental pass then deletes as an orphan.
+    if (targetFrameworks.includes('netstandard2.0')) {
+        globalFiles.push({ relativePath: 'Runtime/Polyfills.cs', content: generatePolyfillsCs(namespaceName) });
+    }
+
     // `ifAbsent` marks this user-owned: written once, never overwritten, and never removed as an
     // orphan when the generated tree changes around it.
     if (config.scaffold) {
-        globalFiles.push({ relativePath: `${sdkName}.csproj`, content: generateCsproj(namespaceName, sdkName), ifAbsent: true });
+        globalFiles.push({
+            relativePath: `${sdkName}.csproj`,
+            content: generateCsproj(namespaceName, sdkName, targetFrameworks),
+            ifAbsent: true,
+        });
     }
 
     const result = runIncrementalCodegen({

package/src/runtime-converters.ts

@@ -11,8 +11,98 @@
  * anything serializing a generated model by hand has to pass `SdkJson.Options`.
  */
 
-/** Generate `Runtime/Converters.cs` for `namespaceName`. Content depends on nothing but the namespace. */
-export function generateConvertersCs(namespaceName: string): string {
+import type { CSharpDateTypes } from './codegen-models.js';
+
+/**
+ * A `date` carried as a `DateTime`, under `dateTypes: "datetime"`.
+ *
+ * Registered on every framework, not only the old one: the framework's own `DateTime` handling writes
+ * a full round-trip timestamp, which is not what the contract says a `date` looks like. Safe to make
+ * options-level because `datetime` maps to `DateTimeOffset`, so nothing else in a generated model is
+ * a `DateTime`.
+ */
+const ISO_DATE_CONVERTER = `/// <summary>
+/// A calendar date, as <c>yyyy-MM-dd</c>, carried in the date part of a <c>DateTime</c>.
+/// </summary>
+/// <remarks>
+/// The time is midnight and the kind is unspecified: a contract's <c>date</c> names neither, and
+/// pretending to either would put a zone offset on the wire.
+/// </remarks>
+public sealed class IsoDateConverter : JsonConverter<DateTime>
+{
+    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a date string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a date string.");
+        if (DateTime.TryParseExact(text, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var exact))
+        {
+            return exact;
+        }
+
+        // A service sending more than the contract promised is read for the part it promised.
+        if (DateTime.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed))
+        {
+            return parsed.Date;
+        }
+
+        throw new JsonException($"'{text}' is not a date.");
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
+    }
+}
+
+`;
+
+/** A `date` carried as the polyfilled `DateOnly`, under the default `dateTypes: "dateonly"`. */
+const DATE_ONLY_CONVERTER = `
+/// <summary>
+/// A calendar date, as <c>yyyy-MM-dd</c>.
+/// </summary>
+/// <remarks>
+/// Compiled only where <c>DateOnly</c> is the SDK's own polyfill. The wire form is the one the
+/// framework's converter writes on net10.0, so a service reads a body from either leg of the build.
+/// </remarks>
+public sealed class DateOnlyConverter : JsonConverter<DateOnly>
+{
+    public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a date string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a date string.");
+        if (!DateOnly.TryParse(text, CultureInfo.InvariantCulture, out var value))
+        {
+            throw new JsonException($"'{text}' is not a date.");
+        }
+
+        return value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}
+`;
+
+/**
+ * Generate `Runtime/Converters.cs`.
+ *
+ * Which date converter is registered follows `dateTypes`, since that decides the CLR type a `date`
+ * arrives as and serialization dispatches on nothing else.
+ */
+export function generateConvertersCs(namespaceName: string, dateTypes: CSharpDateTypes = 'dateonly'): string {
+    const asDateTime = dateTypes === 'datetime';
+
     return `// <auto-generated/>
 // Generated by @contractkit/plugin-csharp. Do not edit manually.
 #nullable enable
@@ -46,6 +136,11 @@ public static class SdkJson
         options.Converters.Add(new BigIntegerConverter());
         options.Converters.Add(new DecimalStringConverter());
         options.Converters.Add(new IsoTimeSpanConverter());
+${asDateTime ? '        options.Converters.Add(new IsoDateConverter());\n' : ''}#if NETSTANDARD2_0
+        // These are the SDK's own types on this framework, so System.Text.Json has no built-in
+        // converter for them. On net10.0 the framework handles them and these are not compiled.
+${asDateTime ? '' : '        options.Converters.Add(new DateOnlyConverter());\n'}        options.Converters.Add(new TimeOnlyConverter());
+#endif
         return options;
     }
 }
@@ -70,8 +165,9 @@ public sealed class BigIntegerConverter : JsonConverter<BigInteger>
         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);
+            // which is the whole reason the contract called it a bigint. Copied to an array rather
+            // than handed to the span overload of GetString, which netstandard2.0 does not have.
+            var raw = Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray());
             return BigInteger.Parse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture);
         }
 
@@ -143,5 +239,40 @@ public sealed class IsoTimeSpanConverter : JsonConverter<TimeSpan>
         writer.WriteStringValue(XmlConvert.ToString(value));
     }
 }
+
+${asDateTime ? ISO_DATE_CONVERTER : ''}#if NETSTANDARD2_0
+${asDateTime ? '' : DATE_ONLY_CONVERTER}
+/// <summary>
+/// A time of day, as <c>HH:mm:ss</c>, with a seven-digit fraction when there is one.
+/// </summary>
+/// <remarks>
+/// Compiled only where <c>TimeOnly</c> is the SDK's own polyfill, and writing what the framework's
+/// own converter writes on net10.0, so a service reads a body from either leg of the build.
+/// </remarks>
+public sealed class TimeOnlyConverter : JsonConverter<TimeOnly>
+{
+    public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a time-of-day string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a time-of-day string.");
+        if (!TimeOnly.TryParse(text, CultureInfo.InvariantCulture, out var value))
+        {
+            throw new JsonException($"'{text}' is not a time of day.");
+        }
+
+        return value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}
+
+#endif
 `;
 }