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

package/dist/emitter.js

@@ -1,4 +1,9 @@
+import { EXTENSION_DATA_PROPERTY, literalCsType, numericCsType, propertyNameIn, STRING_OR_STRING_LIST_SOURCE, } from "./csharp.js";
 import { csStringLiteral, stripSchemaSuffix, toPascalCase } from "./naming.js";
+import { describeMember, inferTagField, isTagField, isVariantLike, sharedFields, } from "./variants.js";
+// The file header lives with the rest of the C# spelling rules; re-exported here so callers
+// keep reaching for it beside `emitModule`, which is the only place it is ever used.
+export { emitFileHeader } from "./csharp.js";
 /**
  * Turn a {@link SchemaModule} into a C# source file body. The caller wraps
  * this with the using-block header (see {@link emitFileHeader}) and writes it
@@ -36,94 +41,113 @@ export function emitModule(module, opts) {
     }
     const body = ctx.typeDecls.join("\n\n");
     const wrapped = `\nnamespace ${opts.namespace};\n\n${body}\n`;
-    return { source: wrapped, usesStringOrStringList: ctx.usesStringOrStringList };
-}
-function isVariantLike(node) {
-    if (node.kind === "variant")
-        return true;
-    if (node.kind === "union") {
-        // Heuristic: unions of all-object-literals with a shared discriminator.
-        // Re-classifying here would require the context; keep it simple and let
-        // the emitter decide. This ordering only affects when emitNamed runs for
-        // the base, not correctness.
-        return (node.members.length > 0 && node.members.every((m) => m.kind === "object" || m.kind === "ref"));
-    }
-    return false;
-}
-/**
- * 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 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("");
-    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");
+    return {
+        source: wrapped,
+        usesStringOrStringList: ctx.usesStringOrStringList,
+        notes: ctx.notes,
+    };
 }
 class EmitContext {
     module;
     opts;
     typeDecls = [];
+    notes = [];
     usesStringOrStringList = false;
+    /** Ref names currently being inlined, so a self-referential alias terminates. */
+    resolvingRefs = new Set();
     /** Names already emitted, to avoid duplicates on cross-references. */
     emittedTypeNames = new Set();
     /** Track named schemas already fully emitted, keyed by source const name. */
     emittedNamed = new Set();
     /**
-     * Named schemas that will be emitted as variant members. They must not
-     * also be emitted as top-level standalone records.
+     * Named schemas that will be emitted as variant members, mapped to the C# name of the
+     * polymorphic base they derive from. They must not also be emitted as top-level
+     * standalone records, and a field referencing one is typed as the base.
      */
-    variantMemberNames = new Set();
+    variantMemberBases = new Map();
+    /** Notes already recorded, so one limitation hit repeatedly is reported once. */
+    reportedNotes = new Set();
     constructor(module, opts) {
         this.module = module;
         this.opts = opts;
     }
-    /** Pre-pass: mark every named schema referenced as a variant member. */
+    /** Record something the emitter could not render faithfully. Deduplicated on the text. */
+    note(message) {
+        if (this.reportedNotes.has(message))
+            return;
+        this.reportedNotes.add(message);
+        this.notes.push(message);
+    }
+    /** Pre-pass: map every named schema referenced as a variant member to its base type. */
     markVariantMembers() {
         for (const named of this.module.schemas.values()) {
-            const collected = this.collectVariantMembers(named.schema);
-            for (const n of collected)
-                this.variantMemberNames.add(n);
+            const members = this.polymorphicMembersOf(named.schema);
+            if (!members)
+                continue;
+            const baseTypeName = this.csTypeNameForNamed(named.name);
+            for (const member of members) {
+                if (member.kind !== "ref")
+                    continue;
+                const claimed = this.variantMemberBases.get(member.name);
+                if (claimed !== undefined && claimed !== baseTypeName) {
+                    // A C# record derives from one base, so a schema belonging to two variants has no
+                    // faithful rendering at all. Say so rather than let the second claim win in silence.
+                    this.note(`"${member.name}" is a member of both ${claimed} and ${baseTypeName}; ` +
+                        `C# allows one base, so it derives from ${claimed}`);
+                    continue;
+                }
+                this.variantMemberBases.set(member.name, baseTypeName);
+            }
         }
     }
-    collectVariantMembers(node) {
-        if (node.kind === "variant") {
-            return this.refsInMembers(node.members);
-        }
-        if (node.kind === "union") {
-            const shape = this.classifyUnion(node.members);
-            if (shape.kind === "discriminated") {
-                return this.refsInMembers(node.members);
-            }
+    /**
+     * The members of a named schema that emits as a polymorphic base, or null if it does not
+     * emit as one. A `variant(...)` always does; a `union([...])` only when every member
+     * resolves to an object sharing one discriminator.
+     */
+    polymorphicMembersOf(node) {
+        if (node.kind === "variant")
+            return node.members;
+        if (node.kind === "union" && this.classifyUnion(node.members).kind === "discriminated") {
+            return node.members;
         }
-        return [];
+        return null;
     }
-    refsInMembers(members) {
-        const out = [];
-        for (const m of members) {
-            if (m.kind === "ref")
-                out.push(m.name);
+    /**
+     * A field with the `optional`/`nullable` wrappers hiding behind named aliases folded in.
+     *
+     * The parser peels a wrapper written on the field itself, but `note: NoteSchema` where
+     * `NoteSchema = nullable(string())` puts one behind a reference, and an alias of that alias
+     * puts it two references away. A field that lost its `?` on the way is a `null` the C# type
+     * swears cannot arrive.
+     *
+     * Only an alias that declares no C# type of its own is followed — the same rule
+     * {@link toCsType} inlines by — so a reference to a record, an enum or a variant is left
+     * alone to resolve to its own named type.
+     */
+    effectiveField(field) {
+        let { optional, nullable, schema } = field;
+        const followed = new Set();
+        for (;;) {
+            if (schema.kind === "optional") {
+                optional = true;
+                schema = schema.inner;
+                continue;
+            }
+            if (schema.kind === "nullable") {
+                nullable = true;
+                schema = schema.inner;
+                continue;
+            }
+            if (schema.kind !== "ref" || followed.has(schema.name))
+                break;
+            const target = this.module.schemas.get(schema.name);
+            if (!target || this.declaresNamedType(target.schema))
+                break;
+            followed.add(schema.name);
+            schema = target.schema;
         }
-        return out;
+        return { ...field, optional, nullable, schema };
     }
     /** Top-level emit for a named schema. */
     emitNamed(named) {
@@ -133,7 +157,7 @@ class EmitContext {
         // If this named schema is going to be emitted as a derived record of a
         // discriminated union, skip the standalone emit. It'll be produced by
         // the variant's own emitter pass.
-        if (this.variantMemberNames.has(named.name) && named.schema.kind === "object") {
+        if (this.variantMemberBases.has(named.name) && named.schema.kind === "object") {
             return;
         }
         const typeName = this.csTypeNameForNamed(named.name);
@@ -193,23 +217,49 @@ class EmitContext {
         if (this.emittedTypeNames.has(name))
             return;
         this.emittedTypeNames.add(name);
-        if (obj.fields.length === 0) {
-            this.typeDecls.push(`public sealed record ${name}();`);
+        const fieldLines = obj.fields.map((f) => this.emitField(f, name));
+        const propertyNames = obj.fields.map((f) => propertyNameIn(name, f.name));
+        const tail = this.recordTail(obj, propertyNames);
+        if (fieldLines.length === 0) {
+            this.typeDecls.push(`public sealed record ${name}()${tail}`);
             return;
         }
-        const lines = [];
-        lines.push(`public sealed record ${name}(`);
-        const fieldLines = [];
-        for (const f of obj.fields) {
-            fieldLines.push(this.emitField(f, name));
-        }
-        lines.push(fieldLines.map((l) => `    ${l}`).join(",\n"));
-        lines.push(");");
-        this.typeDecls.push(lines.join("\n"));
+        this.typeDecls.push([
+            `public sealed record ${name}(`,
+            fieldLines.map((l) => `    ${l}`).join(",\n"),
+            `)${tail}`,
+        ].join("\n"));
+    }
+    /**
+     * What closes a record declaration: a bare `;`, or a body holding the extension-data bag
+     * a `looseObject` needs.
+     *
+     * The bag is declared in the body rather than as a positional parameter because
+     * `System.Text.Json` refuses an extension-data property bound to a constructor parameter,
+     * and every positional record parameter is one.
+     */
+    recordTail(obj, propertyNames) {
+        if (!obj.preservesUnknownKeys)
+            return ";";
+        const taken = new Set(propertyNames);
+        let propertyName = EXTENSION_DATA_PROPERTY;
+        for (let i = 2; taken.has(propertyName); i++)
+            propertyName = `${EXTENSION_DATA_PROPERTY}${i}`;
+        return [
+            "",
+            "{",
+            "    /// <summary>",
+            "    /// JSON members this schema does not declare. A looseObject keeps them, so they are",
+            "    /// carried here rather than dropped on the way back out.",
+            "    /// </summary>",
+            "    [JsonExtensionData]",
+            `    public Dictionary<string, JsonElement>? ${propertyName} { get; set; }`,
+            "}",
+        ].join("\n");
     }
-    emitField(f, parentTypeName) {
-        const optionalOrNullable = f.optional || f.nullable;
-        const propName = toPascalCase(f.name);
+    emitField(rawField, parentTypeName) {
+        const f = this.effectiveField(rawField);
+        const propName = propertyNameIn(parentTypeName, f.name);
         // Nested anonymous types get the enclosing type prepended to their hint
         // (e.g. AddScore.params → AddScoreParams) so sibling objects don't
         // collide on identically-named inline fields.
@@ -218,8 +268,16 @@ class EmitContext {
         });
         for (const d of inlineDecls)
             this.typeDecls.push(d);
-        const suffix = optionalOrNullable ? "?" : "";
-        return `[property: JsonPropertyName(${csStringLiteral(f.name)})] ${csType}${suffix} ${propName}`;
+        const suffix = f.optional || f.nullable ? "?" : "";
+        const attributes = [`JsonPropertyName(${csStringLiteral(f.name)})`];
+        // `optional(X)` means the key may be ABSENT and `nullable(X)` means it may
+        // be `null`; both are `X?` in C#, and writing `null` for the first is the
+        // one that a strict schema on the other end refuses. Only the optional
+        // field is therefore dropped when it has no value.
+        if (f.optional && !f.nullable) {
+            attributes.push("JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)");
+        }
+        return `[property: ${attributes.join(", ")}] ${csType}${suffix} ${propName}`;
     }
     emitEnum(name, values) {
         if (this.emittedTypeNames.has(name))
@@ -241,43 +299,80 @@ class EmitContext {
         if (this.emittedTypeNames.has(name))
             return;
         this.emittedTypeNames.add(name);
-        const members = this.resolveVariantMembers(variant.members);
+        const members = this.resolveVariantMembers(variant.members, variant.discriminator);
         if (members.length === 0) {
             // No resolvable members: emit a placeholder so cross-refs resolve.
             this.typeDecls.push([
                 `// TODO: variant ${name} had no resolvable object members.`,
-                `public abstract record ${name}(string ${toPascalCase(variant.discriminator)});`,
+                `public abstract record ${name}(string ${propertyNameIn(name, variant.discriminator)});`,
             ].join("\n"));
             return;
         }
+        // Fields every member declares identically belong on the base, so a caller can read the
+        // envelope of a union without switching on all twelve of its members first.
+        const shared = sharedFields(members, variant.discriminator);
+        const tagName = propertyNameIn(name, variant.discriminator);
         // Base abstract record with polymorphism attributes.
         const baseLines = [];
         baseLines.push(`[JsonPolymorphic(TypeDiscriminatorPropertyName = ${csStringLiteral(variant.discriminator)})]`);
         for (const m of members) {
             baseLines.push(`[JsonDerivedType(typeof(${m.typeName}), ${csStringLiteral(m.tag)})]`);
         }
-        baseLines.push(`public abstract record ${name}([property: JsonPropertyName(${csStringLiteral(variant.discriminator)})] string ${toPascalCase(variant.discriminator)});`);
+        // `[JsonIgnore]`, not `[JsonPropertyName]`: `System.Text.Json` writes the discriminator itself
+        // from `JsonPolymorphic`, and a property claiming the same JSON name is a hard failure on both
+        // serialize and deserialize ("conflicts with an existing metadata property name"). The property
+        // stays on the record so C# can read the tag without a cast; only the duplicate write goes.
+        const baseParams = [
+            ...shared.map((f) => this.emitField(f, name)),
+            `[property: JsonIgnore] string ${tagName}`,
+        ];
+        if (shared.length === 0) {
+            baseLines.push(`public abstract record ${name}(${baseParams[0]});`);
+        }
+        else {
+            baseLines.push(`public abstract record ${name}(`);
+            baseLines.push(baseParams.map((l) => `    ${l}`).join(",\n"));
+            baseLines.push(");");
+        }
         this.typeDecls.push(baseLines.join("\n"));
-        // Derived records, one per member.
+        // Derived records, one per member. A shared field is a plain pass-through parameter: it is
+        // already a property on the base, so re-declaring it (attributes and all) would shadow it.
+        const sharedNames = new Set(shared.map((f) => f.name));
+        const passThrough = shared.map((f) => propertyNameIn(name, f.name));
         for (const m of members) {
             if (this.emittedTypeNames.has(m.typeName))
                 continue;
             this.emittedTypeNames.add(m.typeName);
-            // Fields minus the discriminator.
-            const fields = m.schema.fields.filter((f) => f.name !== variant.discriminator);
-            const lines = [];
-            if (fields.length === 0) {
-                lines.push(`public sealed record ${m.typeName}() : ${name}(${csStringLiteral(m.tag)});`);
+            const own = m.schema.fields.filter((f) => f.name !== variant.discriminator && !sharedNames.has(f.name));
+            const parameters = [
+                ...shared.map((f) => `${this.csFieldType(f, name)} ${propertyNameIn(name, f.name)}`),
+                ...own.map((f) => this.emitField(f, m.typeName)),
+            ];
+            const call = `${name}(${[...passThrough, csStringLiteral(m.tag)].join(", ")})`;
+            const propertyNames = [...passThrough, ...own.map((f) => propertyNameIn(m.typeName, f.name))];
+            const tail = this.recordTail(m.schema, propertyNames);
+            if (parameters.length === 0) {
+                this.typeDecls.push(`public sealed record ${m.typeName}() : ${call}${tail}`);
             }
             else {
-                lines.push(`public sealed record ${m.typeName}(`);
-                const fieldLines = fields.map((f) => this.emitField(f, m.typeName));
-                lines.push(fieldLines.map((l) => `    ${l}`).join(",\n"));
-                lines.push(`) : ${name}(${csStringLiteral(m.tag)});`);
+                this.typeDecls.push([
+                    `public sealed record ${m.typeName}(`,
+                    parameters.map((l) => `    ${l}`).join(",\n"),
+                    `) : ${call}${tail}`,
+                ].join("\n"));
             }
-            this.typeDecls.push(lines.join("\n"));
         }
     }
+    /** The C# type of a field, without its attributes; for a base pass-through parameter. */
+    csFieldType(rawField, parentTypeName) {
+        const f = this.effectiveField(rawField);
+        const { csType, inlineDecls } = this.csExpression(f.schema, {
+            parentHint: `${parentTypeName}${toPascalCase(f.name)}`,
+        });
+        for (const d of inlineDecls)
+            this.typeDecls.push(d);
+        return f.optional || f.nullable ? `${csType}?` : csType;
+    }
     /**
      * Render a SchemaNode as an inline C# type reference, emitting any
      * nested-type declarations required to support it. Returns both the textual
@@ -295,32 +390,51 @@ class EmitContext {
                 if (node.type === "string")
                     return "string";
                 if (node.type === "number")
-                    return "double";
+                    return numericCsType(node);
                 return "bool";
             case "unknown":
                 return "JsonElement";
             case "literal":
-                return "string";
+                return literalCsType(node.value);
             case "ref": {
                 // Try to resolve the referenced named schema so we know what C#
                 // shape it ultimately maps to (important for enums / variants
                 // whose C# name isn't simply the PascalCase of the const).
                 const resolved = this.module.schemas.get(node.name);
-                if (resolved) {
-                    // Named unions that collapse to string|string[] should be
-                    // substituted with the shared helper type.
-                    if (resolved.schema.kind === "union") {
-                        const shape = this.classifyUnion(resolved.schema.members);
-                        if (shape.kind === "stringOrList") {
-                            this.usesStringOrStringList = true;
-                            return "StringOrStringList";
-                        }
-                    }
+                if (!resolved) {
+                    // Unknown reference. Best guess: treat as a C# type of the same
+                    // stripped name (the author likely knows what they're doing).
+                    return stripSchemaSuffix(node.name);
+                }
+                // A variant member only reaches the wire correctly through its base: the
+                // discriminator is written by `JsonPolymorphic` on the base and by nothing else, so
+                // a field declared as the derived record serialises without the tag the schema on
+                // the other end requires. The base deserialises straight back into the member.
+                const baseTypeName = this.variantMemberBases.get(node.name);
+                if (baseTypeName !== undefined) {
+                    this.note(`"${node.name}" is a member of a variant, so fields referencing it are typed ` +
+                        `as ${baseTypeName} — the discriminator only round-trips through the base`);
+                    return baseTypeName;
+                }
+                // A named alias of a shape that declares no C# type of its own (an `array`, a
+                // `record`, a bare primitive, an `optional`/`nullable` wrapper, another alias)
+                // would otherwise name a type nothing ever writes. Inline the shape it stands for.
+                if (this.declaresNamedType(resolved.schema))
+                    return this.csTypeNameForNamed(node.name);
+                if (this.resolvingRefs.has(node.name)) {
+                    // Only an alias cycle with no declared type anywhere in it gets here
+                    // (`const A = array(B); const B = array(A)`), which has no C# spelling at all.
+                    this.note(`"${node.name}" aliases itself through shapes that declare no type of their ` +
+                        "own; the generated reference to it will not resolve");
                     return this.csTypeNameForNamed(node.name);
                 }
-                // Unknown reference. Best guess: treat as a C# type of the same
-                // stripped name (the author likely knows what they're doing).
-                return stripSchemaSuffix(node.name);
+                this.resolvingRefs.add(node.name);
+                try {
+                    return this.toCsType(resolved.schema, ctx, decls);
+                }
+                finally {
+                    this.resolvingRefs.delete(node.name);
+                }
             }
             case "array": {
                 const inner = this.toCsType(node.inner, ctx, decls);
@@ -388,11 +502,41 @@ class EmitContext {
             return override;
         return stripSchemaSuffix(sourceName);
     }
+    /**
+     * Whether a named schema declares a standalone C# type. Exactly the inverse of the cases
+     * {@link emitNamed} declines to emit anything for, and it has to stay that way: a
+     * reference to a schema that declares nothing has to be replaced by the shape it stands
+     * for, or the generated file names a type nothing writes (CS0246).
+     */
+    declaresNamedType(schema) {
+        switch (schema.kind) {
+            case "object":
+            case "picklist":
+            case "variant":
+                return true;
+            case "union":
+                // A string|string[] union is consumed through the shared helper record, so it
+                // declares nothing of its own. Every other shape emits an enum, a polymorphic base,
+                // or the JsonElement fallback record.
+                return this.classifyUnion(schema.members).kind !== "stringOrList";
+            case "primitive":
+            case "literal":
+            case "array":
+            case "record":
+            case "unknown":
+            case "ref":
+            case "nullable":
+            case "optional":
+                return false;
+        }
+    }
     classifyUnion(members) {
         if (members.length === 0)
             return { kind: "generic" };
-        // All literals → enum.
-        if (members.every((m) => m.kind === "literal")) {
+        // All string literals → enum. Number and boolean literals have no enum
+        // member name to carry them, so a mixed union falls through to the
+        // discriminated/generic checks below rather than emitting a bogus enum.
+        if (members.every((m) => m.kind === "literal" && typeof m.value === "string")) {
             return {
                 kind: "enum",
                 values: members.map((m) => m.value),
@@ -433,19 +577,37 @@ class EmitContext {
         }
         return { kind: "generic" };
     }
-    /** Resolve the members argument of a `variant(...)` (or synthesised from a union). */
-    resolveVariantMembers(members) {
+    /**
+     * Resolve the members argument of a `variant(discriminator, ...)`, or of a union that
+     * classified as discriminated on an inferred one.
+     *
+     * Two members carrying the same tag are an `InvalidOperationException` the moment
+     * `System.Text.Json` builds the polymorphic converter, so the duplicate is dropped and
+     * reported rather than emitted as C# that cannot be constructed.
+     */
+    resolveVariantMembers(members, discriminator) {
         const resolved = [];
+        const tagsSeen = new Map();
         for (const m of members) {
-            const r = this.resolveObjectMember(m);
-            if (r) {
-                resolved.push({
-                    tag: r.tag,
-                    typeName: r.typeName,
-                    schema: r.schema,
-                    sourceName: r.sourceName,
-                });
+            const r = this.resolveObjectMember(m, discriminator);
+            if (!r) {
+                this.note(`${describeMember(m)} of the variant on "${discriminator}" declares no ` +
+                    `literal "${discriminator}" field and was dropped`);
+                continue;
             }
+            const claimedBy = tagsSeen.get(r.tag);
+            if (claimedBy !== undefined) {
+                this.note(`${describeMember(m)} repeats the "${discriminator}" tag "${r.tag}" already ` +
+                    `taken by ${claimedBy}, and was dropped`);
+                continue;
+            }
+            tagsSeen.set(r.tag, r.typeName);
+            resolved.push({
+                tag: r.tag,
+                typeName: r.typeName,
+                schema: r.schema,
+                sourceName: r.sourceName,
+            });
         }
         return resolved;
     }
@@ -453,8 +615,14 @@ class EmitContext {
      * Normalise a union/variant member into { discriminator tag, C# type name,
      * object schema }. Follows refs to named object schemas. Returns null if
      * the member doesn't look like `object({ type: literal('X'), ... })`.
+     *
+     * `declaredDiscriminator` is the field name a `variant(...)` states outright, and it is
+     * taken at its word: guessing a tag from any string literal on the member instead means a
+     * shared envelope's own `type: literal('envelope')` becomes the tag for every member of a
+     * `variant('op', ...)`, which is a duplicate `[JsonDerivedType]` value and an `op` key
+     * that never reaches the wire. Only a bare `union([...])`, which declares nothing, infers.
      */
-    resolveObjectMember(node) {
+    resolveObjectMember(node, declaredDiscriminator) {
         let obj = null;
         let sourceName;
         if (node.kind === "object") {
@@ -469,26 +637,12 @@ class EmitContext {
         }
         if (!obj)
             return null;
-        // Find a field whose schema is a literal. Any field will do, but we
-        // prefer `type`.
-        let discField = null;
-        for (const f of obj.fields) {
-            if (f.schema.kind === "literal" && f.name === "type") {
-                discField = f;
-                break;
-            }
-        }
-        if (!discField) {
-            for (const f of obj.fields) {
-                if (f.schema.kind === "literal") {
-                    discField = f;
-                    break;
-                }
-            }
-        }
+        const discField = declaredDiscriminator === undefined
+            ? inferTagField(obj)
+            : (obj.fields.find((f) => f.name === declaredDiscriminator && isTagField(f)) ?? null);
         if (!discField || discField.schema.kind !== "literal")
             return null;
-        const tag = discField.schema.value;
+        const tag = String(discField.schema.value);
         const typeName = sourceName
             ? stripSchemaSuffix(sourceName)
             : this.freshTypeName(toPascalCase(tag));
@@ -523,51 +677,12 @@ class EmitContext {
         }
         return false;
     }
+    /** Append the hand-written `StringOrStringList` helper, once per module that reaches for it. */
     emitStringOrStringList() {
         if (this.emittedTypeNames.has("StringOrStringList"))
             return;
         this.emittedTypeNames.add("StringOrStringList");
-        const body = `[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();
-    }
-}`;
-        this.typeDecls.push(body);
+        this.typeDecls.push(STRING_OR_STRING_LIST_SOURCE);
     }
 }
 //# sourceMappingURL=emitter.js.map