zod-compiler 1.22.6 → 1.23.0

package/README.md

@@ -13,7 +13,7 @@ Keep your existing Zod schemas. Get **2-43x faster** validation. No code changes
 
 ## Usage
 
-Three ways to use zod-compiler — pick one:
+Four ways to use zod-compiler — pick one:
 
 ### 1. Automatic Mode (Default)
 
@@ -92,6 +92,27 @@ npx zod-compiler generate src/ --schemas explicit --emit bag
 npx zod-compiler generate src/ --emit compact
 ```
 
+### 4. Runtime Compilation (No Build Step)
+
+`jit()` runs the same pipeline in-process, for `tsx`, `ts-node`, Jest — anywhere no plugin fires:
+
+```typescript
+import { jit } from "zod-compiler/jit";
+
+export const UserSchema = jit(z.object({ name: z.string().min(1), email: z.email() }));
+```
+
+Same validators a build emits, installed on the schema object, so Zod interop is unchanged.
+Compilation is lazy — 0.1-0.3 ms on a schema's first parse; `{ eager: true }` compiles up front,
+`jitAll(namespace)` takes a whole module.
+
+The cost is the import: ~570 KB of codegen and `acorn`, **~10 ms of module load**. That suits a
+long-lived process, not a CLI, a cold serverless handler or a browser — use the build plugin there.
+Libraries should ship plain Zod and let the app decide.
+
+Needs `new Function`, as Zod's own object fast-path does. `z.config({ jitless: true })` and a CSP
+that blocks eval both leave a working plain-Zod schema.
+
 ## Build Plugin
 
 ### Supported Build Tools
@@ -156,7 +177,8 @@ import zodCompiler from "zod-compiler/bun";
 await Bun.build({ entrypoints: ["./src/index.tsx"], outdir: "./dist", plugins: [zodCompiler()] });
 ```
 
-For code run straight from source (`bun run src/server.ts`) no build plugin fires — use the
+For code run straight from source (`bun run src/server.ts`) no build plugin fires — use
+[`jit()`](#4-runtime-compilation-no-build-step) to compile in-process, or the
 [CLI](#3-cli-no-bundler) to compile ahead of time.
 
 ### Schema Hoisting
@@ -238,6 +260,9 @@ if (!process.env.ZOD_COMPILER) {
 
 With `@t3-oss/env-*`, pass `skipValidation: !!process.env.ZOD_COMPILER`.
 
+A schema whose SHAPE branches on an env var is baked at build time, and the cache key does not include
+the environment — give each environment its own `cache` directory if you share one across them.
+
 ### Large projects and CI
 
 Discovery executes each schema file inside the bundler's process, so the **first cold run** is the

package/dist/jit.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Runtime compilation — the same extract → codegen pipeline the build plugin
+ * runs, executed in-process and evaluated through `new Function`.
+ *
+ * The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday
+ * code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest
+ * suite, a serverless handler bundled by someone else's toolchain, a library
+ * that ships schemas to consumers. There `compile()` is a no-op and every parse
+ * runs plain Zod. `jit()` closes that gap — one call, no build integration,
+ * measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.
+ *
+ * Nothing here re-implements validation: {@link compileSchemas} and
+ * {@link generateIIFE} are the exact modules the plugin and CLI use, so the
+ * generated validator, its Zod parity and its performance are identical to what
+ * a build would have emitted. The only difference is *when* the code is
+ * produced.
+ *
+ * Compilation is LAZY by default: `jit()` installs accessors that compile on
+ * the first read of a parse method and replace themselves with the compiled
+ * ones. Importing a module of 500 schemas therefore costs nothing, and a
+ * serverless invocation touching three of them pays for three.
+ *
+ * Runtime code generation is not always permitted — a strict CSP without
+ * `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object
+ * fast-pass is itself a `new Function`) and already exposes the two switches
+ * for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.
+ * `jit()` honours both and degrades to plain Zod, so one setting governs both
+ * compilers. Those targets are where the build plugin belongs anyway — it emits
+ * the same validator with no runtime evaluation at all.
+ */
+import { type output, type ZodType } from "zod";
+import type { CompiledSchema } from "./core/types.js";
+export interface JitOptions {
+    /**
+     * Compile immediately instead of on first use. Costs ~0.1-0.2 ms per schema
+     * at import time; useful for a long-lived server that would rather pay during
+     * startup than on the first request, or to surface a compilation failure
+     * eagerly. Default `false`.
+     */
+    eager?: boolean | undefined;
+}
+/**
+ * Compile `schema` in-process and install the compiled `parse` / `safeParse` /
+ * `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.
+ *
+ * Returns the SAME object — identity-preserving exactly as the build plugin is,
+ * so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and
+ * composition into a larger schema all keep working, and every existing
+ * reference to the schema picks the compiled methods up.
+ *
+ * ```ts
+ * import { z } from "zod";
+ * import { jit } from "zod-compiler/jit";
+ *
+ * export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));
+ * UserSchema.safeParse(input); // compiled on this first call
+ * ```
+ *
+ * Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the
+ * same way they do at build time; a schema that cannot be compiled at all is
+ * left as plain Zod.
+ */
+export declare function jit<T extends ZodType>(schema: T, options?: JitOptions): T & CompiledSchema<output<T>>;
+/**
+ * Compile every Zod schema found among an object's own values — typically a
+ * module namespace, so a whole schema file opts in with one call:
+ *
+ * ```ts
+ * import * as schemas from "./schemas.js";
+ * jitAll(schemas);
+ * ```
+ *
+ * The namespace object itself is never written to (a module namespace is
+ * read-only); `jit()` mutates the schema objects it holds, which is what every
+ * importer of that module already references.
+ */
+export declare function jitAll(schemas: object, options?: JitOptions): void;
+//# sourceMappingURL=jit.d.ts.map

package/dist/jit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit.d.ts","sourceRoot":"","sources":["../src/jit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAsD,KAAK,MAAM,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAYpG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAiCtD,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,OAAO,EACnC,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,UAAU,GACnB,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAoD/B;AA0CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAIlE"}

package/dist/jit.js

@@ -0,0 +1,245 @@
+/**
+ * Runtime compilation — the same extract → codegen pipeline the build plugin
+ * runs, executed in-process and evaluated through `new Function`.
+ *
+ * The AOT paths (unplugin, CLI) need a build step to fire. Plenty of everyday
+ * code has none: `tsx server.ts`, `node --experimental-strip-types`, a Jest
+ * suite, a serverless handler bundled by someone else's toolchain, a library
+ * that ships schemas to consumers. There `compile()` is a no-op and every parse
+ * runs plain Zod. `jit()` closes that gap — one call, no build integration,
+ * measured 3-25x on everyday schemas at ~0.1-0.2 ms of one-time compilation.
+ *
+ * Nothing here re-implements validation: {@link compileSchemas} and
+ * {@link generateIIFE} are the exact modules the plugin and CLI use, so the
+ * generated validator, its Zod parity and its performance are identical to what
+ * a build would have emitted. The only difference is *when* the code is
+ * produced.
+ *
+ * Compilation is LAZY by default: `jit()` installs accessors that compile on
+ * the first read of a parse method and replace themselves with the compiled
+ * ones. Importing a module of 500 schemas therefore costs nothing, and a
+ * serverless invocation touching three of them pays for three.
+ *
+ * Runtime code generation is not always permitted — a strict CSP without
+ * `unsafe-eval`, some edge runtimes. Zod v4 has the same constraint (its object
+ * fast-pass is itself a `new Function`) and already exposes the two switches
+ * for it: the `core.util.allowsEval` probe and `z.config({ jitless: true })`.
+ * `jit()` honours both and degrades to plain Zod, so one setting governs both
+ * compilers. Those targets are where the build plugin belongs anyway — it emits
+ * the same validator with no runtime evaluation at all.
+ */
+import { config as zodConfig, core as zodCore, ZodRealError } from "zod";
+import { FAIL_CLASS_DECL, FAILZ_CLASS_DECL, FIN_DECL, FIN_DEFERRED_DECL, FINZ_DECL, generateIIFE, MK_VALIDATOR_DECL, ZOD_MSG_DECLARATION, } from "./core/iife.js";
+import { compileSchemas } from "./core/pipeline.js";
+/**
+ * The declarations `ZOD_CONFIG_IMPORT` supplies to an emitted module, minus the
+ * import itself — `zod`'s three bindings arrive as parameters instead, so the
+ * evaluated code has no module scope to resolve. Byte-for-byte the same helper
+ * source the CLI emitter writes into a `.compiled.ts`, so a JIT validator and
+ * an AOT one share their entire runtime layer.
+ */
+const RUNTIME_PRELUDE = [
+    ZOD_MSG_DECLARATION,
+    FAIL_CLASS_DECL,
+    MK_VALIDATOR_DECL,
+    FIN_DECL,
+    FIN_DEFERRED_DECL,
+    FAILZ_CLASS_DECL,
+    FINZ_DECL,
+].join("\n");
+/**
+ * Methods `__zcMkv` installs. Each is fronted by a compile-on-read accessor
+ * until the schema materializes.
+ *
+ * `~standard` earns its place: Zod builds it as a closure over `_zod.run`, not
+ * over the schema's `safeParse` property, so a Standard Schema consumer (tRPC,
+ * Hono, TanStack Form) that never touches `safeParse` would otherwise keep
+ * running plain Zod forever behind a "compiled" schema.
+ */
+const SLOTS = ["parse", "safeParse", "parseAsync", "safeParseAsync", "is", "~standard"];
+/** Schemas already handed to `jit()`, so a second call is a no-op rather than a recompile. */
+const seen = new WeakSet();
+/**
+ * Compile `schema` in-process and install the compiled `parse` / `safeParse` /
+ * `parseAsync` / `safeParseAsync` / `is` / `~standard` on it.
+ *
+ * Returns the SAME object — identity-preserving exactly as the build plugin is,
+ * so `.shape`, `_zod`, `instanceof`, `z.toJSONSchema()`, `.meta()` and
+ * composition into a larger schema all keep working, and every existing
+ * reference to the schema picks the compiled methods up.
+ *
+ * ```ts
+ * import { z } from "zod";
+ * import { jit } from "zod-compiler/jit";
+ *
+ * export const UserSchema = jit(z.object({ name: z.string(), email: z.email() }));
+ * UserSchema.safeParse(input); // compiled on this first call
+ * ```
+ *
+ * Schemas the compiler cannot reproduce fall back to Zod per sub-schema, the
+ * same way they do at build time; a schema that cannot be compiled at all is
+ * left as plain Zod.
+ */
+export function jit(schema, options) {
+    const target = schema;
+    if (seen.has(target))
+        return schema;
+    seen.add(target);
+    if (options?.eager === true) {
+        materialize(schema);
+        return schema;
+    }
+    // Snapshot Zod's own descriptors first: materialize() restores them before
+    // handing the object to `__zcMkv`, so the generated code sees a pristine
+    // schema — it captures `~standard`'s original `validate` as its throw path,
+    // and capturing a stub there would loop back into itself.
+    const original = new Map();
+    for (const slot of SLOTS) {
+        original.set(slot, Object.getOwnPropertyDescriptor(target, slot));
+    }
+    // Installing the accessors is the one step that can throw rather than degrade:
+    // a slot locked non-configurable (a future Zod, another wrapper) makes
+    // defineProperty raise, and `jit()` is called at module scope — so an
+    // unhandled throw here takes down the importing app at boot. Roll back to
+    // whatever Zod had and leave the schema alone instead.
+    let pending = true;
+    try {
+        installAccessors(target, original, () => {
+            if (!pending)
+                return;
+            pending = false;
+            restore(target, original);
+            materialize(schema);
+        }, () => {
+            if (!pending)
+                return;
+            pending = false;
+            // Restore EVERY slot, not just the one being written. A left-behind
+            // accessor whose trigger has been cancelled would read `target[slot]`
+            // and re-enter itself — unbounded recursion. This is the path the build
+            // plugin takes when a file uses `jit()` too: `__zcMkv` assigns the parse
+            // methods (cancelling here) and then reads `~standard`.
+            restore(target, original);
+        });
+    }
+    catch {
+        pending = false;
+        restore(target, original);
+    }
+    return schema;
+}
+/**
+ * Front every installed method with a compile-on-read accessor. `trigger`
+ * materializes the schema, which replaces these accessors with the compiled
+ * methods (or restores Zod's own), so the read that follows never re-enters.
+ */
+function installAccessors(target, original, trigger, cancel) {
+    for (const slot of SLOTS) {
+        Object.defineProperty(target, slot, {
+            configurable: true,
+            // Preserve Zod's own visibility: parse/safeParse/... are enumerable own
+            // properties, `~standard` is not. `is` does not exist on a Zod schema, so
+            // it follows the non-enumerable convention `compile()` already uses.
+            enumerable: original.get(slot)?.enumerable ?? false,
+            get() {
+                trigger();
+                // Whatever now occupies the slot: the compiled method, or — if
+                // compilation was impossible — Zod's own, put back by restore().
+                return target[slot];
+            },
+            set(value) {
+                // Someone overwrote a method before first use (a test double, another
+                // wrapper). Their value wins, and compilation is cancelled outright —
+                // materializing later would restore Zod's descriptors over it.
+                cancel();
+                Object.defineProperty(target, slot, {
+                    configurable: true,
+                    enumerable: original.get(slot)?.enumerable ?? false,
+                    value,
+                    writable: true,
+                });
+            },
+        });
+    }
+}
+/**
+ * Compile every Zod schema found among an object's own values — typically a
+ * module namespace, so a whole schema file opts in with one call:
+ *
+ * ```ts
+ * import * as schemas from "./schemas.js";
+ * jitAll(schemas);
+ * ```
+ *
+ * The namespace object itself is never written to (a module namespace is
+ * read-only); `jit()` mutates the schema objects it holds, which is what every
+ * importer of that module already references.
+ */
+export function jitAll(schemas, options) {
+    for (const value of Object.values(schemas)) {
+        if (isZodSchema(value))
+            jit(value, options);
+    }
+}
+/** Zod schemas carry `_zod.def`; the same probe auto-discovery uses at build time. */
+function isZodSchema(value) {
+    if (typeof value !== "object" || value === null || !("_zod" in value))
+        return false;
+    const internal = value["_zod"];
+    return typeof internal === "object" && internal !== null && "def" in internal;
+}
+/** Put Zod's own descriptors back, dropping the compile-on-read accessors. */
+function restore(target, original) {
+    for (const slot of SLOTS) {
+        const descriptor = original.get(slot);
+        if (descriptor === undefined)
+            delete target[slot];
+        else
+            Object.defineProperty(target, slot, descriptor);
+    }
+}
+/**
+ * Whether runtime code generation is permitted here. Read per call, never
+ * snapshotted: `z.config({ jitless: true })` runs in an entry point, after the
+ * schema modules it imports have already been evaluated.
+ */
+function codegenAllowed() {
+    return zodCore.globalConfig.jitless !== true && zodCore.util.allowsEval.value;
+}
+/**
+ * Run the pipeline and let the generated IIFE install its methods on `schema`.
+ * Swallows failure: a schema that cannot be compiled keeps Zod's own methods,
+ * which the caller already has, so there is nothing to report and nothing to
+ * break.
+ */
+function materialize(schema) {
+    if (!codegenAllowed())
+        return;
+    try {
+        buildValidator(schema);
+    }
+    catch {
+        // Left as plain Zod. Deliberately silent: `jit()` is an optimization, and a
+        // schema using a construct the compiler declines is a supported outcome,
+        // not an error.
+    }
+}
+/**
+ * Generate the validator and evaluate it, reproducing the module a
+ * `.compiled.ts` would have been: helper preamble, the file-level shared block,
+ * then the `__zcMkv` IIFE whose `__rf[]` bases and install target are the live
+ * schema object passed in as `__schema`.
+ */
+function buildValidator(schema) {
+    const { schemas, shared } = compileSchemas([{ exportName: "jit", schema }], { mode: "inline" });
+    const compiled = schemas[0];
+    if (compiled === undefined)
+        throw new Error("zod-compiler: schema produced no validator");
+    const body = [RUNTIME_PRELUDE, shared.code, `return ${generateIIFE("__schema", compiled)};`].join("\n");
+    // The three bindings ZOD_CONFIG_IMPORT would have imported, passed in so the
+    // evaluated code needs no module resolution of its own.
+    // oxlint-disable-next-line no-new-func -- generating the validator IS the feature
+    const factory = new Function("__zodCompilerConfig", "__zcCore", "__zcZodError", "__schema", body);
+    factory(zodConfig, zodCore, ZodRealError, schema);
+}
+//# sourceMappingURL=jit.js.map

package/dist/jit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit.js","sourceRoot":"","sources":["../src/jit.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-compiler",
-  "version": "1.22.6",
+  "version": "1.23.0",
   "description": "Compile Zod schemas into zero-overhead validation functions",
   "keywords": [
     "aot",
@@ -32,6 +32,12 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./jit": {
+      "types": "./dist/jit.d.ts",
+      "source": "./src/jit.ts",
+      "import": "./dist/jit.js",
+      "default": "./dist/jit.js"
+    },
     "./vite": {
       "types": "./dist/unplugin/vite.d.ts",
       "source": "./src/unplugin/vite.ts",