zod-compiler 2.0.5 → 2.0.7

package/README.md

@@ -2,14 +2,12 @@
 
 **Compile Zod schemas into zero-overhead validation functions at build time.**
 
-Keep your existing Zod schemas. Get **up to 44x faster** validation, and up to **46x** on rejected
+Keep your existing Zod schemas. Get **up to 43x faster** validation, and up to **140x** on rejected
 input. No code changes required.
 
-Requires **Zod ≥ 4.5**. Compiled output reproduces 4.5's semantics exactly, down to code-point string
-lengths, symbol-keyed shapes and tuple issue order, so it does not match earlier 4.x releases. Stay on
-zod-compiler 1.x for Zod 4.0–4.4. An older Zod is refused with an explicit error (the build plugin
-and `jit()` warn once and leave the schemas as plain Zod) rather than compiled into validators that
-disagree with it.
+Requires **Zod ≥ 4.5**; compiled output reproduces 4.5's semantics exactly, so it does not match
+earlier 4.x releases. Use zod-compiler 1.x for Zod 4.0–4.4. An older Zod is refused with an explicit
+error; the build plugin and `jit()` warn once and leave schemas as plain Zod.
 
 - [What Gets Compiled](#what-gets-compiled)
 - [Schema Hoisting](#schema-hoisting)
@@ -28,16 +26,12 @@ loads pre-generated validators.
 |                                        | zod-compiler (build plugins / CLI)           | Zod `z.compile()`                             |
 | -------------------------------------- | -------------------------------------------- | --------------------------------------------- |
 | Compilation                            | Build time (true AOT)                        | Runtime (`z.compile()` or the first parse)    |
-| Reported validation speedup            | Up to 44x; up to 46x on rejected input       | ~9x in Zod's headline example                 |
-| Uses `new Function()` at runtime\*     | No                                           | Yes                                           |
+| Reported validation speedup            | Up to 43x; up to 140x on rejected input      | ~9x in Zod's headline example                 |
+| Uses `new Function()` at runtime       | No                                           | Yes                                           |
 | Cold start                             | Fast; the validator is already generated     | Pays for code generation at startup/first use |
 | Strict CSP without `'unsafe-eval'`     | Supported                                    | Compilation is unavailable                    |
 | Compiler shipped in the runtime bundle | No; only validators and runtime helpers ship | Yes; about 7 KB gzipped according to Zod      |
 
-\*zod-compiler's optional [`jit()`](#4-runtime-compilation-no-build-step) and
-[Node.js register hook](#5-nodejs-register-hook) use `new Function()` and have the same runtime
-code-generation and CSP trade-offs as Zod's `z.compile()`.
-
 ## Usage
 
 Five ways to use zod-compiler. Pick one:
@@ -135,8 +129,7 @@ Compilation is lazy, costing 0.1-0.3 ms on a schema's first parse. `{ eager: tru
 and `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, and
-have libraries ship plain Zod so the app can decide.
+long-lived process, not a CLI, a cold serverless handler or a browser.
 
 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.
@@ -157,11 +150,9 @@ also chains with TypeScript runners:
 node --import zod-compiler/register --import tsx src/server.ts
 ```
 
-This is runtime JIT instrumentation, not the AOT source rewriting the build plugins perform. The hook
-registers the live Zod objects behind exported schema bindings and generates validators in-process on
-first use. It does not execute modules twice, and adds no cache beyond Node's own module cache. Use a
-build plugin or the CLI when validator code must exist before Node starts, or when `new Function` is
-unavailable at runtime.
+This is runtime JIT instrumentation, not AOT source rewriting: the hook generates validators
+in-process on first use. Use a build plugin or the CLI when validator code must exist before Node
+starts, or when `new Function` is unavailable.
 
 Optional settings come from `zod-compiler.json` in the working directory:
 
@@ -282,10 +273,9 @@ bundle. Schemas in a file that share a structurally identical sub-shape emit its
 **19-28% raw / 10-18% gzipped** and scaling with how much the file repeats.
 
 Build plugins serve that module from a resolve hook (`virtual:zod-compiler/runtime`, or
-`__zod-compiler-runtime__` on webpack and rspack, which reject the `virtual:` scheme). A loader host
-has no hook, so [Turbopack](#nextjs-turbopack) imports the same code from the real subpath
-`zod-compiler/runtime` instead. It is opt-in there, since it only pays off where the host bundles that
-import rather than leaving it external.
+`__zod-compiler-runtime__` on webpack and rspack). [Turbopack](#nextjs-turbopack) has no such hook, so
+it imports the real subpath `zod-compiler/runtime` instead, opt-in because it only pays off where the
+host bundles that import.
 
 **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
@@ -376,8 +366,7 @@ The step pays for itself: **Hermes ships no JIT and no `new Function`**, so Zod'
 is unavailable on device and [`jit()`](#4-runtime-compilation-no-build-step) cannot run there at all.
 
 Keep schema modules free of `react-native` and `expo-*` imports, transitively. Discovery executes each
-file and its import graph in Node (in both modes), and one that throws falls back to runtime Zod
-silently.
+file and its import graph in Node, and one that throws falls back to runtime Zod silently.
 
 ### Compact Output (`output: "compact"`)
 
@@ -391,14 +380,13 @@ zodCompiler({ output: "compact" });
 
 ### Workers and Serverless Startup
 
-Workers construct every imported schema at module init, even when an isolate validates only a few.
-Compiling all of them buys validation speed at the cost of bundle size and startup work. Compact output
-trims the generated error path but still retains the Zod schema, and does not make eager construction
-lazy.
+Workers construct every imported schema at module init, even when an isolate validates only a few, so
+compiling all of them trades bundle size and startup work for validation speed. Compact output trims
+the generated error path but does not make construction lazy.
 
-If your app has a clear schema boundary, narrow `include` or use `schemas: "explicit"` to skip
-intermediate exports. Use `output: "bag"` only where consumers need no Zod APIs (`.shape`, `.extend()`,
-`.meta()`, `z.toJSONSchema()`); it can drop the retained schema entirely.
+Narrow `include` or use `schemas: "explicit"` to skip intermediate exports. Use `output: "bag"` where
+consumers need no Zod APIs (`.shape`, `.extend()`, `.meta()`, `z.toJSONSchema()`); it drops the
+retained schema entirely.
 
 Measure startup separately from validation throughput, on the target deployment and bundle.
 
@@ -439,10 +427,9 @@ never mention `zod` cost nothing.
 
 ### Parallel Transforms
 
-Discovery runs one file at a time on the bundler's own thread, serializing executions so concurrent
-transforms cannot double-execute a shared dependency. `parallel` moves whole transforms onto worker
-threads instead, each with its own loader and module cache, which is what makes running them at the
-same time sound.
+Discovery runs one file at a time on the bundler's thread so concurrent transforms cannot
+double-execute a shared dependency. `parallel` moves whole transforms onto worker threads, each with
+its own loader and module cache.
 
 ```typescript
 zodCompiler({ parallel: true }); // one worker per core, less one, capped at 4
@@ -459,18 +446,15 @@ win; files chained through each other can lose. Both rows below are 120 files of
 | independent graphs    |   3,633 ms | 2,263 ms | 1,508 ms | 1,786 ms | 2,119 ms |
 | 120-deep import chain |     945 ms |   977 ms | 1,045 ms | 1,796 ms | 3,332 ms |
 
-So measure before adopting it. `ZOD_COMPILER_TIMING=1` prints the per-phase breakdown, and `discover`
-is the line workers move. Throughput peaks around four workers and declines past it: every extra worker
-re-executes more graph, holds another copy in memory, and adds to the generated source that the single
-receiving thread has to deserialize.
+Measure before adopting it: `ZOD_COMPILER_TIMING=1` prints the per-phase breakdown, and `discover` is
+the line workers move. Throughput peaks around four workers and declines past it, as every extra
+worker re-executes more graph and holds another copy in memory.
 
-Emitted code, sourcemaps and cache entries are identical either way. `parallel` is not part of the
-cache key, so parallel and serial builds share one cache. Disk caching and dependency crawling stay on
-the bundler thread, and a worker that cannot start or dies mid-build has its file retried in-process
-rather than failing the build.
+Emitted code, sourcemaps and cache entries are identical either way, and `parallel` is not part of the
+cache key, so parallel and serial builds share one cache. A worker that cannot start or dies mid-build
+has its file retried in-process.
 
-A **warm cache still beats parallelism** and costs no memory. Reach for `parallel` on the cold runs the
-cache cannot help with.
+A **warm cache still beats parallelism** and costs no memory. Reach for `parallel` on cold runs.
 
 ## Framework Examples
 
@@ -545,7 +529,7 @@ npx zod-compiler check src/schemas.ts --json --fail-under 80
 
 ## What Gets Compiled
 
-### Fully Compiled (up to 44x faster)
+### Fully Compiled (up to 43x faster)
 
 Every Zod type except the fallbacks below: all primitives, `object` / `strictObject` / `looseObject`,
 `array`, `tuple`, `record`, `set`, `map`, `union`, `discriminatedUnion`, `intersection`, `pipe`,
@@ -564,7 +548,7 @@ A schema delegates to Zod when it reaches JavaScript the generated code cannot r
 | ---------------------------------------------------- | -------------------------------------------------------------------------- |
 | `.check(fn)`, `superRefine` + later checks           | The callback holds Zod's payload unmediated, or `fatal` aborts Zod's chain |
 | `ctx`-taking or `async` callbacks                    | Needs Zod's parse context / the async pipeline                             |
-| `z.url()`, `z.jwt()`                                 | Algorithmic formats (`new URL()`, signature parsing)                       |
+| `z.jwt()`                                            | Algorithmic format (signature parsing)                                     |
 | Overlapping or policy-sensitive object intersections | Zod's independent parse-and-merge semantics cannot be safely collapsed     |
 | `.readonly()` over a pass-through container          | Zod freezes the output it rebuilt; these are the caller's own input        |
 | Dynamic error maps, unresolvable `z.lazy()`          | Not knowable at build time                                                 |
@@ -596,61 +580,63 @@ Schema-level `error` and `z.config()` maps are unaffected; for a per-call map us
 
 | Scenario                                        | Zod v3 | Zod v4 | **zod-compiler** | Typia | AJV   | vs Zod v4 |
 | ----------------------------------------------- | ------ | ------ | ---------------- | ----- | ----- | --------- |
-| simple string                                   | 12.6M  | 15.6M  | **16.8M**        | 17.2M | 17.4M | 1.1x      |
-| string (min/max)                                | 12.4M  | 7.4M   | **17.4M**        | 17.6M | 15.5M | 2.4x      |
-| number (int+positive)                           | 11.8M  | 9.4M   | **17.2M**        | 16.3M | 17.4M | 1.8x      |
-| enum                                            | 12.1M  | 14.7M  | **17.4M**        | 17.4M | 17.2M | 1.2x      |
-| bigint (min/max)                                | 11.2M  | 7.9M   | **16.7M**        | —     | —     | 2.1x      |
-| tuple [string, int, bool]                       | 5.6M   | 7.3M   | **17.4M**        | 16.4M | 15.7M | 2.4x      |
-| record\<string, number\>                        | 3.1M   | 2.6M   | **12.7M**        | 12.0M | 15.2M | 5.0x      |
-| set\<string\> (5 items)                         | 3.7M   | 2.3M   | **15.2M**        | —     | —     | 6.6x      |
-| set\<string\> (20 items)                        | 1.3M   | 680K   | **12.1M**        | —     | —     | **18x**   |
-| map\<string, number\> (5 entries)               | 2.0M   | 1.3M   | **13.2M**        | —     | —     | **10x**   |
-| map\<string, number\> (20 entries)              | 637K   | 347K   | **8.5M**         | —     | —     | **24x**   |
-| pipe (non-transform)                            | 8.7M   | 4.7M   | **17.3M**        | —     | —     | 3.6x      |
-| discriminatedUnion (3 variants)                 | 3.3M   | 5.2M   | **17.2M**        | 16.1M | 7.8M  | 3.3x      |
-| discriminatedUnion (8 variants, rotating)       | 2.6M   | 4.4M   | **10.3M**        | —     | —     | 2.3x      |
-| plain union of 8 tagged objects (auto-discrim.) | 356K   | 1.3M   | **10.2M**        | —     | —     | 7.7x      |
-| strict object (DB row)                          | 1.8M   | 3.0M   | **11.3M**        | —     | —     | 3.8x      |
-| medium object (valid)                           | 1.9M   | 2.2M   | **9.4M**         | 11.2M | 7.5M  | 4.2x      |
-| medium object (extra keys stripped)             | 1.8M   | 2.0M   | **9.8M**         | —     | —     | 4.9x      |
-| medium object (invalid)                         | 534K   | 372K   | **15.5M**        | 2.9M  | 7.5M  | **42x**   |
-| large object (10 items)                         | 120K   | 163K   | **5.1M**         | 5.9M  | 1.2M  | **31x**   |
-| large object (100 items)                        | 13K    | 17K    | **766K**         | 1.3M  | 127K  | **44x**   |
-| readonly field (wrapper compiles away)          | 3.0M   | 6.6M   | **16.7M**        | —     | —     | 2.5x      |
-| readonly root object (rebuild + freeze)         | 2.8M   | 5.5M   | **12.9M**        | —     | —     | 2.3x      |
-| readonly array (delegates to Zod)               | 3.9M   | 4.3M   | **4.2M**         | —     | —     | 1.0x      |
-| recursive tree (7 nodes)                        | 581K   | 1.0M   | **7.5M**         | 11.6M | 4.7M  | 7.4x      |
-| recursive tree (121 nodes)                      | 31K    | 57K    | **777K**         | 1.9M  | 371K  | **14x**   |
-| nested recursion (7 nodes)                      | 395K   | 683K   | **7.9M**         | 11.2M | 3.0M  | **12x**   |
-| nested recursion (121 nodes)                    | 24K    | 42K    | **805K**         | 1.6M  | 204K  | **19x**   |
-| deeply nested object (243 leaves)               | 11K    | 27K    | **825K**         | 1.0M  | 125K  | **30x**   |
-| event log (combined)                            | 363K   | 795K   | **7.3M**         | —     | —     | 9.2x      |
-| object with transform (zero-capture)            | 1.1M   | 1.9M   | **6.7M**         | —     | —     | 3.5x      |
-| array 10 × transform (zero-capture)             | 121K   | 206K   | **4.1M**         | —     | —     | **20x**   |
+| simple string                                   | 13.1M  | 15.9M  | **17.3M**        | 18.0M | 17.6M | 1.1x      |
+| string (min/max)                                | 12.3M  | 7.3M   | **17.3M**        | 17.2M | 15.6M | 2.4x      |
+| number (int+positive)                           | 12.4M  | 9.7M   | **17.5M**        | 17.7M | 17.0M | 1.8x      |
+| enum                                            | 11.6M  | 15.5M  | **17.8M**        | 18.1M | 17.5M | 1.1x      |
+| bigint (min/max)                                | 11.9M  | 8.6M   | **17.3M**        | —     | —     | 2.0x      |
+| tuple [string, int, bool]                       | 5.5M   | 7.4M   | **16.7M**        | 16.0M | 15.8M | 2.3x      |
+| record\<string, number\>                        | 3.2M   | 2.5M   | **12.9M**        | 12.0M | 15.2M | 5.1x      |
+| set\<string\> (5 items)                         | 3.6M   | 2.3M   | **15.3M**        | —     | —     | 6.8x      |
+| set\<string\> (20 items)                        | 1.3M   | 679K   | **12.2M**        | —     | —     | **18x**   |
+| map\<string, number\> (5 entries)               | 2.0M   | 1.3M   | **13.5M**        | —     | —     | **10x**   |
+| map\<string, number\> (20 entries)              | 628K   | 346K   | **8.5M**         | —     | —     | **25x**   |
+| pipe (non-transform)                            | 8.8M   | 4.7M   | **16.9M**        | —     | —     | 3.6x      |
+| discriminatedUnion (3 variants)                 | 3.4M   | 5.2M   | **17.1M**        | 16.5M | 7.9M  | 3.3x      |
+| discriminatedUnion (8 variants, rotating)       | 2.6M   | 4.6M   | **10.5M**        | —     | —     | 2.3x      |
+| plain union of 8 tagged objects (auto-discrim.) | 357K   | 1.3M   | **10.5M**        | —     | —     | 7.9x      |
+| strict object (DB row)                          | 1.8M   | 2.9M   | **11.4M**        | —     | —     | 3.8x      |
+| medium object (valid)                           | 1.9M   | 2.3M   | **9.8M**         | 11.1M | 7.6M  | 4.2x      |
+| medium object (extra keys stripped)             | 1.8M   | 2.1M   | **9.7M**         | —     | —     | 4.6x      |
+| medium object (invalid)                         | 517K   | 364K   | **15.9M**        | 2.8M  | 7.5M  | **44x**   |
+| large object (10 items)                         | 120K   | 175K   | **5.3M**         | 6.0M  | 1.2M  | **30x**   |
+| large object (100 items)                        | 13K    | 18K    | **764K**         | 1.3M  | 124K  | **43x**   |
+| readonly field (wrapper compiles away)          | 3.1M   | 6.6M   | **17.8M**        | —     | —     | 2.7x      |
+| readonly root object (rebuild + freeze)         | 2.9M   | 5.6M   | **13.5M**        | —     | —     | 2.4x      |
+| readonly array (delegates to Zod)               | 4.0M   | 4.4M   | **4.4M**         | —     | —     | 1.0x      |
+| recursive tree (7 nodes)                        | 574K   | 997K   | **9.0M**         | 11.9M | 4.8M  | 9.0x      |
+| recursive tree (121 nodes)                      | 32K    | 58K    | **986K**         | 1.9M  | 375K  | **17x**   |
+| nested recursion (7 nodes)                      | 390K   | 696K   | **7.8M**         | 10.5M | 2.9M  | **11x**   |
+| nested recursion (121 nodes)                    | 24K    | 42K    | **816K**         | 1.6M  | 205K  | **20x**   |
+| deeply nested object (243 leaves)               | 11K    | 28K    | **845K**         | 1.0M  | 125K  | **30x**   |
+| event log (combined)                            | 375K   | 808K   | **7.6M**         | —     | —     | 9.4x      |
+| catalog product with image URLs (valid)         | 432K   | 467K   | **2.1M**         | —     | —     | 4.6x      |
+| catalog product with image URLs (invalid)       | 114K   | 106K   | **14.8M**        | —     | —     | **140x**  |
+| catalog page (20 products)                      | 21K    | 23K    | **122K**         | —     | —     | 5.2x      |
+| object with transform (zero-capture)            | 1.1M   | 1.9M   | **7.6M**         | —     | —     | 4.0x      |
+| array 10 × transform (zero-capture)             | 123K   | 209K   | **4.3M**         | —     | —     | **21x**   |
 | array 50 × transform (zero-capture)             | 26K    | 41K    | **1.0M**         | —     | —     | **25x**   |
-| object with captured transform                  | 1.2M   | 7.9M   | **15.9M**        | —     | —     | 2.0x      |
-| object with captured refine (cross-field)       | 1.4M   | 2.2M   | **11.5M**        | —     | —     | 5.2x      |
-| object with superRefine (cross-field)           | 1.4M   | 2.1M   | **9.2M**         | —     | —     | 4.3x      |
-| coerced query object (valid)                    | 1.8M   | 2.9M   | **5.3M**         | —     | —     | 1.9x      |
-| coerced query object (invalid)                  | 1.0M   | 826K   | **10.3M**        | —     | —     | **12x**   |
-| preprocessed query object (valid)               | 433K   | 1.7M   | **5.3M**         | —     | —     | 3.2x      |
-| preprocessed query object (invalid)             | 392K   | 782K   | **12.3M**        | —     | —     | **16x**   |
+| object with captured transform                  | 1.2M   | 8.3M   | **16.2M**        | —     | —     | 2.0x      |
+| object with captured refine (cross-field)       | 1.5M   | 2.2M   | **11.7M**        | —     | —     | 5.3x      |
+| object with superRefine (cross-field)           | 1.5M   | 2.2M   | **9.6M**         | —     | —     | 4.3x      |
+| coerced query object (valid)                    | 1.8M   | 3.0M   | **5.4M**         | —     | —     | 1.8x      |
+| coerced query object (invalid)                  | 1.0M   | 837K   | **10.6M**        | —     | —     | **13x**   |
+| preprocessed query object (valid)               | 432K   | 1.8M   | **5.4M**         | —     | —     | 3.0x      |
+| preprocessed query object (invalid)             | 393K   | 796K   | **12.7M**        | —     | —     | **16x**   |
 | stringbool config object (valid)                | —      | 2.8M   | **6.3M**         | —     | —     | 2.2x      |
-| stringbool config object (invalid)              | —      | 682K   | **13.2M**        | —     | —     | **19x**   |
-| custom/instanceof request (valid)               | 965K   | 3.1M   | **9.9M**         | —     | —     | 3.2x      |
-| custom/instanceof request (invalid)             | 786K   | 928K   | **13.2M**        | —     | —     | **14x**   |
-| disjoint object intersection (valid)            | 1.4M   | 1.6M   | **9.5M**         | —     | —     | 5.9x      |
-| disjoint object intersection (invalid)          | 488K   | 331K   | **15.3M**        | —     | —     | **46x**   |
+| stringbool config object (invalid)              | —      | 698K   | **13.5M**        | —     | —     | **19x**   |
+| custom/instanceof request (valid)               | 979K   | 3.2M   | **10.4M**        | —     | —     | 3.3x      |
+| custom/instanceof request (invalid)             | 795K   | 955K   | **13.6M**        | —     | —     | **14x**   |
+| disjoint object intersection (valid)            | 1.4M   | 1.6M   | **9.7M**         | —     | —     | 6.0x      |
+| disjoint object intersection (invalid)          | 494K   | 335K   | **15.7M**        | —     | —     | **47x**   |
 
 _ops/s, higher is better. `vp test bench` on an Apple M4 Max (zod 4.5.2, zod v3 3.23.8, typia 12, ajv 8),
 best of three runs. The harness costs ~60 ns per iteration, so the fastest rows sit at that floor and gaps
 between the AOT columns there are noise, not real._
 
 Nested objects, arrays and recursive types gain the most. Rejection is fast because a failed
-`safeParse` defers building the error until `.error` is read. Zod 4.5 stopped capturing a stack trace on
-that path too, so its own rejected-input rows are several times faster than 4.3's and the gap there is
-narrower than it was.
+`safeParse` defers building the error until `.error` is read. Zod 4.5 stopped capturing a stack trace
+there too, narrowing the gap on rejected input.
 
 ```bash
 vp run benchmark # run locally
@@ -658,29 +644,22 @@ vp run benchmark # run locally
 
 ### Performance Architecture
 
-An eligible schema compiles to a **fast path**, one `&&` chain validating the whole input with zero
-allocations and reused by `.is()` and `parse()`, plus a **slow path** that collects errors, runs only on
-failure, and is deferred until `.error` is read. A `z.object()` strips, so it instead compiles to a
-single pass that validates and rebuilds together and bails on the first failure, covering the reshaping
-idioms too (array size checks, `.refine()`, `.default()`, `.trim()`, `.transform()`).
-
-Regexes are pre-compiled with bounded repeats unrolled, checks run cheapest-first on both passes (so a
-payload with a wrong boolean is rejected before its email is scanned, whichever was declared first),
-discriminated unions dispatch through a `switch` on the tag (plain tagged unions are auto-discriminated
-into it, on the stripping pass as well as the fast check, and the selected option re-checks neither
-object-ness nor the tag), and oversized check functions are split to stay within V8's optimizer budget.
-`.is()` stays a zero-allocation predicate on schemas with `.default()` fields. `z.email()` runs as a single linear scan instead of a backtracking regex, a record's
-plain-object guard exits on one comparison for an ordinary object, and a case-insensitive `stringbool`
-looks its input up verbatim before paying for `toLowerCase()`. Stripping objects, native coercions,
-`stringbool`, defaults, string rewrites, context-free preprocessors and synchronous transforms validate
-and build their output in one pass. An intersection of two objects with disjoint keys compiles to that
-same single pass over the merged shape, and `z.custom()` / `z.instanceof()` compile to a direct predicate
-call.
-
-Where success is cheaper to compile than failure, only the verdict and output are compiled.
-Intersections and `custom` keep the original Zod schema to construct issues, so a rejection still
-reports exactly what Zod would, an intersection's one-issue-per-side shape included, without slowing the
-hot path.
+A schema compiles to a **fast path** — one zero-allocation `&&` chain, shared by `.is()` and
+`parse()` — plus a **slow path** that collects errors only on failure, deferred until `.error` is read.
+Schemas that reshape their input (stripping objects, coercions, `stringbool`, `z.url()`, defaults,
+transforms, context-free preprocessors, disjoint-key intersections) instead validate and rebuild in a
+single pass that bails on the first failure.
+
+Other optimizations:
+
+- Regexes pre-compiled, bounded repeats unrolled; `z.email()` is a linear scan, not a backtracking regex.
+- Checks run cheapest-first, regardless of declaration order.
+- Discriminated unions dispatch through a `switch`; plain tagged unions are auto-discriminated into one.
+- `z.custom()` / `z.instanceof()` compile to a direct predicate call.
+- Oversized check functions are split to stay within V8's optimizer budget.
+
+Intersections and `custom` keep the original Zod schema to construct issues, so rejections match Zod
+exactly without slowing the hot path.
 
 ## Development
 

package/dist/core/codegen/build-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-path.d.ts","names":[],"sources":["../../../src/core/codegen/build-path.ts"],"mappings":";;;;iBAuMgB,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnB,kBAAkB,IAAI;;;;;;;;;;;iBAmFtB,sBAAsB,IAAI;;;;;;iBAmD1B,cAAc,IAAI,UAAU,KAAK"}
+{"version":3,"file":"build-path.d.ts","names":[],"sources":["../../../src/core/codegen/build-path.ts"],"mappings":";;;;iBAwMgB,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnB,kBAAkB,IAAI;;;;;;;;;;;iBA+EtB,sBAAsB,IAAI;;;;;;iBAmD1B,cAAc,IAAI,UAAU,KAAK"}

package/dist/core/codegen/build-path.js

@@ -1,11 +1,11 @@
-import { declareFastTemps, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRuntimeHelper, emitTemp, escapeString, hasMutation, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput } from "./context.js";
 import { ZC_ASYNC_DECL, ZC_HOP_DECL, ZC_PLAIN_DECL, ZC_PROTO_SCRUB_DECL } from "./issue-decls.js";
+import { declareFastTemps, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRuntimeHelper, emitTemp, escapeString, hasMutation, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput } from "./context.js";
 import { defaultValueExpr, needsPostInnerDefault } from "./schemas/default.js";
 import { detectUnionDiscriminator } from "./schemas/discriminated-union.js";
 import { estimateFastCost, orderByRuntimeCost, predictedInlineSize } from "./fast-size.js";
 import { parsedProperties } from "./schemas/object.js";
 import { innerAppliesDefaultOnUndefined } from "./schemas/optional.js";
-import { fastStringCheck } from "./schemas/string.js";
+import { buildUrlCheck, fastStringCheck, isUrlRewrite } from "./schemas/string.js";
 import { emitStringBoolMap, stringBoolInlineHit, stringBoolUsesInline } from "./schemas/string-bool.js";
 import { createFastGen, generateFast } from "./fast-path.js";
 //#region src/core/codegen/build-path.ts
@@ -40,7 +40,7 @@ function rebuildSet(root, includeProtoScrub = true) {
 		for (const node of nodes) {
 			if (rebuilds.has(node)) continue;
 			const target = node.type === "recursiveRef" ? targets.get(node.refId ?? 0) : void 0;
-			if (node.type === "object" && node.stripUnknownKeys === true || node.type === "readonly" && node.freeze === true || node.type === "default" || node.type === "tuple" && tupleRewritesShortInput(node) || includeProtoScrub && needsProtoScrub(node) || node.type === "stringBool" || node.type === "string" && (node.coerce === true || node.checks.some((c) => c.kind === "overwrite_effect")) || (node.type === "number" || node.type === "boolean" || node.type === "bigint" || node.type === "date") && node.coerce === true || node.type === "effect" || target !== void 0 && rebuilds.has(target) || children(node).some((child) => rebuilds.has(child))) {
+			if (node.type === "object" && node.stripUnknownKeys === true || node.type === "readonly" && node.freeze === true || node.type === "default" || node.type === "tuple" && tupleRewritesShortInput(node) || includeProtoScrub && needsProtoScrub(node) || node.type === "stringBool" || node.type === "string" && (node.coerce === true || node.checks.some((c) => c.kind === "overwrite_effect" || isUrlRewrite(c))) || (node.type === "number" || node.type === "boolean" || node.type === "bigint" || node.type === "date") && node.coerce === true || node.type === "effect" || target !== void 0 && rebuilds.has(target) || children(node).some((child) => rebuilds.has(child))) {
 				rebuilds.add(node);
 				changed = true;
 			}
@@ -95,7 +95,7 @@ function fastResultIsInput(ir) {
 }
 /**
 * True when the subtree mutates for any reason the build pass cannot reproduce —
-* `.catch()`, `z.url()`, `superRefine`. Those rewrite values in ways this pass
+* `.catch()`, `superRefine`. Those rewrite values in ways this pass
 * (which validates, coerces, decodes string booleans, substitutes declared
 * defaults, applies ordered string rewrites and copies) does not model, so the
 * schema keeps the eager walk.
@@ -110,7 +110,7 @@ function mutatesBeyondStrip(ir) {
 */
 function mutatesHere(ir) {
 	switch (ir.type) {
-		case "string": return superRefines(ir.checks) || ir.checks.some((c) => c.kind === "string_format" && c.format === "url");
+		case "string": return superRefines(ir.checks);
 		case "number": return superRefines(ir.checks);
 		case "boolean":
 		case "bigint":
@@ -181,6 +181,9 @@ function generateBuild(ir, ctx) {
 		temps: [],
 		used: 0
 	};
+	const name = emitTemp(ctx, "vb");
+	const recNames = ctx.buildRecNames ??= /* @__PURE__ */ new Map();
+	recNames.set(0, name);
 	const built = build(ir, "input", {
 		ctx,
 		extractable: false,
@@ -188,8 +191,10 @@ function generateBuild(ir, ctx) {
 		rebuilds,
 		scope
 	});
-	if (built === null) return null;
-	const name = emitTemp(ctx, "vb");
+	if (built === null) {
+		recNames.delete(0);
+		return null;
+	}
 	ctx.preamble.push(`function ${name}(input){${declareFastTemps(scope)}${built.code}return ${built.value};}`);
 	return name;
 }
@@ -731,6 +736,10 @@ function buildString(ir, input, g) {
 			break;
 		case "super_refine_effect": return null;
 		default: {
+			if (check.kind === "string_format" && isUrlRewrite(check)) {
+				code += buildUrlCheck(check, value, g.fail, (prefix) => local(g, prefix), g.ctx);
+				break;
+			}
 			const expr = fastStringCheck(check, value, g.ctx);
 			if (expr === null) return null;
 			code += `if(!(${expr}))return ${g.fail};`;