@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/record.test.ts

@@ -272,67 +272,6 @@ test("union exhaustiveness", () => {
   `);
 });
 
-test("applies transforms on the key schema (#5296)", () => {
-  const single = z.record(
-    z.literal("a").transform(() => "b" as const),
-    z.string()
-  );
-  expect(single.parse({ a: "John" })).toEqual({ b: "John" });
-
-  const multi = z.record(
-    z.literal(["a", "b"]).transform((k) => k.toUpperCase()),
-    z.number()
-  );
-  expect(multi.parse({ a: 1, b: 2 })).toEqual({ A: 1, B: 2 });
-
-  // required-key semantics still hold when the keyType has a known value set
-  expect(multi.safeParse({ a: 1 }).success).toBe(false);
-
-  const en = z.record(
-    z.enum(["a", "b"]).transform((k) => k.toUpperCase()),
-    z.number()
-  );
-  expect(en.parse({ a: 1, b: 2 })).toEqual({ A: 1, B: 2 });
-
-  // matches partialRecord, which already applied transforms
-  const part = z.partialRecord(
-    z.literal("a").transform(() => "b" as const),
-    z.string()
-  );
-  expect(part.parse({ a: "John" })).toEqual({ b: "John" });
-});
-
-test("surfaces key schema refinement failures as invalid_key", () => {
-  // refine rejects "b" but it's still in the literal's value set
-  const schema = z.record(
-    z.literal(["a", "b"]).refine((k) => k === "a", { message: "only 'a' is allowed" }),
-    z.string()
-  );
-
-  expect(schema.safeParse({ a: "ok", b: "nope" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_key",
-        "origin": "record",
-        "issues": [
-          {
-            "code": "custom",
-            "path": [],
-            "message": "only 'a' is allowed"
-          }
-        ],
-        "path": [
-          "b"
-        ],
-        "message": "Invalid key in record"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
 test("string record parse - pass", () => {
   const schema = z.record(z.string(), z.boolean());
   schema.parse({
@@ -691,27 +630,3 @@ test("numeric string keys", () => {
   );
   expect(transformedSchema.parse({ 5: "five", 10: "ten" })).toEqual({ 10: "five", 20: "ten" });
 });
-
-test("v3-compat single-arg form: z.record(valueType)", () => {
-  // single arg should default keyType to z.string() and use the arg as valueType
-  const schema = (z.record as any)(z.number());
-  expect(schema.keyType._zod.def.type).toEqual("string");
-  expect(schema.valueType._zod.def.type).toEqual("number");
-
-  expect(schema.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-  expect(schema.safeParse({ a: "x" }).success).toBe(false);
-
-  // params still flow through in the single-arg form
-  const withMessage = (z.record as any)(z.number(), "must be a number record");
-  expect(withMessage.keyType._zod.def.type).toEqual("string");
-  expect(withMessage.valueType._zod.def.type).toEqual("number");
-
-  // toJSONSchema should produce a well-formed schema (regression: previously produced
-  // additionalProperties from undefined valueType, crashing process())
-  const json = z.toJSONSchema(schema);
-  expect(json).toMatchObject({
-    type: "object",
-    propertyNames: { type: "string" },
-    additionalProperties: { type: "number" },
-  });
-});

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

@@ -135,11 +135,6 @@ test("pick and omit with getter", () => {
   }
   expectTypeOf<Category>().toEqualTypeOf<_Category>();
 
-  // Shape should not surface `readonly` modifiers from getter-defined keys.
-  // object/strictObject/looseObject all pass shape through util.Writeable<T>.
-  type Shape = (typeof Category)["shape"];
-  expectTypeOf<Shape>().toEqualTypeOf<{ name: z.ZodString; subcategories: z.ZodArray<typeof Category> }>();
-
   const PickedCategory = Category.pick({ name: true });
   const OmittedCategory = Category.omit({ subcategories: true });
 
@@ -153,50 +148,6 @@ test("pick and omit with getter", () => {
   expect(() => OmittedCategory.parse({ name: "test", subcategories: [] })).toThrow();
 });
 
-test("shape stays writeable through extend/safeExtend/partial/required", () => {
-  const Base = z.object({ name: z.string() });
-
-  const Extended = Base.extend({
-    get sub() {
-      return z.array(Extended);
-    },
-  });
-  type ExtendedShape = (typeof Extended)["shape"];
-  expectTypeOf<ExtendedShape>().toEqualTypeOf<{
-    name: z.ZodString;
-    sub: z.ZodArray<typeof Extended>;
-  }>();
-
-  const SafeExt = Base.safeExtend({ extra: z.string() } as const);
-  type SafeExtShape = (typeof SafeExt)["shape"];
-  expectTypeOf<SafeExtShape>().toEqualTypeOf<{
-    name: z.ZodString;
-    extra: z.ZodString;
-  }>();
-
-  const FromConst = Base.extend({ a: z.string(), b: z.number() } as const);
-  type FromConstShape = (typeof FromConst)["shape"];
-  expectTypeOf<FromConstShape>().toEqualTypeOf<{
-    name: z.ZodString;
-    a: z.ZodString;
-    b: z.ZodNumber;
-  }>();
-
-  const PartialExtended = Extended.partial();
-  type PartialShape = (typeof PartialExtended)["shape"];
-  expectTypeOf<PartialShape>().toEqualTypeOf<{
-    name: z.ZodOptional<z.ZodString>;
-    sub: z.ZodOptional<z.ZodArray<typeof Extended>>;
-  }>();
-
-  const RequiredExtended = Extended.required();
-  type RequiredShape = (typeof RequiredExtended)["shape"];
-  expectTypeOf<RequiredShape>().toEqualTypeOf<{
-    name: z.ZodNonOptional<z.ZodString>;
-    sub: z.ZodNonOptional<z.ZodArray<typeof Extended>>;
-  }>();
-});
-
 test("deferred self-recursion", () => {
   const Feature = z.object({
     title: z.string(),

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

@@ -414,69 +414,6 @@ describe("chained refinements", () => {
     };
     expect(objectSchema.parse(validData)).toEqual(validData);
   });
-
-  test("should run superRefine validation even when base schema validation fails when 'when' is defined and returns true", () => {
-    const baseSchema = z.object({
-      foo: z.number(),
-      bar: z.number(),
-    });
-
-    const schema = baseSchema.superRefine(
-      (data, ctx) => {
-        if (data.foo > 10) {
-          ctx.addIssue({
-            code: "custom",
-            message: "foo must be less than 10",
-          });
-        }
-      },
-      {
-        when: ({ value }) => baseSchema.pick({ foo: true }).safeParse(value).success,
-      }
-    );
-
-    const result = schema.safeParse({
-      foo: 11,
-    });
-    expect(result.success).toEqual(false);
-
-    if (!result.success) {
-      expect(result.error.issues.length).toEqual(2);
-      expect(result.error.issues[0].message).toEqual("Invalid input: expected number, received undefined");
-      expect(result.error.issues[1].message).toEqual("foo must be less than 10");
-    }
-  });
-
-  test("should not run superRefine validation when 'when' is defined and returns false", () => {
-    const baseSchema = z.object({
-      foo: z.number(),
-      bar: z.number(),
-    });
-
-    const schema = baseSchema.superRefine(
-      (data, ctx) => {
-        if (data.foo > 10) {
-          ctx.addIssue({
-            code: "custom",
-            message: "foo must be less than 10",
-          });
-        }
-      },
-      {
-        when: ({ value }) => baseSchema.safeParse(value).success,
-      }
-    );
-
-    const result = schema.safeParse({
-      foo: 11,
-    });
-    expect(result.success).toEqual(false);
-
-    if (!result.success) {
-      expect(result.error.issues.length).toEqual(1);
-      expect(result.error.issues[0].message).toEqual("Invalid input: expected number, received undefined");
-    }
-  });
 });
 
 describe("type refinement with type guards", () => {

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

@@ -217,16 +217,6 @@ test("base64 validations", () => {
     "?QmFzZTY0IGVuY29kaW5nIGlzIGZ1bg==", // Invalid character '?'
     ".MTIzND2Nzg5MC4=", // Invalid character '.'
     "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo", // Missing padding
-    // Whitespace is not part of canonical base64 (RFC 4648 §3.3) — atob() strips
-    // whitespace internally before validating, so the length check alone would
-    // accept "123 " etc.
-    "123 ", // bypasses length-mod-4 via trailing whitespace
-    "SGVsbG8gV29ybGQ= ", // trailing space
-    " SGVsbG8gV29ybGQ=", // leading space
-    "SGVsbG8gV29ybGQ=\n", // trailing newline
-    "SGVs bG8gV29ybGQ=", // internal space
-    "SGVs\nbG8gV29ybGQ=", // internal newline
-    "SGVs\tbG8gV29ybGQ=", // internal tab
   ];
 
   for (const str of invalidBase64Strings) {
@@ -464,12 +454,6 @@ test("httpurl", () => {
   ).toThrow();
   expect(() => httpUrl.parse("http://asdf.c")).toThrow();
   expect(() => httpUrl.parse("mailto:asdf@lckj.com")).toThrow();
-  // missing // after protocol
-  expect(() => httpUrl.parse("http:example.com")).toThrow();
-  expect(() => httpUrl.parse("https:example.com")).toThrow();
-  // missing one /
-  expect(() => httpUrl.parse("https:/www.google.com")).toThrow();
-  expect(() => httpUrl.parse("http:/example.com")).toThrow();
 });
 
 test("url error overrides", () => {
@@ -627,26 +611,12 @@ test("cuid", () => {
         "origin": "string",
         "code": "invalid_format",
         "format": "cuid",
-        "pattern": "/^[cC][0-9a-z]{6,}$/",
+        "pattern": "/^[cC][^\\\\s-]{8,}$/",
         "path": [],
         "message": "Invalid cuid"
       }
     ]]
   `);
-
-  // Strings containing non-base36 characters that the old denylist regex
-  // (/^[cC][^\s-]{8,}$/) accepted. The new regex restricts the body to
-  // [0-9a-z], matching the actual CUID v1 base36 format. See #3621.
-  const previouslyAcceptedNonCuids = [
-    "cly63t164000245zw008pggon';select1;", // SQLi-shaped (no whitespace, no hyphen)
-    "c<script>alert(1)</script>aaaaaa", // XSS-shaped
-    "c{};alert(1)//", // bracket / curly chars
-    "C0123_45678", // underscore is not base36
-    "cAAAAAAAAA", // uppercase letters in body are not base36 (CUIDs are lowercase)
-  ];
-  for (const s of previouslyAcceptedNonCuids) {
-    expect(cuid.safeParse(s).success).toBe(false);
-  }
 });
 
 test("cuid2", () => {
@@ -841,25 +811,6 @@ test("min max getters", () => {
   expect(z.string().maxLength).toEqual(null);
 });
 
-test("boundary cases with zero length", () => {
-  // Test length(0) - only empty string should pass
-  const lengthZero = z.string().length(0);
-  expect(lengthZero.parse("")).toEqual("");
-  expect(() => lengthZero.parse("a")).toThrow();
-
-  // Test min(0) - all strings including empty should pass
-  const minZero = z.string().min(0);
-  expect(minZero.parse("")).toEqual("");
-  expect(minZero.parse("a")).toEqual("a");
-  expect(minZero.parse("hello")).toEqual("hello");
-
-  // Test max(0) - only empty string should pass
-  const maxZero = z.string().max(0);
-  expect(maxZero.parse("")).toEqual("");
-  expect(() => maxZero.parse("a")).toThrow();
-  expect(() => maxZero.parse("hello")).toThrow();
-});
-
 test("trim", () => {
   expect(z.string().trim().min(2).parse(" 12 ")).toEqual("12");
 

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

@@ -482,7 +482,7 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => nullishBruh.parse("1null")).toThrow();
   expect(() => nullishBruh.parse("undefined")).toThrow();
   expect(() => cuid.parse("bjld2cyuq0000t3rmniod1foy")).toThrow();
-  expect(() => cuid.parse("cjld2")).toThrow();
+  expect(() => cuid.parse("cjld2cyu")).toThrow();
   expect(() => cuid.parse("cjld2 cyu")).toThrow();
   expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy ")).toThrow();
   expect(() => cuid.parse("1cjld2cyuq0000t3rmniod1foy")).toThrow();
@@ -555,8 +555,8 @@ test("regexes", () => {
   expect(optionalNumber._zod.pattern.source).toMatchInlineSnapshot(`"^(-?\\d+(?:\\.\\d+)?)?$"`);
   expect(nullishBruh._zod.pattern.source).toMatchInlineSnapshot(`"^(((bruh)|null))?$"`);
   expect(nullishString._zod.pattern.source).toMatchInlineSnapshot(`"^(([\\s\\S]{0,}|null))?$"`);
-  expect(cuid._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][0-9a-z]{6,}$"`);
-  expect(cuidZZZ._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][0-9a-z]{6,}ZZZ$"`);
+  expect(cuid._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][^\\s-]{8,}$"`);
+  expect(cuidZZZ._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][^\\s-]{8,}ZZZ$"`);
   expect(cuid2._zod.pattern.source).toMatchInlineSnapshot(`"^[0-9a-z]+$"`);
   expect(datetime._zod.pattern.source).toMatchInlineSnapshot(
     `"^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"`
@@ -717,7 +717,7 @@ test("template literal parsing - failure - issue format", () => {
       {
         "code": "invalid_format",
         "format": "template_literal",
-        "pattern": "^[cC][0-9a-z]{6,}ZZZ$",
+        "pattern": "^[cC][^\\\\s-]{8,}ZZZ$",
         "path": [],
         "message": "Invalid input"
       }

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

@@ -212,7 +212,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "cuid",
-        "pattern": "^[cC][0-9a-z]{6,}$",
+        "pattern": "^[cC][^\\s-]{8,}$",
         "type": "string",
       }
     `);
@@ -647,47 +647,6 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("number constraints intersection draft-04", () => {
-    // When both minimum (from .int()) and exclusiveMinimum (from .positive()) exist,
-    // the more restrictive constraint should be used
-    expect(z.toJSONSchema(z.number().int().positive().lte(65535), { target: "draft-04" })).toMatchInlineSnapshot(`
-      {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "exclusiveMinimum": true,
-        "maximum": 65535,
-        "minimum": 0,
-        "type": "integer",
-      }
-    `);
-    // Same for openapi-3.0
-    expect(z.toJSONSchema(z.number().int().positive().lte(65535), { target: "openapi-3.0" })).toMatchInlineSnapshot(`
-      {
-        "exclusiveMinimum": true,
-        "maximum": 65535,
-        "minimum": 0,
-        "type": "integer",
-      }
-    `);
-    // When inclusive minimum is more restrictive than exclusive minimum
-    expect(z.toJSONSchema(z.number().gt(3).gte(10), { target: "draft-04" })).toMatchInlineSnapshot(`
-      {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "minimum": 10,
-        "type": "number",
-      }
-    `);
-    // Same logic for maximum constraints
-    expect(z.toJSONSchema(z.number().int().negative(), { target: "draft-04" })).toMatchInlineSnapshot(`
-      {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "exclusiveMaximum": true,
-        "maximum": 0,
-        "minimum": -9007199254740991,
-        "type": "integer",
-      }
-    `);
-  });
-
   test("target normalization draft-04 and draft-07", () => {
     // Test that both old (draft-4, draft-7) and new (draft-04, draft-07) target formats work
     // Test draft-04 / draft-4
@@ -1260,9 +1219,11 @@ describe("toJSONSchema", () => {
         },
         "definitions": {
           "primary": {
+            "id": "primary",
             "type": "string",
           },
           "rest": {
+            "id": "rest",
             "type": "number",
           },
         },
@@ -2053,9 +2014,11 @@ test("extract schemas with id", () => {
     {
       "$defs": {
         "age": {
+          "id": "age",
           "type": "number",
         },
         "name": {
+          "id": "name",
           "type": "string",
         },
       },
@@ -2143,6 +2106,7 @@ test("describe with id", () => {
     {
       "$defs": {
         "jobId": {
+          "id": "jobId",
           "type": "string",
         },
       },
@@ -2167,45 +2131,6 @@ test("describe with id", () => {
   `);
 });
 
-test("id is stripped from $defs entries (draft-2020-12)", () => {
-  // The `id` in `.meta()` is a registration tag — it determines the $defs key
-  // but should not leak into the definition body, where it is redundant.
-  const inner = z.string().meta({ id: "Inner" });
-  const result = z.toJSONSchema(z.object({ a: inner, b: inner }));
-  expect(result.$defs?.Inner).toEqual({ type: "string" });
-  expect((result.$defs?.Inner as any).id).toBeUndefined();
-});
-
-test("id is stripped from definitions entries (draft-04)", () => {
-  // In draft-04, `id` is a reserved keyword that sets a base URI for the
-  // subschema. Leaking Zod's registration tag here is semantically wrong, so
-  // ensure it is stripped.
-  const inner = z.string().meta({ id: "Inner" });
-  const result = z.toJSONSchema(z.object({ a: inner, b: inner }), { target: "draft-04" }) as any;
-  expect(result.definitions?.Inner).toEqual({ type: "string" });
-  expect(result.definitions?.Inner?.id).toBeUndefined();
-});
-
-test("id is stripped from root schema", () => {
-  // The registration tag should not appear on the root either.
-  const A = z.object({ name: z.string() }).meta({ id: "A" });
-  const result = z.toJSONSchema(A);
-  expect((result as any).id).toBeUndefined();
-});
-
-test("id is observable in override callback", () => {
-  // The strip happens after override callbacks run, so userland override code
-  // can still read `jsonSchema.id` if it wants to.
-  const inner = z.string().meta({ id: "Inner" });
-  const seenIds: Array<string | undefined> = [];
-  z.toJSONSchema(z.object({ a: inner }), {
-    override: ({ jsonSchema }) => {
-      if (jsonSchema.id !== undefined) seenIds.push(jsonSchema.id as string);
-    },
-  });
-  expect(seenIds).toContain("Inner");
-});
-
 test("describe with id on wrapper", () => {
   // Test that $ref propagation works when processor sets a different ref (readonly -> innerType)
   // but parent was extracted due to having an id
@@ -2221,6 +2146,7 @@ test("describe with id on wrapper", () => {
     {
       "$defs": {
         "roJobId": {
+          "id": "roJobId",
           "readOnly": true,
           "type": "string",
         },
@@ -2259,10 +2185,12 @@ test("overwrite id", () => {
     {
       "$defs": {
         "aaa": {
+          "id": "aaa",
           "type": "string",
         },
         "bbb": {
           "$ref": "#/$defs/aaa",
+          "id": "bbb",
         },
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -2296,10 +2224,12 @@ test("overwrite id", () => {
     {
       "$defs": {
         "aaa": {
+          "id": "aaa",
           "type": "string",
         },
         "ccc": {
           "$ref": "#/$defs/aaa",
+          "id": "ccc",
         },
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -2421,6 +2351,7 @@ test("top-level readonly", () => {
       "$defs": {
         "B": {
           "additionalProperties": false,
+          "id": "B",
           "properties": {
             "a": {
               "$ref": "#",
@@ -2439,6 +2370,7 @@ test("top-level readonly", () => {
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
       "additionalProperties": false,
+      "id": "A",
       "properties": {
         "b": {
           "$ref": "#/$defs/B",
@@ -2565,6 +2497,7 @@ test("_ref", () => {
     {
       "$defs": {
         "foo": {
+          "id": "foo",
           "type": "string",
         },
       },
@@ -2627,38 +2560,6 @@ test("defaults/prefaults", () => {
   `);
 });
 
-test("falsy prefaults (false, 0, empty string)", () => {
-  // boolean prefault false
-  const a = z.boolean().prefault(false);
-  expect(z.toJSONSchema(a, { io: "input" })).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "default": false,
-      "type": "boolean",
-    }
-  `);
-
-  // number prefault 0
-  const b = z.number().prefault(0);
-  expect(z.toJSONSchema(b, { io: "input" })).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "default": 0,
-      "type": "number",
-    }
-  `);
-
-  // string prefault empty string
-  const c = z.string().prefault("");
-  expect(z.toJSONSchema(c, { io: "input" })).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "default": "",
-      "type": "string",
-    }
-  `);
-});
-
 test("input type", () => {
   const schema = z.object({
     a: z.string(),
@@ -2731,6 +2632,7 @@ test("input type", () => {
       "required": [
         "a",
         "d",
+        "f",
         "g",
       ],
       "type": "object",
@@ -2895,28 +2797,6 @@ test("use output type for preprocess", () => {
   `);
 });
 
-test("strip output-side examples from input JSON schema for codec", () => {
-  const codec = z
-    .codec(z.string(), z.number(), { decode: (s) => Number(s), encode: (n) => String(n) })
-    .meta({ examples: [42] });
-
-  expect(z.toJSONSchema(codec, { io: "input" })).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "string",
-    }
-  `);
-  expect(z.toJSONSchema(codec, { io: "output" })).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "examples": [
-        42,
-      ],
-      "type": "number",
-    }
-  `);
-});
-
 // test("isTransforming", () => {
 //   const tx = z.core.isTransforming;
 //   expect(tx(z.string())).toEqual(false);
@@ -3108,18 +2988,3 @@ test("cycle detection - mutual recursion", () => {
     Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.]
   `);
 });
-
-test("recursive lazy with describe does not stack overflow", () => {
-  const NodeSchema: z.ZodType = z.lazy(() =>
-    z
-      .object({
-        value: z.string().describe("node value"),
-        children: z.array(NodeSchema.describe("child node")).optional().describe("child list"),
-      })
-      .describe("tree node")
-  );
-
-  const result = z.toJSONSchema(NodeSchema, { cycles: "ref", reused: "ref" });
-  expect(result).toBeDefined();
-  expect(result.$defs).toBeDefined();
-});

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

@@ -359,20 +359,3 @@ test("encode error", () => {
     `[ZodEncodeError: Encountered unidirectional transform during encode: ZodTransform]`
   );
 });
-
-test("transform context should have addIssue", () => {
-  const schema = z.transform((val, ctx) => {
-    ctx.addIssue({
-      code: "custom",
-      message: "Not valid",
-    });
-    return val;
-  });
-
-  const result = schema.safeParse("test");
-
-  expect(result.success).toBe(false);
-  if (!result.success) {
-    expect(result.error.issues[0].message).toBe("Not valid");
-  }
-});