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

package/node_modules/zod/src/v4/classic/tests/detached-methods.test.ts

@@ -1,197 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-/**
- * Schema methods are exposed in a way that works when detached from the
- * schema instance — `const opt = schema.optional; opt()` must produce a
- * working `ZodOptional`, not a corrupt one. This pattern is used in real
- * code (e.g. `arr.map(schema.parse)`, `arr.map(schema.optional)`,
- * destructuring inside utility functions).
- *
- * This test caught a regression in colinhacks/zod#5870 where a memory
- * optimization moved methods to the prototype and made `this`-binding
- * required, silently breaking any detached usage.
- */
-
-const probeArgs: Record<string, unknown[]> = {
-  // ZodType
-  optional: [],
-  exactOptional: [],
-  nullable: [],
-  nullish: [],
-  array: [],
-  describe: ["x"],
-  brand: [],
-  readonly: [],
-  default: ["fallback"],
-  catch: ["fallback"],
-  // _ZodString
-  min: [1],
-  max: [10],
-  length: [5],
-  nonempty: [],
-  trim: [],
-  toLowerCase: [],
-  toUpperCase: [],
-  // ZodString format methods
-  email: [],
-  url: [],
-  uuid: [],
-  cuid: [],
-  cuid2: [],
-  ulid: [],
-  base64: [],
-  base64url: [],
-  ipv4: [],
-  ipv6: [],
-  // ZodNumber
-  int: [],
-  positive: [],
-  negative: [],
-  finite: [],
-};
-
-test("detached parse-family methods work without `this` binding", () => {
-  const schema = z.string();
-  const { parse, safeParse } = schema;
-
-  expect(parse("hello")).toBe("hello");
-  expect(safeParse("hello").success).toBe(true);
-});
-
-test("detached schema.optional() returns a working ZodOptional", () => {
-  const schema = z.string();
-  const opt = schema.optional;
-
-  const detached = opt();
-
-  expect(detached).toBeInstanceOf(z.ZodOptional);
-  expect(detached.safeParse("hello").success).toBe(true);
-  expect(detached.safeParse(undefined).success).toBe(true);
-  expect(detached.safeParse(123).success).toBe(false);
-});
-
-test("detached schema.nullable() returns a working ZodNullable", () => {
-  const schema = z.string();
-  const nul = schema.nullable;
-
-  const detached = nul();
-
-  expect(detached).toBeInstanceOf(z.ZodNullable);
-  expect(detached.safeParse("hello").success).toBe(true);
-  expect(detached.safeParse(null).success).toBe(true);
-  expect(detached.safeParse(123).success).toBe(false);
-});
-
-test("detached schema.array() returns a working ZodArray", () => {
-  const schema = z.string();
-  const arr = schema.array;
-
-  const detached = arr();
-
-  expect(detached).toBeInstanceOf(z.ZodArray);
-  expect(detached.safeParse(["a", "b"]).success).toBe(true);
-  expect(detached.safeParse([1, 2]).success).toBe(false);
-});
-
-test("detached schema.describe() returns a described schema", () => {
-  const schema = z.string();
-  const describe = schema.describe;
-
-  const described = describe("hello world");
-
-  expect(described.description).toBe("hello world");
-});
-
-test("detached refinement still validates", () => {
-  const schema = z.string();
-  const refine = schema.refine;
-
-  const refined = refine((s: string) => s.startsWith("x"), "must start with x");
-
-  expect(refined.safeParse("xhello").success).toBe(true);
-  expect(refined.safeParse("hello").success).toBe(false);
-});
-
-test("detached chained calls work — schema.optional then parse", () => {
-  const schema = z.string();
-  const opt = schema.optional;
-  const optionalSchema = opt();
-  const { parse } = optionalSchema;
-
-  expect(parse("hi")).toBe("hi");
-  expect(parse(undefined)).toBe(undefined);
-});
-
-test("detached parse can be called as a free function", () => {
-  const schema = z.string();
-  const parse = schema.parse;
-  const inputs = ["a", "b", "c"];
-
-  const results = inputs.map((v) => parse(v));
-
-  expect(results).toEqual(["a", "b", "c"]);
-});
-
-test("detached methods on z.number() work", () => {
-  const schema = z.number();
-
-  const min = schema.min;
-  const max = schema.max;
-  const positive = schema.positive;
-
-  expect(min(5).safeParse(3).success).toBe(false);
-  expect(max(5).safeParse(7).success).toBe(false);
-  expect(positive().safeParse(-1).success).toBe(false);
-});
-
-test("detached object methods work", () => {
-  const schema = z.object({ a: z.string(), b: z.number() });
-
-  const pick = schema.pick;
-  const omit = schema.omit;
-  const partial = schema.partial;
-  const extend = schema.extend;
-
-  expect(Object.keys(pick({ a: true })._zod.def.shape)).toEqual(["a"]);
-  expect(Object.keys(omit({ a: true })._zod.def.shape)).toEqual(["b"]);
-  expect(partial().safeParse({}).success).toBe(true);
-  const extended = extend({ c: z.boolean() });
-  expect(Object.keys(extended._zod.def.shape).sort()).toEqual(["a", "b", "c"]);
-});
-
-// Sweep across many builder methods at once. If any of them break with the
-// `const m = schema.foo; m(...)` pattern, this test will report which.
-test("broad sweep: detaching builder methods does not throw or produce a corrupt schema", () => {
-  const stringSchema = z.string();
-  const numberSchema = z.number();
-
-  const broken: Array<{ method: string; reason: string }> = [];
-
-  for (const [methodName, args] of Object.entries(probeArgs)) {
-    const target: any = methodName in stringSchema ? stringSchema : methodName in numberSchema ? numberSchema : null;
-    if (!target) continue;
-
-    const detached = target[methodName] as Function | undefined;
-    if (typeof detached !== "function") continue;
-
-    try {
-      const result = detached(...args);
-      // If the detached call returned a schema, sanity-check it parses
-      // its base type. (e.g. `optional()` should accept its inner type.)
-      if (result && typeof result === "object" && "_zod" in result && typeof (result as any).safeParse === "function") {
-        const probeValue = target === stringSchema ? "x" : 1;
-        const r = (result as any).safeParse(probeValue);
-        // success or a clean failure are both fine — we only fail on throw or
-        // on a schema with corrupt internal state (innerType undefined etc).
-        if (r === undefined || (typeof r === "object" && !("success" in r))) {
-          broken.push({ method: methodName, reason: "safeParse returned malformed result" });
-        }
-      }
-    } catch (err: any) {
-      broken.push({ method: methodName, reason: err?.message ?? String(err) });
-    }
-  }
-
-  expect(broken).toEqual([]);
-});

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

@@ -1,39 +0,0 @@
-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/zod/src/v4/classic/tests/jitless-allows-eval.test.ts

@@ -1,46 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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/zod/src/v4/classic/tests/preprocess-types.test.ts

@@ -1,26 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("ZodPreprocess<B> assignable to ZodPipe<$ZodTransform, B>", () => {
-  const pre = z.preprocess((v) => v, z.string().optional());
-  const _asPipe: z.ZodPipe<z.core.$ZodTransform, z.ZodOptional<z.ZodString>> = pre;
-  const _asCorePipe: z.core.$ZodPipe<z.core.$ZodTransform, z.ZodOptional<z.ZodString>> = pre;
-  expectTypeOf(_asPipe).toMatchTypeOf<z.ZodPipe>();
-  expectTypeOf(_asCorePipe).toMatchTypeOf<z.core.$ZodPipe>();
-});
-
-test("ZodPreprocess optin/optout defer to B", () => {
-  const optionalInside = z.preprocess((v) => v, z.string().optional());
-  expectTypeOf<(typeof optionalInside)["_zod"]["optin"]>().toEqualTypeOf<"optional">();
-  expectTypeOf<(typeof optionalInside)["_zod"]["optout"]>().toEqualTypeOf<"optional">();
-
-  const required = z.preprocess((v) => v, z.string());
-  expectTypeOf<(typeof required)["_zod"]["optin"]>().toEqualTypeOf<"optional" | undefined>();
-  expectTypeOf<(typeof required)["_zod"]["optout"]>().toEqualTypeOf<"optional" | undefined>();
-});
-
-test("ZodPreprocess input/output inference", () => {
-  const pre = z.preprocess((v) => v, z.number().optional());
-  expectTypeOf<z.output<typeof pre>>().toEqualTypeOf<number | undefined>();
-  expectTypeOf<z.input<typeof pre>>().toEqualTypeOf<unknown>();
-});