@openclaw/feishu 2026.9.4 → 2026.9.5

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

@@ -170,8 +170,7 @@ test("tuple with all optional elements", () => {
 });
 
 test("tuple fills defaults for missing trailing elements", () => {
-  // Issue #5229: trailing `.default()`/`.prefault()` elements should be
-  // filled in when the input array is shorter than the tuple.
+  // Issue #5229: trailing `.default()`/`.prefault()` elements should be filled in when the input array is shorter than the tuple.
   const t = z.tuple([z.string(), z.string().default("bravo")]);
   expectTypeOf<typeof t._output>().toEqualTypeOf<[string, string]>();
   expectTypeOf<typeof t._input>().toEqualTypeOf<[string, (string | undefined)?]>();
@@ -188,8 +187,7 @@ test("tuple fills defaults for missing trailing elements", () => {
   // Prefault parity
   expect(z.tuple([z.string(), z.string().prefault("delta")]).parse(["alpha"])).toEqual(["alpha", "delta"]);
 
-  // Defaults wrapped in modifiers: `optout` propagates through these, so the
-  // fix is not type-name specific.
+  // Defaults wrapped in modifiers: `optout` propagates through these, so the fix is not type-name specific.
   expect(z.tuple([z.string(), z.string().default("x").nullable()]).parse(["alpha"])).toEqual(["alpha", "x"]);
   expect(z.tuple([z.string(), z.string().default("x").readonly()]).parse(["alpha"])).toEqual(["alpha", "x"]);
   expect(z.tuple([z.string(), z.string().default("x").catch("y")]).parse(["alpha"])).toEqual(["alpha", "x"]);
@@ -202,18 +200,13 @@ test("tuple fills defaults under async parse", async () => {
 });
 
 test("tuple keeps length-1 array for missing `.optional()` elements", () => {
-  // Backwards compat: a trailing `.optional()` element that is omitted from
-  // the input must NOT be filled with `undefined` — the result stays length-1.
-  // Only schemas that produce a defined value get materialized.
+  // Backwards compat: a trailing `.optional()` element that is omitted from the input must NOT be filled with `undefined` — the result stays length-1. Only schemas that produce a defined value get materialized.
   const t = z.tuple([z.string(), z.string().optional()]);
   const out = t.parse(["alpha"]);
   expect(out).toEqual(["alpha"]);
   expect(out.length).toEqual(1);
 
-  // `z.undefined()` is NOT a synonym for `.optional()` — its value type is
-  // *must be undefined*, so the slot is required input. Omitting it triggers
-  // a single `too_small` (no element-level errors, matching v3's abort
-  // semantics); passing explicit `undefined` succeeds and is preserved.
+  // `z.undefined()` is NOT a synonym for `.optional()` — its value type is *must be undefined*, so the slot is required input. Omitting it triggers a single `too_small` (no element-level errors, matching v3's abort semantics); passing explicit `undefined` succeeds and is preserved.
   expect(z.tuple([z.string(), z.undefined()]).safeParse(["alpha"]).error!.issues).toMatchInlineSnapshot(`
     [
       {
@@ -232,14 +225,12 @@ test("tuple keeps length-1 array for missing `.optional()` elements", () => {
   // optin/optout flags through the nullable wrapper.
   expect(z.tuple([z.string(), z.string().optional().nullable()]).parse(["alpha"])).toHaveLength(1);
 
-  // Multiple trailing optionals trim the same way — we don't fill the tail
-  // with literal `undefined`s.
+  // Multiple trailing optionals trim the same way — we don't fill the tail with literal `undefined`s.
   const many = z.tuple([z.string(), z.string().optional(), z.string().optional(), z.string().optional()]);
   expect(many.parse(["alpha"])).toEqual(["alpha"]);
   expect(many.parse(["alpha", "beta"])).toEqual(["alpha", "beta"]);
 
-  // Explicit `undefined` inside `input.length` IS preserved — only slots
-  // past the input get trimmed.
+  // Explicit `undefined` inside `input.length` IS preserved — only slots past the input get trimmed.
   const r = many.parse(["alpha", undefined]);
   expect(r.length).toEqual(2);
   expect(1 in r).toEqual(true);
@@ -261,15 +252,13 @@ test("tuple result is dense when optional precedes a default", () => {
   expect(1 in r).toEqual(true);
   expect(JSON.stringify(r)).toEqual('["alpha",null,"z"]');
 
-  // Trailing optional after a default is still dropped (no later default
-  // forces it to materialize).
+  // Trailing optional after a default is still dropped (no later default forces it to materialize).
   expect(z.tuple([z.string(), z.string().default("d"), z.string().optional()]).parse(["alpha"])).toEqual([
     "alpha",
     "d",
   ]);
 
-  // Multiple interleaved optional/default — every slot up to the last
-  // default must be present and dense.
+  // Multiple interleaved optional/default — every slot up to the last default must be present and dense.
   const interleaved = z.tuple([
     z.string(),
     z.string().optional(),
@@ -283,9 +272,7 @@ test("tuple result is dense when optional precedes a default", () => {
 });
 
 test("tuple truncates absent optional rejections only when the output tail is optional", () => {
-  // An absent optional-output slot can only be swallowed when every later
-  // output slot is optional too. If a later default would make the output tail
-  // required, truncating would violate the tuple's output type.
+  // An absent optional-output slot can only be swallowed when every later output slot is optional too. If a later default would make the output tail required, truncating would violate the tuple's output type.
   const refusesUndefined = z
     .string()
     .optional()
@@ -296,8 +283,7 @@ test("tuple truncates absent optional rejections only when the output tail is op
   expect(r1.success).toBe(false);
   expect(r1.error!.issues[0].path).toEqual([1]);
 
-  // Optional slots BEFORE the rejected one still cannot hide a later required
-  // output slot.
+  // Optional slots BEFORE the rejected one still cannot hide a later required output slot.
   const beforeReject = z.tuple([z.string(), z.string().optional(), refusesUndefined, z.string().default("d")]);
   const r2 = beforeReject.safeParse(["alpha"]);
   expect(r2.success).toBe(false);
@@ -333,8 +319,7 @@ test("tuple rejects absent exact optional before defaulted output", () => {
   expect(schema.parse(["alpha", "bravo"])).toEqual(["alpha", "bravo", "fallback"]);
   expect(schema.safeParse(["alpha", undefined]).success).toBe(false);
 
-  // With no later required output slot, exact optional still behaves like an
-  // omitted tuple tail and truncates cleanly.
+  // With no later required output slot, exact optional still behaves like an omitted tuple tail and truncates cleanly.
   expect(z.tuple([z.string(), z.string().exactOptional(), z.string().optional()]).parse(["alpha"])).toEqual(["alpha"]);
 });
 
@@ -371,10 +356,7 @@ test("tuple preserves explicit undefined inside input even for optional-out sche
 });
 
 test("tuple does NOT break when a required slot fails past input length", () => {
-  // A required slot (no `.optional()` chain, so optout !== "optional") past
-  // input length must still surface an issue rather than silently swallowing
-  // it. Otherwise we'd accept arbitrarily short tuples for required-tail
-  // schemas. The precheck collapses this into a single `too_small`.
+  // A required slot (no `.optional()` chain, so optout !== "optional") past input length must still surface an issue rather than silently swallowing it. Otherwise we'd accept arbitrarily short tuples for required-tail schemas. The precheck collapses this into a single `too_small`.
   const schema = z.tuple([z.string(), z.string()]);
   expect(schema.safeParse(["alpha"]).error!.issues).toMatchInlineSnapshot(`
     [
@@ -494,3 +476,36 @@ test("too_big tuple still surfaces element-wise type errors for present indices"
     ]
   `);
 });
+
+test("partial", () => {
+  const schema = z.tuple([z.string(), z.number(), z.boolean()]).partial();
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<
+    [(string | undefined)?, (number | undefined)?, (boolean | undefined)?]
+  >();
+
+  expect(schema.parse([])).toEqual([]);
+  expect(schema.parse(["a"])).toEqual(["a"]);
+  expect(schema.parse(["a", 1, true])).toEqual(["a", 1, true]);
+  expect(schema.safeParse(["a", "b"]).success).toEqual(false);
+  expect(schema.safeParse(["a", 1, true, 4]).success).toEqual(false);
+
+  // the arity relaxation has to survive the JSON Schema round trip: `minItems` disappears
+  expect(z.toJSONSchema(schema)).toEqual(
+    z.toJSONSchema(z.tuple([z.string().optional(), z.number().optional(), z.boolean().optional()]))
+  );
+});
+
+test("partial leaves rest alone", () => {
+  const schema = z.tuple([z.string()], z.number()).partial();
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<[(string | undefined)?, ...number[]]>();
+
+  expect(schema.parse([])).toEqual([]);
+  expect(schema.parse(["a", 1, 2])).toEqual(["a", 1, 2]);
+  // discriminating input: `true` only if rest had been wrapped too
+  expect(schema.safeParse(["a", undefined]).success).toEqual(false);
+});
+
+test("partial rejects a tuple carrying refinements", () => {
+  const schema = z.tuple([z.string(), z.number()]).refine(([a]) => a.length > 0);
+  expect(() => schema.partial()).toThrow("cannot be used on tuple schemas containing refinements");
+});

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

@@ -198,8 +198,45 @@ test("z.xor() - multiple matches fails", () => {
   const result = schema.safeParse("hello");
   expect(result.success).toBe(false);
   if (!result.success) {
-    expect(result.error.issues[0].code).toBe("invalid_union");
-    expect((result.error.issues[0] as any).inclusive).toBe(false);
+    expect(result.error.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_union",
+          "errors": [],
+          "inclusive": false,
+          "matches": [
+            0,
+            1,
+          ],
+          "message": "Invalid input: more than one option matched",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});
+
+test("z.xor() - multiple matches reports every matching option", () => {
+  // non-strict objects strip unknown keys, so both branches accept the extra key
+  const name = z.object({ name: z.string() });
+  const version = name.extend({ version: z.string() });
+  const result = z.xor([name, version, z.unknown()]).safeParse({ name: "windows", version: "10" });
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    const issue = result.error.issues[0] as z.core.$ZodIssueInvalidUnion;
+    expect(issue.inclusive).toBe(false);
+    expect((issue as Extract<typeof issue, { inclusive: false }>).matches).toEqual([0, 1, 2]);
+    expect(issue.message).toBe("Invalid input: more than one option matched");
+  }
+});
+
+test("z.xor() - zero matches keeps the per-option errors", () => {
+  const result = z.xor([z.string(), z.number()]).safeParse(true);
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    const issue = result.error.issues[0] as z.core.$ZodIssueInvalidUnion;
+    expect(issue.errors).toHaveLength(2);
+    expect(issue.message).toBe("Invalid input");
   }
 });
 

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

@@ -0,0 +1,76 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as zm from "zod/mini";
+import * as z from "zod/v4";
+
+test("validate answers like safeParse.success", () => {
+  expect(z.validate(z.string(), "asdf")).toBe(true);
+  expect(z.validate(z.string(), 12)).toBe(false);
+  expect(z.validate(z.number().int().min(0), 5)).toBe(true);
+  expect(z.validate(z.number().int().min(0), -5)).toBe(false);
+  const schema = z.object({ a: z.string(), b: z.array(z.number()) });
+  expect(z.validate(schema, { a: "x", b: [1, 2] })).toBe(true);
+  expect(z.validate(schema, { a: "x", b: [1, "2"] })).toBe(false);
+  expect(z.validate(schema, null)).toBe(false);
+});
+
+test("validate runs transforms and refinements for the verdict only", () => {
+  const schema = z
+    .string()
+    .transform((s) => s.length)
+    .pipe(z.number().max(3));
+  expect(z.validate(schema, "ab")).toBe(true);
+  expect(z.validate(schema, "abcd")).toBe(false);
+  expect(z.validate(z.coerce.number(), "5")).toBe(true);
+});
+
+test("validate narrows to the input type", () => {
+  const value: unknown = "hi";
+  if (z.validate(z.string(), value)) {
+    expectTypeOf(value).toEqualTypeOf<string>();
+  }
+  const transforming = z.string().transform((s) => s.length);
+  if (z.validate(transforming, value)) {
+    expectTypeOf(value).toEqualTypeOf<string>();
+  }
+});
+
+test("validate throws on async schemas; validateAsync handles them", async () => {
+  const schema = z.string().refine(async (s) => s.length > 2);
+  expect(() => z.validate(schema, "asdf")).toThrow();
+  await expect(z.validateAsync(schema, "asdf")).resolves.toBe(true);
+  await expect(z.validateAsync(schema, "a")).resolves.toBe(false);
+  await expect(z.validateAsync(z.string(), "a")).resolves.toBe(true);
+  // a promise-returning callback that is not declared async compiles, so the compiled schema must stay off the fast path
+  const compiled = z.compile(z.string().refine((s) => Promise.resolve(s.length > 1)));
+  await expect(z.validateAsync(compiled, "abc")).resolves.toBe(true);
+  await expect(z.validateAsync(compiled, "a")).resolves.toBe(false);
+});
+
+test("validate agrees with the compiled fast path and keeps the callback bound", () => {
+  let calls = 0;
+  const schema = z.object({
+    name: z.string().refine((s) => {
+      calls++;
+      return s.length > 1;
+    }),
+  });
+  const compiled = z.compile(schema);
+
+  calls = 0;
+  expect(z.validate(compiled, { name: "ok" })).toBe(true);
+  expect(calls).toBe(1);
+
+  calls = 0;
+  expect(z.validate(compiled, { name: "x" })).toBe(false);
+  expect(calls).toBeLessThanOrEqual(2);
+
+  expect(z.validate(compiled, { name: 42 })).toBe(false);
+  expect(z.validate(schema, { name: "ok" })).toBe(true);
+});
+
+test("validate is exported from zod/mini", () => {
+  expect(zm.validate(zm.string(), "a")).toBe(true);
+  expect(zm.validate(zm.string(), 1)).toBe(false);
+  expect(zm.validate(zm.object({ a: zm.number() }), { a: 1 })).toBe(true);
+});

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

@@ -13,7 +13,7 @@ test("string length", async () => {
           "code": "too_small",
           "exact": true,
           "inclusive": true,
-          "message": "Too small: expected string to have >=4 characters",
+          "message": "Too small: expected string to have exactly 4 characters",
           "minimum": 4,
           "origin": "string",
           "path": [],
@@ -33,7 +33,7 @@ test("string length", async () => {
           "exact": true,
           "inclusive": true,
           "maximum": 4,
-          "message": "Too big: expected string to have <=4 characters",
+          "message": "Too big: expected string to have exactly 4 characters",
           "origin": "string",
           "path": [],
         },

package/node_modules/zod/src/v4/core/api.ts

@@ -229,8 +229,8 @@ export function _emoji<T extends schemas.$ZodEmoji>(
 }
 
 // NanoID
-export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
-export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
+export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
+export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
 // @__NO_SIDE_EFFECTS__
 export function _nanoid<T extends schemas.$ZodNanoID>(
   Class: util.SchemaClass<T>,
@@ -481,6 +481,23 @@ export function _e164<T extends schemas.$ZodE164>(
   });
 }
 
+// CreditCard
+export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
+// @__NO_SIDE_EFFECTS__
+export function _creditCard<T extends schemas.$ZodCreditCard>(
+  Class: util.SchemaClass<T>,
+  params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams
+): T {
+  return new Class({
+    type: "string",
+    format: "credit_card",
+    check: "string_format",
+    abort: false,
+    ...util.normalizeParams(params),
+  });
+}
+
 // JWT
 export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
 export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
@@ -1110,6 +1127,15 @@ export function _property<K extends string, T extends schemas.$ZodType>(
   });
 }
 
+// @__NO_SIDE_EFFECTS__
+export function _properties<Shape extends schemas.$ZodShape>(
+  shape: Shape
+): checks.$ZodCheckProperty<{ -readonly [k in keyof Shape]: core.output<Shape[k]> }>[] {
+  return Object.entries(shape).map(
+    ([property, schema]) => new checks.$ZodCheckProperty({ check: "property", property, schema })
+  ) as any;
+}
+
 export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
 // @__NO_SIDE_EFFECTS__
 export function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType {
@@ -1207,19 +1233,26 @@ export function _xor<const T extends readonly schemas.$ZodObject[]>(
 }
 
 // ZodDiscriminatedUnion
-export interface $ZodTypeDiscriminableInternals<Disc extends string = string>
-  extends schemas.$ZodTypeInternals<unknown, { [K in Disc]?: unknown }> {
+
+// The bound stops at `propValues`; it deliberately does not check that the option carries the discriminator. Any such check has to name the option's `input`, and constraining `input` in argument position forces TypeScript to resolve it while checking the call — circular for an option whose input references the union, which collapses the whole union to `any`. `$ZodDiscriminatedUnion` validates the discriminator lazily instead, when it builds its lookup map.
+//
+// Validating eagerly through `propValues` is not available: reading it runs the option's shape getters, and for a recursive option that getter references the union whose initializer is still running, so it throws `ReferenceError: Cannot access '...' before initialization`.
+//
+// `Object.keys` on the shape is recursion-safe by contrast — it lists the keys without invoking them — so an eager check is reachable. It was tried and reverted: a key list derived from the shape cannot be kept in agreement with `shape` itself, which resolves lazily over the object the caller passed and then freezes to a copy, and it charged every object schema construction time and memory for a check only this one type reads.
+//
+// `_Disc` is unused and retained only so `$ZodTypeDiscriminable<"kind">` keeps compiling for external callers.
+export interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$ZodTypeInternals {
   propValues: util.PropValues;
 }
 
-export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
-  _zod: $ZodTypeDiscriminableInternals<Disc>;
+export interface $ZodTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
+  _zod: $ZodTypeDiscriminableInternals;
 }
 
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
 // @__NO_SIDE_EFFECTS__
 export function _discriminatedUnion<
-  Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]],
+  Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]],
   Disc extends string,
 >(
   Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>,
@@ -1229,7 +1262,7 @@ export function _discriminatedUnion<
 ): schemas.$ZodDiscriminatedUnion<Types, Disc> {
   return new Class({
     type: "union",
-    options,
+    options: options as any as schemas.$ZodType[],
     discriminator,
     ...util.normalizeParams(params),
   }) as any;
@@ -1289,7 +1322,7 @@ export function _tuple(
 }
 
 // ZodRecord
-export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
+export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType" | "partial">;
 // @__NO_SIDE_EFFECTS__
 export function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(
   Class: util.SchemaClass<schemas.$ZodRecord>,
@@ -1519,7 +1552,7 @@ export function _catch<T extends schemas.$ZodObject>(
   return new Class({
     type: "catch",
     innerType,
-    catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as any,
+    catchValue: (typeof catchValue === "function" ? catchValue : util.constantCatch(catchValue)) as any,
   }) as any;
 }
 
@@ -1669,7 +1702,7 @@ export function _superRefine<T>(
         const _issue: any = issue;
         if (_issue.fatal) _issue.continue = false;
         _issue.code ??= "custom";
-        _issue.input ??= payload.value;
+        if (!("input" in _issue)) _issue.input = payload.value;
         _issue.inst ??= ch;
         _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
         payload.issues.push(util.issue(_issue));
@@ -1795,6 +1828,10 @@ export function _stringbool(
     error: params.error,
   }) as any;
 
+  codec._zod.bag.truthy = truthyArray;
+  codec._zod.bag.falsy = falsyArray;
+  codec._zod.bag.case = params.case ?? "insensitive";
+
   return codec;
 }
 
@@ -1807,7 +1844,6 @@ export function _stringFormat<Format extends string>(
 ): schemas.$ZodCustomStringFormat<Format> {
   const params = util.normalizeParams(_params);
   const def: schemas.$ZodCustomStringFormatDef = {
-    ...util.normalizeParams(_params),
     check: "string_format",
     type: "string",
     format,