// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
//
// Usage:
//
//   import "zod/compile";
//   import * as z from "zod";
//   // every schema constructed below this is compiled on first parse
//
// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
//
// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
import { compile } from "./v4/core/compile.js";
import * as core from "./v4/core/index.js";
let compiling = false;
core.globalConfig.postProcessor = (inst) => {
    if (compiling)
        return;
    const originalRun = inst._zod?.run;
    if (typeof originalRun !== "function")
        return;
    const shim = (payload, ctx) => {
        // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
        if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
            return originalRun(payload, ctx);
        }
        compiling = true;
        try {
            // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
            if (core.globalConfig.jitless) {
                inst._zod.run = originalRun;
                return originalRun(payload, ctx);
            }
            // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
            const compiled = compile(inst, { strict: true });
            // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
            inst._zod.run = compiled._zod.run;
            inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
            inst._zod.bag.validator = compiled._zod.bag.validator;
        }
        catch {
            // Permanent fallback for unsupported schemas.
            inst._zod.run = originalRun;
        }
        finally {
            compiling = false;
        }
        return inst._zod.run(payload, ctx);
    };
    // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
    shim.__originalRun = originalRun;
    inst._zod.run = shim;
};