ata-validator 1.35.0 → 1.36.1

package/README.md

@@ -101,16 +101,15 @@ file.
 | Bundle (gzipped) | simple | 1.3 KB | 58.1 KB | 43.9x smaller |
 | Bundle (gzipped) | complex | 7.8 KB | 58.1 KB | 7.4x smaller |
 | Bundle (gzipped) | nested | 4.5 KB | 58.1 KB | 12.9x smaller |
-| Cold start | simple | 22 ms | 44 ms | 2.0x faster |
-| Throughput (1M ops) | simple | 266 Mops/s | 109 Mops/s | 2.4x faster |
-| Compile time | simple | 19 µs | 1.67 ms | 87x faster |
+| Cold start | simple | 22 ms | 40 ms | 1.8x faster |
+| Throughput (1M ops) | simple | 269 Mops/s | 116 Mops/s | 2.3x faster |
+| Compile time | simple | 19 µs | 1.63 ms | 85x faster |
 
 The runtime column is the default validator most frameworks ship. Reproduce on your machine
 with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-09-28,
-on ata-validator 1.33.1. The runtime column's bundle measured 52.7 KB on the previous run and
-58.1 KB now, with ata's modules unchanged in size. Across three runs throughput moved
-between 231 and 280 Mops/s against 97 to 109, cold start between 21 and 22 ms against 40 to 44,
-and the compile ratio between 80x and 87x. The throughput row times a single one-million-call
+on ata-validator 1.36.0. Across four runs throughput moved between 213 and 269 Mops/s against
+94 to 116, cold start between 21 and 22 ms against 40 to 42, and the compile ratio between 79x
+and 90x. The throughput row times a single one-million-call
 loop of a few milliseconds, so it moves the most from run to run; treat the last three rows as
 an order of magnitude rather than a constant.
 
@@ -240,21 +239,21 @@ is the most common way to get a misleading number out of this library.
 
 | | compiled with `ata build` | runtime `new Validator(schema)` |
 |---|---|---|
-| In a bundle, gzipped | **2.2 KB** | 93.2 KB |
-| Time to a served request | **3.5 ms** | 7.7 ms |
+| In a bundle, gzipped | **2.2 KB** | 95.6 KB |
+| Time to a served request | **3.5 ms** | 7.8 ms |
 | Schema known when | build time | any time |
 
 The bundle row is the ten-field user schema in
 `tests/fixtures/error-dx/user.schema.json`, every export of the compiled module against
-`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.35.0.
-The startup row is a Hono route on Bun 1.4, best of seven, median of three rounds, from
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.36.0.
+The startup row is a Hono route on Bun 1.4, median of nine interleaved runs, from
 `benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
 compiled path costs nothing measurable to start. The runtime figure is what it is because
 a schema that arrives at run time can use any keyword, so the whole engine has to be
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 93 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 96 KB of JavaScript on a Node or Bun
 process is not a cost anyone notices, and the runtime API is the simpler thing to reach
 for. Speed is the same either way once warm.
 
@@ -486,7 +485,7 @@ const v = new Validator(schema, {
 
 ### Build-time compile (`ata compile`)
 
-The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.2 KB gzipped, full error detail included, against 93.2 KB for the runtime bundled for the browser.
+The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.2 KB gzipped, full error detail included, against 95.6 KB for the runtime bundled for the browser.
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -528,11 +527,11 @@ npx ata build 'schemas/*.json' --out-dir build/validators --check
 Run with `--watch` during development for incremental rebuilds.
 
 Bundle sizes for the 10-field user schema in `tests/fixtures/error-dx/user.schema.json`,
-minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.35.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.36.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 93.2 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 95.6 KB | The compiler ships with it, because a runtime schema can use any keyword |
 | `isValid` from the compiled module | **1.3 KB** | Nothing else is reachable, so the error collector is dropped |
 | `validate` from the compiled module | **2.0 KB** | Adds the detailed error collector |
 
@@ -541,6 +540,16 @@ bundling it makes no difference: importing only `isValid` already leaves the err
 collector unreachable, and a bundler drops it. Use the flag to cut the file on disk,
 not to cut what ships.
 
+To get the compiled module without changing code written against the runtime API, use
+`compileAway` in [`@ata-project/unplugin`](https://github.com/ata-core/unplugin-ata): a
+`new Validator(schema)` whose schema is known at build time is replaced with the compiled
+module wrapped by `fromCompiled()` from `ata-validator/compiled`, which answers `validate()`,
+`isValidObject()`, `validateJSON()` and `isValidJSON()` as the runtime does, defaults and errors
+included. For the plugin's three-schema test entry a minified Vite build goes from 115.7 KB to
+15.5 KB gzipped. In Node, loading the wrapper and a compiled module and answering the first two
+checks takes 1.12 ms where the runtime takes 6.63 ms (median of 15 fresh processes). Across
+SchemaStore's 977 schemas, 725 can be compiled away; the rest stay on the runtime.
+
 Programmatic API if you prefer to script it:
 
 ```javascript
@@ -557,7 +566,7 @@ through a `setFormats()` export the module carries. `docs/API.md` has the
 details.
 
 **Fastify startup, 10 route schemas, from a cold process to the first validated request:
-ajv 20.2 ms, ata 2.7 ms, no build step required.** ata registers in 0.2 ms of that and
+ajv 19.9 ms, ata 2.9 ms, no build step required.** ata registers in 0.5 ms of that and
 compiles on the first request, so counting only registration would overstate the gap.
 Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 

package/build.d.ts

@@ -155,3 +155,26 @@ export function schemaHash(schema: unknown): string;
  * schema, plus `parse` when {@link ToStandaloneModuleOptions.parse} is set
  * and `validateJSON` when {@link ToStandaloneModuleOptions.positions} is. */
 export function toStandaloneModule(schema: unknown, options?: ToStandaloneModuleOptions): string | null;
+
+/**
+ * Whether `new Validator(schema)` with default options can be replaced by
+ * `fromCompiled()` from `ata-validator/compiled`. False for a schema with
+ * custom `errorMessage`s. A caller also needs {@link compiledModuleFor} to
+ * return a module.
+ */
+export function compiledEligible(schema: unknown): boolean;
+
+/**
+ * The schema a default `Validator` reads after normalization. Pass it to
+ * `fromCompiled()`, so defaults, error order and diagnostics follow the same
+ * document the runtime does.
+ */
+export function compiledSchemaFor(schema: unknown): object;
+
+/**
+ * The module that replaces `new Validator(schema)`, or null where the
+ * replacement would not answer as the runtime does: a schema
+ * {@link compiledEligible} declines, one the emitter cannot compile, and one
+ * whose detailed errors the generator cannot produce.
+ */
+export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs' }): string | null;

package/build.mjs

@@ -8,4 +8,8 @@ export const watch = mod.watch;
 export const bundleStandalone = mod.bundleStandalone;
 export const bundleCompact = mod.bundleCompact;
 export const toStandaloneModule = mod.toStandaloneModule;
+export const schemaHash = mod.schemaHash;
+export const compiledEligible = mod.compiledEligible;
+export const compiledSchemaFor = mod.compiledSchemaFor;
+export const compiledModuleFor = mod.compiledModuleFor;
 export default mod;

package/index.d.ts

@@ -407,6 +407,12 @@ export interface ValidatorOptions {
    * `'log'` warns through `logger` (or the console) and continues.
    */
   strictSchema?: boolean | 'log';
+  /**
+   * The URI the schema was retrieved from. Relative references resolve against
+   * it when the schema declares no `$id` of its own, including a draft-07 root
+   * whose `$id` sits beside a `$ref` and is therefore ignored.
+   */
+  baseURI?: string;
   /** Receives `strictSchema: 'log'` warnings; `false` silences them. */
   logger?: { warn(...args: unknown[]): void } | false;
   /**

package/index.js

@@ -568,11 +568,117 @@ function emitRemovals(node, access, lines, depth, seen) {
   else lines.push(`if(${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
 }
 
+// The coercions the closure pass applies, emitted. Values: `number` and
+// `integer` from numeric strings and booleans, `string` from numbers and
+// booleans, `boolean` from "true"/"1" and "false"/"0".
+const COERCIBLE_TYPES = new Set(['number', 'integer', 'string', 'boolean']);
+function scalarCoercion(a, t) {
+  if (t === 'integer') return [`if(typeof ${a}==='string'){var _n=Number(${a});if(${a}!==''&&Number.isInteger(_n))${a}=_n}`, `if(typeof ${a}==='boolean')${a}=${a}?1:0`];
+  if (t === 'number') return [`if(typeof ${a}==='string'){var _n=Number(${a});if(${a}!==''&&!isNaN(_n))${a}=_n}`, `if(typeof ${a}==='boolean')${a}=${a}?1:0`];
+  if (t === 'string') return [`if(typeof ${a}==='number'||typeof ${a}==='boolean')${a}=String(${a})`];
+  return [`if(${a}==='true'||${a}==='1')${a}=true`, `if(${a}==='false'||${a}==='0')${a}=false`];
+}
+function isScalarCoercible(node) {
+  return !!(node && typeof node === 'object' && typeof node.type === 'string' && COERCIBLE_TYPES.has(node.type));
+}
+// Whether anything below `node` is coerced, as buildNodeCoercer decides it.
+// Remembered per node for the build, since every enclosing node asks again.
+function coercesInside(node, seen, memo) {
+  if (!node || typeof node !== 'object' || seen.has(node)) return false;
+  if (memo && memo.has(node)) return memo.get(node);
+  seen.add(node);
+  let found = false;
+  if (node.properties) {
+    for (const [key, prop] of Object.entries(node.properties)) {
+      if (key === '__proto__' || !prop || typeof prop !== 'object') continue;
+      if (isScalarCoercible(prop) || coercesInside(prop, seen, memo)) { found = true; break; }
+    }
+  }
+  if (!found && node.items && typeof node.items === 'object' && !Array.isArray(node.items)) {
+    found = isScalarCoercible(node.items) || coercesInside(node.items, seen, memo);
+  }
+  seen.delete(node);
+  if (memo) memo.set(node, found);
+  return found;
+}
+function emitCoercions(node, ov, lines, st, depth) {
+  if (st.seen.has(node)) { st.cycle = true; return; }
+  st.seen.add(node);
+  if (node.properties) {
+    for (const [key, prop] of Object.entries(node.properties)) {
+      // Coercion writes with plain assignment, which for a key named
+      // __proto__ rewrites the prototype instead. The raw value still goes
+      // through validation, so skipping is a refusal to coerce, not a hole.
+      if (key === '__proto__' || !prop || typeof prop !== 'object') continue;
+      const k = JSON.stringify(key);
+      const a = `${ov}[${k}]`;
+      if (isScalarCoercible(prop)) lines.push(...scalarCoercion(a, prop.type));
+      // Wrapping a lone value in an array is a top-level rule only, as it was.
+      else if (depth === 0 && prop.type === 'array' && st.arrayMode) lines.push(`if(${k} in ${ov}&&${a}!==undefined&&!Array.isArray(${a}))${a}=[${a}]`);
+      // A leaf, the common case, has nothing below it to coerce.
+      if ((prop.properties || prop.items) && coercesInside(prop, new Set(), st.memo)) {
+        const n = '_c' + st.n++;
+        lines.push(`{const ${n}=${a};if(typeof ${n}==='object'&&${n}!==null){`);
+        emitCoercions(prop, n, lines, st, depth + 1);
+        lines.push('}}');
+      }
+    }
+  }
+  const it = node.items;
+  if (it && typeof it === 'object' && !Array.isArray(it) && (isScalarCoercible(it) || coercesInside(it, new Set(), st.memo))) {
+    const i = '_i' + st.n++;
+    lines.push(`if(Array.isArray(${ov}))for(let ${i}=0;${i}<${ov}.length;${i}++){`);
+    if (isScalarCoercible(it)) lines.push(...scalarCoercion(`${ov}[${i}]`, it.type));
+    if (coercesInside(it, new Set(), st.memo)) {
+      const n = '_c' + st.n++;
+      lines.push(`{const ${n}=${ov}[${i}];if(typeof ${n}==='object'&&${n}!==null){`);
+      emitCoercions(it, n, lines, st, depth + 1);
+      lines.push('}}');
+    }
+    lines.push('}');
+  }
+  st.seen.delete(node);
+}
+function hasDefaultsInside(node, seen) {
+  if (!node || typeof node !== 'object' || !node.properties || seen.has(node)) return false;
+  seen.add(node);
+  let found = false;
+  for (const prop of Object.values(node.properties)) {
+    if (prop && typeof prop === 'object' && (prop.default !== undefined || hasDefaultsInside(prop, seen))) { found = true; break; }
+  }
+  seen.delete(node);
+  return found;
+}
+function emitDefaults(node, ov, lines, st) {
+  if (st.seen.has(node)) { st.cycle = true; return; }
+  st.seen.add(node);
+  for (const [key, prop] of Object.entries(node.properties || {})) {
+    if (!prop || typeof prop !== 'object') continue;
+    const k = JSON.stringify(key);
+    if (prop.default !== undefined) {
+      const def = JSON.stringify(prop.default);
+      // Assignment to a key named __proto__ hits the prototype setter
+      // instead of creating a property; defineProperty writes an own key.
+      lines.push(key === '__proto__'
+        ? `if(!Object.hasOwn(${ov},${k}))Object.defineProperty(${ov},${k},{value:${def},writable:true,enumerable:true,configurable:true})`
+        : `if(!Object.hasOwn(${ov},${k}))${ov}[${k}]=${def}`);
+    }
+    // Into an own property that holds an object, arrays included, as the
+    // closure pass walks it.
+    if (prop.properties && hasDefaultsInside(prop, new Set())) {
+      const n = '_d' + st.n++;
+      lines.push(`if(Object.hasOwn(${ov},${k})){const ${n}=${ov}[${k}];if(typeof ${n}==='object'&&${n}!==null){`);
+      emitDefaults(prop, n, lines, st);
+      lines.push('}}');
+    }
+  }
+  st.seen.delete(node);
+}
+
 // Generate a fast preprocess function via codegen instead of closure arrays
 function buildPreprocessCodegen(schema, options) {
   if (typeof schema !== 'object' || schema === null || !schema.properties) return null;
   const lines = [];
-  const props = schema.properties;
 
   // removeAdditional: strip unknown keys at every level the schema describes,
   // not just the top one. The closure path below (collectRemovals) always
@@ -584,59 +690,44 @@ function buildPreprocessCodegen(schema, options) {
     emitRemovals(schema, 'd', lines, 0, new Set());
   }
 
-  // coerceTypes: inline per property
-  if (options.coerceTypes) {
-    for (const [key, prop] of Object.entries(props)) {
-      if (!prop || typeof prop !== 'object' || !prop.type) continue;
-      // Coercion writes with plain assignment, which for a key named
-      // __proto__ rewrites the prototype instead. The raw value still goes
-      // through validation, so skipping is a refusal to coerce, not a hole.
-      if (key === '__proto__') continue;
-      const t = Array.isArray(prop.type) ? null : prop.type;
-      if (!t) continue;
-      const k = JSON.stringify(key);
-      if (t === 'integer') {
-        lines.push(`if(typeof d[${k}]==='string'){var _n=Number(d[${k}]);if(d[${k}]!==''&&Number.isInteger(_n))d[${k}]=_n}`);
-        lines.push(`if(typeof d[${k}]==='boolean')d[${k}]=d[${k}]?1:0`);
-      } else if (t === 'number') {
-        lines.push(`if(typeof d[${k}]==='string'){var _n=Number(d[${k}]);if(d[${k}]!==''&&!isNaN(_n))d[${k}]=_n}`);
-        lines.push(`if(typeof d[${k}]==='boolean')d[${k}]=d[${k}]?1:0`);
-      } else if (t === 'string') {
-        lines.push(`if(typeof d[${k}]==='number'||typeof d[${k}]==='boolean')d[${k}]=String(d[${k}])`);
-      } else if (t === 'boolean') {
-        lines.push(`if(d[${k}]==='true'||d[${k}]==='1')d[${k}]=true`);
-        lines.push(`if(d[${k}]==='false'||d[${k}]==='0')d[${k}]=false`);
-      } else if (t === 'array' && options.coerceTypes === 'array') {
-        lines.push(`if(${k} in d&&d[${k}]!==undefined&&!Array.isArray(d[${k}]))d[${k}]=[d[${k}]]`);
-      }
-    }
-  }
-
-  // defaults: inline per property
-  if (options.useDefaults !== false) {
-    for (const [key, prop] of Object.entries(props)) {
-      if (prop && typeof prop === 'object' && prop.default !== undefined) {
-        const k = JSON.stringify(key);
-        const def = JSON.stringify(prop.default);
-        // Assignment to a key named __proto__ hits the prototype setter
-        // instead of creating a property; defineProperty writes an own key.
-        lines.push(key === '__proto__'
-          ? `if(!Object.hasOwn(d,${k}))Object.defineProperty(d,${k},{value:${def},writable:true,enumerable:true,configurable:true})`
-          : `if(!Object.hasOwn(d,${k}))d[${k}]=${def}`);
-      }
-    }
-  }
+  // Coercion and defaults reach every depth the closure passes in
+  // validator-core.js reach, with the same rules in the same order, so the
+  // interpreted engine, which uses those passes, gives the same answer. Both
+  // used to stop at the top-level properties. A schema object that contains
+  // itself declines here, and the closure passes, which carry a guard for it,
+  // take the schema.
+  const st = { n: 0, seen: new Set(), cycle: false, arrayMode: options.coerceTypes === 'array', memo: new Map() };
+  if (options.coerceTypes) emitCoercions(schema, 'd', lines, st, 0);
+  // hasDefaultsInside answers without emitting; most schemas have no default,
+  // and the emitting walk allocates for every property it visits.
+  if (options.useDefaults !== false && hasDefaultsInside(schema, new Set())) emitDefaults(schema, 'd', lines, st);
+  if (st.cycle) return null;
 
   if (lines.length === 0) return null;
   // Data may legitimately be null or a non-object (e.g. a `['object','null']`
   // schema), so the per-property mutations must not run on it.
   lines.unshift(`if(d===null||typeof d!=='object')return`);
-  try {
-    return new Function('d', lines.join('\n'));
-  } catch {
-    return null;
+  // The pass depends on property names, types, defaults and which objects
+  // are closed, not on the constraints the verdict checks, so routes that
+  // take the same shape with different limits (a page/limit querystring, an
+  // id param) emit the same source. Compiling it is most of what building the
+  // pass costs, so the function is kept by its source and compiled once. It
+  // holds no state: it rewrites the object it is given and nothing else.
+  const src = lines.join('\n');
+  let fn = _preprocessBySource.get(src);
+  if (fn === undefined) {
+    try {
+      fn = new Function('d', src);
+    } catch {
+      fn = null;
+    }
+    if (_preprocessBySource.size >= PREPROCESS_SOURCE_LIMIT) _preprocessBySource.clear();
+    _preprocessBySource.set(src, fn);
   }
+  return fn;
 }
+const _preprocessBySource = new Map();
+const PREPROCESS_SOURCE_LIMIT = 4096;
 
 
 // parse() for the full package: a generated function that copies the keys the

package/index.node.mjs

@@ -0,0 +1,10 @@
+// The ESM entry Node itself resolves (the `module-sync` condition, Node 22.10
+// and later). Importing index.js with an `import` statement makes Node run
+// its CommonJS lexer over every module the package requires, to find named
+// exports this file lists by hand anyway: 7.7 ms to load against 5.5 through
+// require. Bundlers do not match `module-sync` and keep index.mjs, whose
+// static import they can follow.
+import { createRequire } from 'node:module';
+const mod = createRequire(import.meta.url)('./index.js');
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
+export default mod;

package/lib/aot-build.js

@@ -292,17 +292,22 @@ const { schemaHash } = require('./schema-hash');
 // fromCompiled() around the module toStandaloneModule(schema) writes, which a
 // bundler plugin does so the runtime compiler stays out of the bundle. The
 // wrapper reproduces a default Validator's results exactly for these schemas;
-// tests/test_compiled_parity.js holds that. Declined: anything that rewrites
-// its input before the check, since `useDefaults` is on by default and the
-// module applies no defaults, and custom error messages, which the core
-// applies in a layer the wrapper does not carry. A caller must also get a
+// tests/test_compiled_parity.js holds that. Declined: custom error messages,
+// which the core applies in a layer the wrapper does not carry. A caller must also get a
 // module back from toStandaloneModule, which returns null for a schema it
 // cannot compile. The text checks are deliberately coarse: a property named
 // `default` declines too, and declining costs only the saving.
 function compiledEligible(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
-  const text = JSON.stringify(schema);
-  return !text.includes('"default"') && !text.includes('"errorMessage"');
+  return !JSON.stringify(schema).includes('"errorMessage"');
+}
+
+// The schema a default Validator reads, after normalization: what
+// fromCompiled() takes, so its defaults, sorting and diagnostics follow the
+// same document the runtime does.
+function compiledSchemaFor(schema) {
+  const { Validator } = require('../index.js');
+  return new Validator(schema)._schemaObj;
 }
 
 // The module that replaces `new Validator(schema)`, or null where the
@@ -328,6 +333,7 @@ function compiledModuleFor(schema, opts) {
 
 module.exports = {
   compiledEligible,
+  compiledSchemaFor,
   compiledModuleFor,
   build,
   expandGlobs,

package/lib/compiled.js

@@ -8,11 +8,14 @@
 // objects, which come from the same rejection classes the validator core uses.
 // tests/test_compiled_parity.js holds that over the official suite.
 //
-// Only for a schema compiledEligible() accepts. Anything that rewrites its input
-// (defaults, coercion, removal), custom error messages, and every option other
-// than the defaults stay on the runtime.
+// Only for a schema compiledEligible() accepts, and with the schema
+// compiledSchemaFor() returns: the one the runtime reads, after normalization.
+// Custom error messages and every option other than the defaults stay on the
+// runtime. Defaults are applied as a default Validator applies them, before
+// any check, with the same code.
 
 const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
+const { buildDefaultsApplier } = require('./defaults');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const EMPTY_ERRORS = Object.freeze([]);
@@ -41,9 +44,16 @@ class CompiledState {
 }
 
 function fromCompiled(mod, schema) {
-  const isValid = mod.isValid;
-  const errFn = mod.validate;
   const self = new CompiledState(schema);
+  const fill = buildDefaultsApplier(schema);
+  if (fill) {
+    self._mutatesInput = true;
+    self._preprocess = fill;
+  }
+  // With defaults, the document is filled in before it is checked, on every
+  // entry point, as the runtime does.
+  const isValid = fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
+  const errFn = mod.validate;
   // The generated function's own result, rejected: if it says valid where the
   // verdict said no, the disagreement is reported rather than turned into an
   // acceptance, as the core does.
@@ -63,6 +73,8 @@ function fromCompiled(mod, schema) {
   return {
     validate(data) {
       if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
       return new LazyRejection(buildErrors, data, buildRawErrors);
     },
     isValidObject(data) {

package/lib/defaults.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// The closure pass that fills `default` values, shared by the validator core
+// and by the wrapper around a compiled module, so both fill defaults the same
+// way. The generated pass in index.js is held to this one by
+// tests/test_nested_defaults_engines.js.
+
+// Extract default values from a schema tree. Returns a function that applies
+// defaults to an object in-place (mutates), or null if no defaults exist.
+function buildDefaultsApplier(schema) {
+  if (typeof schema !== "object" || schema === null) return null;
+  const actions = [];
+  collectDefaults(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+// Write an own property. Plain assignment of a key named `__proto__` does
+// not create a property at all: it hits the Object.prototype setter and
+// rewrites the object's prototype, which is how a schema could reach
+// Object.prototype itself. defineProperty has no such special case.
+function setOwn(obj, key, val) {
+  if (key === "__proto__") {
+    Object.defineProperty(obj, key, {
+      value: val,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
+  } else {
+    obj[key] = val;
+  }
+}
+
+function collectDefaults(schema, actions, path) {
+  if (typeof schema !== "object" || schema === null) return;
+  const props = schema.properties;
+  if (!props) return;
+  for (const [key, prop] of Object.entries(props)) {
+    if (prop && typeof prop === "object" && prop.default !== undefined) {
+      const defaultVal = prop.default;
+      if (!path) {
+        actions.push((data) => {
+          if (typeof data === "object" && data !== null && !Object.hasOwn(data, key)) {
+            setOwn(data,
+              key,
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal);
+          }
+        });
+      } else {
+        const parentPath = path;
+        actions.push((data) => {
+          let target = data;
+          for (let j = 0; j < parentPath.length; j++) {
+            if (typeof target !== "object" || target === null) return;
+            // Own keys only. `target[key]` for an inherited name walks the
+            // prototype chain: a parent named `__proto__` that the instance
+            // does not carry resolved to Object.prototype, and the child
+            // defaults were written onto it, for every object in the realm.
+            if (!Object.hasOwn(target, parentPath[j])) return;
+            target = target[parentPath[j]];
+          }
+          if (
+            typeof target === "object" &&
+            target !== null &&
+            !Object.hasOwn(target, key)
+          ) {
+            setOwn(target,
+              key,
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal);
+          }
+        });
+      }
+    }
+    // Recurse into nested object schemas
+    if (prop && typeof prop === "object" && prop.properties) {
+      collectDefaults(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
+module.exports = { buildDefaultsApplier, setOwn };