@openclaw/line 2026.5.20-beta.2 → 2026.5.22

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

@@ -0,0 +1,26 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("check any inference", () => {
+  const t1 = z.any();
+  t1.optional();
+  t1.nullable();
+  type t1 = z.infer<typeof t1>;
+  expectTypeOf<t1>().toEqualTypeOf<any>();
+});
+
+test("check unknown inference", () => {
+  const t1 = z.unknown();
+  t1.optional();
+  t1.nullable();
+  type t1 = z.infer<typeof t1>;
+  expectTypeOf<t1>().toEqualTypeOf<unknown>();
+});
+
+test("check never inference", () => {
+  const t1 = z.never();
+  expect(() => t1.parse(undefined)).toThrow();
+  expect(() => t1.parse("asdf")).toThrow();
+  expect(() => t1.parse(null)).toThrow();
+});

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

@@ -0,0 +1,59 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("basic apply (object)", () => {
+  const schema = z
+    .object({
+      a: z.number(),
+      b: z.string(),
+    })
+    .apply((s) => s.omit({ b: true }))
+    .apply((s) => s.extend({ c: z.boolean() }));
+
+  expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "additionalProperties": false,
+      "properties": {
+        "a": {
+          "type": "number",
+        },
+        "c": {
+          "type": "boolean",
+        },
+      },
+      "required": [
+        "a",
+        "c",
+      ],
+      "type": "object",
+    }
+  `);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<{
+    a: number;
+    c: boolean;
+  }>();
+});
+
+test("basic apply (number)", () => {
+  const setCommonNumberChecks = <T extends z.ZodNumber>(schema: T) => {
+    return schema.min(0).max(100);
+  };
+
+  const schema = z.number().apply(setCommonNumberChecks).nullable();
+
+  expect(() => schema.parse(-1)).toThrowError();
+  expect(() => schema.parse(101)).toThrowError();
+  expect(schema.parse(0)).toBe(0);
+  expect(schema.parse(null)).toBe(null);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
+});
+
+test("The callback's return value becomes the apply's return value.", () => {
+  const symbol = Symbol();
+  const result = z.number().apply(() => symbol);
+
+  expect(result).toBe(symbol);
+  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
+});

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

@@ -0,0 +1,264 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("type inference", () => {
+  const schema = z.string().array();
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string[]>();
+});
+
+test("array min/max", () => {
+  const schema = z.array(z.string()).min(2).max(2);
+  const r1 = schema.safeParse(["asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+
+  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "inclusive": true,
+        "maximum": 2,
+        "message": "Too big: expected array to have <=2 items",
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+});
+
+test("array length", () => {
+  const schema = z.array(z.string()).length(2);
+  schema.parse(["asdf", "asdf"]);
+
+  const r1 = schema.safeParse(["asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "exact": true,
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+
+  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "exact": true,
+        "inclusive": true,
+        "maximum": 2,
+        "message": "Too big: expected array to have <=2 items",
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+});
+
+test("array.nonempty()", () => {
+  const schema = z.string().array().nonempty();
+  schema.parse(["a"]);
+  expect(() => schema.parse([])).toThrow();
+});
+
+test("array.nonempty().max()", () => {
+  const schema = z.string().array().nonempty().max(2);
+  schema.parse(["a"]);
+  expect(() => schema.parse([])).toThrow();
+  expect(() => schema.parse(["a", "a", "a"])).toThrow();
+});
+
+test("parse empty array in nonempty", () => {
+  expect(() =>
+    z
+      .array(z.string())
+      .nonempty()
+      .parse([] as any)
+  ).toThrow();
+});
+
+test("get element", () => {
+  const schema = z.string().array();
+  schema.element.parse("asdf");
+  expect(() => schema.element.parse(12)).toThrow();
+});
+
+test("continue parsing despite array size error", () => {
+  const schema = z.object({
+    people: z.string().array().min(2),
+  });
+
+  const result = schema.safeParse({
+    people: [123],
+  });
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "people",
+          0
+        ],
+        "message": "Invalid input: expected string, received number"
+      },
+      {
+        "origin": "array",
+        "code": "too_small",
+        "minimum": 2,
+        "inclusive": true,
+        "path": [
+          "people"
+        ],
+        "message": "Too small: expected array to have >=2 items"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("parse should fail given sparse array", () => {
+  const schema = z.array(z.string()).nonempty().min(1).max(3);
+  const result = schema.safeParse(new Array(3));
+  expect(result.success).toEqual(false);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          0
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          2
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+// const unique = z.string().array().unique();
+// const uniqueArrayOfObjects = z.array(z.object({ name: z.string() })).unique({ identifier: (item) => item.name });
+
+// test("passing unique validation", () => {
+//   unique.parse(["a", "b", "c"]);
+//   uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Joe" }]);
+// });
+
+// test("failing unique validation", () => {
+//   expect(() => unique.parse(["a", "a", "b"])).toThrow();
+//   expect(() => uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Leo" }])).toThrow();
+// });
+
+// test("continue parsing despite array of primitives uniqueness error", () => {
+//   const schema = z.number().array().unique();
+
+//   const result = schema.safeParse([1, 1, 2, 2, 3]);
+
+//   expect(result.success).toEqual(false);
+//   if (!result.success) {
+//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
+//     expect(issue?.message).toEqual("Values must be unique");
+//   }
+// });
+
+// test("continue parsing despite array of objects not_unique error", () => {
+//   const schema = z.array(z.object({ name: z.string() })).unique({
+//     identifier: (item) => item.name,
+//     showDuplicates: true,
+//   });
+
+//   const result = schema.safeParse([
+//     { name: "Leo" },
+//     { name: "Joe" },
+//     { name: "Leo" },
+//   ]);
+
+//   expect(result.success).toEqual(false);
+//   if (!result.success) {
+//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
+//     expect(issue?.message).toEqual("Element(s): 'Leo' not unique");
+//   }
+// });
+
+// test("returns custom error message without duplicate elements", () => {
+//   const schema = z.number().array().unique({ message: "Custom message" });
+
+//   const result = schema.safeParse([1, 1, 2, 2, 3]);
+
+//   expect(result.success).toEqual(false);
+//   if (!result.success) {
+//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
+//     expect(issue?.message).toEqual("Custom message");
+//   }
+// });
+
+// test("returns error message with duplicate elements", () => {
+//   const schema = z.number().array().unique({ showDuplicates: true });
+
+//   const result = schema.safeParse([1, 1, 2, 2, 3]);
+
+//   expect(result.success).toEqual(false);
+//   if (!result.success) {
+//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
+//     expect(issue?.message).toEqual("Element(s): '1,2' not unique");
+//   }
+// });
+
+// test("returns custom error message with duplicate elements", () => {
+//   const schema = z
+//     .number()
+//     .array()
+//     .unique({
+//       message: (item) => `Custom message: '${item}' are not unique`,
+//       showDuplicates: true,
+//     });
+
+//   const result = schema.safeParse([1, 1, 2, 2, 3]);
+
+//   expect(result.success).toEqual(false);
+//   if (!result.success) {
+//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
+//     expect(issue?.message).toEqual("Custom message: '1,2' are not unique");
+//   }
+// });

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

@@ -0,0 +1,216 @@
+import { expectTypeOf, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("assignability", () => {
+  // $ZodString
+  z.string() satisfies z.core.$ZodString;
+  z.string() satisfies z.ZodString;
+
+  // $ZodNumber
+  z.number() satisfies z.core.$ZodNumber;
+  z.number() satisfies z.ZodNumber;
+
+  // $ZodBigInt
+  z.bigint() satisfies z.core.$ZodBigInt;
+  z.bigint() satisfies z.ZodBigInt;
+
+  // $ZodBoolean
+  z.boolean() satisfies z.core.$ZodBoolean;
+  z.boolean() satisfies z.ZodBoolean;
+
+  // $ZodDate
+  z.date() satisfies z.core.$ZodDate;
+  z.date() satisfies z.ZodDate;
+
+  // $ZodSymbol
+  z.symbol() satisfies z.core.$ZodSymbol;
+  z.symbol() satisfies z.ZodSymbol;
+
+  // $ZodUndefined
+  z.undefined() satisfies z.core.$ZodUndefined;
+  z.undefined() satisfies z.ZodUndefined;
+
+  // $ZodNullable
+  z.string().nullable() satisfies z.core.$ZodNullable;
+  z.string().nullable() satisfies z.ZodNullable;
+
+  // $ZodNull
+  z.null() satisfies z.core.$ZodNull;
+  z.null() satisfies z.ZodNull;
+
+  // $ZodAny
+  z.any() satisfies z.core.$ZodAny;
+  z.any() satisfies z.ZodAny;
+
+  // $ZodUnknown
+  z.unknown() satisfies z.core.$ZodUnknown;
+  z.unknown() satisfies z.ZodUnknown;
+
+  // $ZodNever
+  z.never() satisfies z.core.$ZodNever;
+  z.never() satisfies z.ZodNever;
+
+  // $ZodVoid
+  z.void() satisfies z.core.$ZodVoid;
+  z.void() satisfies z.ZodVoid;
+
+  // $ZodArray
+  z.array(z.string()) satisfies z.core.$ZodArray;
+  z.array(z.string()) satisfies z.ZodArray;
+  z.array(z.string()) satisfies z.ZodType<Array<unknown>>;
+
+  // $ZodObject
+  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
+  z.object({ key: z.string() }) satisfies z.ZodObject<{ key: z.ZodType }>;
+  z.object({ key: z.string() }) satisfies z.ZodType<{ key: string }>;
+
+  // $ZodUnion
+  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
+  z.union([z.string(), z.number()]) satisfies z.ZodUnion;
+  z.union([z.string(), z.number()]) satisfies z.ZodType<string | number>;
+
+  // $ZodIntersection
+  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
+  z.intersection(z.string(), z.number()) satisfies z.ZodIntersection;
+
+  // $ZodTuple
+  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
+  z.tuple([z.string(), z.number()]) satisfies z.ZodTuple;
+
+  // $ZodRecord
+  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
+  z.record(z.string(), z.number()) satisfies z.ZodRecord;
+
+  // $ZodMap
+  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
+  z.map(z.string(), z.number()) satisfies z.ZodMap;
+
+  // $ZodSet
+  z.set(z.string()) satisfies z.core.$ZodSet;
+  z.set(z.string()) satisfies z.ZodSet;
+
+  // $ZodLiteral
+  z.literal("example") satisfies z.core.$ZodLiteral;
+  z.literal("example") satisfies z.ZodLiteral;
+
+  // $ZodEnum
+  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
+  z.enum(["a", "b", "c"]) satisfies z.ZodEnum;
+
+  // $ZodPromise
+  z.promise(z.string()) satisfies z.core.$ZodPromise;
+  z.promise(z.string()) satisfies z.ZodPromise;
+
+  // $ZodLazy
+  const lazySchema = z.lazy(() => z.string());
+  lazySchema satisfies z.core.$ZodLazy;
+  lazySchema satisfies z.ZodLazy;
+
+  // $ZodOptional
+  z.string().optional() satisfies z.core.$ZodOptional;
+  z.string().optional() satisfies z.ZodOptional;
+
+  // $ZodDefault
+  z.string().default("default") satisfies z.core.$ZodDefault;
+  z.string().default("default") satisfies z.ZodDefault;
+
+  // $ZodTemplateLiteral
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.ZodTemplateLiteral;
+
+  // $ZodCustom
+  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
+  z.custom<string>((val) => typeof val === "string") satisfies z.ZodCustom;
+
+  // $ZodTransform
+  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
+  z.transform((val) => val as string) satisfies z.ZodTransform;
+
+  // $ZodNonOptional
+  z.string().optional().nonoptional() satisfies z.core.$ZodNonOptional;
+  z.string().optional().nonoptional() satisfies z.ZodNonOptional;
+
+  // $ZodReadonly
+  z.object({ key: z.string() }).readonly() satisfies z.core.$ZodReadonly;
+  z.object({ key: z.string() }).readonly() satisfies z.ZodReadonly;
+
+  // $ZodNaN
+  z.nan() satisfies z.core.$ZodNaN;
+  z.nan() satisfies z.ZodNaN;
+
+  // $ZodPipe
+  z.unknown().pipe(z.number()) satisfies z.core.$ZodPipe;
+  z.unknown().pipe(z.number()) satisfies z.ZodPipe;
+
+  // $ZodPreprocess
+  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.ZodPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
+  z.preprocess((v) => v, z.number()) satisfies z.ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
+
+  // $ZodSuccess
+  z.success(z.string()) satisfies z.core.$ZodSuccess;
+  z.success(z.string()) satisfies z.ZodSuccess;
+
+  // $ZodCatch
+  z.string().catch("fallback") satisfies z.core.$ZodCatch;
+  z.string().catch("fallback") satisfies z.ZodCatch;
+
+  // $ZodFile
+  z.file() satisfies z.core.$ZodFile;
+  z.file() satisfies z.ZodFile;
+});
+
+test("checks", () => {
+  const _a: z.core.$ZodCheck = {} as any as z.core.$ZodChecks;
+  const _b: z.core.$ZodCheck = {} as any as z.core.$ZodStringFormatChecks;
+  const _c: z.core.$ZodType = {} as any as z.core.$ZodTypes;
+  const _d: z.core.$ZodType = {} as any as z.core.$ZodStringFormatTypes;
+});
+
+test("assignability to $ZodType", () => {
+  z.string() satisfies z.ZodType;
+  z.number() satisfies z.ZodType;
+  z.boolean() satisfies z.ZodType;
+  z.object({ key: z.string() }) satisfies z.ZodType;
+  z.object({ key: z.string() }) satisfies z.ZodType<{ key: string }>;
+  z.array(z.string()) satisfies z.ZodType;
+  z.union([z.string(), z.number()]) satisfies z.ZodType;
+  z.intersection(z.string(), z.number()) satisfies z.ZodType;
+  z.tuple([z.string(), z.number()]) satisfies z.ZodType;
+  z.record(z.string(), z.number()) satisfies z.ZodType;
+  z.map(z.string(), z.number()) satisfies z.ZodType;
+  z.set(z.string()) satisfies z.ZodType;
+  z.literal("example") satisfies z.ZodType;
+
+  expectTypeOf<z.ZodType extends z.core.$ZodType ? true : false>().toEqualTypeOf<true>();
+});
+
+test("assignability with narrowing", () => {
+  type _RefinedSchema<T extends z.ZodType<object> | z.ZodUnion> = T extends z.ZodUnion
+    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
+    : T extends z.ZodType<object>
+      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
+      : never;
+
+  type RefinedTypeSchema<T extends object> = T;
+
+  type RefinedUnionSchema<T extends z.ZodUnion> = T;
+});
+
+test("generic assignability in objects", () => {
+  interface SortItem<T extends string> {
+    key: T;
+    order: string;
+  }
+
+  const createSortItemSchema = <T extends z.ZodType<string>>(sortKeySchema: T) =>
+    z.object({
+      key: sortKeySchema,
+      order: z.string(),
+    });
+
+  <T extends z.ZodType<string>>(sortKeySchema: T, defaultSortBy: SortItem<z.output<T>>[] = []) =>
+    createSortItemSchema(sortKeySchema).array().default(defaultSortBy);
+});