@openclaw/diffs 2026.9.4 → 2026.9.6

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

@@ -58,3 +58,70 @@ test("instanceof respects customError", () => {
 
   z.config({ customError: undefined });
 });
+
+test("z.properties", () => {
+  const httpsUrl = z.instanceof(URL).check(
+    ...z.properties({
+      protocol: z.literal("https:"),
+      hostname: z.string().regex(z.regexes.domain),
+    })
+  );
+
+  expectTypeOf<URL>().toEqualTypeOf<z.infer<typeof httpsUrl>>();
+  expect(httpsUrl.safeParse(new URL("https://example.com")).success).toBe(true);
+
+  // One check iterates the whole shape, so every failing property reports — unlike the equivalent chain of z.property() calls, which aborts on the first.
+  const both = httpsUrl.safeParse(new URL("http://localhost"));
+  expect(both.error!.issues.map((i) => i.path)).toEqual([["protocol"], ["hostname"]]);
+
+  // A failing base schema yields its own issue and no property issues.
+  for (const input of ["not a url", null]) {
+    const issues = httpsUrl.safeParse(input).error!.issues;
+    expect(issues.map((i) => [i.code, i.path])).toEqual([["custom", []]]);
+  }
+
+  // Not specific to z.instanceof(). A base whose type mismatch aborts implicitly rather than explicitly must still not run the property checks against the rejected value.
+  const obj = z
+    .object({ a: z.string(), b: z.string() })
+    .check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
+  expect(obj.safeParse({ a: "x", b: "y" }).success).toBe(true);
+  expect(obj.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
+  for (const input of [null, undefined, 5]) {
+    expect(obj.safeParse(input).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
+  }
+
+  // Known looseness versus the longhand, pinned so it stays deliberate: the check is typed over the whole shape, and `$ZodCheckInternals.check()` is a method, so TypeScript compares it bivariantly and accepts a check type that is a subtype of the target. Naming a key the target lacks therefore compiles here and fails at parse time, where the equivalent chain of `z.property()` calls rejects it outright.
+  z.object({ a: z.string() }).check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
+  expect(
+    z
+      .object({ a: z.string() })
+      .check(...z.properties({ a: z.string(), b: z.literal("y") }))
+      .safeParse({ a: "ok" })
+      .error!.issues.map((i) => [i.code, i.path])
+  ).toEqual([["invalid_value", ["b"]]]);
+
+  // literal and enum inputs widen to their primitive, so a `string`/`boolean` property accepts them without a cast, while a genuine type mismatch or an unknown key still fails to compile
+  z.instanceof(URL).check(z.property("protocol", z.literal("https:")));
+  z.instanceof(Request).check(...z.properties({ method: z.enum(["POST", "PUT"]), bodyUsed: z.literal(false) }));
+  // @ts-expect-error length is a number
+  z.string().check(z.property("length", z.string()));
+  // @ts-expect-error no such key
+  z.instanceof(URL).check(z.property("nope", z.string()));
+
+  // the check feeds the property value into its schema, so it is typed over the input side rather than the output
+  const stringToLength = z.property(
+    "a",
+    z.string().transform((s) => s.length)
+  );
+  z.object({ a: z.string() }).check(stringToLength);
+  // @ts-expect-error a is a number, the schema takes a string
+  z.object({ a: z.number() }).check(stringToLength);
+
+  // The properties check carries no `when`, so the schema stays on the compiled fast path.
+  const compiled = z.compile(httpsUrl);
+  expect(compiled.safeParse(new URL("https://example.com")).success).toBe(true);
+  expect(compiled.safeParse(new URL("http://localhost")).error!.issues.map((i) => i.path)).toEqual([
+    ["protocol"],
+    ["hostname"],
+  ]);
+});

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

@@ -67,6 +67,24 @@ test("object intersection: strict + strict", () => {
   `);
 });
 
+test("object intersection strips __proto__ from pass-through operands", () => {
+  const cases = [
+    [
+      z.intersection(z.object({ name: z.string() }), z.unknown()),
+      JSON.parse('{"__proto__":{"isAdmin":true},"name":"alice"}'),
+      { name: "alice" },
+    ],
+    [z.intersection(z.record(z.string(), z.unknown()), z.any()), JSON.parse('{"__proto__":{},"a":1}'), { a: 1 }],
+  ] as const;
+
+  for (const [schema, input, expected] of cases) {
+    const parsed = schema.parse(input);
+    expect(parsed).toEqual(expected);
+    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(parsed, "__proto__")).toBe(false);
+  }
+});
+
 test("deep intersection", () => {
   const Animal = z.object({
     properties: z.object({
@@ -196,3 +214,121 @@ test("invalid deep merge of object and array combination", async () => {
     `[Error: Unmergable intersection. Error path: ["students",0,"name"]]`
   );
 });
+
+// A record's key schema says which keys that record GOVERNS; it is not a predicate
+// every key in the result must satisfy. TypeScript works the same way: in
+// `{name: string} & Record<`S_${string}`, string>` the index signature constrains
+// only the keys matching it, so `name` is fine. So a key one side does not govern
+// is reconciled against the other side, exactly as unrecognized_keys already is.
+test("a record's key schema governs only its own keys inside an intersection", () => {
+  const Obj = z.object({ name: z.string() });
+  const value = { name: "a", S_a: "s" };
+
+  // Every key-schema flavor behaves the same: `name` belongs to the object side.
+  expect(z.intersection(Obj, z.record(z.string().regex(/^S_/), z.string())).parse(value)).toEqual(value);
+  expect(z.intersection(Obj, z.record(z.templateLiteral(["S_", z.string()]), z.string())).parse(value)).toEqual(value);
+  expect(z.intersection(Obj, z.partialRecord(z.enum(["p1", "p2"]), z.string())).parse({ name: "a", p1: "x" })).toEqual({
+    name: "a",
+    p1: "x",
+  });
+  expect(z.intersection(Obj, z.record(z.enum(["p1"]), z.string())).parse({ name: "a", p1: "x" })).toEqual({
+    name: "a",
+    p1: "x",
+  });
+
+  // A key the record DOES govern still has its value validated across the intersection.
+  const governed = z.intersection(z.object({ S_x: z.number() }), z.record(z.string().regex(/^S_/), z.string()));
+  expect(governed.safeParse({ S_x: 1 }).success).toBe(false);
+
+  // A key NEITHER side governs is still rejected.
+  const strict = z.intersection(z.strictObject({ name: z.string() }), z.record(z.string().regex(/^S_/), z.string()));
+  expect(strict.parse(value)).toEqual(value);
+  expect(strict.safeParse({ ...value, evil: "q" }).success).toBe(false);
+
+  // Standalone, a record still rejects a key it does not govern.
+  expect(z.record(z.string().regex(/^S_/), z.string()).safeParse({ S_a: "s", bad: "x" }).success).toBe(false);
+});
+
+test("partialRecord reports an out-of-set key as unrecognized, not invalid", () => {
+  const enumKeys = z.partialRecord(z.enum(["a", "b"]), z.string()).safeParse({ a: "x", zzz: "q" });
+  expect(enumKeys.success).toBe(false);
+  expect(enumKeys.error!.issues[0].code).toBe("unrecognized_keys");
+
+  // A regex key schema still reports the failure as an invalid key.
+  const regexKeys = z.record(z.string().regex(/^S_/), z.string()).safeParse({ S_a: "x", zzz: "q" });
+  expect(regexKeys.success).toBe(false);
+  expect(regexKeys.error!.issues[0].code).toBe("invalid_key");
+});
+
+test("intersection operands run their own checks, refinements and transforms", () => {
+  let checks = 0;
+  const failing = z.intersection(
+    z.strictObject({ x: z.string() }).check(() => {
+      checks++;
+    }),
+    z.strictObject({ a: z.string() }).superRefine((_data, ctx) => {
+      checks++;
+      ctx.addIssue({ code: "custom", message: "boom" });
+    })
+  );
+  expect(failing.safeParse({ x: "test", a: "hello" })).toMatchObject({
+    success: false,
+    error: { issues: [{ code: "custom", message: "boom" }] },
+  });
+  expect(checks).toBe(2);
+
+  const transformed = z.intersection(
+    z.strictObject({ x: z.string() }).transform((v) => ({ ...v, x: v.x.toUpperCase() })),
+    z.strictObject({ a: z.string() }).transform((v) => ({ ...v, seen: true }))
+  );
+  expect(transformed.parse({ x: "test", a: "hello" })).toEqual({ x: "TEST", a: "hello", seen: true });
+});
+
+test("intersection operands apply defaults, including through a nested intersection", () => {
+  const inner = z.intersection(
+    z.strictObject({ x: z.string().default("X default"), y: z.number() }),
+    z.strictObject({ z: z.boolean() })
+  );
+  const schema = z.intersection(inner, z.strictObject({ a: z.string() }));
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ x: string; y: number } & { z: boolean } & { a: string }>();
+
+  expect(schema.parse({ y: 34, z: true, a: "hello" })).toEqual({ x: "X default", y: 34, z: true, a: "hello" });
+});
+
+test("a record operand runs its own refinements inside an intersection", () => {
+  let calls = 0;
+  const schema = z
+    .record(z.enum(["p1", "p2"]), z.string())
+    .superRefine((_data, ctx) => {
+      calls++;
+      ctx.addIssue({ code: "custom", message: "record refined" });
+    })
+    .and(z.strictObject({ name: z.string() }));
+
+  expect(schema.safeParse({ p1: "a", p2: "b", name: "n" })).toMatchObject({
+    success: false,
+    error: { issues: [{ code: "custom", message: "record refined" }] },
+  });
+  expect(calls).toBe(1);
+});
+
+test("a strict object nested under an operand keeps its strictness", () => {
+  const schema = z.intersection(
+    z.object({ inner: z.strictObject({ a: z.string() }) }),
+    z.object({ other: z.string() })
+  );
+
+  expect(schema.parse({ inner: { a: "x" }, other: "y" })).toEqual({ inner: { a: "x" }, other: "y" });
+  expect(schema.safeParse({ inner: { a: "x", extra: 1 }, other: "y" })).toMatchObject({
+    success: false,
+    error: { issues: [{ code: "unrecognized_keys", keys: ["extra"], path: ["inner"] }] },
+  });
+});
+
+test("a strict object composes with a refined object", () => {
+  const A = z.object({ key1: z.boolean() }).strict();
+  const B = z.object({ key2: z.boolean() }).refine(({ key2 }) => key2, "key2 must be true");
+
+  expect(A.and(B).parse({ key1: true, key2: true })).toEqual({ key1: true, key2: true });
+  expect(A.and(B).safeParse({ key1: true, key2: false }).success).toBe(false);
+});

package/node_modules/zod/src/v4/classic/tests/issue-schema.test.ts

@@ -0,0 +1,215 @@
+import { afterEach, expect, test } from "vitest";
+import * as z from "zod/v4";
+
+afterEach(() => {
+  z.config({ customError: undefined });
+});
+
+/** Error maps run on the first read of `error`, so a test that only observes them reads it. */
+const fail = (r: { error?: unknown }) => r.error;
+
+/** Collects the owning schema's registered metadata for every issue an error map sees. */
+function captureMeta(): { seen: (z.core.GlobalMeta | undefined)[] } {
+  const seen: (z.core.GlobalMeta | undefined)[] = [];
+  z.config({
+    customError: (issue) => {
+      seen.push(issue.schema && z.globalRegistry.get(issue.schema));
+      return undefined;
+    },
+  });
+  return { seen };
+}
+
+test("check-originated issues expose the owning schema", () => {
+  const { seen } = captureMeta();
+
+  fail(z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: "ab" }));
+  fail(z.string().max(2).meta({ title: "Max" }).safeParse("abc"));
+  fail(z.email().meta({ title: "Email" }).safeParse("nope"));
+  fail(z.number().multipleOf(3).meta({ title: "Multiple" }).safeParse(4));
+  fail(z.array(z.string()).min(2).meta({ title: "Array" }).safeParse([]));
+
+  expect(seen).toEqual([
+    { title: "Name" },
+    { title: "Max" },
+    { title: "Email" },
+    { title: "Multiple" },
+    { title: "Array" },
+  ]);
+});
+
+test("schema-originated issues expose the owning schema", () => {
+  const { seen } = captureMeta();
+
+  fail(z.object({ name: z.string().min(5).meta({ title: "Name" }) }).safeParse({ name: 123 }));
+  fail(z.email().meta({ title: "Email" }).safeParse(123));
+
+  expect(seen).toEqual([{ title: "Name" }, { title: "Email" }]);
+});
+
+test("refinements attribute to the refined schema, not the internal check schema", () => {
+  const { seen } = captureMeta();
+
+  fail(
+    z
+      .string()
+      .refine(() => false)
+      .meta({ title: "Refine" })
+      .safeParse("abc")
+  );
+  fail(
+    z
+      .string()
+      .superRefine((_, ctx) => ctx.addIssue({ code: "custom", message: "" }))
+      .meta({ title: "SuperRefine" })
+      .safeParse("abc")
+  );
+
+  expect(seen).toEqual([{ title: "Refine" }, { title: "SuperRefine" }]);
+});
+
+test("the innermost schema owns the issue", () => {
+  const { seen } = captureMeta();
+
+  fail(
+    z
+      .array(z.string().min(5).meta({ title: "Element" }))
+      .meta({ title: "Array" })
+      .safeParse(["ab"])
+  );
+  fail(
+    z
+      .string()
+      .pipe(z.string().min(5).meta({ title: "Target" }))
+      .meta({ title: "Pipe" })
+      .safeParse("ab")
+  );
+  fail(
+    z
+      .looseObject({})
+      .check(z.property("a", z.string().meta({ title: "Property" })))
+      .meta({ title: "Object" })
+      .safeParse({ a: 1 })
+  );
+
+  expect(seen).toEqual([{ title: "Element" }, { title: "Target" }, { title: "Property" }]);
+});
+
+test("issues carrying no usable `inst` still get the owning schema", () => {
+  const { seen } = captureMeta();
+
+  // A hand-pushed issue may carry no inst at all, and ctx.addIssue(string) puts the check's def — not a Zod object — on inst.
+  fail(
+    z
+      .string()
+      .check((payload) => {
+        payload.issues.push({ code: "custom", input: payload.value });
+      })
+      .meta({ title: "Bare" })
+      .safeParse("abc")
+  );
+  const shorthand = z
+    .string()
+    .superRefine((_, ctx) => ctx.addIssue("bad stuff"))
+    .meta({ title: "Shorthand" })
+    .safeParse("abc");
+
+  expect(seen).toEqual([{ title: "Bare" }]);
+  expect(shorthand.error!.issues[0].message).toEqual("bad stuff");
+});
+
+test("async checks expose the owning schema", async () => {
+  const { seen } = captureMeta();
+
+  fail(
+    await z
+      .string()
+      .refine(async () => false)
+      .meta({ title: "Async" })
+      .safeParseAsync("abc")
+  );
+
+  expect(seen).toEqual([{ title: "Async" }]);
+});
+
+test("the owning schema is the clone `.meta()` registered, not the pre-metadata schema", () => {
+  const bare = z.string().min(5);
+  const labeled = bare.meta({ title: "Labeled" });
+  const seen: unknown[] = [];
+  z.config({
+    customError: (issue) => {
+      seen.push(issue.schema === labeled);
+      return undefined;
+    },
+  });
+
+  fail(labeled.safeParse("ab"));
+
+  expect(seen).toEqual([true]);
+});
+
+test("`inst` keeps its meaning and `schema` stays off the finalized issue", () => {
+  const insts: string[] = [];
+  z.config({
+    customError: (issue) => {
+      insts.push(issue.inst!.constructor.name);
+      return undefined;
+    },
+  });
+
+  const tooSmall = z.string().min(5).safeParse("ab").error!;
+  const wrongType = z.string().safeParse(123).error!;
+
+  expect(insts).toEqual(["$ZodCheckMinLength", "ZodString"]);
+  expect(Object.keys(tooSmall.issues[0])).not.toContain("schema");
+  expect(Object.keys(wrongType.issues[0])).not.toContain("schema");
+});
+
+test("every error map kind receives the owning schema", () => {
+  const seen: Record<string, z.core.GlobalMeta | undefined> = {};
+  const capture = (key: string) => (issue: { schema?: z.core.$ZodType | undefined }) => {
+    seen[key] = issue.schema && z.globalRegistry.get(issue.schema);
+    return undefined;
+  };
+
+  fail(
+    z
+      .string()
+      .min(5, { error: capture("check") })
+      .meta({ title: "Check" })
+      .safeParse("ab")
+  );
+
+  // A schema-bound map is only consulted for issues the schema itself raised, so this one needs a type error.
+  fail(
+    z
+      .string({ error: capture("schema") })
+      .meta({ title: "Schema" })
+      .safeParse(123)
+  );
+
+  fail(
+    z
+      .string()
+      .min(5)
+      .meta({ title: "Parse" })
+      .safeParse("ab", { error: capture("parse") })
+  );
+
+  z.config({ customError: capture("customError") });
+  fail(z.string().min(5).meta({ title: "Custom" }).safeParse("ab"));
+
+  // localeError carries the default English locale, so it is restored rather than cleared.
+  const localeError = z.config().localeError;
+  z.config({ customError: undefined, localeError: capture("localeError") });
+  fail(z.string().min(5).meta({ title: "Locale" }).safeParse("ab"));
+  z.config({ localeError });
+
+  expect(seen).toEqual({
+    check: { title: "Check" },
+    schema: { title: "Schema" },
+    parse: { title: "Parse" },
+    customError: { title: "Custom" },
+    localeError: { title: "Locale" },
+  });
+});

package/node_modules/zod/src/v4/classic/tests/jitless-allows-eval.test.ts

@@ -10,23 +10,16 @@ const { allowsEval } = core.util;
 // `securitypolicyviolation` report on strict-CSP pages (no 'unsafe-eval')
 // that Chrome DevTools surfaces as an Issue.
 //
-// The fix: when `globalConfig.jitless` is true, `allowsEval.value`
-// returns `false` without triggering the probe. This test lives in its
-// own file because vitest isolates ESM graphs per file, so the cached
-// `allowsEval.value` is fresh and is never accessed before the config
-// mutation below.
+// The fix: when `globalConfig.jitless` is true, `allowsEval.value` returns `false` without triggering the probe. This test lives in its own file because vitest isolates ESM graphs per file, so the cached `allowsEval.value` is fresh and is never accessed before the config mutation below.
 
 test("globalConfig.jitless=true short-circuits the allowsEval probe", () => {
-  // Set BEFORE first access to allowsEval.value — the getter is memoised
-  // via `cached()`, so the contract is "configure at app entry".
+  // Set BEFORE first access to allowsEval.value — the getter is memoised via `cached()`, so the contract is "configure at app entry".
   z.config({ jitless: true });
 
   // Sanity: config is wired
   expect(core.globalConfig.jitless).toBe(true);
 
-  // Spy: if the probe were still attempted, `new Function("")` would be
-  // called. Swap the global `Function` constructor with a throwing stub
-  // and verify the stub is NEVER invoked.
+  // Spy: if the probe were still attempted, `new Function("")` would be called. Swap the global `Function` constructor with a throwing stub and verify the stub is NEVER invoked.
   const origFunction = globalThis.Function;
   let probeAttempted = false;
   // @ts-expect-error assigning a stub to the Function global for the test

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

@@ -42,7 +42,7 @@ test("opt passthrough", () => {
   expect(z.lazy(() => z.string().optional())._zod.optin).toEqual("optional");
   expect(z.lazy(() => z.string().optional())._zod.optout).toEqual("optional");
 
-  expect(z.lazy(() => z.string().default("asdf"))._zod.optin).toEqual("optional");
+  expect(z.lazy(() => z.string().default("asdf"))._zod.optin).toEqual("defaulted");
   expect(z.lazy(() => z.string().default("asdf"))._zod.optout).toEqual(undefined);
 });
 
@@ -225,3 +225,38 @@ test("lazy initialization", () => {
     subcategories: z.lazy(() => categorySchema.array()),
   });
 });
+
+test("derived internals resolve on self-referential lazy", () => {
+  const optional: any = z.lazy(() => optional.optional());
+  const pipe: any = z.lazy(() => z.pipe(z.string(), pipe));
+
+  expect(optional._zod.optin).toEqual("optional");
+  expect(optional._zod.optout).toEqual("optional");
+  expect(pipe._zod.optin).toEqual(undefined);
+  expect(pipe._zod.optout).toEqual(undefined);
+});
+
+test("a cycle-broken internal is not memoized", () => {
+  const lazyRef: any = z.lazy(() => Rec);
+  const Rec: any = z.union([z.string().optional(), lazyRef]);
+
+  // Reading the outer node first resolves `lazyRef`'s own `optin` through the cycle.
+  expect(Rec._zod.optin).toEqual("optional");
+  expect(lazyRef._zod.optin).toEqual("optional");
+  expect(z.object({ x: Rec, y: lazyRef }).safeParse({ x: "a" }).success).toEqual(true);
+});
+
+test("an internal computed without a cycle break is memoized", () => {
+  // `undefined` is the legitimate answer here and still has to cache: these getters are read per parse, so recomputing them is a parse-path cost.
+  const union = z.union([z.string(), z.number()]);
+  expect(union._zod.optin).toEqual(undefined);
+  expect(Object.getOwnPropertyNames(union._zod)).toContain("optin");
+});
+
+// A compute that throws must memoize nothing, or the second read answers undefined for a schema whose internals were never derived.
+test("a throwing lazy internal throws on every read", () => {
+  const schema = z.discriminatedUnion("type", [z.string() as any]) as any;
+  for (let i = 0; i < 3; i++) {
+    expect(() => schema._zod.propValues).toThrow();
+  }
+});

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

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -115,3 +115,14 @@ test("literal pattern", () => {
     }
   `);
 });
+
+test("empty literal matches nothing", () => {
+  const empty = z.literal([]);
+  expectTypeOf<z.infer<typeof empty>>().toEqualTypeOf<never>();
+  expect(empty.safeParse("").success).toEqual(false);
+  expect(empty.safeParse(undefined).success).toEqual(false);
+  expect(z.templateLiteral(["", empty]).safeParse("").success).toEqual(false);
+  expect(z.toJSONSchema(empty)).toMatchObject({ not: {} });
+
+  expect(z.literal("").safeParse("").success).toEqual(true);
+});

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

@@ -99,6 +99,18 @@ test("failing when map is bigger than max() ", () => {
   expect(result.error!.issues[0].code).toEqual("too_big");
 });
 
+test("failing when map does not match size() ", () => {
+  expect(justTwo.safeParse(new Map([["a", "b"]])).error!.issues[0].message).toEqual(
+    "Too small: expected map to have exactly 2 entries"
+  );
+  const tooBig = new Map([
+    ["a", "b"],
+    ["c", "d"],
+    ["e", "f"],
+  ]);
+  expect(justTwo.safeParse(tooBig).error!.issues[0].message).toEqual("Too big: expected map to have exactly 2 entries");
+});
+
 test("valid parse async", async () => {
   const asyncMap = z.map(
     z.string().refine(async () => false, "bad key"),