@openclaw/signal 2026.7.2-beta.5 → 2026.7.33

package/node_modules/zod/src/v3/tests/refine.test.ts

@@ -1,313 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { ZodIssueCode } from "../ZodError.js";
-import { util } from "../helpers/util.js";
-
-test("refinement", () => {
-  const obj1 = z.object({
-    first: z.string(),
-    second: z.string(),
-  });
-  const obj2 = obj1.partial().strict();
-
-  const obj3 = obj2.refine((data) => data.first || data.second, "Either first or second should be filled in.");
-
-  expect(obj1 === (obj2 as any)).toEqual(false);
-  expect(obj2 === (obj3 as any)).toEqual(false);
-
-  expect(() => obj1.parse({})).toThrow();
-  expect(() => obj2.parse({ third: "adsf" })).toThrow();
-  expect(() => obj3.parse({})).toThrow();
-  obj3.parse({ first: "a" });
-  obj3.parse({ second: "a" });
-  obj3.parse({ first: "a", second: "a" });
-});
-
-test("refinement 2", () => {
-  const validationSchema = z
-    .object({
-      email: z.string().email(),
-      password: z.string(),
-      confirmPassword: z.string(),
-    })
-    .refine((data) => data.password === data.confirmPassword, "Both password and confirmation must match");
-
-  expect(() =>
-    validationSchema.parse({
-      email: "aaaa@gmail.com",
-      password: "aaaaaaaa",
-      confirmPassword: "bbbbbbbb",
-    })
-  ).toThrow();
-});
-
-test("refinement type guard", () => {
-  const validationSchema = z.object({
-    a: z.string().refine((s): s is "a" => s === "a"),
-  });
-  type Input = z.input<typeof validationSchema>;
-  type Schema = z.infer<typeof validationSchema>;
-
-  util.assertEqual<"a", Input["a"]>(false);
-  util.assertEqual<string, Input["a"]>(true);
-
-  util.assertEqual<"a", Schema["a"]>(true);
-  util.assertEqual<string, Schema["a"]>(false);
-});
-
-test("refinement Promise", async () => {
-  const validationSchema = z
-    .object({
-      email: z.string().email(),
-      password: z.string(),
-      confirmPassword: z.string(),
-    })
-    .refine(
-      (data) => Promise.resolve().then(() => data.password === data.confirmPassword),
-      "Both password and confirmation must match"
-    );
-
-  await validationSchema.parseAsync({
-    email: "aaaa@gmail.com",
-    password: "password",
-    confirmPassword: "password",
-  });
-});
-
-test("custom path", async () => {
-  const result = await z
-    .object({
-      password: z.string(),
-      confirm: z.string(),
-    })
-    .refine((data) => data.confirm === data.password, { path: ["confirm"] })
-    .spa({ password: "asdf", confirm: "qewr" });
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues[0].path).toEqual(["confirm"]);
-  }
-});
-
-test("use path in refinement context", async () => {
-  const noNested = z.string()._refinement((_val, ctx) => {
-    if (ctx.path.length > 0) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `schema cannot be nested. path: ${ctx.path.join(".")}`,
-      });
-      return false;
-    } else {
-      return true;
-    }
-  });
-
-  const data = z.object({
-    foo: noNested,
-  });
-
-  const t1 = await noNested.spa("asdf");
-  const t2 = await data.spa({ foo: "asdf" });
-
-  expect(t1.success).toBe(true);
-  expect(t2.success).toBe(false);
-  if (t2.success === false) {
-    expect(t2.error.issues[0].message).toEqual("schema cannot be nested. path: foo");
-  }
-});
-
-test("superRefine", () => {
-  const Strings = z.array(z.string()).superRefine((val, ctx) => {
-    if (val.length > 3) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.too_big,
-        maximum: 3,
-        type: "array",
-        inclusive: true,
-        exact: true,
-        message: "Too many items 😡",
-      });
-    }
-
-    if (val.length !== new Set(val).size) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `No duplicates allowed.`,
-      });
-    }
-  });
-
-  const result = Strings.safeParse(["asfd", "asfd", "asfd", "asfd"]);
-
-  expect(result.success).toEqual(false);
-  if (!result.success) expect(result.error.issues.length).toEqual(2);
-
-  Strings.parse(["asfd", "qwer"]);
-});
-
-test("superRefine async", async () => {
-  const Strings = z.array(z.string()).superRefine(async (val, ctx) => {
-    if (val.length > 3) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.too_big,
-        maximum: 3,
-        type: "array",
-        inclusive: true,
-        exact: true,
-        message: "Too many items 😡",
-      });
-    }
-
-    if (val.length !== new Set(val).size) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `No duplicates allowed.`,
-      });
-    }
-  });
-
-  const result = await Strings.safeParseAsync(["asfd", "asfd", "asfd", "asfd"]);
-
-  expect(result.success).toEqual(false);
-  if (!result.success) expect(result.error.issues.length).toEqual(2);
-
-  Strings.parseAsync(["asfd", "qwer"]);
-});
-
-test("superRefine - type narrowing", () => {
-  type NarrowType = { type: string; age: number };
-  const schema = z
-    .object({
-      type: z.string(),
-      age: z.number(),
-    })
-    .nullable()
-    .superRefine((arg, ctx): arg is NarrowType => {
-      if (!arg) {
-        // still need to make a call to ctx.addIssue
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "cannot be null",
-          fatal: true,
-        });
-        return false;
-      }
-      return true;
-    });
-
-  util.assertEqual<z.infer<typeof schema>, NarrowType>(true);
-
-  expect(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
-  expect(schema.safeParse(null).success).toEqual(false);
-});
-
-test("chained mixed refining types", () => {
-  type firstRefinement = { first: string; second: number; third: true };
-  type secondRefinement = { first: "bob"; second: number; third: true };
-  type thirdRefinement = { first: "bob"; second: 33; third: true };
-  const schema = z
-    .object({
-      first: z.string(),
-      second: z.number(),
-      third: z.boolean(),
-    })
-    .nullable()
-    .refine((arg): arg is firstRefinement => !!arg?.third)
-    .superRefine((arg, ctx): arg is secondRefinement => {
-      util.assertEqual<typeof arg, firstRefinement>(true);
-      if (arg.first !== "bob") {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "`first` property must be `bob`",
-        });
-        return false;
-      }
-      return true;
-    })
-    .refine((arg): arg is thirdRefinement => {
-      util.assertEqual<typeof arg, secondRefinement>(true);
-      return arg.second === 33;
-    });
-
-  util.assertEqual<z.infer<typeof schema>, thirdRefinement>(true);
-});
-
-test("get inner type", () => {
-  z.string()
-    .refine(() => true)
-    .innerType()
-    .parse("asdf");
-});
-
-test("chained refinements", () => {
-  const objectSchema = z
-    .object({
-      length: z.number(),
-      size: z.number(),
-    })
-    .refine(({ length }) => length > 5, {
-      path: ["length"],
-      message: "length greater than 5",
-    })
-    .refine(({ size }) => size > 7, {
-      path: ["size"],
-      message: "size greater than 7",
-    });
-  const r1 = objectSchema.safeParse({
-    length: 4,
-    size: 9,
-  });
-  expect(r1.success).toEqual(false);
-  if (!r1.success) expect(r1.error.issues.length).toEqual(1);
-
-  const r2 = objectSchema.safeParse({
-    length: 4,
-    size: 3,
-  });
-  expect(r2.success).toEqual(false);
-  if (!r2.success) expect(r2.error.issues.length).toEqual(2);
-});
-
-test("fatal superRefine", () => {
-  const Strings = z
-    .string()
-    .superRefine((val, ctx) => {
-      if (val === "") {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "foo",
-          fatal: true,
-        });
-      }
-    })
-    .superRefine((val, ctx) => {
-      if (val !== " ") {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "bar",
-        });
-      }
-    });
-
-  const result = Strings.safeParse("");
-
-  expect(result.success).toEqual(false);
-  if (!result.success) expect(result.error.issues.length).toEqual(1);
-});
-
-test("superRefine after skipped transform", () => {
-  const schema = z
-    .string()
-    .regex(/^\d+$/)
-    .transform((val) => Number(val))
-    .superRefine((val) => {
-      if (typeof val !== "number") {
-        throw new Error("Called without transform");
-      }
-    });
-
-  const result = schema.safeParse("");
-
-  expect(result.success).toEqual(false);
-});

package/node_modules/zod/src/v3/tests/safeparse.test.ts

@@ -1,27 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-const stringSchema = z.string();
-
-test("safeparse fail", () => {
-  const safe = stringSchema.safeParse(12);
-  expect(safe.success).toEqual(false);
-  expect(safe.error).toBeInstanceOf(z.ZodError);
-});
-
-test("safeparse pass", () => {
-  const safe = stringSchema.safeParse("12");
-  expect(safe.success).toEqual(true);
-  expect(safe.data).toEqual("12");
-});
-
-test("safeparse unexpected error", () => {
-  expect(() =>
-    stringSchema
-      .refine((data) => {
-        throw new Error(data);
-      })
-      .safeParse("12")
-  ).toThrow();
-});

package/node_modules/zod/src/v3/tests/set.test.ts

@@ -1,142 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { ZodIssueCode } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const stringSet = z.set(z.string());
-type stringSet = z.infer<typeof stringSet>;
-
-const minTwo = z.set(z.string()).min(2);
-const maxTwo = z.set(z.string()).max(2);
-const justTwo = z.set(z.string()).size(2);
-const nonEmpty = z.set(z.string()).nonempty();
-const nonEmptyMax = z.set(z.string()).nonempty().max(2);
-
-test("type inference", () => {
-  util.assertEqual<stringSet, Set<string>>(true);
-});
-
-test("valid parse", () => {
-  const result = stringSet.safeParse(new Set(["first", "second"]));
-  expect(result.success).toEqual(true);
-  if (result.success) {
-    expect(result.data.has("first")).toEqual(true);
-    expect(result.data.has("second")).toEqual(true);
-    expect(result.data.has("third")).toEqual(false);
-  }
-
-  expect(() => {
-    minTwo.parse(new Set(["a", "b"]));
-    minTwo.parse(new Set(["a", "b", "c"]));
-    maxTwo.parse(new Set(["a", "b"]));
-    maxTwo.parse(new Set(["a"]));
-    justTwo.parse(new Set(["a", "b"]));
-    nonEmpty.parse(new Set(["a"]));
-    nonEmptyMax.parse(new Set(["a"]));
-  }).not.toThrow();
-});
-
-test("valid parse async", async () => {
-  const result = await stringSet.spa(new Set(["first", "second"]));
-  expect(result.success).toEqual(true);
-  if (result.success) {
-    expect(result.data.has("first")).toEqual(true);
-    expect(result.data.has("second")).toEqual(true);
-    expect(result.data.has("third")).toEqual(false);
-  }
-
-  const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
-  expect(asyncResult.success).toEqual(true);
-  if (asyncResult.success) {
-    expect(asyncResult.data.has("first")).toEqual(true);
-    expect(asyncResult.data.has("second")).toEqual(true);
-    expect(asyncResult.data.has("third")).toEqual(false);
-  }
-});
-
-test("valid parse: size-related methods", () => {
-  expect(() => {
-    minTwo.parse(new Set(["a", "b"]));
-    minTwo.parse(new Set(["a", "b", "c"]));
-    maxTwo.parse(new Set(["a", "b"]));
-    maxTwo.parse(new Set(["a"]));
-    justTwo.parse(new Set(["a", "b"]));
-    nonEmpty.parse(new Set(["a"]));
-    nonEmptyMax.parse(new Set(["a"]));
-  }).not.toThrow();
-
-  const sizeZeroResult = stringSet.parse(new Set());
-  expect(sizeZeroResult.size).toBe(0);
-
-  const sizeTwoResult = minTwo.parse(new Set(["a", "b"]));
-  expect(sizeTwoResult.size).toBe(2);
-});
-
-test("failing when parsing empty set in nonempty ", () => {
-  const result = nonEmpty.safeParse(new Set());
-  expect(result.success).toEqual(false);
-
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_small);
-  }
-});
-
-test("failing when set is smaller than min() ", () => {
-  const result = minTwo.safeParse(new Set(["just_one"]));
-  expect(result.success).toEqual(false);
-
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_small);
-  }
-});
-
-test("failing when set is bigger than max() ", () => {
-  const result = maxTwo.safeParse(new Set(["one", "two", "three"]));
-  expect(result.success).toEqual(false);
-
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_big);
-  }
-});
-
-test("doesn’t throw when an empty set is given", () => {
-  const result = stringSet.safeParse(new Set([]));
-  expect(result.success).toEqual(true);
-});
-
-test("throws when a Map is given", () => {
-  const result = stringSet.safeParse(new Map([]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-  }
-});
-
-test("throws when the given set has invalid input", () => {
-  const result = stringSet.safeParse(new Set([Symbol()]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[0].path).toEqual([0]);
-  }
-});
-
-test("throws when the given set has multiple invalid entries", () => {
-  const result = stringSet.safeParse(new Set([1, 2] as any[]) as Set<any>);
-
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[0].path).toEqual([0]);
-    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[1].path).toEqual([1]);
-  }
-});

package/node_modules/zod/src/v3/tests/standard-schema.test.ts

@@ -1,83 +0,0 @@
-// import type { StandardSchemaV1 } from "@standard-schema/spec";
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-import type { StandardSchemaV1 } from "../standard-schema.js";
-
-test("assignability", () => {
-  const _s1: StandardSchemaV1 = z.string();
-  const _s2: StandardSchemaV1<string> = z.string();
-  const _s3: StandardSchemaV1<string, string> = z.string();
-  const _s4: StandardSchemaV1<unknown, string> = z.string();
-  [_s1, _s2, _s3, _s4];
-});
-
-test("type inference", () => {
-  const stringToNumber = z.string().transform((x) => x.length);
-  type input = StandardSchemaV1.InferInput<typeof stringToNumber>;
-  util.assertEqual<input, string>(true);
-  type output = StandardSchemaV1.InferOutput<typeof stringToNumber>;
-  util.assertEqual<output, number>(true);
-});
-
-test("valid parse", () => {
-  const schema = z.string();
-  const result = schema["~standard"].validate("hello");
-  if (result instanceof Promise) {
-    throw new Error("Expected sync result");
-  }
-  expect(result.issues).toEqual(undefined);
-  if (result.issues) {
-    throw new Error("Expected no issues");
-  } else {
-    expect(result.value).toEqual("hello");
-  }
-});
-
-test("invalid parse", () => {
-  const schema = z.string();
-  const result = schema["~standard"].validate(1234);
-  if (result instanceof Promise) {
-    throw new Error("Expected sync result");
-  }
-  expect(result.issues).toBeDefined();
-  if (!result.issues) {
-    throw new Error("Expected issues");
-  }
-  expect(result.issues.length).toEqual(1);
-  expect(result.issues[0].path).toEqual([]);
-});
-
-test("valid parse async", async () => {
-  const schema = z.string().refine(async () => true);
-  const _result = schema["~standard"].validate("hello");
-  if (_result instanceof Promise) {
-    const result = await _result;
-    expect(result.issues).toEqual(undefined);
-    if (result.issues) {
-      throw new Error("Expected no issues");
-    } else {
-      expect(result.value).toEqual("hello");
-    }
-  } else {
-    throw new Error("Expected async result");
-  }
-});
-
-test("invalid parse async", async () => {
-  const schema = z.string().refine(async () => false);
-  const _result = schema["~standard"].validate("hello");
-  if (_result instanceof Promise) {
-    const result = await _result;
-    expect(result.issues).toBeDefined();
-    if (!result.issues) {
-      throw new Error("Expected issues");
-    }
-    expect(result.issues.length).toEqual(1);
-    expect(result.issues[0].path).toEqual([]);
-  } else {
-    throw new Error("Expected async result");
-  }
-});