zod 4.1.0-canary.20250813T051310 → 4.1.0-canary.20250821T014902

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.1.0-canary.20250813T051310",
+  "version": "4.1.0-canary.20250821T014902",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -118,6 +118,7 @@ export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$Z
 export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
   core.$ZodType.init(inst, def);
   inst.def = def;
+  inst.type = def.type;
   Object.defineProperty(inst, "_def", { value: def });
 
   // base methods

package/src/v4/classic/tests/index.test.ts

@@ -827,3 +827,18 @@ test("def typing", () => {
   z.string().catch("fallback").def.type satisfies "catch";
   z.file().def.type satisfies "file";
 });
+
+test("runtime type property exists and returns correct values", () => {
+  const stringSchema = z.string();
+  expect(stringSchema.type).toBe("string");
+});
+
+test("type narrowing works with type property", () => {
+  type ArrayOrRecord = z.ZodArray<z.ZodString> | z.ZodRecord<z.ZodString, z.ZodAny>;
+  const arraySchema = z.array(z.string()) as ArrayOrRecord;
+
+  if (arraySchema.type === "array") {
+    expectTypeOf(arraySchema).toEqualTypeOf<z.ZodArray<z.ZodString>>();
+    expect(arraySchema.element).toBeDefined();
+  }
+});

package/src/v4/core/schemas.ts

@@ -168,9 +168,7 @@ export interface $ZodType<
   "~standard": $ZodStandardSchema<this>;
 }
 export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals>
-  extends $ZodType<T["output"], T["input"], T> {
-  // _zod: T;
-}
+  extends $ZodType<T["output"], T["input"], T> {}
 
 export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def) => {
   inst ??= {} as any;

package/src/v4/mini/schemas.ts

@@ -9,6 +9,7 @@ export interface ZodMiniType<
   out Input = unknown,
   out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
 > extends core.$ZodType<Output, Input, Internals> {
+  type: Internals["def"]["type"];
   check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
   clone(def?: Internals["def"], params?: { parent: boolean }): this;
   register<R extends core.$ZodRegistry>(
@@ -43,7 +44,9 @@ export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$c
     if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
 
     core.$ZodType.init(inst, def);
+
     inst.def = def;
+    inst.type = def.type;
     inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
     inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });

package/src/v4/mini/tests/index.test.ts

@@ -882,3 +882,18 @@ test("defaulted object schema returns shallow clone", () => {
   expect(result1).not.toBe(result2);
   expect(result1).toEqual(result2);
 });
+
+test("runtime type property exists and returns correct values", () => {
+  const stringSchema = z.string();
+  expect(stringSchema.type).toBe("string");
+});
+
+test("type narrowing works with type property", () => {
+  type ArrayOrRecord = z.ZodMiniArray<z.ZodMiniString> | z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniAny>;
+  const arraySchema = z.array(z.string()) as ArrayOrRecord;
+
+  if (arraySchema.type === "array") {
+    expectTypeOf(arraySchema).toEqualTypeOf<z.ZodMiniArray<z.ZodMiniString<unknown>>>();
+    expect(arraySchema.def.element).toBeDefined();
+  }
+});

package/v4/classic/schemas.cjs

@@ -115,6 +115,7 @@ const parse = __importStar(require("./parse.cjs"));
 exports.ZodType = core.$constructor("ZodType", (inst, def) => {
     core.$ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
     // base methods
     inst.check = (...checks) => {

package/v4/classic/schemas.js

@@ -6,6 +6,7 @@ import * as parse from "./parse.js";
 export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
     core.$ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
     // base methods
     inst.check = (...checks) => {

package/v4/mini/schemas.cjs

@@ -121,6 +121,7 @@ exports.ZodMiniType = core.$constructor("ZodMiniType", (inst, def) => {
         throw new Error("Uninitialized schema in ZodMiniType.");
     core.$ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
     inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });

package/v4/mini/schemas.d.cts

@@ -2,6 +2,7 @@ import * as core from "../core/index.cjs";
 import { util } from "../core/index.cjs";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
+    type: Internals["def"]["type"];
     check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     clone(def?: Internals["def"], params?: {
         parent: boolean;

package/v4/mini/schemas.d.ts

@@ -2,6 +2,7 @@ import * as core from "../core/index.js";
 import { util } from "../core/index.js";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
+    type: Internals["def"]["type"];
     check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     clone(def?: Internals["def"], params?: {
         parent: boolean;

package/v4/mini/schemas.js

@@ -6,6 +6,7 @@ export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst,
         throw new Error("Uninitialized schema in ZodMiniType.");
     core.$ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
     inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });