zod-compiler 2.0.4 → 2.0.6

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 **48x** 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 48x 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`,
@@ -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      |
+| simple string                                   | 12.7M  | 15.1M  | **16.5M**        | 17.1M | 17.7M | 1.1x      |
+| string (min/max)                                | 12.5M  | 7.3M   | **16.7M**        | 17.0M | 15.0M | 2.3x      |
+| number (int+positive)                           | 12.0M  | 9.5M   | **16.8M**        | 17.0M | 18.0M | 1.8x      |
+| enum                                            | 11.6M  | 15.1M  | **16.7M**        | 17.3M | 17.5M | 1.1x      |
+| bigint (min/max)                                | 11.5M  | 8.4M   | **16.6M**        | —     | —     | 2.0x      |
+| tuple [string, int, bool]                       | 5.7M   | 7.6M   | **17.5M**        | 17.3M | 16.2M | 2.3x      |
+| record\<string, number\>                        | 3.2M   | 2.6M   | **12.6M**        | 11.8M | 15.1M | 4.9x      |
+| set\<string\> (5 items)                         | 3.6M   | 2.3M   | **15.7M**        | —     | —     | 7.0x      |
+| set\<string\> (20 items)                        | 1.3M   | 679K   | **12.3M**        | —     | —     | **18x**   |
+| map\<string, number\> (5 entries)               | 2.0M   | 1.3M   | **13.4M**        | —     | —     | **10x**   |
+| map\<string, number\> (20 entries)              | 658K   | 348K   | **8.7M**         | —     | —     | **25x**   |
+| pipe (non-transform)                            | 8.9M   | 4.7M   | **17.6M**        | —     | —     | 3.7x      |
+| discriminatedUnion (3 variants)                 | 3.3M   | 5.2M   | **16.3M**        | 15.5M | 7.6M  | 3.1x      |
+| discriminatedUnion (8 variants, rotating)       | 2.6M   | 4.6M   | **10.1M**        | —     | —     | 2.2x      |
+| plain union of 8 tagged objects (auto-discrim.) | 350K   | 1.3M   | **10.4M**        | —     | —     | 7.8x      |
+| strict object (DB row)                          | 1.8M   | 3.0M   | **11.5M**        | —     | —     | 3.9x      |
+| medium object (valid)                           | 2.0M   | 2.3M   | **9.8M**         | 11.4M | 7.6M  | 4.2x      |
+| medium object (extra keys stripped)             | 1.8M   | 2.1M   | **9.6M**         | —     | —     | 4.6x      |
+| medium object (invalid)                         | 464K   | 370K   | **16.0M**        | 2.9M  | 7.6M  | **43x**   |
+| large object (10 items)                         | 119K   | 169K   | **5.2M**         | 5.9M  | 1.2M  | **31x**   |
+| large object (100 items)                        | 13K    | 18K    | **763K**         | 1.3M  | 127K  | **43x**   |
+| readonly field (wrapper compiles away)          | 3.1M   | 6.6M   | **17.1M**        | —     | —     | 2.6x      |
+| readonly root object (rebuild + freeze)         | 2.8M   | 5.6M   | **13.0M**        | —     | —     | 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**   |
-| 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**   |
-| 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**   |
+| recursive tree (7 nodes)                        | 576K   | 1.0M   | **7.8M**         | 11.9M | 4.8M  | 7.8x      |
+| recursive tree (121 nodes)                      | 32K    | 57K    | **774K**         | 1.9M  | 371K  | **13x**   |
+| nested recursion (7 nodes)                      | 388K   | 677K   | **7.7M**         | 10.4M | 3.0M  | **11x**   |
+| nested recursion (121 nodes)                    | 24K    | 41K    | **804K**         | 1.6M  | 210K  | **20x**   |
+| deeply nested object (243 leaves)               | 11K    | 27K    | **847K**         | 1.0M  | 122K  | **31x**   |
+| event log (combined)                            | 370K   | 786K   | **7.7M**         | —     | —     | 9.8x      |
+| catalog product with image URLs (valid)         | 426K   | 451K   | **1.4M**         | —     | —     | 3.1x      |
+| catalog product with image URLs (invalid)       | 115K   | 104K   | **237K**         | —     | —     | 2.3x      |
+| catalog page (20 products)                      | 21K    | 23K    | **74K**          | —     | —     | 3.2x      |
+| object with transform (zero-capture)            | 1.1M   | 1.9M   | **7.3M**         | —     | —     | 3.9x      |
+| array 10 × transform (zero-capture)             | 120K   | 209K   | **4.3M**         | —     | —     | **21x**   |
+| array 50 × transform (zero-capture)             | 25K    | 43K    | **1.0M**         | —     | —     | **24x**   |
+| object with captured transform                  | 1.2M   | 7.8M   | **15.3M**        | —     | —     | 2.0x      |
+| object with captured refine (cross-field)       | 1.5M   | 2.2M   | **11.2M**        | —     | —     | 5.1x      |
+| object with superRefine (cross-field)           | 1.4M   | 2.1M   | **9.1M**         | —     | —     | 4.3x      |
+| coerced query object (valid)                    | 1.8M   | 2.9M   | **5.4M**         | —     | —     | 1.8x      |
+| coerced query object (invalid)                  | 1.0M   | 843K   | **10.2M**        | —     | —     | **12x**   |
+| preprocessed query object (valid)               | 430K   | 1.7M   | **5.3M**         | —     | —     | 3.1x      |
+| preprocessed query object (invalid)             | 382K   | 780K   | **12.3M**        | —     | —     | **16x**   |
+| stringbool config object (valid)                | —      | 2.8M   | **6.4M**         | —     | —     | 2.2x      |
+| stringbool config object (invalid)              | —      | 688K   | **12.6M**        | —     | —     | **18x**   |
+| custom/instanceof request (valid)               | 972K   | 3.1M   | **10.3M**        | —     | —     | 3.3x      |
+| custom/instanceof request (invalid)             | 776K   | 945K   | **13.5M**        | —     | —     | **14x**   |
+| disjoint object intersection (valid)            | 1.4M   | 1.6M   | **10.0M**        | —     | —     | 6.1x      |
+| disjoint object intersection (invalid)          | 482K   | 333K   | **16.0M**        | —     | —     | **48x**   |
 
 _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`, 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.js

@@ -1,5 +1,5 @@
-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";

package/dist/core/codegen/context.d.ts

@@ -501,14 +501,52 @@ declare function emitRuntimeHelper(ctx: CodeGenContext, name: string, decl: stri
  * `[]` root, so any path that looks like an array literal IS one — the new
  * segment is spliced in to keep issue paths a single array allocation
  * (`["data","items",__i_7]`) instead of an allocation per nesting level
- * (`["data"].concat("items").concat(__i_7)`). Opaque expressions fall back
- * to .concat().
+ * (`["data"].concat("items").concat(__i_7)`). An opaque path — a shared walk's
+ * `path` parameter, or an extension of it — appends through `__zcPa` (see
+ * ZC_PATH_APPEND_DECL), not `.concat()`.
  */
-declare function extendPath(parentPath: string, segExpr: string): string;
+declare function extendPath(ctx: CodeGenContext, parentPath: string, segExpr: string): string;
 /** Extend a path expression with a static string key. */
-declare function extendStaticPath(parentPath: string, key: string): string;
+declare function extendStaticPath(ctx: CodeGenContext, parentPath: string, key: string): string;
 /** Extend a path expression with a numeric index. */
-declare function extendStaticPathIndex(parentPath: string, index: number): string;
+declare function extendStaticPathIndex(ctx: CodeGenContext, parentPath: string, index: number): string;
+/**
+ * Slow-walk one member of a container — an array element, a tuple slot, a
+ * record value — without writing to the container while it is still the
+ * caller's.
+ *
+ * Visiting the container's own slot (`input[i]`) as both input and output let
+ * every node that writes its output back write into the CALLER's container: a
+ * pass-through loose object, a record or a tuple assigns its result
+ * unconditionally, so a frozen input (`Object.freeze`, Immer or Redux state)
+ * made `safeParse` throw "Cannot assign to read only property" on valid and
+ * invalid input alike, and an ordinary input had a replacement — a
+ * `__proto__`-scrubbed copy, a recursive member rebuilt by its own validator —
+ * swapped into it in place.
+ *
+ * So a member that rewrites nothing is read into a local and handed a local of
+ * its own to write to. A replacement lands on `container`, the binding the walk
+ * hands back as its output: it starts as the caller's `original` and becomes
+ * `copy` the first time a member's output is not the value read, so a container
+ * nothing replaces still comes back by reference (slowObject's pass-through
+ * `handoff` does the same for properties). A member whose code never names its
+ * output wrote nothing back, and gets no handoff at all.
+ *
+ * A REWRITING member keeps the slot for both, as before: its later checks read
+ * the rewritten value back through the expression it wrote — `.trim().min(1)`
+ * measures the trimmed string, a coercion checks the converted value — which
+ * two locals would split, checking the original instead. Writing the slot is
+ * safe only because every caller copies its container up front for a member
+ * {@link hasMutation} reports, so by then the container is the walk's own.
+ */
+declare function visitMember(g: SlowGen, ir: SchemaIR, member: {
+  readonly container: string;
+  readonly original: string;
+  readonly copy: string;
+  readonly key: string;
+  readonly path: string;
+  readonly issues: string;
+}): string;
 /**
  * Check if a SchemaIR tree produces output that is not the input itself —
  * either value-mutating operations (coerce, default, catch, overwrite) that
@@ -579,5 +617,5 @@ declare function rejectsUndefined(ir: SchemaIR): boolean;
  */
 declare function checkPriority(a: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR, b: CheckIR | BigIntCheckIR | DateCheckIR | SetCheckIR): number;
 //#endregion
-export { CodeGenContext, CodeGenResult, CodegenMode, ConstantKind, ENUM_INLINE_THRESHOLD, FastGen, FastGenerator, FastScope, GeneratedConstant, KEY_MEMBERSHIP_INLINE_THRESHOLD, RETAINED_SCHEMA_VAR, RecTargetGen, SlowGen, SlowGenerator, SourceFormLiteral, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRegex, emitRegexSourceString, emitRetainedMethod, emitRfDelegate, emitRfZod, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, hasSourceForm, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput };
+export { CodeGenContext, CodeGenResult, CodegenMode, ConstantKind, ENUM_INLINE_THRESHOLD, FastGen, FastGenerator, FastScope, GeneratedConstant, KEY_MEMBERSHIP_INLINE_THRESHOLD, RETAINED_SCHEMA_VAR, RecTargetGen, SlowGen, SlowGenerator, SourceFormLiteral, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRegex, emitRegexSourceString, emitRetainedMethod, emitRfDelegate, emitRfZod, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, hasSourceForm, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput, visitMember };
 //# sourceMappingURL=context.d.ts.map

package/dist/core/codegen/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../../src/core/codegen/context.ts"],"mappings":";;;;KAgBY;;;;;KAMA;;;;;;;;;;;;;;;;UAiBK;WACN,MAAM;WACN;WACA;;UAGM;EACf;EACA;;EAEA;;;;;;EAMA,aAAa;;;;;;;EAOb;;;;;;;;;;EAUA;;;;;;;EAOA;;;;;;;EAOA;;;UAIe;;EAEf;;;;;EAKA;;;;;;EAMA;;EAEA,QAAQ;;;UAIO;EACf;EACA;EACA;;EAEA,YAAY;;EAEZ,MAAM;;EAEN,aAAa;;;;;;;;EAQb;;EAEA;;;;;;;;;EASA,aAAa,YAAY;;EAEzB,gBAAgB;;EAEhB,aAAa;;EAEb,eAAe,UAAU;;EAEzB,sBAAsB;;EAEtB;;EAEA,gBAAgB;;EAEhB,gBAAgB,QAAQ;;EAExB,uBAAuB,QAAQ;;;;;;EAM/B,gBAAgB;;;UAMD;WACN;WACA;WACA;WACA;WACA,KAAK;;;;;;;WAOL;;;;;;;;;;;;;;;;WAiBA;;;;;;;;;EAUT,MACE,IAAI,UACJ;IACE;IACA;IACA;IACA;IAGA;;;EAKJ,KAAK;;EAGL,MAAM,gBAAgB,iBAAiB;;EAGvC,IAAI,gBAAgB;;;KAIV,cAAc,UAAU,WAAW,aAAa,IAAI,GAAG,GAAG;;;;;;UASrD;EACf;;;;;;;;;;;EAWA;;;iBAIc,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;;;iBAuBxB,oBACd,GAAG,SACH,SAAS,UACT,kBACA;;UAkBe;WACN;WACA,KAAK;;;;;;;WAQL;;WAGA,OAAO;;;;;;;WAQP;;;;;;;;;;;WAYA;;;;;EAMT,MAAM,IAAI,UAAU;IAAc;IAAgB;;;;;;;;;EASlD,OAAO,gBAAgB;;EAGvB,KAAK;;;;;;;EAQL,MAAM;;EAGN,MAAM,gBAAgB,iBAAiB;;;KAI7B,cAAc,UAAU,WAAW,aAAa,IAAI,GAAG,GAAG;;iBAKtD,SAAS,KAAK,gBAAgB;;;;;;;;;;;;;iBAgB9B,aAAa,KAAK,gBAAgB;;;;;;;;;;;iBAoBlC,mBACd,KAAK,gBACL;EAAU;EAA+B;;;;;;;;;;;;;;;;;;;iBA0B3B,eAAe,KAAK,gBAAgB;;;;;;;;;iBAiBpC,UAAU,KAAK,gBAAgB;;;;;;;;;;;;;cAqBlC;;;;;;;;iBASG,mBAAmB,KAAK;;;;;;;;;;;;;iBA0CxB,UACd,KAAK,gBACL,gBACA,iBACA;;;;;;;;iBAiCc,sBAAsB,KAAK,gBAAgB;;;;;;;;;;;;iBA4B3C,aAAa,KAAK,gBAAgB,gBAAgB;;;;;;;;;;;iBAoBlD,mBACd,KAAK,gBACL,MAAM,cACN,qBACA;;iBAUc,QAAQ,KAAK,gBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;cAwBhD;;;;;;;;;;iBAWG,kBACd,KAAK,gBACL,yBACA;;;;;;;;cAgBW;iBA8BG,aAAa;;KAKjB;;;;;;;;;;;;;;;iBAgBI,cAAc,GAAG,eAAe,KAAK;;;;;;;;;;iBAerC,YAAY,GAAG;;;;;;iBA+Bf,kBAAkB,KAAK,gBAAgB,cAAc;;;;;;;;;;;;iBAqBrD,WAAW,oBAAoB;;iBAS/B,iBAAiB,oBAAoB;;iBAKrC,sBAAsB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0C1C,wBAAwB,IAAI;EAAa;;;;;;;;;;;iBAmBzC,gBAAgB,IAAI;iBAepB,YAAY,IAAI;;;;;;;;;;;;;;iBAuFhB,oBAAoB,IAAI;;;;;;;;;;iBAaxB,iBAAiB,IAAI;;;;;iBAiDrB,cACd,GAAG,UAAU,gBAAgB,cAAc,YAC3C,GAAG,UAAU,gBAAgB,cAAc"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../../src/core/codegen/context.ts"],"mappings":"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"}

package/dist/core/codegen/context.js

@@ -1,3 +1,4 @@
+import { ZC_PATH_APPEND_DECL } from "./issue-decls.js";
 import { fastTestSource, lookupWellKnownRegex, wellKnownRegexSourceName } from "./well-known-regex.js";
 //#region src/core/codegen/context.ts
 /** `var a,b;` declaration for a scope's temps, or "" when it allocated none. */
@@ -392,21 +393,72 @@ function emitRuntimeHelper(ctx, name, decl) {
 * `[]` root, so any path that looks like an array literal IS one — the new
 * segment is spliced in to keep issue paths a single array allocation
 * (`["data","items",__i_7]`) instead of an allocation per nesting level
-* (`["data"].concat("items").concat(__i_7)`). Opaque expressions fall back
-* to .concat().
+* (`["data"].concat("items").concat(__i_7)`). An opaque path — a shared walk's
+* `path` parameter, or an extension of it — appends through `__zcPa` (see
+* ZC_PATH_APPEND_DECL), not `.concat()`.
 */
-function extendPath(parentPath, segExpr) {
+function extendPath(ctx, parentPath, segExpr) {
 	if (parentPath === "[]") return `[${segExpr}]`;
 	if (parentPath.startsWith("[") && parentPath.endsWith("]")) return `${parentPath.slice(0, -1)},${segExpr}]`;
-	return `${parentPath}.concat(${segExpr})`;
+	return `${emitRuntimeHelper(ctx, "__zcPa", ZC_PATH_APPEND_DECL)}(${parentPath},${segExpr})`;
 }
 /** Extend a path expression with a static string key. */
-function extendStaticPath(parentPath, key) {
-	return extendPath(parentPath, escapeString(key));
+function extendStaticPath(ctx, parentPath, key) {
+	return extendPath(ctx, parentPath, escapeString(key));
 }
 /** Extend a path expression with a numeric index. */
-function extendStaticPathIndex(parentPath, index) {
-	return extendPath(parentPath, String(index));
+function extendStaticPathIndex(ctx, parentPath, index) {
+	return extendPath(ctx, parentPath, String(index));
+}
+/**
+* Slow-walk one member of a container — an array element, a tuple slot, a
+* record value — without writing to the container while it is still the
+* caller's.
+*
+* Visiting the container's own slot (`input[i]`) as both input and output let
+* every node that writes its output back write into the CALLER's container: a
+* pass-through loose object, a record or a tuple assigns its result
+* unconditionally, so a frozen input (`Object.freeze`, Immer or Redux state)
+* made `safeParse` throw "Cannot assign to read only property" on valid and
+* invalid input alike, and an ordinary input had a replacement — a
+* `__proto__`-scrubbed copy, a recursive member rebuilt by its own validator —
+* swapped into it in place.
+*
+* So a member that rewrites nothing is read into a local and handed a local of
+* its own to write to. A replacement lands on `container`, the binding the walk
+* hands back as its output: it starts as the caller's `original` and becomes
+* `copy` the first time a member's output is not the value read, so a container
+* nothing replaces still comes back by reference (slowObject's pass-through
+* `handoff` does the same for properties). A member whose code never names its
+* output wrote nothing back, and gets no handoff at all.
+*
+* A REWRITING member keeps the slot for both, as before: its later checks read
+* the rewritten value back through the expression it wrote — `.trim().min(1)`
+* measures the trimmed string, a coercion checks the converted value — which
+* two locals would split, checking the original instead. Writing the slot is
+* safe only because every caller copies its container up front for a member
+* {@link hasMutation} reports, so by then the container is the walk's own.
+*/
+function visitMember(g, ir, member) {
+	const { container, path, issues } = member;
+	const slot = `${container}[${member.key}]`;
+	if (hasMutation(ir)) return g.visit(ir, {
+		input: slot,
+		output: slot,
+		path,
+		issues
+	});
+	const value = g.temp("mv");
+	const out = g.temp("mo");
+	const code = g.visit(ir, {
+		input: value,
+		output: out,
+		path,
+		issues
+	});
+	const read = `var ${value}=${slot};`;
+	if (!code.includes(out)) return read + code;
+	return `${read}var ${out}=${value};${code}if(${out}!==${value}){if(${container}===${member.original}){${container}=${member.copy};}${slot}=${out};}`;
 }
 /**
 * A superRefine callback receives zod's payload, whose `value` is public,
@@ -564,6 +616,6 @@ function checkPriority(a, b) {
 	return (CHECK_PRIORITY[a.kind] ?? 99) - (CHECK_PRIORITY[b.kind] ?? 99);
 }
 //#endregion
-export { ENUM_INLINE_THRESHOLD, KEY_MEMBERSHIP_INLINE_THRESHOLD, RETAINED_SCHEMA_VAR, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRegex, emitRegexSourceString, emitRetainedMethod, emitRfDelegate, emitRfZod, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, hasSourceForm, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput };
+export { ENUM_INLINE_THRESHOLD, KEY_MEMBERSHIP_INLINE_THRESHOLD, RETAINED_SCHEMA_VAR, checkPriority, declareFastTemps, emitConstant, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRegex, emitRegexSourceString, emitRetainedMethod, emitRfDelegate, emitRfZod, emitRuntimeHelper, emitSet, emitTemp, escapeString, extendPath, extendStaticPath, extendStaticPathIndex, fastSentinelWrapper, hasMutation, hasSourceForm, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput, visitMember };
 
 //# sourceMappingURL=context.js.map