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

@@ -143,12 +143,6 @@ test("assignability", () => {
   z.unknown().pipe(z.number()) satisfies z.core.$ZodPipe;
   z.unknown().pipe(z.number()) satisfies z.ZodPipe;
 
-  // $ZodPreprocess
-  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPreprocess;
-  z.preprocess((v) => v, z.number()) satisfies z.ZodPreprocess;
-  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
-  z.preprocess((v) => v, z.number()) satisfies z.ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
-
   // $ZodSuccess
   z.success(z.string()) satisfies z.core.$ZodSuccess;
   z.success(z.string()) satisfies z.ZodSuccess;

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

@@ -128,9 +128,7 @@ test("native enum", () => {
     fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
   });
 
-  // Absent keys flow through to the catch handler.
   expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
-  expect(schema.parse({}, { jitless: true })).toEqual({ fruit: Fruits.apple });
   expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
 });
 
@@ -140,7 +138,6 @@ test("enum", () => {
   });
 
   expect(schema.parse({})).toEqual({ fruit: "apple" });
-  expect(schema.parse({}, { jitless: true })).toEqual({ fruit: "apple" });
   expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
   expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
 });
@@ -277,50 +274,3 @@ test("direction-aware catch", () => {
   // But valid values should still work in reverse
   expect(z.encode(schema, "world")).toBe("world");
 });
-
-test("optional clobbers catch through pipe boundaries", () => {
-  expect(
-    z
-      .string()
-      .catch("X")
-      .transform((s) => s + "!")
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(z.string().catch("X").pipe(z.string()).optional().parse(undefined)).toBeUndefined();
-  expect(
-    z
-      .string()
-      .catch("X")
-      .transform((s) => s + "!")
-      .transform((s) => s.toLowerCase())
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(
-    z
-      .object({
-        a: z
-          .string()
-          .catch("X")
-          .transform((s) => s + "!")
-          .optional(),
-      })
-      .parse({})
-  ).toEqual({});
-
-  expect(
-    z
-      .string()
-      .catch("X")
-      .transform((s) => s + "!")
-      .parse("hi")
-  ).toBe("hi!");
-  expect(
-    z
-      .string()
-      .catch("X")
-      .transform((s) => s + "!")
-      .parse(123)
-  ).toBe("X!");
-});

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/classic/tests/codec.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";
 
 const isoDateCodec = z.codec(
@@ -560,144 +560,3 @@ test("async codec functionality", async () => {
   const mixedResult = await z.decodeAsync(mixedCodec, "123");
   expect(mixedResult).toBe(123);
 });
-
-test("invertCodec basic", () => {
-  const inverted = z.invertCodec(isoDateCodec);
-
-  const testDate = new Date("2024-01-15T10:30:00.000Z");
-  const decoded = z.decode(inverted, testDate);
-  expect(typeof decoded).toBe("string");
-  expect(decoded).toBe("2024-01-15T10:30:00.000Z");
-
-  const encoded = z.encode(inverted, "2024-01-15T10:30:00.000Z");
-  expect(encoded).toBeInstanceOf(Date);
-  expect(encoded.toISOString()).toBe("2024-01-15T10:30:00.000Z");
-});
-
-test("invertCodec round trip", () => {
-  const inverted = z.invertCodec(isoDateCodec);
-  const testDate = new Date("2024-06-01T12:00:00.000Z");
-
-  const toStr = z.decode(inverted, testDate);
-  const backToDate = z.encode(inverted, toStr);
-  expect(backToDate.toISOString()).toBe(testDate.toISOString());
-});
-
-test("invertCodec types", () => {
-  const inverted = z.invertCodec(isoDateCodec);
-
-  type InvIn = z.input<typeof inverted>;
-  type InvOut = z.output<typeof inverted>;
-  expectTypeOf<InvIn>().toEqualTypeOf<Date>();
-  expectTypeOf<InvOut>().toEqualTypeOf<string>();
-});
-
-test("invertCodec is its own inverse", () => {
-  const doubleInverted = z.invertCodec(z.invertCodec(isoDateCodec));
-  const testIsoString = "2024-03-10T08:00:00.000Z";
-
-  const decoded = z.decode(doubleInverted, testIsoString);
-  expect(decoded).toBeInstanceOf(Date);
-  expect(decoded.toISOString()).toBe(testIsoString);
-
-  const encoded = z.encode(doubleInverted, decoded);
-  expect(encoded).toBe(testIsoString);
-});
-
-test("invertCodec with custom codec", () => {
-  const intToString = z.codec(z.int(), z.string().regex(/^\d+$/), {
-    decode: (num) => num.toString(),
-    encode: (str) => Number.parseInt(str, 10),
-  });
-
-  const stringToInt = z.invertCodec(intToString);
-  const result = z.decode(stringToInt, "42");
-  expect(result).toBe(42);
-
-  const back = z.encode(stringToInt, 42);
-  expect(back).toBe("42");
-});
-
-describe("context immutability", () => {
-  test("decode/encode", () => {
-    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
-      decode: (isoString) => new Date(isoString),
-      encode: (date) => date.toISOString(),
-    });
-
-    const ctx = { reportInput: true } as const;
-
-    const result1 = z.decode(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
-    expect(result1).toBeInstanceOf(Date);
-
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-
-    const result2 = z.decode(stringToDateCodec, "2024-12-25T15:45:30.123Z", ctx);
-    expect(result2).toBeInstanceOf(Date);
-
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-
-    z.encode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("direction" in ctx).toBe(false);
-
-    z.safeEncode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("direction" in ctx).toBe(false);
-  });
-
-  test("parse functions", () => {
-    const schema = z.string().min(1);
-    const ctx = { reportInput: true } as const;
-
-    z.parse(schema, "asdf", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-
-    z.safeParse(schema, "asdf", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-  });
-
-  test("async functions", async () => {
-    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
-      decode: (isoString) => new Date(isoString),
-      encode: (date) => date.toISOString(),
-    });
-
-    const ctx = { reportInput: true } as const;
-
-    const schema = z.string();
-    await z.parseAsync(schema, "asdf", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-
-    await z.safeParseAsync(schema, "asdf", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-
-    await z.decodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-
-    await z.encodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-
-    await z.safeDecodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-
-    await z.safeEncodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
-    expect(ctx).toEqual({ reportInput: true });
-    expect("async" in ctx).toBe(false);
-    expect("direction" in ctx).toBe(false);
-  });
-});

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

@@ -274,7 +274,7 @@ test("continuability", () => {
         "message": "Invalid cuid",
         "origin": "string",
         "path": [],
-        "pattern": "/^[cC][0-9a-z]{6,}$/",
+        "pattern": "/^[cC][^\\s-]{8,}$/",
       },
       {
         "code": "custom",

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

@@ -299,4 +299,4 @@ test("redos checker", () => {
     const result = checkSync(schema._zod.pattern.source, "");
     if (result.status !== "safe") throw Error("ReDoS issue");
   }
-}, 10000);
+});

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

@@ -332,50 +332,6 @@ test("defaulted array schema returns shallow clone", () => {
   expect(result1).toEqual(result2);
 });
 
-test("defaulted Map schema returns shallow clone", () => {
-  const schema = z.map(z.string(), z.number()).default(new Map([["a", 1]]));
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("defaulted Set schema returns shallow clone", () => {
-  const schema = z.set(z.string()).default(new Set(["x"]));
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("mutations on defaulted Map do not affect subsequent parses", () => {
-  const schema = z.map(z.string(), z.number()).default(new Map());
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  result1.set("key1", 1);
-  result2.set("key2", 2);
-  expect(result1.size).toBe(1);
-  expect(result1.get("key1")).toBe(1);
-  expect(result1.has("key2")).toBe(false);
-  expect(result2.size).toBe(1);
-  expect(result2.get("key2")).toBe(2);
-  expect(result2.has("key1")).toBe(false);
-});
-
-test("mutations on defaulted Set do not affect subsequent parses", () => {
-  const schema = z.set(z.string()).default(new Set());
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  result1.add("item1");
-  result2.add("item2");
-  expect(result1.size).toBe(1);
-  expect(result1.has("item1")).toBe(true);
-  expect(result1.has("item2")).toBe(false);
-  expect(result2.size).toBe(1);
-  expect(result2.has("item2")).toBe(true);
-  expect(result2.has("item1")).toBe(false);
-});
-
 test("direction-aware defaults", () => {
   const schema = z.string().default("hello");
 

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

@@ -158,14 +158,10 @@ test("invalid discriminator value", () => {
         "errors": [],
         "note": "No matching discriminator",
         "discriminator": "type",
-        "options": [
-          "a",
-          "b"
-        ],
         "path": [
           "type"
         ],
-        "message": "Invalid discriminator value. Expected 'a' | 'b'"
+        "message": "Invalid input"
       }
     ]],
       "success": false,
@@ -264,9 +260,6 @@ test("valid discriminator value, invalid data", () => {
 });
 
 test("wrong schema - missing discriminator", () => {
-  // @ts-expect-error missing discriminator property
-  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
-
   try {
     z.discriminatedUnion("type", [
       z.object({ type: z.literal("a"), a: z.string() }),
@@ -666,29 +659,3 @@ test("def", () => {
   expect(schema.def.discriminator).toEqual("type");
   expect(schema.def.unionFallback).toEqual(true);
 });
-
-test("encode with codec discriminator", () => {
-  const codec1 = z.codec(z.literal(1), z.literal("one"), {
-    decode: () => "one" as const,
-    encode: () => 1 as const,
-  });
-
-  const codec2 = z.codec(z.literal(2), z.literal("two"), {
-    decode: () => "two" as const,
-    encode: () => 2 as const,
-  });
-
-  const schema = z.discriminatedUnion("type", [
-    z.object({ type: codec1, value: z.string() }),
-    z.object({ type: codec2, value: z.number() }),
-  ]);
-
-  // decode (forward) should work
-  const decoded = schema.decode({ type: 1, value: "hello" });
-  expect(decoded).toEqual({ type: "one", value: "hello" });
-
-  // encode (backward) should also work — the discriminator values differ
-  // between forward (1, 2) and backward ("one", "two") directions
-  const encoded = z.encode(schema, { type: "one", value: "hello" });
-  expect(encoded).toEqual({ type: 1, value: "hello" });
-});

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

@@ -80,10 +80,7 @@ test(".flatten()", () => {
 
 test("custom .flatten()", () => {
   type ErrorType = { message: string; code: number };
-  const flattened = parsed.error!.flatten((iss) => ({
-    message: iss.message,
-    code: 1234,
-  }));
+  const flattened = parsed.error!.flatten((iss) => ({ message: iss.message, code: 1234 }));
   expectTypeOf(flattened).toMatchTypeOf<{
     formErrors: ErrorType[];
     fieldErrors: {
@@ -163,10 +160,7 @@ test(".format()", () => {
 
 test("custom .format()", () => {
   type ErrorType = { message: string; code: number };
-  const formatted = parsed.error!.format((iss) => ({
-    message: iss.message,
-    code: 1234,
-  }));
+  const formatted = parsed.error!.format((iss) => ({ message: iss.message, code: 1234 }));
   expectTypeOf(formatted).toMatchTypeOf<{
     _errors: ErrorType[];
     f2?: { _errors: ErrorType[] };
@@ -599,209 +593,3 @@ test("update message after adding issues", () => {
     ]"
   `);
 });
-
-test("z.formatError nested union preserves parent path", () => {
-  const syntheticError = new z.ZodError([
-    {
-      code: "invalid_union",
-      path: ["parent"],
-      message: "Invalid input",
-      errors: [
-        [
-          {
-            code: "invalid_type",
-            expected: "string",
-            path: [],
-            message: "Expected string",
-            input: {},
-          },
-        ],
-        [
-          {
-            code: "invalid_union",
-            path: ["child"],
-            message: "Invalid input",
-            errors: [
-              [
-                {
-                  code: "invalid_type",
-                  expected: "string",
-                  path: [],
-                  message: "Expected string",
-                  input: true,
-                },
-              ],
-              [
-                {
-                  code: "invalid_type",
-                  expected: "number",
-                  path: [],
-                  message: "Expected number",
-                  input: true,
-                },
-              ],
-            ],
-          },
-        ],
-      ],
-    },
-  ] as any);
-
-  const formatted: any = z.formatError(syntheticError);
-
-  // "child" must be nested under "parent", not at root
-  expect(formatted).not.toHaveProperty("child");
-  expect(formatted).toHaveProperty("parent");
-  expect(formatted.parent).toHaveProperty("child");
-  expect(formatted.parent.child._errors).toContain("Expected string");
-  expect(formatted.parent.child._errors).toContain("Expected number");
-  expect(formatted.parent._errors).toContain("Expected string");
-});
-test("z.treeifyError nested union preserves parent path", () => {
-  // When a nested invalid_union appears inside another invalid_union,
-  // the inner errors must stay nested under their parent path, not flatten to root.
-  const syntheticError = new z.ZodError([
-    {
-      code: "invalid_union",
-      path: ["parent"],
-      message: "Invalid input",
-      errors: [
-        [
-          {
-            code: "invalid_type",
-            expected: "string",
-            path: [],
-            message: "Expected string",
-            input: {},
-          },
-        ],
-        [
-          {
-            code: "invalid_union",
-            path: ["child"],
-            message: "Invalid input",
-            errors: [
-              [
-                {
-                  code: "invalid_type",
-                  expected: "string",
-                  path: [],
-                  message: "Expected string",
-                  input: true,
-                },
-              ],
-              [
-                {
-                  code: "invalid_type",
-                  expected: "number",
-                  path: [],
-                  message: "Expected number",
-                  input: true,
-                },
-              ],
-            ],
-          },
-        ],
-      ],
-    },
-  ] as any);
-
-  const tree: any = z.treeifyError(syntheticError);
-
-  // "child" must be nested under "parent", not at root
-  expect(tree.properties).not.toHaveProperty("child");
-  expect(tree.properties).toHaveProperty("parent");
-  expect(tree.properties.parent.properties).toHaveProperty("child");
-  expect(tree.properties.parent.properties.child.errors).toContain("Expected string");
-  expect(tree.properties.parent.properties.child.errors).toContain("Expected number");
-  expect(tree.properties.parent.errors).toContain("Expected string");
-});
-
-test("z.treeifyError deeply nested union (4 levels) preserves full path", () => {
-  // a > b > c > d — each level wrapped in an invalid_union
-  const syntheticError = new z.ZodError([
-    {
-      code: "invalid_union",
-      path: ["a"],
-      message: "Invalid input",
-      errors: [
-        [
-          {
-            code: "invalid_union",
-            path: ["b"],
-            message: "Invalid input",
-            errors: [
-              [
-                {
-                  code: "invalid_union",
-                  path: ["c"],
-                  message: "Invalid input",
-                  errors: [
-                    [
-                      {
-                        code: "invalid_type",
-                        expected: "string",
-                        path: ["d"],
-                        message: "Expected string",
-                        input: 123,
-                      },
-                    ],
-                  ],
-                },
-              ],
-            ],
-          },
-        ],
-      ],
-    },
-  ] as any);
-
-  const tree: any = z.treeifyError(syntheticError);
-
-  // The full path must be preserved: a.b.c.d
-  expect(tree.properties).toHaveProperty("a");
-  expect(tree.properties).not.toHaveProperty("b");
-  expect(tree.properties).not.toHaveProperty("c");
-
-  const lvlA = tree.properties.a;
-  expect(lvlA.properties).toHaveProperty("b");
-
-  const lvlB = lvlA.properties.b;
-  expect(lvlB.properties).toHaveProperty("c");
-
-  const lvlC = lvlB.properties.c;
-  expect(lvlC.properties).toHaveProperty("d");
-  expect(lvlC.properties.d.errors).toContain("Expected string");
-});
-
-test("z.treeifyError nested union with real schema", () => {
-  const innerUnion = z.union([
-    z.object({ type: z.literal("a"), value: z.string() }),
-    z.object({ type: z.literal("b"), value: z.number() }),
-  ]);
-
-  const schema = z.string().or(
-    z.object({
-      settings: z.object({ name: z.string() }).and(innerUnion),
-    })
-  );
-
-  const result = schema.safeParse({
-    settings: { name: 123, type: "x", value: true },
-  });
-
-  expect(result.success).toBe(false);
-  if (!result.success) {
-    const tree: any = z.treeifyError(result.error);
-
-    // All settings-related errors should be under "settings", not at root
-    expect(tree.properties).toHaveProperty("settings");
-    const settingsProperties = tree.properties.settings.properties ?? {};
-    for (const key of Object.keys(settingsProperties)) {
-      // Every sub-property under settings should NOT also appear at root
-      if (key !== "settings") {
-        expect(tree.properties).not.toHaveProperty(key);
-      }
-    }
-  }
-});