fix(core-internal): conjunction-preserving oneOf rewrite; skip negated positions

- The oneOf->anyOf rename bailed when the node already carried anyOf
  (zod merges .meta({anyOf: [...]}) verbatim), leaving a
  reject-everything oneOf after its members were loosened into mutual
  satisfiability. Instead of bailing, the loosened members now move
  under allOf as {anyOf: members} — keywords on one node combine with
  AND, so this is semantically equivalent, loosen-only, and does not
  clobber the user's anyOf.
- The walker recursed into not/if, where oneOf->anyOf INVERTS polarity
  and tightens: a payload matching >=2 members passed not {oneOf}
  pre-#2464 but failed the rewritten not {anyOf} (and under if, the
  rename can flip which then/else branch applies). Negated/conditional
  positions are now skipped; then/else and the other schema-carrying
  keywords are positive-polarity and keep the rewrite.

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

Author: claude

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

@@ -409,8 +409,16 @@ function rewriteOneOfToAnyOf(node: unknown, seen: Set<unknown> = new Set()): voi
         return;
     }
     const record = node as Record<string, unknown>;
-    if (Array.isArray(record.oneOf) && record.anyOf === undefined) {
-        record.anyOf = record.oneOf;
+    if (Array.isArray(record.oneOf)) {
+        if (record.anyOf === undefined) {
+            record.anyOf = record.oneOf;
+        } else {
+            // A user `.meta({anyOf})` can coexist with the emitted `oneOf` — preserve
+            // conjunction semantics without clobbering it: keywords on one node
+            // combine with AND, so `{anyOf: members}` under `allOf` is equivalent.
+            const allOf = Array.isArray(record.allOf) ? record.allOf : (record.allOf = []);
+            allOf.push({ anyOf: record.oneOf });
+        }
         delete record.oneOf;
     }
     for (const [key, value] of Object.entries(record)) {
@@ -419,6 +427,10 @@ function rewriteOneOfToAnyOf(node: unknown, seen: Set<unknown> = new Set()): voi
         // `.meta()` keys — carries user DATA whose literal `oneOf` keys must not be
         // renamed.
         if (!SCHEMA_CARRYING_JSON_SCHEMA_KEYWORDS.has(key)) continue;
+        // oneOf→anyOf is a loosening only in POSITIVE polarity: under `not` it
+        // inverts (a payload matching ≥2 members passed `not {oneOf}` but fails
+        // `not {anyOf}`), and under `if` it can flip which then/else branch applies.
+        if (key === 'not' || key === 'if') continue;
         // Schema MAPS hold schemas under user-chosen names that may collide with
         // annotation keywords (a property literally named `description` still
         // carries a schema) — recurse into every value unconditionally.

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

@@ -622,6 +622,42 @@ describe('zod conversion options (#2464)', () => {
         expect(cfg.default).toEqual({ oneOf: [1, 2] });
     });
 
+    test('the oneOf rewrite preserves a coexisting user anyOf via allOf', () => {
+        // zod merges .meta({anyOf}) verbatim beside the emitted oneOf — bailing there
+        // left a reject-everything oneOf after the members were loosened.
+        const du = z
+            .discriminatedUnion('t', [
+                z.object({ t: z.literal('a').catch('a'), x: z.string().optional() }),
+                z.object({ t: z.literal('b').catch('b'), y: z.string().optional() })
+            ])
+            .meta({ anyOf: [{ type: 'object' }] });
+        const result = standardSchemaToJsonSchema(du, 'output');
+
+        expect(result.oneOf).toBeUndefined();
+        expect(result.anyOf).toEqual([{ type: 'object' }]); // the user's anyOf, unclobbered
+        const allOf = result.allOf as Array<{ anyOf: Array<Record<string, unknown>> }>;
+        expect(allOf).toHaveLength(1);
+        expect(allOf[0]!.anyOf.map(member => member.type)).toEqual(['object', 'object']);
+        expect(new AjvJsonSchemaValidator().getValidator(result)({ t: 'a', x: 'v' }).valid).toBe(true);
+    });
+
+    test('the oneOf rewrite skips negated and conditional positions', () => {
+        // Under `not`, oneOf→anyOf inverts polarity and TIGHTENS: {v: 4} matches
+        // both members, so it passed `not {oneOf}` pre-#2464 but would fail the
+        // rewritten `not {anyOf}`.
+        const schema = z.object({
+            v: z.number().meta({ not: { oneOf: [{ type: 'integer' }, { multipleOf: 2 }] } }),
+            counted: z.number().default(0), // trips the loosened flag
+            name: z.string()
+        });
+        const result = standardSchemaToJsonSchema(schema, 'output');
+
+        expect((result.properties as Record<string, Record<string, unknown>>).v!.not).toEqual({
+            oneOf: [{ type: 'integer' }, { multipleOf: 2 }]
+        });
+        expect(new AjvJsonSchemaValidator().getValidator(result)({ v: 4, counted: 1, name: 'n' }).valid).toBe(true);
+    });
+
     test('custom .meta() keys are annotation-opaque at both carve-out sites', () => {
         // zod merges arbitrary .meta() keys verbatim and 2020-12 validators ignore
         // unknown keywords — they are annotations by construction, like x-*.