@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

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

@@ -264,18 +264,66 @@ 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() })]);
+  // An option whose properties can be listed is checked when the union is constructed.
+  expect(() => z.discriminatedUnion("type", [z.object({ value: z.string() })])).toThrow(
+    /Invalid discriminated union option at index "0"/
+  );
+  expect(() =>
+    z.discriminatedUnion("type", [z.object({ type: z.literal("a"), a: z.string() }), z.object({ b: z.string() })])
+  ).toThrow(/Invalid discriminated union option at index "1"/);
 
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ b: z.string() }) as any,
-    ])._zod.propValues;
-    throw new Error();
-  } catch (e: any) {
-    expect(e.message.includes("Invalid discriminated union option")).toBe(true);
-  }
+  // An option whose shape cannot be listed without resolving it — a pipe here — is left to the lookup map, and fails on the first object parsed.
+  const viaPipe = z.discriminatedUnion("type", [
+    z.object({ value: z.literal("x") }).pipe(z.object({ value: z.literal("x") })),
+  ]);
+  expect(() => viaPipe.safeParse({ value: "x" })).toThrow(/Invalid discriminated union option at index "0"/);
+});
+
+test("the construction check follows shape through both of its phases", () => {
+  // `shape` answers from the object the caller passed until the first read, then from a frozen copy. A key list derived at either moment would disagree with it at the other and reject an option that does carry the discriminator.
+  const mutatedBeforeRead: Record<string, z.ZodType> = { value: z.string() };
+  const A = z.object(mutatedBeforeRead);
+  mutatedBeforeRead.type = z.literal("a");
+  expect(
+    z.discriminatedUnion("type", [A, z.object({ type: z.literal("b") })]).parse({ type: "a", value: "x" })
+  ).toEqual({ type: "a", value: "x" });
+
+  const mutatedAfterRead: Record<string, z.ZodType> = { type: z.literal("a"), value: z.string() };
+  const B = z.object(mutatedAfterRead);
+  B.parse({ type: "a", value: "x" });
+  delete mutatedAfterRead.type;
+  expect(() => z.discriminatedUnion("type", [B])).not.toThrow();
+});
+
+test("deriving a schema neither clobbers nor is inherited by the source", () => {
+  // `.describe()` and friends reuse the def by identity, so the source keeps its own check.
+  const A = z.object({ value: z.literal("x") });
+  A.describe("just documenting this");
+  expect(() => z.discriminatedUnion("type", [A])).toThrow(/Invalid discriminated union option/);
+  expect(() => z.discriminatedUnion("type", [A.describe("d")])).toThrow(/Invalid discriminated union option/);
+
+  // A def rebuilt by a builder is a different object, so it inherits nothing and is left to the lookup map.
+  const Base = z.object({ status: z.literal("failed"), message: z.string() });
+  expect(() => z.discriminatedUnion("code", [Base.extend({ code: z.literal(400) })])).not.toThrow();
+});
+
+test("mutually-recursive getter options are checked without resolving them", () => {
+  // `Object.keys` lists a shape's keys without invoking them, so the check sees `child` without running the getter that references the union being constructed.
+  const variantA = z.object({
+    kind: z.literal("a"),
+    get child() {
+      return tree.optional();
+    },
+  });
+  const variantB = z.object({
+    kind: z.literal("b"),
+    get sibling() {
+      return tree.optional();
+    },
+  });
+  const tree = z.discriminatedUnion("kind", [variantA, variantB]);
+
+  expect(tree.parse({ kind: "a", child: { kind: "b" } })).toEqual({ kind: "a", child: { kind: "b" } });
 });
 
 // removed to account for unions of unions
@@ -687,8 +735,102 @@ test("encode with codec discriminator", () => {
   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
+  // 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" });
 });
+
+test("getDiscriminatedOption", () => {
+  const fruit = z.object({ type: z.literal("fruit"), seeds: z.boolean() });
+  const veg = z.object({ type: z.literal("vegetable"), leafy: z.boolean() });
+  const schema = z.discriminatedUnion("type", [fruit, veg]);
+
+  expect(z.getDiscriminatedOption(schema, "fruit")).toBe(fruit);
+  expect(z.getDiscriminatedOption(schema, "vegetable")).toBe(veg);
+
+  // The result is narrowed to the one member, not the union of all of them.
+  expectTypeOf(z.getDiscriminatedOption(schema, "fruit")).toEqualTypeOf<typeof fruit>();
+  expectTypeOf(z.getDiscriminatedOption(schema, "vegetable")).toEqualTypeOf<typeof veg>();
+  // @ts-expect-error — "unknown" is not a declared discriminator value
+  z.getDiscriminatedOption(schema, "unknown");
+});
+
+test("getDiscriminatedOption — multi-value members and non-string discriminators", () => {
+  const a = z.object({ type: z.literal(["x", "y"]), payload: z.string() });
+  const b = z.object({ type: z.literal("z"), payload: z.number() });
+  const multi = z.discriminatedUnion("type", [a, b]);
+  expect(z.getDiscriminatedOption(multi, "x")).toBe(a);
+  expect(z.getDiscriminatedOption(multi, "y")).toBe(a);
+  expect(z.getDiscriminatedOption(multi, "z")).toBe(b);
+
+  const num = z.object({ type: z.literal(1) });
+  const bool = z.object({ type: z.literal(true) });
+  const nul = z.object({ type: z.null() });
+  const mixed = z.discriminatedUnion("type", [num, bool, nul]);
+  expect(z.getDiscriminatedOption(mixed, 1)).toBe(num);
+  expect(z.getDiscriminatedOption(mixed, true)).toBe(bool);
+  expect(z.getDiscriminatedOption(mixed, null)).toBe(nul);
+
+  // An omittable discriminator claims undefined, so it resolves like any other value.
+  const opt = z.object({ type: z.literal("a").optional(), a: z.string() });
+  const req = z.object({ type: z.literal("b"), b: z.string() });
+  expect(z.getDiscriminatedOption(z.discriminatedUnion("type", [opt, req]), undefined)).toBe(opt);
+});
+
+test("getDiscriminatedOption caches in the bag and costs nothing until called", () => {
+  const schema = z.discriminatedUnion("type", [z.object({ type: z.literal("a") }), z.object({ type: z.literal("b") })]);
+
+  expect(schema._zod.bag.optionsMap).toBeUndefined();
+  expect(z.getDiscriminatedOption(schema, "a")).toBe(schema.options[0]);
+  const map = schema._zod.bag.optionsMap;
+  expect(map).toBeInstanceOf(Map);
+  expect(z.getDiscriminatedOption(schema, "b")).toBe(schema.options[1]);
+  expect(schema._zod.bag.optionsMap).toBe(map);
+
+  // A clone recomputes rather than inheriting the cache.
+  expect(schema.clone()._zod.bag.optionsMap).toBeUndefined();
+});
+
+test.each(["__proto__", "constructor", "toString", "hasOwnProperty", "valueOf"])(
+  "Object.prototype discriminator name: %s",
+  (key) => {
+    const first = z.object({ [key]: z.literal("a"), value: z.string() });
+    const second = z.object({ [key]: z.literal("b"), value: z.number() });
+    const schema = z.discriminatedUnion(key, [first, second]);
+
+    expect(schema._zod.propValues?.[key]).toEqual(new Set(["a", "b"]));
+
+    const input = Object.fromEntries([
+      [key, "a"],
+      ["value", "ok"],
+    ]);
+    const parsed: any = schema.parse(input);
+    expect(Object.prototype.hasOwnProperty.call(parsed, key)).toBe(key !== "__proto__");
+    if (key !== "__proto__") expect(parsed[key]).toBe("a");
+    expect(parsed.value).toBe("ok");
+  }
+);
+
+// An omittable discriminator reads back as undefined at the lookup, exactly as TypeScript sees it: `{ k?: "a" } | { k?: "c" }` does not narrow on `k === undefined`.
+test("an omittable discriminator claims undefined", () => {
+  const omittable = [z.exactOptional(z.literal("a")), z.optional(z.literal("a")), z.literal("a").default("a")];
+  for (const k of omittable) {
+    expect(z.object({ k })._zod.propValues.k).toEqual(new Set(["a", undefined]));
+  }
+
+  // one option omits the key: it claims undefined, so an absent key routes there and the union agrees
+  const options = [
+    z.object({ k: z.exactOptional(z.literal("a")), x: z.string() }),
+    z.object({ k: z.literal("b"), y: z.number() }),
+  ] as const;
+  expect(z.discriminatedUnion("k", options).safeParse({ x: "s" }).success).toEqual(true);
+  expect(z.union(options).safeParse({ x: "s" }).success).toEqual(true);
+  expect(z.discriminatedUnion("k", options).safeParse({ k: "b", y: 1 }).success).toEqual(true);
+
+  // two options omit the key: both claim undefined, so they are not discriminable on it
+  for (const k of omittable) {
+    expect(() =>
+      z.discriminatedUnion("k", [z.object({ k }), z.object({ k: z.exactOptional(z.literal("c")) })]).parse({})
+    ).toThrow(/Duplicate discriminator value "undefined"/);
+  }
+});

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

@@ -160,6 +160,17 @@ test("exclude", () => {
   expectTypeOf<z.infer<typeof EmptyFoodEnum>>().toEqualTypeOf<never>();
 });
 
+test("empty enum matches nothing", () => {
+  const Empty = z.enum([]);
+  expect(Empty._zod.pattern.test("")).toEqual(false);
+  expect(z.templateLiteral(["", Empty]).safeParse("").success).toEqual(false);
+  expect(z.templateLiteral(["", z.object({}).keyof()]).safeParse("").success).toEqual(false);
+
+  expect(z.toJSONSchema(Empty)).toMatchObject({ not: {} });
+
+  expect(z.templateLiteral(["", z.enum([""])]).safeParse("").success).toEqual(true);
+});
+
 test("error map inheritance", () => {
   const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"] as const;
   const FoodEnum = z.enum(foods, { error: () => "This is not food!" });

package/node_modules/zod/src/v4/classic/tests/error-utils.test.ts

@@ -658,8 +658,7 @@ test("z.formatError nested union preserves parent path", () => {
   expect(formatted.parent._errors).toContain("Expected string");
 });
 test("z.treeifyError nested union preserves parent path", () => {
-  // When a nested invalid_union appears inside another invalid_union,
-  // the inner errors must stay nested under their parent path, not flatten to root.
+  // When a nested invalid_union appears inside another invalid_union, the inner errors must stay nested under their parent path, not flatten to root.
   const syntheticError = new z.ZodError([
     {
       code: "invalid_union",
@@ -805,3 +804,114 @@ test("z.treeifyError nested union with real schema", () => {
     }
   }
 });
+
+const prototypePropertyNames = ["__proto__", "constructor", "toString", "hasOwnProperty", "valueOf"] as const;
+
+test.each(prototypePropertyNames)("z.formatError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const formatted = z.formatError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(formatted, name)).toBe(true);
+  expect(Object.getPrototypeOf(formatted)).toBe(Object.prototype);
+  expect((formatted as any)[name]._errors).toEqual(["invalid value"]);
+});
+
+test.each(prototypePropertyNames)("z.treeifyError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const tree = z.treeifyError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(tree.properties, name)).toBe(true);
+  expect(Object.getPrototypeOf(tree.properties)).toBe(Object.prototype);
+  expect((tree as any).properties[name].errors).toEqual(["invalid value"]);
+});
+
+test.each(prototypePropertyNames)("z.flattenError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const { fieldErrors } = z.flattenError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(fieldErrors, name)).toBe(true);
+  expect(Object.getPrototypeOf(fieldErrors)).toBe(Object.prototype);
+  expect((fieldErrors as any)[name]).toEqual(["invalid value"]);
+});
+
+/** The "__proto__" node must be a real own data property, not the inherited accessor. */
+const protoNode = (obj: any) => Object.getOwnPropertyDescriptor(obj, "__proto__")!.value;
+
+test("error formatters merge sibling issues under a __proto__ path", () => {
+  const schema = z.string().check((ctx) => {
+    ctx.issues.push({ code: "custom", message: "a", path: ["__proto__", "x"], input: ctx.value });
+    ctx.issues.push({ code: "custom", message: "b", path: ["__proto__", "y"], input: ctx.value });
+  });
+  const error = schema.safeParse("hello").error!;
+
+  const formatted = protoNode(z.formatError(error));
+  expect(formatted.x._errors).toEqual(["a"]);
+  expect(formatted.y._errors).toEqual(["b"]);
+
+  const tree = protoNode((z.treeifyError(error) as any).properties);
+  expect(tree.properties.x.errors).toEqual(["a"]);
+  expect(tree.properties.y.errors).toEqual(["b"]);
+
+  expect(({} as any).x).toBeUndefined();
+  expect(({} as any).y).toBeUndefined();
+});
+
+test("error formatting leaves Object.prototype untouched for input-derived keys", () => {
+  const record = z.record(z.string(), z.string()).safeParse(JSON.parse('{"toString": 1}'));
+  expect(record.success).toBe(false);
+  expect((z.formatError(record.error!) as any).toString._errors).toHaveLength(1);
+
+  const entries = new Map(Object.entries(JSON.parse('{"__proto__": {"pwn": 1}}')));
+  const result = z.map(z.string(), z.object({ pwn: z.string() })).safeParse(entries);
+  expect(result.success).toBe(false);
+  expect(protoNode(z.formatError(result.error!)).pwn._errors).toHaveLength(1);
+  expect(protoNode((z.treeifyError(result.error!) as any).properties).properties.pwn.errors).toHaveLength(1);
+  expect(({} as any).pwn).toBeUndefined();
+});
+
+test("formatError handles an input-derived _errors path", () => {
+  const schema = z.object({ parent: z.record(z.string(), z.string()) });
+  const result = schema.safeParse({ parent: { _errors: 1 } });
+  expect(result.success).toBe(false);
+
+  const formatted = z.formatError(result.error!);
+  expect(formatted.parent?._errors).toEqual(["Invalid input: expected string, received number"]);
+
+  const nested = z
+    .object({ parent: z.record(z.string(), z.object({ child: z.string() })) })
+    .safeParse({ parent: { _errors: { child: 1 } } });
+  expect(nested.success).toBe(false);
+  expect((z.formatError(nested.error!) as any).parent.child._errors).toEqual([
+    "Invalid input: expected string, received number",
+  ]);
+});
+
+test("error walkers handle path elements named after inherited methods", () => {
+  // "toString" and "constructor" are truthy on the prototype, so a plain lookup finds
+  // the inherited function instead of creating a node, and the push then throws.
+  for (const [schema, input] of [
+    [z.object({ toString: z.string() }), { toString: 1 }],
+    [z.object({ constructor: z.string() }), { constructor: 1 }],
+    [z.object({ toString: z.string(), constructor: z.string() }), { toString: 1, constructor: 2 }],
+  ] as const) {
+    const result = (schema as any).safeParse(input);
+    expect(result.success).toBe(false);
+
+    const formatted = z.formatError(result.error) as any;
+    const tree = z.treeifyError(result.error) as any;
+    for (const key of Object.keys(input)) {
+      expect(formatted[key]._errors).toHaveLength(1);
+      expect(tree.properties[key].errors).toHaveLength(1);
+      expect(Object.prototype.hasOwnProperty.call(formatted, key)).toBe(true);
+    }
+  }
+});

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

@@ -1,7 +1,42 @@
-import { inspect } from "node:util";
-import { expect, test } from "vitest";
+import { inspect, types } from "node:util";
+import { afterEach, expect, test, vi } from "vitest";
 import * as z from "zod/v4";
 
+// Several tests install a global error map. Resetting on the last line of each leaks it into every later test in the file whenever an assertion above that line fails, which turns one real failure into a cascade.
+afterEach(() => {
+  z.config({ customError: undefined });
+});
+
+function getThrownError(fn: () => unknown): unknown {
+  try {
+    fn();
+  } catch (error) {
+    return error;
+  }
+  throw new Error("Expected function to throw");
+}
+
+async function getRejectedError(fn: () => Promise<unknown>): Promise<unknown> {
+  try {
+    await fn();
+  } catch (error) {
+    return error;
+  }
+  throw new Error("Expected function to reject");
+}
+
+function expectFirstStackFrameAtCallsite(error: unknown): void {
+  expect(error).toBeInstanceOf(Error);
+  const stack = (error as Error).stack;
+  expect(stack).toEqual(expect.any(String));
+
+  const firstFrame = stack!.split("\n").find((line) => line.trim().startsWith("at "));
+  expect(firstFrame).toBeDefined();
+  expect(firstFrame).toContain("error.test.ts");
+  expect(firstFrame).not.toContain("core/parse.ts");
+  expect(firstFrame).not.toContain("classic/schemas.ts");
+}
+
 test("error creation", () => {
   const err1 = new z.ZodError([]);
 
@@ -523,7 +558,7 @@ test("z.config customError ", () => {
   // support overrideErrorMap
 
   z.config({ customError: () => ({ message: "override" }) });
-  const result = stringWithCustomError.min(10).safeParse("tooshort");
+  const result = z.string().min(10).safeParse("tooshort");
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
     [ZodError: [
@@ -538,7 +573,40 @@ test("z.config customError ", () => {
     ]]
   `);
   expect(result.error!.issues[0].message).toEqual("override");
-  z.config({ customError: undefined });
+});
+
+test("bound error map covers issues raised by its own checks", () => {
+  const result = stringWithCustomError.min(10).safeParse("tooshort");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toEqual("bound");
+});
+
+test("a check's own error map beats the schema's", () => {
+  const result = stringWithCustomError.min(10, { error: () => "check" }).safeParse("tooshort");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toEqual("check");
+});
+
+test("the schema's error map beats contextual and global for a check issue", () => {
+  z.config({ customError: () => "global" });
+  const result = stringWithCustomError.min(10).safeParse("tooshort", { error: () => "contextual" });
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toEqual("bound");
+});
+
+test("a schema map returning undefined defers to the next rung, and runs once", () => {
+  let calls = 0;
+  const deferring = z.string({
+    error: () => {
+      calls++;
+      return undefined;
+    },
+  });
+  z.config({ customError: () => "global" });
+  const result = deferring.min(10).safeParse("tooshort");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toEqual("global");
+  expect(calls).toEqual(1);
 });
 
 // test("invalid and required", () => {
@@ -671,7 +739,7 @@ test("error inheritance", () => {
   expect(e1).toBeInstanceOf(z.core.$ZodError);
   expect(e1).toBeInstanceOf(z.ZodError);
   expect(e1).toBeInstanceOf(z.ZodRealError);
-  // expect(e1).not.toBeInstanceOf(Error);
+  expect(e1).toBeInstanceOf(Error);
 
   try {
     z.string().parse(123);
@@ -679,10 +747,63 @@ test("error inheritance", () => {
     expect(e1).toBeInstanceOf(z.core.$ZodError);
     expect(e2).toBeInstanceOf(z.ZodError);
     expect(e2).toBeInstanceOf(z.ZodRealError);
-    // expect(e2).toBeInstanceOf(Error);
+    expect(e2).toBeInstanceOf(Error);
   }
 });
 
+test("parse errors capture the caller stack frame", async () => {
+  const schema = z.string();
+  const parse = schema.parse;
+  const parseAsync = schema.parseAsync;
+
+  expectFirstStackFrameAtCallsite(getThrownError(() => schema.parse(123)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => parse(123)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => z.parse(schema, 123)));
+
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => schema.parseAsync(123)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => parseAsync(123)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => z.parseAsync(schema, 123)));
+});
+
+test("codec errors capture the caller stack frame", async () => {
+  const schema = z.string();
+  const encode = schema.encode;
+  const decode = schema.decode;
+  const encodeAsync = schema.encodeAsync;
+  const decodeAsync = schema.decodeAsync;
+
+  expectFirstStackFrameAtCallsite(getThrownError(() => schema.encode(123 as any)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => encode(123 as any)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => z.encode(schema, 123 as any)));
+
+  expectFirstStackFrameAtCallsite(getThrownError(() => schema.decode(123 as any)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => decode(123 as any)));
+  expectFirstStackFrameAtCallsite(getThrownError(() => z.decode(schema, 123 as any)));
+
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => schema.encodeAsync(123 as any)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => encodeAsync(123 as any)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => z.encodeAsync(schema, 123 as any)));
+
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => schema.decodeAsync(123 as any)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => decodeAsync(123 as any)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => z.decodeAsync(schema, 123 as any)));
+});
+
+test("async errors that fail after suspending capture the caller stack frame", async () => {
+  // `Error.captureStackTrace` is skip-until-seen: when it cannot find its callee it discards every frame, not just the ones above. An async wrapper that returns its inner promise without awaiting has already left the async chain by the time the rejection is built, so its callee is unfindable and the stack comes back empty. Only a schema that actually suspends reaches that path — the sync cases above run straight through to their first await and pass either way.
+  const refined = z.string().refine(async () => false, "nope");
+  const codec = z.codec(z.string(), z.number(), {
+    decode: async (value) => value as never,
+    encode: async (value) => value as never,
+  });
+
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => refined.parseAsync("x")));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => codec.decodeAsync("x")));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => z.decodeAsync(codec, "x")));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => codec.encodeAsync(5)));
+  expectFirstStackFrameAtCallsite(await getRejectedError(() => z.encodeAsync(codec, 5)));
+});
+
 test("error serialization", () => {
   try {
     z.string().parse(123);
@@ -709,3 +830,150 @@ test("error serialization", () => {
     `);
   }
 });
+
+test("message is lazy but stays own and enumerable", () => {
+  const err = z.object({ a: z.string() }).safeParse({ a: 1 }).error!;
+
+  expect(Object.keys(err)).toEqual(["name", "message"]);
+  expect(Object.keys({ ...err })).toEqual(["name", "message"]);
+  expect(JSON.parse(JSON.stringify(err)).message).toEqual(err.message);
+  expect(Object.getOwnPropertyDescriptor(err, "message")!.enumerable).toBe(true);
+  expect(Object.getOwnPropertyDescriptor(err, "issues")!.enumerable).toBe(false);
+
+  // computed once, then stable against later mutation of `.issues`
+  const computed = err.message;
+  err.issues.push({ code: "custom", message: "later", path: [], input: undefined });
+  expect(err.message).toEqual(computed);
+
+  // assignment wins over the computed value, and `toString` follows it
+  err.message = "overwritten";
+  expect(err.message).toEqual("overwritten");
+  expect(err.toString()).toEqual("overwritten");
+
+  // a second error computes its own message
+  expect(z.string().safeParse(1).error!.message).not.toEqual(computed);
+});
+
+test("error helpers survive detaching", () => {
+  const err = z.object({ a: z.string() }).safeParse({ a: 1 }).error!;
+  const { format, flatten } = err;
+  const stringify = err.toString;
+
+  expect(format().a?._errors).toEqual(["Invalid input: expected string, received number"]);
+  expect(flatten().fieldErrors.a).toEqual(["Invalid input: expected string, received number"]);
+  expect(stringify()).toEqual(err.message);
+  expect(err.isEmpty).toBe(false);
+  expect(new z.ZodError([]).isEmpty).toBe(true);
+
+  // addIssue refreshes a message that was already materialized
+  const empty = new z.ZodError([]);
+  expect(empty.message).toEqual("[]");
+  empty.addIssue({ code: "custom", message: "added", path: [], input: undefined });
+  expect(empty.message).toContain("added");
+});
+
+test("an error is a real Error, minus the captured frames", () => {
+  const err = z.string().safeParse(123).error!;
+
+  // suppressing the capture, not skipping the constructor, keeps every brand check working
+  expect(err).toBeInstanceOf(Error);
+  expect(types.isNativeError(err)).toBe(true);
+  expect(Object.prototype.toString.call(err)).toBe("[object Error]");
+  expect(structuredClone(err)).toBeInstanceOf(Error);
+
+  // only a returned error loses its frames; the throwing paths restore them
+  expect(err.stack!.startsWith("ZodError: [")).toBe(true);
+  expect(err.stack!).toContain("invalid_type");
+  expect(err.stack!.split("\n").some((line) => line.trim().startsWith("at "))).toBe(false);
+
+  // the borrowed global is given back unchanged, including a caller's own value
+  const ambient = Error.stackTraceLimit;
+  z.string().safeParse(123);
+  expect(Error.stackTraceLimit).toBe(ambient);
+  Error.stackTraceLimit = ambient + 3;
+  try {
+    z.string().safeParse(123);
+    expect(Error.stackTraceLimit).toBe(ambient + 3);
+  } finally {
+    Error.stackTraceLimit = ambient;
+  }
+});
+
+test("an engine without captureStackTrace keeps the frames on a thrown error", async () => {
+  // suppressing the capture is only safe where `parse()` can put the frames back; Safari 11.1 through 17.1 has `stackTraceLimit` but not `captureStackTrace`, and suppressing there would strip the throw's stack
+  const desc = Object.getOwnPropertyDescriptor(Error, "captureStackTrace")!;
+  vi.resetModules();
+  delete (Error as { captureStackTrace?: unknown }).captureStackTrace;
+
+  let thrown: unknown;
+  try {
+    const fresh = await import("zod/v4");
+    function callSite() {
+      fresh.string().parse(1);
+    }
+    try {
+      callSite();
+    } catch (err) {
+      thrown = err;
+    }
+  } finally {
+    Object.defineProperty(Error, "captureStackTrace", desc);
+  }
+
+  expect(thrown).toBeInstanceOf(Error);
+  expect((thrown as Error).stack).toContain("callSite");
+});
+
+test("a realm that hardens Error after import degrades instead of throwing", async () => {
+  // lockdown() runs after zod's module graph evaluates, so the latch fires in a throwaway instance rather than the one this file uses
+  vi.resetModules();
+  const fresh = await import("zod/v4");
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")!;
+  Object.defineProperty(Error, "stackTraceLimit", { value: 10, writable: false, configurable: true });
+
+  try {
+    for (const err of [fresh.string().safeParse(1).error!, fresh.string().safeParse(2).error!]) {
+      expect(err).toBeInstanceOf(Error);
+      expect(err.issues).toHaveLength(1);
+    }
+    expect(Error.stackTraceLimit).toBe(10);
+  } finally {
+    Object.defineProperty(Error, "stackTraceLimit", desc);
+  }
+});
+
+test("an engine with no stackTraceLimit is never written to", () => {
+  // off v8 the property is absent and SES deletes it before hardening; an accessor makes the write observable where a data property would not
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")!;
+  let writes = 0;
+  Object.defineProperty(Error, "stackTraceLimit", {
+    get: () => undefined,
+    set: () => {
+      writes++;
+    },
+    configurable: true,
+  });
+
+  try {
+    const err = z.string().safeParse(123).error!;
+    expect(err).toBeInstanceOf(z.ZodError);
+    expect(types.isNativeError(err)).toBe(true);
+    expect(err.issues).toHaveLength(1);
+    expect(writes).toBe(0);
+  } finally {
+    Object.defineProperty(Error, "stackTraceLimit", desc);
+  }
+});
+
+test("error initializer never installs onto an intrinsic prototype", () => {
+  // `init` accepts any object; a foreign one must not leak accessors onto the prototype it happens to inherit from.
+  z.core.$ZodError.init({} as any, []);
+  z.ZodError.init({} as any, []);
+  z.core.$ZodError.init(new Error() as any, []);
+
+  expect(Object.getOwnPropertyDescriptor(Object.prototype, "toString")!.get).toBeUndefined();
+  expect(Object.getOwnPropertyDescriptor(Error.prototype, "toString")!.get).toBeUndefined();
+  expect(Object.getOwnPropertyNames(Object.prototype)).not.toContain("format");
+  expect({}.toString()).toEqual("[object Object]");
+  expect(String(new Error("boom"))).toEqual("Error: boom");
+});