zod 3.26.0-canary.20250703T011142 → 3.26.0-canary.20250703T025502

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

@@ -0,0 +1,293 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4-mini";
+
+const FAIL = { success: false };
+
+test("z.string", async () => {
+  const a = z.string();
+  expect(z.parse(a, "hello")).toEqual("hello");
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  type a = z.infer<typeof a>;
+  expectTypeOf<a>().toEqualTypeOf<string>();
+});
+
+// test("z.string with description", () => {
+//   const a = z.string({ description: "string description" });
+//   a._def;
+//   expect(a._def.description).toEqual("string description");
+// });
+
+test("z.string with custom error", () => {
+  const a = z.string({ error: () => "BAD" });
+  expect(z.safeParse(a, 123).error!.issues[0].message).toEqual("BAD");
+});
+
+test("inference in checks", () => {
+  const a = z.string().check(z.refine((val) => val.length));
+  z.parse(a, "___");
+  expect(() => z.parse(a, "")).toThrow();
+  const b = z.string().check(z.refine((val) => val.length));
+  z.parse(b, "___");
+  expect(() => z.parse(b, "")).toThrow();
+  const c = z.string().check(z.refine((val) => val.length));
+  z.parse(c, "___");
+  expect(() => z.parse(c, "")).toThrow();
+  const d = z.string().check(z.refine((val) => val.length));
+  z.parse(d, "___");
+  expect(() => z.parse(d, "")).toThrow();
+});
+
+test("z.string async", async () => {
+  // async
+  const a = z.string().check(z.refine(async (val) => val.length));
+  expect(await z.parseAsync(a, "___")).toEqual("___");
+  await expect(() => z.parseAsync(a, "")).rejects.toThrowError();
+});
+
+test("z.uuid", () => {
+  const a = z.uuid();
+  // parse uuid
+  z.parse(a, "550e8400-e29b-41d4-a716-446655440000");
+  z.parse(a, "550e8400-e29b-61d4-a716-446655440000");
+
+  // bad uuid
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+
+  const b = z.uuidv4();
+  z.parse(b, "550e8400-e29b-41d4-a716-446655440000");
+  expect(z.safeParse(b, "550e8400-e29b-61d4-a716-446655440000")).toMatchObject(FAIL);
+
+  const c = z.uuidv6();
+  z.parse(c, "550e8400-e29b-61d4-a716-446655440000");
+  expect(z.safeParse(c, "550e8400-e29b-41d4-a716-446655440000")).toMatchObject(FAIL);
+
+  const d = z.uuidv7();
+  z.parse(d, "550e8400-e29b-71d4-a716-446655440000");
+  expect(z.safeParse(d, "550e8400-e29b-41d4-a716-446655440000")).toMatchObject(FAIL);
+  expect(z.safeParse(d, "550e8400-e29b-61d4-a716-446655440000")).toMatchObject(FAIL);
+});
+
+test("z.email", () => {
+  const a = z.email();
+  expect(z.parse(a, "test@test.com")).toEqual("test@test.com");
+  expect(() => z.parse(a, "test")).toThrow();
+  expect(z.safeParse(a, "bad email", { error: () => "bad email" }).error!.issues[0].message).toEqual("bad email");
+
+  const b = z.email("bad email");
+  expect(z.safeParse(b, "bad email").error!.issues[0].message).toEqual("bad email");
+
+  const c = z.email({ error: "bad email" });
+  expect(z.safeParse(c, "bad email").error!.issues[0].message).toEqual("bad email");
+
+  const d = z.email({ error: () => "bad email" });
+  expect(z.safeParse(d, "bad email").error!.issues[0].message).toEqual("bad email");
+});
+
+test("z.url", () => {
+  const a = z.url();
+  // valid URLs
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(a.parse("ftp://example.com")).toEqual("ftp://example.com");
+  expect(a.parse("http://sub.example.com")).toEqual("http://sub.example.com");
+  expect(a.parse("https://example.com/path?query=123#fragment")).toEqual("https://example.com/path?query=123#fragment");
+  expect(a.parse("http://localhost")).toEqual("http://localhost");
+  expect(a.parse("https://localhost")).toEqual("https://localhost");
+  expect(a.parse("http://localhost:3000")).toEqual("http://localhost:3000");
+  expect(a.parse("https://localhost:3000")).toEqual("https://localhost:3000");
+
+  // invalid URLs
+  expect(() => a.parse("not-a-url")).toThrow();
+  // expect(() => a.parse("http:/example.com")).toThrow();
+  expect(() => a.parse("://example.com")).toThrow();
+  expect(() => a.parse("http://")).toThrow();
+  expect(() => a.parse("example.com")).toThrow();
+
+  // wrong type
+  expect(() => a.parse(123)).toThrow();
+  expect(() => a.parse(null)).toThrow();
+  expect(() => a.parse(undefined)).toThrow();
+});
+
+test("z.url with optional hostname regex", () => {
+  const a = z.url({ hostname: /example\.com$/ });
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://sub.example.com")).toEqual("https://sub.example.com");
+  expect(() => a.parse("http://examples.com")).toThrow();
+  expect(() => a.parse("http://example.org")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url - file urls", () => {
+  // file URLs
+  const a = z.url({ hostname: /.*/ }); // allow any hostname
+  expect(a.parse("file:///path/to/file.txt")).toEqual("file:///path/to/file.txt");
+  expect(a.parse("file:///C:/path/to/file.txt")).toEqual("file:///C:/path/to/file.txt");
+  expect(a.parse("file:///C:/path/to/file.txt?query=123#fragment")).toEqual(
+    "file:///C:/path/to/file.txt?query=123#fragment"
+  );
+});
+test("z.url with optional protocol regex", () => {
+  const a = z.url({ protocol: /^https?$/ });
+  expect(a.parse("http://example.com")).toEqual("http://example.com");
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(() => a.parse("ftp://example.com")).toThrow();
+  expect(() => a.parse("mailto:example@example.com")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url with both hostname and protocol regexes", () => {
+  const a = z.url({ hostname: /example\.com$/, protocol: /^https$/ });
+  expect(a.parse("https://example.com")).toEqual("https://example.com");
+  expect(a.parse("https://sub.example.com")).toEqual("https://sub.example.com");
+  expect(() => a.parse("http://example.com")).toThrow();
+  expect(() => a.parse("https://example.org")).toThrow();
+  expect(() => a.parse("ftp://example.com")).toThrow();
+  expect(() => a.parse("asdf")).toThrow();
+});
+
+test("z.url with invalid regex patterns", () => {
+  const a = z.url({ hostname: /a+$/, protocol: /^ftp$/ });
+  a.parse("ftp://a");
+  a.parse("ftp://aaaaaaaa");
+  expect(() => a.parse("http://aaa")).toThrow();
+  expect(() => a.parse("https://example.com")).toThrow();
+  expect(() => a.parse("ftp://asdfasdf")).toThrow();
+  expect(() => a.parse("ftp://invalid")).toThrow();
+});
+
+test("z.emoji", () => {
+  const a = z.emoji();
+  expect(z.parse(a, "😀")).toEqual("😀");
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+test("z.nanoid", () => {
+  const a = z.nanoid();
+  expect(z.parse(a, "8FHZpIxleEK3axQRBNNjN")).toEqual("8FHZpIxleEK3axQRBNNjN");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.cuid", () => {
+  const a = z.cuid();
+  expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.cuid2", () => {
+  const a = z.cuid2();
+  expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.ulid", () => {
+  const a = z.ulid();
+  expect(z.parse(a, "01ETGRM9QYVX6S9V2F3B6JXG4N")).toEqual("01ETGRM9QYVX6S9V2F3B6JXG4N");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.xid", () => {
+  const a = z.xid();
+  expect(z.parse(a, "9m4e2mr0ui3e8a215n4g")).toEqual("9m4e2mr0ui3e8a215n4g");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+test("z.ksuid", () => {
+  const a = z.ksuid();
+  expect(z.parse(a, "2naeRjTrrHJAkfd3tOuEjw90WCA")).toEqual("2naeRjTrrHJAkfd3tOuEjw90WCA");
+  expect(() => z.parse(a, "abc")).toThrow();
+});
+
+// test("z.ip", () => {
+//   const a = z.ip();
+//   expect(z.parse(a, "127.0.0.1")).toEqual("127.0.0.1");
+//   expect(z.parse(a, "2001:0db8:85a3:0000:0000:8a2e:0370:7334")).toEqual("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
+//   expect(() => z.parse(a, "abc")).toThrow();
+// });
+
+test("z.ipv4", () => {
+  const a = z.ipv4();
+  // valid ipv4
+  expect(z.parse(a, "192.168.1.1")).toEqual("192.168.1.1");
+  expect(z.parse(a, "255.255.255.255")).toEqual("255.255.255.255");
+  // invalid ipv4
+  expect(() => z.parse(a, "999.999.999.999")).toThrow();
+  expect(() => z.parse(a, "256.256.256.256")).toThrow();
+  expect(() => z.parse(a, "192.168.1")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.ipv6", () => {
+  const a = z.ipv6();
+  // valid ipv6
+  expect(z.parse(a, "2001:0db8:85a3:0000:0000:8a2e:0370:7334")).toEqual("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
+  expect(z.parse(a, "::1")).toEqual("::1");
+  // invalid ipv6
+  expect(() => z.parse(a, "2001:db8::85a3::8a2e:370:7334")).toThrow();
+  expect(() => z.parse(a, "2001:db8:85a3:0:0:8a2e:370g:7334")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.base64", () => {
+  const a = z.base64();
+  // valid base64
+  expect(z.parse(a, "SGVsbG8gd29ybGQ=")).toEqual("SGVsbG8gd29ybGQ=");
+  expect(z.parse(a, "U29tZSBvdGhlciBzdHJpbmc=")).toEqual("U29tZSBvdGhlciBzdHJpbmc=");
+  // invalid base64
+  expect(() => z.parse(a, "SGVsbG8gd29ybGQ")).toThrow();
+  expect(() => z.parse(a, "U29tZSBvdGhlciBzdHJpbmc")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+// test("z.jsonString", () => {
+//   const a = z.jsonString();
+//   // valid JSON string
+//   expect(z.parse(a, '{"key":"value"}')).toEqual('{"key":"value"}');
+//   expect(z.parse(a, '["item1", "item2"]')).toEqual('["item1", "item2"]');
+//   // invalid JSON string
+//   expect(() => z.parse(a, '{"key":value}')).toThrow();
+//   expect(() => z.parse(a, '["item1", "item2"')).toThrow();
+//   expect(() => z.parse(a, "hello")).toThrow();
+//   // wrong type
+//   expect(() => z.parse(a, 123)).toThrow();
+// });
+
+test("z.e164", () => {
+  const a = z.e164();
+  // valid e164
+  expect(z.parse(a, "+1234567890")).toEqual("+1234567890");
+  expect(z.parse(a, "+19876543210")).toEqual("+19876543210");
+  // invalid e164
+  expect(() => z.parse(a, "1234567890")).toThrow();
+  expect(() => z.parse(a, "+12345")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
+test("z.jwt", () => {
+  const a = z.jwt();
+  // valid jwt
+  expect(
+    z.parse(
+      a,
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+    )
+  ).toEqual(
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+  );
+  // invalid jwt
+  expect(() => z.parse(a, "invalid.jwt.token")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});

package/src/v4-mini/index.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/v4/classic/compat.cjs

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = exports.$brand = exports.NEVER = exports.ZodIssueCode = void 0;
+exports.config = exports.$brand = exports.ZodIssueCode = void 0;
 exports.setErrorMap = setErrorMap;
 exports.getErrorMap = getErrorMap;
 const core = __importStar(require("../core/index.cjs"));
@@ -42,12 +42,6 @@ exports.ZodIssueCode = {
     invalid_value: "invalid_value",
     custom: "custom",
 };
-/** @deprecated Not necessary in Zod 4. */
-const INVALID = Object.freeze({
-    status: "aborted",
-});
-/** A special constant with type `never` */
-exports.NEVER = INVALID;
 var index_js_1 = require("../core/index.cjs");
 Object.defineProperty(exports, "$brand", { enumerable: true, get: function () { return index_js_1.$brand; } });
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return index_js_1.config; } });

package/v4/classic/compat.d.cts

@@ -21,8 +21,6 @@ export declare const ZodIssueCode: {
     readonly invalid_value: "invalid_value";
     readonly custom: "custom";
 };
-/** A special constant with type `never` */
-export declare const NEVER: never;
 /** @deprecated Use `z.$ZodFlattenedError` */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
 /** @deprecated Use `z.$ZodFormattedError` */

package/v4/classic/compat.d.ts

@@ -21,8 +21,6 @@ export declare const ZodIssueCode: {
     readonly invalid_value: "invalid_value";
     readonly custom: "custom";
 };
-/** A special constant with type `never` */
-export declare const NEVER: never;
 /** @deprecated Use `z.$ZodFlattenedError` */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
 /** @deprecated Use `z.$ZodFormattedError` */

package/v4/classic/compat.js

@@ -14,12 +14,6 @@ export const ZodIssueCode = {
     invalid_value: "invalid_value",
     custom: "custom",
 };
-/** @deprecated Not necessary in Zod 4. */
-const INVALID = Object.freeze({
-    status: "aborted",
-});
-/** A special constant with type `never` */
-export const NEVER = INVALID;
 export { $brand, config } from "../core/index.js";
 /** @deprecated Use `z.config(params)` instead. */
 export function setErrorMap(map) {

package/v4/classic/external.cjs

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coerce = exports.iso = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.locales = exports.TimePrecision = exports.toJSONSchema = exports.flattenError = exports.formatError = exports.prettifyError = exports.treeifyError = exports.regexes = exports.clone = exports.$brand = exports.$input = exports.$output = exports.function = exports.config = exports.registry = exports.globalRegistry = exports.core = void 0;
+exports.coerce = exports.iso = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.locales = exports.NEVER = exports.TimePrecision = exports.toJSONSchema = exports.flattenError = exports.formatError = exports.prettifyError = exports.treeifyError = exports.regexes = exports.clone = exports.$brand = exports.$input = exports.$output = exports.function = exports.config = exports.registry = exports.globalRegistry = exports.core = void 0;
 exports.core = __importStar(require("../core/index.cjs"));
 __exportStar(require("./schemas.cjs"), exports);
 __exportStar(require("./checks.cjs"), exports);
@@ -56,6 +56,7 @@ Object.defineProperty(exports, "formatError", { enumerable: true, get: function
 Object.defineProperty(exports, "flattenError", { enumerable: true, get: function () { return index_js_2.flattenError; } });
 Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return index_js_2.toJSONSchema; } });
 Object.defineProperty(exports, "TimePrecision", { enumerable: true, get: function () { return index_js_2.TimePrecision; } });
+Object.defineProperty(exports, "NEVER", { enumerable: true, get: function () { return index_js_2.NEVER; } });
 exports.locales = __importStar(require("../locales/index.cjs"));
 // iso
 // must be exported from top-level

package/v4/classic/external.d.cts

@@ -5,7 +5,7 @@ export * from "./errors.cjs";
 export * from "./parse.cjs";
 export * from "./compat.cjs";
 export type { infer, output, input } from "../core/index.cjs";
-export { globalRegistry, type GlobalMeta, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, } from "../core/index.cjs";
+export { globalRegistry, type GlobalMeta, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, NEVER, } from "../core/index.cjs";
 export * as locales from "../locales/index.cjs";
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.cjs";
 export * as iso from "./iso.cjs";

package/v4/classic/external.d.ts

@@ -5,7 +5,7 @@ export * from "./errors.js";
 export * from "./parse.js";
 export * from "./compat.js";
 export type { infer, output, input } from "../core/index.js";
-export { globalRegistry, type GlobalMeta, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, } from "../core/index.js";
+export { globalRegistry, type GlobalMeta, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, NEVER, } from "../core/index.js";
 export * as locales from "../locales/index.js";
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
 export * as iso from "./iso.js";

package/v4/classic/external.js

@@ -8,7 +8,7 @@ export * from "./compat.js";
 import { config } from "../core/index.js";
 import en from "../locales/en.js";
 config(en());
-export { globalRegistry, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, } from "../core/index.js";
+export { globalRegistry, registry, config, function, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, NEVER, } from "../core/index.js";
 export * as locales from "../locales/index.js";
 // iso
 // must be exported from top-level

package/v4/classic/schemas.d.cts

@@ -428,18 +428,18 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
      * ```
      */
     merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
-    pick<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-    omit<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    omit<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
     partial(): ZodObject<{
         [k in keyof Shape]: ZodOptional<Shape[k]>;
     }, Config>;
-    partial<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+    partial<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
     }, Config>;
     required(): ZodObject<{
         [k in keyof Shape]: ZodNonOptional<Shape[k]>;
     }, Config>;
-    required<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+    required<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
     }, Config>;
 }

package/v4/classic/schemas.d.ts

@@ -428,18 +428,18 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
      * ```
      */
     merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
-    pick<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-    omit<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    omit<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
     partial(): ZodObject<{
         [k in keyof Shape]: ZodOptional<Shape[k]>;
     }, Config>;
-    partial<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+    partial<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
     }, Config>;
     required(): ZodObject<{
         [k in keyof Shape]: ZodNonOptional<Shape[k]>;
     }, Config>;
-    required<M extends util.Exactly<util.Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+    required<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
         [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
     }, Config>;
 }

package/v4/core/api.cjs

@@ -965,10 +965,10 @@ function _refine(Class, fn, _params) {
     return schema;
 }
 function _stringbool(Classes, _params) {
-    const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);
-    let truthyArray = truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
-    let falsyArray = falsy ?? ["false", "0", "no", "off", "n", "disabled"];
-    if (_case !== "sensitive") {
+    const params = util.normalizeParams(_params);
+    let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+    let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
+    if (params.case !== "sensitive") {
         truthyArray = truthyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
         falsyArray = falsyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
     }
@@ -982,7 +982,7 @@ function _stringbool(Classes, _params) {
         type: "transform",
         transform: (input, payload) => {
             let data = input;
-            if (_case !== "sensitive")
+            if (params.case !== "sensitive")
                 data = data.toLowerCase();
             if (truthySet.has(data)) {
                 return true;
@@ -1001,22 +1001,23 @@ function _stringbool(Classes, _params) {
                 return {};
             }
         },
-        error,
+        error: params.error,
     });
+    // params.error;
     const innerPipe = new _Pipe({
         type: "pipe",
-        in: new _String({ type: "string", error }),
+        in: new _String({ type: "string", error: params.error }),
         out: tx,
-        error,
+        error: params.error,
     });
     const outerPipe = new _Pipe({
         type: "pipe",
         in: innerPipe,
         out: new _Boolean({
             type: "boolean",
-            error,
+            error: params.error,
         }),
-        error,
+        error: params.error,
     });
     return outerPipe;
 }

package/v4/core/api.js

@@ -832,10 +832,10 @@ export function _refine(Class, fn, _params) {
     return schema;
 }
 export function _stringbool(Classes, _params) {
-    const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);
-    let truthyArray = truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
-    let falsyArray = falsy ?? ["false", "0", "no", "off", "n", "disabled"];
-    if (_case !== "sensitive") {
+    const params = util.normalizeParams(_params);
+    let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+    let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
+    if (params.case !== "sensitive") {
         truthyArray = truthyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
         falsyArray = falsyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
     }
@@ -849,7 +849,7 @@ export function _stringbool(Classes, _params) {
         type: "transform",
         transform: (input, payload) => {
             let data = input;
-            if (_case !== "sensitive")
+            if (params.case !== "sensitive")
                 data = data.toLowerCase();
             if (truthySet.has(data)) {
                 return true;
@@ -868,22 +868,23 @@ export function _stringbool(Classes, _params) {
                 return {};
             }
         },
-        error,
+        error: params.error,
     });
+    // params.error;
     const innerPipe = new _Pipe({
         type: "pipe",
-        in: new _String({ type: "string", error }),
+        in: new _String({ type: "string", error: params.error }),
         out: tx,
-        error,
+        error: params.error,
     });
     const outerPipe = new _Pipe({
         type: "pipe",
         in: innerPipe,
         out: new _Boolean({
             type: "boolean",
-            error,
+            error: params.error,
         }),
-        error,
+        error: params.error,
     });
     return outerPipe;
 }

package/v4/core/checks.cjs

@@ -85,7 +85,7 @@ exports.$ZodCheckGreaterThan = core.$constructor("$ZodCheckGreaterThan", (inst,
             return;
         }
         payload.issues.push({
-            origin: origin,
+            origin,
             code: "too_small",
             minimum: def.value,
             input: payload.value,
@@ -320,6 +320,8 @@ exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, de
         payload.issues.push({
             origin: util.getSizableOrigin(input),
             ...(tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }),
+            inclusive: true,
+            exact: true,
             input: payload.value,
             inst,
             continue: !def.abort,
@@ -403,9 +405,9 @@ exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst
         const tooBig = length > def.length;
         payload.issues.push({
             origin,
-            ...(tooBig
-                ? { code: "too_big", maximum: def.length, exact: true }
-                : { code: "too_small", minimum: def.length, exact: true }),
+            ...(tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }),
+            inclusive: true,
+            exact: true,
             input: payload.value,
             inst,
             continue: !def.abort,

package/v4/core/checks.js

@@ -59,7 +59,7 @@ export const $ZodCheckGreaterThan = /*@__PURE__*/ core.$constructor("$ZodCheckGr
             return;
         }
         payload.issues.push({
-            origin: origin,
+            origin,
             code: "too_small",
             minimum: def.value,
             input: payload.value,
@@ -294,6 +294,8 @@ export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSiz
         payload.issues.push({
             origin: util.getSizableOrigin(input),
             ...(tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }),
+            inclusive: true,
+            exact: true,
             input: payload.value,
             inst,
             continue: !def.abort,
@@ -377,9 +379,9 @@ export const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor("$ZodCheckL
         const tooBig = length > def.length;
         payload.issues.push({
             origin,
-            ...(tooBig
-                ? { code: "too_big", maximum: def.length, exact: true }
-                : { code: "too_small", minimum: def.length, exact: true }),
+            ...(tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }),
+            inclusive: true,
+            exact: true,
             input: payload.value,
             inst,
             continue: !def.abort,

package/v4/core/core.cjs

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalConfig = exports.$ZodAsyncError = exports.$brand = void 0;
+exports.globalConfig = exports.$ZodAsyncError = exports.$brand = exports.NEVER = void 0;
 exports.$constructor = $constructor;
 exports.config = config;
+/** A special constant with type `never` */
+exports.NEVER = Object.freeze({
+    status: "aborted",
+});
 function $constructor(name, initializer, params) {
     function init(inst, def) {
         var _a;

package/v4/core/core.d.cts

@@ -11,6 +11,8 @@ export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
     new (def: D): T;
     init(inst: T, def: D): asserts inst is T;
 }
+/** A special constant with type `never` */
+export declare const NEVER: never;
 export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
     Parent?: typeof Class;
 }): $constructor<T, D>;

package/v4/core/core.d.ts

@@ -11,6 +11,8 @@ export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
     new (def: D): T;
     init(inst: T, def: D): asserts inst is T;
 }
+/** A special constant with type `never` */
+export declare const NEVER: never;
 export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
     Parent?: typeof Class;
 }): $constructor<T, D>;