@openclaw/nostr 2026.5.20 → 2026.5.22

package/node_modules/zod/src/v4/mini/tests/number.test.ts

@@ -0,0 +1,95 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/mini";
+
+test("z.number", () => {
+  const a = z.number();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+
+  type a = z.infer<typeof a>;
+  expectTypeOf<a>().toEqualTypeOf<number>();
+});
+
+test("z.number async", async () => {
+  const a = z.number().check(z.refine(async (_) => _ > 0));
+  await expect(z.parseAsync(a, 123)).resolves.toEqual(123);
+  await expect(() => z.parseAsync(a, -123)).rejects.toThrow();
+  await expect(() => z.parseAsync(a, "123")).rejects.toThrow();
+});
+
+test("z.int", () => {
+  const a = z.int();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+});
+
+test("z.float32", () => {
+  const a = z.float32();
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123.45")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  // -3.4028234663852886e38, 3.4028234663852886e38;
+  expect(() => z.parse(a, 3.4028234663852886e38 * 2)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -3.4028234663852886e38 * 2)).toThrow(); // Exceeds min
+});
+
+test("z.float64", () => {
+  const a = z.float64();
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123.45")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 1.7976931348623157e308 * 2)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -1.7976931348623157e308 * 2)).toThrow(); // Exceeds min
+});
+
+test("z.int32", () => {
+  const a = z.int32();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 2147483648)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -2147483649)).toThrow(); // Exceeds min
+});
+
+test("z.uint32", () => {
+  const a = z.uint32();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, -123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 4294967296)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -1)).toThrow(); // Below min
+});
+
+test("z.int64", () => {
+  const a = z.int64();
+  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow();
+  expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow();
+  // expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow(); // Exceeds max
+  // expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow(); // Exceeds min
+});
+
+test("z.uint64", () => {
+  const a = z.uint64();
+  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, -123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
+  expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
+  // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
+  // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
+});

package/node_modules/zod/src/v4/mini/tests/object.test.ts

@@ -0,0 +1,227 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/mini";
+
+test("z.object", () => {
+  const a = z.object({
+    name: z.string(),
+    age: z.number(),
+    points: z.optional(z.number()),
+    "test?": z.boolean(),
+  });
+
+  a._zod.def.shape["test?"];
+  a._zod.def.shape.points._zod.optin;
+
+  type a = z.output<typeof a>;
+
+  expectTypeOf<a>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    points?: number | undefined;
+    "test?": boolean;
+  }>();
+  expect(z.parse(a, { name: "john", age: 30, "test?": true })).toEqual({
+    name: "john",
+    age: 30,
+    "test?": true,
+  });
+  // "test?" is required in ZodObject
+  expect(() => z.parse(a, { name: "john", age: "30" })).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+
+  // null prototype
+  const schema = z.object({ a: z.string() });
+  const obj = Object.create(null);
+  obj.a = "foo";
+  expect(schema.parse(obj)).toEqual({ a: "foo" });
+});
+
+test("z.object().check()", () => {
+  const a = z.object({
+    name: z.string(),
+    age: z.number(),
+    points: z.optional(z.number()),
+    "test?": z.boolean(),
+  });
+
+  type a = z.output<typeof a>;
+
+  a.check(({ value }) => {
+    expectTypeOf(value).toEqualTypeOf<a>();
+  });
+});
+
+test("z.strictObject", () => {
+  const a = z.strictObject({
+    name: z.string(),
+  });
+  expect(z.parse(a, { name: "john" })).toEqual({ name: "john" });
+  expect(() => z.parse(a, { name: "john", age: 30 })).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+test("z.looseObject", () => {
+  const a = z.looseObject({
+    name: z.string(),
+    age: z.number(),
+  });
+  expect(z.parse(a, { name: "john", age: 30 })).toEqual({
+    name: "john",
+    age: 30,
+  });
+  expect(z.parse(a, { name: "john", age: 30, extra: true })).toEqual({
+    name: "john",
+    age: 30,
+    extra: true,
+  });
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+const userSchema = z.object({
+  name: z.string(),
+  age: z.number(),
+  email: z.optional(z.string()),
+});
+
+test("z.keyof", () => {
+  // z.keyof returns an enum schema of the keys of an object schema
+  const userKeysSchema = z.keyof(userSchema);
+  type UserKeys = z.infer<typeof userKeysSchema>;
+  expectTypeOf<UserKeys>().toEqualTypeOf<"name" | "age" | "email">();
+  expect(userKeysSchema).toBeDefined();
+  expect(userKeysSchema._zod.def.type).toBe("enum");
+  expect(userKeysSchema._zod.def.entries).toEqual({
+    name: "name",
+    age: "age",
+    email: "email",
+  });
+  expect(z.safeParse(userKeysSchema, "name").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "age").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "email").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "isAdmin").success).toBe(false);
+});
+
+test("z.extend", () => {
+  const extendedSchema = z.extend(userSchema, {
+    isAdmin: z.boolean(),
+  });
+  type ExtendedUser = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedUser>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    email?: string | undefined;
+    isAdmin: boolean;
+  }>();
+  expect(extendedSchema).toBeDefined();
+  expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
+});
+
+test("z.safeExtend", () => {
+  const extended = z.safeExtend(userSchema, { name: z.string() });
+  expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
+  type Extended = z.infer<typeof extended>;
+  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string | undefined }>();
+  // @ts-expect-error
+  z.safeExtend(userSchema, { name: z.number() });
+});
+
+test("z.pick", () => {
+  const pickedSchema = z.pick(userSchema, { name: true, email: true });
+  type PickedUser = z.infer<typeof pickedSchema>;
+  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string | undefined }>();
+  expect(pickedSchema).toBeDefined();
+  expect(z.safeParse(pickedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.omit", () => {
+  const omittedSchema = z.omit(userSchema, { age: true });
+  type OmittedUser = z.infer<typeof omittedSchema>;
+  expectTypeOf<OmittedUser>().toEqualTypeOf<{
+    name: string;
+    email?: string | undefined;
+  }>();
+  expect(omittedSchema).toBeDefined();
+  expect(Reflect.ownKeys(omittedSchema._zod.def.shape)).toEqual(["name", "email"]);
+  expect(z.safeParse(omittedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.partial", () => {
+  const partialSchema = z.partial(userSchema);
+  type PartialUser = z.infer<typeof partialSchema>;
+  expectTypeOf<PartialUser>().toEqualTypeOf<{
+    name?: string | undefined;
+    age?: number | undefined;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
+});
+
+test("z.partial with mask", () => {
+  const partialSchemaWithMask = z.partial(userSchema, { name: true });
+  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
+  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
+    name?: string | undefined;
+    age: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
+  expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
+});
+
+test("z.pick/omit/partial/required - do not allow unknown keys", () => {
+  const schema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  // Mixed valid + invalid keys - throws at parse time (lazy evaluation)
+  // @ts-expect-error
+  expect(() => z.parse(z.pick(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.omit(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.partial(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.required(schema, { name: true, asdf: true }), {})).toThrow();
+
+  // Only invalid keys
+  // @ts-expect-error
+  expect(() => z.parse(z.pick(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.omit(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.partial(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.required(schema, { $unknown: true }), {})).toThrow();
+});
+
+test("z.catchall", () => {
+  // z.catchall()
+  const schema = z.catchall(
+    z.object({
+      name: z.string(),
+      // age: z.number(),
+    }),
+    z.string()
+  );
+
+  type schemaIn = z.input<typeof schema>;
+  type schemaOut = z.output<typeof schema>;
+  expectTypeOf<schemaIn>().toEqualTypeOf<{
+    name: string;
+    [key: string]: string;
+  }>();
+
+  expectTypeOf<schemaOut>().toEqualTypeOf<{
+    name: string;
+    [key: string]: string;
+  }>();
+
+  schema.parse({
+    name: "john",
+    age: "30",
+    extra: "extra value",
+  });
+
+  expect(() => schema.parse({ name: "john", age: 30 })).toThrow();
+});

package/node_modules/zod/src/v4/mini/tests/prototypes.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "vitest";
+import * as z from "zod/mini";
+
+declare module "zod/v4/core" {
+  interface $ZodType {
+    /** @deprecated */
+    _core(): string;
+  }
+}
+
+test("prototype extension", () => {
+  z.core.$ZodType.prototype._core = function () {
+    return "_core";
+  };
+
+  // should pass
+  const result = z.string()._core();
+  expect(result).toBe("_core");
+  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
+
+  // clean up
+  z.ZodMiniType.prototype._core = undefined;
+});
+
+declare module "zod/v4/mini" {
+  interface ZodMiniType {
+    /** @deprecated */
+    _mini(): string;
+  }
+}
+
+test("prototype extension", () => {
+  z.ZodMiniType.prototype._mini = function () {
+    return "_mini";
+  };
+
+  // should pass
+  const result = z.string()._mini();
+  expect(result).toBe("_mini");
+
+  // clean up
+  z.ZodMiniType.prototype._mini = undefined;
+});

package/node_modules/zod/src/v4/mini/tests/recursive-types.test.ts

@@ -0,0 +1,325 @@
+import { expect, expectTypeOf, test } from "vitest";
+import { z } from "zod/mini";
+
+test("recursion with z.lazy", () => {
+  const data = {
+    name: "I",
+    subcategories: [
+      {
+        name: "A",
+        subcategories: [
+          {
+            name: "1",
+            subcategories: [
+              {
+                name: "a",
+                subcategories: [],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+
+  const Category = z.object({
+    name: z.string(),
+    get subcategories(): z.ZodMiniOptional<z.ZodMiniArray<typeof Category>> {
+      return z.optional(z.array(Category));
+    },
+  });
+  Category.parse(data);
+
+  type Category = z.infer<typeof Category>;
+  interface _Category {
+    name: string;
+    subcategories?: _Category[] | undefined;
+  }
+  expectTypeOf<Category>().toEqualTypeOf<_Category>();
+});
+
+test("recursion involving union type", () => {
+  const data = {
+    value: 1,
+    next: {
+      value: 2,
+      next: {
+        value: 3,
+        next: {
+          value: 4,
+          next: null,
+        },
+      },
+    },
+  };
+
+  const LL = z.object({
+    value: z.number(),
+    get next(): z.ZodMiniNullable<typeof LL> {
+      return z.nullable(LL);
+    },
+  });
+
+  LL.parse(data);
+  type LL = z.infer<typeof LL>;
+  type _LL = {
+    value: number;
+    next: _LL | null;
+  };
+  expectTypeOf<LL>().toEqualTypeOf<_LL>();
+});
+
+test("mutual recursion - native", () => {
+  const Alazy = z.object({
+    val: z.number(),
+    get b() {
+      return z.optional(Blazy);
+    },
+  });
+
+  const Blazy = z.object({
+    val: z.number(),
+    get a() {
+      return z.optional(Alazy);
+    },
+  });
+  const testData = {
+    val: 1,
+    b: {
+      val: 5,
+      a: {
+        val: 3,
+        b: {
+          val: 4,
+          a: {
+            val: 2,
+            b: {
+              val: 1,
+            },
+          },
+        },
+      },
+    },
+  };
+
+  Alazy.parse(testData);
+  Blazy.parse(testData.b);
+
+  type Alazy = z.infer<typeof Alazy>;
+  type Blazy = z.infer<typeof Blazy>;
+  interface _Alazy {
+    val: number;
+    b?: _Blazy | undefined;
+  }
+  interface _Blazy {
+    val: number;
+    a?: _Alazy | undefined;
+  }
+  expectTypeOf<Alazy>().toEqualTypeOf<_Alazy>();
+  expectTypeOf<Blazy>().toEqualTypeOf<_Blazy>();
+
+  expect(() => Alazy.parse({ val: "asdf" })).toThrow();
+});
+
+test("pick and omit with getter", () => {
+  const Category = z.strictObject({
+    name: z.string(),
+    get subcategories() {
+      return z.array(Category);
+    },
+  });
+
+  type Category = z.infer<typeof Category>;
+  interface _Category {
+    name: string;
+    subcategories: _Category[];
+  }
+  expectTypeOf<Category>().toEqualTypeOf<_Category>();
+
+  const PickedCategory = z.pick(Category, { name: true });
+  const OmittedCategory = z.omit(Category, { subcategories: true });
+  type PickedCategory = z.infer<typeof PickedCategory>;
+  type OmittedCategory = z.infer<typeof OmittedCategory>;
+  interface _PickedCategory {
+    name: string;
+  }
+  interface _OmittedCategory {
+    name: string;
+  }
+  expectTypeOf<PickedCategory>().toEqualTypeOf<_PickedCategory>();
+  expectTypeOf<OmittedCategory>().toEqualTypeOf<_OmittedCategory>();
+
+  const picked = { name: "test" };
+  const omitted = { name: "test" };
+
+  PickedCategory.parse(picked);
+  OmittedCategory.parse(omitted);
+
+  expect(() => PickedCategory.parse({ name: "test", subcategories: [] })).toThrow();
+  expect(() => OmittedCategory.parse({ name: "test", subcategories: [] })).toThrow();
+});
+
+test("deferred self-recursion", () => {
+  const Feature = z.object({
+    title: z.string(),
+    get features(): z.ZodMiniOptional<z.ZodMiniArray<typeof Feature>> {
+      return z.optional(z.array(Feature)); //.optional();
+    },
+  });
+  type Feature = z.infer<typeof Feature>;
+
+  const Output = z.object({
+    id: z.int(), //.nonnegative(),
+    name: z.string(),
+    features: z.array(Feature), //.array(), // <—
+  });
+
+  type Output = z.output<typeof Output>;
+
+  type _Feature = {
+    title: string;
+    features?: _Feature[] | undefined;
+  };
+
+  type _Output = {
+    id: number;
+    name: string;
+    features: _Feature[];
+  };
+
+  expectTypeOf<Feature>().toEqualTypeOf<_Feature>();
+  expectTypeOf<Output>().toEqualTypeOf<_Output>();
+});
+
+test("recursion compatibility", () => {
+  // array
+  const A = z.object({
+    get subcategories() {
+      return z.array(A);
+    },
+  });
+  // tuple
+  const B = z.object({
+    get subcategories() {
+      return z.tuple([B, B]);
+    },
+  });
+  // object
+  const C = z.object({
+    get subcategories() {
+      return z.object({
+        subcategories: C,
+      });
+    },
+  });
+  // union
+  const D = z.object({
+    get subcategories() {
+      return z.union([D, z.string()]);
+    },
+  });
+  // intersection
+  const E = z.object({
+    get subcategories() {
+      return z.intersection(E, E);
+    },
+  });
+  // record
+  const F = z.object({
+    get subcategories() {
+      return z.record(z.string(), F);
+    },
+  });
+  // map
+  const G = z.object({
+    get subcategories() {
+      return z.map(z.string(), G);
+    },
+  });
+  // set
+  const H = z.object({
+    get subcategories() {
+      return z.set(H);
+    },
+  });
+  // optional
+  const I = z.object({
+    get subcategories() {
+      return z.optional(I);
+    },
+  });
+  // nullable
+  const J = z.object({
+    get subcategories() {
+      return z.nullable(J);
+    },
+  });
+  // optional
+  const L = z.object({
+    get subcategories() {
+      return z.optional(L);
+    },
+  });
+  // nullable
+  const M = z.object({
+    get subcategories() {
+      return z.nullable(M);
+    },
+  });
+  // nonoptional
+  const N = z.object({
+    get subcategories() {
+      return z.nonoptional(N);
+    },
+  });
+});
+
+test("shape stays writeable through object/strictObject/looseObject/extend with getters", () => {
+  const Cat = z.object({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof Cat> {
+      return z.array(Cat);
+    },
+  });
+  type CatShape = (typeof Cat)["shape"];
+  expectTypeOf<CatShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof Cat>;
+  }>();
+
+  const StrictCat = z.strictObject({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof StrictCat> {
+      return z.array(StrictCat);
+    },
+  });
+  type StrictShape = (typeof StrictCat)["shape"];
+  expectTypeOf<StrictShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof StrictCat>;
+  }>();
+
+  const LooseCat = z.looseObject({
+    name: z.string(),
+    get sub(): z.ZodMiniArray<typeof LooseCat> {
+      return z.array(LooseCat);
+    },
+  });
+  type LooseShape = (typeof LooseCat)["shape"];
+  expectTypeOf<LooseShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof LooseCat>;
+  }>();
+
+  const Base = z.object({ name: z.string() });
+  const Extended = z.extend(Base, {
+    get sub(): z.ZodMiniArray<typeof Extended> {
+      return z.array(Extended);
+    },
+  });
+  type ExtendedShape = (typeof Extended)["shape"];
+  expectTypeOf<ExtendedShape>().toEqualTypeOf<{
+    name: z.ZodMiniString<string>;
+    sub: z.ZodMiniArray<typeof Extended>;
+  }>();
+});