Update input<> and output<> to prevent excessively deep in more cases

Author: colinhacks

packages/tsc/generate.ts

@@ -1,4 +1,6 @@
 import { writeFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
 
 export const ZOD = {
   imports: [`import * as z from "zod/v4";`],
@@ -175,6 +177,8 @@ export function generate(params: GenerateObjectsParams) {
 
   file.push(custom);
 
+  // Create directory if it doesn't exist
+  mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, file.join("\n"), { flag: "w" });
 }
 
@@ -304,6 +308,8 @@ export function generateExtendChain(params: GenerateExtendChainParams) {
     }
   }
 
+  // Create directory if it doesn't exist
+  mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, file.join("\n"), { flag: "w" });
 }
 

packages/tsc/tsconfig.json

@@ -4,7 +4,7 @@
   "compilerOptions": {
     "target": "es2022",
     "module": "NodeNext",
-    // "customConditions": ["@zod/source"],
+    "customConditions": [],
     "incremental": false,
     "noEmit": true
   }

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

@@ -1130,7 +1130,7 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
     return Object.fromEntries(Object.entries(inst._zod.def.shape));
   });
   inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)) as any;
-  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
+  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall }) as any;
   inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
   // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() });
   inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });

packages/zod/src/v4/classic/tests/registries.test.ts

@@ -158,12 +158,8 @@ test("inherit across clone", () => {
   expect(C.meta()).toEqual({ a: true, b: true, description: "hello" });
 });
 
-test("register with replace", () => {
+test("loose examples", () => {
   z.string().register(z.globalRegistry, {
     examples: ["example"],
   });
-  z.string().register(z.globalRegistry, {
-    // @ts-expect-error
-    examples: [1234],
-  });
 });

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

@@ -75,12 +75,23 @@ export class $ZodAsyncError extends Error {
 
 ////////////////////////////  TYPE HELPERS  ///////////////////////////////////
 
-export type input<T extends schemas.$ZodType> = T["_zod"] extends { "~input": any }
+// export type input<T extends schemas.$ZodType> = T["_zod"] extends { "~input": any }
+//   ? T["_zod"]["~input"]
+//   : T["_zod"]["input"];
+// export type output<T extends schemas.$ZodType> = T["_zod"] extends { "~output": any }
+//   ? T["_zod"]["~output"]
+//   : T["_zod"]["output"];
+export type input<T> = T extends { _zod: { "~input": any } }
   ? T["_zod"]["~input"]
-  : T["_zod"]["input"];
-export type output<T extends schemas.$ZodType> = T["_zod"] extends { "~output": any }
+  : T extends { _zod: { input: any } }
+    ? T["_zod"]["input"]
+    : never;
+export type output<T> = T extends { _zod: { "~output": any } }
   ? T["_zod"]["~output"]
-  : T["_zod"]["output"];
+  : T extends { _zod: { output: any } }
+    ? T["_zod"]["output"]
+    : never;
+
 export type { output as infer };
 
 //////////////////////////////   CONFIG   ///////////////////////////////////////

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

@@ -24,7 +24,7 @@ export const _parse: (_Err: $ZodErrorClass) => $Parse = (_Err) => (schema, value
     Error.captureStackTrace(e, _params?.callee);
     throw e;
   }
-  return result.value;
+  return result.value as core.output<typeof schema>;
 };
 
 export const parse: $Parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
@@ -68,7 +68,7 @@ export const _safeParse: (_Err: $ZodErrorClass) => $SafeParse = (_Err) => (schem
         success: false,
         error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
       }
-    : { success: true, data: result.value };
+    : ({ success: true, data: result.value } as any);
 };
 export const safeParse: $SafeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
 
@@ -88,7 +88,7 @@ export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err)
         success: false,
         error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
       }
-    : { success: true, data: result.value };
+    : ({ success: true, data: result.value } as any);
 };
 
 export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);

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

@@ -986,7 +986,7 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends Some
     keyType: union([keyType, never()]),
     valueType,
     ...util.normalizeParams(params),
-  }) as ZodMiniRecord<Key, Value>;
+  }) as ZodMiniRecord<ZodMiniUnion<[Key, ZodMiniNever]>, Value>;
 }
 
 // ZodMiniMap
@@ -1512,17 +1512,15 @@ export const stringbool: (
   ) as any;
 
 // json
-export type ZodMiniJSONSchema = ZodMiniLazy<
-  ZodMiniUnion<
-    [
-      ZodMiniString<string>,
-      ZodMiniNumber<number>,
-      ZodMiniBoolean<boolean>,
-      ZodMiniNull,
-      ZodMiniArray<ZodMiniJSONSchema>,
-      ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>,
-    ]
-  >
+export type ZodMiniJSONSchema = ZodMiniUnion<
+  [
+    ZodMiniString,
+    ZodMiniNumber,
+    ZodMiniBoolean,
+    ZodMiniNull,
+    ZodMiniArray<ZodMiniJSONSchema>,
+    ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>,
+  ]
 > & {
   _zod: {
     input: util.JSONType;
@@ -1531,8 +1529,8 @@ export type ZodMiniJSONSchema = ZodMiniLazy<
 };
 
 export function json(): ZodMiniJSONSchema {
-  const jsonSchema: ZodMiniJSONSchema = _lazy(() => {
+  const jsonSchema: any = _lazy(() => {
     return union([string(), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);
-  }) as ZodMiniJSONSchema;
+  });
   return jsonSchema;
 }

packages/zod/src/v4/mini/tests/index.test.ts

@@ -720,6 +720,8 @@ test("z.lazy", () => {
 test("z.json", () => {
   const a = z.json();
   type a = z.output<typeof a>;
+  a._zod.output;
+
   expectTypeOf<a>().toEqualTypeOf<util.JSONType>();
 
   expect(z.parse(a, "hello")).toEqual("hello");