@openclaw/diffs 2026.9.4 → 2026.9.6

package/node_modules/zod/src/v4/classic/tests/optin-ladder.test.ts

@@ -0,0 +1,235 @@
+import { expect, expectTypeOf, test } from "vitest";
+import { z } from "zod/v4";
+
+/* ------------------------------------------------------------------ *
+ * TYPE-LEVEL — the dangerous half. Defaults must stay OPTIONAL in
+ * z.input and REQUIRED in z.output, exactly as before the ladder.
+ * ------------------------------------------------------------------ */
+test("ladder: z.input / z.output unchanged by the extra rung", () => {
+  const objDefault = z.object({ a: z.string().default("D"), b: z.number() });
+  expectTypeOf<z.input<typeof objDefault>>().toEqualTypeOf<{ a?: string | undefined; b: number }>();
+  expectTypeOf<z.output<typeof objDefault>>().toEqualTypeOf<{ a: string; b: number }>();
+
+  const objPrefault = z.object({ a: z.string().prefault("P"), b: z.number() });
+  expectTypeOf<z.input<typeof objPrefault>>().toEqualTypeOf<{ a?: string | undefined; b: number }>();
+  expectTypeOf<z.output<typeof objPrefault>>().toEqualTypeOf<{ a: string; b: number }>();
+
+  const objOptional = z.object({ a: z.string().optional() });
+  expectTypeOf<z.input<typeof objOptional>>().toEqualTypeOf<{ a?: string | undefined }>();
+
+  const objTransform = z.object({
+    a: z
+      .string()
+      .default("")
+      .transform((v) => v.length),
+  });
+  expectTypeOf<z.input<typeof objTransform>>().toEqualTypeOf<{ a?: string | undefined }>();
+  expectTypeOf<z.output<typeof objTransform>>().toEqualTypeOf<{ a: number }>();
+
+  const standalone = z.string().default("D");
+  expectTypeOf<z.input<typeof standalone>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.output<typeof standalone>>().toEqualTypeOf<string>();
+
+  // a trailing defaulted tuple slot stays optional in the input tuple
+  const tup = z.tuple([z.string(), z.number().default(1)]);
+  expectTypeOf<z.input<typeof tup>>().toEqualTypeOf<[string, (number | undefined)?]>();
+
+  const partialed = objDefault.partial();
+  expectTypeOf<z.input<typeof partialed>>().toEqualTypeOf<{ a?: string | undefined; b?: number | undefined }>();
+});
+
+/* ------------------------------------------------------------------ *
+ * RUNTIME
+ * ------------------------------------------------------------------ */
+test("ladder: the #6321 regression is fixed", () => {
+  const arr = z
+    .string()
+    .default("")
+    .transform((v) => (v ? v.split(",") : []));
+  expect(z.object({ a: arr }).partial().parse({})).toEqual({ a: [] });
+  expect(z.object({ a: arr }).partial().parse({ a: undefined })).toEqual({ a: [] });
+  expect(z.object({ a: arr }).partial().parse({ a: "x,y" })).toEqual({ a: ["x", "y"] });
+  expect(arr.optional().parse(undefined)).toEqual([]);
+  expect(
+    z
+      .string()
+      .prefault("hi")
+      .transform((v) => v.length)
+      .optional()
+      .parse(undefined)
+  ).toBe(2);
+});
+
+test("ladder: key-level admissibility across every rung", () => {
+  expect(z.object({ a: z.string().default("D") }).parse({})).toEqual({ a: "D" });
+  expect(z.object({ a: z.string().prefault("P") }).parse({})).toEqual({ a: "P" });
+  expect(z.object({ a: z.string().optional() }).parse({})).toEqual({});
+  expect(z.object({ a: z.transform(() => "T") }).parse({})).toEqual({ a: "T" });
+  expect(z.object({ a: z.string().catch("C") }).parse({})).toEqual({ a: "C" });
+  expect(z.object({ a: z.string() }).safeParse({}).success).toBe(false);
+});
+
+test("ladder: exactOptional keeps its distinct meaning", () => {
+  expect(z.object({ a: z.string().exactOptional() }).parse({})).toEqual({});
+  expect(z.object({ a: z.string().exactOptional() }).safeParse({ a: undefined }).success).toBe(false);
+});
+
+// An absent key never materializes a value from a schema that only claims the middle rung, however that schema answers `undefined`. The top rung still substitutes, and an explicitly present `undefined` still runs the inner.
+test.each([true, false])("ladder: an absent key stays absent on the middle rung (jitless=%s)", (jitless) => {
+  const opts = { jitless };
+  expect(z.object({ a: z.coerce.string().exactOptional() }).parse({}, opts)).toStrictEqual({});
+  expect(z.object({ a: z.string().catch("C").exactOptional() }).parse({}, opts)).toStrictEqual({});
+  expect(z.object({ a: z.preprocess((v) => v ?? "X", z.string()).exactOptional() }).parse({}, opts)).toStrictEqual({});
+  expect(z.object({ a: z.union([z.coerce.string(), z.string().optional()]) }).parse({}, opts)).toStrictEqual({});
+
+  expect(z.object({ a: z.string().default("D").exactOptional() }).parse({}, opts)).toStrictEqual({ a: "D" });
+  expect(z.object({ a: z.string().prefault("P").exactOptional() }).parse({}, opts)).toStrictEqual({ a: "P" });
+  expect(z.object({ a: z.coerce.string().exactOptional() }).parse({ a: undefined }, opts)).toStrictEqual({
+    a: "undefined",
+  });
+  expect(z.object({ a: z.coerce.string() }).parse({ a: undefined }, opts)).toStrictEqual({ a: "undefined" });
+});
+
+test("ladder: an absent tuple slot on the middle rung truncates the tail", () => {
+  expect(z.tuple([z.string(), z.coerce.string().exactOptional()]).parse(["x"])).toStrictEqual(["x"]);
+  expect(z.tuple([z.string(), z.string().catch("C").exactOptional()]).parse(["x"])).toStrictEqual(["x"]);
+  expect(z.tuple([z.string(), z.string().default("D").exactOptional()]).parse(["x"])).toStrictEqual(["x", "D"]);
+});
+
+// z.compile() assembles its own output, so the gate has to be mirrored there or compile mode silently keeps the invented value.
+test("ladder: compile mode agrees with the interpreted and JIT paths on absent middle-rung slots", () => {
+  const objects = [
+    [z.object({ a: z.coerce.string().exactOptional() }), {}],
+    [z.object({ a: z.string().catch("C").exactOptional() }), {}],
+    [z.object({ a: z.string().default("D").exactOptional() }), { a: "D" }],
+    [z.object({ a: z.string().catch("C") }), { a: "C" }],
+  ] as const;
+  for (const [schema, expected] of objects) {
+    expect(z.compile(schema).parse({})).toStrictEqual(expected);
+    expect(schema.parse({}, { jitless: true })).toStrictEqual(expected);
+    expect(schema.parse({})).toStrictEqual(expected);
+  }
+
+  const tuples = [
+    [z.tuple([z.string(), z.coerce.string().exactOptional()]), ["x"]],
+    [z.tuple([z.string(), z.string().default("D").exactOptional()]), ["x", "D"]],
+  ] as const;
+  for (const [schema, expected] of tuples) {
+    expect(z.compile(schema).parse(["x"])).toStrictEqual(expected);
+    expect(schema.parse(["x"], { jitless: true })).toStrictEqual(expected);
+  }
+});
+
+test("ladder: tuple minimum length respects every rung", () => {
+  expect(z.tuple([z.string().default("D")]).parse([])).toEqual(["D"]);
+  expect(z.tuple([z.string().prefault("P")]).parse([])).toEqual(["P"]);
+  expect(z.tuple([z.string().optional()]).parse([])).toEqual([]);
+  expect(z.tuple([z.string()]).safeParse([]).success).toBe(false);
+  expect(z.tuple([z.string(), z.number().default(1)]).parse(["x"])).toEqual(["x", 1]);
+});
+
+test("ladder: the #5941 / #5939 clobber invariants still hold", () => {
+  expect(
+    z
+      .preprocess((v) => v ?? "X", z.string())
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(z.string().catch("X").optional().parse(undefined)).toBeUndefined();
+  expect(
+    z
+      .string()
+      .catch("X")
+      .transform((s) => `${s}!`)
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(
+    z
+      .transform(() => "T")
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(
+    z
+      .union([z.preprocess((v) => v ?? "X", z.string()), z.number()])
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(z.object({ a: z.preprocess((v) => v ?? "X", z.string()) }).parse({})).toEqual({ a: "X" });
+});
+
+test("ladder: the top rung survives every wrapper order", () => {
+  expect(z.string().default("D").optional().parse(undefined)).toBe("D");
+  expect(z.string().default("D").optional().optional().parse(undefined)).toBe("D");
+  expect(z.string().default("D").nullable().optional().parse(undefined)).toBe("D");
+  expect(z.string().default("D").readonly().optional().parse(undefined)).toBe("D");
+  expect(z.string().default("D").catch("C").optional().parse(undefined)).toBe("D");
+  expect(z.string().default("D").pipe(z.string()).optional().parse(undefined)).toBe("D");
+  expect(
+    z
+      .union([z.string().default("D"), z.number()])
+      .optional()
+      .parse(undefined)
+  ).toBe("D");
+  expect(
+    z
+      .lazy(() => z.string().default("D"))
+      .optional()
+      .parse(undefined)
+  ).toBe("D");
+});
+
+test("ladder: record and catchall paths that read optin", () => {
+  expect(z.record(z.string(), z.string().default("D")).parse({ k: undefined })).toEqual({ k: "D" });
+  expect(z.object({}).catchall(z.string().default("D")).parse({ x: undefined })).toEqual({ x: "D" });
+});
+
+test("ladder: async parity", async () => {
+  const a = z
+    .string()
+    .default("")
+    .transform(async (v) => (v ? v.split(",") : []));
+  expect((await a.optional().safeParseAsync(undefined)).data).toEqual([]);
+  expect((await z.object({ a }).partial().safeParseAsync({})).data).toEqual({ a: [] });
+  expect(
+    (
+      await z
+        .preprocess(async (v) => v ?? "X", z.string())
+        .optional()
+        .safeParseAsync(undefined)
+    ).data
+  ).toBeUndefined();
+});
+
+test("ladder: the rung values themselves", () => {
+  expect(z.string()._zod.optin).toBeUndefined();
+  expect(z.string().optional()._zod.optin).toBe("optional");
+  expect(z.transform(() => 1)._zod.optin).toBe("optional");
+  expect(z.string().catch("C")._zod.optin).toBe("optional");
+  expect(z.string().default("D")._zod.optin).toBe("defaulted");
+  expect(z.string().prefault("P")._zod.optin).toBe("defaulted");
+  expect(
+    z
+      .string()
+      .default("D")
+      .transform((v) => v)._zod.optin
+  ).toBe("defaulted");
+  expect(z.string().default("D").optional()._zod.optin).toBe("defaulted");
+  expect(z.union([z.string().default("D"), z.number()])._zod.optin).toBe("defaulted");
+  expect(z.union([z.string().optional(), z.number()])._zod.optin).toBe("optional");
+});
+
+test("exactOptional overrides the values and pattern optional installs", () => {
+  expect(z.exactOptional(z.enum(["a", "b"]))._zod.values).toEqual(new Set(["a", "b"]));
+  // a format carries its pattern on its def; a chained `.regex()` no longer folds into the inner `_zod.pattern`, the template literal derives that itself
+  expect(z.exactOptional(z.stringFormat("abc", /^abc$/))._zod.pattern).toEqual(/^abc$/);
+  expect(z.templateLiteral(["a", z.exactOptional(z.literal("b"))]).safeParse("a").success).toEqual(false);
+});
+
+// The override is installed once, on a prototype every instance of the type shares, so it has to hold for instances built after the first.
+test("exactOptional's override holds for later instances", () => {
+  z.exactOptional(z.enum(["a", "b"]));
+  expect(z.exactOptional(z.enum(["c", "d"]))._zod.values).toEqual(new Set(["c", "d"]));
+  expect(z.exactOptional(z.stringFormat("xyz", /^xyz$/))._zod.pattern).toEqual(/^xyz$/);
+});

package/node_modules/zod/src/v4/classic/tests/optional.test.ts

@@ -27,7 +27,7 @@ test("optionality", () => {
   expect(b._zod.optout).toEqual("optional");
 
   const c = z.string().default("asdf");
-  expect(c._zod.optin).toEqual("optional");
+  expect(c._zod.optin).toEqual("defaulted");
   expect(c._zod.optout).toEqual(undefined);
 
   const d = z.string().optional().nullable();
@@ -35,27 +35,27 @@ test("optionality", () => {
   expect(d._zod.optout).toEqual("optional");
 
   const e = z.string().default("asdf").nullable();
-  expect(e._zod.optin).toEqual("optional");
+  expect(e._zod.optin).toEqual("defaulted");
   expect(e._zod.optout).toEqual(undefined);
 
   // z.undefined should NOT be optional
   const f = z.undefined();
   expect(f._zod.optin).toEqual(undefined);
   expect(f._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
   expectTypeOf<typeof f._zod.optout>().toEqualTypeOf<"optional" | undefined>();
 
   // z.union should be optional if any of the types are optional
   const g = z.union([z.string(), z.undefined()]);
   expect(g._zod.optin).toEqual(undefined);
   expect(g._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
   expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();
 
   const h = z.union([z.string(), z.optional(z.string())]);
   expect(h._zod.optin).toEqual("optional");
   expect(h._zod.optout).toEqual("optional");
-  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional">();
+  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
   expectTypeOf<typeof h._zod.optout>().toEqualTypeOf<"optional">();
 });
 
@@ -64,7 +64,7 @@ test("pipe optionality", () => {
   const a = z.string().optional().pipe(z.string());
   expect(a._zod.optin).toEqual("optional");
   expect(a._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional">();
+  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
   expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional" | undefined>();
 
   const b = z
@@ -73,11 +73,11 @@ test("pipe optionality", () => {
     .pipe(z.string().optional());
   expect(b._zod.optin).toEqual(undefined);
   expect(b._zod.optout).toEqual("optional");
-  expectTypeOf<typeof b._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof b._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
   expectTypeOf<typeof b._zod.optout>().toEqualTypeOf<"optional">();
 
   const c = z.string().default("asdf").pipe(z.string());
-  expect(c._zod.optin).toEqual("optional");
+  expect(c._zod.optin).toEqual("defaulted");
   expect(c._zod.optout).toEqual(undefined);
 
   const d = z
@@ -202,7 +202,7 @@ test("exactOptional optionality", () => {
   const a = z.string().exactOptional();
   expect(a._zod.optin).toEqual("optional");
   expect(a._zod.optout).toEqual("optional");
-  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional">();
+  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
   expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional">();
 });
 
@@ -268,10 +268,7 @@ test("exactOptional vs optional comparison", () => {
   expect(exactOptionalSchema.safeParse({ a: undefined }).success).toEqual(false);
 });
 
-// Defensive inference coverage: every schema that propagates `optout` participates
-// in object-key optionality inference. If anyone ever changes the set of values that
-// `optout` can take (or how OptionalOutSchema matches them), these assertions must
-// continue to hold or downstream `z.infer<typeof obj>` types silently flip required keys.
+// Defensive inference coverage: every schema that propagates `optout` participates in object-key optionality inference. If anyone ever changes the set of values that `optout` can take (or how OptionalOutSchema matches them), these assertions must continue to hold or downstream `z.infer<typeof obj>` types silently flip required keys.
 test("object key optionality through optout propagation", () => {
   const direct = z.object({ k: z.string().optional() });
   expectTypeOf<z.infer<typeof direct>>().toEqualTypeOf<{ k?: string | undefined }>();
@@ -317,9 +314,7 @@ test("object key optionality through optout propagation", () => {
   }>();
 });
 
-// Defensive: tuple optional-tail inference also reads optout. The PR that introduced
-// `"includeUndefined"` had to update TupleOutputTypeWithOptionals; pin the result so
-// any future flag change has to keep this contract.
+// Defensive: tuple optional-tail inference also reads optout. The PR that introduced `"includeUndefined"` had to update TupleOutputTypeWithOptionals; pin the result so any future flag change has to keep this contract.
 test("tuple tail optionality through optout propagation", () => {
   const trailingOptional = z.tuple([z.string(), z.number().optional()]);
   expectTypeOf<z.output<typeof trailingOptional>>().toEqualTypeOf<[string, (number | undefined)?]>();
@@ -331,3 +326,41 @@ test("tuple tail optionality through optout propagation", () => {
   const interiorOptional = z.tuple([z.string(), z.number().optional(), z.string()]);
   expectTypeOf<z.output<typeof interiorOptional>>().toEqualTypeOf<[string, number | undefined, string]>();
 });
+
+// An absent optional key whose check fails has its issue swallowed; the value the check wrote must go with it, on the JIT fastpass as well as the interpreted path.
+test("swallowed issue on an absent optional key drops its value", async () => {
+  const schema = z.object({
+    a: z
+      .string()
+      .optional()
+      .superRefine((_v, ctx) => {
+        ctx.addIssue({ code: "custom", message: "bad" });
+        ctx.value = "leaked";
+      }),
+  });
+
+  for (const result of [
+    schema.safeParse({}),
+    schema.safeParse({}, { jitless: true }),
+    await schema.safeParseAsync({}),
+  ]) {
+    expect(result.success).toEqual(true);
+    expect("a" in result.data!).toEqual(false);
+  }
+
+  // A present key keeps both the issue and its value.
+  expect(schema.safeParse({ a: "x" }).success).toEqual(false);
+  expect(schema.safeParse({ a: "x" }, { jitless: true }).success).toEqual(false);
+});
+
+test("optional does not swallow an issue it did not cause", () => {
+  // A pipe hands its `out` schema the caller's issues array so an unrecognized key can survive to an enclosing intersection. A defaulted inner substituting for absence must not read that as its own failing and drop it.
+  const result = z
+    .strictObject({ a: z.string() })
+    .transform((): number | undefined => undefined)
+    .pipe(z.number().default(5).optional())
+    .safeParse({ a: "x", extra: 1 });
+
+  expect(result.success).toBe(false);
+  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
+});

package/node_modules/zod/src/v4/classic/tests/partial.test.ts

@@ -156,10 +156,7 @@ test("catch/prefault/default", () => {
     f: z.string().prefault("prefault value"),
   });
 
-  // Catch (d) and default/prefault (b, c, e, f) handle absent keys gracefully.
-  // `a: catch().optional()` short-circuits to undefined when the original
-  // input was undefined, so the property is omitted from the output. All
-  // other catch/default/prefault keys produce their fallback values.
+  // Catch (d) and default/prefault (b, c, e, f) handle absent keys gracefully. `a: catch().optional()` short-circuits to undefined when the original input was undefined, so the property is omitted from the output. All other catch/default/prefault keys produce their fallback values.
   expect(mySchema.parse({})).toMatchInlineSnapshot(`
     {
       "b": "default value",
@@ -448,3 +445,53 @@ test("required - refinement is executed on required schema", () => {
   const validResult = requiredSchema.safeParse({ password: "abc", confirmPassword: "abc" });
   expect(validResult.success).toBe(true);
 });
+
+test("exactPartial - shallow inference", () => {
+  const shallow = nested.exactPartial();
+  type shallow = z.infer<typeof shallow>;
+  expectTypeOf<shallow>().toEqualTypeOf<{
+    name?: string;
+    age?: number;
+    outer?: { inner: string };
+    array?: { asdf: string }[];
+  }>();
+
+  // The point of exactPartial: unlike partial(), this matches TypeScript's Partial<> under exactOptionalPropertyTypes.
+  expectTypeOf<shallow>().toEqualTypeOf<Partial<z.infer<typeof nested>>>();
+});
+
+test("exactPartial - wraps fields in ZodExactOptional", () => {
+  const object = z.object({ name: z.string(), age: z.number() });
+  const exact = object.exactPartial();
+  expect(exact.shape.name).toBeInstanceOf(z.ZodExactOptional);
+  expect(exact.shape.age).toBeInstanceOf(z.ZodExactOptional);
+  expect(exact.shape.name.unwrap()).toBeInstanceOf(z.ZodString);
+});
+
+test("exactPartial - absent keys pass, explicit undefined rejected", () => {
+  const exact = z.object({ name: z.string(), age: z.number() }).exactPartial();
+  expect(exact.parse({})).toEqual({});
+  expect(exact.parse({ name: "asdf" })).toEqual({ name: "asdf" });
+  expect(exact.safeParse({ name: undefined }).success).toBe(false);
+});
+
+test("exactPartial with mask", () => {
+  const object = z.object({ name: z.string(), age: z.number(), country: z.string() });
+  const masked = object.exactPartial({ name: true, age: true });
+  expect(masked.shape.name).toBeInstanceOf(z.ZodExactOptional);
+  expect(masked.shape.age).toBeInstanceOf(z.ZodExactOptional);
+  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
+
+  type masked = z.infer<typeof masked>;
+  expectTypeOf<masked>().toEqualTypeOf<{ name?: string; age?: number; country: string }>();
+
+  expect(masked.parse({ country: "US" })).toEqual({ country: "US" });
+  expect(masked.safeParse({ country: "US", name: undefined }).success).toBe(false);
+});
+
+test("exactPartial - throws on schema with refinements", () => {
+  const refined = z.object({ name: z.string() }).refine(() => true);
+  expect(() => refined.exactPartial()).toThrow(
+    ".exactPartial() cannot be used on object schemas containing refinements"
+  );
+});

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

@@ -1,6 +1,76 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
 
+test.each([false, true])("undefined prefault preserves object keys (jitless: %s)", async (jitless) => {
+  const previous = z.config().jitless;
+  z.config({ jitless });
+  try {
+    let calls = 0;
+    const field = z.union([z.string(), z.undefined()]).prefault(() => {
+      calls++;
+      return undefined;
+    });
+    const schema = z.object({ a: field });
+    expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+    expectTypeOf<z.input<typeof schema>>().toEqualTypeOf<{ a?: string | undefined }>();
+    expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+    expect(schema.parse({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(1);
+    expect(schema.parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(calls).toBe(2);
+    expect(await schema.parseAsync({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(3);
+    expect(schema.parse({ a: "value" })).toStrictEqual({ a: "value" });
+    expect(schema.safeParse({ a: 123 }).success).toBe(false);
+    expect(calls).toBe(3);
+
+    const literal = z.prefault(z.string().optional(), undefined);
+    expect(z.core.compileFn(z.object({ a: literal }))({})).toStrictEqual({ a: undefined });
+    for (const wrapped of [literal, literal.readonly(), literal.nullable(), z.lazy(() => literal)]) {
+      expect(z.object({ a: wrapped }).parse({})).toStrictEqual({ a: undefined });
+    }
+    expect(z.object({ a: literal.optional() }).parse({})).toStrictEqual({});
+    expect(z.object({ a: literal.optional() }).parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(z.tuple([literal]).parse([])).toStrictEqual([undefined]);
+  } finally {
+    z.config({ jitless: previous });
+  }
+});
+
+test("prefault preserves transformed undefined output", async () => {
+  const field = z
+    .string()
+    .transform(() => undefined)
+    .prefault("fallback");
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<undefined>();
+  expect(field.parse(undefined)).toBeUndefined();
+  const schema = z.object({ a: field, optional: z.string().optional() });
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: undefined; optional?: string | undefined }>();
+  expect(schema.parse({})).toStrictEqual({ a: undefined });
+  expect(z.core.compileFn(schema)({})).toStrictEqual({ a: undefined });
+  expect(z.compile(schema).parse({})).toStrictEqual({ a: undefined });
+  expect(
+    await z
+      .object({
+        a: z
+          .string()
+          .transform(async () => undefined)
+          .prefault("fallback"),
+      })
+      .parseAsync({})
+  ).toStrictEqual({ a: undefined });
+  expect(
+    z
+      .object({
+        a: z
+          .string()
+          .prefault("fallback")
+          .transform(() => undefined),
+      })
+      .parse({})
+  ).toStrictEqual({ a: undefined });
+});
+
 test("basic prefault", () => {
   const a = z.prefault(z.string().trim(), "  default  ");
   expect(a).toBeInstanceOf(z.ZodPrefault);

package/node_modules/zod/src/v4/classic/tests/preprocess-types.test.ts

@@ -11,11 +11,11 @@ test("ZodPreprocess<B> assignable to ZodPipe<$ZodTransform, B>", () => {
 
 test("ZodPreprocess optin/optout defer to B", () => {
   const optionalInside = z.preprocess((v) => v, z.string().optional());
-  expectTypeOf<(typeof optionalInside)["_zod"]["optin"]>().toEqualTypeOf<"optional">();
+  expectTypeOf<(typeof optionalInside)["_zod"]["optin"]>().toEqualTypeOf<"optional" | "defaulted">();
   expectTypeOf<(typeof optionalInside)["_zod"]["optout"]>().toEqualTypeOf<"optional">();
 
   const required = z.preprocess((v) => v, z.string());
-  expectTypeOf<(typeof required)["_zod"]["optin"]>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<(typeof required)["_zod"]["optin"]>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
   expectTypeOf<(typeof required)["_zod"]["optout"]>().toEqualTypeOf<"optional" | undefined>();
 });
 
@@ -24,3 +24,21 @@ test("ZodPreprocess input/output inference", () => {
   expectTypeOf<z.output<typeof pre>>().toEqualTypeOf<number | undefined>();
   expectTypeOf<z.input<typeof pre>>().toEqualTypeOf<unknown>();
 });
+
+test("ZodPreprocess narrows input from an annotated preprocessor arg", () => {
+  const trimmed = z.preprocess((val: string | null | undefined) => val?.trim() ?? "", z.string());
+  expectTypeOf<z.input<typeof trimmed>>().toEqualTypeOf<string | null | undefined>();
+  expectTypeOf<z.output<typeof trimmed>>().toEqualTypeOf<string>();
+
+  const obj = z.object({ a: z.preprocess((v: string | number) => String(v), z.string()) });
+  expectTypeOf<z.input<typeof obj>>().toEqualTypeOf<{ a: string | number }>();
+  expectTypeOf<z.output<typeof obj>>().toEqualTypeOf<{ a: string }>();
+});
+
+// The narrowing must ride on the transform's input only. Binding its output too makes $ZodPipeDef's codec-only `transform?` field contravariant in the preprocessor's return type, which drops the bare-type assignability below.
+test("narrowed ZodPreprocess still assignable to the bare type", () => {
+  const pre = z.preprocess((v: string) => v.length, z.number());
+  const _bare: z.ZodPreprocess<z.ZodNumber> = pre;
+  const _bareCore: z.core.$ZodPreprocess = pre;
+  expectTypeOf<(typeof pre)["_zod"]["optin"]>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
+});