@vellumai/cli 0.10.6 → 0.10.7-dev.202607072325.09ad030

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/from-json-schema.test.ts

@@ -732,164 +732,3 @@ test("contentEncoding and contentMediaType are stored as metadata", () => {
   expect(meta?.contentEncoding).toBe("base64");
   expect(meta?.contentMediaType).toBe("image/png");
 });
-
-test("description on enum schema is applied", () => {
-  const schema = fromJSONSchema({
-    enum: ["red", "green", "blue"],
-    description: "A color value",
-  });
-  expect(schema.description).toBe("A color value");
-  expect(schema.parse("red")).toBe("red");
-});
-
-test("description on const schema is applied", () => {
-  const schema = fromJSONSchema({
-    const: "hello",
-    description: "A greeting",
-  });
-  expect(schema.description).toBe("A greeting");
-  expect(schema.parse("hello")).toBe("hello");
-});
-
-test("description on not: {} (never) schema is applied", () => {
-  const schema = fromJSONSchema({
-    not: {},
-    description: "A never schema",
-  });
-  expect(schema.description).toBe("A never schema");
-  expect(() => schema.parse("anything")).toThrow();
-});
-
-test("default on enum schema is applied", () => {
-  const schema = fromJSONSchema({
-    enum: ["red", "green", "blue"],
-    default: "red",
-  });
-  expect(schema.parse(undefined)).toBe("red");
-});
-
-test("default on const schema is applied", () => {
-  const schema = fromJSONSchema({
-    const: "hello",
-    default: "hello",
-  });
-  expect(schema.parse(undefined)).toBe("hello");
-});
-
-test("description and default on enum schema are both applied", () => {
-  const schema = fromJSONSchema({
-    enum: ["red", "green", "blue"],
-    description: "A color value",
-    default: "red",
-  });
-  expect(schema.description).toBe("A color value");
-  expect(schema.parse(undefined)).toBe("red");
-  expect(schema.parse("green")).toBe("green");
-});
-
-test("description on type-array schema is applied", () => {
-  const schema = fromJSONSchema({
-    type: ["string", "number"],
-    description: "A string or number",
-  } as any);
-  expect(schema.description).toBe("A string or number");
-  expect(schema.parse("hello")).toBe("hello");
-  expect(schema.parse(42)).toBe(42);
-});
-
-test("default on type-array schema is applied", () => {
-  const schema = fromJSONSchema({
-    type: ["string", "number"],
-    default: "fallback",
-  } as any);
-  expect(schema.parse(undefined)).toBe("fallback");
-  expect(schema.parse("hello")).toBe("hello");
-  expect(schema.parse(42)).toBe(42);
-});
-
-test("description on schema with anyOf is applied to the outer schema", () => {
-  const schema = fromJSONSchema({
-    description: "Either a string or a number",
-    anyOf: [{ type: "string" }, { type: "number" }],
-  });
-  expect(schema.description).toBe("Either a string or a number");
-  expect(schema.parse("hello")).toBe("hello");
-  expect(schema.parse(42)).toBe(42);
-});
-
-test("default on schema with anyOf is applied to the outer schema", () => {
-  const schema = fromJSONSchema({
-    default: "fallback",
-    anyOf: [{ type: "string" }, { type: "number" }],
-  });
-  expect(schema.parse(undefined)).toBe("fallback");
-  expect(schema.parse(42)).toBe(42);
-});
-
-test("description and unrecognized metadata coexist on the same schema", () => {
-  const customRegistry = z.registry<{ "x-custom"?: string; description?: string }>();
-  const schema = fromJSONSchema(
-    {
-      type: "string",
-      description: "A custom string",
-      "x-custom": "value",
-    },
-    { registry: customRegistry }
-  );
-  expect(schema.description).toBe("A custom string");
-  expect(customRegistry.get(schema)?.["x-custom"]).toBe("value");
-});
-
-test("circular input throws a clear error", () => {
-  const person: any = {
-    type: "object",
-    properties: { name: { type: "string" } },
-    required: ["name"],
-  };
-  person.properties.bestFriend = person;
-  expect(() => fromJSONSchema(person)).toThrow(/not valid JSON/);
-});
-
-test("getter-based input that synthesizes a cycle throws", () => {
-  const root: any = { type: "object", properties: { name: { type: "string" } } };
-  Object.defineProperty(root.properties, "self", {
-    enumerable: true,
-    get() {
-      return root;
-    },
-  });
-  expect(() => fromJSONSchema(root)).toThrow(/not valid JSON/);
-});
-
-test("BigInt in input throws", () => {
-  const input: any = { type: "integer", minimum: 1n };
-  expect(() => fromJSONSchema(input)).toThrow(/not valid JSON/);
-});
-
-test("class-instance input is normalized to a plain object", () => {
-  class StringSchema {
-    type = "string" as const;
-    minLength = 2;
-  }
-  const schema = fromJSONSchema(new StringSchema() as any);
-  expect(schema.parse("hi")).toBe("hi");
-  expect(() => schema.parse("h")).toThrow();
-});
-
-test("getter-based properties are materialized", () => {
-  const input: any = { type: "object", properties: {}, required: [] };
-  Object.defineProperty(input.properties, "name", {
-    enumerable: true,
-    get() {
-      return { type: "string" };
-    },
-  });
-  const schema = fromJSONSchema(input);
-  expect(schema.parse({ name: "Alice" })).toEqual({ name: "Alice" });
-});
-
-test("Date default is coerced to its JSON string form", () => {
-  const date = new Date("2026-01-02T03:04:05.000Z");
-  const schema = fromJSONSchema({ type: "string", default: date as any });
-  expect(schema.parse(undefined)).toBe(date.toISOString());
-});

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/function.test.ts

@@ -186,12 +186,12 @@ test("input validation error", () => {
     expect(e.issues).toMatchInlineSnapshot(`
       [
         {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected array to have >=1 items",
-          "minimum": 1,
-          "origin": "array",
-          "path": [],
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received undefined",
+          "path": [
+            0,
+          ],
         },
       ]
     `);

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/index.test.ts

@@ -247,7 +247,7 @@ test("z.tuple", () => {
   const b = z.tuple([z.string(), z.number(), z.optional(z.string())], z.boolean());
   type b = z.output<typeof b>;
 
-  expectTypeOf<b>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
+  expectTypeOf<b>().toEqualTypeOf<[string, number, string?, ...boolean[]]>();
   const datas = [
     ["hello", 123],
     ["hello", 123, "world"],
@@ -265,7 +265,7 @@ test("z.tuple", () => {
   const cArgs = [z.string(), z.number(), z.optional(z.string())] as const;
   const c = z.tuple(cArgs, z.boolean());
   type c = z.output<typeof c>;
-  expectTypeOf<c>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
+  expectTypeOf<c>().toEqualTypeOf<[string, number, string?, ...boolean[]]>();
   // type c = z.output<typeof c>;
 });
 

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/number.test.ts

@@ -153,36 +153,6 @@ test(".multipleOf() with negative divisor", () => {
   expect(() => schema.parse(7.5)).toThrow();
 });
 
-test(".multipleOf() with scientific notation (multi-digit exponents)", () => {
-  // Regression test for https://github.com/colinhacks/zod/pull/5687
-  // The regex was using \d? which only matches single-digit exponents
-  const schema = z.number().multipleOf(1e-10);
-
-  // These should all pass - they are valid multiples of 1e-10
-  expect(schema.parse(1e-10)).toEqual(1e-10);
-  expect(schema.parse(5e-10)).toEqual(5e-10);
-  expect(schema.parse(1e-9)).toEqual(1e-9); // 10 * 1e-10
-
-  // Test with 1e-15 (exponent = 15, two digits)
-  const schema15 = z.number().multipleOf(1e-15);
-  expect(schema15.parse(1e-15)).toEqual(1e-15);
-  expect(schema15.parse(3e-15)).toEqual(3e-15);
-});
-
-test(".multipleOf() with small floats / scientific notation (#5792)", () => {
-  const schema = z.number().multipleOf(1e-7);
-
-  // Valid multiples (integer * 1e-7)
-  expect(schema.safeParse(0).success).toBe(true);
-  expect(schema.safeParse(1e-7).success).toBe(true);
-  expect(schema.safeParse(2e-7).success).toBe(true);
-  expect(schema.safeParse(3e-7).success).toBe(true);
-
-  // Invalid — 2.5 and 1.5 are not integers
-  expect(schema.safeParse(2.5e-7).success).toBe(false);
-  expect(schema.safeParse(1.5e-7).success).toBe(false);
-});
-
 test(".step() validation", () => {
   const schemaPointOne = z.number().step(0.1);
   const schemaPointZeroZeroZeroOne = z.number().step(0.0001);
@@ -294,31 +264,6 @@ test("string format methods", () => {
   expect(() => a.parse(1)).toThrow();
 });
 
-test("negative zero edge case", () => {
-  const schema = z.number();
-  const negativeZero = -0;
-  const positiveZero = 0;
-
-  // Both -0 and 0 should be valid (parse succeeds)
-  expect(schema.safeParse(negativeZero).success).toBe(true);
-  expect(schema.safeParse(positiveZero).success).toBe(true);
-  // Note: -0 is normalized to 0 after parsing
-  expect(schema.parse(negativeZero) === 0).toBe(true);
-  expect(schema.parse(positiveZero)).toEqual(0);
-
-  // With positive() constraint, both should be invalid (0 is not positive)
-  const positiveSchema = z.number().positive();
-  expect(() => positiveSchema.parse(negativeZero)).toThrow();
-  expect(() => positiveSchema.parse(positiveZero)).toThrow();
-
-  // With nonnegative(), both should be valid (0 is non-negative)
-  const nonnegativeSchema = z.number().nonnegative();
-  expect(nonnegativeSchema.safeParse(negativeZero).success).toBe(true);
-  expect(nonnegativeSchema.safeParse(positiveZero).success).toBe(true);
-  expect(nonnegativeSchema.parse(negativeZero) === 0).toBe(true);
-  expect(nonnegativeSchema.parse(positiveZero)).toEqual(0);
-});
-
 test("error customization", () => {
   z.number().gte(5, { error: (iss) => "Min: " + iss.minimum.valueOf() });
   z.number().lte(5, { error: (iss) => "Max: " + iss.maximum.valueOf() });

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/object.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 import * as core from "zod/v4/core";
 
@@ -232,7 +232,8 @@ test("inferred merged object type with optional properties", async () => {
     .object({ a: z.string(), b: z.string().optional() })
     .merge(z.object({ a: z.string().optional(), b: z.string() }));
   type Merged = z.infer<typeof Merged>;
-  expectTypeOf<Merged>().toEqualTypeOf<{ a?: string | undefined; b: string }>();
+  expectTypeOf<Merged>().toEqualTypeOf<{ a?: string; b: string }>();
+  expectTypeOf<Merged>().toEqualTypeOf<{ a?: string; b: string }>();
 });
 
 test("inferred unioned object type with optional properties", async () => {
@@ -241,9 +242,7 @@ test("inferred unioned object type with optional properties", async () => {
     z.object({ a: z.string().optional(), b: z.string() }),
   ]);
   type Unioned = z.infer<typeof Unioned>;
-  expectTypeOf<Unioned>().toEqualTypeOf<
-    { a: string; b?: string | undefined } | { a?: string | undefined; b: string }
-  >();
+  expectTypeOf<Unioned>().toEqualTypeOf<{ a: string; b?: string } | { a?: string; b: string }>();
 });
 
 test("inferred enum type", async () => {
@@ -280,13 +279,13 @@ test("z.keyof returns enum", () => {
 test("inferred partial object type with optional properties", async () => {
   const Partial = z.object({ a: z.string(), b: z.string().optional() }).partial();
   type Partial = z.infer<typeof Partial>;
-  expectTypeOf<Partial>().toEqualTypeOf<{ a?: string | undefined; b?: string | undefined }>();
+  expectTypeOf<Partial>().toEqualTypeOf<{ a?: string; b?: string }>();
 });
 
 test("inferred picked object type with optional properties", async () => {
   const Picked = z.object({ a: z.string(), b: z.string().optional() }).pick({ b: true });
   type Picked = z.infer<typeof Picked>;
-  expectTypeOf<Picked>().toEqualTypeOf<{ b?: string | undefined }>();
+  expectTypeOf<Picked>().toEqualTypeOf<{ b?: string }>();
 });
 
 test("inferred type for unknown/any keys", () => {
@@ -406,36 +405,6 @@ test("unknownkeys merging", () => {
   expect(c._zod.def.catchall).toBeInstanceOf(core.$ZodNever);
 });
 
-test("merge() throws when receiver has refinements", () => {
-  const a = z
-    .object({
-      password: z.string(),
-      confirmPassword: z.string(),
-    })
-    .refine((data) => data.password === data.confirmPassword);
-
-  const b = z.object({ email: z.string() });
-
-  expect(() => a.merge(b)).toThrow(".merge() cannot be used on object schemas containing refinements");
-});
-
-test("merge() throws when receiver has superRefine", () => {
-  const a = z.object({ x: z.string() }).superRefine(() => {});
-  const b = z.object({ y: z.number() });
-
-  expect(() => a.merge(b)).toThrow(".merge() cannot be used on object schemas containing refinements");
-});
-
-test("merge() preserves refinements on the second schema", () => {
-  const a = z.object({ name: z.string() });
-  const b = z.object({ age: z.number() }).refine((data) => data.age >= 18, { message: "Must be 18+" });
-
-  const merged = a.merge(b);
-
-  expect(merged.parse({ name: "n", age: 21 })).toEqual({ name: "n", age: 21 });
-  expect(() => merged.parse({ name: "n", age: 12 })).toThrow("Must be 18+");
-});
-
 const personToExtend = z.object({
   firstName: z.string(),
   lastName: z.string(),
@@ -669,49 +638,3 @@ test("safeExtend() on object with refinements should not throw", () => {
 
   expect(() => schema.safeExtend({ b: z.string() })).not.toThrow();
 });
-
-// __proto__ in input must not replace the prototype of the parsed object via
-// the assignment setter on the result {}.
-// https://github.com/colinhacks/zod/security/advisories/GHSA-r34p-xfmx-58wv
-// https://github.com/colinhacks/zod/security/advisories/GHSA-84jv-fqfx-wxhr
-describe("__proto__ in object catchall paths", () => {
-  const protoInput = () => JSON.parse('{"__proto__":{"isAdmin":true},"name":"alice"}');
-
-  test("looseObject drops __proto__ and preserves Object.prototype", () => {
-    const schema = z.looseObject({ name: z.string() });
-    const parsed = schema.parse(protoInput());
-    expect(Object.keys(parsed)).toEqual(["name"]);
-    expect((parsed as any).isAdmin).toBeUndefined();
-    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
-  });
-
-  test("passthrough drops __proto__", () => {
-    const schema = z.object({ name: z.string() }).passthrough();
-    const parsed = schema.parse(protoInput());
-    expect((parsed as any).isAdmin).toBeUndefined();
-    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
-  });
-
-  test("catchall(unknown) drops __proto__", () => {
-    const schema = z.object({ name: z.string() }).catchall(z.unknown());
-    const parsed = schema.parse(protoInput());
-    expect((parsed as any).isAdmin).toBeUndefined();
-    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
-  });
-
-  test("safeParseAsync + jitless drops __proto__", async () => {
-    const schema = z.looseObject({ name: z.string() });
-    const result = await schema.safeParseAsync(protoInput(), { jitless: true } as any);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect((result.data as any).isAdmin).toBeUndefined();
-      expect(Object.getPrototypeOf(result.data)).toBe(Object.prototype);
-    }
-  });
-
-  test("strict does not surface __proto__ as unrecognized", () => {
-    const schema = z.object({ name: z.string() }).strict();
-    const result = schema.safeParse(protoInput());
-    expect(result.success).toBe(true);
-  });
-});

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/optional.test.ts

@@ -40,15 +40,15 @@ test("optionality", () => {
 
   // z.undefined should NOT be optional
   const f = z.undefined();
-  expect(f._zod.optin).toEqual(undefined);
-  expect(f._zod.optout).toEqual(undefined);
+  expect(f._zod.optin).toEqual("optional");
+  expect(f._zod.optout).toEqual("optional");
   expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | 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);
+  expect(g._zod.optin).toEqual("optional");
+  expect(g._zod.optout).toEqual("optional");
   expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | undefined>();
   expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();
 
@@ -135,52 +135,6 @@ test("optional prop with pipe", () => {
   schema.parse({}, { jitless: true });
 });
 
-test("object absent keys require optin optional", () => {
-  const valueUndefined = z.object({
-    value: z.undefined(),
-    union: z.union([z.string(), z.undefined()]),
-  });
-
-  expect(valueUndefined.safeParse({}).error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "message": "Invalid input: expected nonoptional, received undefined",
-        "path": [
-          "value",
-        ],
-      },
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "message": "Invalid input: expected nonoptional, received undefined",
-        "path": [
-          "union",
-        ],
-      },
-    ]
-  `);
-  expect(valueUndefined.safeParse({}, { jitless: true }).success).toEqual(false);
-  expect(valueUndefined.parse({ value: undefined, union: undefined })).toEqual({
-    value: undefined,
-    union: undefined,
-  });
-
-  const optionalOutOnly = z.object({
-    value: z
-      .string()
-      .transform((val) => (Math.random() ? val : undefined))
-      .pipe(z.string().optional()),
-  });
-  expect(optionalOutOnly.safeParse({}).success).toEqual(false);
-  expect(optionalOutOnly.safeParse({}, { jitless: true }).success).toEqual(false);
-
-  const defaulted = z.object({ value: z.string().default("fallback") });
-  expect(defaulted.parse({})).toEqual({ value: "fallback" });
-  expect(defaulted.parse({}, { jitless: true })).toEqual({ value: "fallback" });
-});
-
 // exactOptional tests
 test(".exactOptional()", () => {
   const schema = z.string().exactOptional();
@@ -267,67 +221,3 @@ test("exactOptional vs optional comparison", () => {
   // exactOptional() rejects explicit undefined
   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.
-test("object key optionality through optout propagation", () => {
-  const direct = z.object({ k: z.string().optional() });
-  expectTypeOf<z.infer<typeof direct>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  const exact = z.object({ k: z.string().exactOptional() });
-  expectTypeOf<z.infer<typeof exact>>().toEqualTypeOf<{ k?: string }>();
-
-  // nullable() preserves the inner type's optout
-  const nullableOpt = z.object({ k: z.string().optional().nullable() });
-  expectTypeOf<z.infer<typeof nullableOpt>>().toEqualTypeOf<{ k?: string | null | undefined }>();
-
-  // optional() wrapping nullable() — still optional out
-  const optNullable = z.object({ k: z.string().nullable().optional() });
-  expectTypeOf<z.infer<typeof optNullable>>().toEqualTypeOf<{ k?: string | null | undefined }>();
-
-  // union containing an optional member must mark the key as optional
-  const unionWithOpt = z.object({ k: z.union([z.string(), z.string().optional()]) });
-  expectTypeOf<z.infer<typeof unionWithOpt>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  // pipe ending in optional()
-  const pipedToOpt = z.object({
-    k: z
-      .string()
-      .transform((v) => (Math.random() ? v : undefined))
-      .pipe(z.string().optional()),
-  });
-  expectTypeOf<z.output<typeof pipedToOpt>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  // mixed shape pinning required vs optional keys end-to-end
-  const mixed = z.object({
-    req: z.string(),
-    opt: z.string().optional(),
-    exact: z.string().exactOptional(),
-    def: z.string().default("x"),
-    nullableOpt: z.string().optional().nullable(),
-  });
-  expectTypeOf<z.output<typeof mixed>>().toEqualTypeOf<{
-    req: string;
-    opt?: string | undefined;
-    exact?: string;
-    def: string;
-    nullableOpt?: string | null | undefined;
-  }>();
-});
-
-// 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)?]>();
-
-  const trailingExact = z.tuple([z.string(), z.number().exactOptional()]);
-  expectTypeOf<z.output<typeof trailingExact>>().toEqualTypeOf<[string, number?]>();
-
-  // Interior optional must NOT make the tail optional
-  const interiorOptional = z.tuple([z.string(), z.number().optional(), z.string()]);
-  expectTypeOf<z.output<typeof interiorOptional>>().toEqualTypeOf<[string, number | undefined, string]>();
-});

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/partial.test.ts

@@ -156,10 +156,6 @@ 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.
   expect(mySchema.parse({})).toMatchInlineSnapshot(`
     {
       "b": "default value",
@@ -169,27 +165,8 @@ test("catch/prefault/default", () => {
       "f": "prefault value",
     }
   `);
-  expect(mySchema.parse({}, { jitless: true })).toMatchInlineSnapshot(`
-    {
-      "b": "default value",
-      "c": "prefault value",
-      "d": "catch value",
-      "e": "default value",
-      "f": "prefault value",
-    }
-  `);
 
-  expect(mySchema.parse({ d: undefined })).toMatchInlineSnapshot(`
-    {
-      "b": "default value",
-      "c": "prefault value",
-      "d": "catch value",
-      "e": "default value",
-      "f": "prefault value",
-    }
-  `);
-
-  expect(mySchema.parse({ d: undefined }, { jitless: true })).toMatchInlineSnapshot(`
+  expect(mySchema.parse({}, { jitless: true })).toMatchInlineSnapshot(`
     {
       "b": "default value",
       "c": "prefault value",

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/prefault.test.ts

@@ -41,7 +41,7 @@ test("object schema with prefault should return shallow clone", () => {
     .object({
       a: z.string(),
     })
-    .prefault({ a: "x" });
+    .default({ a: "x" });
   const result1 = schema.parse(undefined);
   const result2 = schema.parse(undefined);
   expect(result1).not.toBe(result2);

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/preprocess.test.ts

@@ -280,72 +280,3 @@ test("perform transform with non-fatal issues", () => {
     ]]
   `);
 });
-
-test("preprocess accepts absent object keys (4.3 parity)", () => {
-  const schema = z.object({ a: z.preprocess((v) => v ?? "X", z.string()) });
-  expect(schema.parse({})).toEqual({ a: "X" });
-  expect(schema.parse({ a: "hi" })).toEqual({ a: "hi" });
-  expect(schema.parse({ a: undefined })).toEqual({ a: "X" });
-
-  // Outer optional clobbers preprocess output on undefined input
-  expect(
-    z
-      .preprocess((v) => v ?? "X", z.string())
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(
-    z
-      .preprocess((v) => v ?? "X", z.string())
-      .optional()
-      .parse("hi")
-  ).toBe("hi");
-  expect(z.object({ a: z.preprocess((v) => v ?? "X", z.string()).optional() }).parse({})).toEqual({});
-
-  // Top-level direct call unchanged
-  expect(z.preprocess((v) => v ?? "X", z.string()).parse(undefined)).toBe("X");
-});
-
-// https://github.com/colinhacks/zod/issues/5917
-test("optional propagates through preprocess inside object", () => {
-  const outer = z.object({ x: z.preprocess((v) => v, z.number()).optional() });
-  const inner = z.object({ x: z.preprocess((v) => v, z.number().optional()) });
-
-  expect(outer.safeParse({}).success).toBe(true);
-  expect(inner.safeParse({}).success).toBe(true);
-
-  expect(outer.safeParse({ x: 1 })).toEqual({ success: true, data: { x: 1 } });
-  expect(inner.safeParse({ x: 1 })).toEqual({ success: true, data: { x: 1 } });
-
-  expect(inner._zod.def.shape.x._zod.optin).toBe("optional");
-  expect(inner._zod.def.shape.x._zod.optout).toBe("optional");
-});
-
-test("preprocess is a structural subtype of ZodPipe", () => {
-  const schema = z.preprocess((v) => v, z.string());
-  expect(schema).toBeInstanceOf(z.ZodPipe);
-  expect(schema).toBeInstanceOf(z.ZodPreprocess);
-  expect(schema._zod.def.type).toBe("pipe");
-});
-
-test("preprocess does not propagate values/propValues from inner schema", () => {
-  const inner = z.preprocess((v) => v, z.literal("test"));
-  expect(inner._zod.values).toBeUndefined();
-  expect(inner._zod.propValues).toBeUndefined();
-});
-
-test("preprocess as discriminator throws at construction (no propValues to inherit)", () => {
-  const schema = z.discriminatedUnion("kind", [
-    z.object({ kind: z.preprocess((v: any) => String(v).toUpperCase(), z.literal("A")), a: z.string() }),
-    z.object({ kind: z.preprocess((v: any) => String(v).toUpperCase(), z.literal("B")), b: z.number() }),
-  ]);
-  expect(() => schema.parse({ kind: "a", a: "x" })).toThrow(/Invalid discriminated union option/);
-});
-
-test("preprocess as record key does not restrict accepted keys", () => {
-  const schema = z.record(
-    z.preprocess((v: any) => String(v).toLowerCase(), z.enum(["a", "b"])),
-    z.string()
-  );
-  expect(schema.safeParse({ A: "x", B: "y" })).toEqual({ success: true, data: { a: "x", b: "y" } });
-});