zod 4.1.0-canary.20250821T014902 → 4.1.0-canary.20250823T064644

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

@@ -0,0 +1,68 @@
+import { expect, expectTypeOf, test } from "vitest";
+import { type ZodCustomStringFormat, hash } from "zod"; // adjust path as needed
+
+test("hash() API — types and runtime across all alg/enc combinations", async () => {
+  const { createHash } = await import("node:crypto");
+
+  type Alg = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+  // type Enc = "hex" | "base64" | "base64url";
+
+  const toB64Url = (b64: string) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+
+  const makeDigests = (alg: Alg, input: string) => {
+    const buf = createHash(alg).update(input).digest();
+    const hex = buf.toString("hex");
+    const base64 = buf.toString("base64");
+    const base64url = toB64Url(base64);
+    return { hex, base64, base64url };
+  };
+
+  const algs: ReadonlyArray<Alg> = ["md5", "sha1", "sha256", "sha384", "sha512"];
+  const input = "zodasklfjaasdf";
+
+  // --- Type-level checks (ensure the literal format string is encoded in the return type)
+  expectTypeOf(hash("md5")).toEqualTypeOf<ZodCustomStringFormat<"md5_hex">>();
+  expectTypeOf(hash("sha1")).toEqualTypeOf<ZodCustomStringFormat<"sha1_hex">>();
+  expectTypeOf(hash("sha256", { enc: "base64" as const })).toEqualTypeOf<ZodCustomStringFormat<"sha256_base64">>();
+  expectTypeOf(hash("sha384", { enc: "base64url" as const })).toEqualTypeOf<
+    ZodCustomStringFormat<"sha384_base64url">
+  >();
+
+  // Test generic format types are correctly inferred and Enc defaults to "hex"
+  expectTypeOf(hash("sha256")).toEqualTypeOf<ZodCustomStringFormat<"sha256_hex">>();
+
+  // --- Runtime matrix (success + a few sharp-edged failures per combo)
+  for (const alg of algs) {
+    const { hex, base64, base64url } = makeDigests(alg, input);
+
+    // Success cases
+    expect(hash(alg).parse(hex)).toBe(hex); // default enc=hex
+    expect(hash(alg, { enc: "hex" }).parse(hex)).toBe(hex);
+    expect(hash(alg, { enc: "base64" }).parse(base64)).toBe(base64);
+    expect(hash(alg, { enc: "base64url" }).parse(base64url)).toBe(base64url);
+
+    // Failure cases (wrong encoding to schema)
+    expect(() => hash(alg, { enc: "hex" }).parse(base64)).toThrow();
+    expect(() => hash(alg, { enc: "base64" }).parse(hex)).toThrow();
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64)).toThrow();
+
+    // Encoding-specific failures
+    // hex: uppercase allowed, wrong length should fail
+    hash(alg, { enc: "hex" }).parse(hex.toUpperCase());
+    expect(() => hash(alg, { enc: "hex" }).parse(hex.slice(0, -1))).toThrow();
+
+    // base64: missing required padding should fail (only for algorithms that require padding)
+    if (base64.includes("=")) {
+      const base64NoPad = base64.replace(/=+$/g, "");
+      expect(() => hash(alg, { enc: "base64" }).parse(base64NoPad)).toThrow();
+    }
+
+    // base64url: adding padding or using invalid characters should fail
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "=")).toThrow();
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "!")).toThrow();
+
+    // Param object present but enc omitted should still default to hex at runtime
+    const schemaWithEmptyParams = hash(alg, {} as any);
+    expect(schemaWithEmptyParams.parse(hex)).toBe(hex);
+  }
+});

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

@@ -84,3 +84,18 @@ test("nonoptional in object", () => {
     ]]
   `);
 });
+
+test("encoding", () => {
+  const schema = z.string().optional().nonoptional();
+  expect(z.encode(schema, "hello")).toEqual("hello");
+  expect(() => z.encode(schema, undefined as any)).toThrowErrorMatchingInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "nonoptional",
+        "path": [],
+        "message": "Invalid input: expected nonoptional, received undefined"
+      }
+    ]]
+  `);
+});

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

@@ -162,13 +162,13 @@ test("catchall overrides strict", () => {
   });
 });
 
-test("optional keys are unset", async () => {
+test("optional keys are unset", () => {
   const SNamedEntity = z.object({
     id: z.string(),
     set: z.string().optional(),
     unset: z.string().optional(),
   });
-  const result = await SNamedEntity.parse({
+  const result = SNamedEntity.parse({
     id: "asdf",
     set: undefined,
   });
@@ -435,6 +435,17 @@ test("extend() should have power to override existing key", () => {
   expectTypeOf<PersonWithNumberAsLastName>().toEqualTypeOf<{ firstName: string; lastName: number }>();
 });
 
+test("safeExtend() maintains refinements", () => {
+  const schema = z.object({ name: z.string().min(1) });
+  const extended = schema.safeExtend({ name: z.string().min(2) });
+  expect(() => extended.parse({ name: "" })).toThrow();
+  expect(extended.parse({ name: "ab" })).toEqual({ name: "ab" });
+  type Extended = z.infer<typeof extended>;
+  expectTypeOf<Extended>().toEqualTypeOf<{ name: string }>();
+  // @ts-expect-error
+  schema.safeExtend({ name: z.number() });
+});
+
 test("passthrough index signature", () => {
   const a = z.object({ a: z.string() });
   type a = z.infer<typeof a>;
@@ -576,3 +587,23 @@ test("index signature in shape", () => {
 
   expectTypeOf<schema>().toEqualTypeOf<Record<string, string>>();
 });
+
+test("extent() on object with refinements should throw", () => {
+  const schema = z
+    .object({
+      a: z.string(),
+    })
+    .refine(() => true);
+
+  expect(() => schema.extend({ b: z.string() })).toThrow();
+});
+
+test("safeExtend() on object with refinements should not throw", () => {
+  const schema = z
+    .object({
+      a: z.string(),
+    })
+    .refine(() => true);
+
+  expect(() => schema.safeExtend({ b: z.string() })).not.toThrow();
+});

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

@@ -45,11 +45,6 @@ test("continue on non-fatal errors", () => {
         "code": "custom",
         "path": [],
         "message": "A"
-      },
-      {
-        "code": "custom",
-        "path": [],
-        "message": "B"
       }
     ]],
       "success": false,
@@ -79,3 +74,28 @@ test("break on fatal errors", () => {
     }
   `);
 });
+
+test("reverse parsing with pipe", () => {
+  const schema = z.string().pipe(z.string());
+
+  // Reverse direction: default should NOT be applied
+  expect(z.safeDecode(schema, "asdf")).toMatchInlineSnapshot(`
+    {
+      "data": "asdf",
+      "success": true,
+    }
+  `);
+  expect(z.safeEncode(schema, "asdf")).toMatchInlineSnapshot(`
+    {
+      "data": "asdf",
+      "success": true,
+    }
+  `);
+});
+
+test("reverse parsing with pipe", () => {
+  const schema = z.string().transform((val) => val.length);
+
+  // should throw
+  expect(() => z.encode(schema, 1234)).toThrow();
+});

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

@@ -47,3 +47,28 @@ test("object schema with prefault should return shallow clone", () => {
   expect(result1).not.toBe(result2);
   expect(result1).toEqual(result2);
 });
+
+test("direction-aware prefault", () => {
+  const schema = z.string().prefault("hello");
+
+  // Forward direction (regular parse): prefault should be applied
+  expect(schema.parse(undefined)).toBe("hello");
+
+  // Reverse direction (encode): prefault should NOT be applied, undefined should fail validation
+  expect(z.safeEncode(schema, undefined as any)).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  // But valid values should still work in reverse
+  expect(z.encode(schema, "world")).toBe("world");
+});

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

@@ -269,14 +269,9 @@ test("perform transform with non-fatal issues", () => {
     .transform((val) => val.length)
     .pipe(z.number())
     .refine((_) => false);
-  expect(A.safeParse("asdfasdf").error!.issues).toHaveLength(2);
+  expect(A.safeParse("asdfasdf").error!.issues).toHaveLength(1);
   expect(A.safeParse("asdfasdf").error).toMatchInlineSnapshot(`
     [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      },
       {
         "code": "custom",
         "path": [],

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

@@ -167,8 +167,8 @@ describe("early termination options", () => {
 });
 
 describe("custom error paths", () => {
-  test("should use custom path in error message", async () => {
-    const result = await z
+  test("should use custom path in error message", () => {
+    const result = z
       .object({ password: z.string(), confirm: z.string() })
       .refine((data) => data.confirm === data.password, { path: ["confirm"] })
       .safeParse({ password: "asdf", confirm: "qewr" });
@@ -252,6 +252,79 @@ describe("superRefine functionality", () => {
     await expect(Strings.parseAsync(validArray)).resolves.toEqual(validArray);
   });
 
+  test("should test continuability of custom issues", () => {
+    // Default continue behavior - allows subsequent refinements
+    const defaultContinue = z
+      .string()
+      .superRefine((_, ctx) => {
+        ctx.addIssue({ code: "custom", message: "First issue" });
+      })
+      .refine(() => false, "Second issue");
+
+    expect(defaultContinue.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First issue",
+          "path": []
+        },
+        {
+          "code": "custom",
+          "path": [],
+          "message": "Second issue"
+        }
+      ]],
+        "success": false,
+      }
+    `);
+
+    // Explicit continue: false - prevents subsequent refinements
+    const explicitContinueFalse = z
+      .string()
+      .superRefine((_, ctx) => {
+        ctx.addIssue({ code: "custom", message: "First issue", continue: false });
+      })
+      .refine(() => false, "Second issue");
+
+    expect(explicitContinueFalse.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First issue",
+          "path": []
+        }
+      ]],
+        "success": false,
+      }
+    `);
+
+    // Multiple issues in same refinement - both always added regardless of continue
+    const multipleInSame = z.string().superRefine((_, ctx) => {
+      ctx.addIssue({ code: "custom", message: "First", continue: false });
+      ctx.addIssue({ code: "custom", message: "Second" });
+    });
+
+    expect(multipleInSame.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First",
+          "path": []
+        },
+        {
+          "code": "custom",
+          "message": "Second",
+          "path": []
+        }
+      ]],
+        "success": false,
+      }
+    `);
+  });
+
   test("should accept string as shorthand for custom error message", () => {
     const schema = z.string().superRefine((_, ctx) => {
       ctx.addIssue("bad stuff");
@@ -431,9 +504,9 @@ test("when", () => {
     })
     .refine(
       (data) => {
-        console.log("running check...");
-        console.log(data);
-        console.log(data.password);
+        // console.log("running check...");
+        // console.log(data);
+        // console.log(data.password);
         return data.password === data.confirmPassword;
       },
       {

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

@@ -39,7 +39,7 @@ test("valid parse async", async () => {
   expect(result.data!.has("second")).toEqual(true);
   expect(result.data!.has("third")).toEqual(false);
 
-  const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
+  const asyncResult = stringSet.safeParse(new Set(["first", "second"]));
   expect(asyncResult.success).toEqual(true);
   expect(asyncResult.data!.has("first")).toEqual(true);
   expect(asyncResult.data!.has("second")).toEqual(true);

package/src/v4/classic/tests/string-formats.test.ts

@@ -107,3 +107,19 @@ test("z.stringFormat", () => {
     `/\\^\\(\\?:\\\\d\\{14,19\\}\\|\\\\d\\{4\\}\\(\\?: \\\\d\\{3,6\\}\\)\\{2,4\\}\\|\\\\d\\{4\\}\\(\\?:-\\\\d\\{3,6\\}\\)\\{2,4\\}\\)\\$/u`
   );
 });
+
+test("z.hex", () => {
+  const hexSchema = z.hex();
+
+  // Valid hex strings
+  expect(hexSchema.safeParse("").success).toBe(true); // Empty string is valid hex
+  expect(hexSchema.safeParse("123abc").success).toBe(true);
+  expect(hexSchema.safeParse("DEADBEEF").success).toBe(true);
+  expect(hexSchema.safeParse("0123456789abcdefABCDEF").success).toBe(true);
+
+  // Invalid hex strings
+  expect(hexSchema.safeParse("xyz").success).toBe(false);
+  expect(hexSchema.safeParse("123g").success).toBe(false);
+  expect(hexSchema.safeParse("hello world").success).toBe(false);
+  expect(hexSchema.safeParse("123-abc").success).toBe(false);
+});

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

@@ -527,6 +527,7 @@ test("good uuid", () => {
     "9491d710-3185-5e06-8ea0-6a2f275345e0",
     "9491d710-3185-5e06-9ea0-6a2f275345e0",
     "00000000-0000-0000-0000-000000000000",
+    "ffffffff-ffff-ffff-ffff-ffffffffffff",
   ];
 
   for (const goodUuid of goodUuids) {
@@ -545,7 +546,6 @@ test(`bad uuid`, () => {
     "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
     "invalid uuid",
     "9491d710-3185-4e06-bea0-6a2f275345e0X",
-    "ffffffff-ffff-ffff-ffff-ffffffffffff",
   ]) {
     const result = uuid.safeParse(badUuid);
     expect(result).toMatchObject({ success: false });
@@ -994,3 +994,84 @@ test("hostname", () => {
   expect(() => hostname.parse("-example.com")).toThrow();
   expect(() => hostname.parse("example..com")).toThrow();
 });
+
+test("hash validation", () => {
+  // MD5 tests
+  const md5hex = z.hash("md5");
+  const md5base64 = z.hash("md5", { enc: "base64" });
+  const md5base64url = z.hash("md5", { enc: "base64url" });
+
+  // Valid MD5 hashes
+  expect(md5hex.parse("5d41402abc4b2a76b9719d911017c592")).toBe("5d41402abc4b2a76b9719d911017c592");
+  expect(md5hex.parse("5D41402ABC4B2A76B9719D911017C592")).toBe("5D41402ABC4B2A76B9719D911017C592"); // uppercase
+  expect(md5base64.parse("XUFAKrxLKna5cZ2REBfFkg==")).toBe("XUFAKrxLKna5cZ2REBfFkg==");
+  expect(md5base64url.parse("XUFAKrxLKna5cZ2REBfFkg")).toBe("XUFAKrxLKna5cZ2REBfFkg");
+
+  // Invalid MD5 hashes
+  expect(() => md5hex.parse("5d41402abc4b2a76b9719d911017c59")).toThrow(); // too short
+  expect(() => md5hex.parse("5d41402abc4b2a76b9719d911017c592x")).toThrow(); // too long
+  expect(() => md5base64.parse("XUFAKrxLKna5cZ2REBfFkg=")).toThrow(); // wrong padding
+  expect(() => md5base64url.parse("XUFAKrxLKna5cZ2REBfFkg=")).toThrow(); // has padding
+
+  // SHA1 tests
+  const sha1hex = z.hash("sha1");
+  const sha1base64 = z.hash("sha1", { enc: "base64" });
+  const sha1base64url = z.hash("sha1", { enc: "base64url" });
+
+  // Valid SHA1 hashes
+  expect(sha1hex.parse("aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d")).toBe("aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d");
+  expect(sha1base64.parse("qvTGHdzF6KLavt4PO0gs2a6pQ00=")).toBe("qvTGHdzF6KLavt4PO0gs2a6pQ00=");
+  expect(sha1base64url.parse("qvTGHdzF6KLavt4PO0gs2a6pQ00")).toBe("qvTGHdzF6KLavt4PO0gs2a6pQ00");
+
+  // SHA256 tests
+  const sha256hex = z.hash("sha256");
+  const sha256base64 = z.hash("sha256", { enc: "base64" });
+  const sha256base64url = z.hash("sha256", { enc: "base64url" });
+
+  // Valid SHA256 hashes
+  expect(sha256hex.parse("2cf24dba4f21d4288094c4a2e2c2d6c6b0c3e0c8f0e0c8f0e0c8f0e0c8f0e0c8")).toBe(
+    "2cf24dba4f21d4288094c4a2e2c2d6c6b0c3e0c8f0e0c8f0e0c8f0e0c8f0e0c8"
+  );
+  expect(sha256base64.parse("LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=")).toBe(
+    "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ="
+  );
+  expect(sha256base64url.parse("LPJNul-wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ")).toBe(
+    "LPJNul-wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ"
+  );
+
+  // SHA384 tests (no padding in base64)
+  const sha384hex = z.hash("sha384");
+  const sha384base64 = z.hash("sha384", { enc: "base64" });
+
+  expect(
+    sha384hex.parse("59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c3553bcdb9c666fa90125a3c79f90397bdf5f6a13de828684f")
+  ).toBe("59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c3553bcdb9c666fa90125a3c79f90397bdf5f6a13de828684f");
+  expect(sha384base64.parse("WeF0h3dEjGneawDXozO7+5/xtGPkQ1TDVTvNucZm+pASWjx5+QOXvfX2oT3oKGhP")).toBe(
+    "WeF0h3dEjGneawDXozO7+5/xtGPkQ1TDVTvNucZm+pASWjx5+QOXvfX2oT3oKGhP"
+  );
+
+  // SHA512 tests
+  const sha512hex = z.hash("sha512");
+  const sha512base64 = z.hash("sha512", { enc: "base64" });
+
+  expect(
+    sha512hex.parse(
+      "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043"
+    )
+  ).toBe(
+    "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043"
+  );
+  expect(
+    sha512base64.parse("m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==")
+  ).toBe("m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==");
+
+  // Test default encoding (hex)
+  const defaultHash = z.hash("sha256");
+  expect(defaultHash.parse("2cf24dba4f21d4288094c4a2e2c2d6c6b0c3e0c8f0e0c8f0e0c8f0e0c8f0e0c8")).toBe(
+    "2cf24dba4f21d4288094c4a2e2c2d6c6b0c3e0c8f0e0c8f0e0c8f0e0c8f0e0c8"
+  );
+
+  // Test with custom error message
+  const hashWithMessage = z.hash("md5", { message: "Invalid MD5 hash" });
+  expect(() => hashWithMessage.parse("invalid")).toThrow("Invalid MD5 hash");
+});

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

@@ -64,3 +64,43 @@ test("z.stringbool with custom error messages", () => {
 
   expect(() => a.parse("")).toThrowError("wrong!");
 });
+
+test("z.stringbool codec encoding", () => {
+  const schema = z.stringbool();
+
+  // Test encoding with default values
+  expect(z.encode(schema, true)).toEqual("true");
+  expect(z.encode(schema, false)).toEqual("false");
+});
+
+test("z.stringbool codec encoding with custom values", () => {
+  const schema = z.stringbool({
+    truthy: ["yes", "on", "1"],
+    falsy: ["no", "off", "0"],
+  });
+
+  // Should return first element of custom arrays
+  expect(z.encode(schema, true)).toEqual("yes");
+  expect(z.encode(schema, false)).toEqual("no");
+});
+
+test("z.stringbool codec round trip", () => {
+  const schema = z.stringbool({
+    truthy: ["enabled", "active"],
+    falsy: ["disabled", "inactive"],
+  });
+
+  // Test round trip: string -> boolean -> string
+  const decoded = z.decode(schema, "enabled");
+  expect(decoded).toEqual(true);
+
+  const encoded = z.encode(schema, decoded);
+  expect(encoded).toEqual("enabled"); // First element of truthy array
+
+  // Test with falsy value
+  const decodedFalse = z.decode(schema, "inactive");
+  expect(decodedFalse).toEqual(false);
+
+  const encodedFalse = z.encode(schema, decodedFalse);
+  expect(encodedFalse).toEqual("disabled"); // First element of falsy array
+});

package/src/v4/classic/tests/template-literal.test.ts

@@ -570,7 +570,7 @@ test("regexes", () => {
   );
   expect(ulid._zod.pattern.source).toMatchInlineSnapshot(`"^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$"`);
   expect(uuid._zod.pattern.source).toMatchInlineSnapshot(
-    `"^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$"`
+    `"^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"`
   );
   expect(stringAToZ._zod.pattern.source).toMatchInlineSnapshot(`"^[a-z]+$"`);
   expect(stringStartsWith._zod.pattern.source).toMatchInlineSnapshot(`"^hello.*$"`);

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -109,7 +109,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "uuid",
-        "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$",
+        "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
         "type": "string",
       }
     `);
@@ -269,7 +269,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "uuid",
-        "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$",
+        "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
         "type": "string",
       }
     `);
@@ -552,6 +552,25 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("nullable openapi", () => {
+    expect(z.toJSONSchema(z.string().nullable(), { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+      {
+        "nullable": true,
+        "type": "string",
+      }
+    `);
+  });
+
+  test("union with null openapi", () => {
+    const schema = z.union([z.string(), z.null()]);
+    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+      {
+        "nullable": true,
+        "type": "string",
+      }
+    `);
+  });
+
   test("arrays", () => {
     expect(z.toJSONSchema(z.array(z.string()))).toMatchInlineSnapshot(`
       {

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

@@ -352,3 +352,10 @@ test("do not continue by default", () => {
     }
   `);
 });
+
+test("encode error", () => {
+  const schema = z.string().transform((val) => val.length);
+  expect(() => z.encode(schema, 1234)).toThrowErrorMatchingInlineSnapshot(
+    `[ZodEncodeError: Encountered unidirectional transform during encode: ZodTransform]`
+  );
+});

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

@@ -157,7 +157,7 @@ test("surface continuable errors only if they exist", () => {
               "origin": "string",
               "code": "invalid_format",
               "format": "uuid",
-              "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/",
+              "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/",
               "path": [],
               "message": "Invalid UUID"
             }