zod 4.1.0-canary.20250821T014930 → 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

@@ -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

@@ -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/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"
             }

package/src/v4/core/api.ts

@@ -1476,7 +1476,7 @@ type RawIssue<T extends errors.$ZodIssueBase> = T extends any
       util.MakePartial<T, "message" | "path"> & {
         /** The schema or check that originated this issue. */
         readonly inst?: schemas.$ZodType | checks.$ZodCheck;
-        /** If `true`, Zod will continue executing checks/refinements after this issue. */
+        /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
         readonly continue?: boolean | undefined;
       } & Record<string, unknown>
     >
@@ -1498,7 +1498,7 @@ export function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void
         _issue.code ??= "custom";
         _issue.input ??= payload.value;
         _issue.inst ??= ch;
-        _issue.continue ??= !ch._zod.def.abort;
+        _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
         payload.issues.push(util.issue(_issue));
       }
     };
@@ -1536,16 +1536,12 @@ export interface $ZodStringBoolParams extends TypeParams {
 
 export function _stringbool(
   Classes: {
-    Pipe?: typeof schemas.$ZodPipe;
+    Codec?: typeof schemas.$ZodCodec;
     Boolean?: typeof schemas.$ZodBoolean;
-    Transform?: typeof schemas.$ZodTransform;
     String?: typeof schemas.$ZodString;
   },
   _params?: string | $ZodStringBoolParams
-): schemas.$ZodPipe<
-  schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>,
-  schemas.$ZodBoolean<boolean>
-> {
+): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean> {
   const params = util.normalizeParams(_params);
 
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -1558,15 +1554,19 @@ export function _stringbool(
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
 
-  const _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
+  const _Codec = Classes.Codec ?? schemas.$ZodCodec;
   const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
   const _String = Classes.String ?? schemas.$ZodString;
-  const _Transform = Classes.Transform ?? schemas.$ZodTransform;
 
-  const tx = new _Transform({
-    type: "transform",
-    transform: (input, payload: schemas.ParsePayload<unknown>) => {
-      let data: string = input as string;
+  const stringSchema = new _String({ type: "string", error: params.error });
+  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
+
+  const codec = new _Codec({
+    type: "pipe",
+    in: stringSchema as any,
+    out: booleanSchema as any,
+    transform: ((input: string, payload: schemas.ParsePayload<string>) => {
+      let data: string = input;
       if (params.case !== "sensitive") data = data.toLowerCase();
       if (truthySet.has(data)) {
         return true;
@@ -1578,33 +1578,23 @@ export function _stringbool(
           expected: "stringbool",
           values: [...truthySet, ...falsySet],
           input: payload.value,
-          inst: tx,
+          inst: codec,
           continue: false,
         });
         return {} as never;
       }
-    },
-    error: params.error,
-  });
-  // params.error;
-
-  const innerPipe = new _Pipe({
-    type: "pipe",
-    in: new _String({ type: "string", error: params.error }),
-    out: tx,
+    }) as any,
+    reverseTransform: ((input: boolean, _payload: schemas.ParsePayload<boolean>) => {
+      if (input === true) {
+        return truthyArray[0] || "true";
+      } else {
+        return falsyArray[0] || "false";
+      }
+    }) as any,
     error: params.error,
-  });
+  }) as any;
 
-  const outerPipe = new _Pipe({
-    type: "pipe",
-    in: innerPipe,
-    out: new _Boolean({
-      type: "boolean",
-      error: params.error,
-    }),
-    error: params.error,
-  });
-  return outerPipe as any;
+  return codec;
 }
 
 export function _stringFormat<Format extends string>(