zod-compiler 1.22.5 → 1.23.0

package/README.md

@@ -13,11 +13,11 @@ Keep your existing Zod schemas. Get **2-43x faster** validation. No code changes
 
 ## Usage
 
-There are three ways to use zod-compiler. Choose the one that fits your project.
+Four ways to use zod-compiler — pick one:
 
 ### 1. Automatic Mode (Default)
 
-The plugin automatically detects and compiles all exported Zod schemas at build time. No wrappers, no imports from `zod-compiler` in your source code.
+The plugin detects and compiles every exported Zod schema at build time. No wrappers, no imports from `zod-compiler` in your source.
 
 **vite.config.ts:**
 
@@ -42,11 +42,11 @@ export const CreateUserSchema = z.object({
 });
 ```
 
-Use them as usual. Compiled methods are installed on the original schema object, so `.shape`, `._zod`,
-Standard Schema, `instanceof` and `z.toJSONSchema()` keep working and consumers need no changes.
+Use them as usual. Methods are installed on the original schema object, so `.shape`, `._zod`, Standard
+Schema, `instanceof` and `z.toJSONSchema()` keep working.
 
-Compiled schemas also expose **`.is(input): input is T`** — the compiled check itself, allocating
-nothing. A drop-in replacement for `safeParse(x).success`.
+Compiled schemas also expose **`.is(input): input is T`** — a zero-allocation drop-in for
+`safeParse(x).success`.
 
 ### 2. compile() (Explicit)
 
@@ -69,7 +69,7 @@ validateUser.parse(data);
 validateUser.safeParse(data);
 ```
 
-`compile()` and auto mode coexist — `compile()` schemas are detected first, then every remaining plain Zod export is picked up. To make `compile()` the _only_ path (no automatic detection, no build-time execution of plain schema files), pair it with `schemas: "explicit"` in the plugin options.
+`compile()` and auto mode coexist. Pair with `schemas: "explicit"` to make `compile()` the _only_ path — no automatic detection, no build-time execution of plain schema files.
 
 ### 3. CLI (No Bundler)
 
@@ -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
@@ -148,8 +169,7 @@ export default defineConfig({
 
 ### Bun
 
-zod-compiler is a build-time tool, so on Bun it applies wherever your code passes through a build step.
-Requires **Bun ≥ 1.2.22**.
+Applies wherever your code passes through a build step. Requires **Bun ≥ 1.2.22**.
 
 ```typescript
 import zodCompiler from "zod-compiler/bun";
@@ -157,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
@@ -179,16 +200,14 @@ Only expressions built from imported bindings and literals move; anything touchi
 `new Date()` stays put. Combinator chains on imported schemas qualify via `schemaNamePattern`
 (default `/ZodSchema$/`).
 
-In auto mode hoisted schemas also **compile** — which rescues the schema that never leaves a function
-(a slonik query, a tRPC input), invisible to export scanning. Measured on that pattern: ~16,700 ns →
-~14 ns per call.
+In auto mode hoisted schemas also **compile**, rescuing the schema that never leaves a function (a
+slonik query, a tRPC input) and so is invisible to export scanning: ~16,700 ns → ~14 ns per call.
 
 ### Bundle Size & Cross-File Dedup
 
 Validators share a runtime helper layer imported from one module, so each helper appears once per
-bundle. Schemas in a file sharing a structurally identical sub-shape emit its error walk once, which
-scales with how much a file repeats: **19% raw / 10% gzipped** for two exports reusing one nested
-shape, **28% / 18%** for four exports reusing two.
+bundle. Schemas in a file sharing a structurally identical sub-shape emit its error walk once —
+**19-28% raw / 10-18% gzipped**, scaling with how much the file repeats.
 
 **Transpile-only esbuild builds** (no `--bundle`) never fire the bundler's resolve hooks, so the
 `virtual:` specifier would survive into `dist/` and fail at runtime. Set `codegenMode: "inline"` to emit
@@ -202,8 +221,8 @@ Set `output: "bag"` to also drop the retained Zod schema when you don't need `.s
 
 ### SWC
 
-`zod-compiler/swc` is a programmatic `@swc/core` bridge, not a `.swcrc` WASM plugin — discovery needs
-Node.js, so it wraps `transform()`. Install `@swc/core`, then:
+A programmatic `@swc/core` bridge wrapping `transform()`, not a `.swcrc` plugin. Install
+`@swc/core`, then:
 
 ```typescript
 import { transform } from "zod-compiler/swc";
@@ -220,13 +239,9 @@ Defaults `codegenMode` to `"inline"` (SWC has no virtual-module hook); pass
 
 ### Compact Output (`output: "compact"`)
 
-The error-collecting walk is 64–77% of the generated bytes, and it only reproduces Zod's issues on
-failure — which the retained Zod schema already does. `output: "compact"` (CLI: `--emit compact`)
-compiles the fast path and delegates the cold error path to it.
-
-On 50 distinct schemas, output drops **~73% raw / ~71% gzipped**. The hot path is unchanged, errors are
-Zod's own, and `safeParse(x).success` / `.is(x)` never invoke Zod — only reading `.error` does. Mutation
-schemas keep the compiled path. Mutually exclusive with `output: "bag"`.
+Compiles the fast path and delegates the cold error path to the retained Zod schema, dropping
+**~73% raw / ~71% gzipped** on 50 distinct schemas. The hot path is unchanged and errors are Zod's own;
+only reading `.error` invokes Zod. Mutually exclusive with `output: "bag"`.
 
 ### Auto Mode: Side Effects Warning
 
@@ -245,15 +260,8 @@ if (!process.env.ZOD_COMPILER) {
 
 With `@t3-oss/env-*`, pass `skipValidation: !!process.env.ZOD_COMPILER`.
 
-### schemas: "auto" vs "explicit"
-
-|                              | `"auto"` (default)                                         | `"explicit"` + compile()                    |
-| ---------------------------- | ---------------------------------------------------------- | ------------------------------------------- |
-| Source code changes          | None                                                       | Wrap each schema                            |
-| `zod-compiler` import needed | No                                                         | Yes                                         |
-| What gets compiled           | All exported Zod schemas                                   | Only wrapped schemas                        |
-| Build-time file execution    | Zod-importing files that may export schemas (pre-filtered) | Files with `import ... from "zod-compiler"` |
-| Best for                     | New projects, framework integration                        | Gradual adoption, selective optimization    |
+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
 
@@ -267,14 +275,13 @@ expensive one — later runs hit the persistent cache.
     key: zod-compiler-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }}
 ```
 
-Cache entries self-validate against dependency hashes, so a stale cache can only cause recompiles.
-Scope discovery with `include`; set `ZOD_COMPILER_TIMING=1` to see per-phase wall time. Files that never
-mention `zod` cost nothing.
+Scope discovery with `include`; set `ZOD_COMPILER_TIMING=1` for a per-phase breakdown. Files that
+never mention `zod` cost nothing.
 
 ## Framework Examples
 
-Nothing framework-specific is needed. In auto mode your exported schemas are compiled in place, so
-anything that accepts a Zod schema keeps working and picks up the compiled version:
+Nothing framework-specific is needed — exported schemas are compiled in place, so anything accepting
+a Zod schema picks up the compiled version:
 
 ```typescript
 // tRPC — no .input(compile(...)) needed
@@ -287,14 +294,15 @@ app.post("/users", zValidator("json", UserSchema), (c) => c.json(c.req.valid("js
 useForm({ resolver: zodResolver(SignupSchema) });
 ```
 
-The same applies to any [Standard Schema](https://standardschema.dev) consumer. `~standard.validate`
-is re-installed on top of the compiled path — Zod's own builds it around its internal parse, so
-leaving it alone would have handed these consumers plain Zod. Its `version`/`vendor` are unchanged,
-and an async refinement still resolves through Zod.
+The same applies to any [Standard Schema](https://standardschema.dev) consumer — `~standard.validate`
+routes through the compiled validator.
+
+Compiled methods live on the schema object, so Zod's functional API (`z.safeParse(Schema, x)`) and a
+compiled schema composed into an uncompiled parent stay on plain Zod.
 
 ## Schema Diagnostics
 
-Analyze your schemas before compiling — check coverage, Fast Path eligibility, and get actionable hints:
+Check coverage and Fast Path eligibility before compiling:
 
 ```bash
 npx zod-compiler check src/schemas.ts
@@ -374,16 +382,18 @@ see what compiled.
 ### Behavioral Differences from Zod
 
 Compiled validators match Zod on verdicts, output data and error messages, including issue ordering.
-Two things differ by design, both from the zero-allocation fast path:
+Three things differ by design:
+
+| Behavior                  | Zod                                             | zod-compiler                                            |
+| ------------------------- | ----------------------------------------------- | ------------------------------------------------------- |
+| Record key iteration      | All own keys (`Reflect.ownKeys`)                | Own enumerable **string** keys only                     |
+| Container output identity | A fresh array / set / map / object              | The input container, by reference (array holes survive) |
+| Per-call parse params     | `safeParse(x, { error, reportInput })` honoured | Ignored; global `z.config()` maps still apply           |
 
-| Behavior                  | Zod                                | zod-compiler                                            |
-| ------------------------- | ---------------------------------- | ------------------------------------------------------- |
-| Record key iteration      | All own keys (`Reflect.ownKeys`)   | Own enumerable **string** keys only                     |
-| Container output identity | A fresh array / set / map / object | The input container, by reference (array holes survive) |
+Schema-level `error` and `z.config()` maps are unaffected; for a per-call map use
+`z.safeParse(Schema, x, params)`.
 
-A container whose contents need no rewriting is validated in place and handed back, where Zod always
-rebuilds it. `z.object()` is the exception — it strips unknown keys exactly as Zod does, so its output
-is always a fresh object.
+`z.object()` strips unknown keys exactly as Zod does, so its output is always a fresh object.
 
 ## Benchmark
 
@@ -441,9 +451,8 @@ pnpm benchmark   # run locally
 An eligible schema compiles to a **fast path** — one `&&` chain validating the whole input with zero
 allocations, reused by `.is()` and `parse()` — plus a **slow path** that collects errors, run only on
 failure and deferred until `.error` is read. A `z.object()` strips, so it instead compiles to a single
-pass that validates and rebuilds together, bailing on the first failure. That pass also covers the
-idioms that reshape a value — array size checks, `.refine()`, `.default()`, `.trim()`, `.transform()` —
-so one of them in a schema no longer costs it the whole single-pass parse.
+pass that validates and rebuilds together, bailing on the first failure — including the reshaping
+idioms (array size checks, `.refine()`, `.default()`, `.trim()`, `.transform()`).
 
 Regexes are pre-compiled with bounded repeats unrolled, checks run cheapest-first, discriminated unions
 dispatch through a jump table (plain tagged unions are auto-discriminated into it), and oversized check

package/dist/core/iife.d.ts

@@ -11,8 +11,26 @@ import type { CompiledSchemaInfo } from "./pipeline.js";
  * parse raises (see ZC_SR_DECL).
  */
 export declare const ZOD_CONFIG_IMPORT = "import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from \"zod\";";
-/** File-level __zcMsg declaration (must appear once after ZOD_CONFIG_IMPORT). */
-export declare const ZOD_MSG_DECLARATION = "var __zcMsg=__zodCompilerConfig().localeError;";
+/**
+ * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):
+ * the message an issue gets when nothing was baked into it at build time.
+ *
+ * Resolves zod's tail of `finalizeIssue` — `config.customError` then
+ * `config.localeError` then "Invalid input" — and does it PER CALL, because the
+ * config is mutable: `z.config({ localeError })` in an entry point runs after
+ * the schema modules it imports, so a value snapshotted at module init misses
+ * it. Reading a captured `localeError` alone also dropped `customError`
+ * outright, silently ignoring the global map most i18n setups install.
+ *
+ * The head of zod's chain — the schema's own `error` option — is baked into the
+ * issue at build time and short-circuits this. The one link that cannot be
+ * reproduced is a per-CALL `ctx.error`, which would have to travel through
+ * `safeParse`; that entry point sits at V8's inlining budget, where even an
+ * unused extra parameter measured ~12% on every parse.
+ *
+ * Only ever called while building an error, never on a successful parse.
+ */
+export declare const ZOD_MSG_DECLARATION: string;
 /**
  * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)
  * declares it once per compiled file; lean mode (all unplugin bundlers) declares

package/dist/core/iife.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iife.d.ts","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,2GAC0E,CAAC;AAEzG,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,mDAAmD,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,QAMe,CAAC;AAE5C;yEACyE;AACzE,eAAO,MAAM,QAAQ,sGACgF,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,+DAA+D,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,QAG4B,CAAC;AAE1D,qGAAqG;AACrG,eAAO,MAAM,SAAS,uDAAuD,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,iBAAiB,QAIhB,CAAC;AAUf;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GAC5C,MAAM,CAuBR"}
+{"version":3,"file":"iife.d.ts","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,2GAC0E,CAAC;AAEzG;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,QAKH,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,QAMe,CAAC;AAE5C;yEACyE;AACzE,eAAO,MAAM,QAAQ,sGACgF,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,+DAA+D,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,QAG4B,CAAC;AAE1D,qGAAqG;AACrG,eAAO,MAAM,SAAS,uDAAuD,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,iBAAiB,QAIhB,CAAC;AAUf;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GAC5C,MAAM,CAuBR"}

package/dist/core/iife.js

@@ -10,8 +10,30 @@
  * parse raises (see ZC_SR_DECL).
  */
 export const ZOD_CONFIG_IMPORT = 'import { config as __zodCompilerConfig, core as __zcCore, ZodRealError as __zcZodError } from "zod";';
-/** File-level __zcMsg declaration (must appear once after ZOD_CONFIG_IMPORT). */
-export const ZOD_MSG_DECLARATION = "var __zcMsg=__zodCompilerConfig().localeError;";
+/**
+ * File-level `__zcMsg` declaration (must appear once after ZOD_CONFIG_IMPORT):
+ * the message an issue gets when nothing was baked into it at build time.
+ *
+ * Resolves zod's tail of `finalizeIssue` — `config.customError` then
+ * `config.localeError` then "Invalid input" — and does it PER CALL, because the
+ * config is mutable: `z.config({ localeError })` in an entry point runs after
+ * the schema modules it imports, so a value snapshotted at module init misses
+ * it. Reading a captured `localeError` alone also dropped `customError`
+ * outright, silently ignoring the global map most i18n setups install.
+ *
+ * The head of zod's chain — the schema's own `error` option — is baked into the
+ * issue at build time and short-circuits this. The one link that cannot be
+ * reproduced is a per-CALL `ctx.error`, which would have to travel through
+ * `safeParse`; that entry point sits at V8's inlining budget, where even an
+ * unused extra parameter measured ~12% on every parse.
+ *
+ * Only ever called while building an error, never on a successful parse.
+ */
+export const ZOD_MSG_DECLARATION = 'function __zcUw(m){return typeof m==="string"?m:(m===undefined||m===null?undefined:m.message);}' +
+    "var __zcMsg=function(iss){var c=__zodCompilerConfig(),m;" +
+    "if(c.customError){m=__zcUw(c.customError(iss));if(m!==undefined&&m!==null)return m;}" +
+    "if(c.localeError){m=__zcUw(c.localeError(iss));if(m!==undefined&&m!==null)return m;}" +
+    'return "Invalid input";};';
 /**
  * Shared failure-result for __zcFin / __zcFinD. Inline mode (CLI emitter)
  * declares it once per compiled file; lean mode (all unplugin bundlers) declares

package/dist/core/iife.js.map

@@ -1 +1 @@
-{"version":3,"file":"iife.js","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAC5B,sGAAsG,CAAC;AAEzG,iFAAiF;AACjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,gDAAgD,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,eAAe,GAC1B,+FAA+F;IAC/F,qFAAqF;IACrF,4BAA4B;IAC5B,gDAAgD;IAChD,wIAAwI;IACxI,yCAAyC,CAAC;AAE5C;yEACyE;AACzE,MAAM,CAAC,MAAM,QAAQ,GACnB,mGAAmG,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,4DAA4D,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAC3B,oFAAoF;IACpF,sFAAsF;IACtF,uDAAuD,CAAC;AAE1D,qGAAqG;AACrG,MAAM,CAAC,MAAM,SAAS,GAAG,oDAAoD,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAC5B,6oBAA6oB;IAC7oB,wCAAwC;IACxC,iSAAiS;IACjS,YAAY,CAAC;AAEf,SAAS,mBAAmB,CAAC,WAAmB;IAC9C,MAAM,KAAK,GAAG,wBAAwB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACzD,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,UAAkB,EAClB,MAA0B,EAC1B,OAA6C;IAE7C,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IAC7C,MAAM,MAAM,GAAG,mBAAmB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAC9D,MAAM,SAAS,GAAG,OAAO,EAAE,SAAS,KAAK,KAAK,CAAC;IAC/C,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;IAClD,MAAM,KAAK,GAAG,aAAa,CAAC,UAAU,IAAI,MAAM,CAAC;IACjD,0EAA0E;IAC1E,8EAA8E;IAC9E,4EAA4E;IAC5E,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAEnF,OAAO;QACL,0BAA0B;QAC1B,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC;YACvB,CAAC,CAAC,CAAC,aAAa,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,UAAU,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YACtF,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,aAAa,CAAC,IAAI;aAClB,KAAK,CAAC,IAAI,CAAC;aACX,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,oBAAoB,CAAC;QACtE,aAAa,CAAC,WAAW;QACzB,kBAAkB,MAAM,IAAI,SAAS,IAAI,KAAK,IAAI,KAAK,IAAI;QAC3D,MAAM;KACP,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"iife.js","sourceRoot":"","sources":["../../src/core/iife.ts"],"names":[],"mappings":"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"}

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.5",
+  "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",