@openclaw/feishu 2026.9.3 → 2026.9.5

package/node_modules/zod/src/v4/classic/tests/in-out.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, test } from "vitest";
+import * as z from "zod";
+
+describe("z.input / z.output", () => {
+  test("flat codec: input/output give the right side", () => {
+    const c = z.codec(z.string(), z.bigint(), {
+      decode: (s) => BigInt(s),
+      encode: (n) => n.toString(),
+    });
+    expect(z.input(c).parse("1")).toBe("1");
+    expect(z.output(c).parse(1n)).toBe(1n);
+  });
+
+  test("codec nested in object: output works recursively (regression #5224)", () => {
+    const c = z.codec(z.string(), z.bigint(), {
+      decode: (s) => BigInt(s),
+      encode: (n) => n.toString(),
+    });
+    const obj = z.object({ b: c });
+
+    const decoded = z.output(obj);
+    expect(decoded.parse({ b: 1n })).toEqual({ b: 1n });
+
+    const encoded = z.input(obj);
+    expect(encoded.parse({ b: "1" })).toEqual({ b: "1" });
+  });
+
+  test("nested across record / map: matches the use case in #5224", () => {
+    const keyCodec = z.codec(z.string(), z.enum(["a", "b"]), {
+      decode: (s) => (s === "a" || s === "b" ? s : z.NEVER),
+      encode: (s) => s,
+    });
+    const valueObject = z.object({
+      n: z.codec(z.string(), z.bigint(), { decode: (s) => BigInt(s), encode: (n) => n.toString() }),
+    });
+
+    const fullCodec = z.codec(
+      z.record(z.input(keyCodec), z.input(valueObject)),
+      z.map(z.output(keyCodec), z.output(valueObject)),
+      {
+        decode: (input) => {
+          const m = new Map<"a" | "b", { n: bigint }>();
+          for (const [k, v] of Object.entries(input)) {
+            m.set(keyCodec.decode(k), valueObject.decode(v));
+          }
+          return m;
+        },
+        encode: (input) => {
+          const out: Record<string, { n: string }> = {};
+          for (const [k, v] of input.entries()) {
+            out[keyCodec.encode(k)] = valueObject.encode(v);
+          }
+          return out;
+        },
+      }
+    );
+
+    expect(fullCodec.decode({ a: { n: "1" } })).toEqual(new Map([["a", { n: 1n }]]));
+    expect(fullCodec.encode(new Map([["b", { n: 2n }]]))).toEqual({ b: { n: "2" } });
+  });
+
+  test("schema without pipes is returned with identity (no clone)", () => {
+    const s = z.object({ a: z.string() });
+    expect(z.input(s)).toBe(s);
+    expect(z.output(s)).toBe(s);
+  });
+
+  test("z.output carries checks attached to a pipe", () => {
+    const c = z
+      .codec(z.string(), z.number().int(), { decode: Number, encode: String })
+      .refine((n) => n > 10, { error: "gt10" });
+    const obj = z.object({ list: z.array(c) });
+    const decoded = z.output(obj);
+
+    expect(decoded.parse({ list: [50] })).toEqual({ list: [50] });
+    // The pipe's own check and the one already on its out side both survive, in that order.
+    expect(() => decoded.parse({ list: [5] })).toThrow("gt10");
+    expect(() => decoded.parse({ list: [50.5] })).toThrow();
+    // A pipe's checks run on the decoded value in both directions, so encode enforces them too.
+    expect(() => decoded.encode({ list: [5] })).toThrow("gt10");
+    // Carrying them clones the out side rather than mutating it.
+    expect(c._zod.def.out._zod.def.checks).toHaveLength(1);
+  });
+
+  test("z.input drops a pipe's checks, which constrain a value the input side never produces", () => {
+    const c = z.codec(z.string(), z.number(), { decode: Number, encode: String }).refine((n) => n > 10);
+    expect(z.input(c).parse("5")).toBe("5");
+
+    // Control: a check that isn't attached to a pipe is left alone.
+    expect(() => z.input(z.object({ s: z.string().min(2) })).parse({ s: "a" })).toThrow();
+  });
+
+  test("z.input resolves past a preprocess transform, which is not a real input side", () => {
+    const p = z.preprocess((v) => String(v), z.string().min(5));
+    const encoded = z.input(p);
+
+    expect(encoded.parse("abcde")).toBe("abcde");
+    // The bare transform used to come back here: it validated nothing and re-ran the preprocessor.
+    expect(() => encoded.parse(1)).toThrow();
+    expect(() => encoded.parse("abc")).toThrow();
+    // The same resolution the JSON Schema emitter already makes for this schema.
+    expect(z.toJSONSchema(p, { io: "input" })).toMatchObject({ type: "string", minLength: 5 });
+
+    // A check on the pipe itself travels with whichever side wins.
+    const checked = z.preprocess((v) => String(v), z.string()).refine((s) => s.startsWith("ok"));
+    expect(z.input(checked).parse("okay")).toBe("okay");
+    expect(() => z.input(checked).parse("nope")).toThrow();
+
+    // Control: a codec has two real sides, so its input side is still `in`, by identity.
+    const c = z.codec(z.string(), z.number(), { decode: Number, encode: String });
+    expect(z.input(c)).toBe(c._zod.def.in);
+  });
+
+  test("a wrapper's stored value survives only on the side it belongs to", () => {
+    const c = z.codec(z.string(), z.number(), { decode: Number, encode: String });
+
+    // A default and a catch hold output-side values, so the input projection sheds them.
+    expect(z.input(c.default(7)).parse(undefined)).toBe(undefined);
+    expect(z.input(c.default(7)).parse("1")).toBe("1");
+    expect(() => z.input(c.catch(9)).parse(123 as any)).toThrow();
+    expect(z.input(c.catch(9)).parse("1")).toBe("1");
+    expect(z.output(c.default(7)).parse(undefined)).toBe(7);
+    expect(z.output(c.catch(9)).parse("zz" as any)).toBe(9);
+
+    // A prefault is fed through the schema, so it is input-side and the output projection sheds it.
+    expect(z.input(c.prefault("5")).parse(undefined)).toBe("5");
+    expect(() => z.output(c.prefault("5")).parse(undefined as any)).toThrow();
+    expect(z.output(c.prefault("5")).parse(3)).toBe(3);
+  });
+
+  test("a wrapper over a pipe-free schema keeps both its value and its identity", () => {
+    const d = z.string().default("x");
+    const k = z.string().catch("y");
+    const f = z.string().prefault("z");
+
+    expect(z.input(d)).toBe(d);
+    expect(z.input(d).parse(undefined)).toBe("x");
+    expect(z.input(k)).toBe(k);
+    expect(z.output(f)).toBe(f);
+
+    const obj = z.object({ a: z.string().default("q") });
+    expect(z.input(obj)).toBe(obj);
+    expect(z.input(obj).parse({})).toEqual({ a: "q" });
+  });
+
+  test("runtime `z.input` agrees with type-level `z.input<T>`", () => {
+    const c = z.codec(z.string(), z.bigint(), {
+      decode: (s) => BigInt(s),
+      encode: (n) => n.toString(),
+    });
+    const obj = z.object({ b: c });
+
+    // Runtime: parse the input shape.
+    const parsed = z.input(obj).parse({ b: "1" });
+    // Type: matches the declared input type.
+    const asType: z.input<typeof obj> = parsed;
+    expect(asType).toEqual({ b: "1" });
+  });
+});

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

@@ -653,8 +653,7 @@ test("z.custom check", () => {
 });
 
 test("z.check", () => {
-  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic
-  // the function should return base.$ZodResult
+  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic the function should return base.$ZodResult
   const a = z.any().check(
     z.check<string>((ctx) => {
       if (typeof ctx.value === "string") return;
@@ -736,6 +735,26 @@ test("z.refine", () => {
   expect(() => z.parse(a, "hi")).toThrow();
 });
 
+test("z.superRefine preserves explicit nullish issue input", () => {
+  const schema = z.string().check(
+    z.superRefine((_, ctx) => {
+      ctx.addIssue({ code: "custom", message: "default" });
+      ctx.addIssue({ code: "custom", message: "null", input: null });
+      ctx.addIssue({ code: "custom", message: "undefined", input: undefined });
+    })
+  );
+
+  const result = z.safeParse(schema, "sensitive", { reportInput: true });
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues).toHaveLength(3);
+    expect(result.error.issues[0].input).toEqual("sensitive");
+    expect(result.error.issues[1].input).toEqual(null);
+    expect(result.error.issues[2]).toHaveProperty("input");
+    expect(result.error.issues[2].input).toEqual(undefined);
+  }
+});
+
 // test("z.superRefine", () => {
 //   const a = z.number([
 //     z.superRefine((val, ctx) => {

package/node_modules/zod/src/v4/classic/tests/instance-footprint.test.ts

@@ -0,0 +1,281 @@
+import { expect, test } from "vitest";
+
+import * as zm from "zod/mini";
+import * as z from "zod/v4";
+import * as core from "zod/v4/core";
+
+// V8 sizes an instance's property backing store in steps, and schema instances get no in-object slots (their constructor assigns nothing itself): 12 own properties cost 128 bytes, 13 cost 848, 21 cost 1616. Methods therefore live on the prototype and materialize per instance on first read. These bounds are what keeps a schema graph small; crossing one silently multiplies its memory by 6x.
+const MAX_OWN_PROPS = 12;
+
+test("schema instances stay under V8's property-count step", () => {
+  const cases: Array<[string, object]> = [
+    ["string", z.string()],
+    ["number", z.number()],
+    ["bigint", z.bigint()],
+    ["boolean", z.boolean()],
+    ["date", z.date()],
+    ["enum", z.enum(["a", "b"])],
+    ["array", z.array(z.string())],
+    ["object", z.object({ a: z.string() })],
+    ["record", z.record(z.string(), z.string())],
+    ["map", z.map(z.string(), z.string())],
+    ["set", z.set(z.string())],
+    ["union", z.union([z.string(), z.number()])],
+    ["optional", z.string().optional()],
+    ["pipe", z.string().pipe(z.string())],
+    ["email", z.email()],
+    ["mini string", zm.string()],
+    ["mini object", zm.object({ a: zm.string() })],
+  ];
+
+  const over = cases
+    .map(([name, schema]) => [name, Reflect.ownKeys(schema).length] as const)
+    .filter(([, count]) => count > MAX_OWN_PROPS);
+
+  expect(over).toEqual([]);
+});
+
+test("prototype-installed members survive detaching", () => {
+  const schema = z.string();
+  const { parse, safeParse, spa } = schema;
+
+  expect(parse("hi")).toEqual("hi");
+  expect(safeParse("hi").success).toEqual(true);
+  expect(["a", "b"].map((v) => parse(v))).toEqual(["a", "b"]);
+  expect(spa).toBe(schema.safeParseAsync);
+
+  const email = schema.email;
+  expect(email().safeParse("a@b.co").success).toEqual(true);
+});
+
+test("prototype-installed members can be overwritten per instance", () => {
+  const schema: any = z.string();
+  schema.parse = () => "overridden";
+
+  expect(schema.parse("anything")).toEqual("overridden");
+  expect(z.string().parse("untouched")).toEqual("untouched");
+});
+
+test("~standard is lazy but complete", () => {
+  const schema = z.string();
+
+  expect(Object.prototype.hasOwnProperty.call(schema, "~standard")).toEqual(false);
+  expect(schema["~standard"].vendor).toEqual("zod");
+  expect(schema["~standard"].version).toEqual(1);
+  expect(schema["~standard"].validate("hi")).toEqual({ value: "hi" });
+  expect((schema["~standard"] as any).jsonSchema.input()).toMatchObject({ type: "string" });
+  // Reading it caches on the instance, so the getter runs once.
+  expect(Object.prototype.hasOwnProperty.call(schema, "~standard")).toEqual(true);
+});
+
+test("caching a lazy member preserves its original enumerability", () => {
+  const schema = z.string();
+
+  // Methods were enumerable own properties before they moved to the prototype, so touching one still surfaces it to `Object.keys`.
+  void schema.parse;
+  void schema.optional;
+  expect(Object.keys(schema)).toContain("parse");
+  expect(Object.keys(schema)).toContain("optional");
+
+  // `~standard` never was an own data property, so caching it must not add it to `Object.keys` or to `JSON.stringify` of a schema.
+  void schema["~standard"];
+  expect(Object.keys(schema)).not.toContain("~standard");
+  expect(JSON.stringify(schema)).not.toContain("~standard");
+
+  // An explicit assignment behaves like one, as before.
+  const other: any = z.string();
+  other["~standard"] = { vendor: "x" };
+  expect(Object.keys(other)).toContain("~standard");
+});
+
+test("_def stays read-only", () => {
+  expect(() => {
+    (z.string() as any)._def = {};
+  }).toThrow(TypeError);
+  expect(() => {
+    (z.function({ input: [z.string()], output: z.number() }) as any)._def = {};
+  }).toThrow(TypeError);
+  const schema = z.string();
+  expect(schema._def).toBe(schema._zod.def);
+  expect(z.object({ a: z.string() })._def.type).toEqual("object");
+});
+
+test("deferred initializers are released after construction", () => {
+  expect(z.string()._zod.deferred).toEqual(undefined);
+  expect(z.object({ a: z.string() })._zod.deferred).toEqual(undefined);
+});
+
+test("a trait initializer called directly still installs its members", () => {
+  // a direct `init` installs onto the receiver's own prototype, since it is not below the constructor's
+  z.string();
+
+  const proto = {};
+  const inst = Object.create(proto) as z.ZodString;
+  z.ZodString.init(inst, { type: "string" });
+
+  expect(typeof inst.email).toBe("function");
+  expect(typeof inst.optional).toBe("function");
+  expect(Object.prototype.hasOwnProperty.call(proto, "email")).toBe(true);
+});
+
+test("a nested init during a repeat construction still installs its members", () => {
+  // the install used to read a module-level flag the outer construction set, so a nested `init` on an unrelated receiver inherited an answer that was not about it
+  const seen: string[] = [];
+
+  // an assertion signature needs the call target explicitly annotated
+  const Nested: core.$constructor<any> = core.$constructor<any>("Nested", () => {}, {
+    tag() {
+      return "nested";
+    },
+  });
+  const Outer = core.$constructor<any>("Outer", (_inst, def) => {
+    if (!def.nest) return;
+    // not a plain `{}`: the install target would resolve to `Object.prototype` and leak `tag` into every object the worker touches
+    const plain: any = Object.create({});
+    Nested.init(plain, {});
+    seen.push(typeof plain.tag);
+  });
+
+  new Outer({ nest: false });
+  new Outer({ nest: true });
+
+  expect(seen).toEqual(["function"]);
+});
+
+test("a derived trait's members win over the ones it composes", () => {
+  // Classic installs a richer `~standard` over core's. Trait dedupe is what orders them: core's initializer runs once, at the first `init` that reaches it, so classic's always lands second.
+  expect(typeof (z.string()["~standard"] as any).jsonSchema.input).toBe("function");
+});
+
+test("a live member keeps the descriptor a prototype member had", () => {
+  // An object literal's getter is enumerable; the `defineProperty` it replaced was not. `for..in` over a schema is public surface, and the construction path walks the prototype with it.
+  const proto = Object.getPrototypeOf(z.string());
+  expect(Object.getOwnPropertyDescriptor(proto, "description")?.enumerable).toBe(false);
+  expect(Object.getOwnPropertyDescriptor(proto, "_def")?.enumerable).toBe(false);
+
+  const keys: string[] = [];
+  for (const k in z.string()) keys.push(k);
+  expect(keys).toEqual(["def", "type", "format", "minLength", "maxLength"]);
+});
+
+test("a live member is not cached per instance", () => {
+  const schema = z.string();
+
+  expect(schema.description).toBe(undefined);
+  core.globalRegistry.add(schema, { description: "later" });
+  expect(schema.description).toBe("later");
+  expect(Object.prototype.hasOwnProperty.call(schema, "description")).toBe(false);
+});
+
+test("constructing through a subclass does not strip the base prototype", () => {
+  // `super(def)` gives `this` a prototype of `new.target.prototype`, so a constructor can complete a construction without having built its own prototype.
+  const MyString: new (def: { type: "string" }) => z.ZodString = class extends (z.ZodString as any) {} as any;
+  new MyString({ type: "string" });
+
+  const plain = z.string();
+  expect(plain.parse("x")).toBe("x");
+  expect(typeof plain.email).toBe("function");
+  expect(typeof new MyString({ type: "string" }).email).toBe("function");
+});
+
+test("a subclass's own members survive the install", () => {
+  // The members go on the prototype of the constructor that built the instance, so a subclass's own prototype keeps what it declared. `z.symbol()` is constructed nowhere else here, which puts the subclass before its base — the ordering the install has to get right. Asserted rather than assumed, so warming it elsewhere fails the test instead of hollowing it out.
+  expect(Object.prototype.hasOwnProperty.call((z.ZodSymbol as any).prototype, "parse")).toBe(false);
+  const First = class extends (z.ZodSymbol as any) {
+    parse() {
+      return "PARSE";
+    }
+    optional() {
+      return "OPTIONAL";
+    }
+  } as any;
+  const first = new First({ type: "symbol" });
+  expect(first.parse(Symbol())).toBe("PARSE");
+  expect(first.optional()).toBe("OPTIONAL");
+  const sym = Symbol();
+  expect(z.symbol().parse(sym)).toBe(sym);
+
+  // and the other way round, with the base prototype already built by one of the `z.number()` calls above. Asserted for the same reason: warm it nowhere and this block quietly becomes a second copy of the cold case.
+  expect(Object.prototype.hasOwnProperty.call((z.ZodNumber as any).prototype, "parse")).toBe(true);
+  const Second = class extends (z.ZodNumber as any) {
+    parse() {
+      return "SECOND";
+    }
+  } as any;
+  expect(new Second({ type: "number" }).parse(1)).toBe("SECOND");
+
+  // two levels deep: neither prototype takes a copy, so the inherited member is one function
+  const Third = class extends (Second as any) {} as any;
+  new Third({ type: "number" });
+  expect(Second.prototype.parse).toBe(Third.prototype.parse);
+});
+
+test("a hand-written getter member accepts assignment", () => {
+  // Every member was an accessor with a setter before they moved onto `proto`, so a getter written by hand needs one too.
+  const schema: any = z.string();
+  schema.spa = () => "SPA";
+  schema.toJSONSchema = () => "JSON";
+  expect(schema.spa()).toBe("SPA");
+  expect(schema.toJSONSchema()).toBe("JSON");
+
+  const mini: any = zm.string();
+  mini.with = () => "WITH";
+  expect(mini.with()).toBe("WITH");
+});
+
+test("shape is lazy and stays out of Object.keys", () => {
+  const schema = z.object({ a: z.string() });
+
+  expect(Object.prototype.hasOwnProperty.call(schema, "shape")).toEqual(false);
+  expect("shape" in schema).toEqual(true);
+  expect(Object.keys(schema)).not.toContain("shape");
+  expect({ ...schema }).not.toHaveProperty("shape");
+
+  expect(Object.keys(schema.shape)).toEqual(["a"]);
+
+  // Reading caches a non-enumerable own data property. An own accessor here would put every later object schema into V8 dictionary mode.
+  expect(Object.prototype.hasOwnProperty.call(schema, "shape")).toEqual(true);
+  expect(Object.getOwnPropertyDescriptor(schema, "shape")).toMatchObject({
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+  expect(Object.keys(schema)).not.toContain("shape");
+
+  const mini = zm.object({ a: zm.string() });
+  expect(Object.prototype.hasOwnProperty.call(mini, "shape")).toEqual(false);
+  expect(Object.keys(mini.shape)).toEqual(["a"]);
+  expect(Object.keys(mini)).not.toContain("shape");
+});
+
+test("shape accepts repeated assignment and recomputes after deletion", () => {
+  const schema: any = z.object({ a: z.string() });
+
+  schema.shape = { b: z.number() };
+  expect(Object.keys(schema.shape)).toEqual(["b"]);
+  // The cached property stays writable, so a second assignment does not throw in strict mode.
+  schema.shape = { c: z.boolean() };
+  expect(Object.keys(schema.shape)).toEqual(["c"]);
+
+  // Deleting clears the memo rather than removing the property, since the accessor lives on the prototype.
+  delete schema.shape;
+  expect(Object.keys(schema.shape)).toEqual(["a"]);
+});
+
+test("a self-referential shape getter breaks the cycle instead of recursing", () => {
+  const Self: any = z.object({
+    a: z.string(),
+    get b() {
+      return z.array(z.object(Self.shape));
+    },
+  });
+  expect(Object.keys(Self.shape)).toEqual(["a", "b"]);
+
+  const Mini: any = zm.object({
+    a: zm.string(),
+    get b() {
+      return zm.array(zm.object(Mini.shape));
+    },
+  });
+  expect(Object.keys(Mini.shape)).toEqual(["a", "b"]);
+});

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

@@ -58,3 +58,50 @@ test("instanceof respects customError", () => {
 
   z.config({ customError: undefined });
 });
+
+test("z.properties", () => {
+  const httpsUrl = z.instanceof(URL).check(
+    ...z.properties({
+      protocol: z.literal("https:" as string),
+      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);
+
+  // Checks abort on the first failure, exactly as the equivalent chain of z.property() calls does.
+  const both = httpsUrl.safeParse(new URL("http://localhost"));
+  expect(both.error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+
+  // 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"]]);
+  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: every element 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. Typing each element over only its own key fixes that and breaks every valid call, since a union argument must satisfy the target on its own.
+  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"]]]);
+
+  // Plain property checks carry 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"]]);
+});

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