From 931c6afc42e5e507bd8aa4d3b8adf0e924b5fe99 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Noblot <noblot.jb@gmail.com>
Date: Sat, 13 May 2023 21:08:54 +0200
Subject: [PATCH 01/63] improve typings for TS with array

---
 .../src/attributes/Constraints.ts             | 47 +++++++++++++++++++
 .../src/input/JSONSchemaInput.ts              | 25 +++++++---
 .../src/language/TypeScriptFlow.ts            | 10 +++-
 .../src/language/TypeScriptZod.ts             | 15 +++++-
 4 files changed, 88 insertions(+), 9 deletions(-)

diff --git a/packages/quicktype-core/src/attributes/Constraints.ts b/packages/quicktype-core/src/attributes/Constraints.ts
index a0370f4ccf..bfabb143b4 100644
--- a/packages/quicktype-core/src/attributes/Constraints.ts
+++ b/packages/quicktype-core/src/attributes/Constraints.ts
@@ -110,6 +110,21 @@ export const minMaxLengthTypeAttributeKind: TypeAttributeKind<MinMaxConstraint>
     "maxLength"
 );
 
+export const minMaxItemsTypeAttributeKind: TypeAttributeKind<MinMaxConstraint> = new MinMaxConstraintTypeAttributeKind(
+    "minMaxItems",
+    new Set<TypeKind>(["array"]),
+    "minItems",
+    "maxItems"
+);
+
+
+export const minMaxContainsTypeAttributeKind: TypeAttributeKind<MinMaxConstraint> = new MinMaxConstraintTypeAttributeKind(
+    "minMaxItems",
+    new Set<TypeKind>(["array"]),
+    "minContains",
+    "maxContains"
+);
+
 function producer(schema: JSONSchema, minProperty: string, maxProperty: string): MinMaxConstraint | undefined {
     if (!(typeof schema === "object")) return undefined;
 
@@ -151,6 +166,30 @@ export function minMaxLengthAttributeProducer(
     return { forString: minMaxLengthTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
 }
 
+export function minMaxItemsAttributeProducer(
+    schema: JSONSchema,
+    _ref: Ref,
+    types: Set<JSONSchemaType>
+): JSONSchemaAttributes | undefined {
+    if (!types.has("array")) return undefined;
+
+    const maybeMinMaxLength = producer(schema, "minItems", "maxItems");
+    if (maybeMinMaxLength === undefined) return undefined;
+    return { forArray: minMaxItemsTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
+}
+
+export function minMaxContainsAttributeProducer(
+    schema: JSONSchema,
+    _ref: Ref,
+    types: Set<JSONSchemaType>
+): JSONSchemaAttributes | undefined {
+    if (!types.has("array")) return undefined;
+
+    const maybeMinMaxLength = producer(schema, "minContains", "maxContains");
+    if (maybeMinMaxLength === undefined) return undefined;
+    return { forArray: minMaxContainsTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
+}
+
 export function minMaxValueForType(t: Type): MinMaxConstraint | undefined {
     return minMaxTypeAttributeKind.tryGetInAttributes(t.getAttributes());
 }
@@ -159,6 +198,14 @@ export function minMaxLengthForType(t: Type): MinMaxConstraint | undefined {
     return minMaxLengthTypeAttributeKind.tryGetInAttributes(t.getAttributes());
 }
 
+export function minMaxItemsForType(t: Type): MinMaxConstraint | undefined {
+    return minMaxItemsTypeAttributeKind.tryGetInAttributes(t.getAttributes());
+}
+
+export function minMaxContainsForType(t: Type): MinMaxConstraint | undefined {
+    return minMaxContainsTypeAttributeKind.tryGetInAttributes(t.getAttributes());
+}
+
 export class PatternTypeAttributeKind extends TypeAttributeKind<string> {
     constructor() {
         super("pattern");
diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index 61cb97e316..13112e12e1 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -49,6 +49,8 @@ import { accessorNamesAttributeProducer } from "../attributes/AccessorNames";
 import { enumValuesAttributeProducer } from "../attributes/EnumValues";
 import { minMaxAttributeProducer } from "../attributes/Constraints";
 import { minMaxLengthAttributeProducer } from "../attributes/Constraints";
+import { minMaxItemsAttributeProducer } from "../attributes/Constraints";
+import { minMaxContainsAttributeProducer } from "../attributes/Constraints";
 import { patternAttributeProducer } from "../attributes/Constraints";
 import { uriSchemaAttributesProducer } from "../attributes/URIAttributes";
 
@@ -494,6 +496,7 @@ export type JSONSchemaAttributes = {
     forObject?: TypeAttributes;
     forNumber?: TypeAttributes;
     forString?: TypeAttributes;
+    forArray?: TypeAttributes;
     forCases?: TypeAttributes[];
 };
 export type JSONSchemaAttributeProducer = (
@@ -779,26 +782,27 @@ async function addTypesInSchema(
             }
         }
 
-        async function makeArrayType(): Promise<TypeRef> {
+        async function makeArrayType(attributes: TypeAttributes): Promise<TypeRef> {
             const singularAttributes = singularizeTypeNames(typeAttributes);
+            
             const items = schema.items;
             let itemType: TypeRef;
             if (Array.isArray(items)) {
                 const itemsLoc = loc.push("items");
                 const itemTypes = await arrayMapSync(items, async (item, i) => {
                     const itemLoc = itemsLoc.push(i.toString());
-                    return await toType(checkJSONSchema(item, itemLoc.canonicalRef), itemLoc, singularAttributes);
+                    return await toType(checkJSONSchema(item, itemLoc.canonicalRef), itemLoc, attributes);
                 });
-                itemType = typeBuilder.getUnionType(emptyTypeAttributes, new Set(itemTypes));
+                itemType = typeBuilder.getUnionType(attributes, new Set(itemTypes));
             } else if (typeof items === "object") {
                 const itemsLoc = loc.push("items");
-                itemType = await toType(checkJSONSchema(items, itemsLoc.canonicalRef), itemsLoc, singularAttributes);
+                itemType = await toType(checkJSONSchema(items, itemsLoc.canonicalRef), itemsLoc, attributes);
             } else if (items !== undefined) {
                 return messageError("SchemaArrayItemsMustBeStringOrArray", withRef(loc, { actual: items }));
             } else {
                 itemType = typeBuilder.getPrimitiveType("any");
             }
-            typeBuilder.addAttributes(itemType, singularAttributes);
+            typeBuilder.addAttributes(itemType, attributes);
             return typeBuilder.getArrayType(emptyTypeAttributes, itemType);
         }
 
@@ -931,7 +935,7 @@ async function addTypesInSchema(
             }
 
             const stringAttributes = combineTypeAttributes(
-                "union",
+                "union", 
                 inferredAttributes,
                 combineProducedAttributes(({ forString }) => forString)
             );
@@ -944,7 +948,12 @@ async function addTypesInSchema(
             }
 
             if (includeArray) {
-                unionTypes.push(await makeArrayType());
+                const arrayAttributes = combineTypeAttributes(
+                    "union",
+                    inferredAttributes,
+                    combineProducedAttributes(({ forArray }) => forArray)
+                );
+                unionTypes.push(await makeArrayType(arrayAttributes));
             }
             if (includeObject) {
                 unionTypes.push(await makeObjectType());
@@ -1124,6 +1133,8 @@ export class JSONSchemaInput implements Input<JSONSchemaSourceData> {
             uriSchemaAttributesProducer,
             minMaxAttributeProducer,
             minMaxLengthAttributeProducer,
+            minMaxItemsAttributeProducer,
+            minMaxContainsAttributeProducer,
             patternAttributeProducer
         ].concat(additionalAttributeProducers);
     }
diff --git a/packages/quicktype-core/src/language/TypeScriptFlow.ts b/packages/quicktype-core/src/language/TypeScriptFlow.ts
index 6f0b725d69..3f9a0185f9 100644
--- a/packages/quicktype-core/src/language/TypeScriptFlow.ts
+++ b/packages/quicktype-core/src/language/TypeScriptFlow.ts
@@ -16,6 +16,7 @@ import { defined, panic } from "../support/Support";
 import { TargetLanguage } from "../TargetLanguage";
 import { RenderContext } from "../Renderer";
 import { isES3IdentifierStart } from "./JavaScriptUnicodeMaps";
+import { minMaxItemsForType } from "../attributes/Constraints";
 
 export const tsFlowOptions = Object.assign({}, javaScriptOptions, {
     justTypes: new BooleanOption("just-types", "Interfaces only", false),
@@ -121,12 +122,19 @@ export abstract class TypeScriptFlowBaseRenderer extends JavaScriptRenderer {
             _stringType => singleWord("string"),
             arrayType => {
                 const itemType = this.sourceFor(arrayType.items);
+                const minMaxItems = minMaxItemsForType(arrayType.items);
                 if (
                     (arrayType.items instanceof UnionType && !this._tsFlowOptions.declareUnions) ||
                     arrayType.items instanceof ArrayType
                 ) {
-                    return singleWord(["Array<", itemType.source, ">"]);
+                    if (minMaxItems?.[0] && minMaxItems[0] > 0) {
+                        return singleWord(["[", itemType.source, ", ...", itemType.source ,"[]]"]);
+                    }
+                    return singleWord(["ArrayT<", itemType.source, ">"]);
                 } else {
+                    if (minMaxItems?.[0] && minMaxItems[0] > 0) {
+                        return singleWord(["[",parenIfNeeded(itemType) ,", ...", parenIfNeeded(itemType),"[]]"]);
+                    }
                     return singleWord([parenIfNeeded(itemType), "[]"]);
                 }
             },
diff --git a/packages/quicktype-core/src/language/TypeScriptZod.ts b/packages/quicktype-core/src/language/TypeScriptZod.ts
index 4d4d769e82..24dfb0c343 100644
--- a/packages/quicktype-core/src/language/TypeScriptZod.ts
+++ b/packages/quicktype-core/src/language/TypeScriptZod.ts
@@ -20,6 +20,7 @@ import { legalizeName } from "./JavaScript";
 import { Sourcelike } from "../Source";
 import { panic } from "../support/Support";
 import { ConvenienceRenderer } from "../ConvenienceRenderer";
+import { minMaxItemsForType } from "../attributes/Constraints";
 
 export const typeScriptZodOptions = {
     justSchema: new BooleanOption("just-schema", "Schema only", false)
@@ -121,7 +122,19 @@ export class TypeScriptZodRenderer extends ConvenienceRenderer {
             _integerType => "z.number()",
             _doubleType => "z.number()",
             _stringType => "z.string()",
-            arrayType => ["z.array(", this.typeMapTypeFor(arrayType.items, false), ")"],
+            arrayType => {
+                const minMaxItems = minMaxItemsForType(arrayType.items);
+                console.log('minMax', minMaxItems);
+
+                const arrayString = ["z.array(", this.typeMapTypeFor(arrayType.items, false), ")"]
+                if (minMaxItems?.[0]) {
+                    arrayString.push('.min(', minMaxItems[0].toString(10) , ')');
+                }
+                if (minMaxItems?.[1]) {
+                    arrayString.push('.max(', minMaxItems[1].toString(10) , ')');
+                }
+                return arrayString;
+            },
             _classType => panic("Should already be handled."),
             _mapType => ["z.record(z.string(), ", this.typeMapTypeFor(_mapType.values, false), ")"],
             _enumType => panic("Should already be handled."),

From a60d0b20b1f834f0b509bcde85dc48d6c57c0dd0 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Noblot <noblot.jb@gmail.com>
Date: Wed, 17 May 2023 21:23:34 +0200
Subject: [PATCH 02/63] rm some error

---
 packages/quicktype-core/src/input/JSONSchemaInput.ts  | 6 ++----
 packages/quicktype-core/src/language/TypeScriptZod.ts | 3 +--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index 13112e12e1..f6dc4d17da 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -546,7 +546,7 @@ class Resolver {
             assert(canonical.hasAddress, "Canonical ref can't be resolved without an address");
             const address = canonical.address;
 
-            let schema =
+            const schema =
                 canonical.addressURI === undefined
                     ? undefined
                     : await this._store.get(address, this._ctx.debugPrintSchemaResolving);
@@ -615,7 +615,7 @@ async function addTypesInSchema(
     references: ReadonlyMap<string, Ref>,
     attributeProducers: JSONSchemaAttributeProducer[]
 ): Promise<void> {
-    let typeForCanonicalRef = new EqualityMap<Ref, TypeRef>();
+    const typeForCanonicalRef = new EqualityMap<Ref, TypeRef>();
 
     function setTypeForLocation(loc: Location, t: TypeRef): void {
         const maybeRef = typeForCanonicalRef.get(loc.canonicalRef);
@@ -783,8 +783,6 @@ async function addTypesInSchema(
         }
 
         async function makeArrayType(attributes: TypeAttributes): Promise<TypeRef> {
-            const singularAttributes = singularizeTypeNames(typeAttributes);
-            
             const items = schema.items;
             let itemType: TypeRef;
             if (Array.isArray(items)) {
diff --git a/packages/quicktype-core/src/language/TypeScriptZod.ts b/packages/quicktype-core/src/language/TypeScriptZod.ts
index 24dfb0c343..aface9103d 100644
--- a/packages/quicktype-core/src/language/TypeScriptZod.ts
+++ b/packages/quicktype-core/src/language/TypeScriptZod.ts
@@ -124,8 +124,7 @@ export class TypeScriptZodRenderer extends ConvenienceRenderer {
             _stringType => "z.string()",
             arrayType => {
                 const minMaxItems = minMaxItemsForType(arrayType.items);
-                console.log('minMax', minMaxItems);
-
+                
                 const arrayString = ["z.array(", this.typeMapTypeFor(arrayType.items, false), ")"]
                 if (minMaxItems?.[0]) {
                     arrayString.push('.min(', minMaxItems[0].toString(10) , ')');

From 3820de49bfb0e14692bec5e7f58945a98a86b8be Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Noblot <noblot.jb@gmail.com>
Date: Sun, 21 May 2023 14:56:14 +0200
Subject: [PATCH 03/63] fix add typo ArrayT in TypesScriptFlow

---
 packages/quicktype-core/src/language/TypeScriptFlow.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/TypeScriptFlow.ts b/packages/quicktype-core/src/language/TypeScriptFlow.ts
index 3f9a0185f9..05fdb30170 100644
--- a/packages/quicktype-core/src/language/TypeScriptFlow.ts
+++ b/packages/quicktype-core/src/language/TypeScriptFlow.ts
@@ -130,7 +130,7 @@ export abstract class TypeScriptFlowBaseRenderer extends JavaScriptRenderer {
                     if (minMaxItems?.[0] && minMaxItems[0] > 0) {
                         return singleWord(["[", itemType.source, ", ...", itemType.source ,"[]]"]);
                     }
-                    return singleWord(["ArrayT<", itemType.source, ">"]);
+                    return singleWord(["Array<", itemType.source, ">"]);
                 } else {
                     if (minMaxItems?.[0] && minMaxItems[0] > 0) {
                         return singleWord(["[",parenIfNeeded(itemType) ,", ...", parenIfNeeded(itemType),"[]]"]);

From d7943816116a2721c78d6b262df5c94345773d3c Mon Sep 17 00:00:00 2001
From: "jonas.hao" <imkoche@gmail.com>
Date: Mon, 23 Jun 2025 23:34:03 +0800
Subject: [PATCH 04/63] feat(Rust): Add integer type inference option

1. Added IntegerType enum
2. Introduced integerType configuration option
 - Supports forced i32/i64 usage
 - Enables automatic selection based on numerical range
---
 .../src/language/Rust/RustRenderer.ts         | 31 ++++++++++++-
 .../src/language/Rust/language.ts             | 16 +++++++
 test/inputs/schema/integer-type.1.json        |  8 ++++
 test/inputs/schema/integer-type.schema        | 43 +++++++++++++++++++
 test/languages.ts                             |  5 +++
 5 files changed, 102 insertions(+), 1 deletion(-)
 create mode 100644 test/inputs/schema/integer-type.1.json
 create mode 100644 test/inputs/schema/integer-type.schema

diff --git a/packages/quicktype-core/src/language/Rust/RustRenderer.ts b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
index 22e81babca..052a4a6a1c 100644
--- a/packages/quicktype-core/src/language/Rust/RustRenderer.ts
+++ b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
@@ -27,8 +27,10 @@ import {
     removeNullFromUnion,
 } from "../../Type/TypeUtils";
 
+import { minMaxValueForType } from "../../attributes/Constraints";
 import { keywords } from "./constants";
 import type { rustOptions } from "./language";
+import { IntegerType } from "./language";
 import {
     Density,
     type NamingStyleKey,
@@ -96,6 +98,33 @@ export class RustRenderer extends ConvenienceRenderer {
         return "/// ";
     }
 
+    private getIntegerType(integerType: Type): string {
+        switch (this._options.integerType) {
+            case IntegerType.ForceI32:
+                return "i32";
+            case IntegerType.ForceI64:
+                return "i64";
+            case IntegerType.Conservative:
+            default: {
+                const minMax = minMaxValueForType(integerType);
+                if (minMax !== undefined) {
+                    const [min, max] = minMax;
+                    // Check if values fit in i32 range: [-2147483648, 2147483647]
+                    const i32Min = -2147483648;
+                    const i32Max = 2147483647;
+                    
+                    if (
+                        (min === undefined || min >= i32Min) &&
+                        (max === undefined || max <= i32Max)
+                    ) {
+                        return "i32";
+                    }
+                }
+                return "i64";
+            }
+        }
+    }
+
     private nullableRustType(t: Type, withIssues: boolean): Sourcelike {
         return ["Option<", this.breakCycle(t, withIssues), ">"];
     }
@@ -121,7 +150,7 @@ export class RustRenderer extends ConvenienceRenderer {
                     "Option<serde_json::Value>",
                 ),
             (_boolType) => "bool",
-            (_integerType) => "i64",
+            (integerType) => this.getIntegerType(integerType),
             (_doubleType) => "f64",
             (_stringType) => "String",
             (arrayType) => [
diff --git a/packages/quicktype-core/src/language/Rust/language.ts b/packages/quicktype-core/src/language/Rust/language.ts
index 4981d6a6f8..60abb790e4 100644
--- a/packages/quicktype-core/src/language/Rust/language.ts
+++ b/packages/quicktype-core/src/language/Rust/language.ts
@@ -10,6 +10,12 @@ import type { LanguageName, RendererOptions } from "../../types";
 import { RustRenderer } from "./RustRenderer";
 import { Density, Visibility } from "./utils";
 
+export enum IntegerType {
+    Conservative = "conservative",
+    ForceI32 = "force-i32",
+    ForceI64 = "force-i64",
+}
+
 export const rustOptions = {
     density: new EnumOption(
         "density",
@@ -30,6 +36,16 @@ export const rustOptions = {
         } as const,
         "private",
     ),
+    integerType: new EnumOption(
+        "integer-type",
+        "Integer type inference",
+        {
+            conservative: IntegerType.Conservative,
+            "force-i32": IntegerType.ForceI32,
+            "force-i64": IntegerType.ForceI64,
+        } as const,
+        "conservative",
+    ),
     deriveDebug: new BooleanOption("derive-debug", "Derive Debug impl", false),
     deriveClone: new BooleanOption("derive-clone", "Derive Clone impl", false),
     derivePartialEq: new BooleanOption(
diff --git a/test/inputs/schema/integer-type.1.json b/test/inputs/schema/integer-type.1.json
new file mode 100644
index 0000000000..eb9b681430
--- /dev/null
+++ b/test/inputs/schema/integer-type.1.json
@@ -0,0 +1,8 @@
+{
+  "small_positive": 50,
+  "large_positive": 2500000000,
+  "small_negative": -50,
+  "large_negative": -2500000000,
+  "i32_range": 1000000000,
+  "beyond_i32": 9000000000000000000
+}
diff --git a/test/inputs/schema/integer-type.schema b/test/inputs/schema/integer-type.schema
new file mode 100644
index 0000000000..b096a3443d
--- /dev/null
+++ b/test/inputs/schema/integer-type.schema
@@ -0,0 +1,43 @@
+{
+  "type": "object",
+  "properties": {
+    "small_positive": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100
+    },
+    "large_positive": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 5000000000
+    },
+    "small_negative": {
+      "type": "integer",
+      "minimum": -100,
+      "maximum": 0
+    },
+    "large_negative": {
+      "type": "integer",
+      "minimum": -5000000000,
+      "maximum": 0
+    },
+    "i32_range": {
+      "type": "integer",
+      "minimum": -2147483648,
+      "maximum": 2147483647
+    },
+    "beyond_i32": {
+      "type": "integer",
+      "minimum": -9223372036854775808,
+      "maximum": 9223372036854775807
+    }
+  },
+  "required": [
+    "small_positive",
+    "large_positive",
+    "small_negative",
+    "large_negative",
+    "i32_range",
+    "beyond_i32"
+  ]
+}
diff --git a/test/languages.ts b/test/languages.ts
index 9573f3e574..ee795909f0 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -260,6 +260,9 @@ export const RustLanguage: Language = {
         { visibility: "crate" },
         { visibility: "private" },
         { visibility: "public" },
+        { "integer-type": "conservative" },
+        { "integer-type": "force-i32" },
+        { "integer-type": "force-i64" },
     ],
     sourceFiles: ["src/language/Rust/index.ts"],
 };
@@ -584,6 +587,8 @@ export const CPlusPlusLanguage: Language = {
     skipSchema: [
         // uses too much memory
         "keyword-unions.schema",
+        // seems like a problem with integer range check
+        "integer-type.schema",
     ],
     rendererOptions: {},
     quickTestRendererOptions: [

From af0c9ff51cb5e60bc12e372838a214e38479d6bc Mon Sep 17 00:00:00 2001
From: haya14busa <haya14busa@gmail.com>
Date: Sat, 5 Jul 2025 22:24:21 +0900
Subject: [PATCH 05/63] feat: Add support for unevaluatedProperties in JSON
 Schema

Add support for the unevaluatedProperties keyword from JSON Schema draft 2019-09/2020-12.
When additionalProperties is not defined, unevaluatedProperties is now used as a fallback
to determine the type of additional properties in an object.

This fixes issues where objects using unevaluatedProperties would generate incorrect
types (e.g., map[string]interface{} instead of properly typed maps in Go).
---
 .../src/input/JSONSchemaInput.ts              |  5 ++
 .../schema/unevaluated-properties.1.json      | 14 ++++++
 .../schema/unevaluated-properties.2.json      | 19 ++++++++
 .../schema/unevaluated-properties.schema      | 46 +++++++++++++++++++
 4 files changed, 84 insertions(+)
 create mode 100644 test/inputs/schema/unevaluated-properties.1.json
 create mode 100644 test/inputs/schema/unevaluated-properties.2.json
 create mode 100644 test/inputs/schema/unevaluated-properties.schema

diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index 6907c0e488..0ce3152918 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -1108,6 +1108,11 @@ async function addTypesInSchema(
             ) {
                 additionalProperties = schema.patternProperties[".*"];
             }
+            
+            // Handle unevaluatedProperties if additionalProperties is not defined
+            if (additionalProperties === undefined && schema.unevaluatedProperties !== undefined) {
+                additionalProperties = schema.unevaluatedProperties;
+            }
 
             const objectAttributes = combineTypeAttributes(
                 "union",
diff --git a/test/inputs/schema/unevaluated-properties.1.json b/test/inputs/schema/unevaluated-properties.1.json
new file mode 100644
index 0000000000..a8e22fbc6a
--- /dev/null
+++ b/test/inputs/schema/unevaluated-properties.1.json
@@ -0,0 +1,14 @@
+{
+    "config": {
+        "name": "test-config",
+        "settings": {
+            "option1": [
+                {"key": "foo", "value": "bar"},
+                {"key": "baz", "value": "qux"}
+            ],
+            "option2": [
+                {"key": "hello", "value": "world"}
+            ]
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/inputs/schema/unevaluated-properties.2.json b/test/inputs/schema/unevaluated-properties.2.json
new file mode 100644
index 0000000000..a739f3e56c
--- /dev/null
+++ b/test/inputs/schema/unevaluated-properties.2.json
@@ -0,0 +1,19 @@
+{
+    "config": {
+        "name": "multiple-versions",
+        "settings": {
+            "v1.0.0": [
+                {"key": "checksum1", "value": "abc123"},
+                {"key": "checksum2", "value": "def456"}
+            ],
+            "v1.1.0": [
+                {"key": "checksum1", "value": "ghi789"}
+            ],
+            "latest": [
+                {"key": "checksum1", "value": "jkl012"},
+                {"key": "checksum2", "value": "mno345"},
+                {"key": "checksum3", "value": "pqr678"}
+            ]
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/inputs/schema/unevaluated-properties.schema b/test/inputs/schema/unevaluated-properties.schema
new file mode 100644
index 0000000000..1e1382a192
--- /dev/null
+++ b/test/inputs/schema/unevaluated-properties.schema
@@ -0,0 +1,46 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "unevaluated-properties.schema",
+    "title": "Test unevaluatedProperties support",
+    "type": "object",
+    "properties": {
+        "config": {
+            "$ref": "#/$defs/Config"
+        }
+    },
+    "$defs": {
+        "Config": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "settings": {
+                    "$ref": "#/$defs/Settings"
+                }
+            }
+        },
+        "Settings": {
+            "type": "object",
+            "properties": {},
+            "unevaluatedProperties": {
+                "type": "array",
+                "items": {
+                    "$ref": "#/$defs/Item"
+                }
+            }
+        },
+        "Item": {
+            "type": "object",
+            "properties": {
+                "key": {
+                    "type": "string"
+                },
+                "value": {
+                    "type": "string"
+                }
+            },
+            "required": ["key", "value"]
+        }
+    }
+}
\ No newline at end of file

From 8493ff4ccad0acad000c0c5ea9baf713d21ef2b3 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:47:26 -0400
Subject: [PATCH 06/63] feat(kotlin)!: default framework is now jackson

Klaxon has been unmaintained since ~2022 and our own fixture skip-lists
cite its open bugs; the Jackson renderer is feature-complete and fully
CI-covered. The kotlin/schema-kotlin fixtures now pin framework=klaxon
explicitly so the Klaxon renderer keeps end-to-end coverage
(kotlin-jackson and kotlinx fixtures cover the other frameworks).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/Kotlin/language.ts | 2 +-
 test/languages.ts                                       | 4 +++-
 test/unit/just-types-option.test.ts                     | 4 ++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/packages/quicktype-core/src/language/Kotlin/language.ts b/packages/quicktype-core/src/language/Kotlin/language.ts
index 28adca237c..528d00dd6b 100644
--- a/packages/quicktype-core/src/language/Kotlin/language.ts
+++ b/packages/quicktype-core/src/language/Kotlin/language.ts
@@ -33,7 +33,7 @@ export const kotlinOptions = {
             klaxon: "Klaxon",
             kotlinx: "KotlinX",
         } as const,
-        "klaxon",
+        "jackson",
     ),
     acronymStyle: acronymOption(AcronymStyleOptions.Pascal),
     packageName: new StringOption("package", "Package", "PACKAGE", "quicktype"),
diff --git a/test/languages.ts b/test/languages.ts
index b64b21cfca..a94a0d0cff 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1278,7 +1278,9 @@ export const KotlinLanguage: Language = {
         "recursive-union-flattening.schema",
     ],
     skipMiscJSON: false,
-    rendererOptions: {},
+    // The default framework is jackson; this fixture deliberately pins
+    // klaxon so the Klaxon renderer keeps end-to-end coverage.
+    rendererOptions: { framework: "klaxon" },
     quickTestRendererOptions: [],
     sourceFiles: ["src/language/Kotlin/index.ts"],
 };
diff --git a/test/unit/just-types-option.test.ts b/test/unit/just-types-option.test.ts
index 8ae56e317a..4d3e31766a 100644
--- a/test/unit/just-types-option.test.ts
+++ b/test/unit/just-types-option.test.ts
@@ -131,8 +131,8 @@ describe("framework defaults", () => {
         expect(output).toContain("io.circe");
     });
 
-    test("Kotlin defaults to Klaxon", async () => {
+    test("Kotlin defaults to Jackson", async () => {
         const output = await linesFor("kotlin");
-        expect(output).toContain("com.beust.klaxon");
+        expect(output).toContain("com.fasterxml.jackson");
     });
 });

From fa3eb91bda545da8c63f03a65d4f4d612617eda3 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:47:55 -0400
Subject: [PATCH 07/63] feat(csharp)!: default framework is now SystemTextJson

System.Text.Json is the built-in, Microsoft-recommended serializer;
Newtonsoft.Json is in maintenance mode. The csharp, schema-csharp,
schema-json-csharp, and graphql-csharp fixtures now pin
framework=NewtonSoft explicitly so the Newtonsoft renderer keeps its
end-to-end coverage (the SystemTextJson fixtures already exist).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/CSharp/language.ts | 2 +-
 test/languages.ts                                       | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/quicktype-core/src/language/CSharp/language.ts b/packages/quicktype-core/src/language/CSharp/language.ts
index 0b0c7235f5..2115aac3e8 100644
--- a/packages/quicktype-core/src/language/CSharp/language.ts
+++ b/packages/quicktype-core/src/language/CSharp/language.ts
@@ -35,7 +35,7 @@ export const cSharpOptions = {
             NewtonSoft: "NewtonSoft",
             SystemTextJson: "SystemTextJson",
         } as const,
-        "NewtonSoft",
+        "SystemTextJson",
     ),
     useList: new EnumOption(
         "array-type",
diff --git a/test/languages.ts b/test/languages.ts
index a94a0d0cff..6d11b24445 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -114,7 +114,9 @@ export const CSharpLanguage: Language = {
     skipSchema: [
         "top-level-enum.schema", // The code we generate for top-level enums is incompatible with the driver
     ],
-    rendererOptions: { "check-required": "true" },
+    // The default framework is SystemTextJson; this fixture deliberately
+    // pins NewtonSoft so the Newtonsoft renderer keeps end-to-end coverage.
+    rendererOptions: { "check-required": "true", framework: "NewtonSoft" },
     quickTestRendererOptions: [
         { "array-type": "list" },
         { "csharp-version": "5" },

From e2d5790cc8fbe685e36225e9497fddb044803fa1 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:48:19 -0400
Subject: [PATCH 08/63] feat(cplusplus)!: boost is now off by default

C++17 std::optional/std::variant have been universally available since
~2018; requiring Boost by default is a legacy accommodation. CI already
compiles the fixture at -std=c++17. The quicktest options now exercise
boost=true so the Boost code path keeps coverage.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/CPlusPlus/language.ts | 2 +-
 test/languages.ts                                          | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/quicktype-core/src/language/CPlusPlus/language.ts b/packages/quicktype-core/src/language/CPlusPlus/language.ts
index e614e7ec9e..cca4dd10be 100644
--- a/packages/quicktype-core/src/language/CPlusPlus/language.ts
+++ b/packages/quicktype-core/src/language/CPlusPlus/language.ts
@@ -104,7 +104,7 @@ export const cPlusPlusOptions = {
     boost: new BooleanOption(
         "boost",
         "Require a dependency on boost. Without boost, C++17 is required",
-        true,
+        false,
     ),
     hideNullOptional: new BooleanOption(
         "hide-null-optional",
diff --git a/test/languages.ts b/test/languages.ts
index 6d11b24445..2a1dd4a6fe 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -721,7 +721,9 @@ export const CPlusPlusLanguage: Language = {
         { "code-format": "with-struct" },
         { wstring: "use-wstring" },
         { "const-style": "east-const" },
-        { boost: "false" },
+        // The default is boost=false (C++17); this keeps the boost code
+        // path covered.
+        { boost: "true" },
     ],
     sourceFiles: ["src/language/CPlusPlus/index.ts"],
 };

From 4e65b12c4ab54b2569610c878d4e46844d197fd6 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:49:10 -0400
Subject: [PATCH 09/63] feat(rust)!: public fields and Debug/Clone derives by
 default; remove edition-2018

- visibility now defaults to public: private fields on generated structs
  can neither be constructed nor read by consumers, and every modern
  Rust codegen emits pub fields.
- derive-debug and derive-clone now default to true, per the Rust API
  guidelines (C-COMMON-TRAITS); all emitted field types are Clone, so
  this always compiles.
- The vestigial edition-2018 option is deleted: it only toggled between
  'use serde::...' and the pre-2018 'extern crate serde_derive;' prelude.
  The 2018+ form is now unconditional. Passing --edition-2018 is an
  error now (breaking).

A quicktest combo pins the old defaults (visibility=private, no
derives) so the legacy output shape keeps fixture coverage.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../quicktype-core/src/language/Rust/RustRenderer.ts     | 6 +-----
 packages/quicktype-core/src/language/Rust/language.ts    | 7 +++----
 test/languages.ts                                        | 9 +++++++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/quicktype-core/src/language/Rust/RustRenderer.ts b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
index c342f0141d..3024d97d5b 100644
--- a/packages/quicktype-core/src/language/Rust/RustRenderer.ts
+++ b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
@@ -376,11 +376,7 @@ export class RustRenderer extends ConvenienceRenderer {
         }
 
         this.ensureBlankLine();
-        if (this._options.edition2018) {
-            this.emitLine("use serde::{Serialize, Deserialize};");
-        } else {
-            this.emitLine("extern crate serde_derive;");
-        }
+        this.emitLine("use serde::{Serialize, Deserialize};");
 
         if (this.haveMaps) {
             this.emitLine("use std::collections::HashMap;");
diff --git a/packages/quicktype-core/src/language/Rust/language.ts b/packages/quicktype-core/src/language/Rust/language.ts
index 29030a4994..692980468a 100644
--- a/packages/quicktype-core/src/language/Rust/language.ts
+++ b/packages/quicktype-core/src/language/Rust/language.ts
@@ -28,10 +28,10 @@ export const rustOptions = {
             crate: Visibility.Crate,
             public: Visibility.Public,
         } as const,
-        "private",
+        "public",
     ),
-    deriveDebug: new BooleanOption("derive-debug", "Derive Debug impl", false),
-    deriveClone: new BooleanOption("derive-clone", "Derive Clone impl", false),
+    deriveDebug: new BooleanOption("derive-debug", "Derive Debug impl", true),
+    deriveClone: new BooleanOption("derive-clone", "Derive Clone impl", true),
     derivePartialEq: new BooleanOption(
         "derive-partial-eq",
         "Derive PartialEq impl",
@@ -42,7 +42,6 @@ export const rustOptions = {
         "Skip serializing empty Option fields",
         false,
     ),
-    edition2018: new BooleanOption("edition-2018", "Edition 2018", true),
     leadingComments: new BooleanOption(
         "leading-comments",
         "Leading Comments",
diff --git a/test/languages.ts b/test/languages.ts
index 2a1dd4a6fe..993b51bb6c 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -305,8 +305,13 @@ export const RustLanguage: Language = {
     quickTestRendererOptions: [
         { density: "dense" },
         { visibility: "crate" },
-        { visibility: "private" },
-        { visibility: "public" },
+        // The pre-flip defaults: private fields without Debug/Clone
+        // derives, kept covered after the defaults changed.
+        {
+            visibility: "private",
+            "derive-debug": "false",
+            "derive-clone": "false",
+        },
     ],
     sourceFiles: ["src/language/Rust/index.ts"],
 };

From 130bd6fe7fcac92fb24bec1850f9cf7676e5de88 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:49:50 -0400
Subject: [PATCH 10/63] feat(typescript)!: prefer-unions is now on by default

The ecosystem has turned on TypeScript enum syntax: Node's default type
stripping and tsc --erasableSyntaxOnly both hard-error on it. Enums now
render as unions of string literals by default; --no-prefer-unions
restores the old output. Runtime typechecking of enum values is
unaffected (the typeMap lists case values either way), so the schema
fixtures' enum fail-samples still fail as required.

Flow always rendered enums as string-literal unions and ignores this
option; its output is unchanged.

quicktests pin prefer-unions=false for typescript (covering the enum
code path) and flow.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../quicktype-core/src/language/TypeScriptFlow/language.ts | 2 +-
 test/languages.ts                                          | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/TypeScriptFlow/language.ts b/packages/quicktype-core/src/language/TypeScriptFlow/language.ts
index d7f0f208ba..78d9b38f0b 100644
--- a/packages/quicktype-core/src/language/TypeScriptFlow/language.ts
+++ b/packages/quicktype-core/src/language/TypeScriptFlow/language.ts
@@ -32,7 +32,7 @@ export const tsFlowOptions = {
     preferUnions: new BooleanOption(
         "prefer-unions",
         "Use union type instead of enum",
-        false,
+        true,
     ),
     preferTypes: new BooleanOption(
         "prefer-types",
diff --git a/test/languages.ts b/test/languages.ts
index 993b51bb6c..7e36ecad1a 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -963,6 +963,9 @@ export const TypeScriptLanguage: Language = {
         { "acronym-style": "pascal" },
         { converters: "all-objects" },
         { readonly: "true" },
+        // The default is prefer-unions=true; this keeps the TypeScript
+        // enum code path covered.
+        { "prefer-unions": "false" },
     ],
     sourceFiles: ["src/language/TypeScript/index.ts"],
 };
@@ -1042,6 +1045,10 @@ export const FlowLanguage: Language = {
         { "runtime-typecheck": "false" },
         { "runtime-typecheck-ignore-unknown-properties": "true" },
         { "nice-property-names": "true" },
+        // Flow always renders enums as unions of string literals, so
+        // this only asserts that the flipped default stays a no-op for
+        // Flow output.
+        { "prefer-unions": "false" },
     ],
     sourceFiles: ["src/language/Flow/index.ts"],
 };

From dd015225e201d7be3e9ed995308795b49c244806 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:50:31 -0400
Subject: [PATCH 11/63] feat(java)!: arrays now render as List<T> by default

List<T> is the universal Java DTO idiom (Effective Java, OpenAPI
Generator, jsonschema2pojo); raw arrays fight equals/hashCode and
generics. The quicktest entries for the java, java-datetime-legacy, and
java-lombok fixtures now pin array-type=array so the T[] code path
keeps coverage.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/Java/language.ts | 2 +-
 test/languages.ts                                     | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/packages/quicktype-core/src/language/Java/language.ts b/packages/quicktype-core/src/language/Java/language.ts
index fac9e16b87..87d5166219 100644
--- a/packages/quicktype-core/src/language/Java/language.ts
+++ b/packages/quicktype-core/src/language/Java/language.ts
@@ -22,7 +22,7 @@ export const javaOptions = {
         "array-type",
         "Use T[] or List<T>",
         { array: false, list: true } as const,
-        "array",
+        "list",
     ),
     justTypes: new BooleanOption("just-types", "Plain types only", false),
     dateTimeProvider: new EnumOption(
diff --git a/test/languages.ts b/test/languages.ts
index 7e36ecad1a..c16cd17993 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -200,7 +200,9 @@ export const JavaLanguage: Language = {
     skipMiscJSON: false,
     skipSchema: ["keyword-unions.schema"], // generates classes with names that are case-insensitively equal
     rendererOptions: {},
-    quickTestRendererOptions: [{ "array-type": "list" }],
+    // The default is array-type=list; this keeps the T[] code path
+    // covered.
+    quickTestRendererOptions: [{ "array-type": "array" }],
     sourceFiles: ["src/language/Java/index.ts"],
 };
 
@@ -217,13 +219,13 @@ export const JavaLanguageWithLegacyDateTime: Language = {
     ],
     skipMiscJSON: true, // Handles edge cases differently and does not allow optional milliseconds.
     rendererOptions: { "datetime-provider": "legacy" },
-    quickTestRendererOptions: [{ "array-type": "list" }],
+    quickTestRendererOptions: [{ "array-type": "array" }],
 };
 
 export const JavaLanguageWithLombok: Language = {
     ...JavaLanguage,
     base: "test/fixtures/java-lombok",
-    quickTestRendererOptions: [{ "array-type": "list", lombok: "true" }],
+    quickTestRendererOptions: [{ "array-type": "array", lombok: "true" }],
 };
 
 export const PythonLanguage: Language = {

From 06f7556a439d0a6837d3feffaf9af1548770b8c0 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:52:31 -0400
Subject: [PATCH 12/63] feat(dart)!: final properties by default; remove
 null-safety option

- final-props now defaults to true: Effective Dart and all current
  data-class idioms (freezed, @immutable culture) use final fields.
  A quicktest pins final-props=false so the mutable-property path
  keeps coverage.
- The null-safety option is deleted: null-safe output is the only
  choice that compiles under Dart 3, so the non-null-safe branches were
  dead weight. Null-safe rendering is now unconditional; passing
  --null-safety/--no-null-safety is an error now (breaking).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/Dart/DartRenderer.ts         | 45 +++++--------------
 .../src/language/Dart/language.ts             |  3 +-
 test/languages.ts                             |  4 +-
 3 files changed, 15 insertions(+), 37 deletions(-)

diff --git a/packages/quicktype-core/src/language/Dart/DartRenderer.ts b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
index f11f77f6f3..8a46bd7577 100644
--- a/packages/quicktype-core/src/language/Dart/DartRenderer.ts
+++ b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
@@ -266,9 +266,7 @@ export class DartRenderer extends ConvenienceRenderer {
     ): Sourcelike {
         const nullable =
             forceNullable ||
-            (this._options.nullSafety &&
-                t.isNullable &&
-                !this._options.requiredProperties);
+            (t.isNullable && !this._options.requiredProperties);
         const withNullable = (s: Sourcelike): Sourcelike =>
             nullable ? [s, "?"] : s;
         return matchType<Sourcelike>(
@@ -321,11 +319,7 @@ export class DartRenderer extends ConvenienceRenderer {
         list: Sourcelike,
         mapper: Sourcelike,
     ): Sourcelike {
-        if (
-            this._options.nullSafety &&
-            isNullable &&
-            !this._options.requiredProperties
-        ) {
+        if (isNullable && !this._options.requiredProperties) {
             return [
                 list,
                 " == null ? [] : ",
@@ -356,11 +350,7 @@ export class DartRenderer extends ConvenienceRenderer {
         map: Sourcelike,
         valueMapper: Sourcelike,
     ): Sourcelike {
-        if (
-            this._options.nullSafety &&
-            isNullable &&
-            !this._options.requiredProperties
-        ) {
+        if (isNullable && !this._options.requiredProperties) {
             return [
                 "Map.from(",
                 map,
@@ -388,11 +378,7 @@ export class DartRenderer extends ConvenienceRenderer {
         classType: ClassType,
         dynamic: Sourcelike,
     ): Sourcelike {
-        if (
-            this._options.nullSafety &&
-            isNullable &&
-            !this._options.requiredProperties
-        ) {
+        if (isNullable && !this._options.requiredProperties) {
             return [
                 dynamic,
                 " == null ? null : ",
@@ -431,10 +417,7 @@ export class DartRenderer extends ConvenienceRenderer {
             (_nullType) => dynamic, // FIXME: check null
             (_boolType) => dynamic,
             (_integerType) => dynamic,
-            (_doubleType) => [
-                dynamic,
-                this._options.nullSafety ? "?.toDouble()" : ".toDouble()",
-            ],
+            (_doubleType) => [dynamic, "?.toDouble()"],
             (_stringType) => dynamic,
             (arrayType) =>
                 this.mapList(
@@ -469,8 +452,7 @@ export class DartRenderer extends ConvenienceRenderer {
                     defined(this._enumValues.get(enumType)),
                     ".map[",
                     dynamic,
-                    this._options.nullSafety &&
-                    (!isNullable || this._options.requiredProperties)
+                    !isNullable || this._options.requiredProperties
                         ? "]!"
                         : "]",
                 ];
@@ -493,8 +475,7 @@ export class DartRenderer extends ConvenienceRenderer {
                     case "date":
                         if (
                             (transformedStringType.isNullable || isNullable) &&
-                            !this._options.requiredProperties &&
-                            this._options.nullSafety
+                            !this._options.requiredProperties
                         ) {
                             return [
                                 dynamic,
@@ -544,7 +525,6 @@ export class DartRenderer extends ConvenienceRenderer {
                 ),
             (_classType) => {
                 if (
-                    this._options.nullSafety &&
                     (_classType.isNullable || isNullable) &&
                     !this._options.requiredProperties
                 ) {
@@ -588,7 +568,6 @@ export class DartRenderer extends ConvenienceRenderer {
                 switch (transformedStringType.kind) {
                     case "date-time":
                         if (
-                            this._options.nullSafety &&
                             !this._options.requiredProperties &&
                             (transformedStringType.isNullable || isNullable)
                         ) {
@@ -598,7 +577,6 @@ export class DartRenderer extends ConvenienceRenderer {
                         return [dynamic, ".toIso8601String()"];
                     case "date":
                         if (
-                            this._options.nullSafety &&
                             !this._options.requiredProperties &&
                             (transformedStringType.isNullable || isNullable)
                         ) {
@@ -642,8 +620,8 @@ export class DartRenderer extends ConvenienceRenderer {
             this.forEachClassProperty(c, "none", (name, _, prop) => {
                 const required =
                     this._options.requiredProperties ||
-                    (this._options.nullSafety &&
-                        (!prop.type.isNullable || !prop.isOptional));
+                    !prop.type.isNullable ||
+                    !prop.isOptional;
                 this.emitLine(required ? "required " : "", "this.", name, ",");
             });
         });
@@ -869,9 +847,8 @@ export class DartRenderer extends ConvenienceRenderer {
 
                                 const required =
                                     this._options.requiredProperties ||
-                                    (this._options.nullSafety &&
-                                        (!prop.type.isNullable ||
-                                            !prop.isOptional));
+                                    !prop.type.isNullable ||
+                                    !prop.isOptional;
                                 if (this._options.useJsonAnnotation) {
                                     this.classPropertyCounter++;
                                     this.emitLine(
diff --git a/packages/quicktype-core/src/language/Dart/language.ts b/packages/quicktype-core/src/language/Dart/language.ts
index f32e85868e..167b061d71 100644
--- a/packages/quicktype-core/src/language/Dart/language.ts
+++ b/packages/quicktype-core/src/language/Dart/language.ts
@@ -15,7 +15,6 @@ import type { LanguageName, RendererOptions } from "../../types.js";
 import { DartRenderer } from "./DartRenderer.js";
 
 export const dartOptions = {
-    nullSafety: new BooleanOption("null-safety", "Null Safety", true),
     justTypes: new BooleanOption("just-types", "Types only", false),
     codersInClass: new BooleanOption(
         "coders-in-class",
@@ -36,7 +35,7 @@ export const dartOptions = {
     finalProperties: new BooleanOption(
         "final-props",
         "Make all properties final",
-        false,
+        true,
     ),
     generateCopyWith: new BooleanOption(
         "copy-with",
diff --git a/test/languages.ts b/test/languages.ts
index c16cd17993..ac2692e2ab 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1584,7 +1584,9 @@ export const DartLanguage: Language = {
     ],
     skipMiscJSON: true,
     rendererOptions: {},
-    quickTestRendererOptions: [],
+    // The default is final-props=true; this keeps the mutable-property
+    // code path covered.
+    quickTestRendererOptions: [{ "final-props": "false" }],
     sourceFiles: ["src/language/Dart/index.ts"],
 };
 

From 120c95872fbad5c83bae3c61a175e8bd3ee2279d Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:53:07 -0400
Subject: [PATCH 13/63] feat(swift)!: density now defaults to normal; remove
 swift-5-support

- density=normal (one property per line, explicit CodingKeys) is what
  swift-format, SwiftFormat, and the Google Swift style guide produce;
  merged declarations read as a codegen quirk. Round-tripping is
  identical. The dense path stays covered by the existing
  density=dense quicktest; the now-redundant density=normal quicktest
  is dropped.
- The swift-5-support option is deleted: the renderer never read it,
  so it has been a no-op for years. Passing --swift-5-support is an
  error now (breaking).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/Swift/language.ts | 7 +------
 test/languages.ts                                      | 3 ++-
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/packages/quicktype-core/src/language/Swift/language.ts b/packages/quicktype-core/src/language/Swift/language.ts
index 1e6a53b493..7e9fecf155 100644
--- a/packages/quicktype-core/src/language/Swift/language.ts
+++ b/packages/quicktype-core/src/language/Swift/language.ts
@@ -72,7 +72,7 @@ export const swiftOptions = {
             dense: true,
             normal: false,
         } as const,
-        "dense",
+        "normal",
         "secondary",
     ),
     linux: new BooleanOption(
@@ -91,11 +91,6 @@ export const swiftOptions = {
         "If no matching case is found enum value is set to null",
         false,
     ),
-    swift5Support: new BooleanOption(
-        "swift-5-support",
-        "Renders output in a Swift 5 compatible mode",
-        false,
-    ),
     sendable: new BooleanOption(
         "sendable",
         "Mark generated models as Sendable",
diff --git a/test/languages.ts b/test/languages.ts
index ac2692e2ab..22ac96cd4d 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -875,8 +875,9 @@ export const SwiftLanguage: Language = {
             "simple-object.json",
             { "struct-or-class": "class", "final-classes": "true" },
         ],
+        // The default is density=normal; this keeps the dense code path
+        // covered.
         { density: "dense" },
-        { density: "normal" },
         { "access-level": "internal" },
         { "access-level": "public" },
         { protocol: "equatable" },

From dd91f6f99de6c025fc790f6250d97c7e292a4318 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 19:53:36 -0400
Subject: [PATCH 14/63] feat(haskell)!: arrays now render as lists by default

Hand-written aeson records overwhelmingly use [a]; the Vector default
was inherited from the Elm renderer and forces an extra import. The
quicktest entry now pins array-type=array so the Vector code path
keeps coverage.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/Haskell/language.ts | 2 +-
 test/languages.ts                                        | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/quicktype-core/src/language/Haskell/language.ts b/packages/quicktype-core/src/language/Haskell/language.ts
index 422adbd528..6d764ae766 100644
--- a/packages/quicktype-core/src/language/Haskell/language.ts
+++ b/packages/quicktype-core/src/language/Haskell/language.ts
@@ -19,7 +19,7 @@ export const haskellOptions = {
             array: false,
             list: true,
         } as const,
-        "array",
+        "list",
     ),
     moduleName: new StringOption(
         "module",
diff --git a/test/languages.ts b/test/languages.ts
index 22ac96cd4d..b07495510c 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1731,7 +1731,9 @@ export const HaskellLanguage: Language = {
         "required-non-properties.schema",
     ],
     rendererOptions: {},
-    quickTestRendererOptions: [{ "array-type": "list" }],
+    // The default is array-type=list; this keeps the Vector code path
+    // covered.
+    quickTestRendererOptions: [{ "array-type": "array" }],
     sourceFiles: ["src/language/Haskell/index.ts"],
 };
 

From 3b2cb1b758f6fed40f4902e24d9ee9ab5c8cca88 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Sun, 19 Jul 2026 20:34:39 -0400
Subject: [PATCH 15/63] fix(cplusplus): preserve JSON null in
 std::optional/shared_ptr deserialization
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The emitted adl_serializer for optionals handled null by calling the
optional *factory* with no arguments. That is only correct in boost
mode, where the factory is boost::optional and produces an empty
optional. In boost-free mode std::make_optional<T>() wraps a
default-constructed T, and std::make_shared<T>() (both modes) points at
a default-constructed T — so a JSON null inside a union or array came
back as 0/""/{} on round-trip. Null now maps to an empty optType<T>().

This is a pre-existing bug in the boost=false option; flipping the
default to boost=false in this branch merely exposed it, because the
old {boost:"false"} quicktest never actually ran: quicktests without a
pinned input run against combinations[1-4].json, which are all in the
C++ fixture's skipJSON. The boost quicktests are therefore now pinned
to unions.json (nulls inside unions, where the boost and std code
paths differ) and pokedex.json so they really execute.

Verified locally: QUICKTEST=true FIXTURE=cplusplus passes end to end
(63 tests), with the boost=true quicktests compiled against Boost 1.84
headers; unions.json round-trips byte-identically in both modes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/CPlusPlus/CPlusPlusRenderer.ts          | 8 +++++++-
 test/languages.ts                                        | 9 +++++++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
index 289d2652ae..ec99e8029b 100644
--- a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
+++ b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
@@ -2144,8 +2144,14 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                             ],
                             false,
                             () => {
+                                // A JSON null must become an *empty*
+                                // optional.  Only `optType<T>()` guarantees
+                                // that: the factory would wrap a
+                                // default-constructed T (std::make_optional
+                                // and std::make_shared both do), turning
+                                // null into 0/""/{} on round-trip.
                                 this.emitLine(
-                                    `if (j.is_null()) return ${factory}<T>(); else return ${factory}<T>(j.get<T>());`,
+                                    `if (j.is_null()) return ${optType}<T>(); else return ${factory}<T>(j.get<T>());`,
                                 );
                             },
                         );
diff --git a/test/languages.ts b/test/languages.ts
index b07495510c..9386bba84c 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -729,8 +729,13 @@ export const CPlusPlusLanguage: Language = {
         { wstring: "use-wstring" },
         { "const-style": "east-const" },
         // The default is boost=false (C++17); this keeps the boost code
-        // path covered.
-        { boost: "true" },
+        // path covered.  Pinned to specific inputs because the default
+        // quicktest inputs (combinations[1-4].json) are all in this
+        // fixture's skipJSON, so plain-options quicktests never run for
+        // C++.  unions.json exercises nulls inside unions, where the
+        // boost and std optional/variant code paths differ.
+        ["unions.json", { boost: "true" }],
+        ["pokedex.json", { boost: "true" }],
     ],
     sourceFiles: ["src/language/CPlusPlus/index.ts"],
 };

From e78765ae0535be12ba71f6b20d7337fdb7bc5b3b Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:00:50 -0400
Subject: [PATCH 16/63] fix(java): carry element types in union list
 deserialization
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In list mode, the union deserializer read JSON arrays with
jsonParser.readValueAs(new TypeReference<List>() {}) — a raw List, so
Jackson skipped element-type checking entirely and schema-invalid
inputs (e.g. a string array where List<Long> is expected) deserialized
successfully instead of being rejected. The TypeReference now carries
the full generic type (javaType instead of javaTypeWithoutGenerics),
e.g. TypeReference<List<Long>>.

This is a pre-existing bug in the array-type=list option; flipping the
default to list in this branch merely exposed it, via the
implicit-class-array-union.schema expected-failure sample in the
schema-java fixture (its .fail.union.json no longer failed).

Verified by running the generated code against Jackson 2.17: all five
valid samples round-trip, both fail samples now exit nonzero, and the
old code demonstrably accepted the bad input. A corpus-wide sweep of
all schema and JSON inputs in list mode shows every emitted
TypeReference now carries its element type; union-heavy inputs
(unions.json, combinations1-4, php-mixed-union, optional-union,
union-constructor-clash) round-trip within the harness' tolerances.
(Union members of map type still use raw readValueAs(Map.class) — that
looseness is mode-independent and pre-existing in both array and list
modes; left as a follow-up.)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/Java/JavaJacksonRenderer.ts               | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/Java/JavaJacksonRenderer.ts b/packages/quicktype-core/src/language/Java/JavaJacksonRenderer.ts
index 673e44ad1f..15c24bebed 100644
--- a/packages/quicktype-core/src/language/Java/JavaJacksonRenderer.ts
+++ b/packages/quicktype-core/src/language/Java/JavaJacksonRenderer.ts
@@ -206,11 +206,16 @@ export class JacksonRenderer extends JavaRenderer {
             const { fieldName } = this.unionField(u, t);
             const rendered = this.javaTypeWithoutGenerics(true, t);
             if (this._options.useList && t instanceof ArrayType) {
+                // The TypeReference must carry the full generic type:
+                // a raw `TypeReference<List>` would make Jackson accept
+                // any element type, so schema-invalid inputs (which the
+                // expected-failure fixtures rely on rejecting) would
+                // deserialize successfully.
                 this.emitLine(
                     "value.",
                     fieldName,
                     " = jsonParser.readValueAs(new TypeReference<",
-                    rendered,
+                    this.javaType(true, t),
                     ">() {});",
                 );
             } else if (

From 02da1cdb39e3353ad4a80776a54ac4a81e288e0b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Jul 2026 12:21:35 +0000
Subject: [PATCH 17/63] build(deps): bump stream-json from 1.8.0 to 3.5.0

Bumps [stream-json](https://github.com/uhop/stream-json) from 1.8.0 to 3.5.0.
- [Commits](https://github.com/uhop/stream-json/compare/1.8.0...3.5.0)

---
updated-dependencies:
- dependency-name: stream-json
  dependency-version: 3.5.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json | 26 +++++++++++++++++++++-----
 package.json      |  2 +-
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index bc94a988e2..edbfb913e7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,7 +28,7 @@
                 "quicktype-graphql-input": "24.0.0",
                 "quicktype-typescript-input": "24.0.0",
                 "readable-stream": "^4.5.2",
-                "stream-json": "1.8.0",
+                "stream-json": "3.5.0",
                 "string-to-stream": "^3.0.1",
                 "wordwrap": "^1.0.0"
             },
@@ -8387,14 +8387,30 @@
             }
         },
         "node_modules/stream-chain": {
-            "version": "2.2.5",
-            "license": "BSD-3-Clause"
+            "version": "4.2.5",
+            "resolved": "https://registry.npmjs.org/stream-chain/-/stream-chain-4.2.5.tgz",
+            "integrity": "sha512-Wtyq3bNE3ggLR0v2vftqvuhltym3WbZAkZpfIrkr5F/6vpeUmWmwTgXa16zD87gpahwJ/Qulq3zVfUlgIc0J2A==",
+            "license": "BSD-3-Clause",
+            "engines": {
+                "node": ">=22"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/uhop"
+            }
         },
         "node_modules/stream-json": {
-            "version": "1.8.0",
+            "version": "3.5.0",
+            "resolved": "https://registry.npmjs.org/stream-json/-/stream-json-3.5.0.tgz",
+            "integrity": "sha512-dobB7zipGW8o11PvdRljQSWuyMxifADLvoHeA4elwNWOTbZo6+BlNa+P6aCq7Y9jRiWTy2Ucu2xSv0Y2/T+/kQ==",
             "license": "BSD-3-Clause",
             "dependencies": {
-                "stream-chain": "^2.2.5"
+                "stream-chain": "^4.2.5"
+            },
+            "engines": {
+                "node": ">=22"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/uhop"
             }
         },
         "node_modules/stream-read-all": {
diff --git a/package.json b/package.json
index f6b9361260..ade50b15c7 100644
--- a/package.json
+++ b/package.json
@@ -48,7 +48,7 @@
         "quicktype-graphql-input": "24.0.0",
         "quicktype-typescript-input": "24.0.0",
         "readable-stream": "^4.5.2",
-        "stream-json": "1.8.0",
+        "stream-json": "3.5.0",
         "string-to-stream": "^3.0.1",
         "wordwrap": "^1.0.0"
     },

From 6285309c8080986ade100d9c3d44aa10f05815ad Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:37:27 -0400
Subject: [PATCH 18/63] feat(csharp)!: default csharp-version is now 8

With #2694 merged, C# 8 output with nullable reference types becomes
the out-of-box experience, pairing with the SystemTextJson default.
Both csharp fixtures now pin csharp-version=5 and =6 in their
quicktests (replacing the now-redundant =8 rows), so all three
language-version code paths stay covered.

Promoting v8 to the base schema-fixture runs put Newtonsoft v8 over
the full schema corpus for the first time (quicktests only cover the
JSON fixtures) and exposed a gap in #2694's NRT pragma set: the
emitted constraint-check and string-transformer helpers produce
CS8602, CS8604, and CS8625 warnings under '#nullable enable', which
'dotnet run' prints to stdout ahead of the JSON, breaking the fixture
comparison. Those three codes are now suppressed alongside the
existing CS8618/CS8601/CS8603(/CS8765) pragmas; a corpus-wide compile
scan of every schema under both frameworks confirms no other warning
codes remain.

Suppressing CS8602 also fixes the exact issue behind three
schema-csharp-SystemTextJson skips (minmaxlength, optional-constraints,
optional-const-ref), so those schemas are un-skipped.

Verified locally with dotnet SDK 8.0.423: QUICKTEST runs of csharp,
csharp-SystemTextJson, schema-csharp, and schema-csharp-SystemTextJson
all pass end to end (272 tests), with every quicktest row confirmed
executing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../CSharp/NewtonSoftCSharpRenderer.ts        |  9 +++++++++
 .../CSharp/SystemTextJsonCSharpRenderer.ts    |  4 ++++
 .../src/language/CSharp/language.ts           |  2 +-
 test/languages.ts                             | 19 ++++++++++++++-----
 4 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
index 1993f6e135..b4aebaf7a2 100644
--- a/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
@@ -197,7 +197,10 @@ export class NewtonsoftCSharpRenderer extends CSharpRenderer {
 
         this.emitLine("#pragma warning restore CS8618");
         this.emitLine("#pragma warning restore CS8601");
+        this.emitLine("#pragma warning restore CS8602");
         this.emitLine("#pragma warning restore CS8603");
+        this.emitLine("#pragma warning restore CS8604");
+        this.emitLine("#pragma warning restore CS8625");
         this.emitLine("#pragma warning restore CS8765");
     }
 
@@ -239,7 +242,13 @@ export class NewtonsoftCSharpRenderer extends CSharpRenderer {
             this.emitLine("#nullable enable");
             this.emitLine("#pragma warning disable CS8618");
             this.emitLine("#pragma warning disable CS8601");
+            // CS8602/CS8604/CS8625: the emitted constraint-check and
+            // string-transformer helpers dereference and pass around
+            // Deserialize<T>() results, which are nullable under NRT.
+            this.emitLine("#pragma warning disable CS8602");
             this.emitLine("#pragma warning disable CS8603");
+            this.emitLine("#pragma warning disable CS8604");
+            this.emitLine("#pragma warning disable CS8625");
             this.emitLine("#pragma warning disable CS8765");
         }
     }
diff --git a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
index e64a915dcb..f3eccc8df4 100644
--- a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
@@ -196,6 +196,7 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
 
         this.emitLine("#pragma warning restore CS8618");
         this.emitLine("#pragma warning restore CS8601");
+        this.emitLine("#pragma warning restore CS8602");
         this.emitLine("#pragma warning restore CS8603");
     }
 
@@ -237,6 +238,9 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
         this.emitLine("#nullable enable");
         this.emitLine("#pragma warning disable CS8618");
         this.emitLine("#pragma warning disable CS8601");
+        // CS8602: the emitted constraint-check converters dereference
+        // Deserialize<T>() results, which are nullable under NRT.
+        this.emitLine("#pragma warning disable CS8602");
         this.emitLine("#pragma warning disable CS8603");
     }
 
diff --git a/packages/quicktype-core/src/language/CSharp/language.ts b/packages/quicktype-core/src/language/CSharp/language.ts
index 48f7473ea7..5501853064 100644
--- a/packages/quicktype-core/src/language/CSharp/language.ts
+++ b/packages/quicktype-core/src/language/CSharp/language.ts
@@ -71,7 +71,7 @@ export const cSharpOptions = {
             "6": 6,
             "8": 8,
         } as const,
-        "6",
+        "8",
         "secondary",
     ),
     virtual: new BooleanOption("virtual", "Generate virtual properties", false),
diff --git a/test/languages.ts b/test/languages.ts
index b8b5c05183..48fc658fb7 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -119,8 +119,10 @@ export const CSharpLanguage: Language = {
     rendererOptions: { "check-required": "true", framework: "NewtonSoft" },
     quickTestRendererOptions: [
         { "array-type": "list" },
+        // The default is csharp-version=8; these keep the older
+        // language-version code paths covered.
         { "csharp-version": "5" },
-        { "csharp-version": "8" },
+        { "csharp-version": "6" },
         { density: "dense" },
         { "number-type": "decimal" },
         { "any-type": "dynamic" },
@@ -160,15 +162,22 @@ export const CSharpLanguageSystemTextJson: Language = {
         // The following skips are pre-existing System.Text.Json renderer issues,
         // found when first enabling the schema fixture for this language:
         "keyword-unions.schema", // a property named "JsonSerializer" collides with System.Text.Json.JsonSerializer: CS0120
-        "minmaxlength.schema", // generated converter triggers CS8602 warnings, which "dotnet run" prints to stdout, breaking the JSON comparison
-        "optional-constraints.schema", // same CS8602 stdout issue; also min/max on integers and pattern on optional strings aren't checked, so expected-failure samples don't fail
-        "optional-const-ref.schema", // same CS8602 stdout issue; also min/max on integers isn't checked, so the expected-failure sample doesn't fail
+        // minmaxlength.schema, optional-constraints.schema, and
+        // optional-const-ref.schema used to be skipped here because the
+        // generated converters triggered CS8602 warnings, which "dotnet
+        // run" prints to stdout, breaking the JSON comparison.  The
+        // generated code now suppresses CS8602 alongside the other NRT
+        // pragmas, so they run.  (Their .fail.<feature>.json samples are
+        // not exercised because this fixture doesn't declare the minmax,
+        // minmaxlength, or pattern features.)
     ],
     rendererOptions: { "check-required": "true", framework: "SystemTextJson" },
     quickTestRendererOptions: [
         { "array-type": "list" },
+        // The default is csharp-version=8; these keep the older
+        // language-version code paths covered.
+        { "csharp-version": "5" },
         { "csharp-version": "6" },
-        { "csharp-version": "8" },
         { density: "dense" },
         { "number-type": "decimal" },
         { "any-type": "dynamic" },

From 643fef6f4948554587f8db7e69c19cbc7482243f Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:37:22 -0400
Subject: [PATCH 19/63] fix: migrate to stream-json 3.x API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

stream-json 3.x replaced the Parser class export with a lowercase
parser factory; the Duplex-stream form is now parser.asStream().
Token names, payload shapes, and the pack/stream option defaults are
unchanged from 1.x, so the event handler needs no changes.

Also drop @types/stream-json (1.x types) — 3.x ships its own
TypeScript declarations.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 package-lock.json               | 18 ------------------
 package.json                    |  1 -
 src/CompressedJSONFromStream.ts |  4 ++--
 3 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index edbfb913e7..feb26d96da 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -44,7 +44,6 @@
                 "@types/node": "~20.19.0",
                 "@types/semver": "^7.5.0",
                 "@types/shelljs": "^0.10.0",
-                "@types/stream-json": "^1.7.3",
                 "@types/urijs": "^1.19.26",
                 "@types/wordwrap": "^1.0.3",
                 "ajv": "^5.5.2",
@@ -2023,23 +2022,6 @@
                 "fast-glob": "^3.3.2"
             }
         },
-        "node_modules/@types/stream-chain": {
-            "version": "2.0.1",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "@types/node": "*"
-            }
-        },
-        "node_modules/@types/stream-json": {
-            "version": "1.7.3",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "@types/node": "*",
-                "@types/stream-chain": "*"
-            }
-        },
         "node_modules/@types/unicode-properties": {
             "version": "1.3.2",
             "resolved": "https://registry.npmjs.org/@types/unicode-properties/-/unicode-properties-1.3.2.tgz",
diff --git a/package.json b/package.json
index ade50b15c7..99d54307c8 100644
--- a/package.json
+++ b/package.json
@@ -61,7 +61,6 @@
         "@types/node": "~20.19.0",
         "@types/semver": "^7.5.0",
         "@types/shelljs": "^0.10.0",
-        "@types/stream-json": "^1.7.3",
         "@types/urijs": "^1.19.26",
         "@types/wordwrap": "^1.0.3",
         "ajv": "^5.5.2",
diff --git a/src/CompressedJSONFromStream.ts b/src/CompressedJSONFromStream.ts
index 67e9c05b48..1ce83b0b59 100644
--- a/src/CompressedJSONFromStream.ts
+++ b/src/CompressedJSONFromStream.ts
@@ -1,5 +1,5 @@
 import type { Readable } from "readable-stream";
-import { Parser } from "stream-json";
+import { parser } from "stream-json";
 
 import { CompressedJSON, type Value } from "quicktype-core";
 
@@ -25,7 +25,7 @@ export class CompressedJSONFromStream extends CompressedJSON<Readable> {
     private _currentIntegerString = "";
 
     public async parse(readStream: Readable): Promise<Value> {
-        const combo = new Parser({ packKeys: true, packStrings: true });
+        const combo = parser.asStream({ packKeys: true, packStrings: true });
         combo.on(
             "data",
             (item: { name: string; value: string | undefined }) => {

From 48001815ca588392690f31aea7add4e65aa57ccc Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:42:21 -0400
Subject: [PATCH 20/63] fix(elm): generate Elm 0.19 code

Modernize the Elm renderer from Elm 0.18 (which elm.org no longer
supports) to Elm 0.19:

- Seed decode pipelines with `Jdec.succeed` instead of the `decode`
  function that was removed in NoRedInk/elm-json-decode-pipeline 1.0.
- Use the 0.19 elm/json encoder API: `Json.Encode.list`/`array` now take
  the element encoder directly and `Json.Encode.dict` exists, so the
  generated `makeArrayEncoder`/`makeListEncoder`/`makeDictEncoder`
  helpers are gone; only `makeNullableEncoder` remains.
- Stop exposing `map`/`toList` from imports (Elm 0.19 shadowing rules);
  only `Dict` (and `Array` when needed) are exposed.
- Forbid the parameter names used by generated functions (`x`, `y`, `r`,
  `f`, `m`, `str`, `somethingElse`) as global identifiers: Elm 0.19 does
  not allow a parameter to shadow a top-level definition.
- Never start generated identifiers with an underscore, which Elm 0.19
  rejects.
- Escape non-printable characters in string literals with Elm's
  `\u{XXXX}` syntax; the previously used `\uXXXX`/`\UXXXXXXXX` forms are
  syntax errors in Elm 0.19.
- Update the usage comment to `elm install NoRedInk/elm-json-decode-pipeline`
  and fix a stray backtick in it.

Elm 0.18 output is not supported anymore.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/Elm/ElmRenderer.ts           | 54 ++++++-------------
 .../src/language/Elm/constants.ts             | 13 +++--
 .../quicktype-core/src/language/Elm/utils.ts  | 17 +++++-
 3 files changed, 40 insertions(+), 44 deletions(-)

diff --git a/packages/quicktype-core/src/language/Elm/ElmRenderer.ts b/packages/quicktype-core/src/language/Elm/ElmRenderer.ts
index 72acf1b41e..3f0e914064 100644
--- a/packages/quicktype-core/src/language/Elm/ElmRenderer.ts
+++ b/packages/quicktype-core/src/language/Elm/ElmRenderer.ts
@@ -19,7 +19,7 @@ import {
     parenIfNeeded,
     singleWord,
 } from "../../Source.js";
-import { decapitalize, stringEscape } from "../../support/Strings.js";
+import { decapitalize } from "../../support/Strings.js";
 import { defined } from "../../support/Support.js";
 import type { TargetLanguage } from "../../TargetLanguage.js";
 import type {
@@ -34,6 +34,7 @@ import { matchType, nullableFromUnion } from "../../Type/TypeUtils.js";
 import { forbiddenNames } from "./constants.js";
 import type { elmOptions } from "./language.js";
 import {
+    elmStringEscape,
     lowerNamingFunction,
     requiredOrOptional,
     upperNamingFunction,
@@ -301,14 +302,15 @@ export class ElmRenderer extends ConvenienceRenderer {
             (arrayType) =>
                 multiWord(
                     " ",
-                    ["make", this.arrayType, "Encoder"],
+                    ["Jenc.", decapitalize(this.arrayType)],
                     parenIfNeeded(this.encoderNameForType(arrayType.items)),
                 ),
             (classType) => singleWord(this.encoderNameForNamedType(classType)),
             (mapType) =>
                 multiWord(
                     " ",
-                    "makeDictEncoder",
+                    "Jenc.dict",
+                    "identity",
                     parenIfNeeded(this.encoderNameForType(mapType.values)),
                 ),
             (enumType) => singleWord(this.encoderNameForNamedType(enumType)),
@@ -456,7 +458,7 @@ export class ElmRenderer extends ConvenienceRenderer {
         this.emitLine(decoderName, " : Jdec.Decoder ", className);
         this.emitLine(decoderName, " =");
         this.indent(() => {
-            this.emitLine("Jpipe.decode ", className);
+            this.emitLine("Jdec.succeed ", className);
             this.indent(() => {
                 this.forEachClassProperty(c, "none", (_, jsonName, p) => {
                     const propDecoder = parenIfNeeded(
@@ -467,7 +469,7 @@ export class ElmRenderer extends ConvenienceRenderer {
                         "|> ",
                         reqOrOpt,
                         ' "',
-                        stringEscape(jsonName),
+                        elmStringEscape(jsonName),
                         '" ',
                         propDecoder,
                         fallback,
@@ -490,7 +492,7 @@ export class ElmRenderer extends ConvenienceRenderer {
                     this.emitLine(
                         bracketOrComma,
                         ' ("',
-                        stringEscape(jsonName),
+                        elmStringEscape(jsonName),
                         '", ',
                         propEncoder,
                         " x.",
@@ -522,7 +524,7 @@ export class ElmRenderer extends ConvenienceRenderer {
                         this.forEachEnumCase(e, "none", (name, jsonName) => {
                             this.emitLine(
                                 '"',
-                                stringEscape(jsonName),
+                                elmStringEscape(jsonName),
                                 '" -> Jdec.succeed ',
                                 name,
                             );
@@ -547,7 +549,7 @@ export class ElmRenderer extends ConvenienceRenderer {
                 this.emitLine(
                     name,
                     ' -> Jenc.string "',
-                    stringEscape(jsonName),
+                    elmStringEscape(jsonName),
                     '"',
                 );
             });
@@ -652,11 +654,11 @@ export class ElmRenderer extends ConvenienceRenderer {
             this.emitCommentLines([
                 "To decode the JSON data, add this file to your project, run",
                 "",
-                "    elm-package install NoRedInk/elm-decode-pipeline",
+                "    elm install NoRedInk/elm-json-decode-pipeline",
                 "",
                 "add these imports",
                 "",
-                "    import Json.Decode exposing (decodeString)`);",
+                "    import Json.Decode exposing (decodeString)",
             ]);
             this.emitLine(
                 "--     import ",
@@ -695,11 +697,9 @@ export class ElmRenderer extends ConvenienceRenderer {
             this.emitMultiline(`import Json.Decode as Jdec
 import Json.Decode.Pipeline as Jpipe
 import Json.Encode as Jenc
-import Dict exposing (Dict, map, toList)`);
-            if (this._options.useList) {
-                this.emitLine("import List exposing (map)");
-            } else {
-                this.emitLine("import Array exposing (Array, map)");
+import Dict exposing (Dict)`);
+            if (!this._options.useList) {
+                this.emitLine("import Array exposing (Array)");
             }
         }
 
@@ -741,29 +741,7 @@ import Dict exposing (Dict, map, toList)`);
 
         this.emitLine("--- encoder helpers");
         this.ensureBlankLine();
-        this.emitLine(
-            "make",
-            this.arrayType,
-            "Encoder : (a -> Jenc.Value) -> ",
-            this.arrayType,
-            " a -> Jenc.Value",
-        );
-        this.emitLine("make", this.arrayType, "Encoder f arr =");
-        this.indent(() => {
-            this.emitLine(
-                "Jenc.",
-                decapitalize(this.arrayType),
-                " (",
-                this.arrayType,
-                ".map f arr)",
-            );
-        });
-        this.ensureBlankLine();
-        this.emitMultiline(`makeDictEncoder : (a -> Jenc.Value) -> Dict String a -> Jenc.Value
-makeDictEncoder f dict =
-	Jenc.object (toList (Dict.map (\\k -> f) dict))
-
-makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value
+        this.emitMultiline(`makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value
 makeNullableEncoder f m =
 	case m of
 	Just x -> f x
diff --git a/packages/quicktype-core/src/language/Elm/constants.ts b/packages/quicktype-core/src/language/Elm/constants.ts
index 5b3d119736..5f66253a27 100644
--- a/packages/quicktype-core/src/language/Elm/constants.ts
+++ b/packages/quicktype-core/src/language/Elm/constants.ts
@@ -27,11 +27,16 @@ export const forbiddenNames = [
     "List",
     "Dict",
     "Maybe",
-    "map",
-    "toList",
-    "makeArrayEncoder",
-    "makeDictEncoder",
     "makeNullableEncoder",
+    // Parameter names used in generated functions.  Elm 0.19 does not
+    // allow a parameter to shadow a top-level definition.
+    "x",
+    "y",
+    "r",
+    "f",
+    "m",
+    "str",
+    "somethingElse",
     "Int",
     "True",
     "False",
diff --git a/packages/quicktype-core/src/language/Elm/utils.ts b/packages/quicktype-core/src/language/Elm/utils.ts
index 17f12794ea..9083d68dce 100644
--- a/packages/quicktype-core/src/language/Elm/utils.ts
+++ b/packages/quicktype-core/src/language/Elm/utils.ts
@@ -3,12 +3,16 @@ import {
     allLowerWordStyle,
     allUpperWordStyle,
     combineWords,
+    escapeNonPrintableMapper,
     firstUpperWordStyle,
+    intToHex,
     isAscii,
-    isLetterOrUnderscore,
+    isLetter,
     isLetterOrUnderscoreOrDigit,
+    isPrintable,
     legalizeCharacters,
     splitIntoWords,
+    utf32ConcatMap,
 } from "../../support/Strings.js";
 import { type ClassProperty, UnionType } from "../../Type/index.js";
 import { nullableFromUnion } from "../../Type/TypeUtils.js";
@@ -27,10 +31,19 @@ function elmNameStyle(original: string, upper: boolean): string {
         upper ? allUpperWordStyle : allLowerWordStyle,
         allUpperWordStyle,
         "",
-        isLetterOrUnderscore,
+        // Elm identifiers must not start with an underscore.
+        isLetter,
     );
 }
 
+function unicodeEscape(codePoint: number): string {
+    return `\\u{${intToHex(codePoint, 4).toUpperCase()}}`;
+}
+
+export const elmStringEscape = utf32ConcatMap(
+    escapeNonPrintableMapper(isPrintable, unicodeEscape),
+);
+
 export const upperNamingFunction = funPrefixNamer("upper", (n) =>
     elmNameStyle(n, true),
 );

From e7b277b18c0534a7dc3be9611f2b3b048ec38741 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:42:21 -0400
Subject: [PATCH 21/63] feat(elm): default array-type to list

`List` is the idiomatic Elm collection type, and with the 0.19
`Json.Encode.list` API it needs no custom encoder helper.  Generating
`Array` is still available via `--array-type array`.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/language/Elm/language.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/Elm/language.ts b/packages/quicktype-core/src/language/Elm/language.ts
index efdbc0601a..1924a213fa 100644
--- a/packages/quicktype-core/src/language/Elm/language.ts
+++ b/packages/quicktype-core/src/language/Elm/language.ts
@@ -23,7 +23,7 @@ export const elmOptions = {
             array: false,
             list: true,
         } as const,
-        "array",
+        "list",
     ),
     // FIXME: Do this via a configurable named eventually.
     moduleName: new StringOption(

From cba633012a66b84fed1a539d4a366b72065f6067 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:43:49 -0400
Subject: [PATCH 22/63] test(elm): revive Elm fixtures on Elm 0.19 and
 re-enable them in CI

Rewrite the fixture driver for Elm 0.19: `elm.json` replaces
`elm-package.json`, `Main.elm` uses `Platform.worker` and
`Jdec.errorToString`, and `runner.js` uses the 0.19 embedding API
(`Elm.Main.init()`).  The setup command compiles a new `Warmup.elm` to
pre-populate the shared ELM_HOME package cache, because elm 0.19.1 can
corrupt its package registry when parallel compiles race on a cold
cache; the 0.18-era `sysconfcpus` hack is gone.

Every skip-list entry was re-verified against elm 0.19.1:

- `identifiers.json`, `simple-identifiers.json`, `blns-object.json`,
  `nst-test-suite.json`, and `keywords.json` now pass (they only failed
  on 0.19 escape syntax, leading underscores, and shadowing, all fixed
  in the renderer) and are only excluded from the diff-via-schema code
  comparison, where schema round-tripping changes inferred names.
- The recursive inputs stay skipped: Elm type aliases cannot be
  recursive.
- `constructor.schema` and `keyword-unions.schema` stay skipped with an
  accurate reason: elm/json's field decoder uses the JS `in` operator,
  which finds inherited Object.prototype members.
- `nested-intersection-union.schema` is newly skipped: the generated
  decoder accepts invalid union members because all class properties
  decode via `Jpipe.optional`.
- `recursive-union-flattening.schema` (added since the fixture was
  disabled) is skipped for recursion.

The quicktest renderer option flips to `array-type: array` to keep the
non-default Array path covered now that `list` is the default.

The full corpus passes locally with elm 0.19.1 (215 JSON tests
including misc, 67 schema tests), so `elm,schema-elm` returns to the CI
matrix; the workflow's elm 0.19.1 install step already existed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/test-pr.yaml     |  4 +--
 test/fixtures/elm/Main.elm         | 27 +++++++++++------
 test/fixtures/elm/Warmup.elm       | 18 ++++++++++++
 test/fixtures/elm/elm-package.json | 14 ---------
 test/fixtures/elm/elm.json         | 17 +++++++++++
 test/fixtures/elm/runner.js        |  8 ++---
 test/languages.ts                  | 47 ++++++++++++++++++------------
 7 files changed, 86 insertions(+), 49 deletions(-)
 create mode 100644 test/fixtures/elm/Warmup.elm
 delete mode 100644 test/fixtures/elm/elm-package.json
 create mode 100644 test/fixtures/elm/elm.json

diff --git a/.github/workflows/test-pr.yaml b/.github/workflows/test-pr.yaml
index fe79e6fc67..da9bd1061e 100644
--- a/.github/workflows/test-pr.yaml
+++ b/.github/workflows/test-pr.yaml
@@ -55,14 +55,12 @@ jobs:
                     - scala3,schema-scala3
                     - scala3-upickle,schema-scala3-upickle
                     - elixir,schema-elixir,graphql-elixir
+                    - elm,schema-elm
                     - comment-injection-treesitter,comment-injection-typescript,comment-injection-typescript-zod,comment-injection-typescript-effect-schema
 
                     # Partially working
                     # - schema-typescript # TODO Unify with typescript once fixed
 
-                    # Implementation is too outdated to test in GitHub Actions
-                    # - elm,schema-elm
-
                     # Language is too niche / obscure to test easily on ubuntu-22.04
                     # - pike,schema-pike
 
diff --git a/test/fixtures/elm/Main.elm b/test/fixtures/elm/Main.elm
index f821145e22..b1c7345b82 100644
--- a/test/fixtures/elm/Main.elm
+++ b/test/fixtures/elm/Main.elm
@@ -1,31 +1,40 @@
-port module Main exposing (..)
+port module Main exposing (main)
 
--- this is required for the ports
-import Json.Decode exposing (decodeString)
+import Json.Decode exposing (decodeString, errorToString)
 import QuickType
 
+
 port fromJS : (String -> msg) -> Sub msg
+
+
 port toJS : String -> Cmd msg
 
+
 type Msg
     = FromJS String
 
+
 update : Msg -> () -> ( (), Cmd Msg )
 update msg _ =
     case msg of
         FromJS str ->
             case decodeString QuickType.quickType str of
-            Ok r -> ((), toJS (QuickType.quickTypeToString r))
-            Err err -> ((), toJS ("Error: " ++ err))
+                Ok r ->
+                    ( (), toJS (QuickType.quickTypeToString r) )
+
+                Err err ->
+                    ( (), toJS ("Error: " ++ errorToString err) )
+
 
 subscriptions : () -> Sub Msg
 subscriptions _ =
-    fromJS (FromJS)
+    fromJS FromJS
+
 
-main : Program Never () Msg
+main : Program () () Msg
 main =
-    Platform.program
-        { init = ( (), Cmd.none )
+    Platform.worker
+        { init = \_ -> ( (), Cmd.none )
         , update = update
         , subscriptions = subscriptions
         }
diff --git a/test/fixtures/elm/Warmup.elm b/test/fixtures/elm/Warmup.elm
new file mode 100644
index 0000000000..c0b29a36af
--- /dev/null
+++ b/test/fixtures/elm/Warmup.elm
@@ -0,0 +1,18 @@
+module Warmup exposing (warmup)
+
+{-| Compiled once by the fixture's setup command so that all package
+dependencies are downloaded and built into the shared ELM_HOME cache
+before the per-sample compiles run in parallel. Concurrent cold-cache
+downloads can corrupt elm 0.19.1's package registry.
+-}
+
+import Dict exposing (Dict)
+import Json.Decode as Jdec
+import Json.Decode.Pipeline as Jpipe
+import Json.Encode as Jenc
+
+
+warmup : Jdec.Decoder ( Dict String Int, Jenc.Value )
+warmup =
+    Jdec.succeed (\x -> ( Dict.empty, x ))
+        |> Jpipe.required "x" Jdec.value
diff --git a/test/fixtures/elm/elm-package.json b/test/fixtures/elm/elm-package.json
deleted file mode 100644
index d688a53c96..0000000000
--- a/test/fixtures/elm/elm-package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "version": "1.0.0",
-    "summary": "helpful summary of your project, less than 80 characters",
-    "repository": "https://github.com/user/project.git",
-    "license": "BSD3",
-    "source-directories": ["."],
-    "exposed-modules": [],
-    "dependencies": {
-        "NoRedInk/elm-decode-pipeline": "3.0.0 <= v < 4.0.0",
-        "elm-lang/core": "5.1.1 <= v < 6.0.0",
-        "elm-lang/html": "2.0.0 <= v < 3.0.0"
-    },
-    "elm-version": "0.18.0 <= v < 0.19.0"
-}
diff --git a/test/fixtures/elm/elm.json b/test/fixtures/elm/elm.json
new file mode 100644
index 0000000000..47fcea36e2
--- /dev/null
+++ b/test/fixtures/elm/elm.json
@@ -0,0 +1,17 @@
+{
+    "type": "application",
+    "source-directories": ["."],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "NoRedInk/elm-json-decode-pipeline": "1.0.1",
+            "elm/core": "1.0.5",
+            "elm/json": "1.1.3"
+        },
+        "indirect": {}
+    },
+    "test-dependencies": {
+        "direct": {},
+        "indirect": {}
+    }
+}
diff --git a/test/fixtures/elm/runner.js b/test/fixtures/elm/runner.js
index d1c23b799f..455b1b68e5 100644
--- a/test/fixtures/elm/runner.js
+++ b/test/fixtures/elm/runner.js
@@ -1,9 +1,9 @@
-const Elm = require("./elm.js");
+const { Elm } = require("./elm.js");
 const fs = require("fs");
 
-const ports = Elm.Main.worker().ports;
+const app = Elm.Main.init();
 
-ports.toJS.subscribe((result) => {
+app.ports.toJS.subscribe((result) => {
     if (result.startsWith("Error: ")) {
         process.stderr.write(result + "\n", () => {
             process.exit(1);
@@ -15,4 +15,4 @@ ports.toJS.subscribe((result) => {
     }
 });
 
-ports.fromJS.send(fs.readFileSync(process.argv[2], "utf8"));
+app.ports.fromJS.send(fs.readFileSync(process.argv[2], "utf8"));
diff --git a/test/languages.ts b/test/languages.ts
index 3b4362efb2..69b5fecb77 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1,6 +1,5 @@
 import type { LanguageName } from "quicktype-core";
 
-import * as process from "node:process";
 // @ts-expect-error: ../dist only exists after the root package is built
 import type { RendererOptions } from "../dist/quicktype-core/Run";
 
@@ -732,16 +731,21 @@ export const CPlusPlusLanguage: Language = {
 export const ElmLanguage: Language = {
     name: "elm",
     base: "test/fixtures/elm",
-    setupCommand: "rm -rf elm-stuff/build-artifacts && elm-make --yes",
-    compileCommand:
-        process.env.CI === "true"
-            ? "sysconfcpus -n 1 elm-make Main.elm QuickType.elm --output elm.js"
-            : "elm-make Main.elm QuickType.elm --output elm.js",
+    // Compiling `Warmup.elm` once up front downloads and builds all package
+    // dependencies into the shared ELM_HOME cache; elm 0.19.1 can corrupt
+    // its package registry when parallel compiles race on a cold cache.
+    setupCommand: "rm -rf elm-stuff && elm make Warmup.elm --output=/dev/null",
+    compileCommand: "elm make Main.elm --output elm.js",
     runCommand(sample: string) {
         return `node ./runner.js "${sample}"`;
     },
     diffViaSchema: true,
     skipDiffViaSchema: [
+        "blns-object.json",
+        "identifiers.json",
+        "keywords.json",
+        "nst-test-suite.json",
+        "simple-identifiers.json",
         "bug863.json",
         "reddit.json",
         "github-events.json",
@@ -767,21 +771,17 @@ export const ElmLanguage: Language = {
     features: ["enum", "union", "no-defaults"],
     output: "QuickType.elm",
     topLevel: "QuickType",
+    // Elm type aliases cannot be recursive, so all inputs that produce
+    // recursive types must be skipped.
     skipJSON: [
-        "identifiers.json",
-        "simple-identifiers.json",
-        "blns-object.json",
-        "recursive.json",
-        "direct-recursive.json",
-        "bug427.json",
-        "bug790.json",
-        "list.json",
-        "nst-test-suite.json",
-        "keywords.json", // stack overflow
+        "recursive.json", // recursion
+        "direct-recursive.json", // recursion
+        "bug427.json", // recursion
+        "bug790.json", // recursion
+        "list.json", // recursion
     ],
     skipMiscJSON: false,
     skipSchema: [
-        "constructor.schema", // can't handle "constructor" property
         "union-list.schema", // recursion
         "list.schema", // recursion
         "ref-remote.schema", // recursion
@@ -789,10 +789,19 @@ export const ElmLanguage: Language = {
         "postman-collection.schema", // recursion
         "vega-lite.schema", // recursion
         "simple-ref.schema", // recursion
-        "keyword-unions.schema", // can't handle "hasOwnProperty" for some reason
+        "recursive-union-flattening.schema", // recursion
+        // elm/json's field decoder uses the JS `in` operator, which finds
+        // inherited Object.prototype members, so an absent "constructor"
+        // property decodes to the object's constructor function.
+        "constructor.schema",
+        "keyword-unions.schema",
+        // The generated decoder accepts invalid union members because all
+        // class properties decode via `Jpipe.optional`.
+        "nested-intersection-union.schema",
     ],
     rendererOptions: {},
-    quickTestRendererOptions: [{ "array-type": "list" }],
+    // `list` is the default now; keep the `Array` code path covered.
+    quickTestRendererOptions: [{ "array-type": "array" }],
     sourceFiles: ["src/language/Elm/index.ts"],
 };
 

From 0926136b13ea17a9714ba36a04a3fca978c17a46 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 08:53:42 -0400
Subject: [PATCH 23/63] fix(csharp): never double the nullable annotation on
 optional union properties
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For an optional property whose type is itself a nullable union (e.g.
GraphQL's nullable String, which infers as string | null),
propertyDefinition calls nullableCSType on the union, whose csType
rendering already resolves the union through nullableCSType and
appends '?'. At csharp-version 8 the outer call then appended a second
one, emitting 'public string?? Name' — invalid C# (CS1519). The same
path produced 'long??' for optional nullable value-type unions at any
version. nullableCSType now unwraps a nullable union before rendering,
so the annotation is applied exactly once.

This is a pre-existing bug in the csharp-version=8 option: the GraphQL
fixtures run base options only, so flipping the default to 8 put v8
GraphQL output in CI for the first time (caught by graphql-csharp on
github5.graphql).

Verified locally with dotnet SDK 8: a corpus-wide sweep (all GraphQL,
schema, and JSON inputs under both frameworks, 242 generated files)
contains no doubled '?' in any type position, a representative set
compiles clean, and the full CI fixture set - csharp, schema-csharp,
schema-json-csharp, graphql-csharp, csharp-SystemTextJson,
schema-csharp-SystemTextJson - passes end to end (326 tests).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/CSharp/CSharpRenderer.ts     | 22 ++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/packages/quicktype-core/src/language/CSharp/CSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/CSharpRenderer.ts
index 3e331a310b..482cb14f71 100644
--- a/packages/quicktype-core/src/language/CSharp/CSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/CSharpRenderer.ts
@@ -15,11 +15,11 @@ import { type Sourcelike, maybeAnnotated } from "../../Source.js";
 import { assert } from "../../support/Support.js";
 import type { TargetLanguage } from "../../TargetLanguage.js";
 import { followTargetType } from "../../Transformers.js";
-import type {
-    ClassProperty,
-    ClassType,
-    EnumType,
-    Type,
+import {
+    type ClassProperty,
+    type ClassType,
+    type EnumType,
+    type Type,
     UnionType,
 } from "../../Type/index.js";
 import {
@@ -187,6 +187,18 @@ export class CSharpRenderer extends ConvenienceRenderer {
         withIssues = false,
     ): Sourcelike {
         t = followTargetType(t);
+        // A nullable union already renders with its own "?" through
+        // csType's union case; unwrap it so the annotation is applied
+        // exactly once.  Without this, an optional property whose type
+        // is e.g. `string | null` would render as `string??` at C# 8
+        // (and a nullable value-type union as `long??` at any version).
+        if (t instanceof UnionType) {
+            const nullable = nullableFromUnion(t);
+            if (nullable !== null) {
+                t = followTargetType(nullable);
+            }
+        }
+
         const csType = this.csType(t, follow, withIssues);
         if (isValueType(t) || this._csOptions.version >= 8) {
             return [csType, "?"];

From f9c452125268d80991a20b1d5f0012532160edea Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 09:25:46 -0400
Subject: [PATCH 24/63] test(elm): move the Elm toolchain to 0.19.2

Elm 0.19.2 (released 2026-07-06) is a compiler performance release with
no language changes.  It refuses to build applications whose elm.json
declares 0.19.1, so the fixture's elm.json now declares 0.19.2, and CI
downloads the 0.19.2 binary (the release assets are named
elm-0.19.2-linux-x64.gz; the old binary-for-linux-64-bit.gz naming is
gone).

The `Warmup.elm` cache pre-warm stays: concurrent cold-cache builds
still corrupt the shared ELM_HOME package cache with 0.19.2 (verified:
16 parallel cold-cache `elm make` runs consistently fail without the
warmup, and the fixtures pass with it).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/test-pr.yaml | 2 +-
 test/fixtures/elm/Warmup.elm   | 3 ++-
 test/fixtures/elm/elm.json     | 2 +-
 test/languages.ts              | 5 +++--
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/test-pr.yaml b/.github/workflows/test-pr.yaml
index da9bd1061e..7001f80230 100644
--- a/.github/workflows/test-pr.yaml
+++ b/.github/workflows/test-pr.yaml
@@ -134,7 +134,7 @@ jobs:
             - name: Install Elm
               if: ${{ contains(matrix.fixture, 'elm') }}
               run: |
-                  curl -L -o elm.gz https://github.com/elm/compiler/releases/download/0.19.1/binary-for-linux-64-bit.gz
+                  curl -L -o elm.gz https://github.com/elm/compiler/releases/download/0.19.2/elm-0.19.2-linux-x64.gz
                   gunzip elm.gz
                   chmod +x elm
                   sudo mv elm /usr/local/bin/
diff --git a/test/fixtures/elm/Warmup.elm b/test/fixtures/elm/Warmup.elm
index c0b29a36af..d16256ba17 100644
--- a/test/fixtures/elm/Warmup.elm
+++ b/test/fixtures/elm/Warmup.elm
@@ -3,7 +3,8 @@ module Warmup exposing (warmup)
 {-| Compiled once by the fixture's setup command so that all package
 dependencies are downloaded and built into the shared ELM_HOME cache
 before the per-sample compiles run in parallel. Concurrent cold-cache
-downloads can corrupt elm 0.19.1's package registry.
+builds corrupt elm's shared package cache (still reproducible with
+elm 0.19.2).
 -}
 
 import Dict exposing (Dict)
diff --git a/test/fixtures/elm/elm.json b/test/fixtures/elm/elm.json
index 47fcea36e2..7489e93007 100644
--- a/test/fixtures/elm/elm.json
+++ b/test/fixtures/elm/elm.json
@@ -1,7 +1,7 @@
 {
     "type": "application",
     "source-directories": ["."],
-    "elm-version": "0.19.1",
+    "elm-version": "0.19.2",
     "dependencies": {
         "direct": {
             "NoRedInk/elm-json-decode-pipeline": "1.0.1",
diff --git a/test/languages.ts b/test/languages.ts
index 69b5fecb77..417fa61091 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -732,8 +732,9 @@ export const ElmLanguage: Language = {
     name: "elm",
     base: "test/fixtures/elm",
     // Compiling `Warmup.elm` once up front downloads and builds all package
-    // dependencies into the shared ELM_HOME cache; elm 0.19.1 can corrupt
-    // its package registry when parallel compiles race on a cold cache.
+    // dependencies into the shared ELM_HOME cache; elm corrupts its shared
+    // package cache when parallel compiles race on a cold cache (still
+    // reproducible with elm 0.19.2).
     setupCommand: "rm -rf elm-stuff && elm make Warmup.elm --output=/dev/null",
     compileCommand: "elm make Main.elm --output elm.js",
     runCommand(sample: string) {

From 5990c74ed3d7b598e949b81eb0888d40e9c66750 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 09:48:19 -0400
Subject: [PATCH 25/63] Raise engines.node to >=20.19.0

stream-json 3.x is ESM-only and is loaded from our CJS dist via
require(esm), which Node supports only from 20.19 / 22.12. Declare
the real floor instead of letting Node 20.0-20.18 users fail at
runtime with ERR_REQUIRE_ESM.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 0527d411f3..5de5e45354 100644
--- a/package.json
+++ b/package.json
@@ -6,7 +6,7 @@
     "types": "dist/index.d.ts",
     "repository": "https://github.com/glideapps/quicktype",
     "engines": {
-        "node": ">=20.0.0"
+        "node": ">=20.19.0"
     },
     "scripts": {
         "pub": "script/publish-npm.sh && script/publish-vscode.sh",

From 27c1f845041387ade8a6bf58939486fef57c1beb Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 10:21:40 -0400
Subject: [PATCH 26/63] Fix biome formatting in JSONSchemaInput.ts

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/input/JSONSchemaInput.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index 4e534ee19d..5a931731e9 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -1138,9 +1138,12 @@ async function addTypesInSchema(
             ) {
                 additionalProperties = schema.patternProperties[".*"];
             }
-            
+
             // Handle unevaluatedProperties if additionalProperties is not defined
-            if (additionalProperties === undefined && schema.unevaluatedProperties !== undefined) {
+            if (
+                additionalProperties === undefined &&
+                schema.unevaluatedProperties !== undefined
+            ) {
                 additionalProperties = schema.unevaluatedProperties;
             }
 

From 61f95a0feebeaab10a2ff5bdcd8369bbb48c3c19 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 11:15:37 -0400
Subject: [PATCH 27/63] test(schema): prove unevaluatedProperties values are
 typed, not any
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A map<string, Item[]> and a map<string, any> round-trip the positive
samples identically, so add an expected-failure sample with a mistyped
map value. Languages that don't reject mistyped map values skip it via
a new shared skipsMapValueValidation list, which also absorbs the
existing go-schema-pattern-properties.schema entries — the same
failure mode.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../schema/unevaluated-properties.1.fail.json |  8 ++++++
 test/languages.ts                             | 27 ++++++++++++-------
 2 files changed, 26 insertions(+), 9 deletions(-)
 create mode 100644 test/inputs/schema/unevaluated-properties.1.fail.json

diff --git a/test/inputs/schema/unevaluated-properties.1.fail.json b/test/inputs/schema/unevaluated-properties.1.fail.json
new file mode 100644
index 0000000000..1b5ea63b1f
--- /dev/null
+++ b/test/inputs/schema/unevaluated-properties.1.fail.json
@@ -0,0 +1,8 @@
+{
+    "config": {
+        "name": "test-config",
+        "settings": {
+            "option1": "not-an-item-list"
+        }
+    }
+}
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..94921b7593 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -46,6 +46,15 @@ const skipsUntypedUnions = [
     "implicit-class-array-union.schema",
 ];
 
+// The generated code does not reject wrong-typed values in typed maps (a
+// map<string, T> accepts values that are not T), so the bare `.fail.json`
+// samples for these map-valued schemas do not fail as expected.  Add any new
+// schema whose fail sample relies on rejecting a mistyped map value.
+const skipsMapValueValidation = [
+    "go-schema-pattern-properties.schema",
+    "unevaluated-properties.schema",
+];
+
 export type LanguageFeature =
     | "enum"
     | "union"
@@ -576,7 +585,7 @@ export const CJSONLanguage: Language = {
         ...skipsEnumValueValidation,
         /* Union, Map and Arrays with invalid types are not checked (for the current implementation, can be added later, should abord parsing and return NULL) */
         "class-with-additional.schema",
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         "multi-type-enum.schema",
         "nested-intersection-union.schema",
         "prefix-items.schema",
@@ -889,7 +898,7 @@ export const SwiftLanguage: Language = {
         "required.schema",
         "multi-type-enum.schema",
         "intersection.schema",
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         ...skipsEnumValueValidation,
         "date-time.schema",
         "class-with-additional.schema",
@@ -1317,7 +1326,7 @@ export const KotlinLanguage: Language = {
         // instead of rejecting it.
         "nested-intersection-union.schema",
         "class-with-additional.schema",
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         // IllegalArgumentException
         "accessors.schema",
         "description.schema",
@@ -1408,7 +1417,7 @@ export const KotlinJacksonLanguage: Language = {
         // instead of rejecting it.
         "nested-intersection-union.schema",
         "class-with-additional.schema",
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         // IllegalArgumentException
         "accessors.schema",
         "description.schema",
@@ -1675,7 +1684,7 @@ export const PikeLanguage: Language = {
         // no implicit cast int <-> float in Pike
         ...skipsIntFloatUnions,
         // all below: not failing on expected failure. That's because Pike's quite tolerant with assignments.
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         "class-with-additional.schema",
         "multi-type-enum.schema",
         ...skipsUntypedUnions,
@@ -1764,7 +1773,7 @@ export const HaskellLanguage: Language = {
         "prefix-items.schema",
         "direct-union.schema",
         ...skipsEnumValueValidation,
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         "intersection.schema",
         "multi-type-enum.schema",
         "keyword-unions.schema",
@@ -1933,7 +1942,7 @@ export const TypeScriptZodLanguage: Language = {
         "constructor.schema",
         // z.coerce.date() serializes back as ISO UTC, not the input string
         "date-time.schema",
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         "intersection.schema",
         "multi-type-enum.schema",
         "keyword-unions.schema",
@@ -2049,7 +2058,7 @@ export const TypeScriptEffectSchemaLanguage: Language = {
         ...skipsUntypedUnions,
         "direct-union.schema",
         ...skipsEnumValueValidation,
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
         "intersection.schema",
         "multi-type-enum.schema",
         "keyword-unions.schema",
@@ -2116,7 +2125,7 @@ export const ElixirLanguage: Language = {
 
         // The test incorrectly succeeds due to the emitter being permissive for unions that contain only primitives. A future enhancement
         // for the Elixir emitter could be a user-controlled 'strict' mode that pattern matches even on unions of only primitive types.
-        "go-schema-pattern-properties.schema",
+        ...skipsMapValueValidation,
 
         // The generated top-level type is not emitted as a TopLevel module the fixture can call.
         "recursive-union-flattening.schema",

From 1ddaf28abf783d0ec5724faa5604640553820cab Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:17:26 -0400
Subject: [PATCH 28/63] fix(rust): require both bounds for conservative i32
 inference
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The conservative integer-type mode treated a one-sided schema bound as
fitting i32, so `{"type": "integer", "minimum": 0}` — unbounded above —
rendered as `i32`, an overflow hazard.  Conservative now picks i32 only
when the schema bounds the integer on both sides and both bounds fit
the i32 range.

Also override `getSupportedIntegerRange` so that with `force-i32`,
whole numbers in input JSON outside the i32 range are inferred as
`double` instead of an integer type that cannot round-trip them,
matching how cJSON's `integer-size` option hooks into the integer
range machinery from #2931.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/language/Rust/RustRenderer.ts         | 27 ++++++++-----------
 .../src/language/Rust/language.ts             | 26 ++++++++++++++++++
 2 files changed, 37 insertions(+), 16 deletions(-)

diff --git a/packages/quicktype-core/src/language/Rust/RustRenderer.ts b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
index 7bb7df6d37..eda0ace698 100644
--- a/packages/quicktype-core/src/language/Rust/RustRenderer.ts
+++ b/packages/quicktype-core/src/language/Rust/RustRenderer.ts
@@ -5,6 +5,7 @@ import {
     anyTypeIssueAnnotation,
     nullTypeIssueAnnotation,
 } from "../../Annotation.js";
+import { minMaxValueForType } from "../../attributes/Constraints.js";
 import {
     ConvenienceRenderer,
     type ForbiddenWordsInfo,
@@ -27,7 +28,6 @@ import {
     removeNullFromUnion,
 } from "../../Type/TypeUtils.js";
 
-import { minMaxValueForType } from "../../attributes/Constraints.js";
 import { keywords } from "./constants.js";
 import { IntegerType, type rustOptions } from "./language.js";
 import {
@@ -103,23 +103,18 @@ export class RustRenderer extends ConvenienceRenderer {
                 return "i32";
             case IntegerType.ForceI64:
                 return "i64";
-            case IntegerType.Conservative:
             default: {
+                // Conservative: use i32 only when the schema bounds the
+                // integer on *both* sides and both bounds fit in i32.  A
+                // one-sided bound (e.g. only `"minimum": 0`) leaves the
+                // other side unbounded, so it must stay i64.
                 const minMax = minMaxValueForType(integerType);
-                if (minMax !== undefined) {
-                    const [min, max] = minMax;
-                    // Check if values fit in i32 range: [-2147483648, 2147483647]
-                    const i32Min = -2147483648;
-                    const i32Max = 2147483647;
-                    
-                    if (
-                        (min === undefined || min >= i32Min) &&
-                        (max === undefined || max <= i32Max)
-                    ) {
-                        return "i32";
-                    }
-                }
-                return "i64";
+                if (minMax === undefined) return "i64";
+                const [min, max] = minMax;
+                if (min === undefined || max === undefined) return "i64";
+                const i32Min = -2147483648;
+                const i32Max = 2147483647;
+                return min >= i32Min && max <= i32Max ? "i32" : "i64";
             }
         }
     }
diff --git a/packages/quicktype-core/src/language/Rust/language.ts b/packages/quicktype-core/src/language/Rust/language.ts
index 94312fcea1..ce25cf9408 100644
--- a/packages/quicktype-core/src/language/Rust/language.ts
+++ b/packages/quicktype-core/src/language/Rust/language.ts
@@ -4,6 +4,11 @@ import {
     EnumOption,
     getOptionValues,
 } from "../../RendererOptions/index.js";
+import {
+    INT32_RANGE,
+    INT64_RANGE,
+    type IntegerRange,
+} from "../../support/IntegerRange.js";
 import { TargetLanguage } from "../../TargetLanguage.js";
 import type { LanguageName, RendererOptions } from "../../types.js";
 
@@ -82,6 +87,27 @@ export class RustTargetLanguage extends TargetLanguage<
         return rustOptions;
     }
 
+    /**
+     * The range of whole numbers the generated integer type can
+     * represent.  With `integer-type: force-i32` every integer renders
+     * as `i32`, so whole numbers in input JSON outside the i32 range
+     * must be inferred as `double`.  `conservative` only narrows to
+     * `i32` when schema bounds prove it fits, so it keeps the i64
+     * range.
+     */
+    public getSupportedIntegerRange(
+        rendererOptions: Record<string, unknown> = {},
+    ): IntegerRange | null {
+        if (
+            rustOptions.integerType.getValue(rendererOptions) ===
+            IntegerType.ForceI32
+        ) {
+            return INT32_RANGE;
+        }
+
+        return INT64_RANGE;
+    }
+
     protected makeRenderer<Lang extends LanguageName = "rust">(
         renderContext: RenderContext,
         untypedOptionValues: RendererOptions<Lang>,

From b47f541aeb40c009d56bb3f9332fd4cdb1237b5d Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:17:44 -0400
Subject: [PATCH 29/63] Drop the dead minContains/maxContains attribute kind

Its name duplicated "minMaxItems", so it could never coexist with the
real minItems/maxItems attribute, and its reader was never called.
Also biome-format the minItems producer.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/attributes/Constraints.ts             | 34 ++++---------------
 1 file changed, 6 insertions(+), 28 deletions(-)

diff --git a/packages/quicktype-core/src/attributes/Constraints.ts b/packages/quicktype-core/src/attributes/Constraints.ts
index a374bc625b..7f2ca6f5c0 100644
--- a/packages/quicktype-core/src/attributes/Constraints.ts
+++ b/packages/quicktype-core/src/attributes/Constraints.ts
@@ -138,14 +138,6 @@ export const minMaxItemsTypeAttributeKind: TypeAttributeKind<MinMaxConstraint> =
         "maxItems",
     );
 
-export const minMaxContainsTypeAttributeKind: TypeAttributeKind<MinMaxConstraint> =
-    new MinMaxConstraintTypeAttributeKind(
-        "minMaxItems",
-        new Set<TypeKind>(["array"]),
-        "minContains",
-        "maxContains",
-    );
-
 function producer(
     schema: JSONSchema,
     minProperty: string,
@@ -198,25 +190,15 @@ export function minMaxLengthAttributeProducer(
 export function minMaxItemsAttributeProducer(
     schema: JSONSchema,
     _ref: Ref,
-    types: Set<JSONSchemaType>
-): JSONSchemaAttributes | undefined {
-    if (!types.has("array")) return undefined;
-
-    const maybeMinMaxLength = producer(schema, "minItems", "maxItems");
-    if (maybeMinMaxLength === undefined) return undefined;
-    return { forArray: minMaxItemsTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
-}
-
-export function minMaxContainsAttributeProducer(
-    schema: JSONSchema,
-    _ref: Ref,
-    types: Set<JSONSchemaType>
+    types: Set<JSONSchemaType>,
 ): JSONSchemaAttributes | undefined {
     if (!types.has("array")) return undefined;
 
-    const maybeMinMaxLength = producer(schema, "minContains", "maxContains");
-    if (maybeMinMaxLength === undefined) return undefined;
-    return { forArray: minMaxContainsTypeAttributeKind.makeAttributes(maybeMinMaxLength) };
+    const maybeMinMaxItems = producer(schema, "minItems", "maxItems");
+    if (maybeMinMaxItems === undefined) return undefined;
+    return {
+        forArray: minMaxItemsTypeAttributeKind.makeAttributes(maybeMinMaxItems),
+    };
 }
 
 export function minMaxValueForType(t: Type): MinMaxConstraint | undefined {
@@ -231,10 +213,6 @@ export function minMaxItemsForType(t: Type): MinMaxConstraint | undefined {
     return minMaxItemsTypeAttributeKind.tryGetInAttributes(t.getAttributes());
 }
 
-export function minMaxContainsForType(t: Type): MinMaxConstraint | undefined {
-    return minMaxContainsTypeAttributeKind.tryGetInAttributes(t.getAttributes());
-}
-
 export class PatternTypeAttributeKind extends TypeAttributeKind<string> {
     public constructor() {
         super("pattern");

From e92c26a63ce6a22566142c2ad8c687b04c1c37e7 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:18:07 -0400
Subject: [PATCH 30/63] Read minItems/maxItems off the array type; tuples only
 in TypeScript

The attribute now lives on the array type itself, so the renderers read
it from there instead of from the item type, where it would leak into
item-type identity and unification.

The minItems tuple shape ([T, T, ...T[]] for minItems 2) moves from the
shared TS/Flow base renderer into the TypeScript renderer: Flow (pinned
at flow-bin 0.66 in CI) has no tuple-rest syntax, so Flow keeps plain
array types.  TypeScript spells out up to 16 guaranteed elements and
ignores maxItems, which nothing in the generated code enforces.  Zod
emits both z.array(T).min(n) and .max(m).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../TypeScriptFlowBaseRenderer.ts             | 52 +++++++------------
 .../TypeScriptZod/TypeScriptZodRenderer.ts    | 15 +++---
 2 files changed, 26 insertions(+), 41 deletions(-)

diff --git a/packages/quicktype-core/src/language/TypeScriptFlow/TypeScriptFlowBaseRenderer.ts b/packages/quicktype-core/src/language/TypeScriptFlow/TypeScriptFlowBaseRenderer.ts
index 30942c00b4..efcdbb2cee 100644
--- a/packages/quicktype-core/src/language/TypeScriptFlow/TypeScriptFlowBaseRenderer.ts
+++ b/packages/quicktype-core/src/language/TypeScriptFlow/TypeScriptFlowBaseRenderer.ts
@@ -1,4 +1,3 @@
-import { minMaxItemsForType } from "../../attributes/Constraints.js";
 import { type Name, type Namer, funPrefixNamer } from "../../Naming.js";
 import type { RenderContext } from "../../Renderer.js";
 import type { OptionValues } from "../../RendererOptions/index.js";
@@ -48,6 +47,23 @@ export abstract class TypeScriptFlowBaseRenderer extends JavaScriptRenderer {
         return super.namerForObjectProperty();
     }
 
+    // Flow (pinned at flow-bin 0.66 in CI) has no tuple-rest syntax, so
+    // the base implementation always renders plain array types; the
+    // TypeScript renderer overrides this to spell out `minItems`
+    // guarantees as a tuple.
+    protected sourceForArrayType(arrayType: ArrayType): MultiWord {
+        const itemType = this.sourceFor(arrayType.items);
+        if (
+            (arrayType.items instanceof UnionType &&
+                !this._tsFlowOptions.declareUnions) ||
+            arrayType.items instanceof ArrayType
+        ) {
+            return singleWord(["Array<", itemType.source, ">"]);
+        }
+
+        return singleWord([parenIfNeeded(itemType), "[]"]);
+    }
+
     protected sourceFor(t: Type): MultiWord {
         if (
             this._tsFlowOptions.preferConstValues &&
@@ -71,39 +87,7 @@ export abstract class TypeScriptFlowBaseRenderer extends JavaScriptRenderer {
             (_integerType) => singleWord("number"),
             (_doubleType) => singleWord("number"),
             (_stringType) => singleWord("string"),
-            (arrayType) => {
-                const itemType = this.sourceFor(arrayType.items);
-                const minMaxItems = minMaxItemsForType(arrayType.items);
-                if (
-                    (arrayType.items instanceof UnionType &&
-                        !this._tsFlowOptions.declareUnions) ||
-                    arrayType.items instanceof ArrayType
-                ) {
-                    if (minMaxItems?.[0] && minMaxItems[0] > 0) {
-                        return singleWord([
-                            "[",
-                            itemType.source,
-                            ", ...",
-                            itemType.source,
-                            "[]]",
-                        ]);
-                    }
-
-                    return singleWord(["Array<", itemType.source, ">"]);
-                }
-
-                if (minMaxItems?.[0] && minMaxItems[0] > 0) {
-                    return singleWord([
-                        "[",
-                        parenIfNeeded(itemType),
-                        ", ...",
-                        parenIfNeeded(itemType),
-                        "[]]",
-                    ]);
-                }
-
-                return singleWord([parenIfNeeded(itemType), "[]"]);
-            },
+            (arrayType) => this.sourceForArrayType(arrayType),
             (_classType) => panic("We handled this above"),
             (mapType) =>
                 singleWord([
diff --git a/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts b/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
index 92f80f972a..714c0adf11 100644
--- a/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
+++ b/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
@@ -113,22 +113,23 @@ export class TypeScriptZodRenderer extends ConvenienceRenderer {
             (_doubleType) => "z.number()",
             (_stringType) => "z.string()",
             (arrayType) => {
-                const minMaxItems = minMaxItemsForType(arrayType.items);
+                const [minItems, maxItems] =
+                    minMaxItemsForType(arrayType) ?? [];
 
-                const arrayString: Sourcelike[] = [
+                const arraySource: Sourcelike[] = [
                     "z.array(",
                     this.typeMapTypeFor(arrayType.items, false),
                     ")",
                 ];
-                if (minMaxItems?.[0]) {
-                    arrayString.push(".min(", minMaxItems[0].toString(10), ")");
+                if (minItems !== undefined && minItems > 0) {
+                    arraySource.push(".min(", minItems.toString(10), ")");
                 }
 
-                if (minMaxItems?.[1]) {
-                    arrayString.push(".max(", minMaxItems[1].toString(10), ")");
+                if (maxItems !== undefined) {
+                    arraySource.push(".max(", maxItems.toString(10), ")");
                 }
 
-                return arrayString;
+                return arraySource;
             },
             (_classType) => panic("Should already be handled."),
             (_mapType) => [

From cc4567a4e7dc8371e39fa59684dd028e108cfaea Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:20:25 -0400
Subject: [PATCH 31/63] test: fixture-test the Rust integer-type option end to
 end

- Support pinned-input quick-test entries that name a `.schema` file:
  they now run in the JSON Schema fixture with their renderer options,
  while the JSON fixtures ignore them.
- Pin the Rust integer-type quick tests: conservative and force-i64
  run against integer-type.schema; force-i32 runs against
  minmax-integer.schema, whose sample values all fit in i32.
- Redesign integer-type.schema to cover one-sided bounds (which must
  stay i64), exact i32 boundaries, bounds one past them, and large
  bounds, using only integers that are exactly representable as IEEE
  doubles.  The previous +/-2^63 bounds are lossy as JS doubles - the
  int64 max rounds up to 2^63, which overflowed the int64_t constraint
  constants in generated C++ - and that was why the schema had to be
  skipped for C++.  With exact bounds the skip is no longer needed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/fixtures.ts                       | 55 +++++++++++++++++++++++++-
 test/inputs/schema/integer-type.1.json | 11 ++++--
 test/inputs/schema/integer-type.schema | 46 +++++++++++++--------
 test/languages.ts                      | 11 +++---
 4 files changed, 97 insertions(+), 26 deletions(-)

diff --git a/test/fixtures.ts b/test/fixtures.ts
index dece181ef6..dfd3f1f57e 100644
--- a/test/fixtures.ts
+++ b/test/fixtures.ts
@@ -461,6 +461,11 @@ class JSONFixture extends LanguageFixture {
                 .flatMap((qt) => {
                     if (Array.isArray(qt)) {
                         const [filename, ro] = qt;
+                        if (filename.endsWith(".schema")) {
+                            // Runs in the JSON Schema fixture instead.
+                            return [];
+                        }
+
                         const input = _.find(
                             ([] as string[]).concat(
                                 prioritySamples,
@@ -747,7 +752,50 @@ class JSONSchemaFixture extends LanguageFixture {
 
     getSamples(sources: string[]): { priority: Sample[]; others: Sample[] } {
         const prioritySamples = testsInDir("test/inputs/schema/", "schema");
-        return samplesFromSources(sources, prioritySamples, [], "schema");
+        const samples = samplesFromSources(
+            sources,
+            prioritySamples,
+            [],
+            "schema",
+        );
+
+        if (sources.length === 0 && !ONLY_OUTPUT) {
+            // Pinned-input quick-test entries that name a `.schema` file
+            // run in this fixture with their renderer options.  Plain
+            // renderer-option combinations and `.json` entries run in
+            // the JSON fixture.
+            const quickTestSamples = _.chain(
+                this.language.quickTestRendererOptions,
+            )
+                .flatMap((qt) => {
+                    if (!Array.isArray(qt)) return [];
+
+                    const [filename, ro] = qt;
+                    if (!filename.endsWith(".schema")) return [];
+
+                    const input = _.find(prioritySamples, (p) =>
+                        p.endsWith(`/${filename}`),
+                    );
+                    if (input === undefined) {
+                        return failWith(
+                            `quick-test schema ${filename} not found`,
+                            { qt },
+                        );
+                    }
+
+                    return [
+                        {
+                            path: input,
+                            additionalRendererOptions: ro,
+                            saveOutput: false,
+                        },
+                    ];
+                })
+                .value();
+            samples.priority = quickTestSamples.concat(samples.priority);
+        }
+
+        return samples;
     }
 
     shouldSkipTest(sample: Sample): boolean {
@@ -1508,6 +1556,11 @@ class CommandSuccessfulLanguageFixture extends LanguageFixture {
                 .flatMap((qt) => {
                     if (Array.isArray(qt)) {
                         const [filename, ro] = qt;
+                        if (filename.endsWith(".schema")) {
+                            // Runs in the JSON Schema fixture instead.
+                            return [];
+                        }
+
                         const input = _.find(
                             ([] as string[]).concat(
                                 prioritySamples,
diff --git a/test/inputs/schema/integer-type.1.json b/test/inputs/schema/integer-type.1.json
index eb9b681430..1c281a6c38 100644
--- a/test/inputs/schema/integer-type.1.json
+++ b/test/inputs/schema/integer-type.1.json
@@ -1,8 +1,11 @@
 {
   "small_positive": 50,
-  "large_positive": 2500000000,
   "small_negative": -50,
-  "large_negative": -2500000000,
-  "i32_range": 1000000000,
-  "beyond_i32": 9000000000000000000
+  "i32_range": 2147483647,
+  "above_i32_max": 2147483648,
+  "below_i32_min": -2147483649,
+  "only_minimum": 3000000000,
+  "only_maximum": -3000000000,
+  "unbounded": 9007199254740991,
+  "large_bounds": -9007199254740991
 }
diff --git a/test/inputs/schema/integer-type.schema b/test/inputs/schema/integer-type.schema
index b096a3443d..87ef95310d 100644
--- a/test/inputs/schema/integer-type.schema
+++ b/test/inputs/schema/integer-type.schema
@@ -6,38 +6,52 @@
       "minimum": 0,
       "maximum": 100
     },
-    "large_positive": {
-      "type": "integer",
-      "minimum": 0,
-      "maximum": 5000000000
-    },
     "small_negative": {
       "type": "integer",
       "minimum": -100,
       "maximum": 0
     },
-    "large_negative": {
-      "type": "integer",
-      "minimum": -5000000000,
-      "maximum": 0
-    },
     "i32_range": {
       "type": "integer",
       "minimum": -2147483648,
       "maximum": 2147483647
     },
-    "beyond_i32": {
+    "above_i32_max": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 2147483648
+    },
+    "below_i32_min": {
+      "type": "integer",
+      "minimum": -2147483649,
+      "maximum": 0
+    },
+    "only_minimum": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "only_maximum": {
+      "type": "integer",
+      "maximum": 0
+    },
+    "unbounded": {
+      "type": "integer"
+    },
+    "large_bounds": {
       "type": "integer",
-      "minimum": -9223372036854775808,
-      "maximum": 9223372036854775807
+      "minimum": -9007199254740991,
+      "maximum": 9007199254740991
     }
   },
   "required": [
     "small_positive",
-    "large_positive",
     "small_negative",
-    "large_negative",
     "i32_range",
-    "beyond_i32"
+    "above_i32_max",
+    "below_i32_min",
+    "only_minimum",
+    "only_maximum",
+    "unbounded",
+    "large_bounds"
   ]
 }
diff --git a/test/languages.ts b/test/languages.ts
index 3cd8ccc7fd..98027c2397 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -327,9 +327,12 @@ export const RustLanguage: Language = {
             "derive-debug": "false",
             "derive-clone": "false",
         },
-        { "integer-type": "conservative" },
-        { "integer-type": "force-i32" },
-        { "integer-type": "force-i64" },
+        // Exercise the integer-type option against schemas with integer
+        // bounds.  force-i32 is pinned to a schema whose sample values
+        // all fit in i32 so the round-trip still succeeds.
+        ["integer-type.schema", { "integer-type": "conservative" }],
+        ["integer-type.schema", { "integer-type": "force-i64" }],
+        ["minmax-integer.schema", { "integer-type": "force-i32" }],
     ],
     sourceFiles: ["src/language/Rust/index.ts"],
 };
@@ -733,8 +736,6 @@ export const CPlusPlusLanguage: Language = {
     skipSchema: [
         // uses too much memory
         "keyword-unions.schema",
-        // seems like a problem with integer range check
-        "integer-type.schema",
         // The generated deserializer accepts non-object values when all class properties are optional.
         "nested-intersection-union.schema",
         // Recursive top-level unions produce aliases that can refer to later aliases.

From a63c6fdb45e60bac1b3d3697362fc545a018c138 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:22:14 -0400
Subject: [PATCH 32/63] Let arrays carry identity attributes through graph
 rewriting
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ArrayType.reconstitute goes through getUniqueArrayType when its item
type isn't reconstituted yet, and that path added the type's attributes
after creation — which asserts for identity attributes.  Arrays never
had identity attributes before minItems/maxItems; now the attributes are
passed at type-creation time, like the object-type path already does.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/quicktype-core/src/GraphRewriting.ts   | 10 ++++++++--
 packages/quicktype-core/src/Type/TypeBuilder.ts |  7 +++++--
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/packages/quicktype-core/src/GraphRewriting.ts b/packages/quicktype-core/src/GraphRewriting.ts
index 69d1781ffb..7e0ece821f 100644
--- a/packages/quicktype-core/src/GraphRewriting.ts
+++ b/packages/quicktype-core/src/GraphRewriting.ts
@@ -189,8 +189,14 @@ export class TypeReconstituter<TBuilder extends BaseGraphRewriteBuilder> {
     }
 
     public getUniqueArrayType(): void {
-        this.registerAndAddAttributes(
-            this.builderForNewType().getUniqueArrayType(this._forwardingRef),
+        // The attributes must be passed at creation, not added
+        // afterwards with `addAttributes`, which would assert on
+        // identity attributes such as minItems/maxItems.
+        this.register(
+            this.builderForNewType().getUniqueArrayType(
+                this._typeAttributes,
+                this._forwardingRef,
+            ),
         );
     }
 
diff --git a/packages/quicktype-core/src/Type/TypeBuilder.ts b/packages/quicktype-core/src/Type/TypeBuilder.ts
index bb2edba208..d358c6175b 100644
--- a/packages/quicktype-core/src/Type/TypeBuilder.ts
+++ b/packages/quicktype-core/src/Type/TypeBuilder.ts
@@ -479,11 +479,14 @@ export class TypeBuilder {
         this.registerType(type);
     }
 
-    public getUniqueArrayType(forwardingRef?: TypeRef): TypeRef {
+    public getUniqueArrayType(
+        attributes?: TypeAttributes,
+        forwardingRef?: TypeRef,
+    ): TypeRef {
         return this.addType(
             forwardingRef,
             (tr) => new ArrayType(tr, this.typeGraph, undefined),
-            undefined,
+            attributes,
         );
     }
 

From 615b20b177f3d20af0b569727c91994798bc4677 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:22:18 -0400
Subject: [PATCH 33/63] test: expected-output fixtures for JSON inputs

The JSON fixture harness asserts round-trip output ~ input, with
unconditional leniency: extra null properties in the output are always
allowed, and allowMissingNull languages may drop nulls.  Correct
behaviors where the output legitimately differs from the input were
therefore untestable -- concretely, that Go's omitempty drops null
fields.

Port the JSON Schema fixtures' `.out.<feature>.json` convention to JSON
inputs: an input `foo.json` may come with an expected-output file
`foo.out.<key>.json`, which applies to a run when `<key>` is one of the
language's `features` or the name of a renderer option that the
particular run sets (via a pinned `quickTestRendererOptions` entry).
When it applies, the output must match strictly, without the null
leniency; when absent, behavior is unchanged.  `.out.` files are
excluded from test-input enumeration.

Use it to assert the omit-empty behavior from #2509: a pinned Go run of
priority/omit-empty.json with omit-empty enabled must drop the null
field, per omit-empty.out.omit-empty.json.  The input is in priority/
(not misc/) so it also runs under QUICKTEST in CI.

Salvaged from #2509; the test case is Adam724's.

Co-authored-by: Adam724 <alaspina6@gmail.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/fixtures.ts                              | 33 ++++++++++++++++---
 test/inputs/json/priority/omit-empty.json     | 11 +++++++
 .../priority/omit-empty.out.omit-empty.json   | 10 ++++++
 test/languages.ts                             |  7 +++-
 test/utils.ts                                 |  6 +++-
 5 files changed, 61 insertions(+), 6 deletions(-)
 create mode 100644 test/inputs/json/priority/omit-empty.json
 create mode 100644 test/inputs/json/priority/omit-empty.out.omit-empty.json

diff --git a/test/fixtures.ts b/test/fixtures.ts
index dece181ef6..45f51eb937 100644
--- a/test/fixtures.ts
+++ b/test/fixtures.ts
@@ -359,14 +359,39 @@ class JSONFixture extends LanguageFixture {
             return 0;
         }
 
-        compareJsonFileToJson(
-            comparisonArgs(
+        // The analog of the JSON Schema fixture's `.out.<feature>.json`
+        // convention: a JSON input `foo.json` can come with an expected-output
+        // file `foo.out.<key>.json`, which applies when `<key>` is one of the
+        // language's `features`, or the name of a renderer option this
+        // particular run sets (via `quickTestRendererOptions`).  When it
+        // applies, the output must match it exactly, without the usual
+        // round-trip leniency for null properties.  This is how output that
+        // legitimately differs from the input — e.g. Go's `omitempty`
+        // dropping null fields — gets asserted.
+        let expectedFilename = filename;
+        let strict = false;
+        const expectedOutputKeys = [
+            ...this.language.features,
+            ...Object.keys(additionalRendererOptions),
+        ];
+        for (const key of expectedOutputKeys) {
+            const outFilename = filename.replace(/\.json$/, `.out.${key}.json`);
+            if (fs.existsSync(outFilename)) {
+                expectedFilename = outFilename;
+                strict = true;
+                break;
+            }
+        }
+
+        compareJsonFileToJson({
+            ...comparisonArgs(
                 this.language,
                 filename,
-                filename,
+                expectedFilename,
                 additionalRendererOptions,
             ),
-        );
+            strict,
+        });
 
         if (
             this.language.diffViaSchema &&
diff --git a/test/inputs/json/priority/omit-empty.json b/test/inputs/json/priority/omit-empty.json
new file mode 100644
index 0000000000..56425f9b78
--- /dev/null
+++ b/test/inputs/json/priority/omit-empty.json
@@ -0,0 +1,11 @@
+{
+    "results": [
+        {
+            "age": 52,
+            "name": null
+        },
+        {
+            "age": 27
+        }
+    ]
+}
diff --git a/test/inputs/json/priority/omit-empty.out.omit-empty.json b/test/inputs/json/priority/omit-empty.out.omit-empty.json
new file mode 100644
index 0000000000..809e3cfa02
--- /dev/null
+++ b/test/inputs/json/priority/omit-empty.out.omit-empty.json
@@ -0,0 +1,10 @@
+{
+    "results": [
+        {
+            "age": 52
+        },
+        {
+            "age": 27
+        }
+    ]
+}
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..1aedcb4024 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -500,7 +500,12 @@ export const GoLanguage: Language = {
         "postman-collection.schema",
     ],
     rendererOptions: {},
-    quickTestRendererOptions: [],
+    quickTestRendererOptions: [
+        // Runs against the expected-output file
+        // `omit-empty.out.omit-empty.json`, which asserts that `omitempty`
+        // actually drops the null field.
+        ["omit-empty.json", { "omit-empty": "true" }],
+    ],
     sourceFiles: ["src/language/Golang/index.ts"],
 };
 
diff --git a/test/utils.ts b/test/utils.ts
index db98e3101b..3a6d1f4bc2 100644
--- a/test/utils.ts
+++ b/test/utils.ts
@@ -186,7 +186,11 @@ export async function inDir(dir: string, work: () => Promise<void>) {
 }
 
 export function testsInDir(dir: string, extension: string): string[] {
-    return shell.ls(`${dir}/*.${extension}`);
+    // Expected-output files (`foo.out.<key>.json`) accompany test inputs;
+    // they are never test inputs themselves.
+    return shell
+        .ls(`${dir}/*.${extension}`)
+        .filter((fn) => !/\.out\.[^./]+\.[^./]+$/.test(fn));
 }
 
 export interface Sample {

From b66dd02b656e78f67f97d364b25464378476a91b Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:23:11 -0400
Subject: [PATCH 34/63] feat(csharp): option to suppress DateOnly/TimeOnly
 converters (System.Text.Json)

The System.Text.Json C# renderer unconditionally emits DateOnlyConverter
and TimeOnlyConverter helper classes and registers them in
Converter.Settings.  DateOnly and TimeOnly only exist on .NET 6+, so the
generated code does not compile on .NET Standard or older targets
(issue #2629).

Add a System.Text.Json-only boolean option,
--[no-]dateonly-timeonly-converters (on by default), that suppresses
both the converter classes and their registration.  Nothing else in the
generated code references them, so suppressed output still compiles and
round-trips; default output is byte-for-byte identical.

The option lives in systemTextJsonCSharpOptions rather than the shared
cSharpOptions, so only the System.Text.Json renderer's typed options
include it; CSharpTargetLanguage.getOptions() now returns the
System.Text.Json superset so the CLI accepts the flag.

Covered by a pinned csharp-SystemTextJson quick-test (unions.json with
the converters suppressed must compile and round-trip) and a unit test
asserting the converter classes' presence by default and absence under
the flag.

Reimplementation of #2842 by youcefnb (findyoucef); supersedes it.
Fixes #2629.

Co-authored-by: youcefnb <youcef@colorado.edu>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../CSharp/SystemTextJsonCSharpRenderer.ts    | 26 ++++++--
 .../src/language/CSharp/language.ts           | 14 ++++-
 test/languages.ts                             |  3 +
 ...sharp-dateonly-timeonly-converters.test.ts | 59 +++++++++++++++++++
 4 files changed, 93 insertions(+), 9 deletions(-)
 create mode 100644 test/unit/csharp-dateonly-timeonly-converters.test.ts

diff --git a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
index f3eccc8df4..230077e5b0 100644
--- a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
@@ -512,8 +512,11 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
                             }
                         }
 
-                        this.emitLine("new DateOnlyConverter(),");
-                        this.emitLine("new TimeOnlyConverter(),");
+                        if (this._options.dateTimeOnlyConverters) {
+                            this.emitLine("new DateOnlyConverter(),");
+                            this.emitLine("new TimeOnlyConverter(),");
+                        }
+
                         this.emitLine("IsoDateTimeOffsetConverter.Singleton");
                         // this.emitLine("new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }");
                     });
@@ -1305,7 +1308,16 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
             this.forEachTransformation("leading-and-interposing", (n, t) =>
                 this.emitTransformation(n, t),
             );
-            this.emitMultiline(`
+            if (this._options.dateTimeOnlyConverters) {
+                this.emitDateTimeOnlyConverters();
+            }
+
+            this.emitIsoDateTimeOffsetConverter();
+        }
+    }
+
+    private emitDateTimeOnlyConverters(): void {
+        this.emitMultiline(`
 public class DateOnlyConverter : JsonConverter<DateOnly>
 {
 	private readonly string serializationFormat;
@@ -1345,9 +1357,12 @@ public class TimeOnlyConverter : JsonConverter<TimeOnly>
 
 	public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
 			=> writer.WriteStringValue(value.ToString(serializationFormat));
-}
+}`);
+    }
 
-internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
+    private emitIsoDateTimeOffsetConverter(): void {
+        this.ensureBlankLine();
+        this.emitMultiline(`internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 {
 	public override bool CanConvert(Type t) => t == typeof(DateTimeOffset);
 
@@ -1415,7 +1430,6 @@ internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 
 	public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter();
 }`);
-        }
     }
 
     protected needNamespace(): boolean {
diff --git a/packages/quicktype-core/src/language/CSharp/language.ts b/packages/quicktype-core/src/language/CSharp/language.ts
index 5501853064..a894415acb 100644
--- a/packages/quicktype-core/src/language/CSharp/language.ts
+++ b/packages/quicktype-core/src/language/CSharp/language.ts
@@ -133,7 +133,15 @@ export const cSharpOptions = {
 
 export const newtonsoftCSharpOptions = { ...cSharpOptions };
 
-export const systemTextJsonCSharpOptions = { ...cSharpOptions };
+export const systemTextJsonCSharpOptions = {
+    ...cSharpOptions,
+    dateTimeOnlyConverters: new BooleanOption(
+        "dateonly-timeonly-converters",
+        "Emit DateOnly/TimeOnly converters (requires .NET 6 or later)",
+        true,
+        "secondary",
+    ),
+};
 
 export const cSharpLanguageConfig = {
     displayName: "C#",
@@ -148,8 +156,8 @@ export class CSharpTargetLanguage extends TargetLanguage<
         super(cSharpLanguageConfig);
     }
 
-    public getOptions(): typeof cSharpOptions {
-        return cSharpOptions;
+    public getOptions(): typeof systemTextJsonCSharpOptions {
+        return systemTextJsonCSharpOptions;
     }
 
     public get stringTypeMapping(): StringTypeMapping {
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..291fd6ec38 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -180,6 +180,9 @@ export const CSharpLanguageSystemTextJson: Language = {
         { density: "dense" },
         { "number-type": "decimal" },
         { "any-type": "dynamic" },
+        // Suppressing the DateOnly/TimeOnly converters (for pre-.NET 6
+        // targets) must still produce compiling, round-tripping code.
+        ["unions.json", { "dateonly-timeonly-converters": "false" }],
     ],
     sourceFiles: ["src/language/CSharp/index.ts"],
 };
diff --git a/test/unit/csharp-dateonly-timeonly-converters.test.ts b/test/unit/csharp-dateonly-timeonly-converters.test.ts
new file mode 100644
index 0000000000..8824348605
--- /dev/null
+++ b/test/unit/csharp-dateonly-timeonly-converters.test.ts
@@ -0,0 +1,59 @@
+import {
+    InputData,
+    JSONSchemaInput,
+    type RendererOptions,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+import { describe, expect, test } from "vitest";
+
+async function renderCSharp(
+    rendererOptions: RendererOptions = {},
+): Promise<string> {
+    const schema = {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            count: { type: "integer" },
+        },
+        required: ["name", "count"],
+    };
+
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({
+        name: "TopLevel",
+        schema: JSON.stringify(schema),
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({
+        inputData,
+        lang: "csharp",
+        rendererOptions: { framework: "SystemTextJson", ...rendererOptions },
+    });
+    return result.lines.join("\n");
+}
+
+describe("C# System.Text.Json DateOnly/TimeOnly converters", () => {
+    test("emits the converters by default", async () => {
+        const output = await renderCSharp();
+
+        expect(output).toContain("class DateOnlyConverter");
+        expect(output).toContain("class TimeOnlyConverter");
+        expect(output).toContain("new DateOnlyConverter(),");
+        expect(output).toContain("new TimeOnlyConverter(),");
+    });
+
+    test("omits the converters with dateonly-timeonly-converters=false", async () => {
+        const output = await renderCSharp({
+            "dateonly-timeonly-converters": "false",
+        });
+
+        expect(output).not.toContain("DateOnlyConverter");
+        expect(output).not.toContain("TimeOnlyConverter");
+        // The DateTimeOffset converter is unaffected.
+        expect(output).toContain("class IsoDateTimeOffsetConverter");
+        expect(output).toContain("IsoDateTimeOffsetConverter.Singleton");
+    });
+});

From 6c5b447e0c66e712853ec90705c2f2277f8aa4c3 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:23:39 -0400
Subject: [PATCH 35/63] Add min-max-items fixture tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The schema covers arrays with only minItems, only maxItems, both,
neither, and union item types.  The expected-failure samples are gated
on a new "minmaxitems" feature, declared only by typescript-zod — the
one tested language whose generated code enforces the constraints at
runtime (z.array(...).min/.max).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../min-max-items.1.fail.minmaxitems.json     |  7 ++++
 test/inputs/schema/min-max-items.1.json       |  7 ++++
 .../min-max-items.2.fail.minmaxitems.json     |  7 ++++
 test/inputs/schema/min-max-items.2.json       |  7 ++++
 test/inputs/schema/min-max-items.schema       | 41 +++++++++++++++++++
 test/languages.ts                             |  3 +-
 6 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 test/inputs/schema/min-max-items.1.fail.minmaxitems.json
 create mode 100644 test/inputs/schema/min-max-items.1.json
 create mode 100644 test/inputs/schema/min-max-items.2.fail.minmaxitems.json
 create mode 100644 test/inputs/schema/min-max-items.2.json
 create mode 100644 test/inputs/schema/min-max-items.schema

diff --git a/test/inputs/schema/min-max-items.1.fail.minmaxitems.json b/test/inputs/schema/min-max-items.1.fail.minmaxitems.json
new file mode 100644
index 0000000000..9e45bbc7ee
--- /dev/null
+++ b/test/inputs/schema/min-max-items.1.fail.minmaxitems.json
@@ -0,0 +1,7 @@
+{
+  "minOnly": ["one"],
+  "maxOnly": [1, 2, 3],
+  "minAndMax": [1.25, 2.5],
+  "plain": [],
+  "unionItems": [1, "two", 3]
+}
diff --git a/test/inputs/schema/min-max-items.1.json b/test/inputs/schema/min-max-items.1.json
new file mode 100644
index 0000000000..0d5c53a959
--- /dev/null
+++ b/test/inputs/schema/min-max-items.1.json
@@ -0,0 +1,7 @@
+{
+  "minOnly": ["one", "two"],
+  "maxOnly": [1, 2, 3],
+  "minAndMax": [1.25, 2.5],
+  "plain": [],
+  "unionItems": [1, "two", 3]
+}
diff --git a/test/inputs/schema/min-max-items.2.fail.minmaxitems.json b/test/inputs/schema/min-max-items.2.fail.minmaxitems.json
new file mode 100644
index 0000000000..6db25cd8fb
--- /dev/null
+++ b/test/inputs/schema/min-max-items.2.fail.minmaxitems.json
@@ -0,0 +1,7 @@
+{
+  "minOnly": ["one", "two", "three"],
+  "maxOnly": [1, 2, 3, 4],
+  "minAndMax": [3.75],
+  "plain": ["only"],
+  "unionItems": ["one", 2]
+}
diff --git a/test/inputs/schema/min-max-items.2.json b/test/inputs/schema/min-max-items.2.json
new file mode 100644
index 0000000000..7bb633b93d
--- /dev/null
+++ b/test/inputs/schema/min-max-items.2.json
@@ -0,0 +1,7 @@
+{
+  "minOnly": ["one", "two", "three"],
+  "maxOnly": [],
+  "minAndMax": [3.75],
+  "plain": ["only"],
+  "unionItems": ["one", 2]
+}
diff --git a/test/inputs/schema/min-max-items.schema b/test/inputs/schema/min-max-items.schema
new file mode 100644
index 0000000000..7aaf9e8092
--- /dev/null
+++ b/test/inputs/schema/min-max-items.schema
@@ -0,0 +1,41 @@
+{
+  "type": "object",
+  "properties": {
+    "minOnly": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 2
+    },
+    "maxOnly": {
+      "type": "array",
+      "items": {
+        "type": "integer"
+      },
+      "maxItems": 3
+    },
+    "minAndMax": {
+      "type": "array",
+      "items": {
+        "type": "number"
+      },
+      "minItems": 1,
+      "maxItems": 4
+    },
+    "plain": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "unionItems": {
+      "type": "array",
+      "items": {
+        "type": ["integer", "string"]
+      },
+      "minItems": 2
+    }
+  },
+  "required": ["minOnly", "maxOnly", "minAndMax", "plain", "unionItems"]
+}
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..102530b40d 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -57,6 +57,7 @@ export type LanguageFeature =
     | "uuid"
     | "minmax"
     | "minmaxlength"
+    | "minmaxitems"
     | "pattern";
 
 export interface Language {
@@ -1864,7 +1865,7 @@ export const TypeScriptZodLanguage: Language = {
         "e8b04.json",
     ],
     allowMissingNull: false,
-    features: ["enum", "union", "no-defaults", "date-time"],
+    features: ["enum", "union", "no-defaults", "date-time", "minmaxitems"],
     output: "TopLevel.ts",
     topLevel: "TopLevel",
     skipJSON: [

From 8f09c2127fef9d9bc79f2343cd3743d982242462 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:38:50 -0400
Subject: [PATCH 36/63] Skip pre-existing schema-typescript failures

The schema-typescript fixture is not in the CI matrix yet; running it
locally hits three schemas whose generated interfaces mix declared
properties with a typed-additionalProperties index signature (TS2411).
They fail identically with unmodified master, so skip them with a note.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/languages.ts | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/test/languages.ts b/test/languages.ts
index 102530b40d..5ad1842cc1 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -986,7 +986,17 @@ export const TypeScriptLanguage: Language = {
     topLevel: "TopLevel",
     skipJSON: [],
     skipMiscJSON: false,
-    skipSchema: ["keyword-unions.schema"], // can't handle "constructor" property
+    skipSchema: [
+        "keyword-unions.schema", // can't handle "constructor" property
+        // Pre-existing failures (this fixture is not in CI yet, and these
+        // fail with unmodified master too): objects with both declared
+        // properties and typed additionalProperties render as an interface
+        // whose properties are not assignable to its index signature
+        // (TS2411).
+        "class-map-union.schema",
+        "class-with-additional.schema",
+        "vega-lite.schema",
+    ],
     rendererOptions: { "explicit-unions": "yes" },
     quickTestRendererOptions: [
         { "runtime-typecheck": "false" },

From cef6206f116914d11b5094895346dda5baa2e114 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 12:50:50 -0400
Subject: [PATCH 37/63] test(elm): retry elm make after clearing elm-stuff

The Elm compiler's per-project cache locking is flaky under heavy
parallel load ("elm-stuff/0.19.2/d.dat: withBinaryFile: resource busy
(file is locked)", elm/compiler#2258, seen in CI run 29758296129). The
canonical workaround is to delete elm-stuff and rebuild; do that
automatically on the first compile failure. The retry rebuilds
dependencies from the warmed shared ELM_HOME, so it only costs time
when the flake actually strikes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/languages.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..8bbf5d8580 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -761,7 +761,11 @@ export const ElmLanguage: Language = {
     // package cache when parallel compiles race on a cold cache (still
     // reproducible with elm 0.19.2).
     setupCommand: "rm -rf elm-stuff && elm make Warmup.elm --output=/dev/null",
-    compileCommand: "elm make Main.elm --output elm.js",
+    // The retry after clearing elm-stuff works around the compiler's flaky
+    // per-project cache locking ("d.dat: withBinaryFile: resource busy",
+    // elm/compiler#2258), which strikes under heavy parallel load.
+    compileCommand:
+        "elm make Main.elm --output elm.js || (rm -rf elm-stuff && elm make Main.elm --output elm.js)",
     runCommand(sample: string) {
         return `node ./runner.js "${sample}"`;
     },

From b632d0312a0f0a0cef8967ef055b90848eb2a8ac Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 13:23:23 -0400
Subject: [PATCH 38/63] Fix process.process.exit typo in the test harness error
 path

When main() rejects (e.g. a fixture setupCommand fails on a network
flake), the catch handler crashed with "Cannot read properties of
undefined (reading 'exit')" instead of exiting cleanly, burying the
real error under a TypeError. Introduced in 232e259e.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test.ts b/test/test.ts
index dd9a1933a5..a3c87d1d29 100755
--- a/test/test.ts
+++ b/test/test.ts
@@ -85,5 +85,5 @@ async function main(sources: string[]) {
 // skip 2 `node` args
 main(process.argv.slice(2)).catch((reason) => {
     console.error(reason);
-    process.process.exit(1);
+    process.exit(1);
 });

From e52e675777ecf0b2bec16fb8a1b41ad28327f0a4 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 13:42:33 -0400
Subject: [PATCH 39/63] Skip min-max-items.schema for kotlinx
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

unionItems is an int|string union array; kotlinx renders unions as
sealed classes without serializer wiring, so decoding the bare JSON
literals fails at runtime (#2951) — same reason as the other union
schemas in this list.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 test/languages.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/languages.ts b/test/languages.ts
index 5ad1842cc1..c903215dc2 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1563,6 +1563,7 @@ export const KotlinXLanguage: Language = {
         "implicit-class-array-union.schema",
         "integer-float-union.schema",
         "integer-string.schema",
+        "min-max-items.schema", // unionItems is an int|string union array
         "minmaxlength.schema",
         "multi-type-enum.schema",
         "mutually-recursive.schema",

From 56737cefddc54ef5ac583040ba6e7428ef125012 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:35:18 -0400
Subject: [PATCH 40/63] fix(typescript-zod): preserve null for nullable
 date-time fields (#2880)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../language/TypeScriptZod/TypeScriptZodRenderer.ts   | 11 ++++++++---
 test/languages.ts                                     |  3 ---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts b/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
index 6406101476..580d65e364 100644
--- a/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
+++ b/packages/quicktype-core/src/language/TypeScriptZod/TypeScriptZodRenderer.ts
@@ -124,9 +124,14 @@ export class TypeScriptZodRenderer extends ConvenienceRenderer {
             ],
             (_enumType) => panic("Should already be handled."),
             (unionType) => {
-                const children = Array.from(unionType.getChildren()).map(
-                    (type: Type) => this.typeMapTypeFor(type, false),
-                );
+                const children = Array.from(unionType.getChildren())
+                    // Coercing schemas can accept null, so handle it first.
+                    .sort(
+                        (a, b) =>
+                            Number(b.kind === "null") -
+                            Number(a.kind === "null"),
+                    )
+                    .map((type: Type) => this.typeMapTypeFor(type, false));
                 return ["z.union([", ...arrayIntercalate(", ", children), "])"];
             },
             (_transformedStringType) => {
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..8e5da86de3 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1879,9 +1879,6 @@ export const TypeScriptZodLanguage: Language = {
         // Does not handle top level array
         "bug863.json",
 
-        // z.coerce.date() coerces null to the Unix epoch: #2880
-        "bug2590.json",
-
         "no-classes.json",
         "00c36.json",
         "10be4.json",

From d12b24f6c2f6171ec9f5b5c33070366ebbe5e56d Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:36:26 -0400
Subject: [PATCH 41/63] fix(schema-input): report clean fetch error for missing
 schema paths (#2812)

When --src-lang schema was given a nonexistent source path (e.g. a literal
wildcard like '*.json' that a shell such as PowerShell doesn't expand),
JSONSchemaStore.get swallowed the fetch error and returned undefined, and
Resolver.resolveVirtualRef then tried to read virtualRef.address on a Ref
with no address, panicking with "Internal error: Defined value expected,
but got undefined." instead of a real diagnostic.

Use virtualRef.toString() (which doesn't require an address) when building
the fetch-error message, so a missing schema path now reports a normal
"Could not fetch schema ..." error instead of crashing.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/input/JSONSchemaInput.ts              |  2 +-
 test/unit/missing-schema-path.test.ts         | 36 +++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 test/unit/missing-schema-path.test.ts

diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index d3a0e4feef..70a51256ee 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -783,7 +783,7 @@ class Resolver {
             return [schema, result[1]];
         }
 
-        return schemaFetchError(base, virtualRef.address);
+        return schemaFetchError(base, virtualRef.toString());
     }
 
     public async resolveTopLevelRef(ref: Ref): Promise<[JSONSchema, Location]> {
diff --git a/test/unit/missing-schema-path.test.ts b/test/unit/missing-schema-path.test.ts
new file mode 100644
index 0000000000..8656b820dd
--- /dev/null
+++ b/test/unit/missing-schema-path.test.ts
@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+    FetchingJSONSchemaStore,
+    InputData,
+    JSONSchemaInput,
+    quicktype,
+} from "quicktype-core";
+import { expect, test } from "vitest";
+
+// Regression test for issue #2812: shells such as PowerShell pass wildcard
+// arguments through literally, so a schema wildcard with no matching file must
+// report a normal missing-file error rather than an internal error.
+test("missing JSON Schema paths report the fetch error", async () => {
+    const tempDir = fs.mkdtempSync(
+        path.join(os.tmpdir(), "quicktype-missing-schema-"),
+    );
+    const missingPath = path.join(tempDir, "*.json");
+
+    try {
+        const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+        await schemaInput.addSource({ name: "TopLevel", uris: [missingPath] });
+        const inputData = new InputData();
+        inputData.addInput(schemaInput);
+
+        await expect(
+            quicktype({ inputData, lang: "typescript" }),
+        ).rejects.toThrow(
+            `Could not fetch schema #, referred to from ${missingPath}#`,
+        );
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+});

From 1885cad234ed9207c097b4fd3e1b9279ed4b39bf Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:36:36 -0400
Subject: [PATCH 42/63] fix(typescript-input): strip brace-wrapped types from
 JSDoc @type tags (#2695)

typescript-json-schema treats a property's `@type {string}` JSDoc tag as a
"type" validation keyword and copies its raw text verbatim, braces
included, into the generated schema's `type` field. That produces invalid
JSON Schema like `"type": "{string}"`, which also makes quicktype fail hard
when that schema is later consumed for any other output language.

Sanitize the schema after generateSchema() runs: strip a single pair of
surrounding braces from any string `type` value.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../quicktype-typescript-input/src/index.ts   | 26 +++++++++++++++++++
 test/unit/typescript-input.test.ts            | 17 ++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/packages/quicktype-typescript-input/src/index.ts b/packages/quicktype-typescript-input/src/index.ts
index e29f49118f..f94edb4007 100644
--- a/packages/quicktype-typescript-input/src/index.ts
+++ b/packages/quicktype-typescript-input/src/index.ts
@@ -125,6 +125,30 @@ function patchGeneratorForBuiltinTypes(
     };
 }
 
+// typescript-json-schema copies JSDoc `@type {string}` annotations into the
+// generated schema verbatim. Strip the JSDoc braces so the value is a valid
+// JSON Schema type.
+function sanitizeTypeAnnotations(value: unknown): void {
+    if (Array.isArray(value)) {
+        value.forEach(sanitizeTypeAnnotations);
+        return;
+    }
+
+    if (value === null || typeof value !== "object") {
+        return;
+    }
+
+    const schema = value as Record<string, unknown>;
+    if (typeof schema.type === "string") {
+        const match = /^\{([^{}]+)\}$/.exec(schema.type);
+        if (match !== null) {
+            schema.type = match[1];
+        }
+    }
+
+    Object.values(schema).forEach(sanitizeTypeAnnotations);
+}
+
 // FIXME: We're stringifying and then parsing this schema again. Just pass around
 // the schema directly.
 export function schemaForTypeScriptSources(
@@ -151,6 +175,8 @@ export function schemaForTypeScriptSources(
     patchGeneratorForBuiltinTypes(generator, program);
 
     const schema = generateSchema(program, "*", settings, undefined, generator);
+    sanitizeTypeAnnotations(schema);
+
     const uris: string[] = [];
     let topLevelName = "";
 
diff --git a/test/unit/typescript-input.test.ts b/test/unit/typescript-input.test.ts
index 2e5f6a8842..dedb3335d2 100644
--- a/test/unit/typescript-input.test.ts
+++ b/test/unit/typescript-input.test.ts
@@ -84,6 +84,23 @@ describe("schemaForTypeScriptSources", () => {
         expect(schema.definitions.Person.type).toBe("object");
     });
 
+    // https://github.com/glideapps/quicktype/issues/2695
+    test("strips braces from JSDoc type annotations", () => {
+        const { schema } = schemaForSource(`
+            export type Person = {
+                /**
+                 * @type {string}
+                 * @memberOf {Person}
+                 */
+                name: string;
+            };
+
+            export type MemberInfo = Required<Person>;
+        `);
+
+        expect(schema.definitions.Person.properties.name.type).toBe("string");
+    });
+
     test("class property initializers become defaults", () => {
         const { schema } = schemaForSource(`
             export class Config {

From 45e67006c356e130761bc623bc6c96741a5a2fc3 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:38:29 -0400
Subject: [PATCH 43/63] fix(json-schema): recognize $defs when deriving type
 names (#2778)

The definitionName getter in JSONSchemaInput.ts only recognized the
legacy "definitions" keyword, so types defined under the standard
"$defs" keyword (draft 2019-09+) never had their schema-given name
treated as a given name. combineNames then merged the type's other
candidate names by common prefix, producing truncated/wrong names
(e.g. "LightParams" became "Light").

Fix: also recognize "$defs" in definitionName.

Adds a schema fixture (light.schema/light.1.json) exercising the
round trip, and a focused unit test asserting the generated
TypeScript interface keeps its given name, since fixture tests don't
observe generated symbol names.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/input/JSONSchemaInput.ts              |  2 +-
 test/inputs/schema/light.1.json               |  7 +++
 test/inputs/schema/light.schema               | 21 ++++++++
 test/unit/json-schema-definitions.test.ts     | 51 +++++++++++++++++++
 4 files changed, 80 insertions(+), 1 deletion(-)
 create mode 100644 test/inputs/schema/light.1.json
 create mode 100644 test/inputs/schema/light.schema
 create mode 100644 test/unit/json-schema-definitions.test.ts

diff --git a/packages/quicktype-core/src/input/JSONSchemaInput.ts b/packages/quicktype-core/src/input/JSONSchemaInput.ts
index d3a0e4feef..30678943dc 100644
--- a/packages/quicktype-core/src/input/JSONSchemaInput.ts
+++ b/packages/quicktype-core/src/input/JSONSchemaInput.ts
@@ -306,7 +306,7 @@ export class Ref {
     public get definitionName(): string | undefined {
         const pe = arrayGetFromEnd(this.path, 2);
         if (pe === undefined) return undefined;
-        if (keyOrIndex(pe) === "definitions")
+        if (keyOrIndex(pe) === "definitions" || keyOrIndex(pe) === "$defs")
             return keyOrIndex(defined(arrayLast(this.path)));
         return undefined;
     }
diff --git a/test/inputs/schema/light.1.json b/test/inputs/schema/light.1.json
new file mode 100644
index 0000000000..478f25fe74
--- /dev/null
+++ b/test/inputs/schema/light.1.json
@@ -0,0 +1,7 @@
+{
+  "LightParams": {
+    "outlet_id": "outlet-1",
+    "app_id": "app-1",
+    "rgba": "255,255,255,1"
+  }
+}
diff --git a/test/inputs/schema/light.schema b/test/inputs/schema/light.schema
new file mode 100644
index 0000000000..42c4b43b64
--- /dev/null
+++ b/test/inputs/schema/light.schema
@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$defs": {
+    "LightParams": {
+      "type": "object",
+      "properties": {
+        "outlet_id": { "type": "string" },
+        "app_id": { "type": "string" },
+        "rgba": { "type": "string" }
+      },
+      "additionalProperties": false,
+      "required": ["outlet_id", "app_id", "rgba"]
+    }
+  },
+  "type": "object",
+  "properties": {
+    "LightParams": { "$ref": "#/$defs/LightParams" }
+  },
+  "additionalProperties": false,
+  "required": ["LightParams"]
+}
diff --git a/test/unit/json-schema-definitions.test.ts b/test/unit/json-schema-definitions.test.ts
new file mode 100644
index 0000000000..f63702d495
--- /dev/null
+++ b/test/unit/json-schema-definitions.test.ts
@@ -0,0 +1,51 @@
+import {
+    FetchingJSONSchemaStore,
+    InputData,
+    JSONSchemaInput,
+    quicktype,
+} from "quicktype-core";
+import { expect, test } from "vitest";
+
+const lightSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $defs: {
+        LightParams: {
+            type: "object",
+            properties: {
+                outlet_id: { type: "string" },
+                app_id: { type: "string" },
+                rgba: { type: "string" },
+            },
+            additionalProperties: false,
+            required: ["outlet_id", "app_id", "rgba"],
+        },
+    },
+    type: "object",
+    properties: {
+        LightParams: { $ref: "#/$defs/LightParams" },
+    },
+    additionalProperties: false,
+    required: ["LightParams"],
+};
+
+test("a type under $defs keeps its definition name (issue #2778)", async () => {
+    const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
+    await schemaInput.addSource({
+        name: "LightSchema",
+        schema: JSON.stringify(lightSchema),
+    });
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({
+        inputData,
+        lang: "typescript",
+        rendererOptions: { "just-types": "true" },
+    });
+    const output = result.lines.join("\n");
+
+    // The fixture exercises this schema end-to-end, but generated symbol names
+    // are not observable at runtime, so assert the regression here.
+    expect(output).toContain("LightParams: LightParams;");
+    expect(output).toContain("export interface LightParams {");
+});

From 544ed4b683bc2b50d2d811de76be417584abbfd9 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:38:44 -0400
Subject: [PATCH 44/63] fix(dart): preserve null for optional list properties
 (#2656)

Dart's fromJson/toJson for nullable List properties collapsed null
into an empty array ("x == null ? [] : ..."), even though the field
is declared nullable (List<T>?). This lost the null-vs-empty-list
distinction that some APIs rely on. mapList now emits
"x == null ? null : ..." for both directions, matching the pattern
already used by mapClass for nullable class-typed properties.

Also re-enables the Dart optional-const-ref.schema fixture, which was
previously skipped specifically because of this bug (absent optional
list properties didn't round-trip).

Fixes #2656

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 packages/quicktype-core/src/language/Dart/DartRenderer.ts | 2 +-
 test/languages.ts                                         | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/quicktype-core/src/language/Dart/DartRenderer.ts b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
index 8a46bd7577..52826b851f 100644
--- a/packages/quicktype-core/src/language/Dart/DartRenderer.ts
+++ b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
@@ -322,7 +322,7 @@ export class DartRenderer extends ConvenienceRenderer {
         if (isNullable && !this._options.requiredProperties) {
             return [
                 list,
-                " == null ? [] : ",
+                " == null ? null : ",
                 "List<",
                 itemType,
                 ">.from(",
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..94096fd824 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1621,9 +1621,6 @@ export const DartLanguage: Language = {
         "keyword-unions.schema",
         "ref-remote.schema",
         "uuid.schema",
-        /* Absent optional lists don't round-trip: the generated fromJson/toJson
-           turn them into [], so the output no longer matches the input */
-        "optional-const-ref.schema",
     ],
     skipMiscJSON: true,
     rendererOptions: {},

From 24db80635ae14200fae10e5c6730d1e19f8d1dfa Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:42:36 -0400
Subject: [PATCH 45/63] fix(cli): surface clear error for duplicate -o instead
 of internal error (#2457)

Passing a singular CLI option twice (e.g. `-o a -o b`) made
command-line-args throw ALREADY_SET even during partial parsing, which
tripped an assert in parseOptions() and surfaced an opaque "Internal
error: Partial option parsing should not have failed" instead of the
library's clear message. Drop the assert so partial-parse failures
flow through the same messageError("DriverCLIOptionParsingFailed", ...)
path as non-partial failures.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 src/index.ts                  |  1 -
 test/unit/cli-options.test.ts | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 test/unit/cli-options.test.ts

diff --git a/src/index.ts b/src/index.ts
index 6ae510e25b..d22d5e70f5 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -751,7 +751,6 @@ function parseOptions(
             { argv, partial },
         );
     } catch (e) {
-        assert(!partial, "Partial option parsing should not have failed");
         return messageError("DriverCLIOptionParsingFailed", {
             message: exceptionToString(e),
         });
diff --git a/test/unit/cli-options.test.ts b/test/unit/cli-options.test.ts
new file mode 100644
index 0000000000..44b22288c9
--- /dev/null
+++ b/test/unit/cli-options.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, test } from "vitest";
+
+import { parseCLIOptions } from "../../src/index.js";
+
+describe("CLI option parsing", () => {
+    test("reports a duplicate output option as a user input error", () => {
+        expect(() =>
+            parseCLIOptions(["-o", "list.go", "-o", "list.ts"]),
+        ).toThrow(/^Option parsing failed: .*Singular option already set/);
+
+        expect(() =>
+            parseCLIOptions(["-o", "list.go", "-o", "list.ts"]),
+        ).not.toThrow("Internal error");
+    });
+});

From 44fe04bf430222d4343a82df55c3d13a4253fe93 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:44:21 -0400
Subject: [PATCH 46/63] fix(schema): emit min/max constraints for applicable
 type kinds (#2557)

The applicability guard in MinMaxConstraintTypeAttributeKind.addToSchema
was inverted: it skipped emitting minimum/maximum/minLength/maxLength
exactly when the type's kind WAS applicable, so schema-to-schema
round-trips silently dropped these constraints (pattern and description
were unaffected since PatternTypeAttributeKind used the correct polarity).

Added a schema-schema fixture (test/fixtures/schema/main.js) that
validates round-tripped JSON Schema output with AJV, plus
test/inputs/schema/schema-constraints.schema with pass/fail samples
exercising minLength/maxLength/minimum/maximum, which fail before this
fix and pass after it.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/attributes/Constraints.ts             |  2 +-
 test/fixtures.ts                              |  1 +
 test/fixtures/schema/main.js                  | 22 +++++++++++++++++++
 ...chema-constraints.1.fail.minmaxlength.json |  4 ++++
 test/inputs/schema/schema-constraints.1.json  |  4 ++++
 ...chema-constraints.2.fail.minmaxlength.json |  4 ++++
 .../schema-constraints.3.fail.minmax.json     |  4 ++++
 .../schema-constraints.4.fail.minmax.json     |  4 ++++
 test/inputs/schema/schema-constraints.schema  | 16 ++++++++++++++
 test/languages.ts                             | 20 +++++++++++++++++
 10 files changed, 80 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/schema/main.js
 create mode 100644 test/inputs/schema/schema-constraints.1.fail.minmaxlength.json
 create mode 100644 test/inputs/schema/schema-constraints.1.json
 create mode 100644 test/inputs/schema/schema-constraints.2.fail.minmaxlength.json
 create mode 100644 test/inputs/schema/schema-constraints.3.fail.minmax.json
 create mode 100644 test/inputs/schema/schema-constraints.4.fail.minmax.json
 create mode 100644 test/inputs/schema/schema-constraints.schema

diff --git a/packages/quicktype-core/src/attributes/Constraints.ts b/packages/quicktype-core/src/attributes/Constraints.ts
index 4ef6561866..54a8a0ed23 100644
--- a/packages/quicktype-core/src/attributes/Constraints.ts
+++ b/packages/quicktype-core/src/attributes/Constraints.ts
@@ -97,7 +97,7 @@ export class MinMaxConstraintTypeAttributeKind extends TypeAttributeKind<MinMaxC
         t: Type,
         attr: MinMaxConstraint,
     ): void {
-        if (this._typeKinds.has(t.kind)) return;
+        if (!this._typeKinds.has(t.kind)) return;
 
         const [min, max] = attr;
         if (min !== undefined) {
diff --git a/test/fixtures.ts b/test/fixtures.ts
index dece181ef6..1e2eba6675 100644
--- a/test/fixtures.ts
+++ b/test/fixtures.ts
@@ -1587,6 +1587,7 @@ export const allFixtures: Fixture[] = [
     new JSONSchemaJSONFixture(languages.CSharpLanguage),
     new JSONTypeScriptFixture(languages.CSharpLanguage),
     // new JSONSchemaFixture(languages.CrystalLanguage),
+    new JSONSchemaFixture(languages.JSONSchemaLanguage),
     new JSONSchemaFixture(languages.CSharpLanguage),
     new JSONSchemaFixture(
         languages.CSharpLanguageSystemTextJson,
diff --git a/test/fixtures/schema/main.js b/test/fixtures/schema/main.js
new file mode 100644
index 0000000000..4154703efe
--- /dev/null
+++ b/test/fixtures/schema/main.js
@@ -0,0 +1,22 @@
+const fs = require("node:fs");
+
+const Ajv = require("ajv");
+const addFormats = require("ajv-formats");
+const draft06MetaSchema = require("ajv/dist/refs/json-schema-draft-06.json");
+
+const schema = JSON.parse(fs.readFileSync("TopLevel.schema", "utf8"));
+const input = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+
+const ajv = new Ajv({ ownProperties: true });
+ajv.addMetaSchema(draft06MetaSchema);
+addFormats(ajv);
+ajv.addVocabulary(["qt-uri-protocols", "qt-uri-extensions"]);
+ajv.addFormat("integer", true);
+ajv.addFormat("boolean", true);
+
+if (!ajv.validate(schema, input)) {
+    console.error(ajv.errorsText());
+    process.exit(1);
+}
+
+console.log(JSON.stringify(input));
diff --git a/test/inputs/schema/schema-constraints.1.fail.minmaxlength.json b/test/inputs/schema/schema-constraints.1.fail.minmaxlength.json
new file mode 100644
index 0000000000..a97fbc7d0d
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.1.fail.minmaxlength.json
@@ -0,0 +1,4 @@
+{
+  "minMaxLength": "1234",
+  "percent": 0.5
+}
diff --git a/test/inputs/schema/schema-constraints.1.json b/test/inputs/schema/schema-constraints.1.json
new file mode 100644
index 0000000000..e9d5e80644
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.1.json
@@ -0,0 +1,4 @@
+{
+  "minMaxLength": "12345",
+  "percent": 0.5
+}
diff --git a/test/inputs/schema/schema-constraints.2.fail.minmaxlength.json b/test/inputs/schema/schema-constraints.2.fail.minmaxlength.json
new file mode 100644
index 0000000000..74468bc773
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.2.fail.minmaxlength.json
@@ -0,0 +1,4 @@
+{
+  "minMaxLength": "123456",
+  "percent": 0.5
+}
diff --git a/test/inputs/schema/schema-constraints.3.fail.minmax.json b/test/inputs/schema/schema-constraints.3.fail.minmax.json
new file mode 100644
index 0000000000..6c4d06e986
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.3.fail.minmax.json
@@ -0,0 +1,4 @@
+{
+  "minMaxLength": "12345",
+  "percent": -0.5
+}
diff --git a/test/inputs/schema/schema-constraints.4.fail.minmax.json b/test/inputs/schema/schema-constraints.4.fail.minmax.json
new file mode 100644
index 0000000000..15899cab42
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.4.fail.minmax.json
@@ -0,0 +1,4 @@
+{
+  "minMaxLength": "12345",
+  "percent": 2
+}
diff --git a/test/inputs/schema/schema-constraints.schema b/test/inputs/schema/schema-constraints.schema
new file mode 100644
index 0000000000..ad847eee04
--- /dev/null
+++ b/test/inputs/schema/schema-constraints.schema
@@ -0,0 +1,16 @@
+{
+  "type": "object",
+  "properties": {
+    "minMaxLength": {
+      "type": "string",
+      "minLength": 5,
+      "maxLength": 5
+    },
+    "percent": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    }
+  },
+  "required": ["minMaxLength", "percent"]
+}
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..7c6d2eca82 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -81,6 +81,26 @@ export interface Language {
     sourceFiles?: string[];
 }
 
+export const JSONSchemaLanguage: Language = {
+    name: "schema",
+    base: "test/fixtures/schema",
+    runCommand(sample: string) {
+        return `node main.js "${sample}"`;
+    },
+    diffViaSchema: false,
+    skipDiffViaSchema: [],
+    allowMissingNull: false,
+    features: ["minmax", "minmaxlength", "pattern"],
+    output: "TopLevel.schema",
+    topLevel: "TopLevel",
+    skipJSON: [],
+    skipMiscJSON: false,
+    skipSchema: [],
+    rendererOptions: {},
+    quickTestRendererOptions: [],
+    sourceFiles: ["src/language/JSONSchema/JSONSchemaRenderer.ts"],
+};
+
 export const CSharpLanguage: Language = {
     name: "csharp",
     base: "test/fixtures/csharp",

From e52d5303cee2723b3ac3f93247cf41b5561b2bc9 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:49:24 -0400
Subject: [PATCH 47/63] fix(csharp): throw JsonException/NotSupportedException
 in SystemTextJson converters (#2364)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../CSharp/SystemTextJsonCSharpRenderer.ts    | 11 +++--
 ...csharp-system-text-json-exceptions.test.ts | 45 +++++++++++++++++++
 2 files changed, 52 insertions(+), 4 deletions(-)
 create mode 100644 test/unit/csharp-system-text-json-exceptions.test.ts

diff --git a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
index f3eccc8df4..2012326edd 100644
--- a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
@@ -375,8 +375,11 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
         this.emitLine("case JsonTokenType.", tokenType, ":");
     }
 
-    private emitThrow(message: Sourcelike): void {
-        this.emitLine("throw new Exception(", message, ");");
+    private emitThrow(
+        exceptionType: "JsonException" | "NotSupportedException",
+        message: Sourcelike,
+    ): void {
+        this.emitLine("throw new ", exceptionType, "(", message, ");");
     }
 
     private deserializeTypeCode(typeName: Sourcelike): Sourcelike {
@@ -1239,7 +1242,7 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
                         (v) => this.emitLine("return ", v, ";"),
                     );
                     if (!allHandled) {
-                        this.emitThrow([
+                        this.emitThrow("JsonException", [
                             '"Cannot unmarshal type ',
                             csType,
                             '"',
@@ -1266,7 +1269,7 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
                             () => this.emitLine("return;"),
                         );
                         if (!allHandled) {
-                            this.emitThrow([
+                            this.emitThrow("NotSupportedException", [
                                 '"Cannot marshal type ',
                                 csType,
                                 '"',
diff --git a/test/unit/csharp-system-text-json-exceptions.test.ts b/test/unit/csharp-system-text-json-exceptions.test.ts
new file mode 100644
index 0000000000..04ddc339b7
--- /dev/null
+++ b/test/unit/csharp-system-text-json-exceptions.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, test } from "vitest";
+
+import {
+    InputData,
+    JSONSchemaInput,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+
+async function renderSystemTextJsonCSharp(schema: object): Promise<string> {
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({
+        name: "TopLevel",
+        schema: JSON.stringify(schema),
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({
+        inputData,
+        lang: "csharp",
+        rendererOptions: { framework: "SystemTextJson" },
+    });
+    return result.lines.join("\n");
+}
+
+describe("C# System.Text.Json converters", () => {
+    test("throw serializer-supported exceptions for union conversion failures", async () => {
+        const output = await renderSystemTextJsonCSharp({
+            type: "object",
+            properties: {
+                mixed: { oneOf: [{ type: "integer" }, { type: "string" }] },
+            },
+            required: ["mixed"],
+        });
+
+        expect(output).toContain(
+            'throw new JsonException("Cannot unmarshal type Mixed");',
+        );
+        expect(output).toContain(
+            'throw new NotSupportedException("Cannot marshal type Mixed");',
+        );
+        expect(output).not.toContain("throw new Exception(");
+    });
+});

From 4b6e2b39b3e672fb2a5972f84a0f178ab3cd4457 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:51:12 -0400
Subject: [PATCH 48/63] fix(typescript): annotate m() helper's props array to
 satisfy noImplicitAny (#2430)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/language/JavaScript/JavaScriptRenderer.ts             | 3 ++-
 test/fixtures/typescript/tsconfig.json                        | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/quicktype-core/src/language/JavaScript/JavaScriptRenderer.ts b/packages/quicktype-core/src/language/JavaScript/JavaScriptRenderer.ts
index c14a44efdb..def7a00ee1 100644
--- a/packages/quicktype-core/src/language/JavaScript/JavaScriptRenderer.ts
+++ b/packages/quicktype-core/src/language/JavaScript/JavaScriptRenderer.ts
@@ -473,7 +473,8 @@ function o(props${anyArrayAnnotation}, additional${anyAnnotation}) {
 }
 
 function m(additional${anyAnnotation}) {
-    return { props: [], additional };
+    const props${anyArrayAnnotation} = [];
+    return { props, additional };
 }
 
 function r(name${stringAnnotation}) {
diff --git a/test/fixtures/typescript/tsconfig.json b/test/fixtures/typescript/tsconfig.json
index a4d26e23cd..6bcd3937d1 100644
--- a/test/fixtures/typescript/tsconfig.json
+++ b/test/fixtures/typescript/tsconfig.json
@@ -1,7 +1,9 @@
 {
     "compilerOptions": {
         "target": "es6",
-        "noEmit": true
+        "noEmit": true,
+        "noImplicitAny": true,
+        "strictNullChecks": false
     },
     "files": ["main.ts"]
 }

From 15599a45792db35797db4bb08188588c8ae1bbd9 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:51:13 -0400
Subject: [PATCH 49/63] fix(c++): include Generators.hpp and name real types in
 multi-source usage comments (#2438)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../language/CPlusPlus/CPlusPlusRenderer.ts   | 15 ++---
 test/fixtures.ts                              |  4 ++
 test/fixtures/cplusplus/main.cpp              |  3 +-
 test/languages.ts                             | 10 +++-
 test/unit/cplusplus-multi-source.test.ts      | 59 +++++++++++++++++++
 5 files changed, 76 insertions(+), 15 deletions(-)
 create mode 100644 test/unit/cplusplus-multi-source.test.ts

diff --git a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
index ec99e8029b..af927cc209 100644
--- a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
+++ b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
@@ -503,21 +503,13 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                 "",
             ]);
 
-            if (this._options.typeSourceStyle) {
-                this.forEachTopLevel("none", (_, topLevelName) => {
-                    this.emitLine(
-                        "//     ",
-                        topLevelName,
-                        " data = nlohmann::json::parse(jsonString);",
-                    );
-                });
-            } else {
+            this.forEachTopLevel("none", (_, topLevelName) => {
                 this.emitLine(
                     "//     ",
-                    basename,
+                    topLevelName,
                     " data = nlohmann::json::parse(jsonString);",
                 );
-            }
+            });
 
             if (this._options.wstring) {
                 this.emitLine("//");
@@ -3187,6 +3179,7 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
             this.emitHelper();
 
             this.startFile("Generators.hpp", true);
+            this._generatedFiles.add("Generators.hpp");
 
             this._allTypeNames.forEach((t) => {
                 this.emitInclude(false, [t, ".hpp"]);
diff --git a/test/fixtures.ts b/test/fixtures.ts
index dece181ef6..1f5d1adb98 100644
--- a/test/fixtures.ts
+++ b/test/fixtures.ts
@@ -1563,6 +1563,10 @@ export const allFixtures: Fixture[] = [
     new JSONFixture(languages.CJSONMultiHeaderLanguage, "cjson-multi-header"),
     new JSONFixture(languages.CJSONMultiSplitLanguage, "cjson-multi-split"),
     new JSONFixture(languages.CPlusPlusLanguage),
+    new JSONFixture(
+        languages.CPlusPlusMultiSourceLanguage,
+        "cplusplus-multi-source",
+    ),
     new JSONFixture(languages.PHPLanguage),
     new JSONFixture(languages.RustLanguage),
     new JSONFixture(languages.RubyLanguage),
diff --git a/test/fixtures/cplusplus/main.cpp b/test/fixtures/cplusplus/main.cpp
index d963530b52..7d070451be 100644
--- a/test/fixtures/cplusplus/main.cpp
+++ b/test/fixtures/cplusplus/main.cpp
@@ -3,8 +3,7 @@
 #include <fstream>
 #include <streambuf>
 
-#include "TopLevel.hpp"
-#include "Generators.hpp"
+#include "quicktype.hpp"
 
 using quicktype::TopLevel;
 using nlohmann::json;
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..67253fe69c 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -712,7 +712,7 @@ export const CPlusPlusLanguage: Language = {
         "union",
         "no-defaults",
     ],
-    output: "TopLevel.hpp",
+    output: "quicktype.hpp",
     topLevel: "TopLevel",
     skipJSON: [
         // fails on a string containing null
@@ -737,7 +737,6 @@ export const CPlusPlusLanguage: Language = {
     ],
     rendererOptions: {},
     quickTestRendererOptions: [
-        { "source-style": "multi-source" },
         { "code-format": "with-struct" },
         { wstring: "use-wstring" },
         { "const-style": "east-const" },
@@ -753,6 +752,13 @@ export const CPlusPlusLanguage: Language = {
     sourceFiles: ["src/language/CPlusPlus/index.ts"],
 };
 
+export const CPlusPlusMultiSourceLanguage: Language = {
+    ...CPlusPlusLanguage,
+    includeJSON: ["pokedex.json"],
+    rendererOptions: { "source-style": "multi-source" },
+    quickTestRendererOptions: [],
+};
+
 export const ElmLanguage: Language = {
     name: "elm",
     base: "test/fixtures/elm",
diff --git a/test/unit/cplusplus-multi-source.test.ts b/test/unit/cplusplus-multi-source.test.ts
new file mode 100644
index 0000000000..734dca7f1f
--- /dev/null
+++ b/test/unit/cplusplus-multi-source.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, test } from "vitest";
+
+import {
+    InputData,
+    jsonInputForTargetLanguage,
+    quicktypeMultiFile,
+} from "quicktype-core";
+
+async function cPlusPlusMultiSourceFiles(): Promise<Map<string, string>> {
+    const jsonInput = jsonInputForTargetLanguage("cplusplus");
+    await jsonInput.addSource({
+        name: "ChunkCache",
+        samples: ['{"chunks":["one"],"size":1}'],
+    });
+    await jsonInput.addSource({
+        name: "BufferPath",
+        samples: ['{"path":"somewhere","maxSize":2}'],
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(jsonInput);
+    const result = await quicktypeMultiFile({
+        inputData,
+        lang: "cplusplus",
+        outputFilename: "quicktype.hpp",
+        rendererOptions: { "source-style": "multi-source" },
+    });
+
+    return new Map(
+        Array.from(result, ([filename, serialized]) => [
+            filename,
+            serialized.lines.join("\n"),
+        ]),
+    );
+}
+
+describe("C++ multi-source output", () => {
+    test("the umbrella header includes the JSON generators", async () => {
+        const files = await cPlusPlusMultiSourceFiles();
+        expect(files.get("quicktype.hpp")).toContain(
+            '#include "Generators.hpp"',
+        );
+    });
+
+    test("usage comments name top-level types, not generated files", async () => {
+        const files = await cPlusPlusMultiSourceFiles();
+        for (const [filename, source] of files) {
+            expect(source).toContain(
+                "//     ChunkCache data = nlohmann::json::parse(jsonString);",
+            );
+            expect(source).toContain(
+                "//     BufferPath data = nlohmann::json::parse(jsonString);",
+            );
+            expect(source).not.toContain(
+                `//     ${filename} data = nlohmann::json::parse(jsonString);`,
+            );
+        }
+    });
+});

From ddab4935516c3edd98e0daeabf123b8af540bc23 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 16:58:48 -0400
Subject: [PATCH 50/63] fix(cpp): support std::optional in Utf16_Utf8 string
 conversion (#2383)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../language/CPlusPlus/CPlusPlusRenderer.ts   | 22 +++++++++++++++++++
 test/languages.ts                             |  4 +++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
index ec99e8029b..55e371d735 100644
--- a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
+++ b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
@@ -3403,6 +3403,28 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
                 );
                 this.superThis.ensureBlankLine();
 
+                if (this.superThis.haveOptionalProperties) {
+                    this.superThis.emitLine(
+                        "template<typename TF, typename TT>",
+                    );
+                    this.superThis.emitBlock(
+                        [
+                            "static toType convert(tag<",
+                            this.superThis._optionalType,
+                            "<TF> >, tag<",
+                            this.superThis._optionalType,
+                            "<TT> >, fromType opt)",
+                        ],
+                        false,
+                        () => {
+                            this.superThis.emitLine(
+                                "if (!opt) return toType(); else return toType(Utf16_Utf8<TF,TT>::convert(*opt));",
+                            );
+                        },
+                    );
+                    this.superThis.ensureBlankLine();
+                }
+
                 this.superThis.emitLine("template<typename TF, typename TT>");
                 this.superThis.emitBlock(
                     [
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..95f7f17d3e 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -739,7 +739,9 @@ export const CPlusPlusLanguage: Language = {
     quickTestRendererOptions: [
         { "source-style": "multi-source" },
         { "code-format": "with-struct" },
-        { wstring: "use-wstring" },
+        // bug2521.json has an optional string, exercising UTF conversion
+        // through std::optional.
+        ["bug2521.json", { wstring: "use-wstring" }],
         { "const-style": "east-const" },
         // The default is boost=false (C++17); this keeps the boost code
         // path covered.  Pinned to specific inputs because the default

From aa83b1c5059aa1d05610b2f190a02f624c4b620c Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 17:00:09 -0400
Subject: [PATCH 51/63] fix(cpp): silence unused-parameter warnings for empty
 objects (#2362)

Empty JSON Schema objects generate C++ from_json/to_json functions
whose j and/or x parameters go unreferenced, tripping
-Wunused-parameter under -Werror. Emit (void)j;/(void)x; for
classes with no properties.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/language/CPlusPlus/CPlusPlusRenderer.ts          | 9 +++++++++
 test/languages.ts                                        | 3 ++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
index ec99e8029b..ecfd6d62a3 100644
--- a/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
+++ b/packages/quicktype-core/src/language/CPlusPlus/CPlusPlusRenderer.ts
@@ -1373,6 +1373,11 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
             ],
             false,
             () => {
+                if (c.getProperties().size === 0) {
+                    this.emitLine("(void)j;");
+                    this.emitLine("(void)x;");
+                }
+
                 this.forEachClassProperty(c, "none", (name, json, p) => {
                     const [, , setterName] = defined(
                         this._gettersAndSettersForPropertyName.get(name),
@@ -1562,6 +1567,10 @@ export class CPlusPlusRenderer extends ConvenienceRenderer {
             false,
             () => {
                 this.emitLine("j = json::object();");
+                if (c.getProperties().size === 0) {
+                    this.emitLine("(void)x;");
+                }
+
                 this.forEachClassProperty(c, "none", (name, json, p) => {
                     const propType = p.type;
                     cppType = this.cppType(
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..1e7d486a4f 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -688,7 +688,8 @@ export const CPlusPlusLanguage: Language = {
     base: "test/fixtures/cplusplus",
     setupCommand:
         "curl -o json.hpp https://raw.githubusercontent.com/nlohmann/json/87df1d6708915ffbfa26a051ad7562ecc22e5579/src/json.hpp",
-    compileCommand: "g++ -O0 -o quicktype -std=c++17 main.cpp",
+    compileCommand:
+        "g++ -O0 -o quicktype -std=c++17 -Werror=unused-parameter main.cpp",
     runCommand(sample: string) {
         return `./quicktype "${sample}"`;
     },

From 806a11201a36d6048f893c8de054e6b98d3132d9 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 17:02:33 -0400
Subject: [PATCH 52/63] fix(csharp): always emit <auto-generated /> header
 (#1973)

The C# renderers (SystemTextJson and NewtonSoft) gated the entire
emitDefaultLeadingComments() block, including the `// <auto-generated />`
marker, on this._needHelpers. This meant --features attributes-only,
--features just-types, and --just-types dropped the auto-generated marker
entirely, while --features complete kept it. Only the "To parse this JSON
data..." usage blurb and the #nullable/#pragma lines actually depend on
helper code being emitted.

Now the `// <auto-generated />` line (and the following `//`) is always
emitted; only the usage instructions and preprocessor directives remain
gated on _needHelpers.

Fixes #1973

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../language/CSharp/NewtonSoftCSharpRenderer.ts |  4 ++--
 .../CSharp/SystemTextJsonCSharpRenderer.ts      |  4 ++--
 test/unit/just-types-option.test.ts             | 17 +++++++++++++++++
 3 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
index b4aebaf7a2..4fbd16c23c 100644
--- a/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/NewtonSoftCSharpRenderer.ts
@@ -205,10 +205,10 @@ export class NewtonsoftCSharpRenderer extends CSharpRenderer {
     }
 
     protected emitDefaultLeadingComments(): void {
-        if (!this._needHelpers) return;
-
         this.emitLine("// <auto-generated />");
         this.emitLine("//");
+
+        if (!this._needHelpers) return;
         this.emitLine(
             "// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do",
             this.topLevels.size === 1 ? "" : " one of these",
diff --git a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
index f3eccc8df4..62980f4a9c 100644
--- a/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
+++ b/packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts
@@ -201,10 +201,10 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
     }
 
     protected emitDefaultLeadingComments(): void {
-        if (!this._needHelpers) return;
-
         this.emitLine("// <auto-generated />");
         this.emitLine("//");
+
+        if (!this._needHelpers) return;
         this.emitLine(
             "// To parse this JSON data, add NuGet 'System.Text.Json' then do",
             this.topLevels.size === 1 ? "" : " one of these",
diff --git a/test/unit/just-types-option.test.ts b/test/unit/just-types-option.test.ts
index 4d3e31766a..26f435bbae 100644
--- a/test/unit/just-types-option.test.ts
+++ b/test/unit/just-types-option.test.ts
@@ -56,6 +56,23 @@ describe("just-types generates plain types in every language", () => {
     });
 });
 
+describe("C# generated-file marker", () => {
+    test.each([
+        ["SystemTextJson attributes-only", { features: "attributes-only" }],
+        [
+            "NewtonSoft attributes-only",
+            { framework: "NewtonSoft", features: "attributes-only" },
+        ],
+        ["just-types", { "just-types": true }],
+        ["complete", { features: "complete" }],
+    ] as Array<
+        [string, RendererOptions]
+    >)("%s", async (_name, rendererOptions) => {
+        const output = await linesFor("csharp", rendererOptions);
+        expect(output.startsWith("// <auto-generated />\n//\n")).toBe(true);
+    });
+});
+
 describe("the removed enum spellings are errors", () => {
     // The old spellings aren't valid `RendererOptions` anymore, which is
     // the point: they must also fail for API callers who evade the types.

From 315d9866026014fb26b58e316f9b34a0239085ed Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 17:16:48 -0400
Subject: [PATCH 53/63] fix(dart): keep top-level fromJson/toJson names with
 --from-map (#1719)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/language/Dart/DartRenderer.ts         |  4 +-
 test/languages.ts                             |  8 ++-
 test/unit/dart-method-names.test.ts           | 68 +++++++++++++++++++
 3 files changed, 76 insertions(+), 4 deletions(-)
 create mode 100644 test/unit/dart-method-names.test.ts

diff --git a/packages/quicktype-core/src/language/Dart/DartRenderer.ts b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
index 8a46bd7577..1b0cd45684 100644
--- a/packages/quicktype-core/src/language/Dart/DartRenderer.ts
+++ b/packages/quicktype-core/src/language/Dart/DartRenderer.ts
@@ -117,12 +117,12 @@ export class DartRenderer extends ConvenienceRenderer {
         const encoder = new DependencyName(
             propertyNamingFunction,
             name.order,
-            (lookup) => `${lookup(name)}_${this.toJson}`,
+            (lookup) => `${lookup(name)}_toJson`,
         );
         const decoder = new DependencyName(
             propertyNamingFunction,
             name.order,
-            (lookup) => `${lookup(name)}_${this.fromJson}`,
+            (lookup) => `${lookup(name)}_fromJson`,
         );
         this._topLevelDependents.set(name, { encoder, decoder });
         return [encoder, decoder];
diff --git a/test/languages.ts b/test/languages.ts
index 6bcfd43611..0d214b119e 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -1628,8 +1628,12 @@ export const DartLanguage: Language = {
     skipMiscJSON: true,
     rendererOptions: {},
     // The default is final-props=true; this keeps the mutable-property
-    // code path covered.
-    quickTestRendererOptions: [{ "final-props": "false" }],
+    // code path covered.  The targeted from-map sample also verifies that
+    // the fixture driver can keep calling the top-level JSON string helpers.
+    quickTestRendererOptions: [
+        { "final-props": "false" },
+        ["simple-object.json", { "from-map": "true" }],
+    ],
     sourceFiles: ["src/language/Dart/index.ts"],
 };
 
diff --git a/test/unit/dart-method-names.test.ts b/test/unit/dart-method-names.test.ts
new file mode 100644
index 0000000000..17ed1e35c9
--- /dev/null
+++ b/test/unit/dart-method-names.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, test } from "vitest";
+
+import {
+    InputData,
+    type RendererOptions,
+    jsonInputForTargetLanguage,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+
+async function renderDart(
+    rendererOptions: RendererOptions = {},
+): Promise<string[]> {
+    const jsonInput = jsonInputForTargetLanguage("dart");
+    await jsonInput.addSource({
+        name: "Sensordata",
+        samples: ['{"sensor":"temp","data":[1,2,3]}'],
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(jsonInput);
+
+    const result = await quicktype({
+        inputData,
+        lang: "dart",
+        rendererOptions,
+    });
+    return result.lines;
+}
+
+describe("Dart JSON method names", () => {
+    test("from-map only renames class-level map methods", async () => {
+        const lines = await renderDart({ "from-map": "true" });
+
+        expect(lines).toContain(
+            "Sensordata sensordataFromJson(String str) => Sensordata.fromMap(json.decode(str));",
+        );
+        expect(lines).toContain(
+            "String sensordataToJson(Sensordata data) => json.encode(data.toMap());",
+        );
+        expect(lines).toContain(
+            "    factory Sensordata.fromMap(Map<String, dynamic> json) => Sensordata(",
+        );
+        expect(lines).toContain("    Map<String, dynamic> toMap() => {");
+        expect(lines.some((line) => line.includes("sensordataFromMap"))).toBe(
+            false,
+        );
+        expect(lines.some((line) => line.includes("sensordataToMap"))).toBe(
+            false,
+        );
+    });
+
+    test("uses Json names at both levels by default", async () => {
+        const lines = await renderDart();
+
+        expect(lines).toContain(
+            "Sensordata sensordataFromJson(String str) => Sensordata.fromJson(json.decode(str));",
+        );
+        expect(lines).toContain(
+            "String sensordataToJson(Sensordata data) => json.encode(data.toJson());",
+        );
+        expect(lines).toContain(
+            "    factory Sensordata.fromJson(Map<String, dynamic> json) => Sensordata(",
+        );
+        expect(lines).toContain("    Map<String, dynamic> toJson() => {");
+        expect(lines.some((line) => line.includes("fromMap"))).toBe(false);
+        expect(lines.some((line) => line.includes("toMap"))).toBe(false);
+    });
+});

From 3b9776947bd0f1e833edb21e91b95e36f0ca8c3c Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 17:37:17 -0400
Subject: [PATCH 54/63] fix(input): reject non-OK HTTP responses when reading
 from a URL (#2572)

quicktype's URL input reader handed the fetch response body straight to
the JSON parser without checking response.ok, so an HTTP error (e.g. a
401 from an expired auth token) whose body happened to be valid JSON
was silently treated as legitimate input, generating types from the
error payload and exiting 0. Now readableFromFileOrURL throws a clear
error including the HTTP status when the response is not OK.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 packages/quicktype-core/src/input/io/NodeIO.ts |  5 +++++
 test/unit/url-input.test.ts                    | 13 +++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/packages/quicktype-core/src/input/io/NodeIO.ts b/packages/quicktype-core/src/input/io/NodeIO.ts
index a5df74f00f..137e8ecf71 100644
--- a/packages/quicktype-core/src/input/io/NodeIO.ts
+++ b/packages/quicktype-core/src/input/io/NodeIO.ts
@@ -107,6 +107,11 @@ export async function readableFromFileOrURL(
             const response = await globalThis.fetch(fileOrURL, {
                 headers: parseHeaders(httpHeaders),
             });
+            if (!response.ok) {
+                throw new Error(
+                    `HTTP ${response.status} ${response.statusText}`,
+                );
+            }
 
             return readableFromResponseBody(defined(response.body));
         }
diff --git a/test/unit/url-input.test.ts b/test/unit/url-input.test.ts
index eeb17002c0..24807a8adb 100644
--- a/test/unit/url-input.test.ts
+++ b/test/unit/url-input.test.ts
@@ -19,6 +19,7 @@ import * as path from "node:path";
 
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 
+import { readFromFileOrURL } from "../../packages/quicktype-core/src/input/io/NodeIO.js";
 import { main as quicktype } from "../../src";
 
 const files: Record<string, string> = {
@@ -74,6 +75,12 @@ async function generateTypeScript(
 
 beforeAll(async () => {
     server = http.createServer((request, response) => {
+        if (path.basename(request.url ?? "") === "unauthorized.json") {
+            response.writeHead(401, { "Content-Type": "application/json" });
+            response.end('{"message":"Bad credentials"}');
+            return;
+        }
+
         const content = files[path.basename(request.url ?? "")];
         if (content === undefined) {
             response.writeHead(404);
@@ -105,6 +112,12 @@ describe("native fetch URL inputs", () => {
         expect(output).toContain("veryUniquePropertyName");
     });
 
+    test("rejects an HTTP error response", async () => {
+        await expect(
+            readFromFileOrURL(`${baseURL}/unauthorized.json`),
+        ).rejects.toThrow("HTTP 401 Unauthorized");
+    });
+
     test("resolves a relative remote JSON Schema reference", async () => {
         const output = await generateTypeScript("schema", "main.schema");
         expect(output).toContain("veryUniqueReferencedProperty");

From f58485edfc4e64347aeb2b828ab82e2f92e9580a Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 18:00:18 -0400
Subject: [PATCH 55/63] fix(core): preserve JSON Schema enum case order (#1289)

ConvenienceRenderer.forEachEnumCase always alphabetized enum cases by
their rendered name before handing them to every language renderer's
emitEnum, so C++ (and other languages) generated enums in alphabetical
order instead of the order declared in the source JSON Schema/JSON.
Stop sorting and let the existing insertion order (already preserved
by the underlying case-names map) flow through unchanged.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../quicktype-core/src/ConvenienceRenderer.ts |  5 +--
 test/unit/enum-order.test.ts                  | 32 +++++++++++++++++++
 2 files changed, 33 insertions(+), 4 deletions(-)
 create mode 100644 test/unit/enum-order.test.ts

diff --git a/packages/quicktype-core/src/ConvenienceRenderer.ts b/packages/quicktype-core/src/ConvenienceRenderer.ts
index de5901e6e2..af8ff16031 100644
--- a/packages/quicktype-core/src/ConvenienceRenderer.ts
+++ b/packages/quicktype-core/src/ConvenienceRenderer.ts
@@ -995,10 +995,7 @@ export abstract class ConvenienceRenderer extends Renderer {
         f: (name: Name, jsonName: string, position: ForEachPosition) => void,
     ): void {
         const caseNames = defined(this._caseNamesStoreView).get(e);
-        const sortedCaseNames = mapSortBy(caseNames, (n) =>
-            defined(this.names.get(n)),
-        );
-        this.forEachWithBlankLines(sortedCaseNames, blankLocations, f);
+        this.forEachWithBlankLines(caseNames, blankLocations, f);
     }
 
     protected forEachTransformation(
diff --git a/test/unit/enum-order.test.ts b/test/unit/enum-order.test.ts
new file mode 100644
index 0000000000..da930ac15c
--- /dev/null
+++ b/test/unit/enum-order.test.ts
@@ -0,0 +1,32 @@
+import {
+    InputData,
+    JSONSchemaInput,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+import { expect, test } from "vitest";
+
+const schema = JSON.stringify({
+    $schema: "http://json-schema.org/draft-04/schema#",
+    title: "Test",
+    type: "object",
+    properties: {
+        errorCode: {
+            type: "string",
+            enum: ["B", "A", "E"],
+        },
+    },
+});
+
+test("preserves JSON Schema enum case order", async () => {
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({ name: "Test", schema });
+
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({ inputData, lang: "c++" });
+
+    expect(result.lines).toContain(
+        "    enum class ErrorCode : int { B, A, E };",
+    );
+});

From fb1af6950ddcd882780d017147ec0fbd0ffb4bb4 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 18:19:42 -0400
Subject: [PATCH 56/63] docs: require positive and negative cases for schema
 fixture tests

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index 938400de68..141758e423 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -15,6 +15,9 @@ JSON to the input.
   `.N.json` samples and `.N.fail.<feature>.json` expected-failure samples. A
   fail sample must make the generated program exit nonzero; which fail
   samples run is controlled by the language's `features` list.
+- Every schema fixture test must have at least one positive (`.N.json`) and
+  one negative (`.N.fail.<feature>.json`) test case, unless there is a very
+  good reason not to.
 - Per-language configuration — which inputs run (`skipJSON`, `includeJSON`,
   `skipSchema`), renderer options, and `features` — lives in
   `test/languages.ts`; fixtures are registered in `test/fixtures.ts`.

From 89d9f2ad9fce42399a8b091fd87701ae45700447 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 19:14:56 -0400
Subject: [PATCH 57/63] fix(cjson): start enum values at 1 so invalid/missing
 input is distinguishable (#2357)

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/language/CJSON/CJSONRenderer.ts       | 16 +++++++-
 test/unit/cjson-enum-default.test.ts          | 37 +++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 test/unit/cjson-enum-default.test.ts

diff --git a/packages/quicktype-core/src/language/CJSON/CJSONRenderer.ts b/packages/quicktype-core/src/language/CJSON/CJSONRenderer.ts
index c750529c98..442978d9e6 100644
--- a/packages/quicktype-core/src/language/CJSON/CJSONRenderer.ts
+++ b/packages/quicktype-core/src/language/CJSON/CJSONRenderer.ts
@@ -428,6 +428,7 @@ export class CJSONRenderer extends ConvenienceRenderer {
                 const combinedName = allUpperWordStyle(
                     this.sourcelikeToString(enumName),
                 );
+                let isFirst = true;
                 this.forEachEnumCase(enumType, "none", (name, jsonName) => {
                     if (enumValues !== undefined) {
                         const [enumValue] = getAccessorName(
@@ -444,11 +445,22 @@ export class CJSONRenderer extends ConvenienceRenderer {
                                 ",",
                             );
                         } else {
-                            this.emitLine(combinedName, "_", name, ",");
+                            this.emitLine(
+                                combinedName,
+                                "_",
+                                name,
+                                isFirst ? " = 1," : ",",
+                            );
                         }
                     } else {
-                        this.emitLine(combinedName, "_", name, ",");
+                        this.emitLine(
+                            combinedName,
+                            "_",
+                            name,
+                            isFirst ? " = 1," : ",",
+                        );
                     }
+                    isFirst = false;
                 });
             },
             "",
diff --git a/test/unit/cjson-enum-default.test.ts b/test/unit/cjson-enum-default.test.ts
new file mode 100644
index 0000000000..b2c02d60ee
--- /dev/null
+++ b/test/unit/cjson-enum-default.test.ts
@@ -0,0 +1,37 @@
+import { InputData, JSONSchemaInput, quicktype } from "quicktype-core";
+import { describe, expect, test } from "vitest";
+
+const schema = JSON.stringify({
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties: {
+        subscription: {
+            type: "string",
+            enum: ["state", "config", "heartbeat"],
+        },
+    },
+    required: ["subscription"],
+});
+
+async function cJSONOutput(): Promise<string> {
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({ name: "TopLevel", schema });
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({ inputData, lang: "cjson" });
+    return result.lines.join("\n");
+}
+
+describe("cJSON enum invalid value", () => {
+    test("does not collide with a real enumerator", async () => {
+        const output = await cJSONOutput();
+
+        expect(output).toContain(`enum Subscription {
+    SUBSCRIPTION_CONFIG = 1,
+    SUBSCRIPTION_HEARTBEAT,
+    SUBSCRIPTION_STATE,
+};`);
+        expect(output).toContain("enum Subscription x = 0;");
+    });
+});

From 1ab2a02eba5e58b36e7d13c8cef6b9b0b65f1fbd Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 19:19:39 -0400
Subject: [PATCH 58/63] fix(schema): keep allOf-merged properties when a branch
 sets additionalProperties: false (#1257)

When merging object types from an `allOf`, IntersectionAccumulator
discarded a property as soon as any other branch didn't declare that
property and didn't allow additional properties. Since JSON Schema
input commonly sets `additionalProperties: false` on every branch,
this meant merging two or more `allOf` branches with disjoint property
sets produced an empty (or partially empty) merged object instead of
the union of all their properties.

Fix ResolveIntersections.ts so a property known from any branch is
kept in the merged object regardless of whether other branches
restrict additional properties; `additionalProperties: false` still
correctly disallows properties nobody declared.

Added test/inputs/schema/all-of-additional-properties-false.schema
with a positive fixture sample and a `.fail.enum` negative sample
(invalid enum value for a property merged in from one of the allOf
branches, which only fails if that property survived the merge).

Verified locally: npm run build passes, npm run test:unit passes (176
tests), and QUICKTEST=true FIXTURE=schema-typescript script/test
passes (exit 0), including the new fixture. CI will cover the other
schema-<language> fixtures.

Fixes #1257

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/rewrites/ResolveIntersections.ts      | 24 ++++++-------
 ...ditional-properties-false.1.fail.enum.json |  6 ++++
 .../all-of-additional-properties-false.1.json |  6 ++++
 .../all-of-additional-properties-false.schema | 35 +++++++++++++++++++
 4 files changed, 58 insertions(+), 13 deletions(-)
 create mode 100644 test/inputs/schema/all-of-additional-properties-false.1.fail.enum.json
 create mode 100644 test/inputs/schema/all-of-additional-properties-false.1.json
 create mode 100644 test/inputs/schema/all-of-additional-properties-false.schema

diff --git a/packages/quicktype-core/src/rewrites/ResolveIntersections.ts b/packages/quicktype-core/src/rewrites/ResolveIntersections.ts
index 7f3ab80d84..a7aeefa83a 100644
--- a/packages/quicktype-core/src/rewrites/ResolveIntersections.ts
+++ b/packages/quicktype-core/src/rewrites/ResolveIntersections.ts
@@ -191,6 +191,9 @@ class IntersectionAccumulator
             const existing = defined(this._objectProperties).get(name);
             const newProperty = maybeObject.getProperties().get(name);
 
+            // A property declared by any intersection member is known on
+            // the merged object.  A member that doesn't allow additional
+            // properties must not discard properties declared by others.
             if (existing !== undefined && newProperty !== undefined) {
                 const cp = new GenericClassProperty(
                     existing.typeData.add(newProperty.type),
@@ -206,23 +209,18 @@ class IntersectionAccumulator
                     existing.isOptional,
                 );
                 defined(this._objectProperties).set(name, cp);
-            } else if (existing !== undefined) {
-                defined(this._objectProperties).delete(name);
-            } else if (
-                newProperty !== undefined &&
-                this._additionalPropertyTypes !== undefined
-            ) {
-                // FIXME: This is potentially slow
-                const types = new Set(this._additionalPropertyTypes).add(
-                    newProperty.type,
-                );
+            } else if (newProperty !== undefined) {
+                const types =
+                    this._additionalPropertyTypes === undefined
+                        ? new Set([newProperty.type])
+                        : new Set(this._additionalPropertyTypes).add(
+                              newProperty.type,
+                          );
                 defined(this._objectProperties).set(
                     name,
                     new GenericClassProperty(types, newProperty.isOptional),
                 );
-            } else if (newProperty !== undefined) {
-                defined(this._objectProperties).delete(name);
-            } else {
+            } else if (existing === undefined) {
                 mustNotHappen();
             }
         }
diff --git a/test/inputs/schema/all-of-additional-properties-false.1.fail.enum.json b/test/inputs/schema/all-of-additional-properties-false.1.fail.enum.json
new file mode 100644
index 0000000000..d70bdfd082
--- /dev/null
+++ b/test/inputs/schema/all-of-additional-properties-false.1.fail.enum.json
@@ -0,0 +1,6 @@
+{
+  "amount": 1250,
+  "frequency": "NotAValidFrequency",
+  "type": "GrossSalaryAmount",
+  "description": "Base salary"
+}
diff --git a/test/inputs/schema/all-of-additional-properties-false.1.json b/test/inputs/schema/all-of-additional-properties-false.1.json
new file mode 100644
index 0000000000..e7b04d57f3
--- /dev/null
+++ b/test/inputs/schema/all-of-additional-properties-false.1.json
@@ -0,0 +1,6 @@
+{
+  "amount": 1250,
+  "frequency": "Monthly",
+  "type": "GrossSalaryAmount",
+  "description": "Base salary"
+}
diff --git a/test/inputs/schema/all-of-additional-properties-false.schema b/test/inputs/schema/all-of-additional-properties-false.schema
new file mode 100644
index 0000000000..4dc96ac791
--- /dev/null
+++ b/test/inputs/schema/all-of-additional-properties-false.schema
@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "AmountAndFrequency": {
+      "type": "object",
+      "properties": {
+        "amount": { "type": "number" },
+        "frequency": {
+          "type": "string",
+          "enum": ["Weekly", "Monthly", "Annually"]
+        }
+      },
+      "additionalProperties": false,
+      "required": ["amount", "frequency"]
+    },
+    "Income": {
+      "allOf": [
+        { "$ref": "#/definitions/AmountAndFrequency" },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "enum": ["GrossSalaryAmount", "Overtime"]
+            },
+            "description": { "type": "string" }
+          },
+          "additionalProperties": false,
+          "required": ["type"]
+        }
+      ]
+    }
+  },
+  "$ref": "#/definitions/Income"
+}

From d545d837679ddb7d62c78513a6e0d34d14eebed5 Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 19:24:29 -0400
Subject: [PATCH 59/63] fix(python): try integer before number in union
 deserialization (#1318)

For a union of `integer` and `number` (e.g. JSON Schema `type: ["integer",
"number"]`), the Python target emitted `from_union([from_float, from_int],
...)`. `from_float` accepts plain ints and coerces them to `float`, so
`from_int` was unreachable: every integer value silently turned into a
float and the round-trip was not bijective (`5` became `5.0`).

Reorder Python union member (de)serializer dispatch so the `integer` branch
is always tried before `number`/`double`.

Co-Authored-By: gpt-5.6-sol via pi <noreply@openai.com>
---
 .../src/language/Python/JSONPythonRenderer.ts | 21 ++++++--
 .../schema/integer-before-number.1.json       |  1 +
 .../schema/integer-before-number.2.json       |  1 +
 .../integer-before-number.3.fail.union.json   |  1 +
 .../schema/integer-before-number.schema       |  5 ++
 test/languages.ts                             | 48 +++++++++++++++----
 test/unit/python-union-order.test.ts          | 26 ++++++++++
 7 files changed, 91 insertions(+), 12 deletions(-)
 create mode 100644 test/inputs/schema/integer-before-number.1.json
 create mode 100644 test/inputs/schema/integer-before-number.2.json
 create mode 100644 test/inputs/schema/integer-before-number.3.fail.union.json
 create mode 100644 test/inputs/schema/integer-before-number.schema
 create mode 100644 test/unit/python-union-order.test.ts

diff --git a/packages/quicktype-core/src/language/Python/JSONPythonRenderer.ts b/packages/quicktype-core/src/language/Python/JSONPythonRenderer.ts
index 20d5fc5aa8..98b44f4db1 100644
--- a/packages/quicktype-core/src/language/Python/JSONPythonRenderer.ts
+++ b/packages/quicktype-core/src/language/Python/JSONPythonRenderer.ts
@@ -22,7 +22,7 @@ import {
     UnionMemberMatchTransformer,
     transformationForType,
 } from "../../Transformers.js";
-import type { ClassType, Type } from "../../Type/index.js";
+import type { ClassType, Type, UnionType } from "../../Type/index.js";
 import { matchType } from "../../Type/TypeUtils.js";
 
 import { PythonRenderer } from "./PythonRenderer.js";
@@ -785,6 +785,21 @@ export class JSONPythonRenderer extends PythonRenderer {
         return panic(`Transformer ${xfer.kind} is not supported`);
     }
 
+    private unionMembers(unionType: UnionType): Type[] {
+        // from_float also accepts integers, so from_int must be tried first.
+        const members = Array.from(unionType.members);
+        const integerIndex = members.findIndex((m) => m.kind === "integer");
+        const doubleIndex = members.findIndex((m) => m.kind === "double");
+
+        if (doubleIndex >= 0 && integerIndex > doubleIndex) {
+            const integerType = defined(members[integerIndex]);
+            members.splice(integerIndex, 1);
+            members.splice(doubleIndex, 0, integerType);
+        }
+
+        return members;
+    }
+
     // Returns the code to deserialize `value` as type `t`.  If `t` has
     // an associated transformer, the code for that transformer is
     // returned.
@@ -837,7 +852,7 @@ export class JSONPythonRenderer extends PythonRenderer {
                 }),
             (unionType) => {
                 // FIXME: handle via transformers
-                const deserializers = Array.from(unionType.members).map(
+                const deserializers = this.unionMembers(unionType).map(
                     (m) => makeLambda(this.deserializer(identity, m)).source,
                 );
                 return compose(value, (v) => [
@@ -929,7 +944,7 @@ export class JSONPythonRenderer extends PythonRenderer {
                     ")",
                 ]),
             (unionType) => {
-                const serializers = Array.from(unionType.members).map(
+                const serializers = this.unionMembers(unionType).map(
                     (m) => makeLambda(this.serializer(identity, m)).source,
                 );
                 return compose(value, (v) => [
diff --git a/test/inputs/schema/integer-before-number.1.json b/test/inputs/schema/integer-before-number.1.json
new file mode 100644
index 0000000000..7ed6ff82de
--- /dev/null
+++ b/test/inputs/schema/integer-before-number.1.json
@@ -0,0 +1 @@
+5
diff --git a/test/inputs/schema/integer-before-number.2.json b/test/inputs/schema/integer-before-number.2.json
new file mode 100644
index 0000000000..9ad974f610
--- /dev/null
+++ b/test/inputs/schema/integer-before-number.2.json
@@ -0,0 +1 @@
+5.5
diff --git a/test/inputs/schema/integer-before-number.3.fail.union.json b/test/inputs/schema/integer-before-number.3.fail.union.json
new file mode 100644
index 0000000000..c10b1ae65f
--- /dev/null
+++ b/test/inputs/schema/integer-before-number.3.fail.union.json
@@ -0,0 +1 @@
+"not a number"
diff --git a/test/inputs/schema/integer-before-number.schema b/test/inputs/schema/integer-before-number.schema
new file mode 100644
index 0000000000..5d8aa8914c
--- /dev/null
+++ b/test/inputs/schema/integer-before-number.schema
@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-06/schema#",
+  "description": "An integer or non-integer number",
+  "type": ["integer", "number"]
+}
diff --git a/test/languages.ts b/test/languages.ts
index 70fa741ebf..5fb848dff2 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -121,6 +121,7 @@ export const CSharpLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "top-level-enum.schema", // The code we generate for top-level enums is incompatible with the driver
     ],
     // The default framework is SystemTextJson; this fixture deliberately
@@ -167,6 +168,7 @@ export const CSharpLanguageSystemTextJson: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "top-level-enum.schema", // The code we generate for top-level enums is incompatible with the driver
         // The following skips are pre-existing System.Text.Json renderer issues,
         // found when first enabling the schema fixture for this language:
@@ -218,7 +220,10 @@ export const JavaLanguage: Language = {
         "nst-test-suite.json",
     ],
     skipMiscJSON: false,
-    skipSchema: ["keyword-unions.schema"], // generates classes with names that are case-insensitively equal
+    skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
+        "keyword-unions.schema", // generates classes with names that are case-insensitively equal
+    ],
     rendererOptions: {},
     // The default is array-type=list; this keeps the T[] code path
     // covered.
@@ -229,6 +234,7 @@ export const JavaLanguage: Language = {
 export const JavaLanguageWithLegacyDateTime: Language = {
     ...JavaLanguage,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         ...JavaLanguage.skipSchema,
         "date-time.schema", // Expects less strict serialization.
     ],
@@ -327,7 +333,7 @@ export const RustLanguage: Language = {
     output: "module_under_test.rs",
     topLevel: "TopLevel",
     skipJSON: [],
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     skipMiscJSON: false,
     rendererOptions: {},
     quickTestRendererOptions: [
@@ -377,6 +383,7 @@ export const CrystalLanguage: Language = {
         "e8b04.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Crystal does not handle enum mapping
         ...skipsEnumValueValidation,
         // Crystal does not support top-level primitives
@@ -473,6 +480,7 @@ export const RubyLanguage: Language = {
         "kitchen-sink.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // We don't generate a convenience method for top-level enums
         "top-level-enum.schema",
     ],
@@ -514,6 +522,7 @@ export const GoLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // can't differenciate empty array and nothing for optional empty array
         // (omitempty).
         "postman-collection.schema",
@@ -590,6 +599,7 @@ export const CJSONLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         /* Member names are different when generating with schema */
         "vega-lite.schema",
         /* Enum as TopLevel is not supported */
@@ -650,7 +660,7 @@ export const CJSONDefaultLanguage: Language = {
     topLevel: "TopLevel",
     includeJSON: ["nbl-stats.json"],
     skipMiscJSON: true,
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     rendererOptions: {},
     quickTestRendererOptions: [],
     sourceFiles: ["src/language/CJSON/index.ts"],
@@ -674,7 +684,7 @@ export const CJSONMultiHeaderLanguage: Language = {
     topLevel: "TopLevel",
     includeJSON: ["nbl-stats.json"],
     skipMiscJSON: true,
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     rendererOptions: { "source-style": "multi-source" },
     quickTestRendererOptions: [],
     sourceFiles: ["src/language/CJSON/index.ts"],
@@ -698,7 +708,7 @@ export const CJSONMultiSplitLanguage: Language = {
     topLevel: "TopLevel",
     includeJSON: ["nbl-stats.json"],
     skipMiscJSON: true,
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     rendererOptions: {
         "source-style": "multi-source",
         "header-only": "false",
@@ -752,6 +762,7 @@ export const CPlusPlusLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // uses too much memory
         "keyword-unions.schema",
         // The generated deserializer accepts non-object values when all class properties are optional.
@@ -838,6 +849,7 @@ export const ElmLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "union-list.schema", // recursion
         "list.schema", // recursion
         "ref-remote.schema", // recursion
@@ -912,6 +924,7 @@ export const SwiftLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // The code we generate for top-level enums is incompatible with the driver
         "top-level-enum.schema",
         // This works on macOS, but on Linux one of the failure test cases doesn't fail
@@ -977,7 +990,7 @@ export const ObjectiveCLanguage: Language = {
         "combinations4.json",
     ],
     skipMiscJSON: false,
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     rendererOptions: { functions: "true" },
     quickTestRendererOptions: [],
     sourceFiles: ["src/language/Objective-C/index.ts"],
@@ -1016,6 +1029,7 @@ export const TypeScriptLanguage: Language = {
     skipJSON: [],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "keyword-unions.schema", // can't handle "constructor" property
         // Pre-existing failures (this fixture is not in CI yet, and these
         // fail with unmodified master too): objects with both declared
@@ -1058,7 +1072,10 @@ export const JavaScriptLanguage: Language = {
     topLevel: "TopLevel",
     skipJSON: [],
     skipMiscJSON: false,
-    skipSchema: ["keyword-unions.schema"], // can't handle "constructor" property
+    skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
+        "keyword-unions.schema", // can't handle "constructor" property
+    ],
     rendererOptions: {},
     quickTestRendererOptions: [
         { "runtime-typecheck": "false" },
@@ -1089,7 +1106,7 @@ export const JavaScriptPropTypesLanguage: Language = {
         "spotify-album.json", // renderer does not support recursion
         "76ae1.json", // renderer does not support recursion
     ],
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     skipMiscJSON: false,
     rendererOptions: { "module-system": "es6" },
     quickTestRendererOptions: [{ converters: "top-level" }],
@@ -1111,6 +1128,7 @@ export const FlowLanguage: Language = {
     skipJSON: [],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "keyword-unions.schema", // can't handle "constructor" property
     ],
     rendererOptions: { "explicit-unions": "yes" },
@@ -1167,6 +1185,7 @@ export const Scala3Language: Language = {
         "bug2521.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Same raw-identifier limitation as in skipJSON: a property
         // named "_" and classes shadowing None/Option don't compile.
         "keyword-unions.schema",
@@ -1217,6 +1236,7 @@ export const Scala3UpickleLanguage: Language = {
         "bug2521.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Same raw-identifier limitation as in skipJSON: a property
         // named "_" and classes shadowing None/Option don't compile.
         "keyword-unions.schema",
@@ -1287,7 +1307,7 @@ I havea no idea how to encode these tests correctly.
         "php-mixed-union.json",
         "nst-test-suite.json",
     ],
-    skipSchema: [],
+    skipSchema: ["integer-before-number.schema"], // Python-specific union-order regression.
     skipMiscJSON: false,
     rendererOptions: { "just-types": "true" },
     quickTestRendererOptions: [],
@@ -1349,6 +1369,7 @@ export const KotlinLanguage: Language = {
         "bug427.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Very weird - the types are correct, but it can (de)serialize the string,
         // which is not represented in the types (implicit-class-array-union);
         // class-map-union: KlaxonException: Couldn't find a suitable constructor for class UnionValue to initialize with {}
@@ -1440,6 +1461,7 @@ export const KotlinJacksonLanguage: Language = {
         "bug427.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Very weird - the types are correct, but it can (de)serialize the string,
         // which is not represented in the types (implicit-class-array-union);
         // class-map-union: KlaxonException: Couldn't find a suitable constructor for class UnionValue to initialize with {}
@@ -1575,6 +1597,7 @@ export const KotlinXLanguage: Language = {
         "identifiers.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // Unions render as sealed classes without serializer wiring, so
         // deserialization fails at runtime (documented TODO in
         // KotlinXRenderer.ts).
@@ -1644,6 +1667,7 @@ export const DartLanguage: Language = {
         "keywords.json",
     ],
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "enum-with-null.schema",
         // Deliberately NOT ...skipsEnumValueValidation: Dart runs
         // optional-enum.schema as its own regression test (see PR #2720),
@@ -1712,6 +1736,7 @@ export const PikeLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "top-level-enum.schema", // output generated properly, but not a class
         "keyword-unions.schema", // seems like a problem with deserializing
         // no implicit cast int <-> float in Pike
@@ -1798,6 +1823,7 @@ export const HaskellLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "any.schema",
         ...skipsUntypedUnions,
         // The test driver encodes the Maybe result, so a failed decode prints
@@ -1854,6 +1880,7 @@ export const PHPLanguage: Language = {
     ],
     skipMiscJSON: true,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // PHP class names are case-insensitive, but the namer dedups
         // case-sensitively, so this declares classes that collide (same
         // reason Java and Python skip it).
@@ -1963,6 +1990,7 @@ export const TypeScriptZodLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "any.schema",
         ...skipsUntypedUnions,
         "direct-union.schema",
@@ -2084,6 +2112,7 @@ export const TypeScriptEffectSchemaLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         "any.schema",
         ...skipsUntypedUnions,
         "direct-union.schema",
@@ -2144,6 +2173,7 @@ export const ElixirLanguage: Language = {
     ],
     skipMiscJSON: false,
     skipSchema: [
+        "integer-before-number.schema", // Python-specific union-order regression.
         // The error occurs because a guard clause that references TopLevel is compiled before TopLevel itself. To fix this, put
         // TopLevel before Bar, but this doesn't address the actual problem if for example a pattern match to Bar was in TopLevel.
         "mutually-recursive.schema",
diff --git a/test/unit/python-union-order.test.ts b/test/unit/python-union-order.test.ts
new file mode 100644
index 0000000000..9487c2ff72
--- /dev/null
+++ b/test/unit/python-union-order.test.ts
@@ -0,0 +1,26 @@
+import {
+    InputData,
+    JSONSchemaInput,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+import { expect, test } from "vitest";
+
+const schema = JSON.stringify({
+    type: ["integer", "number"],
+});
+
+// Schema fixtures use JSON.parse, which unifies JSON integers and floats as
+// JavaScript numbers (5 and 5.0 compare identically), so assert source order.
+test("Python tries integer before number in unions", async () => {
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({ name: "TopLevel", schema });
+
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({ inputData, lang: "python" });
+    const output = result.lines.join("\n");
+
+    expect(output).toContain("from_union([from_int, from_float]");
+    expect(output).toContain("from_union([from_int, to_float]");
+});

From e977e88a2839afc361c70b526b5b38736c2cb6ed Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 19:59:18 -0400
Subject: [PATCH 60/63] docs: document known CI flakiness and retry policy

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index 141758e423..ab2f9eb95d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -30,6 +30,26 @@ new ones. Unit tests in `test/unit/` are a complement for what fixtures cannot
 express (asserting that some code is *not* generated, API-level behavior, fast
 local iteration) — never a substitute.
 
+## Known CI flakiness
+
+Three fixture-CI failure modes are infrastructure flakes, not test or PR bugs:
+
+- **scala3-upickle**: the Bloop compiler server sometimes times out after 30
+  seconds at startup, and `maven-nightlies` artifact downloads sometimes fail.
+- **elm**: the fixture setup (`rm -rf elm-stuff && elm make Warmup.elm`) can
+  race the compiler, deadlocking on `elm-stuff/*.dat` file locks.
+- **cjson**: `cJSON.c` is downloaded from raw.githubusercontent.com at test
+  time and can hit transient SSL/connection failures.
+
+Two things amplify them: the fixture matrix runs with `fail-fast: true`, so
+one flaky job cancels all sibling language jobs, and the `test-complete`
+check only mirrors the matrix — it is never an independent failure.
+
+For the time being we accept these flakes; when one happens, retry the failed
+jobs (`gh run rerun <run-id> --failed`). A failure in one of these areas only
+counts as real if it reproduces across retries or the PR actually touches
+that area.
+
 ## Releasing / version bumps
 
 Do not bump versions in any `package.json` before a release. Package manifest

From 349bc781415b0a2d892af2f5941f0ac620f750ac Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 20:04:15 -0400
Subject: [PATCH 61/63] test(cjson): skip enum-value fail sample for all-of
 merge schema

cjson's generated deserializer does not validate enum values, so the
`.1.fail.enum.json` negative sample of the new
`all-of-additional-properties-false.schema` fixture round-trips instead of
being rejected, making the expected-failure assertion fail. Add the schema
to the shared `skipsEnumValueValidation` list, matching the existing enum
fixtures that other non-enum-validating languages already skip.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 test/languages.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/languages.ts b/test/languages.ts
index 70fa741ebf..6172dc1de0 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -25,6 +25,7 @@ const skipsEnumValueValidation = [
     "enum-large.schema",
     "optional-enum.schema",
     "const-non-string.schema",
+    "all-of-additional-properties-false.schema",
 ];
 
 // The language makes no int/double distinction in unions (e.g. an integer is

From 4fa7cc14d4a1ddf74160a0a034503195f78b0edb Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 20:09:59 -0400
Subject: [PATCH 62/63] test(cjson): skip schema-constraints.schema
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

cjson declares the minmax/minmaxlength features so the fail samples run,
but its generated code does not enforce min/max/length constraints — which
is why it already skips minmax.schema, minmaxlength.schema, pattern.schema
and optional-constraints.schema. The new schema-constraints.schema is the
same kind of constraint fixture and was never added to the skip list, so
its expected-failure samples were not rejected and schema-cjson failed.
Scope it out for cjson alongside the existing constraint schemas.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 test/languages.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/languages.ts b/test/languages.ts
index 7c6d2eca82..5667f5016c 100644
--- a/test/languages.ts
+++ b/test/languages.ts
@@ -602,6 +602,7 @@ export const CJSONLanguage: Language = {
         "prefix-items.schema",
         /* Constraints (min/max and regex) are not supported (for the current implementation, can be added later, should abord parsing and return NULL) */
         "minmaxlength.schema",
+        "schema-constraints.schema",
         "optional-const-ref.schema",
         /* Same unsupported min/max, length and regex constraints, applied to optional properties */
         "optional-constraints.schema",

From b2d88d328928d67dec914ac04dbcf4ca25cda5de Mon Sep 17 00:00:00 2001
From: Mark Probst <mark.probst@gmail.com>
Date: Mon, 20 Jul 2026 20:24:01 -0400
Subject: [PATCH 63/63] docs: prefer fixture tests over unit tests when both
 can cover a change

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index ab2f9eb95d..7a769ca160 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -28,7 +28,9 @@ Any change that affects generated output MUST be covered by a JSON or JSON
 Schema fixture test — by enabling existing inputs for the language or adding
 new ones. Unit tests in `test/unit/` are a complement for what fixtures cannot
 express (asserting that some code is *not* generated, API-level behavior, fast
-local iteration) — never a substitute.
+local iteration) — never a substitute. Do not add a unit test when a fixture
+test will do the job: if a fixture input already exercises the behavior, a
+unit test duplicating that coverage is superfluous and should not be added.
 
 ## Known CI flakiness