fix(core-internal): null-tolerant array/tuple elements; quiet never verdicts; annotation-safe oneOf rewrite

- Array/tuple ELEMENT positions: JSON.stringify turns an undefined
  element into null (unlike an undefined-valued object key, which it
  drops), so a tolerant element (.default()/.prefault(), ...) may ship
  as null while the advertised items/prefixItems subschema rejected it
  — z.array(z.number().default(0)) output rejected the wire form
  [1, null, 3]. The override now wraps such emitted subschemas as
  {anyOf: [original, {type: 'null'}]} (loosen-only), mirroring how the
  catch degrade already behaves at the same position.
- z.never() union members yielded undefined verdicts and defeated the
  every-member rule: z.union([z.never(), z.bigint()]) threw pre-#2464
  but listed as a phantom. never now returns a QUIET non-object verdict
  (it matches no value, so it can never make a union satisfiable or
  object-shaped) — loud co-members restore the pre-#2464 throw while
  bare never, never+never, and never+representable shapes keep listing
  exactly as they did pre-#2464 (never is deliberately NOT in the loud
  set).
- rewriteOneOfToAnyOf walked blindly into annotation VALUES via
  Object.values, renaming a literal user-data oneOf key inside
  default/examples (advertised default: {oneOf: [1,2]} became
  {anyOf: [1,2]}). The walk now skips ANNOTATION_JSON_SCHEMA_KEYWORDS
  plus const/enum/x-* values, mirroring the catch-degrade loop's
  annotation carve-out.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: claude

packages/core-internal/src/util/standardSchema.ts

@@ -290,6 +290,32 @@ function zodConversionOptions(
                 }
                 return;
             }
+            if (def.type === 'array') {
+                // JSON.stringify turns an undefined array ELEMENT into `null` (unlike an
+                // undefined-valued object key, which it drops), so a tolerant element
+                // (`.default()`/`.prefault()`, …) may ship as null — the advertised item
+                // subschema must accept it.
+                const items = ctx.jsonSchema.items;
+                if (typeof items === 'object' && items !== null && !Array.isArray(items) && hasStructuralMissingKeyTolerance(def.element)) {
+                    loosened.value = true;
+                    ctx.jsonSchema.items = { anyOf: [items, { type: 'null' }] };
+                }
+                return;
+            }
+            if (def.type === 'tuple') {
+                // Same wire mechanism per prefix position.
+                const prefixItems = ctx.jsonSchema.prefixItems;
+                if (Array.isArray(def.items) && Array.isArray(prefixItems)) {
+                    for (const [index, item] of def.items.entries()) {
+                        const emitted = prefixItems[index];
+                        if (typeof emitted === 'object' && emitted !== null && hasStructuralMissingKeyTolerance(item)) {
+                            loosened.value = true;
+                            prefixItems[index] = { anyOf: [emitted, { type: 'null' }] };
+                        }
+                    }
+                }
+                return;
+            }
             if (def.type !== 'object') return;
             const isStrict = def.catchall?._zod.def.type === 'never';
             if (!isStrict && ctx.jsonSchema.additionalProperties === false) {
@@ -331,7 +357,13 @@ function rewriteOneOfToAnyOf(node: unknown, seen: Set<unknown> = new Set()): voi
         record.anyOf = record.oneOf;
         delete record.oneOf;
     }
-    for (const value of Object.values(record)) rewriteOneOfToAnyOf(value, seen);
+    for (const [key, value] of Object.entries(record)) {
+        // Annotation keywords (and const/enum) carry user DATA, not schemas — a
+        // plain-data object inside them may legitimately have a literal `oneOf` key
+        // that must not be renamed.
+        if (ANNOTATION_JSON_SCHEMA_KEYWORDS.has(key) || key === 'const' || key === 'enum' || key.startsWith('x-')) continue;
+        rewriteOneOfToAnyOf(value, seen);
+    }
 }
 
 /**
@@ -683,6 +715,14 @@ function nonObjectTypelessRootVerdict(
         const loudness = nonObjectLiteralLoudness(def.values);
         return loudness === undefined ? undefined : { type: 'literal', loud: loudness === 'loud' };
     }
+    if (def.type === 'never') {
+        // z.never() matches no value: it can never make a union satisfiable or
+        // object-shaped. Quiet, though — bare/all-never shapes emitted `{not: {}}`
+        // without throwing pre-#2464 and must keep listing; the verdict only turns a
+        // union loud when a loud co-member (e.g. a bigint) is present, restoring the
+        // pre-#2464 throw for those.
+        return { type: 'never', loud: false };
+    }
     return NON_OBJECT_UNREPRESENTABLE_TYPES.has(def.type) ? { type: def.type, loud: true } : undefined;
 }
 

packages/core-internal/test/util/standardSchema.test.ts

@@ -445,6 +445,46 @@ describe('zod conversion options (#2464)', () => {
         expect(new AjvJsonSchemaValidator().getValidator(result)({ t: 'a', x: 'v' }).valid).toBe(true);
     });
 
+    test('tolerant array/tuple elements also accept null in output schemas', () => {
+        // JSON.stringify turns an undefined array ELEMENT into null (it drops
+        // undefined-valued object keys), so the raw payload the server validates and
+        // ships ([1, undefined, 3]) reaches the wire as [1, null, 3].
+        const schema = z.object({
+            a: z.array(z.number().default(0)),
+            t: z.tuple([z.string().default('x'), z.number()]),
+            name: z.string()
+        });
+        const result = standardSchemaToJsonSchema(schema, 'output');
+
+        expect(new AjvJsonSchemaValidator().getValidator(result)({ a: [1, null, 3], t: [null, 1], name: 'n' }).valid).toBe(true);
+        // Non-tolerant elements keep their strict subschema.
+        const plain = standardSchemaToJsonSchema(z.object({ a: z.array(z.number()) }), 'output');
+        expect((plain.properties as Record<string, Record<string, unknown>>).a!.items).toEqual({ type: 'number' });
+    });
+
+    test('z.never() union members are quiet non-object verdicts', () => {
+        // z.never() matches no value: it cannot make a union satisfiable, so a loud
+        // co-member must keep the pre-#2464 throw ...
+        expect(() => standardSchemaToJsonSchema(z.union([z.never(), z.bigint()]), 'input')).toThrow(/must describe objects/);
+        // ... while quiet shapes (which converted silently pre-#2464) keep listing.
+        expect(standardSchemaToJsonSchema(z.never(), 'input').type).toBe('object');
+        expect(standardSchemaToJsonSchema(z.union([z.never(), z.string()]), 'input').type).toBe('object');
+        expect(standardSchemaToJsonSchema(z.union([z.never(), z.never()]), 'input').type).toBe('object');
+    });
+
+    test('the oneOf rewrite does not descend into annotation values', () => {
+        const schema = z.object({
+            cfg: z.object({ oneOf: z.array(z.number()) }).default({ oneOf: [1, 2] }),
+            counted: z.number().default(0), // trips the loosened flag
+            name: z.string()
+        });
+        const result = standardSchemaToJsonSchema(schema, 'output');
+
+        // `default` carries user DATA — its literal `oneOf` key must survive.
+        const cfg = (result.properties as Record<string, Record<string, unknown>>).cfg!;
+        expect(cfg.default).toEqual({ oneOf: [1, 2] });
+    });
+
     test('.catch() and union-nested defaults with async stages are dropped from output required', () => {
         const schema = z.object({
             c: z