Fix json (#4630)

* Fix json

* Tweaks

* Clean up

* Clean up

Author: colinhacks

packages/zod/src/v4/classic/schemas.ts

@@ -987,7 +987,7 @@ export function date(params?: string | core.$ZodDateParams): ZodDate {
 
 // ZodArray
 export interface ZodArray<T extends core.SomeType = core.$ZodType>
-  extends ZodType<any, any, core.$ZodArrayInternals<T>>,
+  extends _ZodType<core.$ZodArrayInternals<T>>,
     core.$ZodArray<T> {
   element: T;
   min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
@@ -1370,7 +1370,7 @@ export function map<Key extends core.SomeType, Value extends core.SomeType>(
 
 // ZodSet
 export interface ZodSet<T extends core.SomeType = core.$ZodType>
-  extends ZodType<any, any, core.$ZodSetInternals<T>>,
+  extends _ZodType<core.$ZodSetInternals<T>>,
     core.$ZodSet<T> {
   min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
   /** */
@@ -1996,14 +1996,18 @@ export const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPi
   ) as any;
 
 // json
-export type ZodJSONSchema = ZodUnion<
+type _ZodJSONSchema = ZodUnion<
   [ZodString, ZodNumber, ZodBoolean, ZodNull, ZodArray<ZodJSONSchema>, ZodRecord<ZodString, ZodJSONSchema>]
-> & {
-  _zod: {
-    input: util.JSONType;
-    output: util.JSONType;
-  };
-};
+>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+
+export interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+  output: util.JSONType;
+  input: util.JSONType;
+}
+export interface ZodJSONSchema extends _ZodJSONSchema {
+  _zod: ZodJSONSchemaInternals;
+}
 
 export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
   const jsonSchema: any = lazy(() => {
@@ -2016,9 +2020,9 @@ export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
 // preprocess
 
 // /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
-export function preprocess<A, U extends core.SomeType>(
-  fn: (arg: unknown, ctx: RefinementCtx) => A,
+export function preprocess<A, U extends core.SomeType, B = unknown>(
+  fn: (arg: B, ctx: RefinementCtx) => A,
   schema: U
-): ZodPipe<ZodTransform<A, unknown>, U> {
-  return pipe(transform(fn as any), schema as any);
+): ZodPipe<ZodTransform<A, B>, U> {
+  return pipe(transform(fn as any), schema as any) as any;
 }

packages/zod/src/v4/classic/tests/recursive-types.test.ts

@@ -211,6 +211,7 @@ test("mutual recursion with meta", () => {
         b: _B;
       }>
     | undefined;
+  // | undefined;
   type _B = Readonly<{
     name: string;
     a?: _A;

packages/zod/src/v4/core/schemas.ts

@@ -154,11 +154,7 @@ export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$Z
 
 export type $ZodStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
 
-// export interface _$ZodType<T extends _$ZodTypeInternals = _$ZodTypeInternals> {
-//   _zod: T;
-// }
 export type SomeType = { _zod: _$ZodTypeInternals };
-// _$ZodType; //<any, any, $ZodTypeInternals<unknown, unknown>>;
 
 export interface $ZodType<
   O = unknown,
@@ -168,6 +164,10 @@ export interface $ZodType<
   _zod: Internals;
   "~standard": $ZodStandardSchema<this>;
 }
+export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals>
+  extends $ZodType<T["output"], T["input"], T> {
+  // _zod: T;
+}
 
 export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def) => {
   inst ??= {} as any;
@@ -300,8 +300,8 @@ export interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, In
   }>;
 }
 
-export interface $ZodString<Input = unknown> extends $ZodType {
-  _zod: $ZodStringInternals<Input>;
+export interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {
+  // _zod: $ZodStringInternals<Input>;
 }
 
 export const $ZodString: core.$constructor<$ZodString> = /*@__PURE__*/ core.$constructor("$ZodString", (inst, def) => {
@@ -1463,9 +1463,8 @@ export interface $ZodArrayInternals<T extends SomeType = $ZodType>
   isst: errors.$ZodIssueInvalidType;
 }
 
-export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodArrayInternals<T>;
-}
+export interface $ZodArray<T extends SomeType = $ZodType>
+  extends $ZodType<core.output<T>[], core.input<T>[], $ZodArrayInternals<T>> {}
 
 function handleArrayResult(result: ParsePayload<any>, final: ParsePayload<any[]>, index: number) {
   if (result.issues.length) {
@@ -1524,30 +1523,6 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
 //////////                      //////////
 //////////////////////////////////////////
 //////////////////////////////////////////
-export type $ZodShape = Readonly<{ [k: string]: $ZodType }>;
-
-export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
-  type: "object";
-  shape: Shape;
-  catchall?: $ZodType | undefined;
-}
-
-export interface $ZodObjectInternals<
-  /** @ts-ignore Cast variance */
-  out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
-  out Config extends $ZodObjectConfig = $ZodObjectConfig,
-> extends _$ZodTypeInternals {
-  def: $ZodObjectDef<Shape>;
-  config: Config;
-  isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
-  propValues: util.PropValues;
-  // special keys only used for objects
-  // not defined on $ZodTypeInternals (base interface) because it breaks cyclical inference
-  // the z.infer<> util checks for these first when extracting inferred type
-  output: $InferObjectOutput<Shape, Config["out"]>;
-  input: $InferObjectInput<Shape, Config["in"]>;
-}
-export type $ZodLooseShape = Record<string, any>;
 
 type OptionalOutSchema = { _zod: { optout: "optional" } };
 type OptionalInSchema = { _zod: { optin: "optional" } };
@@ -1656,12 +1631,33 @@ export type $catchall<T extends SomeType> = {
   in: { [k: string]: core.input<T> };
 };
 
+export type $ZodShape = Readonly<{ [k: string]: $ZodType }>;
+
+export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+
+export interface $ZodObjectInternals<
+  /** @ts-ignore Cast variance */
+  out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
+  out Config extends $ZodObjectConfig = $ZodObjectConfig,
+> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
+  propValues: util.PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+}
+export type $ZodLooseShape = Record<string, any>;
+
 export interface $ZodObject<
   /** @ts-ignore Cast variance */
   out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
   out Params extends $ZodObjectConfig = $ZodObjectConfig,
 > extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
-  // _zod: $ZodObjectInternals<Shape, Params>;
   "~standard": $ZodStandardSchema<this>;
 }
 

play.ts

@@ -1,54 +1,3 @@
 import { z } from "zod/v4";
 
-z.ipv4()
-  .transform((value) => {
-    // Called when invalid value
-    console.log("input:", value);
-
-    return value;
-  })
-  .safeParse("invalid_value");
-
-z.email()
-  .transform((value) => {
-    // Called when invalid value
-    console.log("input:", value);
-
-    return value;
-  })
-  .safeParse("invalid_value");
-
-z.uuid()
-  .transform((value) => {
-    // Called when invalid value
-    console.log("input:", value);
-
-    return value;
-  })
-  .safeParse("invalid_value");
-
-z.url()
-  .transform((value) => {
-    // Not called when invalid value
-    console.log("input:", value);
-    return value;
-  })
-  .safeParse("invalid_value");
-
-z.number()
-  .transform((value) => {
-    // Not called when invalid value
-    console.log("input:", value);
-
-    return value;
-  })
-  .safeParse("invalid_value");
-
-z.boolean()
-  .transform((value) => {
-    // Not called when invalid value
-    console.log("input:", value);
-
-    return value;
-  })
-  .safeParse("invalid_value");
+z;