clawdlets 0.3.3 → 0.4.0

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

@@ -1,302 +0,0 @@
-import { checkSync } from "recheck";
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("basic datetime parsing", () => {
-  const datetime = z.string().datetime();
-  datetime.parse("1970-01-01T00:00:00.000Z");
-  datetime.parse("2022-10-13T09:52:31.816Z");
-  datetime.parse("2022-10-13T09:52:31.8162314Z");
-  datetime.parse("1970-01-01T00:00:00Z");
-  datetime.parse("2022-10-13T09:52:31Z");
-  expect(() => datetime.parse("")).toThrow();
-  expect(() => datetime.parse("foo")).toThrow();
-  expect(() => datetime.parse("2020-10-14")).toThrow();
-  expect(() => datetime.parse("T18:45:12.123")).toThrow();
-  expect(() => datetime.parse("2020-10-14T17:42:29+00:00")).toThrow();
-});
-
-test("datetime parsing with precision -1", () => {
-  const datetimeNoMs = z.string().datetime({ precision: -1, offset: true, local: true });
-  datetimeNoMs.parse("1970-01-01T00:00Z");
-  datetimeNoMs.parse("2022-10-13T09:52Z");
-  datetimeNoMs.parse("2022-10-13T09:52+02:00");
-
-  datetimeNoMs.parse("2022-10-13T09:52");
-  expect(() => datetimeNoMs.parse("tuna")).toThrow();
-  expect(() => datetimeNoMs.parse("2022-10-13T09:52+02")).toThrow();
-  expect(() => datetimeNoMs.parse("1970-01-01T00:00:00.000Z")).toThrow();
-  expect(() => datetimeNoMs.parse("1970-01-01T00:00:00.Z")).toThrow();
-  expect(() => datetimeNoMs.parse("2022-10-13T09:52:31.816Z")).toThrow();
-});
-
-test("datetime parsing with precision 0", () => {
-  const datetimeNoMs = z.string().datetime({ precision: 0 });
-  datetimeNoMs.parse("1970-01-01T00:00:00Z");
-  datetimeNoMs.parse("2022-10-13T09:52:31Z");
-  expect(() => datetimeNoMs.parse("tuna")).toThrow();
-  expect(() => datetimeNoMs.parse("1970-01-01T00:00:00.000Z")).toThrow();
-  expect(() => datetimeNoMs.parse("1970-01-01T00:00:00.Z")).toThrow();
-  expect(() => datetimeNoMs.parse("2022-10-13T09:52:31.816Z")).toThrow();
-});
-
-test("datetime parsing with precision 3", () => {
-  const datetime3Ms = z.string().datetime({ precision: 3 });
-  datetime3Ms.parse("1970-01-01T00:00:00.000Z");
-  datetime3Ms.parse("2022-10-13T09:52:31.123Z");
-  expect(() => datetime3Ms.parse("tuna")).toThrow();
-  expect(() => datetime3Ms.parse("1970-01-01T00:00:00.1Z")).toThrow();
-  expect(() => datetime3Ms.parse("1970-01-01T00:00:00.12Z")).toThrow();
-  expect(() => datetime3Ms.parse("2022-10-13T09:52:31Z")).toThrow();
-});
-
-test("datetime parsing with offset", () => {
-  const datetimeOffset = z.string().datetime({ offset: true });
-  datetimeOffset.parse("1970-01-01T00:00:00.000Z");
-  datetimeOffset.parse("2022-10-13T09:52:31.816234134Z");
-  datetimeOffset.parse("1970-01-01T00:00:00Z");
-  datetimeOffset.parse("2022-10-13T09:52:31.4Z");
-  datetimeOffset.parse("2020-10-14T17:42:29+00:00");
-  datetimeOffset.parse("2020-10-14T17:42:29+03:15");
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+0315")).toThrow();
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+03")).toThrow();
-  expect(() => datetimeOffset.parse("tuna")).toThrow();
-  expect(() => datetimeOffset.parse("2022-10-13T09:52:31.Z")).toThrow();
-
-  // Invalid offset tests
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+24:00")).toThrow(); // out of range hours
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:60")).toThrow(); // out of range minutes
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+1:30")).toThrow(); // single digit hours
-  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:")).toThrow(); // incomplete offset
-});
-
-test("datetime parsing with offset and precision 0", () => {
-  const datetimeOffsetNoMs = z.string().datetime({ offset: true, precision: 0 });
-  datetimeOffsetNoMs.parse("1970-01-01T00:00:00Z");
-  datetimeOffsetNoMs.parse("2022-10-13T09:52:31Z");
-  datetimeOffsetNoMs.parse("2020-10-14T17:42:29+00:00");
-  expect(() => datetimeOffsetNoMs.parse("2020-10-14T17:42:29+0000")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("2020-10-14T17:42:29+00")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("tuna")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("1970-01-01T00:00:00.000Z")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("1970-01-01T00:00:00.Z")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("2022-10-13T09:52:31.816Z")).toThrow();
-  expect(() => datetimeOffsetNoMs.parse("2020-10-14T17:42:29.124+00:00")).toThrow();
-});
-
-test("datetime parsing with offset and precision 4", () => {
-  const datetimeOffset4Ms = z.string().datetime({ offset: true, precision: 4 });
-  datetimeOffset4Ms.parse("1970-01-01T00:00:00.1234Z");
-  datetimeOffset4Ms.parse("2020-10-14T17:42:29.1234+00:00");
-  expect(() => datetimeOffset4Ms.parse("2020-10-14T17:42:29.1234+0000")).toThrow();
-  expect(() => datetimeOffset4Ms.parse("2020-10-14T17:42:29.1234+00")).toThrow();
-  expect(() => datetimeOffset4Ms.parse("tuna")).toThrow();
-  expect(() => datetimeOffset4Ms.parse("1970-01-01T00:00:00.123Z")).toThrow();
-  expect(() => datetimeOffset4Ms.parse("2020-10-14T17:42:29.124+00:00")).toThrow();
-});
-
-test("datetime offset normalization", () => {
-  const a = z.iso.datetime({ offset: true });
-
-  expect(a.safeParse("2020-10-14T17:42:29+02")).toMatchObject({ success: false });
-  expect(a.safeParse("2020-10-14T17:42:29+0200")).toMatchObject({ success: false });
-  a.safeParse("2020-10-14T17:42:29+02:00");
-});
-
-test("datetime parsing with local option", () => {
-  const a = z.string().datetime({ local: true });
-
-  expect(a.safeParse("1970-01-01T00:00")).toMatchObject({ success: true });
-  expect(a.safeParse("1970-01-01T00:00:00")).toMatchObject({ success: true });
-  expect(a.safeParse("2022-10-13T09:52:31.816")).toMatchObject({ success: true });
-  expect(a.safeParse("1970-01-01T00:00:00.000")).toMatchObject({ success: true });
-  expect(a.safeParse("1970-01-01T00")).toMatchObject({ success: false });
-
-  // Should reject timezone indicators and invalid formats
-
-  expect(() => a.parse("2022-10-13T09:52:31+00:00")).toThrow();
-  expect(() => a.parse("2022-10-13 09:52:31")).toThrow();
-  expect(() => a.parse("2022-10-13T24:52:31")).toThrow();
-  expect(() => a.parse("2022-10-13T24:52")).toThrow();
-  expect(() => a.parse("2022-10-13T24:52Z")).toThrow();
-});
-
-test("datetime parsing with local and offset", () => {
-  const a = z.string().datetime({ local: true, offset: true });
-
-  // expect(a.parse("2022-10-13T12:52")).toEqual("2022-10-13T12:52:00");
-  a.parse("2022-10-13T12:52:00");
-  a.parse("2022-10-13T12:52:00Z");
-  a.parse("2022-10-13T12:52Z");
-  a.parse("2022-10-13T12:52");
-  a.parse("2022-10-13T12:52+02:00");
-  expect(() => a.parse("2022-10-13T12:52:00+02")).toThrow();
-  // expect(() => a.parse("2022-10-13T12:52Z")).toThrow();
-  // expect(() => a.parse("2022-10-13T12:52+02:00")).toThrow();
-});
-
-test("date parsing", () => {
-  const date = z.string().date();
-  date.parse("1970-01-01");
-  date.parse("2022-01-31");
-  date.parse("2022-03-31");
-  date.parse("2022-04-30");
-  date.parse("2022-05-31");
-  date.parse("2022-06-30");
-  date.parse("2022-07-31");
-  date.parse("2022-08-31");
-  date.parse("2022-09-30");
-  date.parse("2022-10-31");
-  date.parse("2022-11-30");
-  date.parse("2022-12-31");
-
-  date.parse("2000-02-29");
-  date.parse("2400-02-29");
-  expect(() => date.parse("2022-02-29")).toThrow();
-  expect(() => date.parse("2100-02-29")).toThrow();
-  expect(() => date.parse("2200-02-29")).toThrow();
-  expect(() => date.parse("2300-02-29")).toThrow();
-  expect(() => date.parse("2500-02-29")).toThrow();
-
-  expect(() => date.parse("")).toThrow();
-  expect(() => date.parse("foo")).toThrow();
-  expect(() => date.parse("200-01-01")).toThrow();
-  expect(() => date.parse("20000-01-01")).toThrow();
-  expect(() => date.parse("2000-0-01")).toThrow();
-  expect(() => date.parse("2000-011-01")).toThrow();
-  expect(() => date.parse("2000-01-0")).toThrow();
-  expect(() => date.parse("2000-01-011")).toThrow();
-  expect(() => date.parse("2000/01/01")).toThrow();
-  expect(() => date.parse("01-01-2022")).toThrow();
-  expect(() => date.parse("01/01/2022")).toThrow();
-  expect(() => date.parse("2000-01-01 00:00:00Z")).toThrow();
-  expect(() => date.parse("2020-10-14T17:42:29+00:00")).toThrow();
-  expect(() => date.parse("2020-10-14T17:42:29Z")).toThrow();
-  expect(() => date.parse("2020-10-14T17:42:29")).toThrow();
-  expect(() => date.parse("2020-10-14T17:42:29.123Z")).toThrow();
-
-  expect(() => date.parse("2000-00-12")).toThrow();
-  expect(() => date.parse("2000-12-00")).toThrow();
-  expect(() => date.parse("2000-01-32")).toThrow();
-  expect(() => date.parse("2000-13-01")).toThrow();
-  expect(() => date.parse("2000-21-01")).toThrow();
-
-  expect(() => date.parse("2000-02-30")).toThrow();
-  expect(() => date.parse("2000-02-31")).toThrow();
-  expect(() => date.parse("2000-04-31")).toThrow();
-  expect(() => date.parse("2000-06-31")).toThrow();
-  expect(() => date.parse("2000-09-31")).toThrow();
-  expect(() => date.parse("2000-11-31")).toThrow();
-});
-
-test("time parsing", () => {
-  const time = z.string().time();
-  time.parse("00:00:00");
-  time.parse("23:00:00");
-  time.parse("00:59:00");
-  time.parse("00:00:59");
-  time.parse("23:59:59");
-  time.parse("09:52:31");
-  time.parse("23:59:59.9999999");
-  time.parse("00:00");
-  expect(() => time.parse("")).toThrow();
-  expect(() => time.parse("foo")).toThrow();
-  expect(() => time.parse("00:00:00Z")).toThrow();
-  expect(() => time.parse("0:00:00")).toThrow();
-  expect(() => time.parse("00:0:00")).toThrow();
-  expect(() => time.parse("00:00:0")).toThrow();
-  expect(() => time.parse("00:00:00.000+00:00")).toThrow();
-  expect(() => time.parse("24:00:00")).toThrow();
-  expect(() => time.parse("00:60:00")).toThrow();
-  expect(() => time.parse("00:00:60")).toThrow();
-  expect(() => time.parse("24:60:60")).toThrow();
-
-  const time2 = z.string().time({ precision: 2 });
-  time2.parse("00:00:00.00");
-  time2.parse("09:52:31.12");
-  time2.parse("23:59:59.99");
-  expect(() => time2.parse("")).toThrow();
-  expect(() => time2.parse("foo")).toThrow();
-  expect(() => time2.parse("00:00:00")).toThrow();
-  expect(() => time2.parse("00:00:00.00Z")).toThrow();
-  expect(() => time2.parse("00:00:00.0")).toThrow();
-  expect(() => time2.parse("00:00:00.000")).toThrow();
-  expect(() => time2.parse("00:00:00.00+00:00")).toThrow();
-
-  const time3 = z.string().time({ precision: z.TimePrecision.Minute });
-  time3.parse("00:00");
-  expect(() => time3.parse("00:00:00")).toThrow();
-});
-
-test("duration", () => {
-  const duration = z.string().duration();
-
-  const validDurations = [
-    "P3Y6M4DT12H30M5S",
-    "P2Y9M3DT12H31M8.001S",
-    // "+P3Y6M4DT12H30M5S",
-    // "-PT0.001S",
-    // "+PT0.001S",
-    "PT0,001S",
-    "PT12H30M5S",
-    // "-P2M1D",
-    // "P-2M-1D",
-    // "-P5DT10H",
-    // "P-5DT-10H",
-    "P1Y",
-    "P2MT30M",
-    "PT6H",
-    "P5W",
-    // "P0.5Y",
-    // "P0,5Y",
-    // "P42YT7.004M",
-  ];
-
-  const invalidDurations = [
-    "foo bar",
-    "",
-    " ",
-    "P",
-    "PT",
-    "P1Y2MT",
-    "T1H",
-    "P0.5Y1D",
-    "P0,5Y6M",
-    "P1YT",
-    "P-2M-1D",
-    "P-5DT-10H",
-    "P1W2D",
-    "-P1D",
-  ];
-
-  for (const val of validDurations) {
-    const result = duration.safeParse(val);
-    if (!result.success) {
-      throw Error(`Valid duration could not be parsed: ${val}`);
-    }
-  }
-
-  for (const val of invalidDurations) {
-    const result = duration.safeParse(val);
-
-    if (result.success) {
-      throw Error(`Invalid duration was successful parsed: ${val}`);
-    }
-
-    expect(result.error.issues[0].message).toEqual("Invalid ISO duration");
-  }
-});
-
-test("redos checker", () => {
-  const a = z.iso.datetime();
-  const b = z.string().datetime({ offset: true });
-  const c = z.string().datetime({ local: true });
-  const d = z.string().datetime({ local: true, offset: true, precision: 3 });
-  const e = z.string().date();
-  const f = z.string().time();
-  const g = z.string().duration();
-  for (const schema of [a, b, c, d, e, f, g]) {
-    const result = checkSync(schema._zod.pattern.source, "");
-    if (result.status !== "safe") throw Error("ReDoS issue");
-  }
-});

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

@@ -1,365 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("basic defaults", () => {
-  expect(z.string().default("default").parse(undefined)).toBe("default");
-});
-
-test("default with optional", () => {
-  const schema = z.string().optional().default("default");
-  expect(schema.parse(undefined)).toBe("default");
-  expect(schema.unwrap().parse(undefined)).toBe(undefined);
-});
-
-test("default with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .default("default");
-  expect(stringWithDefault.parse(undefined)).toBe("default");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodPipe);
-  expect(stringWithDefault.unwrap().in).toBeInstanceOf(z.ZodString);
-  expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("default on existing optional", () => {
-  const stringWithDefault = z.string().optional().default("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("optional on default", () => {
-  const stringWithDefault = z.string().default("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string | undefined>();
-
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-});
-
-// test("complex chain example", () => {
-//   const complex = z
-//     .string()
-//     .default("asdf")
-//     .transform((val) => val.toUpperCase())
-//     .default("qwer")
-//     .unwrap()
-//     .optional()
-//     .default("asdfasdf");
-
-//   expect(complex.parse(undefined)).toBe("asdfasdf");
-// });
-
-test("removeDefault", () => {
-  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("apply default at output", () => {
-  const schema = z
-    .string()
-    .transform((_) => (Math.random() > 0 ? undefined : _))
-    .default("asdf");
-  expect(schema.parse("")).toEqual("asdf");
-});
-
-test("nested", () => {
-  const inner = z.string().default("asdf");
-  const outer = z.object({ inner }).default({
-    inner: "qwer",
-  });
-  type input = z.input<typeof outer>;
-  expectTypeOf<input>().toEqualTypeOf<{ inner?: string | undefined } | undefined>();
-  type out = z.output<typeof outer>;
-  expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();
-  expect(outer.parse(undefined)).toEqual({ inner: "qwer" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained defaults", () => {
-  const stringWithDefault = z.string().default("inner").default("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("outer");
-});
-
-test("object optionality", () => {
-  const schema = z.object({
-    hi: z.string().default("hi"),
-  });
-  type schemaInput = z.input<typeof schema>;
-  type schemaOutput = z.output<typeof schema>;
-  expectTypeOf<schemaInput>().toEqualTypeOf<{ hi?: string | undefined }>();
-  expectTypeOf<schemaOutput>().toEqualTypeOf<{ hi: string }>();
-  expect(schema.parse({})).toEqual({
-    hi: "hi",
-  });
-});
-
-test("nested prefault/default", () => {
-  const a = z
-    .string()
-    .default("a")
-    .refine((val) => val.startsWith("a"));
-  const b = z
-    .string()
-    .refine((val) => val.startsWith("b"))
-    .default("b");
-  const c = z
-    .string()
-    .prefault("c")
-    .refine((val) => val.startsWith("c"));
-  const d = z
-    .string()
-    .refine((val) => val.startsWith("d"))
-    .prefault("d");
-
-  const obj = z.object({
-    a,
-    b,
-    c,
-    d,
-  });
-
-  expect(obj.safeParse({ a: "a1", b: "b1", c: "c1", d: "d1" })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a1",
-        "b": "b1",
-        "c": "c1",
-        "d": "d1",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(obj.safeParse({ a: "f", b: "f", c: "f", d: "f" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "a"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "b"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "c"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "d"
-        ],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(obj.safeParse({})).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(obj.safeParse({ a: undefined, b: undefined, c: undefined, d: undefined })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  const obj2 = z.object({
-    a: a.optional(),
-    b: b.optional(),
-    c: c.optional(),
-    d: d.optional(),
-  });
-  expect(obj2.safeParse({ a: undefined, b: undefined, c: undefined, d: undefined })).toMatchInlineSnapshot(`
-    {
-      "data": {
-        "a": "a",
-        "b": "b",
-        "c": "c",
-        "d": "d",
-      },
-      "success": true,
-    }
-  `);
-
-  expect(a.parse(undefined)).toBe("a");
-  expect(b.parse(undefined)).toBe("b");
-  expect(c.parse(undefined)).toBe("c");
-  expect(d.parse(undefined)).toBe("d");
-});
-
-test("failing default", () => {
-  const a = z
-    .string()
-    .default("z")
-    .refine((val) => val.startsWith("a"));
-  const b = z
-    .string()
-    .refine((val) => val.startsWith("b"))
-    .default("z");
-  const c = z
-    .string()
-    .prefault("z")
-    .refine((val) => val.startsWith("c"));
-  const d = z
-    .string()
-    .refine((val) => val.startsWith("d"))
-    .prefault("z");
-
-  const obj = z.object({
-    a,
-    b,
-    c,
-    d,
-  });
-
-  expect(
-    obj.safeParse({
-      a: undefined,
-      b: undefined,
-      c: undefined,
-      d: undefined,
-    }).error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "a",
-        ],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "c",
-        ],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [
-          "d",
-        ],
-      },
-    ]
-  `);
-});
-
-test("partial should not clobber defaults", () => {
-  const objWithDefaults = z.object({
-    a: z.string().default("defaultA"),
-    b: z.string().default("defaultB"),
-    c: z.string().default("defaultC"),
-  });
-
-  const objPartialWithOneRequired = objWithDefaults.partial(); //.required({ a: true });
-
-  const test = objPartialWithOneRequired.parse({});
-  expect(test).toMatchInlineSnapshot(`
-    {
-      "a": "defaultA",
-      "b": "defaultB",
-      "c": "defaultC",
-    }
-  `);
-});
-
-test("defaulted object schema returns shallow clone", () => {
-  const schema = z
-    .object({
-      a: z.string(),
-    })
-    .default({ a: "x" });
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("defaulted array schema returns shallow clone", () => {
-  const schema = z.array(z.string()).default(["x"]);
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("direction-aware defaults", () => {
-  const schema = z.string().default("hello");
-
-  // Forward direction (regular parse): defaults should be applied
-  expect(schema.parse(undefined)).toBe("hello");
-  expect(schema.parse("hello")).toBe("hello");
-
-  // Reverse direction (encode): defaults should NOT be applied, undefined should fail validation
-  expect(() => z.encode(schema, undefined as any)).toThrow();
-
-  // But valid values should still work in reverse
-  expect(z.safeEncode(schema, "world")).toMatchInlineSnapshot(`
-    {
-      "data": "world",
-      "success": true,
-    }
-  `);
-  expect(z.safeEncode(schema, undefined as any)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/node_modules/zod/src/v4/classic/tests/describe-meta-checks.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as z from "../index.js";
-
-describe("z.describe() check", () => {
-  it("registers description in globalRegistry", () => {
-    const schema = z.string().check(z.describe("A string"));
-    expect(z.globalRegistry.get(schema)?.description).toBe("A string");
-  });
-});
-
-describe("z.meta() check", () => {
-  it("registers metadata in globalRegistry", () => {
-    const schema = z.number().check(z.meta({ title: "Age", description: "User's age" }));
-    const meta = z.globalRegistry.get(schema);
-    expect(meta?.title).toBe("Age");
-    expect(meta?.description).toBe("User's age");
-  });
-});
-
-describe("combined usage", () => {
-  it("works with multiple checks", () => {
-    const schema = z.string().check(z.describe("Email address"), z.meta({ title: "Email" }));
-    const meta = z.globalRegistry.get(schema);
-    expect(meta?.description).toBe("Email address");
-    expect(meta?.title).toBe("Email");
-  });
-});