@nocobase/plugin-flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.11

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

@@ -0,0 +1,302 @@
+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/dist/node_modules/zod/src/v4/classic/tests/default.test.ts

@@ -0,0 +1,365 @@
+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/dist/node_modules/zod/src/v4/classic/tests/describe-meta-checks.test.ts

@@ -0,0 +1,27 @@
+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");
+  });
+});