perf(v4): preserve JIT fastpass in parseMaybeAsync / safeParseMaybeAsync

The previous implementation forced ctx.async = true upfront, which
bypassed ZodObject's JIT fastpass (gated on ctx?.async === false strict)
and caused a ~5x slowdown on the sync hot path that 99% of consumers
take. This was the regression that closed #5924.

Run sync first (async: false) so the fastpass engages; only fall back to
the async path on $ZodAsyncError or a Promise return. Closures in the
hot path are flattened (the previous higher-order finalize factory
allocated per call).

Sync object schemas now match safeParse within benchmark noise; async
schemas pay one extra short-circuited sync pass that bails on the first
async check, which is the right tradeoff given async is the minority case.

Refs #5379, #5924.

Author: dokson

packages/bench/object-maybe-async.ts

@@ -0,0 +1,26 @@
+import * as z from "../zod/src/v4/index.js";
+import { makeData } from "./benchUtil.js";
+import { metabench } from "./metabench.js";
+
+const schema = z.object({
+  string: z.string(),
+  boolean: z.boolean(),
+  number: z.number(),
+});
+
+const DATA = makeData(1000, () => ({
+  number: Math.random(),
+  string: `${Math.random()}`,
+  boolean: Math.random() > 0.5,
+}));
+
+const bench = metabench("small: z.object().safeParse vs safeParseMaybeAsync", {
+  safeParse() {
+    for (const _ of DATA) schema.safeParse(_);
+  },
+  safeParseMaybeAsync() {
+    for (const _ of DATA) schema.safeParseMaybeAsync(_);
+  },
+});
+
+await bench.run();

packages/zod/src/v4/core/parse.ts

@@ -59,17 +59,36 @@ export type $ParseMaybeAsync = <T extends schemas.$ZodType>(
 
 export const _parseMaybeAsync: (_Err: $ZodErrorClass) => $ParseMaybeAsync =
   (_Err) => (schema, value, _ctx, _params) => {
+    // Sync first: ZodObject's JIT fastpass requires ctx.async === false.
+    const syncCtx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: false } : { async: false };
+    const ErrCls = _params?.Err ?? _Err;
+    let r: schemas.ParsePayload | Promise<schemas.ParsePayload> | undefined;
+    let asyncFallback = false;
+    try {
+      r = schema._zod.run({ value, issues: [] }, syncCtx);
+    } catch (e) {
+      if (!(e instanceof core.$ZodAsyncError)) throw e;
+      asyncFallback = true;
+    }
+    if (!asyncFallback && !(r instanceof Promise)) {
+      if (r!.issues.length) {
+        const e = new ErrCls(r!.issues.map((iss) => util.finalizeIssue(iss, syncCtx, core.config())));
+        util.captureStackTrace(e, _params?.callee);
+        throw e;
+      }
+      return r!.value as core.output<typeof schema>;
+    }
     const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: true } : { async: true };
-    const finalize = (r: schemas.ParsePayload) => {
-      if (r.issues.length) {
-        const e = new (_params?.Err ?? _Err)(r.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+    const ar = schema._zod.run({ value, issues: [] }, ctx);
+    const finalize = (rr: schemas.ParsePayload) => {
+      if (rr.issues.length) {
+        const e = new ErrCls(rr.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
         util.captureStackTrace(e, _params?.callee);
         throw e;
       }
-      return r.value as core.output<typeof schema>;
+      return rr.value as core.output<typeof schema>;
     };
-    const result = schema._zod.run({ value, issues: [] }, ctx);
-    return result instanceof Promise ? result.then(finalize) : finalize(result);
+    return ar instanceof Promise ? ar.then(finalize) : finalize(ar);
   };
 
 export const parseMaybeAsync: $ParseMaybeAsync = /* @__PURE__*/ _parseMaybeAsync(errors.$ZodRealError);
@@ -124,13 +143,30 @@ export type $SafeParseMaybeAsync = <T extends schemas.$ZodType>(
 ) => util.MaybeAsync<util.SafeParseResult<core.output<T>>>;
 
 export const _safeParseMaybeAsync: (_Err: $ZodErrorClass) => $SafeParseMaybeAsync = (_Err) => (schema, value, _ctx) => {
+  // Sync first: ZodObject's JIT fastpass requires ctx.async === false.
+  const syncCtx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: false } : { async: false };
+  let r: schemas.ParsePayload | Promise<schemas.ParsePayload> | undefined;
+  let asyncFallback = false;
+  try {
+    r = schema._zod.run({ value, issues: [] }, syncCtx);
+  } catch (e) {
+    if (!(e instanceof core.$ZodAsyncError)) throw e;
+    asyncFallback = true;
+  }
+  if (!asyncFallback && !(r instanceof Promise)) {
+    return (
+      r!.issues.length
+        ? { success: false, error: new _Err(r!.issues.map((iss) => util.finalizeIssue(iss, syncCtx, core.config()))) }
+        : { success: true, data: r!.value }
+    ) as any;
+  }
   const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: true } : { async: true };
-  const finalize = (r: schemas.ParsePayload) =>
-    r.issues.length
-      ? { success: false, error: new _Err(r.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))) }
-      : { success: true, data: r.value };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  return (result instanceof Promise ? result.then(finalize) : finalize(result)) as any;
+  const ar = schema._zod.run({ value, issues: [] }, ctx);
+  const finalize = (rr: schemas.ParsePayload) =>
+    rr.issues.length
+      ? { success: false, error: new _Err(rr.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))) }
+      : { success: true, data: rr.value };
+  return (ar instanceof Promise ? ar.then(finalize) : finalize(ar)) as any;
 };
 
 export const safeParseMaybeAsync: $SafeParseMaybeAsync = /* @__PURE__*/ _safeParseMaybeAsync(errors.$ZodRealError);