@contractkit/plugin-csharp 0.1.6 → 0.2.0

package/src/runtime-polyfills.ts

@@ -0,0 +1,352 @@
+/**
+ * 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 function generatePolyfillsCs(namespaceName: string): string {
+    return `// <auto-generated/>
+// Generated by @contractkit/plugin-csharp. Do not edit manually.
+#nullable enable
+
+#if NETSTANDARD2_0
+
+using System;
+using System.Globalization;
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// The marker the compiler requires before it will emit an <c>init</c> accessor.
+    /// </summary>
+    internal static class IsExternalInit
+    {
+    }
+
+    /// <summary>
+    /// Marks a member whose initialization the compiler requires at every construction site.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+    internal sealed class RequiredMemberAttribute : Attribute
+    {
+    }
+
+    /// <summary>
+    /// Names a compiler feature a member depends on, so a compiler that does not have it refuses the
+    /// member rather than misreading it.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
+    internal sealed class CompilerFeatureRequiredAttribute : Attribute
+    {
+        public CompilerFeatureRequiredAttribute(string featureName)
+        {
+            FeatureName = featureName;
+        }
+
+        public string FeatureName { get; }
+
+        public bool IsOptional { get; init; }
+
+        public const string RefStructs = nameof(RefStructs);
+
+        public const string RequiredMembers = nameof(RequiredMembers);
+    }
+}
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Marks a constructor that sets every required member itself.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
+    internal sealed class SetsRequiredMembersAttribute : Attribute
+    {
+    }
+}
+
+namespace ${namespaceName}.Runtime
+{
+    /// <summary>
+    /// A calendar date with no time and no offset. Stands in for <c>System.DateOnly</c>.
+    /// </summary>
+    /// <remarks>
+    /// Carries what a generated SDK and the code around it need: construction, ordering, conversion
+    /// to and from <see cref="DateTime"/>, and the <c>yyyy-MM-dd</c> form a contract's <c>date</c>
+    /// travels as. Not a complete reimplementation of the framework type.
+    /// </remarks>
+    public readonly struct DateOnly : IEquatable<DateOnly>, IComparable<DateOnly>, IComparable
+    {
+        private readonly DateTime _value;
+
+        public DateOnly(int year, int month, int day)
+        {
+            _value = new DateTime(year, month, day);
+        }
+
+        private DateOnly(DateTime value)
+        {
+            _value = value.Date;
+        }
+
+        public static DateOnly MinValue => new DateOnly(DateTime.MinValue);
+
+        public static DateOnly MaxValue => new DateOnly(DateTime.MaxValue);
+
+        public int Year => _value.Year;
+
+        public int Month => _value.Month;
+
+        public int Day => _value.Day;
+
+        public int DayOfYear => _value.DayOfYear;
+
+        public DayOfWeek DayOfWeek => _value.DayOfWeek;
+
+        /// <summary>The date part of <paramref name="value"/>, dropping its time and kind.</summary>
+        public static DateOnly FromDateTime(DateTime value) => new DateOnly(value);
+
+        /// <summary>This date at midnight, with an unspecified kind. What a XAML date picker binds to.</summary>
+        public DateTime ToDateTime() => _value;
+
+        /// <summary>This date at <paramref name="time"/>, with an unspecified kind.</summary>
+        public DateTime ToDateTime(TimeOnly time) => _value.Add(time.ToTimeSpan());
+
+        public DateOnly AddDays(int value) => new DateOnly(_value.AddDays(value));
+
+        public DateOnly AddMonths(int value) => new DateOnly(_value.AddMonths(value));
+
+        public DateOnly AddYears(int value) => new DateOnly(_value.AddYears(value));
+
+        public static DateOnly Parse(string s) => Parse(s, CultureInfo.InvariantCulture);
+
+        /// <exception cref="FormatException">When <paramref name="s"/> is not a date.</exception>
+        public static DateOnly Parse(string s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+            {
+                throw new FormatException("'" + s + "' is not a date.");
+            }
+
+            return result;
+        }
+
+        public static bool TryParse(string? s, out DateOnly result) => TryParse(s, CultureInfo.InvariantCulture, out result);
+
+        /// <remarks>
+        /// The wire form is tried first and exactly; anything else the culture reads as a date is
+        /// then taken by its date part, which is what the framework type does too.
+        /// </remarks>
+        public static bool TryParse(string? s, IFormatProvider? provider, out DateOnly result)
+        {
+            var culture = provider ?? CultureInfo.InvariantCulture;
+            if (DateTime.TryParseExact(s, "yyyy-MM-dd", culture, DateTimeStyles.None, out var exact))
+            {
+                result = new DateOnly(exact);
+                return true;
+            }
+
+            if (DateTime.TryParse(s, culture, DateTimeStyles.None, out var parsed))
+            {
+                result = new DateOnly(parsed);
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
+        /// <summary>The ISO 8601 form, <c>yyyy-MM-dd</c>. Also how the date travels on the wire.</summary>
+        public override string ToString() => _value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
+
+        public string ToString(string? format) => _value.ToString(format, CultureInfo.InvariantCulture);
+
+        public string ToString(string? format, IFormatProvider? provider) => _value.ToString(format, provider);
+
+        public bool Equals(DateOnly other) => _value == other._value;
+
+        public override bool Equals(object? obj) => obj is DateOnly other && Equals(other);
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public int CompareTo(DateOnly other) => _value.CompareTo(other._value);
+
+        public int CompareTo(object? obj)
+        {
+            if (obj is null) return 1;
+            if (obj is DateOnly other) return CompareTo(other);
+            throw new ArgumentException("Object must be of type DateOnly.", nameof(obj));
+        }
+
+        public static bool operator ==(DateOnly left, DateOnly right) => left.Equals(right);
+
+        public static bool operator !=(DateOnly left, DateOnly right) => !left.Equals(right);
+
+        public static bool operator <(DateOnly left, DateOnly right) => left.CompareTo(right) < 0;
+
+        public static bool operator <=(DateOnly left, DateOnly right) => left.CompareTo(right) <= 0;
+
+        public static bool operator >(DateOnly left, DateOnly right) => left.CompareTo(right) > 0;
+
+        public static bool operator >=(DateOnly left, DateOnly right) => left.CompareTo(right) >= 0;
+    }
+
+    /// <summary>
+    /// A time of day with no date and no offset. Stands in for <c>System.TimeOnly</c>.
+    /// </summary>
+    /// <remarks>
+    /// At least zero and less than 24 hours, which is what separates it from the
+    /// <see cref="TimeSpan"/> a contract's <c>duration</c> maps to.
+    /// </remarks>
+    public readonly struct TimeOnly : IEquatable<TimeOnly>, IComparable<TimeOnly>, IComparable
+    {
+        private static readonly TimeSpan OneDay = TimeSpan.FromDays(1);
+
+        /// <summary>Accepted on the way in: the wire form, with or without a fraction, and <c>HH:mm</c>.</summary>
+        private static readonly string[] Formats = { "HH:mm:ss.FFFFFFF", "HH:mm" };
+
+        private readonly TimeSpan _value;
+
+        public TimeOnly(int hour, int minute)
+            : this(new TimeSpan(hour, minute, 0))
+        {
+        }
+
+        public TimeOnly(int hour, int minute, int second)
+            : this(new TimeSpan(hour, minute, second))
+        {
+        }
+
+        public TimeOnly(int hour, int minute, int second, int millisecond)
+            : this(new TimeSpan(0, hour, minute, second, millisecond))
+        {
+        }
+
+        private TimeOnly(TimeSpan value)
+        {
+            if (value < TimeSpan.Zero || value >= OneDay)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "A time of day is at least zero and less than 24 hours.");
+            }
+
+            _value = value;
+        }
+
+        public static TimeOnly MinValue => new TimeOnly(TimeSpan.Zero);
+
+        public static TimeOnly MaxValue => new TimeOnly(OneDay - TimeSpan.FromTicks(1));
+
+        public int Hour => _value.Hours;
+
+        public int Minute => _value.Minutes;
+
+        public int Second => _value.Seconds;
+
+        public int Millisecond => _value.Milliseconds;
+
+        public long Ticks => _value.Ticks;
+
+        /// <summary>The time part of <paramref name="value"/>.</summary>
+        public static TimeOnly FromDateTime(DateTime value) => new TimeOnly(value.TimeOfDay);
+
+        /// <exception cref="ArgumentOutOfRangeException">When <paramref name="value"/> is negative or a day or more.</exception>
+        public static TimeOnly FromTimeSpan(TimeSpan value) => new TimeOnly(value);
+
+        /// <summary>This time as a span since midnight. What a XAML time picker binds to.</summary>
+        public TimeSpan ToTimeSpan() => _value;
+
+        public static TimeOnly Parse(string s) => Parse(s, CultureInfo.InvariantCulture);
+
+        /// <exception cref="FormatException">When <paramref name="s"/> is not a time of day.</exception>
+        public static TimeOnly Parse(string s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+            {
+                throw new FormatException("'" + s + "' is not a time of day.");
+            }
+
+            return result;
+        }
+
+        public static bool TryParse(string? s, out TimeOnly result) => TryParse(s, CultureInfo.InvariantCulture, out result);
+
+        public static bool TryParse(string? s, IFormatProvider? provider, out TimeOnly result)
+        {
+            var culture = provider ?? CultureInfo.InvariantCulture;
+            if (DateTime.TryParseExact(s, Formats, culture, DateTimeStyles.None, out var exact))
+            {
+                result = new TimeOnly(exact.TimeOfDay);
+                return true;
+            }
+
+            if (DateTime.TryParse(s, culture, DateTimeStyles.None, out var parsed))
+            {
+                result = new TimeOnly(parsed.TimeOfDay);
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
+        /// <summary>
+        /// The ISO 8601 form: <c>HH:mm:ss</c>, and a fraction of seven digits when there is one.
+        /// </summary>
+        /// <remarks>
+        /// Byte for byte what System.Text.Json's own converter writes for a <c>TimeOnly</c> on
+        /// net10.0 — including the seven digits, which it does not trim — so a service cannot tell
+        /// which leg of the build sent a body.
+        /// </remarks>
+        public override string ToString() =>
+            _value.Ticks % TimeSpan.TicksPerSecond == 0
+                ? _value.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture)
+                : _value.ToString("hh':'mm':'ss'.'fffffff", CultureInfo.InvariantCulture);
+
+        public string ToString(string? format) => _value.ToString(format, CultureInfo.InvariantCulture);
+
+        public string ToString(string? format, IFormatProvider? provider) => _value.ToString(format, provider);
+
+        public bool Equals(TimeOnly other) => _value == other._value;
+
+        public override bool Equals(object? obj) => obj is TimeOnly other && Equals(other);
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public int CompareTo(TimeOnly other) => _value.CompareTo(other._value);
+
+        public int CompareTo(object? obj)
+        {
+            if (obj is null) return 1;
+            if (obj is TimeOnly other) return CompareTo(other);
+            throw new ArgumentException("Object must be of type TimeOnly.", nameof(obj));
+        }
+
+        public static bool operator ==(TimeOnly left, TimeOnly right) => left.Equals(right);
+
+        public static bool operator !=(TimeOnly left, TimeOnly right) => !left.Equals(right);
+
+        public static bool operator <(TimeOnly left, TimeOnly right) => left.CompareTo(right) < 0;
+
+        public static bool operator <=(TimeOnly left, TimeOnly right) => left.CompareTo(right) <= 0;
+
+        public static bool operator >(TimeOnly left, TimeOnly right) => left.CompareTo(right) > 0;
+
+        public static bool operator >=(TimeOnly left, TimeOnly right) => left.CompareTo(right) >= 0;
+    }
+}
+
+#endif
+`;
+}

package/src/runtime.ts

@@ -62,7 +62,13 @@ public sealed class SdkOptions
 public class SdkException : HttpRequestException
 {
     public SdkException(int status, string body, HttpResponseHeaders? responseHeaders = null, string? message = null)
+#if NETSTANDARD2_0
+        // .NET Standard 2.0's HttpRequestException carries no status of its own. Status below does,
+        // so nothing is lost but the base type's own StatusCode property.
+        : base(message ?? $"Request failed with status {status}")
+#else
         : base(message ?? $"Request failed with status {status}", null, ToStatusCode(status))
+#endif
     {
         Status = status;
         Body = body;
@@ -121,8 +127,10 @@ public class SdkException : HttpRequestException
         }
     }
 
+#if !NETSTANDARD2_0
     private static HttpStatusCode? ToStatusCode(int status) =>
         status is >= 100 and <= 599 ? (HttpStatusCode)status : null;
+#endif
 }
 
 /// <summary>
@@ -210,6 +218,16 @@ public sealed class SdkHttp : IDisposable
 
     public JsonSerializerOptions Json { get; }
 
+    /// <summary>
+    /// The PATCH verb.
+    /// </summary>
+    /// <remarks>
+    /// <c>HttpMethod</c> carries a static for every other verb a contract can declare, but not for
+    /// this one on every framework the SDK builds against, so it is spelled once here rather than
+    /// allocated per call.
+    /// </remarks>
+    public static readonly HttpMethod Patch = new HttpMethod("PATCH");
+
     /// <summary>
     /// Send one request and read its body.
     /// </summary>
@@ -248,7 +266,13 @@ public sealed class SdkHttp : IDisposable
         }
 
         var message = await Client.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken).ConfigureAwait(false);
+#if NETSTANDARD2_0
+        // The cancellable overload arrived in .NET 5. ResponseContentRead above has already buffered
+        // the body, so this read is a copy rather than a wait on the network.
+        var bytes = await message.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+#else
         var bytes = await message.Content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
+#endif
         var response = new SdkResponse(message, bytes);
 
         var status = response.Status;

package/src/scaffold.ts

@@ -3,39 +3,78 @@
  *
  * 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 const SCAFFOLD_VERSIONS = {
     targetFramework: 'net10.0',
+    systemTextJson: '10.0.12',
+    /** The oldest language version the generated sources compile under: records, `required`, primary constructors. */
+    netstandardLangVersion: '12.0',
 } as const;
 
+/** The framework the scaffold targets when the config names none. */
+export const DEFAULT_TARGET_FRAMEWORKS: readonly CSharpTargetFramework[] = [SCAFFOLD_VERSIONS.targetFramework];
+
 /**
  * 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 function generateCsproj(namespaceName: string, sdkName: string): string {
+export function generateCsproj(
+    namespaceName: string,
+    sdkName: string,
+    targetFrameworks: readonly CSharpTargetFramework[] = DEFAULT_TARGET_FRAMEWORKS,
+): string {
+    const frameworks =
+        targetFrameworks.length === 1
+            ? `    <TargetFramework>${targetFrameworks[0]}</TargetFramework>`
+            : `    <TargetFrameworks>${targetFrameworks.join(';')}</TargetFrameworks>`;
+
+    const netstandard = targetFrameworks.includes('netstandard2.0')
+        ? `
+  <!-- .NET Standard 2.0 predates the language features the generated sources use. -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <LangVersion>${SCAFFOLD_VERSIONS.netstandardLangVersion}</LangVersion>
+  </PropertyGroup>
+
+  <!-- The one framework where System.Text.Json is a package rather than part of the platform. -->
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Text.Json" Version="${SCAFFOLD_VERSIONS.systemTextJson}" />
+  </ItemGroup>
+`
+        : '';
+
     return `<!-- Created once by @contractkit/plugin-csharp. Yours to edit: it is never regenerated. -->
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>${SCAFFOLD_VERSIONS.targetFramework}</TargetFramework>
+${frameworks}
     <Nullable>enable</Nullable>
     <ImplicitUsings>disable</ImplicitUsings>
     <RootNamespace>${namespaceName}</RootNamespace>
     <AssemblyName>${sdkName}</AssemblyName>
   </PropertyGroup>
-
+${netstandard}
 </Project>
 `;
 }

package/tests/codegen-client.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { buildModelIndex } from '@contractkit/core';
 import type { ContractRootNode, OpRootNode } from '@contractkit/core';
 import { buildPathExpression, deriveClientClassName, deriveMethodName, generateCSharpClient, hasPublicOperations } from '../src/codegen-client.js';
+import type { CSharpDateTypes } from '../src/codegen-models.js';
 import { collectHoistedTypes } from '../src/hoist.js';
 import {
     contractRoot,
@@ -18,12 +19,22 @@ import {
     scalarType,
 } from './helpers.js';
 
-function render(root: OpRootNode, opts: { contracts?: ContractRootNode[]; modelsWithInput?: Set<string>; includeInternal?: boolean } = {}): string {
+function render(
+    root: OpRootNode,
+    opts: { contracts?: ContractRootNode[]; modelsWithInput?: Set<string>; includeInternal?: boolean; dateTypes?: CSharpDateTypes } = {},
+): string {
     const contracts = opts.contracts ?? [];
     const modelIndex = buildModelIndex(contracts.flatMap(r => r.models));
     const modelsWithInput = opts.modelsWithInput ?? new Set<string>();
     const hoisted = collectHoistedTypes(contracts, { modelIndex, modelsWithInput });
-    return generateCSharpClient(root, { namespace: 'Acme.Sdk', modelsWithInput, modelIndex, hoisted, includeInternal: opts.includeInternal });
+    return generateCSharpClient(root, {
+        namespace: 'Acme.Sdk',
+        dateTypes: opts.dateTypes,
+        modelsWithInput,
+        modelIndex,
+        hoisted,
+        includeInternal: opts.includeInternal,
+    });
 }
 
 describe('naming', () => {
@@ -85,6 +96,21 @@ describe('class and method shape', () => {
         expect(out).not.toContain('var response = await');
     });
 
+    it('names the verb through HttpMethod, and PATCH through the runtime static instead', () => {
+        const verbs: [Parameters<typeof opOperation>[0], string][] = [
+            ['get', 'HttpMethod.Get'],
+            ['post', 'HttpMethod.Post'],
+            ['put', 'HttpMethod.Put'],
+            ['delete', 'HttpMethod.Delete'],
+            // `HttpMethod.Patch` does not exist on netstandard2.0, so the runtime spells this one.
+            ['patch', 'SdkHttp.Patch'],
+        ];
+        for (const [method, expression] of verbs) {
+            const root = opRoot([opRoute('/payments', [opOperation(method, { sdk: 'act' })])]);
+            expect(render(root, { contracts })).toContain(`        ${expression},`);
+        }
+    });
+
     it('sends the Input variant of a body model', () => {
         const root = opRoot([opRoute('/payments', [opOperation('post', { sdk: 'create', request: opRequest('Payment') })])]);
         const out = render(root, { contracts, modelsWithInput: new Set(['Payment']) });
@@ -271,9 +297,9 @@ describe('responses', () => {
 describe('response headers', () => {
     const contracts = [contractRoot([model('Payment', [field('id', scalarType('uuid'))])])];
 
-    function withHeaders(headers: { name: string; optional: boolean; type: ReturnType<typeof scalarType> }[]): string {
+    function withHeaders(headers: { name: string; optional: boolean; type: ReturnType<typeof scalarType> }[], dateTypes?: CSharpDateTypes): string {
         const root = opRoot([opRoute('/payments', [opOperation('get', { sdk: 'get', responses: [{ ...opResponse(200, 'Payment'), headers }] })])]);
-        return render(root, { contracts });
+        return render(root, { contracts, dateTypes });
     }
 
     it('requires a declared header and parses it to its type', () => {
@@ -298,6 +324,14 @@ describe('response headers', () => {
         expect(withHeaders([{ name: 'h', optional: false, type: scalarType('datetime') }])).toContain('DateTimeOffset.Parse(');
         expect(withHeaders([{ name: 'h', optional: false, type: scalarType('duration') }])).toContain('XmlConvert.ToTimeSpan(');
         expect(withHeaders([{ name: 'h', optional: false, type: scalarType('bigint') }])).toContain('BigInteger.Parse(');
+        expect(withHeaders([{ name: 'h', optional: false, type: scalarType('date') }])).toContain('DateOnly.Parse(');
+        expect(withHeaders([{ name: 'h', optional: false, type: scalarType('time') }])).toContain('TimeOnly.Parse(');
+    });
+
+    it('reads a date header as the type dateTypes asked for, so a header matches its model field', () => {
+        const out = withHeaders([{ name: 'x-day', optional: false, type: scalarType('date') }], 'datetime');
+        expect(out).toContain('DateTime.Parse(http.RequireHeader(response, "x-day"), CultureInfo.InvariantCulture)');
+        expect(out).toContain('public sealed record GetHeaders(DateTime XDay);');
     });
 
     it('renames an optional header pattern variable that would redeclare a parameter', () => {

package/tests/codegen-models.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { ContractRootNode, ScalarTypeNode } from '@contractkit/core';
 import { buildModelIndex } from '@contractkit/core';
-import { generateCSharpModels } from '../src/codegen-models.js';
+import { generateCSharpModels, type CSharpDateTypes } from '../src/codegen-models.js';
 import { collectHoistedTypes } from '../src/hoist.js';
 import {
     arrayType,
@@ -21,13 +21,18 @@ import {
 /** Render a root the way the plugin does: hoist across the project, then generate. */
 function render(
     root: ContractRootNode,
-    opts: { modelsWithInput?: Set<string>; warn?: (m: string) => void; roots?: ContractRootNode[] } = {},
+    opts: {
+        modelsWithInput?: Set<string>;
+        warn?: (m: string) => void;
+        roots?: ContractRootNode[];
+        dateTypes?: CSharpDateTypes;
+    } = {},
 ): string {
     const roots = opts.roots ?? [root];
     const modelIndex = buildModelIndex(roots.flatMap(r => r.models));
     const modelsWithInput = opts.modelsWithInput ?? new Set<string>();
     const hoisted = collectHoistedTypes(roots, { modelIndex, modelsWithInput, warn: message => opts.warn?.(message) });
-    return generateCSharpModels(root, { namespace: 'Acme.Sdk', modelsWithInput, modelIndex, hoisted, warn: opts.warn });
+    return generateCSharpModels(root, { namespace: 'Acme.Sdk', dateTypes: opts.dateTypes, modelsWithInput, modelIndex, hoisted, warn: opts.warn });
 }
 
 function one(name: string, ...fields: Parameters<typeof field>[] extends never ? never : ReturnType<typeof field>[]): ContractRootNode {
@@ -79,6 +84,20 @@ describe('scalar mapping', () => {
     it('maps a null scalar to a nullable object', () => {
         expect(render(one('M', field('f', scalarType('null'))))).toContain('public required object? F { get; init; }');
     });
+
+    it('maps date to DateTime under dateTypes, and leaves time alone', () => {
+        const root = contractRoot([model('M', [field('d', scalarType('date')), field('t', scalarType('time'))])]);
+        const out = render(root, { dateTypes: 'datetime' });
+        expect(out).toContain('public required DateTime D { get; init; }');
+        // `duration` is already TimeSpan and serialization dispatches on the CLR type, so a time
+        // carried as one would go out as PT9H30M.
+        expect(out).toContain('public required TimeOnly T { get; init; }');
+    });
+
+    it('treats a DateTime date as a value type, so an optional one is Nullable rather than a reference', () => {
+        const root = contractRoot([model('M', [field('d', scalarType('date'), { optional: true })])]);
+        expect(render(root, { dateTypes: 'datetime' })).toContain('public DateTime? D { get; init; }');
+    });
 });
 
 describe('composite types', () => {
@@ -255,6 +274,24 @@ describe('declarations', () => {
         expect(render(root)).toContain('global using Ps = System.Collections.Generic.List<Acme.Sdk.Models.P>;');
     });
 
+    it('names both spellings of a polyfilled alias target, the one thing a file import cannot cover', () => {
+        const root = contractRoot([model('Day', [], { type: scalarType('date') }), model('Days', [], { type: arrayType(scalarType('time')) })]);
+        const out = render(root);
+        expect(out).toContain(
+            '#if NETSTANDARD2_0\nglobal using Day = Acme.Sdk.Runtime.DateOnly;\n#else\nglobal using Day = System.DateOnly;\n#endif',
+        );
+        // A container around the polyfilled type is rewritten in place rather than missed.
+        expect(out).toContain('global using Days = System.Collections.Generic.List<Acme.Sdk.Runtime.TimeOnly>;');
+        expect(out).toContain('global using Days = System.Collections.Generic.List<System.TimeOnly>;');
+    });
+
+    it('imports the runtime namespace, which is where DateOnly comes from on an older framework', () => {
+        const root = contractRoot([model('Slot', [field('day', scalarType('date'))])]);
+        const out = render(root);
+        expect(out).toContain('using Acme.Sdk.Runtime;');
+        expect(out).toContain('public required DateOnly Day { get; init; }');
+    });
+
     it('drops nullability from an alias, which C# cannot express, and says so', () => {
         const warnings: string[] = [];
         const root = contractRoot([model('MaybeName', [], { type: unionType(scalarType('string'), scalarType('null')) })]);