@wopee-io/wopee.wdio 5.2.5 → 6.0.1

package/node_modules/zod/src/v4/mini/tests/cyclic-data.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, expect, test } from "vitest";
+import * as z from "zod/mini";
+
+// the config object lives on globalThis, so only file isolation protects it; pin the unset precondition explicitly
+beforeEach(() => {
+  delete z.config().memoizer;
+});
+
+const cyclic = (): any => {
+  const input: any = { id: 1 };
+  input.self = input;
+  return input;
+};
+
+test("cyclic input needs the memoizer opt-in", () => {
+  const Before: any = z.object({
+    id: z.number(),
+    get self() {
+      return Before;
+    },
+  });
+  expect(() => Before.parse(cyclic())).toThrow(RangeError);
+
+  z.config({ memoizer: z.memoizer() });
+  const After: any = z.object({
+    id: z.number(),
+    get self() {
+      return After;
+    },
+  });
+  const out = After.parse(cyclic());
+  expect(out.self).toBe(out);
+  expect(out).not.toBe(cyclic());
+  // read at construction, so a schema built before the opt-in keeps none
+  expect(() => Before.parse(cyclic())).toThrow(RangeError);
+});
+
+test("the opt-in reaches every core container", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Arr: any = z.array(z.lazy(() => Arr));
+  const input: any = [];
+  input.push(input);
+  const out = Arr.parse(input);
+  expect(out[0]).toBe(out);
+});
+
+test("rejects a cycle that closes through a transform", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Inner: any = z.object({
+    name: z.string(),
+    get self() {
+      return Wrapped;
+    },
+  });
+  const Wrapped: any = z.pipe(
+    Inner,
+    z.transform((value: any) => ({ wrapped: value }))
+  );
+
+  const input: any = { name: "x" };
+  input.self = input;
+
+  expect(() => Wrapped.parse(input)).toThrow(/reference cycle/);
+});
+
+test("leaves a transform that is not on the cycle alone", () => {
+  z.config({ memoizer: z.memoizer() });
+  const Node: any = z.object({
+    n: z.pipe(
+      z.number(),
+      z.transform((value: number) => value * 2)
+    ),
+    get self() {
+      return Node;
+    },
+  });
+
+  const input: any = { n: 21 };
+  input.self = input;
+
+  const result = Node.parse(input);
+  expect(result.n).toBe(42);
+  expect(result.self).toBe(result);
+});

package/node_modules/zod/src/v4/mini/tests/deep-partial.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/mini";
+
+describe("mini deepPartial", () => {
+  test("makes a ZodMiniObject's fields optional recursively", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({ bio: z.string(), age: z.number() }),
+    });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.ZodMiniObject>();
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ profile: {} })).toEqual({ profile: {} });
+    expect(partial.parse({ name: "x", profile: { bio: "b" } })).toEqual({
+      name: "x",
+      profile: { bio: "b" },
+    });
+  });
+
+  test("preserves ZodMiniObject structural type (shape accessible)", () => {
+    const schema = z.object({ a: z.string(), nested: z.object({ b: z.number() }) });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial.shape.a).toExtend<z.ZodMiniOptional<z.ZodMiniString>>();
+    expectTypeOf(partial.shape.nested).toExtend<z.ZodMiniOptional<z.ZodMiniObject>>();
+  });
+
+  test("tuple elements stay required", () => {
+    const schema = z.tuple([z.object({ a: z.string() }), z.string()]);
+    const partial = z.deepPartial(schema);
+    expect(() => partial.parse([{}])).toThrow();
+    expect(partial.parse([{}, "x"])).toEqual([{}, "x"]);
+  });
+
+  test("ZodMiniCodec preserved through deepPartial", () => {
+    const schema = z.codec(z.object({ a: z.string() }), z.object({ a: z.string() }), {
+      decode: (v) => v,
+      encode: (v) => v,
+    });
+    const partial = z.deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.ZodMiniCodec>();
+  });
+
+  test("recursive getter-based object is typeable", () => {
+    const Category = z.object({
+      name: z.string(),
+      get subcategories() {
+        return z.optional(z.array(Category));
+      },
+    });
+    const partial = z.deepPartial(Category);
+    expectTypeOf(partial).toExtend<z.ZodMiniObject>();
+    expect(partial.parse({ subcategories: [{}] })).toEqual({ subcategories: [{}] });
+  });
+});

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

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import * as z from "zod/v4-mini";
+import * as z from "zod/mini";
 
 test("no locale by default", () => {
   const result = z.safeParse(z.string(), 12);
@@ -11,12 +11,31 @@ test("no locale by default", () => {
 test("error inheritance", () => {
   const e1 = z.string().safeParse(123).error!;
   expect(e1).toBeInstanceOf(z.core.$ZodError);
-  // expect(e1).not.toBeInstanceOf(Error);
+  expect(e1).toBeInstanceOf(Error);
 
+  let e2: unknown;
   try {
     z.string().parse(123);
-  } catch (e2) {
-    expect(e2).toBeInstanceOf(z.core.$ZodRealError);
-    expect(e2).toBeInstanceOf(Error);
+  } catch (err) {
+    e2 = err;
   }
+  expect(e2).toBeInstanceOf(z.core.$ZodRealError);
+  expect(e2).toBeInstanceOf(Error);
+});
+
+test("a thrown error carries a stack rooted at the parse call site", () => {
+  function callSite() {
+    z.parse(z.string(), 123);
+  }
+
+  let thrown: unknown;
+  try {
+    callSite();
+  } catch (err) {
+    thrown = err;
+  }
+  expect(thrown).toBeInstanceOf(Error);
+  const stack = (thrown as Error).stack!;
+  expect(stack.startsWith("$ZodError: [")).toBe(true);
+  expect(stack).toContain("callSite");
 });

package/node_modules/zod/src/v4/mini/tests/functions.test.ts

@@ -1,43 +1,14 @@
 import { expect, test } from "vitest";
-// import * as z from "zod/v4/core";
+import * as z from "zod/mini";
 
 test("z.function", () => {
   expect(true).toEqual(true);
 });
 
-// test("z.function", () => {
-//   const a = z.function({
-//     args: z.tuple([z.string()]),
-//     returns: z.string(),
-//   });
+test("implement exposes the function schema at runtime", () => {
+  const schema = z.function({ input: [z.string()], output: z.number() });
+  const fn = schema.implement((s) => s.length);
 
-//   const myFunc = a.implement((name: string | number) => `Hello, ${name}!`);
-
-//   expect(myFunc("world")).toEqual("Hello, world!");
-//   expect(() => myFunc(123 as any)).toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFunc(123);
-//     expectTypeOf(r).toEqualTypeOf<string>();
-//   };
-// });
-
-// test("z.function async", async () => {
-//   const b = z.function({
-//     args: z.tuple([z.string()]).$check(async (_) => {}),
-//     returns: z.string().$check(async (_) => {}),
-//   });
-//   const myFuncAsync = b.implementAsync(async (name) => `Hello, ${name}!`);
-
-//   expect(await myFuncAsync("world")).toEqual("Hello, world!");
-//   expect(myFuncAsync(123 as any)).rejects.toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFuncAsync(123);
-//     expectTypeOf(r).toEqualTypeOf<Promise<string>>();
-//   };
-// });
+  expect((fn as any)._zod).toBe(schema._zod);
+  expect(fn("asdf")).toBe(4);
+});

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

@@ -1,7 +1,63 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4-mini";
+import * as z from "zod/mini";
 import type { util } from "zod/v4/core";
 
+test("factory checks", () => {
+  const string = z.string({ checks: [z.minLength(1), z.maxLength(3)] as const });
+  const number = z.number({ checks: [z.minimum(1), z.maximum(3)] as const });
+  expectTypeOf<z.output<typeof string>>().toEqualTypeOf<string>();
+  expectTypeOf<z.output<typeof number>>().toEqualTypeOf<number>();
+  for (const [schema, valid, invalid] of [
+    [string, "ab", ""],
+    [number, 2, 4],
+  ] as const) {
+    expect(z.validate(schema, valid)).toBe(true);
+    expect(z.validate(schema, invalid)).toBe(false);
+    expect(schema._zod.parent).toBeUndefined();
+    expect(z.validate(z.compile(schema), valid)).toBe(true);
+    expect(z.validate(z.compile(schema), invalid)).toBe(false);
+  }
+  // @ts-expect-error numeric checks cannot validate strings
+  z.string({ checks: [z.minimum(1)] });
+  // @ts-expect-error length checks cannot validate numbers
+  z.number({ checks: [z.minLength(1)] });
+});
+
+test("factory checks snapshot caller arrays", () => {
+  for (const factory of [z.string, z.coerce.string]) {
+    const checks = [z.minLength(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    checks.push(z.minLength(10));
+    expect(z.validate(schema, "long")).toBe(true);
+    expect(z.validate(z.compile(schema), "long")).toBe(true);
+    expect(z.toJSONSchema(schema).minLength).toBe(1);
+  }
+  for (const factory of [z.number, z.coerce.number]) {
+    const checks = [z.minimum(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    checks.push(z.minimum(10));
+    expect(z.validate(schema, 3)).toBe(true);
+    expect(z.validate(z.compile(schema), 3)).toBe(true);
+    expect(z.toJSONSchema(schema).minimum).toBe(1);
+  }
+});
+
 test("z.boolean", () => {
   const a = z.boolean();
   expect(z.parse(a, true)).toEqual(true);
@@ -165,6 +221,28 @@ test("z.iso.duration", () => {
   expect(z.safeParse(b, d2).success).toEqual(false);
 });
 
+test("z.prefault preserves undefined output", async () => {
+  const field = z.prefault(z.union([z.string(), z.undefined()]), () => undefined);
+  const schema = z.object({ a: field });
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+  expect(z.parse(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: undefined })).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: "value" })).toStrictEqual({ a: "value" });
+  expect(z.safeParse(schema, { a: 123 }).success).toBe(false);
+  expect(await z.parseAsync(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(z.object({ a: z.prefault(z.optional(z.string()), undefined) }), {})).toStrictEqual({ a: undefined });
+  const transformed = z.prefault(
+    z.pipe(
+      z.string(),
+      z.transform(() => undefined)
+    ),
+    "fallback"
+  );
+  expectTypeOf<z.output<typeof transformed>>().toEqualTypeOf<undefined>();
+  expect(z.parse(z.object({ a: transformed }), {})).toStrictEqual({ a: undefined });
+});
+
 test("z.undefined", () => {
   const a = z.undefined();
   expect(z.parse(a, undefined)).toEqual(undefined);
@@ -228,6 +306,63 @@ test("z.union", () => {
   expect(() => z.parse(a, true)).toThrow();
 });
 
+test("z.union([]) / z.xor([]) / z.discriminatedUnion(_, []) construct and reject all input", () => {
+  for (const schema of [z.union([]), z.xor([])]) {
+    const r = schema.safeParse("anything");
+    expect(r.success).toEqual(false);
+    if (!r.success) {
+      expect(r.error.issues[0].code).toBe("invalid_union");
+      expect((r.error.issues[0] as any).errors).toEqual([]);
+    }
+  }
+  const disc = z.discriminatedUnion("type", [] as any);
+  const r = disc.safeParse({ type: "x" });
+  expect(r.success).toEqual(false);
+  if (!r.success) {
+    expect(r.error.issues[0].code).toBe("invalid_union");
+    expect((r.error.issues[0] as any).errors).toEqual([]);
+    expect((r.error.issues[0] as any).options).toEqual([]);
+  }
+});
+
+test("z.discriminatedUnion rejects object options missing the discriminator", () => {
+  expect(() => z.discriminatedUnion("type", [z.object({ value: z.string() })])).toThrow(
+    /Invalid discriminated union option at index "0"/
+  );
+
+  // An option whose shape cannot be listed without resolving it is left to the lookup map, on the first object parsed.
+  const viaPipe = z.discriminatedUnion("type", [
+    z.pipe(z.object({ value: z.literal("x") }), z.object({ value: z.literal("x") })),
+  ]);
+  expect(() => z.safeParse(viaPipe, { value: "x" })).toThrow(/Invalid discriminated union option at index "0"/);
+});
+
+test("z.discriminatedUnion infers mutually-recursive getter options", () => {
+  const variantA = z.object({
+    kind: z.literal("a"),
+    get child() {
+      return z.optional(tree);
+    },
+  });
+
+  const variantB = z.object({
+    kind: z.literal("b"),
+    get sibling() {
+      return z.optional(tree);
+    },
+  });
+
+  const tree = z.discriminatedUnion("kind", [variantA, variantB]);
+
+  type _Tree = { kind: "a"; child?: _Tree | undefined } | { kind: "b"; sibling?: _Tree | undefined };
+
+  expectTypeOf<z.input<typeof tree>>().toEqualTypeOf<_Tree>();
+  expectTypeOf<z.input<typeof tree>>().not.toBeAny();
+
+  expect(z.parse(tree, { kind: "a", child: { kind: "b" } })).toEqual({ kind: "a", child: { kind: "b" } });
+  expect(() => z.parse(tree, { kind: "c" })).toThrow();
+});
+
 test("z.intersection", () => {
   const a = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
   expect(z.parse(a, { a: "hello", b: 123 })).toEqual({ a: "hello", b: 123 });
@@ -247,7 +382,7 @@ test("z.tuple", () => {
   const b = z.tuple([z.string(), z.number(), z.optional(z.string())], z.boolean());
   type b = z.output<typeof b>;
 
-  expectTypeOf<b>().toEqualTypeOf<[string, number, string?, ...boolean[]]>();
+  expectTypeOf<b>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
   const datas = [
     ["hello", 123],
     ["hello", 123, "world"],
@@ -265,7 +400,7 @@ test("z.tuple", () => {
   const cArgs = [z.string(), z.number(), z.optional(z.string())] as const;
   const c = z.tuple(cArgs, z.boolean());
   type c = z.output<typeof c>;
-  expectTypeOf<c>().toEqualTypeOf<[string, number, string?, ...boolean[]]>();
+  expectTypeOf<c>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
 });
 
 test("z.record", () => {
@@ -296,6 +431,44 @@ test("z.record", () => {
   expect(() => z.parse(c, { a: "hello", b: "world" })).toThrow();
   // extra keys
   expect(() => z.parse(c, { a: "hello", b: "world", c: "world", d: "world" })).toThrow();
+
+  // literal union keys
+  const d = z.record(z.union([z.literal("a"), z.literal(0)]), z.string());
+  type d = z.output<typeof d>;
+  expectTypeOf<d>().toEqualTypeOf<Record<"a" | 0, string>>();
+  expect(z.parse(d, { a: "hello", 0: "world" })).toEqual({
+    a: "hello",
+    0: "world",
+  });
+
+  // TypeScript enum keys
+  enum Enum {
+    A = 0,
+    B = "hi",
+  }
+
+  const e = z.record(z.enum(Enum), z.string());
+  type e = z.output<typeof e>;
+  expectTypeOf<e>().toEqualTypeOf<Record<Enum, string>>();
+  expect(z.parse(e, { [Enum.A]: "hello", [Enum.B]: "world" })).toEqual({
+    [Enum.A]: "hello",
+    [Enum.B]: "world",
+  });
+
+  const partial = z.partialRecord(z.enum(["__proto__", "b"]), z.string());
+  type partial = z.output<typeof partial>;
+  expectTypeOf<partial>().toEqualTypeOf<Partial<Record<"__proto__" | "b", string>>>();
+  const parsed: any = z.parse(partial, Object.fromEntries([["__proto__", "declared"]]));
+  expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+  expect(Object.prototype.hasOwnProperty.call(parsed, "__proto__")).toBe(false);
+  expect(parsed).toEqual({});
+  expect(z.parse(partial, {})).toEqual({});
+
+  // v3-compat single-arg form: z.record(valueType) defaults keyType to z.string()
+  const f = (z.record as any)(z.number());
+  expect(f._zod.def.keyType._zod.def.type).toEqual("string");
+  expect(f._zod.def.valueType._zod.def.type).toEqual("number");
+  expect(z.parse(f, { a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
 });
 
 test("z.map", () => {
@@ -396,6 +569,14 @@ test("z.enum - native", () => {
   // expect(a.enum.A).toEqual(NativeEnum.A);
   // expect(a.enum.B).toEqual(NativeEnum.B);
   // expect(a.enum.C).toEqual(NativeEnum.C);
+
+  enum NumericEnum {
+    A = 0,
+    B = 1,
+  }
+
+  // numeric enums carry reverse-mapping keys; options lists only what parse accepts
+  expect(z.enum(NumericEnum).options).toEqual([NumericEnum.A, NumericEnum.B]);
 });
 
 test("z.nativeEnum", () => {
@@ -626,8 +807,7 @@ test("z.custom", () => {
 });
 
 test("z.check", () => {
-  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic
-  // the function should return core.$ZodResult
+  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic the function should return core.$ZodResult
   const a = z.any().check(
     z.check<string>((ctx) => {
       if (typeof ctx.value === "string") return;
@@ -649,6 +829,47 @@ test("z.check", () => {
   });
 });
 
+test("z.with (alias for z.check)", () => {
+  // .with() should work exactly the same as .check()
+  const a = z.any().with(
+    z.check<string>((ctx) => {
+      if (typeof ctx.value === "string") return;
+      ctx.issues.push({
+        code: "custom",
+        origin: "custom",
+        message: "Expected a string",
+        input: ctx.value,
+      });
+    })
+  );
+  expect(z.safeParse(a, "hello")).toMatchObject({
+    success: true,
+    data: "hello",
+  });
+  expect(z.safeParse(a, 123)).toMatchObject({
+    success: false,
+    error: { issues: [{ code: "custom", message: "Expected a string" }] },
+  });
+
+  // Test with refine
+  const b = z.string().with(z.refine((val) => val.length > 3, "Must be longer than 3"));
+  expect(z.safeParse(b, "hello").success).toBe(true);
+  expect(z.safeParse(b, "hi").success).toBe(false);
+
+  // Test with function
+  const c = z.string().with(({ value, issues }) => {
+    if (value.length <= 3) {
+      issues.push({
+        code: "custom",
+        input: value,
+        message: "Must be longer than 3",
+      });
+    }
+  });
+  expect(z.safeParse(c, "hello").success).toBe(true);
+  expect(z.safeParse(c, "hi").success).toBe(false);
+});
+
 test("z.instanceof", () => {
   class A {}
 
@@ -777,19 +998,22 @@ test("z.stringbool", () => {
   expect(z.parse(b, "n")).toEqual(false);
   expect(z.safeParse(b, "true")).toMatchObject({ success: false });
   expect(z.safeParse(b, "false")).toMatchObject({ success: false });
+  expect(b._zod.bag.truthy).toEqual(["y"]);
+  expect(b._zod.bag.falsy).toEqual(["n"]);
 
   const c = z.stringbool({
     case: "sensitive",
   });
   expect(z.parse(c, "true")).toEqual(true);
   expect(z.safeParse(c, "TRUE")).toMatchObject({ success: false });
+  expect(c._zod.bag.case).toEqual("sensitive");
 });
 
 // promise
 test("z.promise", async () => {
   const a = z.promise(z.string());
   type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
+  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
 
   expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
     success: true,
@@ -869,3 +1093,54 @@ test("def typing", () => {
   z.catch(z.string(), "fallback").def.type satisfies "catch";
   z.file().def.type satisfies "file";
 });
+
+test("defaulted object schema returns shallow clone", () => {
+  const schema = z._default(
+    z.object({
+      a: z.string(),
+    }),
+    { a: "x" }
+  );
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  expect(result1).not.toBe(result2);
+  expect(result1).toEqual(result2);
+});
+
+test("runtime type property exists and returns correct values", () => {
+  const stringSchema = z.string();
+  expect(stringSchema.type).toBe("string");
+});
+
+test("type narrowing works with type property", () => {
+  type ArrayOrRecord = z.ZodMiniArray<z.ZodMiniString> | z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniAny>;
+  const arraySchema = z.array(z.string()) as ArrayOrRecord;
+
+  if (arraySchema.type === "array") {
+    expectTypeOf(arraySchema).toEqualTypeOf<z.ZodMiniArray<z.ZodMiniString<unknown>>>();
+    expect(arraySchema.def.element).toBeDefined();
+  }
+});
+
+test("getDiscriminatedOption", () => {
+  const a = z.object({ type: z.literal("a"), x: z.string() });
+  const b = z.object({ type: z.literal("b"), y: z.number() });
+  const schema = z.discriminatedUnion("type", [a, b]);
+
+  expect(z.getDiscriminatedOption(schema, "a")).toBe(a);
+  expect(z.getDiscriminatedOption(schema, "b")).toBe(b);
+  expectTypeOf(z.getDiscriminatedOption(schema, "a")).toEqualTypeOf<typeof a>();
+});
+
+test("z.partial on a tuple", () => {
+  const schema = z.partial(z.tuple([z.string(), z.number()]));
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<[(string | undefined)?, (number | undefined)?]>();
+
+  expect(z.safeParse(schema, []).success).toEqual(true);
+  expect(z.safeParse(schema, ["a"]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", 1]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", "b"]).success).toEqual(false);
+
+  const refined = z.tuple([z.string(), z.number()]).check(z.refine(([a]) => a.length > 0));
+  expect(() => z.partial(refined)).toThrow("cannot be used on tuple schemas containing refinements");
+});

package/node_modules/zod/src/v4/mini/tests/number.test.ts

@@ -1,5 +1,5 @@
 import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4-mini";
+import * as z from "zod/mini";
 
 test("z.number", () => {
   const a = z.number();
@@ -93,3 +93,17 @@ test("z.uint64", () => {
   // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
   // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
 });
+
+test("number and bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int()._zod.def.format).toEqualTypeOf<"safeint">();
+  expectTypeOf(z.uint32()._zod.def.format).toEqualTypeOf<"uint32">();
+  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
+
+  z.int32() satisfies z.ZodMiniInt32;
+  z.uint64() satisfies z.ZodMiniUInt64;
+
+  // @ts-expect-error a float64 schema is not a ZodMiniFloat32
+  z.float64() satisfies z.ZodMiniFloat32;
+  // @ts-expect-error a uint64 schema is not a ZodMiniInt64
+  z.uint64() satisfies z.ZodMiniInt64;
+});