@openclaw/nostr 2026.5.20 → 2026.5.22

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

@@ -0,0 +1,409 @@
+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("defaulted Map schema returns shallow clone", () => {
+  const schema = z.map(z.string(), z.number()).default(new Map([["a", 1]]));
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  expect(result1).not.toBe(result2);
+  expect(result1).toEqual(result2);
+});
+
+test("defaulted Set schema returns shallow clone", () => {
+  const schema = z.set(z.string()).default(new Set(["x"]));
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  expect(result1).not.toBe(result2);
+  expect(result1).toEqual(result2);
+});
+
+test("mutations on defaulted Map do not affect subsequent parses", () => {
+  const schema = z.map(z.string(), z.number()).default(new Map());
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  result1.set("key1", 1);
+  result2.set("key2", 2);
+  expect(result1.size).toBe(1);
+  expect(result1.get("key1")).toBe(1);
+  expect(result1.has("key2")).toBe(false);
+  expect(result2.size).toBe(1);
+  expect(result2.get("key2")).toBe(2);
+  expect(result2.has("key1")).toBe(false);
+});
+
+test("mutations on defaulted Set do not affect subsequent parses", () => {
+  const schema = z.set(z.string()).default(new Set());
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  result1.add("item1");
+  result2.add("item2");
+  expect(result1.size).toBe(1);
+  expect(result1.has("item1")).toBe(true);
+  expect(result1.has("item2")).toBe(false);
+  expect(result2.size).toBe(1);
+  expect(result2.has("item2")).toBe(true);
+  expect(result2.has("item1")).toBe(false);
+});
+
+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

@@ -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");
+  });
+});

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

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+const description = "a description";
+
+// test("passing `description` to schema should add a description", () => {
+//   expect(z.string({ description }).description).toEqual(description);
+//   expect(z.number({ description }).description).toEqual(description);
+//   expect(z.boolean({ description }).description).toEqual(description);
+// });
+
+test(".describe", () => {
+  expect(z.string().describe(description).description).toEqual(description);
+  expect(z.number().describe(description).description).toEqual(description);
+  expect(z.boolean().describe(description).description).toEqual(description);
+});
+
+test("adding description with z.globalRegistry", () => {
+  const schema = z.string();
+  z.core.globalRegistry.add(schema, { description });
+  z.core.globalRegistry.get(schema);
+  expect(schema.description).toEqual(description);
+});
+
+// in Zod 4 descriptions are not inherited
+// test("description should carry over to chained schemas", () => {
+//   const schema = z.string().describe(description);
+//   expect(schema.description).toEqual(description);
+//   expect(schema.optional().description).toEqual(description);
+//   expect(schema.optional().nullable().default("default").description).toEqual(description);
+// });

package/node_modules/zod/src/v4/classic/tests/detached-methods.test.ts

@@ -0,0 +1,197 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+/**
+ * Schema methods are exposed in a way that works when detached from the
+ * schema instance — `const opt = schema.optional; opt()` must produce a
+ * working `ZodOptional`, not a corrupt one. This pattern is used in real
+ * code (e.g. `arr.map(schema.parse)`, `arr.map(schema.optional)`,
+ * destructuring inside utility functions).
+ *
+ * This test caught a regression in colinhacks/zod#5870 where a memory
+ * optimization moved methods to the prototype and made `this`-binding
+ * required, silently breaking any detached usage.
+ */
+
+const probeArgs: Record<string, unknown[]> = {
+  // ZodType
+  optional: [],
+  exactOptional: [],
+  nullable: [],
+  nullish: [],
+  array: [],
+  describe: ["x"],
+  brand: [],
+  readonly: [],
+  default: ["fallback"],
+  catch: ["fallback"],
+  // _ZodString
+  min: [1],
+  max: [10],
+  length: [5],
+  nonempty: [],
+  trim: [],
+  toLowerCase: [],
+  toUpperCase: [],
+  // ZodString format methods
+  email: [],
+  url: [],
+  uuid: [],
+  cuid: [],
+  cuid2: [],
+  ulid: [],
+  base64: [],
+  base64url: [],
+  ipv4: [],
+  ipv6: [],
+  // ZodNumber
+  int: [],
+  positive: [],
+  negative: [],
+  finite: [],
+};
+
+test("detached parse-family methods work without `this` binding", () => {
+  const schema = z.string();
+  const { parse, safeParse } = schema;
+
+  expect(parse("hello")).toBe("hello");
+  expect(safeParse("hello").success).toBe(true);
+});
+
+test("detached schema.optional() returns a working ZodOptional", () => {
+  const schema = z.string();
+  const opt = schema.optional;
+
+  const detached = opt();
+
+  expect(detached).toBeInstanceOf(z.ZodOptional);
+  expect(detached.safeParse("hello").success).toBe(true);
+  expect(detached.safeParse(undefined).success).toBe(true);
+  expect(detached.safeParse(123).success).toBe(false);
+});
+
+test("detached schema.nullable() returns a working ZodNullable", () => {
+  const schema = z.string();
+  const nul = schema.nullable;
+
+  const detached = nul();
+
+  expect(detached).toBeInstanceOf(z.ZodNullable);
+  expect(detached.safeParse("hello").success).toBe(true);
+  expect(detached.safeParse(null).success).toBe(true);
+  expect(detached.safeParse(123).success).toBe(false);
+});
+
+test("detached schema.array() returns a working ZodArray", () => {
+  const schema = z.string();
+  const arr = schema.array;
+
+  const detached = arr();
+
+  expect(detached).toBeInstanceOf(z.ZodArray);
+  expect(detached.safeParse(["a", "b"]).success).toBe(true);
+  expect(detached.safeParse([1, 2]).success).toBe(false);
+});
+
+test("detached schema.describe() returns a described schema", () => {
+  const schema = z.string();
+  const describe = schema.describe;
+
+  const described = describe("hello world");
+
+  expect(described.description).toBe("hello world");
+});
+
+test("detached refinement still validates", () => {
+  const schema = z.string();
+  const refine = schema.refine;
+
+  const refined = refine((s: string) => s.startsWith("x"), "must start with x");
+
+  expect(refined.safeParse("xhello").success).toBe(true);
+  expect(refined.safeParse("hello").success).toBe(false);
+});
+
+test("detached chained calls work — schema.optional then parse", () => {
+  const schema = z.string();
+  const opt = schema.optional;
+  const optionalSchema = opt();
+  const { parse } = optionalSchema;
+
+  expect(parse("hi")).toBe("hi");
+  expect(parse(undefined)).toBe(undefined);
+});
+
+test("detached parse can be called as a free function", () => {
+  const schema = z.string();
+  const parse = schema.parse;
+  const inputs = ["a", "b", "c"];
+
+  const results = inputs.map((v) => parse(v));
+
+  expect(results).toEqual(["a", "b", "c"]);
+});
+
+test("detached methods on z.number() work", () => {
+  const schema = z.number();
+
+  const min = schema.min;
+  const max = schema.max;
+  const positive = schema.positive;
+
+  expect(min(5).safeParse(3).success).toBe(false);
+  expect(max(5).safeParse(7).success).toBe(false);
+  expect(positive().safeParse(-1).success).toBe(false);
+});
+
+test("detached object methods work", () => {
+  const schema = z.object({ a: z.string(), b: z.number() });
+
+  const pick = schema.pick;
+  const omit = schema.omit;
+  const partial = schema.partial;
+  const extend = schema.extend;
+
+  expect(Object.keys(pick({ a: true })._zod.def.shape)).toEqual(["a"]);
+  expect(Object.keys(omit({ a: true })._zod.def.shape)).toEqual(["b"]);
+  expect(partial().safeParse({}).success).toBe(true);
+  const extended = extend({ c: z.boolean() });
+  expect(Object.keys(extended._zod.def.shape).sort()).toEqual(["a", "b", "c"]);
+});
+
+// Sweep across many builder methods at once. If any of them break with the
+// `const m = schema.foo; m(...)` pattern, this test will report which.
+test("broad sweep: detaching builder methods does not throw or produce a corrupt schema", () => {
+  const stringSchema = z.string();
+  const numberSchema = z.number();
+
+  const broken: Array<{ method: string; reason: string }> = [];
+
+  for (const [methodName, args] of Object.entries(probeArgs)) {
+    const target: any = methodName in stringSchema ? stringSchema : methodName in numberSchema ? numberSchema : null;
+    if (!target) continue;
+
+    const detached = target[methodName] as Function | undefined;
+    if (typeof detached !== "function") continue;
+
+    try {
+      const result = detached(...args);
+      // If the detached call returned a schema, sanity-check it parses
+      // its base type. (e.g. `optional()` should accept its inner type.)
+      if (result && typeof result === "object" && "_zod" in result && typeof (result as any).safeParse === "function") {
+        const probeValue = target === stringSchema ? "x" : 1;
+        const r = (result as any).safeParse(probeValue);
+        // success or a clean failure are both fine — we only fail on throw or
+        // on a schema with corrupt internal state (innerType undefined etc).
+        if (r === undefined || (typeof r === "object" && !("success" in r))) {
+          broken.push({ method: methodName, reason: "safeParse returned malformed result" });
+        }
+      }
+    } catch (err: any) {
+      broken.push({ method: methodName, reason: err?.message ?? String(err) });
+    }
+  }
+
+  expect(broken).toEqual([]);
+});