@loomhelm/multi-task-flow 0.2.7 → 0.2.9

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v4/classic/tests/validate.test.ts

@@ -1,645 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as zm from "zod/mini";
-import * as z from "zod/v4";
-
-test("validate answers like safeParse.success", () => {
-  expect(z.validate(z.string(), "asdf")).toBe(true);
-  expect(z.validate(z.string(), 12)).toBe(false);
-  expect(z.validate(z.number().int().min(0), 5)).toBe(true);
-  expect(z.validate(z.number().int().min(0), -5)).toBe(false);
-  const schema = z.object({ a: z.string(), b: z.array(z.number()) });
-  expect(z.validate(schema, { a: "x", b: [1, 2] })).toBe(true);
-  expect(z.validate(schema, { a: "x", b: [1, "2"] })).toBe(false);
-  expect(z.validate(schema, null)).toBe(false);
-});
-
-test("validate runs transforms and refinements for the verdict only", () => {
-  const schema = z
-    .string()
-    .transform((s) => s.length)
-    .pipe(z.number().max(3));
-  expect(z.validate(schema, "ab")).toBe(true);
-  expect(z.validate(schema, "abcd")).toBe(false);
-  expect(z.validate(z.coerce.number(), "5")).toBe(true);
-});
-
-test("validate narrows to the input type", () => {
-  const value: unknown = "hi";
-  if (z.validate(z.string(), value)) {
-    expectTypeOf(value).toEqualTypeOf<string>();
-  }
-  const transforming = z.string().transform((s) => s.length);
-  if (z.validate(transforming, value)) {
-    expectTypeOf(value).toEqualTypeOf<string>();
-  }
-});
-
-test("validate throws on async schemas; validateAsync handles them", async () => {
-  const schema = z.string().refine(async (s) => s.length > 2);
-  expect(() => z.validate(schema, "asdf")).toThrow();
-  await expect(z.validateAsync(schema, "asdf")).resolves.toBe(true);
-  await expect(z.validateAsync(schema, "a")).resolves.toBe(false);
-  await expect(z.validateAsync(z.string(), "a")).resolves.toBe(true);
-  // a promise-returning callback that is not declared async compiles, so the compiled schema must stay off the fast path
-  const compiled = z.compile(z.string().refine((s) => Promise.resolve(s.length > 1)));
-  await expect(z.validateAsync(compiled, "abc")).resolves.toBe(true);
-  await expect(z.validateAsync(compiled, "a")).resolves.toBe(false);
-});
-
-test("validate agrees with the compiled fast path and keeps the callback bound", () => {
-  let calls = 0;
-  const schema = z.object({
-    name: z.string().refine((s) => {
-      calls++;
-      return s.length > 1;
-    }),
-  });
-  const compiled = z.compile(schema);
-
-  calls = 0;
-  expect(z.validate(compiled, { name: "ok" })).toBe(true);
-  expect(calls).toBe(1);
-
-  calls = 0;
-  expect(z.validate(compiled, { name: "x" })).toBe(false);
-  // a user callback can throw, so its rejection is not decidable and the fallback still runs
-  expect(calls).toBeLessThanOrEqual(2);
-
-  expect(z.validate(compiled, { name: 42 })).toBe(false);
-  expect(z.validate(compiled, { name: "x" }, {})).toBe(false);
-  expect(z.validate(schema, { name: "ok" })).toBe(true);
-});
-
-test("the validate shortcut is taken for callback-free schemas only", () => {
-  const definite = (s: z.ZodType) => (z.compile(s, { strict: true }) as any)._zod.bag.validator?.definite;
-
-  // nothing here can throw, so a compiled rejection is proof the runtime would reject
-  expect(definite(z.object({ a: z.string().min(1), b: z.number().max(3), c: z.email() }))).toBe(true);
-  expect(definite(z.array(z.enum(["a", "b"])))).toBe(true);
-
-  // each of these can answer INVALID for something the interpreter throws on
-  expect(definite(z.object({ a: z.string().refine(() => true) }))).toBe(false);
-  expect(definite(z.string().transform((v) => v))).toBe(false);
-  expect(definite(z.custom(() => true))).toBe(false);
-  expect(definite(z.number().catch(0))).toBe(false);
-  expect(definite(z.lazy(() => z.string()))).toBe(false);
-  expect(
-    definite(
-      z.intersection(
-        z.number(),
-        z.number().transform((x) => x + 1)
-      )
-    )
-  ).toBe(false);
-  expect(
-    definite(
-      z.record(
-        z.string().transform((k) => k),
-        z.number()
-      )
-    )
-  ).toBe(false);
-});
-
-test("compiled validate keeps the fallback where INVALID is not a decidable rejection", () => {
-  // an intersection answers INVALID for an unmergeable merge, which the interpreter answers with a throw — a fast false would misreport a schema bug
-  const unmergeable = z.compile(
-    z.intersection(
-      z.number(),
-      z.number().transform((x) => x + 1)
-    ),
-    { strict: true }
-  );
-  expect(() => z.validate(unmergeable, 1234)).toThrow("Unmergable intersection");
-
-  // a when-gated check islands at codegen, and an island answers INVALID for an async run too
-  const gated = z.number().refine(() => Promise.resolve(true));
-  (gated._zod.def.checks![0]!._zod.def as { when?: unknown }).when = () => true;
-  const compiled = z.compile(z.object({ n: gated }), { strict: true });
-  expect(() => z.validate(compiled, { n: 3 })).toThrow(z.core.$ZodAsyncError);
-  expect(() => z.validate(z.object({ n: gated }), { n: 3 })).toThrow(z.core.$ZodAsyncError);
-
-  // a plain function handing back a promise answers INVALID for union parity, so a transform is never a decidable rejection
-  const piped = z.string().transform(() => Promise.resolve(1));
-  expect(() => z.validate(z.compile(piped, { strict: true }), "x")).toThrow(z.core.$ZodAsyncError);
-  expect(() => z.validate(piped, "x")).toThrow(z.core.$ZodAsyncError);
-
-  // a continuable child issue short-circuits the compiled intersection before its merge, but the interpreter reaches the merge and throws
-  const continuable = z.intersection(
-    z.number().min(10),
-    z.number().transform((x) => x + 1)
-  );
-  expect(() => z.validate(z.compile(continuable, { strict: true }), 1)).toThrow("Unmergable intersection");
-  expect(() => z.validate(continuable, 1)).toThrow("Unmergable intersection");
-});
-
-test("compiled validate agrees with the interpreter, verdict and throw alike", () => {
-  // guards the `definite` flag: a new generator that answers INVALID for something the interpreter throws on must clear it, or this fails
-  const thenable = () => Promise.resolve(1) as never;
-  const schemas: z.ZodType[] = [
-    z.object({ a: z.string(), b: z.number().min(1) }),
-    z.strictObject({ a: z.string() }),
-    z.array(z.string().min(1)),
-    z.tuple([z.string()], z.number()),
-    z.record(z.string(), z.number()),
-    // a record key compiles in its own context, so its definiteness has to be carried out
-    z.record(z.string().transform(thenable), z.number()),
-    z.record(z.email(), z.number()),
-    z.union([z.string(), z.number()]),
-    z.intersection(
-      z.number(),
-      z.number().transform((x) => x + 1)
-    ),
-    z.intersection(
-      z.number().min(10),
-      z.number().transform((x) => x + 1)
-    ),
-    // unmergeable with no user callback in it, so only the intersection itself can clear the flag
-    z.intersection(z.string().default("a"), z.string().default("b")),
-    z.lazy(() => z.object({ a: z.string() })),
-    z.number().catch(0),
-    z.nonoptional(z.string().optional()),
-    z.map(z.string(), z.number()),
-    z.set(z.string().min(2)),
-    z.templateLiteral(["a", z.number()]),
-    z.coerce.number(),
-    z.stringbool(),
-    z.string().transform(thenable),
-    z.union([z.string().transform(thenable), z.number()]),
-    z.array(z.string().transform(thenable)),
-    z.custom(thenable),
-    z.string().refine(thenable),
-    z.string().pipe(z.string().min(3)),
-    // a codec's decode is the pipe branch's transform, and a plain function can still hand back a promise
-    z.codec(z.string(), z.number(), { decode: thenable, encode: String }),
-    z.object({ first: z.string(), second: z.codec(z.string(), z.number(), { decode: thenable, encode: String }) }),
-    // a continuable check does not settle the interpreter's walk, so it reaches a throwing callback the compiled path short-circuits past — the first-failure exit does not cover the check chain
-    z
-      .string()
-      .min(5)
-      .refine(() => {
-        throw new RangeError("u");
-      }),
-    z
-      .string()
-      .min(5)
-      .superRefine(() => {
-        throw new RangeError("u");
-      }),
-    // a user callback can throw, and compiled code can reject an earlier sibling before ever reaching it
-    z.object({
-      first: z.string(),
-      second: z.string().refine(() => {
-        throw new RangeError("u");
-      }),
-    }),
-    z.object({
-      first: z.string(),
-      second: z.custom(() => {
-        throw new TypeError("u");
-      }),
-    }),
-    // superRefine and check take the other branch of the refine generator than refine does
-    z.object({
-      first: z.string(),
-      second: z.string().superRefine(() => {
-        throw new RangeError("u");
-      }),
-    }),
-    z.string().superRefine(thenable as never),
-    z.object({
-      first: z.string(),
-      second: z.string().transform(() => {
-        throw new RangeError("u");
-      }),
-    }),
-    z.object({ first: z.string(), second: z.custom(thenable) }),
-    z.tuple([
-      z.string(),
-      z.number().catch(() => {
-        throw new RangeError("u");
-      }),
-    ]),
-  ];
-  const inputs = [
-    "x",
-    "ab",
-    "",
-    0,
-    1,
-    Number.NaN,
-    true,
-    null,
-    undefined,
-    {},
-    { a: "x" },
-    { a: 1 },
-    [],
-    ["x"],
-    new Map(),
-    new Set(["a"]),
-    "true",
-    // the exposing shape: an earlier field the compiled path rejects before it reaches the throwing one
-    { first: 1, second: "s" },
-    { first: "s", second: "s" },
-    { first: 1 },
-    [1, "x"],
-    ["s", "x"],
-  ];
-  const outcome = (fn: () => unknown) => {
-    try {
-      return `ok:${fn()}`;
-    } catch (err) {
-      return `throw:${(err as Error)?.constructor?.name}`;
-    }
-  };
-
-  for (const schema of schemas) {
-    let compiled: z.ZodType;
-    try {
-      compiled = z.compile(schema, { strict: true });
-    } catch {
-      continue; // refused at codegen, so there is no fast path to disagree
-    }
-    for (const input of inputs) {
-      expect(
-        outcome(() => z.validate(compiled, input)),
-        `${JSON.stringify(input)} on ${schema._zod.def.type}`
-      ).toBe(outcome(() => z.validate(schema, input)));
-    }
-  }
-});
-
-test("validate is exported from zod/mini", () => {
-  expect(zm.validate(zm.string(), "a")).toBe(true);
-  expect(zm.validate(zm.string(), 1)).toBe(false);
-  expect(zm.validate(zm.object({ a: zm.number() }), { a: 1 })).toBe(true);
-});
-
-test("the validate method matches the top-level function", () => {
-  expect(z.string().validate("asdf")).toBe(true);
-  expect(z.string().validate(12)).toBe(false);
-  expect(z.object({ a: z.string() }).validate({ a: "x" })).toBe(true);
-  expect(z.object({ a: z.string() }).validate({ a: 1 })).toBe(false);
-  expect(z.compile(z.object({ a: z.string() })).validate({ a: "x" })).toBe(true);
-});
-
-test("the validate method narrows to the input type", () => {
-  const value: unknown = "hi";
-  if (z.string().validate(value)) {
-    expectTypeOf(value).toEqualTypeOf<string>();
-  }
-  const transforming = z.string().transform((s) => s.length);
-  if (transforming.validate(value)) {
-    expectTypeOf(value).toEqualTypeOf<string>();
-    expectTypeOf(value).not.toEqualTypeOf<number>();
-  }
-});
-
-test("the validate method takes a params argument", () => {
-  let calls = 0;
-  const error = () => {
-    calls++;
-    return "bad";
-  };
-  expect(z.string().validate(12, { error })).toBe(false);
-  expect(z.string().validate("ok", { error })).toBe(true);
-  // a ctx defeats the compiled definite shortcut, so this is the fallback answering
-  expect(z.compile(z.string()).validate(12, { error })).toBe(false);
-  expect(z.string().validate("ok", { jitless: true })).toBe(true);
-  // no issue is ever finalized, so an error map never runs
-  expect(calls).toBe(0);
-});
-
-test("the validateAsync method handles async schemas the method form throws on", async () => {
-  const schema = z.string().refine(async (s) => s.length > 2);
-  expect(() => schema.validate("asdf")).toThrow(z.core.$ZodAsyncError);
-  await expect(schema.validateAsync("asdf")).resolves.toBe(true);
-  await expect(schema.validateAsync("a")).resolves.toBe(false);
-  await expect(z.string().validateAsync(12)).resolves.toBe(false);
-});
-
-test("zod/mini has no validate method", () => {
-  const schema = zm.string();
-  expect("parse" in schema).toBe(true);
-  expect("validate" in schema).toBe(false);
-  expect("validateAsync" in schema).toBe(false);
-});
-
-// counts reads of each child slot, so a stopped walk is observable without putting a callback in the schema — a refinement spy would work too, but reading the input says nothing about what ran
-function counted(
-  slots: Record<string, unknown>,
-  bad: Record<string, unknown> = {}
-): [Record<string, unknown>, () => number] {
-  let reads = 0;
-  const obj: Record<string, unknown> = { ...bad };
-  for (const [k, v] of Object.entries(slots)) {
-    Object.defineProperty(obj, k, {
-      enumerable: true,
-      get() {
-        reads++;
-        return v;
-      },
-    });
-  }
-  return [obj, () => reads];
-}
-
-test("validate stops a container at its first aborting issue", () => {
-  const shape = { a: z.number(), b: z.string(), c: z.string() };
-
-  for (const jitless of [false, true]) {
-    const label = jitless ? "interpreted" : "compiled";
-    const [input, reads] = counted({ b: "x", c: "x" }, { a: "no" });
-    expect(z.validate(z.object(shape), input, { jitless }), label).toBe(false);
-    expect(reads(), `${label}: keys read after the first abort`).toBe(0);
-
-    const [ok, okReads] = counted({ b: "x", c: "x" }, { a: 1 });
-    expect(z.validate(z.object(shape), ok, { jitless }), label).toBe(true);
-    expect(okReads(), `${label}: a valid parse still reads every key`).toBe(2);
-  }
-
-  // an array stops at the first bad element
-  const arr: unknown[] = [1];
-  let elementReads = 0;
-  for (const i of [1, 2]) {
-    Object.defineProperty(arr, i, {
-      enumerable: true,
-      get() {
-        elementReads++;
-        return "x";
-      },
-    });
-  }
-  expect(z.validate(z.array(z.string()), arr)).toBe(false);
-  expect(elementReads, "elements read after the first abort").toBe(0);
-
-  // the shape phase's abort carries across into the catchall
-  const [co, coReads] = counted({ b: "x" }, { a: "no" });
-  expect(z.validate(z.object({ a: z.number() }).catchall(z.string()), co)).toBe(false);
-  expect(coReads(), "catchall keys read after the shape aborted").toBe(0);
-
-  // and a tuple's fixed items carry into its rest
-  const tup: unknown[] = ["no"];
-  let restReads = 0;
-  for (const i of [1, 2]) {
-    Object.defineProperty(tup, i, {
-      enumerable: true,
-      get() {
-        restReads++;
-        return "x";
-      },
-    });
-  }
-  expect(z.validate(z.tuple([z.number()], z.string()), tup)).toBe(false);
-  expect(restReads, "rest elements read after a fixed item aborted").toBe(0);
-});
-
-test("a default provider runs only when the key is absent", () => {
-  const boom = (): never => {
-    throw new RangeError("boom");
-  };
-  // the provider sits behind an accessor, so reading the def would call it
-  for (const [name, schema] of [
-    ["default", z.object({ a: z.number(), b: z.string().default(boom as any) })],
-    ["prefault", z.object({ a: z.number(), b: z.string().prefault(boom as any) })],
-  ] as const) {
-    expect(z.validate(schema, { a: "bad", b: "ok" }), name).toBe(false);
-    expect(z.validate(schema, { a: 1, b: "ok" }), name).toBe(true);
-  }
-  // absent, the provider does run, and its throw is the parse's own
-  expect(() => z.validate(z.object({ b: z.string().default(boom as any) }), {})).toThrow(RangeError);
-});
-
-test("the first failure stops the walk whatever follows it", () => {
-  // a sibling after the failure is never parsed, so its refinement never runs
-  let calls = 0;
-  const spy = z.string().refine(() => {
-    calls++;
-    return true;
-  });
-  expect(z.validate(z.object({ a: z.number(), b: spy, c: spy }), { a: "no", b: "x", c: "x" })).toBe(false);
-  expect(calls).toBe(0);
-
-  // reads of the trailing key say whether the walk stopped, without putting a callback in the schema
-  const skips = (b: z.ZodType, value: unknown = "x") => {
-    let reads = 0;
-    const input: Record<string, unknown> = { a: "no" };
-    Object.defineProperty(input, "b", {
-      enumerable: true,
-      get() {
-        reads++;
-        return value;
-      },
-    });
-    z.validate(z.object({ a: z.number(), b }), input);
-    return reads === 0;
-  };
-
-  // the trailing key is skipped no matter what it holds -- user code included, since it is never reached
-  for (const [name, b, value] of [
-    ["plain", z.string(), "x"],
-    ["min", z.string().min(2), "x"],
-    ["email", z.email(), "x"],
-    ["array", z.array(z.string().min(2)), ["ab"]],
-    ["error map", z.string({ error: () => "nope" }), "x"],
-    ["transform", z.string().transform((v) => v), "x"],
-    ["refine", z.string().refine(() => true), "x"],
-    ["custom", z.custom(() => true), "x"],
-    ["catch", z.string().catch("x"), "x"],
-    ["lazy", z.lazy(() => z.string()), "x"],
-    ["coerce", z.coerce.number(), 1],
-  ] as [string, z.ZodType, unknown][]) {
-    expect(skips(b, value), name).toBe(true);
-  }
-});
-
-test("a continuable issue never stops the walk", () => {
-  // .min() is continuable, so a surrounding schema can still reconcile it and the guard must not stop
-  let calls = 0;
-  const el = z
-    .string()
-    .min(5)
-    .refine(() => {
-      calls++;
-      return true;
-    });
-  expect(z.validate(z.array(el), ["a", "b", "c"])).toBe(false);
-  expect(calls).toBe(3);
-});
-
-test("z.record keeps walking under validate", () => {
-  // deliberate asymmetry: a record's invalid_key aborts, but an enclosing intersection reconciles it against the sibling operand, so a stopped loop hides keys the sibling does not own
-  let reads = 0;
-  const input: Record<string, unknown> = { a: 1 };
-  for (const k of ["b", "c"]) {
-    Object.defineProperty(input, k, {
-      enumerable: true,
-      get() {
-        reads++;
-        return "x";
-      },
-    });
-  }
-  expect(z.validate(z.record(z.string(), z.string()), input)).toBe(false);
-  expect(reads).toBe(2);
-});
-
-test("validate matches safeParse where an issue can still be reconciled away", async () => {
-  const recA = z.record(z.string().regex(/^a/), z.any());
-  const recB = z.record(z.string().regex(/^b/), z.any());
-  const schemas: z.ZodType[] = [
-    z.intersection(recA, recB),
-    z.intersection(recA.pipe(z.any()), recB.pipe(z.any())),
-    z.intersection(z.strictObject({ a: z.string() }), z.strictObject({ b: z.number() })),
-    z.intersection(z.array(z.string()), z.array(z.string().min(2))),
-    z.strictObject({ a: z.string() }).pipe(z.any()),
-    z.union([z.strictObject({ a: z.string() }), z.strictObject({ a: z.string(), b: z.number() })]),
-    z.array(z.string()).catch([]),
-    z.object({ a: z.string() }).optional(),
-  ];
-  const inputs: unknown[] = [
-    { a1: 1, b1: 2 },
-    { a1: 1, b1: 2, zz: 3 },
-    { a1: 1, zz: 2, b1: 3, yy: 4 },
-    { b1: 1, a1: 2, zz: 3, yy: 4 },
-    { a: "x", b: 1 },
-    { a: "x", b: 1, c: 9 },
-    { a: "x" },
-    ["ab", "cd"],
-    ["a", "b"],
-    undefined,
-  ];
-
-  const outcome = (fn: () => unknown) => {
-    try {
-      return `ok:${fn()}`;
-    } catch (err) {
-      return `throw:${(err as Error)?.constructor?.name}`;
-    }
-  };
-  const outcomeAsync = async (fn: () => Promise<unknown>) => {
-    try {
-      return `ok:${await fn()}`;
-    } catch (err) {
-      return `throw:${(err as Error)?.constructor?.name}`;
-    }
-  };
-
-  for (const schema of schemas) {
-    for (const input of inputs) {
-      const label = `${schema._zod.def.type} on ${JSON.stringify(input)}`;
-      expect(
-        outcome(() => z.validate(schema, input)),
-        label
-      ).toBe(outcome(() => schema.safeParse(input).success));
-      expect(await outcomeAsync(() => z.validateAsync(schema, input)), label).toBe(
-        await outcomeAsync(async () => (await schema.safeParseAsync(input)).success)
-      );
-    }
-  }
-});
-
-test("abortEarly does not leak into safeParse", () => {
-  const schema = z.object({ a: z.string(), b: z.string(), c: z.string() });
-  expect(schema.safeParse({ a: 1, b: 2, c: 3 }).error!.issues).toHaveLength(3);
-  expect(z.validate(schema, { a: 1, b: 2, c: 3 })).toBe(false);
-  expect(schema.safeParse({ a: 1, b: 2, c: 3 }).error!.issues).toHaveLength(3);
-});
-
-test("a callback after the first failure never runs, so validate answers where safeParse throws", () => {
-  const boom = (): never => {
-    throw new RangeError("boom");
-  };
-  // the deliberate divergence, in every shape that can carry a callback: an earlier sibling settles the boolean, so the later throw is never reached
-  const lateSym = Symbol("late");
-  const cases: [string, z.ZodType, unknown][] = [
-    ["object transform", z.object({ a: z.number(), b: z.string().transform(boom) }), { a: "bad", b: "ok" }],
-    ["object refine", z.object({ a: z.number(), b: z.string().refine(boom) }), { a: "bad", b: "ok" }],
-    ["object custom", z.object({ a: z.number(), b: z.custom(boom) }), { a: "bad", b: "ok" }],
-    // these three hang the callback off `_zod.check` rather than the def
-    ["object check", z.object({ a: z.number(), b: z.string().check(boom) }), { a: "bad", b: "ok" }],
-    ["object superRefine", z.object({ a: z.number(), b: z.string().superRefine(boom) }), { a: "bad", b: "ok" }],
-    ["object overwrite", z.object({ a: z.number(), b: z.string().overwrite(boom as any) }), { a: "bad", b: "ok" }],
-    // the input must carry the same symbol with a value the field accepts, or the transform never runs and the row asserts nothing
-    [
-      "symbol key",
-      z.object({ a: z.number(), [lateSym]: z.string().transform(boom) } as any),
-      { a: "bad", [lateSym]: "ok" },
-    ],
-    ["object catch", z.object({ a: z.number(), b: z.string().catch(boom) }), { a: "bad", b: 1 }],
-    ["object lazy", z.object({ a: z.number(), b: z.lazy(() => z.string().transform(boom)) }), { a: "bad", b: "ok" }],
-    ["array", z.array(z.union([z.number(), z.string().transform(boom)])), [true, "throws"]],
-    ["tuple rest", z.tuple([z.number()], z.string().transform(boom)), ["bad", "throws"]],
-    ["catchall", z.object({ a: z.number() }).catchall(z.string().transform(boom)), { a: "bad", b: "ok" }],
-    ["set", z.set(z.union([z.number(), z.string().transform(boom)])), new Set([true, "throws"])],
-    [
-      "map",
-      z.map(z.string(), z.union([z.number(), z.string().transform(boom)])),
-      new Map<any, any>([
-        [1, 0],
-        ["k", "throws"],
-      ]),
-    ],
-  ];
-
-  const outcome = (fn: () => unknown) => {
-    try {
-      return `ok:${fn()}`;
-    } catch (err) {
-      return `throw:${(err as Error)?.constructor?.name}`;
-    }
-  };
-
-  for (const [name, schema, input] of cases) {
-    // safeParse walks the whole tree and reaches the throw; validate settled the answer at the earlier sibling and never runs it
-    expect(
-      outcome(() => schema.safeParse(input).success),
-      `${name}: safeParse`
-    ).toBe("throw:RangeError");
-    expect(
-      outcome(() => z.validate(schema, input)),
-      `${name}: validate`
-    ).toBe("ok:false");
-  }
-});
-
-test("the stop lands between children, not inside one", () => {
-  const boom = (): never => {
-    throw new RangeError("boom");
-  };
-  // both parse as a unit, so an abort in one half cannot skip the other; stopping inside either risks a discarded issue turning a false into a true
-  const pairs: [string, z.ZodType, unknown][] = [
-    ["map entry", z.map(z.number(), z.string().transform(boom)), new Map([["bad", "ok"]])],
-    ["tuple fixed item", z.tuple([z.number(), z.string().transform(boom)]), ["bad", "ok"]],
-  ];
-  for (const [name, schema, input] of pairs) {
-    expect(() => z.validate(schema, input), name).toThrow(RangeError);
-    expect(() => schema.safeParse(input), `${name}: safeParse agrees`).toThrow(RangeError);
-  }
-
-  // between children, the stop does happen
-  expect(z.validate(z.object({ a: z.number(), b: z.string().transform(boom) }), { a: "bad", b: "ok" })).toBe(false);
-  expect(z.validate(z.array(z.union([z.number(), z.string().transform(boom)])), [true, "ok"])).toBe(false);
-});
-
-test("validate rethrows a callback it actually reaches", () => {
-  const boom = (): never => {
-    throw new RangeError("boom");
-  };
-  // nothing rejects before the callback, so validate reaches it and the throw is the caller's
-  const cases: [string, z.ZodType, unknown][] = [
-    ["transform", z.object({ a: z.string().transform(boom), b: z.number() }), { a: "ok", b: "bad" }],
-    ["refine", z.object({ a: z.string().refine(boom), b: z.number() }), { a: "ok", b: "bad" }],
-    ["check", z.object({ a: z.string().check(boom), b: z.number() }), { a: "ok", b: "bad" }],
-    ["array element", z.array(z.string().transform(boom)), ["ok", "ok"]],
-    ["catchall", z.object({}).catchall(z.string().transform(boom)), { a: "ok" }],
-    ["set", z.set(z.string().transform(boom)), new Set(["ok"])],
-    ["map", z.map(z.string(), z.string().transform(boom)), new Map([["k", "ok"]])],
-    ["tuple rest", z.tuple([z.string()], z.string().transform(boom)), ["ok", "ok"]],
-  ];
-  for (const [name, schema, input] of cases) {
-    expect(() => z.validate(schema, input), name).toThrow(RangeError);
-  }
-});