@vellumai/cli 0.10.6-dev.202607072040.fb971ce → 0.10.6-staging.1

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

@@ -80,7 +80,10 @@ 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: {
@@ -160,7 +163,10 @@ 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[] };
@@ -593,3 +599,209 @@ 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);
+      }
+    }
+  }
+});

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

@@ -732,3 +732,164 @@ 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/{@vellumai/local-mode/node_modules/zod → zod}/src/v4/classic/tests/function.test.ts

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

package/node_modules/zod/src/v4/classic/tests/global-config.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, expect, test } from "vitest";
+import * as z from "zod/v4";
+import * as core from "zod/v4/core";
+
+// `globalConfig` is attached to `globalThis.__zod_globalConfig` so that a
+// single config object is shared across CJS/ESM builds and across multiple
+// bundled copies of Zod in a monorepo. This mirrors the existing
+// `globalRegistry` -> `globalThis.__zod_globalRegistry` treatment.
+//
+// See #5789 for the footgun this fixes: users with both CJS and ESM
+// instances of Zod loaded had to call `z.config({ jitless: true })`
+// twice — once per instance — because each module-scope `globalConfig`
+// was a different object. With this change, one call updates state seen
+// by every loaded copy.
+
+afterEach(() => {
+  // Don't leak config mutations into other test files.
+  delete core.globalConfig.jitless;
+});
+
+test("globalConfig is singleton and attached to globalThis", () => {
+  expect(core.globalConfig).toBe((globalThis as any).__zod_globalConfig);
+});
+
+test("z.config writes are observed via globalThis.__zod_globalConfig", () => {
+  z.config({ jitless: true });
+  expect((globalThis as any).__zod_globalConfig.jitless).toBe(true);
+});
+
+test("pre-set globalThis.__zod_globalConfig is preserved on import", () => {
+  // Object identity is preserved across reloads of the module: anyone who
+  // pre-populates `globalThis.__zod_globalConfig` before Zod loads (e.g.
+  // an inline script before the bundle) keeps that exact object as the
+  // source of truth. Mutating it directly is equivalent to z.config().
+  const direct = (globalThis as any).__zod_globalConfig;
+  direct.jitless = true;
+  expect(core.globalConfig.jitless).toBe(true);
+  expect(z.config()).toBe(core.globalConfig);
+});

package/node_modules/{@vellumai/local-mode/node_modules/zod → 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?, ...boolean[]]>();
+  expectTypeOf<b>().toEqualTypeOf<[string, number, (string | undefined)?, ...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?, ...boolean[]]>();
+  expectTypeOf<c>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
   // type c = z.output<typeof c>;
 });
 

package/node_modules/zod/src/v4/classic/tests/jitless-allows-eval.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+import * as core from "zod/v4/core";
+
+const { allowsEval } = core.util;
+
+// Regression test for the CSP feature-probe issue (#4461, #5414):
+// `allowsEval` used to always invoke `new Function("")` even when the
+// user had opted into `z.config({ jitless: true })`, producing a
+// `securitypolicyviolation` report on strict-CSP pages (no 'unsafe-eval')
+// that Chrome DevTools surfaces as an Issue.
+//
+// The fix: when `globalConfig.jitless` is true, `allowsEval.value`
+// returns `false` without triggering the probe. This test lives in its
+// own file because vitest isolates ESM graphs per file, so the cached
+// `allowsEval.value` is fresh and is never accessed before the config
+// mutation below.
+
+test("globalConfig.jitless=true short-circuits the allowsEval probe", () => {
+  // Set BEFORE first access to allowsEval.value — the getter is memoised
+  // via `cached()`, so the contract is "configure at app entry".
+  z.config({ jitless: true });
+
+  // Sanity: config is wired
+  expect(core.globalConfig.jitless).toBe(true);
+
+  // Spy: if the probe were still attempted, `new Function("")` would be
+  // called. Swap the global `Function` constructor with a throwing stub
+  // and verify the stub is NEVER invoked.
+  const origFunction = globalThis.Function;
+  let probeAttempted = false;
+  // @ts-expect-error assigning a stub to the Function global for the test
+  globalThis.Function = function StubFunction(..._args: unknown[]): never {
+    probeAttempted = true;
+    throw new Error("allowsEval probe should have been skipped under jitless=true");
+  };
+
+  try {
+    expect(allowsEval.value).toBe(false);
+    expect(probeAttempted).toBe(false);
+  } finally {
+    globalThis.Function = origFunction;
+    // Restore config so other test files in the same worker see default
+    delete core.globalConfig.jitless;
+  }
+});

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

@@ -0,0 +1,29 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("Georgian locale uses 'ველი' instead of 'სტრინგი'", () => {
+  // Save original error map to restore later if needed, though tests are usually isolated or we can reset
+  // const originalErrorMap = z.getErrorMap(); // z.getErrorMap might not exist, but let's assume isolation or just set it
+
+  z.setErrorMap(z.locales.ka().localeError);
+
+  // Test 1: Invalid type (Expected string, received number)
+  const stringSchema = z.string();
+  const numberResult = stringSchema.safeParse(123);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    // Expected: "არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი"
+    expect(numberResult.error.issues[0].message).toBe("არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი");
+  }
+
+  // Test 2: Invalid base64
+  const base64Schema = z.string().base64();
+  const base64Result = base64Schema.safeParse("not base64!");
+  expect(base64Result.success).toBe(false);
+  if (!base64Result.success) {
+    // Expected: "არასწორი base64-კოდირებული ველი"
+    // "არასწორი ${FormatDictionary[_issue.format] ?? issue.format}"
+    // FormatDictionary['base64'] is "base64-კოდირებული ველი"
+    expect(base64Result.error.issues[0].message).toBe("არასწორი base64-კოდირებული ველი");
+  }
+});

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

@@ -0,0 +1,24 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("Romanian locale uses 'șir' instead of 'string'", () => {
+  z.setErrorMap(z.locales.ro().localeError);
+
+  // Test 1: Invalid type (Expected string, received number)
+  const stringSchema = z.string();
+  const numberResult = stringSchema.safeParse(123);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    // Expected: "Intrare invalidă: așteptat șir, primit număr"
+    expect(numberResult.error.issues[0].message).toBe("Intrare invalidă: așteptat șir, primit număr");
+  }
+
+  // Test 2: Invalid base64
+  const base64Schema = z.string().base64();
+  const base64Result = base64Schema.safeParse("not base64!");
+  expect(base64Result.success).toBe(false);
+  if (!base64Result.success) {
+    // Expected: "Format invalid: șir codat base64"
+    expect(base64Result.error.issues[0].message).toBe("Format invalid: șir codat base64");
+  }
+});

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

@@ -153,6 +153,36 @@ 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);
@@ -264,6 +294,31 @@ 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() });