@wecode-ai/weibo-openclaw-plugin 2.2.3 → 2.2.5

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

@@ -143,6 +143,12 @@ test("assignability", () => {
   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;

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

@@ -128,7 +128,9 @@ test("native enum", () => {
     fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
   });
 
+  // Absent keys flow through to the catch handler.
   expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
+  expect(schema.parse({}, { jitless: true })).toEqual({ fruit: Fruits.apple });
   expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
 });
 
@@ -138,6 +140,7 @@ test("enum", () => {
   });
 
   expect(schema.parse({})).toEqual({ fruit: "apple" });
+  expect(schema.parse({}, { jitless: true })).toEqual({ fruit: "apple" });
   expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
   expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
 });
@@ -274,3 +277,50 @@ test("direction-aware catch", () => {
   // But valid values should still work in reverse
   expect(z.encode(schema, "world")).toBe("world");
 });
+
+test("optional clobbers catch through pipe boundaries", () => {
+  expect(
+    z
+      .string()
+      .catch("X")
+      .transform((s) => s + "!")
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(z.string().catch("X").pipe(z.string()).optional().parse(undefined)).toBeUndefined();
+  expect(
+    z
+      .string()
+      .catch("X")
+      .transform((s) => s + "!")
+      .transform((s) => s.toLowerCase())
+      .optional()
+      .parse(undefined)
+  ).toBeUndefined();
+  expect(
+    z
+      .object({
+        a: z
+          .string()
+          .catch("X")
+          .transform((s) => s + "!")
+          .optional(),
+      })
+      .parse({})
+  ).toEqual({});
+
+  expect(
+    z
+      .string()
+      .catch("X")
+      .transform((s) => s + "!")
+      .parse("hi")
+  ).toBe("hi!");
+  expect(
+    z
+      .string()
+      .catch("X")
+      .transform((s) => s + "!")
+      .parse(123)
+  ).toBe("X!");
+});

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

@@ -1,4 +1,4 @@
-import { expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 
 const isoDateCodec = z.codec(
@@ -560,3 +560,144 @@ test("async codec functionality", async () => {
   const mixedResult = await z.decodeAsync(mixedCodec, "123");
   expect(mixedResult).toBe(123);
 });
+
+test("invertCodec basic", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+
+  const testDate = new Date("2024-01-15T10:30:00.000Z");
+  const decoded = z.decode(inverted, testDate);
+  expect(typeof decoded).toBe("string");
+  expect(decoded).toBe("2024-01-15T10:30:00.000Z");
+
+  const encoded = z.encode(inverted, "2024-01-15T10:30:00.000Z");
+  expect(encoded).toBeInstanceOf(Date);
+  expect(encoded.toISOString()).toBe("2024-01-15T10:30:00.000Z");
+});
+
+test("invertCodec round trip", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+  const testDate = new Date("2024-06-01T12:00:00.000Z");
+
+  const toStr = z.decode(inverted, testDate);
+  const backToDate = z.encode(inverted, toStr);
+  expect(backToDate.toISOString()).toBe(testDate.toISOString());
+});
+
+test("invertCodec types", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+
+  type InvIn = z.input<typeof inverted>;
+  type InvOut = z.output<typeof inverted>;
+  expectTypeOf<InvIn>().toEqualTypeOf<Date>();
+  expectTypeOf<InvOut>().toEqualTypeOf<string>();
+});
+
+test("invertCodec is its own inverse", () => {
+  const doubleInverted = z.invertCodec(z.invertCodec(isoDateCodec));
+  const testIsoString = "2024-03-10T08:00:00.000Z";
+
+  const decoded = z.decode(doubleInverted, testIsoString);
+  expect(decoded).toBeInstanceOf(Date);
+  expect(decoded.toISOString()).toBe(testIsoString);
+
+  const encoded = z.encode(doubleInverted, decoded);
+  expect(encoded).toBe(testIsoString);
+});
+
+test("invertCodec with custom codec", () => {
+  const intToString = z.codec(z.int(), z.string().regex(/^\d+$/), {
+    decode: (num) => num.toString(),
+    encode: (str) => Number.parseInt(str, 10),
+  });
+
+  const stringToInt = z.invertCodec(intToString);
+  const result = z.decode(stringToInt, "42");
+  expect(result).toBe(42);
+
+  const back = z.encode(stringToInt, 42);
+  expect(back).toBe("42");
+});
+
+describe("context immutability", () => {
+  test("decode/encode", () => {
+    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
+      decode: (isoString) => new Date(isoString),
+      encode: (date) => date.toISOString(),
+    });
+
+    const ctx = { reportInput: true } as const;
+
+    const result1 = z.decode(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(result1).toBeInstanceOf(Date);
+
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    const result2 = z.decode(stringToDateCodec, "2024-12-25T15:45:30.123Z", ctx);
+    expect(result2).toBeInstanceOf(Date);
+
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    z.encode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("direction" in ctx).toBe(false);
+
+    z.safeEncode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("direction" in ctx).toBe(false);
+  });
+
+  test("parse functions", () => {
+    const schema = z.string().min(1);
+    const ctx = { reportInput: true } as const;
+
+    z.parse(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    z.safeParse(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+  });
+
+  test("async functions", async () => {
+    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
+      decode: (isoString) => new Date(isoString),
+      encode: (date) => date.toISOString(),
+    });
+
+    const ctx = { reportInput: true } as const;
+
+    const schema = z.string();
+    await z.parseAsync(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    await z.safeParseAsync(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    await z.decodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.encodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.safeDecodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.safeEncodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+  });
+});

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

@@ -274,7 +274,7 @@ test("continuability", () => {
         "message": "Invalid cuid",
         "origin": "string",
         "path": [],
-        "pattern": "/^[cC][^\\s-]{8,}$/",
+        "pattern": "/^[cC][0-9a-z]{6,}$/",
       },
       {
         "code": "custom",

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

@@ -299,4 +299,4 @@ test("redos checker", () => {
     const result = checkSync(schema._zod.pattern.source, "");
     if (result.status !== "safe") throw Error("ReDoS issue");
   }
-});
+}, 10000);

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

@@ -332,6 +332,50 @@ test("defaulted array schema returns shallow clone", () => {
   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");
 

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([]);
+});

package/node_modules/zod/src/v4/classic/tests/discriminated-unions.test.ts

@@ -158,10 +158,14 @@ test("invalid discriminator value", () => {
         "errors": [],
         "note": "No matching discriminator",
         "discriminator": "type",
+        "options": [
+          "a",
+          "b"
+        ],
         "path": [
           "type"
         ],
-        "message": "Invalid input"
+        "message": "Invalid discriminator value. Expected 'a' | 'b'"
       }
     ]],
       "success": false,
@@ -260,6 +264,9 @@ test("valid discriminator value, invalid data", () => {
 });
 
 test("wrong schema - missing discriminator", () => {
+  // @ts-expect-error missing discriminator property
+  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
+
   try {
     z.discriminatedUnion("type", [
       z.object({ type: z.literal("a"), a: z.string() }),
@@ -659,3 +666,29 @@ test("def", () => {
   expect(schema.def.discriminator).toEqual("type");
   expect(schema.def.unionFallback).toEqual(true);
 });
+
+test("encode with codec discriminator", () => {
+  const codec1 = z.codec(z.literal(1), z.literal("one"), {
+    decode: () => "one" as const,
+    encode: () => 1 as const,
+  });
+
+  const codec2 = z.codec(z.literal(2), z.literal("two"), {
+    decode: () => "two" as const,
+    encode: () => 2 as const,
+  });
+
+  const schema = z.discriminatedUnion("type", [
+    z.object({ type: codec1, value: z.string() }),
+    z.object({ type: codec2, value: z.number() }),
+  ]);
+
+  // decode (forward) should work
+  const decoded = schema.decode({ type: 1, value: "hello" });
+  expect(decoded).toEqual({ type: "one", value: "hello" });
+
+  // encode (backward) should also work — the discriminator values differ
+  // between forward (1, 2) and backward ("one", "two") directions
+  const encoded = z.encode(schema, { type: "one", value: "hello" });
+  expect(encoded).toEqual({ type: 1, value: "hello" });
+});