@game-infra/valibot-to-csharp 0.0.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Savin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -8,36 +8,35 @@ We author JSON schemas in TypeScript (in editors and web tooling) but consume th
 
 ## Install
 
-This package is private and consumed as source from a sibling `game-infra` checkout (see `docs/CONSUMING.md` in the repo root). Add it to your game repo as a linked dependency:
+This one is published, unlike the rest of the repo's tooling: a game repo that generates C# from its own schemas needs the generator without checking out `game-infra`.
+
+```sh
+pnpm add -D @game-infra/valibot-to-csharp
+```
+
+A sibling checkout still works and is what you want while changing the generator itself (see `docs/CONSUMING.md` in the repo root):
 
 ```jsonc
 // pnpm
 "devDependencies": {
   "@game-infra/valibot-to-csharp": "link:../../../game-infra/packages/valibot-to-csharp"
 }
-
-// npm
-"devDependencies": {
-  "@game-infra/valibot-to-csharp": "file:../../../game-infra/packages/valibot-to-csharp"
-}
 ```
 
 ## CLI
 
-There is no published dist, so run the CLI straight from the sibling checkout's source with a TS runner such as tsx. Plain `node src/cli.ts` does not work: Node's type stripping refuses to map the `.js` relative import specifiers this repo uses onto their `.ts` sources.
-
 ```sh
-npx tsx ../game-infra/packages/valibot-to-csharp/src/cli.ts \
+npx valibot-to-csharp \
   --input ./schemas/events.ts \
   --input ./schemas/common.ts \
   --output ./Generated \
   --namespace MyGame.Events
 ```
 
-Alternatively, build once inside `game-infra` (`pnpm --filter @game-infra/valibot-to-csharp build`) and run the compiled entry point, which keeps its shebang:
+From a sibling checkout there is no `dist`, so run the source with a TS runner such as tsx. Plain `node src/cli.ts` does not work: Node's type stripping refuses to map the `.js` relative import specifiers this repo uses onto their `.ts` sources.
 
 ```sh
-node ../game-infra/packages/valibot-to-csharp/dist/cli.js --input ./schemas/events.ts --output ./Generated --namespace MyGame.Events
+npx tsx ../game-infra/packages/valibot-to-csharp/src/cli.ts --input ./schemas/events.ts --output ./Generated --namespace MyGame.Events
 ```
 
 Flags:
@@ -89,28 +88,152 @@ import { emitFileHeader, emitModule, parseFiles } from "@game-infra/valibot-to-c
 
 const module = parseFiles(["./schemas/events.ts"]);
 const emit = emitModule(module, { namespace: "MyGame.Events" });
-const csSource = emitFileHeader(module.notes) + emit.source;
+// Both note channels: what the parser could not read, and what the emitter could not
+// render faithfully. Each one is something the generated file no longer carries.
+const csSource = emitFileHeader([...module.notes, ...emit.notes]) + emit.source;
 ```
 
 ## Supported valibot surface
 
-| valibot                              | C#                                                       |
-| ------------------------------------ | -------------------------------------------------------- |
-| `string()`                           | `string`                                                 |
-| `number()`                           | `double`                                                 |
-| `boolean()`                          | `bool`                                                   |
-| `unknown()`                          | `JsonElement`                                            |
-| `array(X)`                           | `IReadOnlyList<X>`                                       |
-| `record(string(), V)`                | `IReadOnlyDictionary<string, V>`                         |
-| `object({...})`                      | `public sealed record`                                   |
-| `optional(X)` / `nullable(X)`        | Nullable field (`X?`)                                    |
-| `literal('a')`                       | String literal (merged into enums/variant tags)          |
-| `picklist(['a','b'])`                | `[JsonConverter(typeof(JsonStringEnumConverter))] enum`  |
-| `union([literal(...), ...])`         | Enum                                                     |
-| `union([string(), array(string())])` | `StringOrStringList` helper (auto-emitted)               |
-| `union([{type:'A',...}, ...])`       | `[JsonPolymorphic] abstract record` with derived records |
-| `variant('type', [...])`             | Same as discriminated union                              |
-| `pipe(inner, ...validators)`         | `inner` (validators are ignored)                         |
+| valibot                                         | C#                                                       |
+| ----------------------------------------------- | -------------------------------------------------------- |
+| `string()`                                      | `string`                                                 |
+| `number()`                                      | `double`                                                 |
+| `pipe(number(), integer(), minValue, maxValue)` | `int` when both bounds fit `Int32`, otherwise `long`     |
+| `boolean()`                                     | `bool`                                                   |
+| `unknown()`                                     | `JsonElement`                                            |
+| `array(X)`                                      | `IReadOnlyList<X>`                                       |
+| `record(string(), V)`                           | `IReadOnlyDictionary<string, V>`                         |
+| `object`, `strictObject`                        | `public sealed record` (closed)                          |
+| `looseObject`                                   | `public sealed record` + `[JsonExtensionData]` bag       |
+| `nullable(X)`                                   | Nullable field (`X?`)                                    |
+| `optional(X)`                                   | Nullable field, omitted when null                        |
+| `literal('a')`                                  | String literal (merged into enums/variant tags)          |
+| `literal(1)` / `literal(true)`                  | Constant `int`/`long`/`double` / `bool` field            |
+| `picklist(['a','b'])`                           | `[JsonConverter(typeof(JsonStringEnumConverter))] enum`  |
+| `union([literal(...), ...])`                    | Enum (string literals only)                              |
+| `union([string(), array(string())])`            | `StringOrStringList` helper (auto-emitted)               |
+| `union([{type:'A',...}, ...])`                  | `[JsonPolymorphic] abstract record` with derived records |
+| `variant('type', [...])`                        | Same as discriminated union                              |
+| `pipe(inner, ...validators)`                    | `inner`, plus the numeric refinements above              |
+
+### Numbers
+
+A bare `number()` is a `double`, which is the honest mapping and the wrong one
+for anything a digest is taken over: `double` round-trips `1e+21`, and .NET and
+JavaScript disagree on how to spell that. Pipe it through `integer()` and the
+emitted type is integral. It narrows to `int` only when `minValue` and `maxValue`
+both bound it inside `System.Int32` — JavaScript integers run to 2^53, so an
+unbounded one held in an `int` would refuse every value past two billion, which
+is a whole class of documents rejected rather than a rounding error.
+
+A numeric `literal(n)` is bounded by definition — the value is both bounds — so it
+takes its type by the same rule: `literal(1)` is an `int`, `literal(3000000000)` a
+`long`, and `literal(1.5)` a `double`.
+
+### Absent versus null
+
+`optional(X)` and `nullable(X)` are both `X?` in C#, and they are not the same
+fact on the wire: the first says the key may be absent, the second says the value
+may be `null`. Optional fields therefore carry
+`[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]`, so serialising
+one with no value omits the key instead of writing a `null` that a schema
+accepting only absence would refuse. Nullable fields keep writing `null`.
+
+### Unknown keys
+
+`object()` ignores entries its shape does not declare and `strictObject()` rejects
+them, so a closed C# record loses nothing. `looseObject()` keeps them, so its record
+carries a `[JsonExtensionData]` bag:
+
+```csharp
+public sealed record Envelope(
+    [property: JsonPropertyName("id")] string Id
+)
+{
+    [JsonExtensionData]
+    public Dictionary<string, JsonElement>? AdditionalProperties { get; set; }
+}
+```
+
+The bag is declared in the record body rather than as a positional parameter:
+`System.Text.Json` refuses an extension-data property bound to a constructor
+parameter, and every positional record parameter is one.
+
+### Which field is the discriminator
+
+A `variant('op', [...])` states its discriminator, and the emitter takes it at its
+word: a member is tagged by its `op` literal and by nothing else. Only a bare
+`union([...])`, which declares nothing, infers one — a string literal field,
+preferring one named `type`.
+
+The difference shows up the moment members share an envelope that carries a string
+literal of its own:
+
+```ts
+const envelope = { type: literal("op"), at: string() };
+export const MoveOpSchema = object({ ...envelope, op: literal("move") });
+export const HaltOpSchema = object({ ...envelope, op: literal("halt") });
+export const OpSchema = variant("op", [MoveOpSchema, HaltOpSchema]);
+```
+
+Tagging by `type` would give both members the `[JsonDerivedType]` value `"op"`, which
+`System.Text.Json` refuses when it builds the converter, and would leave the real `op`
+key off the wire entirely. Two members that do end up claiming the same tag — an
+ambiguity in the schema itself — are reported in the generated header, and only the
+first is emitted.
+
+### Referring to one member of a variant
+
+A field pointing at a single member (`last: optional(MoveOpSchema)`) is typed as the
+polymorphic **base**, not as the member:
+
+```csharp
+[property: JsonPropertyName("last")] Op? Last
+```
+
+The discriminator is written by `JsonPolymorphic` on the base and by nothing else, so
+a field declared as the derived record would serialise with no `op` key at all. The
+base deserialises straight back into the member; the widening is noted in the
+generated file's header.
+
+### Shared fields on a union's base
+
+Fields that every member of a `variant`/discriminated union declares identically — same name, same
+nullability, same shape — are hoisted onto the abstract base record, and each member passes them
+through as a plain constructor parameter. A shared envelope is then readable off the base type
+instead of through a switch over every member:
+
+```csharp
+foreach (var e in events) Console.WriteLine(e.Seq);  // declared once, on MatchEvent
+```
+
+A field only some members have, or one whose shape differs between them, stays on the members that
+have it.
+
+### Shared field groups
+
+Fields common to several schemas can live in a plain object literal and be
+spread into each one; the parser resolves the spread against module-level
+literals in the same file, and a later field of the same name wins as it does in
+JavaScript.
+
+```ts
+const eventEnvelope = { seq: seqSchema, createdAt: string() };
+
+export const JoinedSchema = strictObject({
+  ...eventEnvelope,
+  type: literal("joined"),
+});
+```
+
+A spread it cannot resolve — a value from another module, a call, a `.entries`
+access — contributes nothing rather than failing, so keep groups local and literal.
+Every unresolved spread is reported in the generated file's header, so a missing
+envelope is visible in the artifact rather than only in the diff of the C# it
+produced. A field an unreadable expression overrides is dropped and reported the same
+way: keeping the group's version would type the property as the shared shape while
+the schema says something else.
 
 Cross-file imports (relative paths only) are followed automatically so imported schemas land in the same output file. Imports from `node_modules` are not traversed.
 
@@ -118,13 +241,18 @@ Cross-file imports (relative paths only) are followed automatically so imported
 
 - Not evaluated: the generator parses the source and never executes it. Schemas built at runtime (e.g. produced from a function) are invisible to it.
 - String literal kludge: if you write `string('foo')` inside a `union(...)` (a shorthand some schemas use as a literal placeholder), the parser treats it as `literal('foo')` and notes the substitution in the generated file.
-- Unsupported features: `lazy`, `tuple`, `intersect`, `custom` transforms, and non-string record keys. Heterogeneous unions with no common discriminator fall back to `JsonElement`.
+- Unsupported features: `lazy`, `tuple`, `intersect`, `custom` transforms, and non-string record keys. Heterogeneous unions with no common discriminator fall back to `JsonElement`; a union mixing a numeric literal with a numeric schema (`union([literal(0), pipe(number(), integer())])`) is one of those, so express such a range as a single piped number with a `check` instead.
+- A discriminated union's base record keeps its tag as a plain `[JsonIgnore]` property: `System.Text.Json` writes the discriminator from `JsonPolymorphic`, and a second property claiming that JSON name is a hard failure on both serialize and deserialize.
+- A property whose C# name would equal its enclosing type's gets a `Value` suffix (`variant('op', ...)` named `Op` emits `OpValue`), because C# refuses the collision.
+- A named alias that declares no C# type of its own — `array(...)`, `record(...)`, a bare primitive, an `optional`/`nullable` wrapper, or another such alias — is inlined wherever it is referenced, wrappers and all. `export const NoteSchema = nullable(string())` used as a field is a `string?`, not a reference to a `Note` type nothing declares.
+- Anything dropped on the way is reported in the generated file's header, from both note channels. A generated file that lost a field says so at the top of itself.
 - Nested anonymous objects are named `<ParentType><FieldName>` to avoid collisions with sibling inline types.
 - `DTO` becomes `Dto` in emitted type names (e.g. `EventDefinitionDTOSchema` becomes `EventDefinitionDto`).
 
 ## Extension points
 
 - New valibot features: add a node kind to `src/ir.ts`, parse it in `src/parser.ts`, and teach `src/emitter.ts` how to render it. The IR is a closed union, so the compiler points at every switch that needs a new case.
+- The emitter's supporting rules live beside it: `src/csharp.ts` holds everything about how a value spells itself in C# (numeric widths, property names, the file header, the hand-written `StringOrStringList` source), and `src/variants.ts` holds union classification (which field tags a member, what every member has in common). Neither needs a module to answer, so both are plain functions.
 - Naming: `--union-name` (CLI) / `unionRenames` (API) override the C# base-type name of a union or variant schema without touching the TS source.
 
 ## Dependencies
@@ -133,4 +261,4 @@ Cross-file imports (relative paths only) are followed automatically so imported
 
 ## Consumers
 
-The `*-schemas` contract packages in this repo, and game repos that need C# mirrors of their JSON contracts for .NET clients.
+The `*-schemas` contract packages in this repo, and game repos that need C# mirrors of their JSON contracts for .NET clients — among them _Chaos Overlords: New Chrome_, whose MonoGame client mirrors the multiplayer server's valibot wire contracts.

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/csharp.d.ts

@@ -0,0 +1,65 @@
+/**
+ * How a schema value spells itself in C#: numeric widths, property names, the file header,
+ * and the source of the one hand-written helper type the emitter can reach for.
+ *
+ * Kept apart from the emitter because none of it needs a module to answer — given a node or
+ * a name, the answer is the same every time.
+ */
+import type { PrimitiveNode } from "./ir.js";
+/** Property name for the `[JsonExtensionData]` bag a `looseObject` record carries. */
+export declare const EXTENSION_DATA_PROPERTY = "AdditionalProperties";
+/**
+ * The C# type for a `number()`.
+ *
+ * A plain number is `double`. An `integer()` is integral, and narrows to `int`
+ * only when both declared bounds fit `System.Int32`: JavaScript integers run to
+ * 2^53, so an unbounded one deserialised into an `int` would reject every value
+ * above two billion — the failure mode is a whole class of documents refused,
+ * not a rounding error, so the wider type is the safe default.
+ */
+export declare function numericCsType(node: PrimitiveNode): string;
+/**
+ * The C# type of a `literal(...)` value, by the JSON kind it stands for.
+ *
+ * A numeric literal is a `number()` whose bounds are the value itself, so it goes through
+ * {@link numericCsType} rather than repeating the Int32 fit test: `literal(3000000000)` is
+ * a `long` for the same reason `pipe(number(), integer(), minValue(3000000000))` is, and
+ * spelling it `double` would put a `3E+09` where the digest expects `3000000000`.
+ */
+export declare function literalCsType(value: string | number | boolean): string;
+/**
+ * The C# property name for a field of a given type.
+ *
+ * C# refuses a member whose name is its enclosing type's (CS0542), which a
+ * `variant("op", ...)` named `Op` walks straight into. The JSON name is carried
+ * by `JsonPropertyName` either way, so the C# name is free to move.
+ */
+export declare function propertyNameIn(typeName: string, fieldName: string): string;
+/**
+ * Render the file-level header: auto-generated banner, whatever the parse and the emit could
+ * not carry across, and the using-block. Split out so callers that want to embed the emitter
+ * output in larger files can skip it.
+ *
+ * Pass both {@link SchemaModule.notes} and {@link EmitResult.notes}: a field the parser could
+ * not read and a member the emitter had to drop are the same kind of fact to whoever opens
+ * the generated file, and the header is the only place either one surfaces.
+ *
+ * @example
+ * ```ts
+ * import { emitFileHeader, emitModule, parseFiles } from "@game-infra/valibot-to-csharp";
+ *
+ * const module = parseFiles(["./schemas/events.ts"]);
+ * const emit = emitModule(module, { namespace: "MyGame.Events" });
+ * const header = emitFileHeader([...module.notes, ...emit.notes]);
+ * // "// <auto-generated>..." plus the System.Text.Json using-block
+ * ```
+ */
+export declare function emitFileHeader(notes: string[]): string;
+/**
+ * The C# source of the `StringOrStringList` helper: the one type the emitter writes by hand
+ * rather than deriving from a schema. `union([string(), array(string())])` has no C# shape of
+ * its own, so it gets a record with implicit conversions and a converter that reads either
+ * form and writes back the one it was given.
+ */
+export declare const STRING_OR_STRING_LIST_SOURCE = "[JsonConverter(typeof(StringOrStringListConverter))]\npublic sealed record StringOrStringList(IReadOnlyList<string> Values)\n{\n    public static implicit operator StringOrStringList(string value) => new(new[] { value });\n    public static implicit operator StringOrStringList(string[] values) => new(values);\n}\n\npublic sealed class StringOrStringListConverter : JsonConverter<StringOrStringList>\n{\n    public override StringOrStringList Read(ref Utf8JsonReader reader, System.Type typeToConvert, JsonSerializerOptions options)\n    {\n        if (reader.TokenType == JsonTokenType.String)\n        {\n            var single = reader.GetString() ?? string.Empty;\n            return new StringOrStringList(new[] { single });\n        }\n        if (reader.TokenType == JsonTokenType.StartArray)\n        {\n            var list = new List<string>();\n            while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)\n            {\n                list.Add(reader.GetString() ?? string.Empty);\n            }\n            return new StringOrStringList(list);\n        }\n        throw new JsonException(\"Expected string or array of strings for StringOrStringList.\");\n    }\n\n    public override void Write(Utf8JsonWriter writer, StringOrStringList value, JsonSerializerOptions options)\n    {\n        if (value.Values.Count == 1)\n        {\n            writer.WriteStringValue(value.Values[0]);\n            return;\n        }\n        writer.WriteStartArray();\n        foreach (var v in value.Values) writer.WriteStringValue(v);\n        writer.WriteEndArray();\n    }\n}";
+//# sourceMappingURL=csharp.d.ts.map

package/dist/csharp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../src/csharp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAK9D;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAKzD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAUtE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG1E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAoBtD;AAED;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,qkDAuCvC,CAAC"}

package/dist/csharp.js

@@ -0,0 +1,147 @@
+/**
+ * How a schema value spells itself in C#: numeric widths, property names, the file header,
+ * and the source of the one hand-written helper type the emitter can reach for.
+ *
+ * Kept apart from the emitter because none of it needs a module to answer — given a node or
+ * a name, the answer is the same every time.
+ */
+import { toPascalCase } from "./naming.js";
+/** Property name for the `[JsonExtensionData]` bag a `looseObject` record carries. */
+export const EXTENSION_DATA_PROPERTY = "AdditionalProperties";
+const INT32_MIN = -2_147_483_648;
+const INT32_MAX = 2_147_483_647;
+/**
+ * The C# type for a `number()`.
+ *
+ * A plain number is `double`. An `integer()` is integral, and narrows to `int`
+ * only when both declared bounds fit `System.Int32`: JavaScript integers run to
+ * 2^53, so an unbounded one deserialised into an `int` would reject every value
+ * above two billion — the failure mode is a whole class of documents refused,
+ * not a rounding error, so the wider type is the safe default.
+ */
+export function numericCsType(node) {
+    if (!node.integer)
+        return "double";
+    const { min, max } = node;
+    const fitsInt32 = min !== undefined && max !== undefined && min >= INT32_MIN && max <= INT32_MAX;
+    return fitsInt32 ? "int" : "long";
+}
+/**
+ * The C# type of a `literal(...)` value, by the JSON kind it stands for.
+ *
+ * A numeric literal is a `number()` whose bounds are the value itself, so it goes through
+ * {@link numericCsType} rather than repeating the Int32 fit test: `literal(3000000000)` is
+ * a `long` for the same reason `pipe(number(), integer(), minValue(3000000000))` is, and
+ * spelling it `double` would put a `3E+09` where the digest expects `3000000000`.
+ */
+export function literalCsType(value) {
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "boolean")
+        return "bool";
+    return numericCsType({
+        kind: "primitive",
+        type: "number",
+        integer: Number.isSafeInteger(value),
+        min: value,
+        max: value,
+    });
+}
+/**
+ * The C# property name for a field of a given type.
+ *
+ * C# refuses a member whose name is its enclosing type's (CS0542), which a
+ * `variant("op", ...)` named `Op` walks straight into. The JSON name is carried
+ * by `JsonPropertyName` either way, so the C# name is free to move.
+ */
+export function propertyNameIn(typeName, fieldName) {
+    const propName = toPascalCase(fieldName);
+    return propName === typeName ? `${propName}Value` : propName;
+}
+/**
+ * Render the file-level header: auto-generated banner, whatever the parse and the emit could
+ * not carry across, and the using-block. Split out so callers that want to embed the emitter
+ * output in larger files can skip it.
+ *
+ * Pass both {@link SchemaModule.notes} and {@link EmitResult.notes}: a field the parser could
+ * not read and a member the emitter had to drop are the same kind of fact to whoever opens
+ * the generated file, and the header is the only place either one surfaces.
+ *
+ * @example
+ * ```ts
+ * import { emitFileHeader, emitModule, parseFiles } from "@game-infra/valibot-to-csharp";
+ *
+ * const module = parseFiles(["./schemas/events.ts"]);
+ * const emit = emitModule(module, { namespace: "MyGame.Events" });
+ * const header = emitFileHeader([...module.notes, ...emit.notes]);
+ * // "// <auto-generated>..." plus the System.Text.Json using-block
+ * ```
+ */
+export function emitFileHeader(notes) {
+    const lines = [
+        "// <auto-generated>",
+        "//   This file was generated by @game-infra/valibot-to-csharp.",
+        "//   Do not edit by hand; regenerate from the valibot source instead.",
+        "// </auto-generated>",
+    ];
+    for (const note of notes) {
+        lines.push(`// ${note}`);
+    }
+    lines.push("");
+    // A file the compiler recognises as auto-generated is outside the project's nullable context, so
+    // every `T?` in it is an error (CS8669) unless the file turns the context on itself.
+    lines.push("#nullable enable");
+    lines.push("");
+    lines.push("using System.Collections.Generic;");
+    lines.push("using System.Text.Json;");
+    lines.push("using System.Text.Json.Serialization;");
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * The C# source of the `StringOrStringList` helper: the one type the emitter writes by hand
+ * rather than deriving from a schema. `union([string(), array(string())])` has no C# shape of
+ * its own, so it gets a record with implicit conversions and a converter that reads either
+ * form and writes back the one it was given.
+ */
+export const STRING_OR_STRING_LIST_SOURCE = `[JsonConverter(typeof(StringOrStringListConverter))]
+public sealed record StringOrStringList(IReadOnlyList<string> Values)
+{
+    public static implicit operator StringOrStringList(string value) => new(new[] { value });
+    public static implicit operator StringOrStringList(string[] values) => new(values);
+}
+
+public sealed class StringOrStringListConverter : JsonConverter<StringOrStringList>
+{
+    public override StringOrStringList Read(ref Utf8JsonReader reader, System.Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var single = reader.GetString() ?? string.Empty;
+            return new StringOrStringList(new[] { single });
+        }
+        if (reader.TokenType == JsonTokenType.StartArray)
+        {
+            var list = new List<string>();
+            while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
+            {
+                list.Add(reader.GetString() ?? string.Empty);
+            }
+            return new StringOrStringList(list);
+        }
+        throw new JsonException("Expected string or array of strings for StringOrStringList.");
+    }
+
+    public override void Write(Utf8JsonWriter writer, StringOrStringList value, JsonSerializerOptions options)
+    {
+        if (value.Values.Count == 1)
+        {
+            writer.WriteStringValue(value.Values[0]);
+            return;
+        }
+        writer.WriteStartArray();
+        foreach (var v in value.Values) writer.WriteStringValue(v);
+        writer.WriteEndArray();
+    }
+}`;
+//# sourceMappingURL=csharp.js.map

package/dist/csharp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.js","sourceRoot":"","sources":["../src/csharp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,sFAAsF;AACtF,MAAM,CAAC,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE9D,MAAM,SAAS,GAAG,CAAC,aAAa,CAAC;AACjC,MAAM,SAAS,GAAG,aAAa,CAAC;AAEhC;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,IAAmB;IAC/C,IAAI,CAAC,IAAI,CAAC,OAAO;QAAE,OAAO,QAAQ,CAAC;IACnC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC1B,MAAM,SAAS,GAAG,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,IAAI,SAAS,CAAC;IACjG,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;AACpC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,KAAgC;IAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC/C,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IAC9C,OAAO,aAAa,CAAC;QACnB,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;QACpC,GAAG,EAAE,KAAK;QACV,GAAG,EAAE,KAAK;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,SAAiB;IAChE,MAAM,QAAQ,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;IACzC,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,cAAc,CAAC,KAAe;IAC5C,MAAM,KAAK,GAAG;QACZ,qBAAqB;QACrB,gEAAgE;QAChE,uEAAuE;QACvE,sBAAsB;KACvB,CAAC;IACF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;IAC3B,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,iGAAiG;IACjG,qFAAqF;IACrF,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC/B,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;IAChD,KAAK,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IACtC,KAAK,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;IACpD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuC1C,CAAC"}

package/dist/emitter.d.ts

@@ -1,4 +1,5 @@
 import type { SchemaModule } from "./ir.js";
+export { emitFileHeader } from "./csharp.js";
 /**
  * Options accepted by {@link emitModule}.
  *
@@ -36,6 +37,13 @@ export interface EmitResult {
     source: string;
     /** True if any StringOrStringList helper was referenced. */
     usesStringOrStringList: boolean;
+    /**
+     * Shapes the emitter could not render faithfully — a dropped variant member, a widened
+     * field type, a reference it could not close. The caller renders these into the generated
+     * file's header alongside {@link SchemaModule.notes}, so a lossy translation says so in
+     * the artifact rather than only in whoever ran it.
+     */
+    notes: string[];
 }
 /**
  * Turn a {@link SchemaModule} into a C# source file body. The caller wraps
@@ -52,17 +60,4 @@ export interface EmitResult {
  * ```
  */
 export declare function emitModule(module: SchemaModule, opts: EmitOptions): EmitResult;
-/**
- * Render the file-level header: auto-generated banner + using-block. Split out
- * so callers that want to embed the emitter output in larger files can skip it.
- *
- * @example
- * ```ts
- * import { emitFileHeader } from "@game-infra/valibot-to-csharp";
- *
- * const header = emitFileHeader([]);
- * // "// <auto-generated>..." plus the System.Text.Json using-block
- * ```
- */
-export declare function emitFileHeader(notes: string[]): string;
 //# sourceMappingURL=emitter.d.ts.map

package/dist/emitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,YAAY,EAGb,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CA0B9E;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAgBtD"}
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAIV,YAAY,EAGb,MAAM,SAAS,CAAC;AAajB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,sBAAsB,EAAE,OAAO,CAAC;IAChC;;;;;OAKG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CA8B9E"}