ata-validator 1.25.0 → 1.27.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 1.27.0 - 2026-09-17
+
+### Added
+
+- `parse()` is now emitted for the record shape: `additionalProperties` as a schema, which is what `z.record` and every generator's map type compile to, with or without declared `properties` beside it. The key set is open by declaration, so keeping every key is exact, and every undeclared value is rebuilt against the one schema that governs it, stripping unknown keys inside it the same way a declared property's rebuild would. Defaults under a record value are not filled, because the runtime's `useDefaults` does not fill them there and `parse()` output stays equal to `validate().data`. Still declined, loudly: `additionalProperties: true` (the value is unconstrained, and this pass only copies what it can prove), applicators next to a record (a branch could constrain some keys' values beyond the record schema), and `patternProperties` (a key matching several patterns must satisfy all of them at once, which the rebuild cannot pick a shape for).
+- `onWarning` now receives a second argument, `{ kind }`, naming which capability degraded: `'error-detail'` or `'parse'`. A build that requested both can tell the warnings apart instead of treating any warning as degraded errors. `build()` result warnings carry the same `kind` field. Existing single-argument callbacks keep working unchanged.
+
+### Fixed
+
+- Two more fixed-name collisions in the generated-code path, the same family as the `patternProperties` helper-scope bug in 1.26.0: a record whose values are themselves records (`additionalProperties` nested in itself) generated an inner loop that redeclared the outer loop's variables and threw `ReferenceError: Cannot access '_av' before initialization` at validation time, and `patternProperties` inside a `patternProperties` value schema had the same collision on its own loop variables. All three loop names now carry a unique suffix. The combined error generator already did this; the boolean generator now matches it.
+
+## 1.26.0 - 2026-09-17
+
+### Added
+
+- `toStandaloneModule(schema, { parse: true })` inlines local, acyclic `$ref`s before the clone proof runs, so schemas that keep their shapes in `$defs` and reference them, which is every schema a generator emits, now get a `parse()`. Only a node that is exactly a `$ref` plus annotations is inlined; a cycle, an external reference or a constraining sibling keyword leaves the reference in place and the clone declines as before. Defaults follow the runtime exactly: a `default` written next to the `$ref` fills, a `default` written inside the referenced definition does not, because `validate()` with `useDefaults` draws the same line and `parse()` must not be more generous than `validate()`. A new test holds `parse()` output equal to the runtime's `validate().data` on the same input.
+- When `parse: true` is requested and the clone still cannot be proven, the decline is loud: `onWarning` fires with the reason, and the emitted module carries a NOTE comment saying it has no `parse` export. Previously the only way to notice was reading the export list.
+
+### Fixed
+
+- The runtime compiler built `patternProperties` (and combined `additionalProperties`) child validators with `new Function`, which discarded the parent's helper scope: a child schema that needed a compiled pattern or format helper threw `ReferenceError` at validation time. Child checks are now generated inline in the parent validator and share its helper bindings. Reported and fixed by @jdalton in #46.
+- The TypeScript declarations emitted next to a compiled module now declare the `schemaHash` export; 1.25.0 added it to every module but not to the generated `.d.mts`, so importing it by name failed type checking while working at runtime.
+
 ## 1.25.0 - 2026-09-17
 
 ### Fixed

package/README.md

@@ -60,7 +60,7 @@ file.
   libraries maintained outside this project. On its validation page, valid data, the run of
   2026-09-13 against ata 1.14.1 puts ata first at 603 ns, with the next entry at 1.77 times
   that. The same site puts ata last on the download page, at 64.9 KB gzipped, because the entry
-  it bundles is the runtime compiler; the module `ata build` emits for that schema is 3.9 KB
+  it bundles is the runtime compiler; the module `ata build` emits for that schema is 5.1 KB
   minified and gzipped, and a compiled entry for the harness is in preparation.
 - [Bowtie](https://bowtie.report/), the cross-implementation JSON Schema test harness. ata's
   harness runs Draft 2020-12 and draft 7 there; on the harness at ata 1.16.1 the official suite
@@ -71,17 +71,19 @@ file.
 
 | Dimension | Schema | ata-AOT | runtime validator | Difference |
 |---|---|---|---|---|
-| Bundle (gzipped) | simple | 1.0 KB | 52.7 KB | 50.5x smaller |
-| Bundle (gzipped) | complex | 4.8 KB | 52.7 KB | 11.0x smaller |
-| Bundle (gzipped) | nested | 2.3 KB | 52.7 KB | 23.1x smaller |
+| Bundle (gzipped) | simple | 1.1 KB | 52.7 KB | 48.1x smaller |
+| Bundle (gzipped) | complex | 7.6 KB | 52.7 KB | 7.0x smaller |
+| Bundle (gzipped) | nested | 4.1 KB | 52.7 KB | 13.0x smaller |
 | Cold start | simple | 21 ms | 40 ms | 1.9x faster |
-| Throughput (1M ops) | simple | 258 Mops/s | 102 Mops/s | 2.5x faster |
-| Compile time | simple | 8 µs | 1.61 ms | 191x faster |
+| Throughput (1M ops) | simple | 257 Mops/s | 114 Mops/s | 2.3x faster |
+| Compile time | simple | 14 µs | 1.52 ms | 111x 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-08-13. Across three runs throughput moved between 258 and 278
-Mops/s and the compile ratio between 150x and 199x, so treat the last two rows as an order
-of magnitude rather than a constant.
+with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-09-17,
+on ata-validator 1.25.0, whose emitted modules carry full error detail and a schema hash, which
+is where the growth over earlier 1.x module sizes comes from. Across three runs throughput moved
+between 257 and 297 Mops/s and the compile ratio between 104x and 112x, so treat the last two
+rows as an order of magnitude rather than a constant.
 
 The wins are largest on bundle size and compile time because AOT moves work from runtime to
 build time. Throughput and cold start are also faster because the compiled validator is a
@@ -209,19 +211,19 @@ 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 | **1.9 KB** | 75.6 KB |
-| Time to a served request | **3.5 ms** | 10.7 ms |
+| In a bundle, gzipped | **4.5 KB** | 87.0 KB |
+| Time to a served request | **3.4 ms** | 10.6 ms |
 | Schema known when | build time | any time |
 
 The bundle row is a ten-field user schema built with
 `bun build --minify --target=browser`. The startup row is a Hono route on Bun 1.4, best
-of seven, against 3.6 ms for the same app doing no validation at all, so the compiled
+of seven, against 3.7 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.** 76 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 87 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.
 
@@ -450,7 +452,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. Typical output is about 2 KB gzipped for a ten-field schema, against 74 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. Typical output is about 4.5 KB gzipped for a ten-field schema, full error detail included, against 87 KB for the runtime bundled for the browser.
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs

package/lib/aot-build.js

@@ -159,14 +159,16 @@ async function build(opts) {
         sourceMap,
         schemaFile,
         formatMode: opts.formatMode,
-        onWarning: (w) => inputWarnings.push(w),
+        onWarning: (w, meta) => inputWarnings.push({ message: w, kind: (meta && meta.kind) || 'general' }),
       });
       if (inputWarnings.length > 0) {
         if (opts.strict) {
-          failed.push({ input, error: inputWarnings.join('; ') });
+          failed.push({ input, error: inputWarnings.map((x) => x.message).join('; ') });
           continue;
         }
-        for (const w of inputWarnings) warnings.push({ input, warning: w });
+        // `kind` says which capability degraded ('error-detail', 'parse'),
+        // so a caller that requested both can tell the warnings apart.
+        for (const x of inputWarnings) warnings.push({ input, warning: x.message, kind: x.kind });
       }
       if (!src) {
         const reason = 'schema is not AOT-compatible (toStandaloneModule returned null)';

package/lib/aot-impl.js

@@ -199,6 +199,74 @@ function emitFormatDecls(closures, mode, declKW) {
 // Returns null when the clone cannot be proven exact, and the module then
 // simply has no parse(). Declining is recoverable; a sanitiser that quietly
 // drops a property the schema allows is not.
+// Resolve a local JSON pointer ('#', '#/$defs/x', draft-7 '#/definitions/x',
+// any '#/...' path) against the schema root. Returns null for anything else:
+// external documents, anchors, URNs. Those stay with the runtime engines.
+function resolveLocalPointer(root, ref) {
+  if (ref === '#') return root;
+  if (typeof ref !== 'string' || !ref.startsWith('#/')) return null;
+  let cur = root;
+  for (const raw of ref.slice(2).split('/')) {
+    let seg = raw.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (cur === null || typeof cur !== 'object') return null;
+    if (!Object.prototype.hasOwnProperty.call(cur, seg)) {
+      try { seg = decodeURIComponent(seg); } catch (_) { return null; }
+      if (!Object.prototype.hasOwnProperty.call(cur, seg)) return null;
+    }
+    cur = cur[seg];
+  }
+  return cur;
+}
+
+// Inline local, acyclic $refs before the clone proof runs, so a generated
+// schema ($defs + $ref, the shape every schema generator emits) can still get
+// a parse(). Only a node that is exactly a $ref plus annotations is replaced;
+// a $ref with a constraining sibling, a cycle, an unresolvable target or an
+// external reference is left in place, and emitClone declines it as before.
+// The walk never mutates its input and never descends into data positions
+// (default, const, enum, examples), where an object holding a "$ref" key is
+// a value, not a schema.
+const _INLINE_ANNOTATIONS = new Set(['$ref', 'title', 'description', '$comment', 'examples', 'deprecated', 'readOnly', 'writeOnly', 'default']);
+const _INLINE_DATA_KEYS = new Set(['default', 'const', 'enum', 'examples']);
+function inlineRefsForClone(root) {
+  const state = { budget: 512 };
+  // `inRef` marks content brought in from behind a reference. The runtime's
+  // useDefaults fills a default written next to the $ref, and does not fill
+  // defaults written inside the referenced definition, so the inlined copy
+  // keeps the first and drops the second. parse() must stay exactly as
+  // generous as validate(); a parse that fills more is a disagreement, not a
+  // feature.
+  const walk = (node, active, inRef) => {
+    if (!node || typeof node !== 'object') return node;
+    if (Array.isArray(node)) return node.map((n) => walk(n, active, inRef));
+    let cur = node;
+    let entered = false;
+    let siblingDefault;
+    while (cur && typeof cur === 'object' && !Array.isArray(cur) && typeof cur.$ref === 'string') {
+      for (const k of Object.keys(cur)) if (!_INLINE_ANNOTATIONS.has(k)) return node;
+      if (active.has(cur.$ref) || state.budget-- <= 0) return node;
+      const target = resolveLocalPointer(root, cur.$ref);
+      if (!target || typeof target !== 'object' || Array.isArray(target)) return node;
+      if (!entered && !inRef && cur.default !== undefined) siblingDefault = cur.default;
+      active = new Set(active);
+      active.add(cur.$ref);
+      cur = target;
+      entered = true;
+    }
+    const strip = inRef || entered;
+    const out = {};
+    for (const k of Object.keys(cur)) {
+      if (strip && k === 'default') continue;
+      const v = cur[k];
+      if (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') { out[k] = v; continue; }
+      out[k] = walk(v, active, strip);
+    }
+    if (siblingDefault !== undefined) out.default = siblingDefault;
+    return out;
+  };
+  return walk(root, new Set(), false);
+}
+
 function emitClone(node, access, depth) {
   if (!node || typeof node !== 'object') return null;
   if (depth > 12) return null;
@@ -211,15 +279,35 @@ function emitClone(node, access, depth) {
   // never widen the key set. `not` never widens it. `unevaluatedProperties`
   // is admitted only as `false` under that proof, where it is exactly
   // `additionalProperties: false`.
-  if (node.$ref || node.patternProperties ||
-      node.additionalProperties === true ||
-      (node.additionalProperties && typeof node.additionalProperties === 'object')) {
+  if (node.$ref || node.patternProperties || node.additionalProperties === true) {
     return null;
   }
+  // additionalProperties as a schema is the record shape (z.record and every
+  // generator's map type): the key set is open by declaration, so keeping
+  // every key is exact, and every undeclared value is rebuilt against that
+  // one schema. That is a proof, not a guess, so it is admitted. What stays
+  // out: applicators next to a record (a branch could constrain some keys'
+  // values beyond the record schema, and the rebuild would ignore it), and
+  // `additionalProperties: true`, where the value is unconstrained and this
+  // pass only copies what it can name. An open object with no
+  // `additionalProperties` at all also stays out, for the original reason:
+  // validate() accepts its unknown keys, so a parse() that strips them would
+  // silently drop allowed data, and one that keeps them raw would not be a
+  // sanitiser.
+  const apSchema = (node.additionalProperties && typeof node.additionalProperties === 'object')
+    ? node.additionalProperties
+    : null;
+  if (apSchema) {
+    if (node.unevaluatedProperties !== undefined) return null;
+    if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
+        node.dependentSchemas !== undefined || node.dependencies !== undefined ||
+        node.$dynamicRef !== undefined || node.$recursiveRef !== undefined) return null;
+  }
   if (node.unevaluatedProperties !== undefined && node.unevaluatedProperties !== false) return null;
-  if (node.type !== 'object' || !node.properties) return null;
-  const keys = Object.keys(node.properties);
-  if (keys.length === 0) return null;
+  if (node.type !== 'object') return null;
+  if (!node.properties && !apSchema) return null;
+  const keys = node.properties ? Object.keys(node.properties) : [];
+  if (keys.length === 0 && !apSchema) return null;
   if (node.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
       node.unevaluatedProperties === false) {
     if (node.$dynamicRef !== undefined || node.$recursiveRef !== undefined ||
@@ -239,13 +327,6 @@ function emitClone(node, access, depth) {
   }
   const required = new Set(Array.isArray(node.required) ? node.required : []);
 
-  // A property is copyable only when the emitter can name everything that
-  // may live under it: a primitive holds nothing, and an object with declared
-  // properties is rebuilt the same way. A $ref, a composition, an array of
-  // objects or an untyped node could all carry keys this code cannot see, and
-  // copying the reference would smuggle them into a value that claims to be
-  // sanitised, so the whole clone is declined instead.
-  const PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
   const fixed = [];
   const conditional = [];
   for (const key of keys) {
@@ -268,47 +349,41 @@ function emitClone(node, access, depth) {
       if (!probe || !probe(prop.default)) return null;
     }
     const read = `${access}[${JSON.stringify(key)}]`;
-    let value;
-    const types = Array.isArray(prop.type) ? prop.type : [prop.type];
-    if (types.every((t) => PRIMITIVE.has(t))) {
-      value = read;
-    } else if (prop.type === 'object' && prop.properties) {
-      const nested = emitClone(prop, read, depth + 1);
-      if (!nested) return null;
-      // The nested schema may also admit null, in which case there is nothing
-      // to rebuild and the value passes through.
-      value = required.has(key) ? nested : nested;
-    } else if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
-               !Array.isArray(prop.items) &&
-               (Array.isArray(prop.items.type) ? prop.items.type : [prop.items.type])
-                 .every((t) => PRIMITIVE.has(t))) {
-      // An array of primitives has nowhere to hide a key. The reference is
-      // shared with the input, exactly as a shallow strip would leave it.
-      value = read;
-    } else if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
-               !Array.isArray(prop.items) && prop.items.type === 'object' &&
-               prop.items.properties) {
-      // An array of objects: rebuild each element the same way, so unknown
-      // keys inside the array are dropped too. Most real schemas have one of
-      // these, and declining them left parse() emitted only for shapes nobody
-      // writes.
-      const el = '_e' + depth;
-      const inner = emitClone(prop.items, el, depth + 1);
-      if (!inner) return null;
-      value = `${read}.map((${el}) => (${inner}))`;
-    } else {
-      return null;
-    }
+    const value = emitValueExpr(prop, read, depth);
+    if (value === null) return null;
     if (required.has(key)) fixed.push(`${JSON.stringify(key)}: ${value}`);
     else conditional.push({ key, value, dflt: prop.default });
   }
-  if (fixed.length === 0 && conditional.length === 0) return null;
+  if (fixed.length === 0 && conditional.length === 0 && !apSchema) return null;
+
+  const tmp = `_c${depth}`;
+  // The record loop: every key of the input that is not a declared property
+  // is kept, its value rebuilt against the additionalProperties schema. The
+  // input is already validated, so every such value satisfies that schema;
+  // the rebuild only strips inside it. Defaults under a record value are
+  // dropped before emission because the runtime's useDefaults does not fill
+  // them there, and parse() must equal validate().data, not improve on it.
+  let recordLoop = '';
+  if (apSchema) {
+    const kVar = `_k${depth}`;
+    const vVar = `_v${depth}`;
+    const valueExpr = emitValueExpr(stripDefaultsDeep(apSchema), vVar, depth);
+    if (valueExpr === null) return null;
+    let skip = '';
+    let declSet = '';
+    if (keys.length > 8) {
+      declSet = `const _d${depth} = new Set(${JSON.stringify(keys)}); `;
+      skip = `if (_d${depth}.has(${kVar})) continue; `;
+    } else if (keys.length > 0) {
+      skip = `if (${keys.map((k) => `${kVar} === ${JSON.stringify(k)}`).join(' || ')}) continue; `;
+    }
+    recordLoop = ` ${declSet}for (const ${kVar} of Object.keys(${access})) { ${skip}const ${vVar} = ${access}[${kVar}]; ${tmp}[${kVar}] = ${valueExpr}; }`;
+  }
 
   const literal = `{ ${fixed.join(', ')} }`;
-  if (conditional.length === 0) return literal;
+  if (conditional.length === 0 && !recordLoop) return literal;
   // Optional properties are added only when present, so the result never
   // gains a key the input did not have.
-  const tmp = `_c${depth}`;
   const adds = conditional
     .map(({ key, value, dflt }) => {
       const set = `if (${JSON.stringify(key)} in ${access}) ${tmp}[${JSON.stringify(key)}] = ${value};`;
@@ -317,7 +392,55 @@ function emitClone(node, access, depth) {
       return dflt === undefined ? set : `${set} else ${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
     })
     .join(' ');
-  return `(function(){ const ${tmp} = ${literal}; ${adds} return ${tmp}; })()`;
+  return `(function(){ const ${tmp} = ${literal}; ${adds}${recordLoop} return ${tmp}; })()`;
+}
+
+// The value dispatch shared by declared properties and the record loop. A
+// value is copyable only when the emitter can name everything that may live
+// under it: a primitive holds nothing, an object with declared properties or
+// a record schema is rebuilt the same way, an array of primitives has
+// nowhere to hide a key. A $ref, a composition or an untyped node could all
+// carry keys this code cannot see, and copying the reference would smuggle
+// them into a value that claims to be sanitised, so the caller declines the
+// whole clone instead.
+// Drop every schema-position `default` in a subtree, leaving data positions
+// (const, enum, examples) untouched. Used on a record's value schema, where
+// the runtime's useDefaults fills nothing.
+function stripDefaultsDeep(node) {
+  if (!node || typeof node !== 'object') return node;
+  if (Array.isArray(node)) return node.map(stripDefaultsDeep);
+  const out = {};
+  for (const k of Object.keys(node)) {
+    if (k === 'default') continue;
+    out[k] = _INLINE_DATA_KEYS.has(k) ? node[k] : stripDefaultsDeep(node[k]);
+  }
+  return out;
+}
+
+const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
+function emitValueExpr(prop, read, depth) {
+  if (!prop || typeof prop !== 'object') return null;
+  if (prop.$ref) return null;
+  const types = Array.isArray(prop.type) ? prop.type : [prop.type];
+  if (types.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
+  const isRecordable = (s) => s.properties ||
+    (s.additionalProperties && typeof s.additionalProperties === 'object');
+  if (prop.type === 'object' && isRecordable(prop)) {
+    return emitClone(prop, read, depth + 1);
+  }
+  if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
+      !Array.isArray(prop.items)) {
+    const it = prop.items;
+    const itemTypes = Array.isArray(it.type) ? it.type : [it.type];
+    if (itemTypes.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
+    if (it.type === 'object' && isRecordable(it)) {
+      const el = '_e' + depth;
+      const inner = emitClone(it, el, depth + 1);
+      if (!inner) return null;
+      return `${read}.map((${el}) => (${inner}))`;
+    }
+  }
+  return null;
 }
 
 function toStandaloneModule(validator, opts) {
@@ -351,8 +474,12 @@ function toStandaloneModule(validator, opts) {
       // way the runtime validator does. The module still ships, with the
       // verdict exact, but every failure reports the single ATA9000 stub.
       // Silence here cost a user a debugging session; hence the channel.
+      // The second argument names which capability degraded, so a build that
+      // requested several can tell this warning from a parse decline instead
+      // of treating any warning as "errors degraded".
       opts.onWarning(
-        'error detail could not be generated for this schema; the module reports failures as the single ATA9000 abort-early error. The verdict is unaffected. For detailed errors, validate failing documents with the runtime Validator.'
+        'error detail could not be generated for this schema; the module reports failures as the single ATA9000 abort-early error. The verdict is unaffected. For detailed errors, validate failing documents with the runtime Validator.',
+        { kind: 'error-detail' }
       );
     }
   }
@@ -422,11 +549,22 @@ function toStandaloneModule(validator, opts) {
   // schema declares. Off by default: it costs bytes in every emitted module,
   // and the reason to compile a schema ahead of time is usually to ship as
   // little as possible. Ask for it with { parse: true }.
-  const cloneExpr = !(opts && opts.parse) ? null : emitClone(
-    typeof validator._schemaObj === 'object' ? validator._schemaObj : null,
-    'data',
-    0,
-  );
+  // Local acyclic $refs are inlined first, so the schemas generators emit
+  // ($defs + $ref everywhere) still get a parse(). When the clone is still
+  // not provable, the decline is loud: the caller asked for parse and is not
+  // getting it, and discovering that by reading the export list cost a user
+  // an afternoon. Same channel as the error-detail decline above.
+  let cloneExpr = null;
+  if (opts && opts.parse) {
+    const baseSchema = typeof validator._schemaObj === 'object' ? validator._schemaObj : null;
+    cloneExpr = baseSchema ? emitClone(inlineRefsForClone(baseSchema), 'data', 0) : null;
+    if (!cloneExpr && typeof opts.onWarning === 'function') {
+      opts.onWarning(
+        'parse() could not be generated for this schema: the rebuild is only emitted where the allowed key set is provable, and a remaining $ref (cyclic, external, or carrying constraining siblings), patternProperties, applicators next to an open key set, or an unconstrained additionalProperties makes it someone else\'s decision. The module ships without a parse export; validate and strip with the runtime Validator instead.',
+        { kind: 'parse' }
+      );
+    }
+  }
   // Named _ataParse rather than parse: the emitted module also carries the
   // safe-regex prelude, which has a module-scope parse() of its own for
   // reading patterns. A second declaration of that name shadowed it and the
@@ -483,9 +621,12 @@ function validateJSON(text) {
     ? `export { ${names}${parseAlias} };\nexport default { ${names}${parseProp} };\n`
     : `module.exports = { ${names}${parseProp} };\nmodule.exports.default = module.exports;\n`;
 
-  const degradedNote = (!abortEarly && !errCore)
+  let degradedNote = (!abortEarly && !errCore)
     ? '// NOTE: error detail was requested but could not be generated for this\n// schema; failures report the single ATA9000 abort-early error. The verdict\n// is exact. Validate failing documents with the runtime Validator for detail.\n'
     : '';
+  if (opts && opts.parse && !cloneExpr) {
+    degradedNote += '// NOTE: parse() was requested but could not be generated for this schema;\n// the module has no parse export. Validate and strip with the runtime Validator.\n';
+  }
   return `// Auto-generated by ata-validator — do not edit.
 // Schema is embedded; runtime has zero dependency on ata-validator.
 ${degradedNote}'use strict';

package/lib/js-compiler.js

@@ -2201,17 +2201,24 @@ function genCode(schema, v, lines, ctx, knownType) {
   // against that sub-schema. Skip if patternProperties is present (handled by
   // the unified loop). Composition cases are filtered out by codegenSafe.
   if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null && !schema.patternProperties) {
+    // The loop variables carry a unique suffix: a record whose values are
+    // themselves records nests this loop inside itself, and a fixed `_av`
+    // made the inner `const _av=_av[_k]` a self-reference that threw at
+    // validation time.
+    const apId = ctx._apLoopId = (ctx._apLoopId || 0) + 1
+    const kVar = `_k${apId}`
+    const avVar = `_av${apId}`
     const declared = schema.properties ? Object.keys(schema.properties) : []
     const skipCheck = declared.length === 0
       ? null
-      : declared.map(k => `_k===${JSON.stringify(k)}`).join('||')
+      : declared.map(k => `${kVar}===${JSON.stringify(k)}`).join('||')
     const subLines = []
-    genCode(schema.additionalProperties, '_av', subLines, ctx)
+    genCode(schema.additionalProperties, avVar, subLines, ctx)
     if (subLines.length > 0) {
       const body = subLines.join(';')
       const loop = skipCheck
-        ? `for(var _k in ${v}){if(${skipCheck})continue;const _av=${v}[_k];${body}}`
-        : `for(var _k in ${v}){const _av=${v}[_k];${body}}`
+        ? `for(var ${kVar} in ${v}){if(${skipCheck})continue;const ${avVar}=${v}[${kVar}];${body}}`
+        : `for(var ${kVar} in ${v}){const ${avVar}=${v}[${kVar}];${body}}`
       _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
     }
   }
@@ -2246,15 +2253,13 @@ function genCode(schema, v, lines, ctx, knownType) {
       }
     }
 
-    // Build sub-schema validators as closure vars
+    // Build sub-schema checks inline so they share the parent helper scope.
+    const subChecks = []
     for (let i = 0; i < ppEntries.length; i++) {
       const [, sub] = ppEntries[i]
       const subLines = []
-      genCode(sub, `_ppv`, subLines, ctx)
-      const fnBody = subLines.length === 0 ? `return true` : `${subLines.join(';')};return true`
-      const fnVar = `_ppf${pi}_${i}`
-      ctx.closureVars.push(fnVar)
-      ctx.closureVals.push(new Function('_ppv', fnBody))
+      genCode(sub, `_ppv${pi}`, subLines, ctx)
+      subChecks.push(subLines.join(';'))
     }
 
     const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
@@ -2268,13 +2273,11 @@ function genCode(schema, v, lines, ctx, knownType) {
       ctx._ppHandledAdditional = true
       ctx._ppHandledPropertyNames = !!pn
       const propKeys = Object.keys(schema.properties || {})
-      let apFn = null
+      let apCheck = null
       if (apSchema) {
         const apLines = []
-        genCode(apSchema, '_apv', apLines, ctx)
-        apFn = `_apf${pi}`
-        ctx.closureVars.push(apFn)
-        ctx.closureVals.push(new Function('_apv', apLines.length === 0 ? 'return true' : `${apLines.join(';')};return true`))
+        genCode(apSchema, `_apv${pi}`, apLines, ctx)
+        apCheck = apLines.join(';')
       }
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
       // propertyNames checks (merged into same loop)
@@ -2308,14 +2311,14 @@ function genCode(schema, v, lines, ctx, knownType) {
       if (ppEntries.length > 0) {
         lines.push(`let _pm${pi}=false`)
         for (let i = 0; i < ppEntries.length; i++) {
-          lines.push(`if(${matchers[i].check}){_pm${pi}=true;if(!_ppf${pi}_${i}(${v}[${kVar}]))return false}`)
+          lines.push(`if(${matchers[i].check}){_pm${pi}=true;const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
         }
       }
       // A key that is neither declared nor matched is additional. switch on
       // the declared names (V8 compiles string cases to a jump table); no
       // switch at all when nothing is declared, since a switch with no case
       // clause is a syntax error.
-      const additional = apFn ? `if(!${apFn}(${v}[${kVar}]))return false` : `return false`
+      const additional = apCheck !== null ? `const _apv${pi}=${v}[${kVar}];${apCheck}` : `return false`
       const notMatched = ppEntries.length > 0 ? `if(!_pm${pi}){${additional}}` : additional
       if (propKeys.length) {
         const switchCases = propKeys.map(k => `case ${JSON.stringify(k)}:`).join('')
@@ -2352,7 +2355,7 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
       }
       for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}&&!_ppf${pi}_${i}(${v}[${kVar}]))return false`)
+        lines.push(`if(${matchers[i].check}){const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
       }
       lines.push(`}}`)
     }

package/lib/ts-gen.js

@@ -238,7 +238,8 @@ export type Result = ValidResult | InvalidResult;
 
 export declare function isValid(data: unknown): data is ${rootName};
 export declare function validate(data: unknown): Result;
-declare const _default: { validate: typeof validate; isValid: typeof isValid };
+export declare const schemaHash: string;
+declare const _default: { validate: typeof validate; isValid: typeof isValid; schemaHash: typeof schemaHash };
 export default _default;
 `;
 }

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.25.0';
+module.exports = '1.27.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "JSON Schema validation that compiles for speed and still runs where code generation is blocked. Compiled and interpreted engines answer identically at 100% of the official suite. TypeScript inference, Standard Schema V1, and a build step that emits dependency-free modules.",
   "main": "index.js",
   "module": "index.mjs",
@@ -122,13 +122,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.25.0",
-    "@ata-validator/native-darwin-x64": "1.25.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.25.0",
-    "@ata-validator/native-linux-arm64-musl": "1.25.0",
-    "@ata-validator/native-linux-x64-gnu": "1.25.0",
-    "@ata-validator/native-linux-x64-musl": "1.25.0",
-    "@ata-validator/native-win32-x64": "1.25.0"
+    "@ata-validator/native-darwin-arm64": "1.27.0",
+    "@ata-validator/native-darwin-x64": "1.27.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.27.0",
+    "@ata-validator/native-linux-arm64-musl": "1.27.0",
+    "@ata-validator/native-linux-x64-gnu": "1.27.0",
+    "@ata-validator/native-linux-x64-musl": "1.27.0",
+    "@ata-validator/native-win32-x64": "1.27.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"