zod-compiler 1.27.0 → 2.0.0

package/README.md

@@ -2,9 +2,13 @@
 
 **Compile Zod schemas into zero-overhead validation functions at build time.**
 
-Keep your existing Zod schemas. Get **1.2-43x faster** validation, and up to **190x** on rejected
+Keep your existing Zod schemas. Get **1.1-46x faster** validation, and up to **41x** on rejected
 input. No code changes required.
 
+Requires **Zod ≥ 4.5**. The compiled output reproduces 4.5's semantics exactly — code-point string
+lengths, symbol-keyed shapes, tuple issue order — so it does not match earlier 4.x releases. Stay on
+zod-compiler 1.x if you are on Zod 4.0–4.4.
+
 - [What Gets Compiled](#what-gets-compiled)
 - [Schema Hoisting](#schema-hoisting)
 - [Benchmark](#benchmark)
@@ -188,6 +192,7 @@ has neither — see [React Native / Expo](#react-native--expo).
 | `apply`       | `"build" \| "serve" \| "all"`    | builds + Vitest | **Vite only**: when the plugin runs                                                                         |
 | `codegenMode` | `"lean" \| "inline"`             | auto            | `"inline"` emits helpers per file; needed for transpile-only esbuild — see [SWC](#swc)                      |
 | `cache`       | `boolean \| string`              | `true`          | Persistent transform cache in `node_modules/.cache/zod-compiler`                                            |
+| `parallel`    | `boolean \| number`              | `false`         | Run transforms on worker threads — see [Parallel Transforms](#parallel-transforms)                          |
 
 ```typescript
 zodCompiler({
@@ -412,6 +417,41 @@ expensive one — later runs hit the persistent cache.
 Scope discovery with `include`; set `ZOD_COMPILER_TIMING=1` for a per-phase breakdown. Files that
 never mention `zod` cost nothing.
 
+### Parallel Transforms
+
+Discovery runs one file at a time on the bundler's own thread — executions are serialized 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.
+
+```typescript
+zodCompiler({ parallel: true }); // one worker per core, less one, capped at 4
+zodCompiler({ parallel: 2 }); // or pick the count yourself
+```
+
+**Whether it pays depends on your import graph, not your core count.** A module shared by many
+schema files is executed once in-process and once _per worker_ here. Files with independent graphs
+win; files chained through each other can lose. Both rows below are 120 files of 8 schemas each, on
+12 performance cores — the only difference is whether the files import one another:
+
+| Transform (120 files) | in-process |      n=2 |      n=4 |      n=8 |     n=12 |
+| --------------------- | ---------: | -------: | -------: | -------: | -------: |
+| 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 the
+`discover` line is the one workers move. Throughput peaks around four workers and declines past it:
+beyond that point every extra worker re-executes more graph, holds another copy of it in memory, and
+adds to the generated source that the single receiving thread has to deserialize.
+
+Emitted code, sourcemaps and cache entries are identical either way — `parallel` is not part of the
+cache key, so a parallel build and a serial one share the same cache. The disk cache and dependency
+crawling stay on the bundler thread, and if a worker cannot start or dies mid-build its file is
+retried in-process rather than failing the build.
+
+A **warm cache still beats parallelism**, and costs no memory — reach for `parallel` for the cold
+runs the cache cannot help with.
+
 ## Framework Examples
 
 Nothing framework-specific is needed — exported schemas are compiled in place, so anything accepting
@@ -485,7 +525,7 @@ npx zod-compiler check src/schemas.ts --json --fail-under 80
 
 ## What Gets Compiled
 
-### Fully Compiled (1.2-43x faster)
+### Fully Compiled (1.1-46x faster)
 
 Every Zod type except the fallbacks below — all primitives, `object` / `strictObject` / `looseObject`,
 `array`, `tuple`, `record`, `set`, `map`, `union`, `discriminatedUnion`, `intersection`, `pipe`,
@@ -521,7 +561,7 @@ Three things differ by design:
 
 | Behavior                  | Zod                                             | zod-compiler                                            |
 | ------------------------- | ----------------------------------------------- | ------------------------------------------------------- |
-| Record key iteration      | All own keys (`Reflect.ownKeys`)                | Own enumerable **string** keys only                     |
+| Record key iteration      | Own enumerable keys, symbols included           | 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           |
 
@@ -536,59 +576,61 @@ 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  | 14.3M  | **16.5M**        | 17.8M | 17.6M | 1.2x      |
-| string (min/max)                                | 12.5M  | 7.5M   | **15.9M**        | 17.0M | 15.2M | 2.1x      |
-| number (int+positive)                           | 12.3M  | 7.8M   | **16.6M**        | 16.8M | 17.3M | 2.1x      |
-| enum                                            | 11.7M  | 12.1M  | **16.2M**        | 17.7M | 17.3M | 1.3x      |
-| bigint (min/max)                                | 12.0M  | 7.7M   | **15.9M**        | —     | —     | 2.1x      |
-| tuple [string, int, bool]                       | 5.8M   | 6.5M   | **15.7M**        | 17.1M | 16.3M | 2.4x      |
-| record\<string, number\>                        | 3.2M   | 2.8M   | **15.2M**        | 12.1M | 15.2M | 5.5x      |
-| set\<string\> (5 items)                         | 3.7M   | 2.3M   | **14.7M**        | —     | —     | 6.4x      |
-| set\<string\> (20 items)                        | 1.3M   | 683K   | **12.0M**        | —     | —     | **18x**   |
-| map\<string, number\> (5 entries)               | 2.1M   | 1.4M   | **13.1M**        | —     | —     | 9.6x      |
-| map\<string, number\> (20 entries)              | 635K   | 362K   | **8.3M**         | —     | —     | **23x**   |
-| pipe (non-transform)                            | 8.6M   | 5.6M   | **15.9M**        | —     | —     | 2.8x      |
-| discriminatedUnion (3 variants)                 | 3.3M   | 4.0M   | **15.8M**        | 15.5M | 7.7M  | 4.0x      |
-| discriminatedUnion (8 variants, rotating)       | 2.7M   | 3.4M   | **9.2M**         | —     | —     | 2.7x      |
-| plain union of 8 tagged objects (auto-discrim.) | 363K   | 632K   | **9.1M**         | —     | —     | **14x**   |
-| strict object (DB row)                          | 1.8M   | 3.1M   | **10.9M**        | —     | —     | 3.5x      |
-| medium object (valid)                           | 1.9M   | 2.4M   | **9.7M**         | 11.2M | 7.7M  | 4.1x      |
-| medium object (extra keys stripped)             | 1.8M   | 2.3M   | **9.4M**         | —     | —     | 4.2x      |
-| medium object (invalid)                         | 504K   | 80K    | **14.7M**        | 2.9M  | 7.7M  | **184x**  |
-| large object (10 items)                         | 122K   | 166K   | **5.3M**         | 5.9M  | 1.2M  | **32x**   |
-| large object (100 items)                        | 13K    | 18K    | **781K**         | 1.3M  | 125K  | **43x**   |
-| readonly field (wrapper compiles away)          | 3.1M   | 4.4M   | **15.7M**        | —     | —     | 3.6x      |
-| readonly root object (rebuild + freeze)         | 2.9M   | 3.8M   | **12.2M**        | —     | —     | 3.2x      |
-| readonly array (delegates to Zod)               | 3.9M   | 2.9M   | **2.9M**         | —     | —     | 1.0x      |
-| recursive tree (7 nodes)                        | 569K   | 2.1M   | **8.2M**         | 11.6M | 4.8M  | 3.9x      |
-| recursive tree (121 nodes)                      | 32K    | 135K   | **800K**         | 1.9M  | 372K  | 5.9x      |
-| nested recursion (7 nodes)                      | 391K   | 1.0M   | **7.9M**         | 11.1M | 3.1M  | 7.8x      |
-| nested recursion (121 nodes)                    | 24K    | 62K    | **818K**         | 1.6M  | 218K  | **13x**   |
-| deeply nested object (243 leaves)               | 11K    | 20K    | **828K**         | 1.1M  | 117K  | **42x**   |
-| event log (combined)                            | 368K   | 609K   | **8.2M**         | —     | —     | **13x**   |
-| object with transform (zero-capture)            | 1.2M   | 1.9M   | **6.5M**         | —     | —     | 3.4x      |
-| array 10 × transform (zero-capture)             | 121K   | 214K   | **4.2M**         | —     | —     | **20x**   |
-| array 50 × transform (zero-capture)             | 25K    | 44K    | **1.0M**         | —     | —     | **24x**   |
-| object with captured transform                  | 1.4M   | 6.3M   | **15.1M**        | —     | —     | 2.4x      |
-| object with captured refine (cross-field)       | 1.6M   | 2.4M   | **15.3M**        | —     | —     | 6.3x      |
-| object with superRefine (cross-field)           | 1.6M   | 2.3M   | **11.6M**        | —     | —     | 5.0x      |
-| coerced query object (valid)                    | 1.9M   | 2.3M   | **5.2M**         | —     | —     | 2.2x      |
-| coerced query object (invalid)                  | 1.1M   | 162K   | **10.1M**        | —     | —     | **62x**   |
-| preprocessed query object (valid)               | 426K   | 1.6M   | **5.3M**         | —     | —     | 3.4x      |
-| preprocessed query object (invalid)             | 387K   | 149K   | **12.4M**        | —     | —     | **84x**   |
-| stringbool config object (valid)                | —      | 1.9M   | **6.0M**         | —     | —     | 3.1x      |
-| stringbool config object (invalid)              | —      | 129K   | **13.1M**        | —     | —     | **101x**  |
-| custom/instanceof request (valid)               | 894K   | 3.0M   | **8.6M**         | —     | —     | 2.9x      |
-| custom/instanceof request (invalid)             | 755K   | 158K   | **8.5M**         | —     | —     | **54x**   |
-| disjoint object intersection (valid)            | 1.4M   | 1.7M   | **9.7M**         | —     | —     | 5.7x      |
-| disjoint object intersection (invalid)          | 548K   | 80K    | **15.3M**        | —     | —     | **190x**  |
-
-_ops/s, higher is better. `vp test bench` on an Apple M4 Max (zod 4.3.6, zod v3 3.23.8, typia 12, ajv 8),
-best of three runs. The harness costs ~55 ns per iteration, so the fastest rows sit at that floor and gaps
+| simple string                                   | 8.5M   | 10.4M  | **11.0M**        | 11.1M | 11.2M | 1.1x      |
+| string (min/max)                                | 8.2M   | 4.9M   | **10.8M**        | 11.0M | 10.0M | 2.2x      |
+| number (int+positive)                           | 7.9M   | 6.7M   | **10.7M**        | 11.1M | 11.4M | 1.6x      |
+| enum                                            | 8.0M   | 9.4M   | **11.1M**        | 11.2M | 11.3M | 1.2x      |
+| bigint (min/max)                                | 7.6M   | 5.6M   | **10.9M**        | —     | —     | 2.0x      |
+| tuple [string, int, bool]                       | 3.9M   | 4.8M   | **10.9M**        | 10.6M | 10.1M | 2.3x      |
+| record\<string, number\>                        | 2.2M   | 1.8M   | **8.0M**         | 7.3M  | 9.6M  | 4.6x      |
+| set\<string\> (5 items)                         | 2.5M   | 1.5M   | **9.9M**         | —     | —     | 6.8x      |
+| set\<string\> (20 items)                        | 918K   | 445K   | **7.7M**         | —     | —     | **17x**   |
+| map\<string, number\> (5 entries)               | 1.4M   | 864K   | **8.7M**         | —     | —     | **10x**   |
+| map\<string, number\> (20 entries)              | 448K   | 236K   | **5.5M**         | —     | —     | **24x**   |
+| pipe (non-transform)                            | 5.9M   | 3.2M   | **10.5M**        | —     | —     | 3.3x      |
+| discriminatedUnion (3 variants)                 | 2.3M   | 3.6M   | **10.7M**        | 10.3M | 5.4M  | 3.0x      |
+| discriminatedUnion (8 variants, rotating)       | 1.8M   | 3.1M   | **6.6M**         | —     | —     | 2.1x      |
+| plain union of 8 tagged objects (auto-discrim.) | 244K   | 898K   | **6.1M**         | —     | —     | 6.8x      |
+| strict object (DB row)                          | 1.2M   | 2.0M   | **7.0M**         | —     | —     | 3.6x      |
+| medium object (valid)                           | 1.3M   | 1.5M   | **5.6M**         | 6.9M  | 4.7M  | 3.9x      |
+| medium object (extra keys stripped)             | 1.2M   | 1.3M   | **5.7M**         | —     | —     | 4.3x      |
+| medium object (invalid)                         | 359K   | 263K   | **9.8M**         | 2.0M  | 5.1M  | **37x**   |
+| large object (10 items)                         | 82K    | 110K   | **3.6M**         | 3.8M  | 765K  | **33x**   |
+| large object (100 items)                        | 9K     | 12K    | **531K**         | 759K  | 82K   | **46x**   |
+| readonly field (wrapper compiles away)          | 2.2M   | 4.7M   | **11.0M**        | —     | —     | 2.3x      |
+| readonly root object (rebuild + freeze)         | 2.1M   | 4.0M   | **8.6M**         | —     | —     | 2.1x      |
+| readonly array (delegates to Zod)               | 2.8M   | 3.0M   | **2.9M**         | —     | —     | 1.0x      |
+| recursive tree (7 nodes)                        | 407K   | 727K   | **5.3M**         | 7.4M  | 2.9M  | 7.3x      |
+| recursive tree (121 nodes)                      | 23K    | 42K    | **510K**         | 1.3M  | 232K  | **12x**   |
+| nested recursion (7 nodes)                      | 280K   | 489K   | **4.6M**         | 7.2M  | 1.8M  | 9.3x      |
+| nested recursion (121 nodes)                    | 17K    | 30K    | **461K**         | 1.1M  | 126K  | **15x**   |
+| deeply nested object (243 leaves)               | 8K     | 20K    | **327K**         | 666K  | 83K   | **17x**   |
+| event log (combined)                            | 257K   | 575K   | **4.9M**         | —     | —     | 8.6x      |
+| object with transform (zero-capture)            | 752K   | 1.3M   | **4.4M**         | —     | —     | 3.4x      |
+| array 10 × transform (zero-capture)             | 89K    | 137K   | **2.7M**         | —     | —     | **20x**   |
+| array 50 × transform (zero-capture)             | 18K    | 28K    | **689K**         | —     | —     | **25x**   |
+| object with captured transform                  | 862K   | 5.4M   | **9.6M**         | —     | —     | 1.8x      |
+| object with captured refine (cross-field)       | 995K   | 1.3M   | **7.3M**         | —     | —     | 5.6x      |
+| object with superRefine (cross-field)           | 1.0M   | 1.4M   | **5.9M**         | —     | —     | 4.3x      |
+| coerced query object (valid)                    | 1.2M   | 2.0M   | **3.6M**         | —     | —     | 1.8x      |
+| coerced query object (invalid)                  | 754K   | 603K   | **6.8M**         | —     | —     | **11x**   |
+| preprocessed query object (valid)               | 302K   | 1.1M   | **3.6M**         | —     | —     | 3.2x      |
+| preprocessed query object (invalid)             | 268K   | 574K   | **7.8M**         | —     | —     | **14x**   |
+| stringbool config object (valid)                | —      | 2.0M   | **3.7M**         | —     | —     | 1.9x      |
+| stringbool config object (invalid)              | —      | 497K   | **8.6M**         | —     | —     | **17x**   |
+| custom/instanceof request (valid)               | 689K   | 2.0M   | **5.6M**         | —     | —     | 2.7x      |
+| custom/instanceof request (invalid)             | 527K   | 624K   | **5.7M**         | —     | —     | 9.1x      |
+| disjoint object intersection (valid)            | 946K   | 1.0M   | **5.7M**         | —     | —     | 5.5x      |
+| disjoint object intersection (invalid)          | 343K   | 240K   | **9.8M**         | —     | —     | **41x**   |
+
+_ops/s, higher is better. `vp test bench` on an Apple M1 Max (zod 4.5.2, zod v3 3.23.8, typia 12, ajv 8),
+best of three runs. The harness costs ~90 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.
+`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.
 
 ```bash
 vp run benchmark # run locally

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

@@ -33,6 +33,17 @@ declare function rebuildsOutput(ir: SchemaIR): boolean;
  * size-gated `__fo_` split) to fix a shortcut that only the root takes.
  */
 declare function fastResultIsInput(ir: SchemaIR): boolean;
+/**
+ * Does anything STRICTLY BELOW `ir` hand back a container needing a `__proto__`
+ * scrub?
+ *
+ * The root's by-reference shortcut can filter the value it returns
+ * (`data: __zcPs(input)`), but that only reaches the OUTER container — a nested
+ * one is never touched, because the shortcut does not walk. So a schema with a
+ * scrub-needing descendant keeps the eager slow walk, which scrubs at every
+ * level. Only the root's own scrub is shortcut-compatible.
+ */
+declare function nestedNeedsProtoScrub(ir: SchemaIR): boolean;
 /**
  * Host the whole schema as `function NAME(input){…}` returning the built value
  * or the FAIL sentinel. Returns the function name, or null when the schema is
@@ -40,5 +51,5 @@ declare function fastResultIsInput(ir: SchemaIR): boolean;
  */
 declare function generateBuild(ir: SchemaIR, ctx: CodeGenContext): string | null;
 //#endregion
-export { fastResultIsInput, generateBuild, rebuildsOutput };
+export { fastResultIsInput, generateBuild, nestedNeedsProtoScrub, rebuildsOutput };
 //# sourceMappingURL=build-path.d.ts.map

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":";;;;iBA2JgB,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnB,kBAAkB,IAAI;;;;;;iBA2GtB,cAAc,IAAI,UAAU,KAAK"}
+{"version":3,"file":"build-path.d.ts","names":[],"sources":["../../../src/core/codegen/build-path.ts"],"mappings":";;;;iBA8KgB,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnB,kBAAkB,IAAI;;;;;;;;;;;iBAmFtB,sBAAsB,IAAI;;;;;;iBAmD1B,cAAc,IAAI,UAAU,KAAK"}

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

@@ -1,7 +1,8 @@
-import { declareFastTemps, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRuntimeHelper, emitTemp, escapeString, hasMutation, keyMembershipTest, literalToJs, outputAlwaysDefined, rejectsUndefined } from "./context.js";
-import { ZC_HOP_DECL, ZC_PLAIN_DECL } from "./issue-decls.js";
+import { declareFastTemps, emitEffectCallable, emitEffectFn, emitPooledConstant, emitRuntimeHelper, emitTemp, escapeString, hasMutation, keyMembershipTest, literalToJs, needsProtoScrub, outputAlwaysDefined, rejectsUndefined, tupleRewritesShortInput } from "./context.js";
+import { ZC_HOP_DECL, ZC_PLAIN_DECL, ZC_PROTO_SCRUB_DECL } from "./issue-decls.js";
 import { defaultValueExpr, needsPostInnerDefault } from "./schemas/default.js";
 import { estimateFastCost, predictedInlineSize } from "./fast-size.js";
+import { parsedProperties } from "./schemas/object.js";
 import { innerAppliesDefaultOnUndefined } from "./schemas/optional.js";
 import { fastStringCheck } from "./schemas/string.js";
 import { emitStringBoolMap, stringBoolUsesInline } from "./schemas/string-bool.js";
@@ -20,7 +21,7 @@ import { createFastGen, generateFast } from "./fast-path.js";
 * Resolving the ref against its target closes the cycle, and iterating to a
 * fixpoint settles the mutual dependency between the two.
 */
-function rebuildSet(root) {
+function rebuildSet(root, includeProtoScrub = true) {
 	const targets = /* @__PURE__ */ new Map([[0, root]]);
 	const nodes = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -38,7 +39,7 @@ function rebuildSet(root) {
 		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 === "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")) || (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;
 			}
@@ -81,6 +82,7 @@ function rebuildsOutput(ir) {
 */
 function fastResultIsInput(ir) {
 	if (rebuildsOutput(ir)) return false;
+	if (needsProtoScrub(ir)) return false;
 	const seen = /* @__PURE__ */ new Set();
 	const ordered = (node) => {
 		if (seen.has(node)) return false;
@@ -122,6 +124,25 @@ function mutatesHere(ir) {
 function superRefines(checks) {
 	return checks !== void 0 && checks.some((c) => c.kind === "super_refine_effect");
 }
+/**
+* Does anything STRICTLY BELOW `ir` hand back a container needing a `__proto__`
+* scrub?
+*
+* The root's by-reference shortcut can filter the value it returns
+* (`data: __zcPs(input)`), but that only reaches the OUTER container — a nested
+* one is never touched, because the shortcut does not walk. So a schema with a
+* scrub-needing descendant keeps the eager slow walk, which scrubs at every
+* level. Only the root's own scrub is shortcut-compatible.
+*/
+function nestedNeedsProtoScrub(ir) {
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		if (seen.has(node)) return false;
+		seen.add(node);
+		return children(node).some((child) => needsProtoScrub(child) || walk(child));
+	};
+	return walk(ir);
+}
 function children(ir) {
 	switch (ir.type) {
 		case "object": return ir.catchall ? [...Object.values(ir.properties), ir.catchall] : Object.values(ir.properties);
@@ -153,6 +174,7 @@ function children(ir) {
 function generateBuild(ir, ctx) {
 	const rebuilds = rebuildSet(ir);
 	if (!rebuilds.has(ir) || mutatesBeyondStrip(ir)) return null;
+	if (needsProtoScrub(ir) && !rebuildSet(ir, false).has(ir)) return null;
 	const fail = emitFailSentinel(ctx);
 	const scope = {
 		temps: [],
@@ -214,6 +236,7 @@ function build(ir, input, g) {
 			};
 		}
 	}
+	if (needsProtoScrub(ir) && !children(ir).some((child) => g.rebuilds.has(child))) return passthrough(ir, input, g);
 	const before = g.scope.used;
 	const out = buildInline(ir, input, {
 		...g,
@@ -396,14 +419,25 @@ function hostPassthrough(ir, g) {
 	g.ctx.preamble.push(`function ${name}(${param}){${declareFastTemps(scope)}return ${expr === "true" ? param : `(${expr})?${param}:${g.fail}`};}`);
 	return name;
 }
-/** Validate in place with the Fast Path and hand the input straight back. */
+/**
+* Validate in place with the Fast Path and hand the input straight back —
+* filtered through `__zcPs` for a container zod would have stripped an own
+* `__proto__` from (see ZC_PROTO_SCRUB_DECL). The filter copies only when the
+* key is present, so the ordinary value is still returned by reference.
+*/
 function passthrough(ir, input, g) {
 	const expr = generateFast(ir, createFastGen(input, g.ctx, true, g.scope));
 	if (expr === null) return null;
-	return {
-		code: expr === "true" ? "" : `if(!(${expr}))return ${g.fail};`,
+	const guard = expr === "true" ? "" : `if(!(${expr}))return ${g.fail};`;
+	if (!needsProtoScrub(ir)) return {
+		code: guard,
 		value: input
 	};
+	const slot = local(g, "bs");
+	return {
+		code: `${guard}${slot}=${emitRuntimeHelper(g.ctx, "__zcPs", ZC_PROTO_SCRUB_DECL)}(${input});`,
+		value: slot
+	};
 }
 /**
 * Rebuild from the declared keys. Sound for a stripping object (that IS the
@@ -432,7 +466,9 @@ function buildReadonly(ir, input, g) {
 function buildObject(ir, input, g) {
 	if (ir.catchall !== void 0) return null;
 	if (ir.stripUnknownKeys !== true && ir.strict !== true) return null;
+	if (ir.skipAbsentKeys !== void 0 && ir.skipAbsentKeys.length > 0) return null;
 	if (ir.suppressAbsentKeys !== void 0 && ir.suppressAbsentKeys.length > 0) return null;
+	const nonoptional = new Set(ir.nonoptionalKeys ?? []);
 	const refines = ir.checks ?? [];
 	if (refines.some((check) => check.kind !== "refine_effect")) return null;
 	let code = `if(typeof ${input}!=="object"||${input}===null||Array.isArray(${input}))return ${g.fail};`;
@@ -441,9 +477,10 @@ function buildObject(ir, input, g) {
 		code += `for(${keyVar} in ${input}){if(!(${keyMembershipTest(g.ctx, Object.keys(ir.properties), keyVar)}))return ${g.fail};}`;
 	}
 	const slots = [];
-	for (const [key, propIR] of Object.entries(ir.properties)) {
+	for (const [key, propIR] of parsedProperties(ir)) {
 		const keyStr = escapeString(key);
 		const slot = local(g, "bv");
+		if (nonoptional.has(key)) code += `if(!(${keyStr} in ${input}))return ${g.fail};`;
 		code += `${slot}=${input}[${keyStr}];`;
 		const propBuilt = build(propIR, slot, g);
 		if (propBuilt === null) return null;
@@ -505,6 +542,7 @@ function buildArray(ir, input, g) {
 }
 function buildTuple(ir, input, g) {
 	if (ir.rest !== null) return null;
+	if (ir.optStart !== ir.items.length) return null;
 	if (ir.items.some((item) => !rejectsUndefined(item))) return null;
 	let code = `if(!Array.isArray(${input})||${input}.length!==${ir.items.length})return ${g.fail};`;
 	const values = [];
@@ -703,6 +741,6 @@ function local(g, prefix) {
 	return name;
 }
 //#endregion
-export { fastResultIsInput, generateBuild, rebuildsOutput };
+export { fastResultIsInput, generateBuild, nestedNeedsProtoScrub, rebuildsOutput };
 
 //# sourceMappingURL=build-path.js.map