@vellumai/cli 0.10.5 → 0.10.6-dev.202607062124.26c976d

package/node_modules/@vellumai/local-mode/node_modules/zod/src/v4/classic/tests/tuple.test.ts

@@ -0,0 +1,183 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("successful validation", () => {
+  const testTuple = z.tuple([z.string(), z.number()]);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = testTuple.parse(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = testTuple.safeParse(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
+  `);
+
+  const r2 = testTuple.safeParse(["asdf", 1234, true]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "too_big",
+        "maximum": 2,
+        "inclusive": true,
+        "origin": "array",
+        "path": [],
+        "message": "Too big: expected array to have <=2 items"
+      }
+    ]]
+  `);
+
+  const r3 = testTuple.safeParse({});
+  expect(r3.success).toEqual(false);
+  expect(r3.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
+  `);
+});
+
+test("async validation", async () => {
+  const testTuple = z
+    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
+    .refine(async () => true);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = await testTuple.parseAsync(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
+  `);
+
+  const r2 = await testTuple.safeParseAsync(["asdf", 1234, true]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "too_big",
+        "maximum": 2,
+        "inclusive": true,
+        "origin": "array",
+        "path": [],
+        "message": "Too big: expected array to have <=2 items"
+      }
+    ]]
+  `);
+
+  const r3 = await testTuple.safeParseAsync({});
+  expect(r3.success).toEqual(false);
+  expect(r3.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
+  `);
+});
+
+test("tuple with optional elements", () => {
+  const myTuple = z.tuple([z.string(), z.number().optional(), z.string().optional()]).rest(z.boolean());
+  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number?, string?, ...boolean[]]>();
+
+  const goodData = [["asdf"], ["asdf", 1234], ["asdf", 1234, "asdf"], ["asdf", 1234, "asdf", true, false, true]];
+  for (const data of goodData) {
+    expect(myTuple.parse(data)).toEqual(data);
+  }
+
+  const badData = [
+    ["asdf", "asdf"],
+    ["asdf", 1234, "asdf", "asdf"],
+    ["asdf", 1234, "asdf", true, false, "asdf"],
+  ];
+  for (const data of badData) {
+    expect(() => myTuple.parse(data)).toThrow();
+  }
+});
+
+test("tuple with optional elements followed by required", () => {
+  const myTuple = z.tuple([z.string(), z.number().optional(), z.string()]).rest(z.boolean());
+  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number | undefined, string, ...boolean[]]>();
+
+  const goodData = [
+    ["asdf", 1234, "asdf"],
+    ["asdf", 1234, "asdf", true, false, true],
+  ];
+  for (const data of goodData) {
+    expect(myTuple.parse(data)).toEqual(data);
+  }
+
+  const badData = [
+    ["asdf"],
+    ["asdf", 1234],
+    ["asdf", 1234, "asdf", "asdf"],
+    ["asdf", 1234, "asdf", true, false, "asdf"],
+  ];
+  for (const data of badData) {
+    expect(() => myTuple.parse(data)).toThrow();
+  }
+});
+
+test("tuple with all optional elements", () => {
+  const allOptionalTuple = z.tuple([z.string().optional(), z.number().optional(), z.boolean().optional()]);
+  expectTypeOf<typeof allOptionalTuple._output>().toEqualTypeOf<[string?, number?, boolean?]>();
+
+  // Empty array should be valid (all items optional)
+  expect(allOptionalTuple.parse([])).toEqual([]);
+
+  // Partial arrays should be valid
+  expect(allOptionalTuple.parse(["hello"])).toEqual(["hello"]);
+  expect(allOptionalTuple.parse(["hello", 42])).toEqual(["hello", 42]);
+
+  // Full array should be valid
+  expect(allOptionalTuple.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
+
+  // Array that's too long should fail
+  expect(() => allOptionalTuple.parse(["hello", 42, true, "extra"])).toThrow();
+});
+
+test("tuple with rest schema", () => {
+  const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
+  expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
+
+  expect(myTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
+
+  expect(() => myTuple.parse(["asdf", 1234, "asdf"])).toThrow();
+  type t1 = z.output<typeof myTuple>;
+
+  expectTypeOf<t1>().toEqualTypeOf<[string, number, ...boolean[]]>();
+});
+
+test("sparse array input", () => {
+  const schema = z.tuple([z.string(), z.number()]);
+  expect(() => schema.parse(new Array(2))).toThrow();
+});

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

@@ -217,57 +217,3 @@ test("z.xor() type inference", () => {
   type Result = z.infer<typeof schema>;
   expectTypeOf<Result>().toEqualTypeOf<string | number | boolean>();
 });
-
-test("z.union([]) constructs and rejects all input", () => {
-  const schema = z.union([]);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<never>();
-  const result = schema.safeParse("anything");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_union",
-          "errors": [],
-          "message": "Invalid input",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("z.xor([]) constructs and rejects all input", () => {
-  const schema = z.xor([]);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<never>();
-  const result = schema.safeParse("anything");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_union",
-          "errors": [],
-          "message": "Invalid input",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("z.discriminatedUnion with empty options constructs and rejects", () => {
-  const schema = z.discriminatedUnion("type", [] as any);
-  const nonObject = schema.safeParse("nope");
-  expect(nonObject.success).toEqual(false);
-  if (!nonObject.success) {
-    expect(nonObject.error.issues[0].code).toBe("invalid_type");
-  }
-  const obj = schema.safeParse({ type: "x" });
-  expect(obj.success).toEqual(false);
-  if (!obj.success) {
-    expect(obj.error.issues[0].code).toBe("invalid_union");
-    expect((obj.error.issues[0] as any).errors).toEqual([]);
-    expect((obj.error.issues[0] as any).options).toEqual([]);
-  }
-});

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/api.ts

@@ -246,23 +246,8 @@ export function _nanoid<T extends schemas.$ZodNanoID>(
 }
 
 // CUID
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link _cuid2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link _cuid2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link _cuid2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
 // @__NO_SIDE_EFFECTS__
 export function _cuid<T extends schemas.$ZodCUID>(
   Class: util.SchemaClass<T>,
@@ -1207,19 +1192,17 @@ export function _xor<const T extends readonly schemas.$ZodObject[]>(
 }
 
 // ZodDiscriminatedUnion
-export interface $ZodTypeDiscriminableInternals<Disc extends string = string>
-  extends schemas.$ZodTypeInternals<unknown, { [K in Disc]?: unknown }> {
+export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
   propValues: util.PropValues;
 }
 
-export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
-  _zod: $ZodTypeDiscriminableInternals<Disc>;
+export interface $ZodTypeDiscriminable extends schemas.$ZodType {
+  _zod: $ZodTypeDiscriminableInternals;
 }
-
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
 // @__NO_SIDE_EFFECTS__
 export function _discriminatedUnion<
-  Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]],
+  Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]],
   Disc extends string,
 >(
   Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>,
@@ -1650,16 +1633,8 @@ export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
   addIssue(arg: string | $ZodSuperRefineIssue): void;
 }
 
-export interface $ZodSuperRefineParams {
-  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
-  when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
-}
-
 // @__NO_SIDE_EFFECTS__
-export function _superRefine<T>(
-  fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>,
-  params?: $ZodSuperRefineParams
-): checks.$ZodCheck<T> {
+export function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T> {
   const ch = _check<T>((payload) => {
     (payload as $RefinementCtx).addIssue = (issue) => {
       if (typeof issue === "string") {
@@ -1677,7 +1652,7 @@ export function _superRefine<T>(
     };
 
     return fn(payload.value, payload as $RefinementCtx<T>);
-  }, params);
+  });
   return ch;
 }
 

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/checks.ts

@@ -13,7 +13,7 @@ export interface $ZodCheckDef {
   error?: errors.$ZodErrorMap<never> | undefined;
   /** If true, no later checks will be executed if this check fails. Default `false`. */
   abort?: boolean | undefined;
-  /** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
   when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/core.ts

@@ -10,7 +10,7 @@ export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
 }
 
 /** A special constant with type `never` */
-export const NEVER: never = /*@__PURE__*/ Object.freeze({
+export const NEVER: never = Object.freeze({
   status: "aborted",
 }) as never;
 
@@ -130,22 +130,7 @@ export interface $ZodConfig {
   jitless?: boolean | undefined;
 }
 
-interface GlobalThisWithConfig {
-  /**
-   * The globalConfig instance shared across both CommonJS and ESM builds.
-   * Attached to `globalThis` (mirroring `__zod_globalRegistry`) so that a
-   * single config object is used regardless of how Zod is loaded — CJS,
-   * ESM, multiple bundles in a monorepo, etc. This means `z.config(...)`
-   * applied against any one instance is observed by all of them, and
-   * pre-populating it before Zod loads (e.g. `globalThis.__zod_globalConfig
-   * = { jitless: true }` in an inline script) takes effect immediately on
-   * import.
-   */
-  __zod_globalConfig?: $ZodConfig;
-}
-
-(globalThis as GlobalThisWithConfig).__zod_globalConfig ??= {};
-export const globalConfig: $ZodConfig = (globalThis as GlobalThisWithConfig).__zod_globalConfig!;
+export const globalConfig: $ZodConfig = {};
 
 export function config(newConfig?: Partial<$ZodConfig>): $ZodConfig {
   if (newConfig) Object.assign(globalConfig, newConfig);

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/errors.ts

@@ -91,7 +91,6 @@ interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
   readonly errors: $ZodIssue[][];
   readonly input?: unknown;
   readonly discriminator?: string | undefined;
-  readonly options?: util.Primitive[];
   readonly inclusive?: true;
 }
 
@@ -292,35 +291,32 @@ export function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
 export function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
 export function formatError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIssue) => issue.message as U) {
   const fieldErrors: $ZodFormattedError<T> = { _errors: [] } as any;
-  const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
+  const processError = (error: { issues: $ZodIssue[] }) => {
     for (const issue of error.issues) {
       if (issue.code === "invalid_union" && issue.errors.length) {
-        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+        issue.errors.map((issues) => processError({ issues }));
       } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
+        processError({ issues: issue.issues });
       } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
+        processError({ issues: issue.issues });
+      } else if (issue.path.length === 0) {
+        (fieldErrors as any)._errors.push(mapper(issue));
       } else {
-        const fullpath = [...path, ...issue.path];
-        if (fullpath.length === 0) {
-          (fieldErrors as any)._errors.push(mapper(issue));
-        } else {
-          let curr: any = fieldErrors;
-          let i = 0;
-          while (i < fullpath.length) {
-            const el = fullpath[i]!;
-            const terminal = i === fullpath.length - 1;
-
-            if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
-            } else {
-              curr[el] = curr[el] || { _errors: [] };
-              curr[el]._errors.push(mapper(issue));
-            }
-
-            curr = curr[el];
-            i++;
+        let curr: any = fieldErrors;
+        let i = 0;
+        while (i < issue.path.length) {
+          const el = issue.path[i]!;
+          const terminal = i === issue.path.length - 1;
+
+          if (!terminal) {
+            curr[el] = curr[el] || { _errors: [] };
+          } else {
+            curr[el] = curr[el] || { _errors: [] };
+            curr[el]._errors.push(mapper(issue));
           }
+
+          curr = curr[el];
+          i++;
         }
       }
     }
@@ -336,10 +332,7 @@ export type $ZodErrorTree<T, U = string> = T extends util.Primitive
     : T extends any[]
       ? { errors: U[]; items?: Array<$ZodErrorTree<T[number], U>> }
       : T extends object
-        ? {
-            errors: U[];
-            properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> };
-          }
+        ? { errors: U[]; properties?: { [K in keyof T]?: $ZodErrorTree<T[K], U> } }
         : { errors: U[] };
 
 export function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
@@ -350,11 +343,11 @@ export function treeifyError<T, U>(error: $ZodError<T>, mapper = (issue: $ZodIss
     for (const issue of error.issues) {
       if (issue.code === "invalid_union" && issue.errors.length) {
         // regular union error
-        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+        issue.errors.map((issues) => processError({ issues }, issue.path));
       } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
+        processError({ issues: issue.issues }, issue.path);
       } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
+        processError({ issues: issue.issues }, issue.path);
       } else {
         const fullpath = [...path, ...issue.path];
         if (fullpath.length === 0) {

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/json-schema-processors.ts

@@ -65,31 +65,36 @@ export const numberProcessor: Processor<schemas.$ZodNumber> = (schema, ctx, _jso
   if (typeof format === "string" && format.includes("int")) json.type = "integer";
   else json.type = "number";
 
-  // when both minimum and exclusiveMinimum exist, pick the more restrictive one
-  const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
-  const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
-  const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
-
-  if (exMin) {
-    if (legacy) {
+  if (typeof exclusiveMinimum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
       json.minimum = exclusiveMinimum;
       json.exclusiveMinimum = true;
     } else {
       json.exclusiveMinimum = exclusiveMinimum;
     }
-  } else if (typeof minimum === "number") {
+  }
+  if (typeof minimum === "number") {
     json.minimum = minimum;
+    if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMinimum >= minimum) delete json.minimum;
+      else delete json.exclusiveMinimum;
+    }
   }
 
-  if (exMax) {
-    if (legacy) {
+  if (typeof exclusiveMaximum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
       json.maximum = exclusiveMaximum;
       json.exclusiveMaximum = true;
     } else {
       json.exclusiveMaximum = exclusiveMaximum;
     }
-  } else if (typeof maximum === "number") {
+  }
+  if (typeof maximum === "number") {
     json.maximum = maximum;
+    if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMaximum <= maximum) delete json.maximum;
+      else delete json.exclusiveMaximum;
+    }
   }
 
   if (typeof multipleOf === "number") json.multipleOf = multipleOf;
@@ -281,10 +286,7 @@ export const arrayProcessor: Processor<schemas.$ZodArray> = (schema, ctx, _json,
   if (typeof maximum === "number") json.maxItems = maximum;
 
   json.type = "array";
-  json.items = process(def.element, ctx as any, {
-    ...params,
-    path: [...params.path, "items"],
-  });
+  json.items = process(def.element, ctx as any, { ...params, path: [...params.path, "items"] });
 };
 
 export const objectProcessor: Processor<schemas.$ZodObject> = (schema, ctx, _json, params) => {
@@ -525,8 +527,7 @@ export const catchProcessor: Processor<schemas.$ZodCatch> = (schema, ctx, json,
 
 export const pipeProcessor: Processor<schemas.$ZodPipe> = (schema, ctx, _json, params) => {
   const def = schema._zod.def as schemas.$ZodPipeDef;
-  const inIsTransform = def.in._zod.traits.has("$ZodTransform");
-  const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
+  const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
   process(innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = innerType;

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/parse.ts

@@ -14,7 +14,7 @@ export type $Parse = <T extends schemas.$ZodType>(
 ) => core.output<T>;
 
 export const _parse: (_Err: $ZodErrorClass) => $Parse = (_Err) => (schema, value, _ctx, _params) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: false } : { async: false };
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new core.$ZodAsyncError();
@@ -37,7 +37,7 @@ export type $ParseAsync = <T extends schemas.$ZodType>(
 ) => Promise<core.output<T>>;
 
 export const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync = (_Err) => async (schema, value, _ctx, params) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: true } : { async: true };
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) result = await result;
   if (result.issues.length) {
@@ -79,7 +79,7 @@ export type $SafeParseAsync = <T extends schemas.$ZodType>(
 ) => Promise<util.SafeParseResult<core.output<T>>>;
 
 export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: true } : { async: true };
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) result = await result;
 
@@ -101,7 +101,7 @@ export type $Encode = <T extends schemas.$ZodType>(
 ) => core.input<T>;
 
 export const _encode: (_Err: $ZodErrorClass) => $Encode = (_Err) => (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" as const } : { direction: "backward" as const };
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
   return _parse(_Err)(schema, value, ctx as any) as any;
 };
 
@@ -126,7 +126,7 @@ export type $EncodeAsync = <T extends schemas.$ZodType>(
 ) => Promise<core.input<T>>;
 
 export const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" as const } : { direction: "backward" as const };
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
   return _parseAsync(_Err)(schema, value, ctx as any) as any;
 };
 
@@ -151,7 +151,7 @@ export type $SafeEncode = <T extends schemas.$ZodType>(
 ) => util.SafeParseResult<core.input<T>>;
 
 export const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode = (_Err) => (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" as const } : { direction: "backward" as const };
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
   return _safeParse(_Err)(schema, value, ctx as any) as any;
 };
 
@@ -176,7 +176,7 @@ export type $SafeEncodeAsync = <T extends schemas.$ZodType>(
 ) => Promise<util.SafeParseResult<core.input<T>>>;
 
 export const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" as const } : { direction: "backward" as const };
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
   return _safeParseAsync(_Err)(schema, value, ctx as any) as any;
 };
 

package/node_modules/{zod → @vellumai/local-mode/node_modules/zod}/src/v4/core/regexes.ts

@@ -1,11 +1,6 @@
 import * as util from "./util.js";
 
-/**
- * @deprecated CUID v1 is deprecated by its authors due to information leakage
- * (timestamps embedded in the id). Use {@link cuid2} instead.
- * See https://github.com/paralleldrive/cuid.
- */
-export const cuid: RegExp = /^[cC][0-9a-z]{6,}$/;
+export const cuid: RegExp = /^[cC][^\s-]{8,}$/;
 export const cuid2: RegExp = /^[0-9a-z]+$/;
 export const ulid: RegExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
 export const xid: RegExp = /^[0-9a-vA-V]{20}$/;
@@ -86,8 +81,6 @@ export const hostname: RegExp =
 
 export const domain: RegExp = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 
-export const httpProtocol: RegExp = /^https?$/;
-
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
 // E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
 export const e164: RegExp = /^\+[1-9]\d{6,14}$/;