ata-validator 1.23.0 → 1.25.0

package/lib/aot-impl.js

@@ -13,7 +13,9 @@
 //   bundleCompact(Validator, schemas, opts)
 //   loadBundle(Validator, mods, schemas, opts)
 
-const { compileToJSCodegenWithErrors } = require('./js-compiler');
+const { compileToJSCodegenWithErrors, compileToJSCodegen, unevalContributions } = require('./js-compiler');
+const { buildDataPositionMap } = require('./data-positions');
+const { schemaHash } = require('./schema-hash');
 const SAFE_REGEX_SOURCE = require('./safe-regex-source');
 
 // Embedded verbatim in standalone modules so the output file has no runtime
@@ -54,6 +56,35 @@ function safeRePrelude(...fns) {
   return fns.some((f) => f && f._usesSafeRe) ? getSafeRegexEmbed() + '\n' : '';
 }
 
+// Serialize the closure variables a compiled function referenced (regexes,
+// sets, lookup tables, preprocessor functions) into declarations for load
+// scope. Regex lines are no longer inlined into _source, so every emitter
+// must declare them exactly once outside the emitted function; inlining them
+// in the body recompiled the pattern on every call.
+function closureDeclLines(jsFn, declKW) {
+  const kw = declKW || 'const';
+  const lines = [];
+  if (!jsFn || !jsFn._closures || jsFn._closures.length === 0) return lines;
+  for (const { name, val } of jsFn._closures) {
+    if (Array.isArray(val)) { lines.push(`${kw} ${name} = ${JSON.stringify(val)};`); continue; }
+    if (val && val.__ataSafe) {
+      lines.push(`${kw} ${name} = __ataSafeRe(${JSON.stringify(val.source)});`);
+    } else if (val instanceof RegExp) {
+      const flags = val.flags;
+      lines.push(`${kw} ${name} = new RegExp(${JSON.stringify(val.source)}${flags ? ', ' + JSON.stringify(flags) : ''});`);
+    } else if (val instanceof Set) {
+      lines.push(`${kw} ${name} = new Set(${JSON.stringify([...val])});`);
+    } else if (typeof val === 'function') {
+      // new Function('_ppv', body) — extract body from toString()
+      const str = val.toString();
+      const m = str.match(/^function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/);
+      const body = m ? m[1].trim() : str;
+      lines.push(`${kw} ${name} = function(_ppv) { ${body} };`);
+    }
+  }
+  return lines;
+}
+
 // A validator can enforce more than its schema says. `withKeywords` from
 // @ata-project/keywords wraps an instance's entry points, and a wrapper
 // declares that by setting `_externalChecks`. The emitters below build their
@@ -87,11 +118,12 @@ function toStandalone(validator) {
   );
   const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
 
+  const closureSrc = closureDeclLines(jsFn).join('\n');
   return `// Auto-generated by ata-validator — do not edit
 'use strict';
 ${_CP_LEN_SOURCE}
 ${safeRePrelude(jsFn, jsErrFn)}${preambleSrc}
-const boolFn = function(d) {
+${closureSrc ? closureSrc + '\n' : ''}const boolFn = function(d) {
   ${src}
 };
 const hybridFactory = function(R, E) {
@@ -171,17 +203,40 @@ function emitClone(node, access, depth) {
   if (!node || typeof node !== 'object') return null;
   if (depth > 12) return null;
   // Only plain object nodes are cloneable, and only when the schema names
-  // every property it keeps. A union type, a $ref, or any composition means
-  // the set of allowed keys is not this node's to decide.
-  if (node.$ref || node.allOf || node.anyOf || node.oneOf || node.not ||
-      node.if || node.patternProperties || node.unevaluatedProperties ||
+  // every property it keeps. A $ref means the set of allowed keys is not
+  // this node's to decide. In-place applicators (allOf, anyOf, oneOf,
+  // if/then/else) are admitted under the same proof the unevaluated* error
+  // generators use: every property name they contribute must already be
+  // declared in this node's own `properties`, so they constrain values but
+  // 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')) {
     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.allOf || node.anyOf || node.oneOf || node.if || node.then || node.else ||
+      node.unevaluatedProperties === false) {
+    if (node.$dynamicRef !== undefined || node.$recursiveRef !== undefined ||
+        node.dependentSchemas !== undefined || node.dependencies !== undefined) return null;
+    const names = new Set();
+    const state = { prefix: 0 };
+    for (const k of ['allOf', 'anyOf', 'oneOf']) {
+      if (node[k] !== undefined) {
+        if (!Array.isArray(node[k])) return null;
+        for (const b of node[k]) if (!unevalContributions(b, 'props', names, state, 0)) return null;
+      }
+    }
+    for (const k of ['if', 'then', 'else']) {
+      if (node[k] !== undefined && !unevalContributions(node[k], 'props', names, state, 0)) return null;
+    }
+    for (const n of names) if (!Object.prototype.hasOwnProperty.call(node.properties, n)) return null;
+  }
   const required = new Set(Array.isArray(node.required) ? node.required : []);
 
   // A property is copyable only when the emitter can name everything that
@@ -196,7 +251,22 @@ function emitClone(node, access, depth) {
   for (const key of keys) {
     const prop = node.properties[key];
     if (!prop || typeof prop !== 'object') return null;
-    if (prop.$ref || prop.allOf || prop.anyOf || prop.oneOf || prop.not || prop.if) return null;
+    if (prop.$ref) return null;
+    // A property that is required and carries a default is the one place the
+    // runtime and a raw-input validation disagree: the runtime fills the
+    // default before checking `required`, so `{}` validates there and would
+    // throw here. Declining keeps parse() exactly as strict as validate().
+    if (required.has(key) && prop.default !== undefined) return null;
+    // A default the property's own schema rejects would make parse() hand
+    // back a document validate() refuses: the runtime fills defaults before
+    // validating, so it catches the bad default, and a raw-input check here
+    // never sees it. Probe the default at emit time and decline when it does
+    // not hold, or when the subschema cannot be compiled to check it.
+    if (prop.default !== undefined) {
+      let probe = null;
+      try { probe = compileToJSCodegen(prop, null, null); } catch (_) { probe = null; }
+      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];
@@ -230,7 +300,7 @@ function emitClone(node, access, depth) {
       return null;
     }
     if (required.has(key)) fixed.push(`${JSON.stringify(key)}: ${value}`);
-    else conditional.push({ key, value });
+    else conditional.push({ key, value, dflt: prop.default });
   }
   if (fixed.length === 0 && conditional.length === 0) return null;
 
@@ -240,7 +310,12 @@ function emitClone(node, access, depth) {
   // gains a key the input did not have.
   const tmp = `_c${depth}`;
   const adds = conditional
-    .map(({ key, value }) => `if (${JSON.stringify(key)} in ${access}) ${tmp}[${JSON.stringify(key)}] = ${value};`)
+    .map(({ key, value, dflt }) => {
+      const set = `if (${JSON.stringify(key)} in ${access}) ${tmp}[${JSON.stringify(key)}] = ${value};`;
+      // The default is emitted as a literal inside the call, so an object or
+      // array default is a fresh value on every parse, never shared state.
+      return dflt === undefined ? set : `${set} else ${tmp}[${JSON.stringify(key)}] = ${JSON.stringify(dflt)};`;
+    })
     .join(' ');
   return `(function(){ const ${tmp} = ${literal}; ${adds} return ${tmp}; })()`;
 }
@@ -269,6 +344,16 @@ function toStandaloneModule(validator, opts) {
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
     if (errSrc) {
       errCore = `const errFn = function(d, _all) {\n  ${errSrc}\n};\n`;
+    } else if (opts && typeof opts.onWarning === 'function') {
+      // The caller asked for error detail and is not getting it: the error
+      // generator declined this schema (unevaluated* and a few other shapes),
+      // and a standalone module has no interpreted engine to fall back to the
+      // 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.
+      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.'
+      );
     }
   }
 
@@ -284,29 +369,8 @@ function toStandaloneModule(validator, opts) {
 
   // Serialize closure vars referenced in _fn body: regex, sub-validators, sets.
   let closureDecls = '';
-  if (jsFn._closures && jsFn._closures.length > 0) {
-    const lines = [];
-    for (const { name, val } of jsFn._closures) {
-      if (Array.isArray(val)) {
-        lines.push(`const ${name} = ${JSON.stringify(val)};`);
-        continue;
-      }
-      if (val && val.__ataSafe) {
-        lines.push(`const ${name} = __ataSafeRe(${JSON.stringify(val.source)});`);
-      } else if (val instanceof RegExp) {
-        const flags = val.flags;
-        lines.push(`const ${name} = new RegExp(${JSON.stringify(val.source)}${flags ? ', ' + JSON.stringify(flags) : ''});`);
-      } else if (val instanceof Set) {
-        lines.push(`const ${name} = new Set(${JSON.stringify([...val])});`);
-      } else if (typeof val === 'function') {
-        // new Function('_ppv', body) — extract body from toString()
-        const str = val.toString();
-        // Matches: "function anonymous(_ppv\n) {\nbody\n}" or "function(_ppv){body}"
-        const m = str.match(/^function[^(]*\([^)]*\)\s*\{([\s\S]*)\}$/)
-        const body = m ? m[1].trim() : str;
-        lines.push(`const ${name} = function(_ppv) { ${body} };`);
-      }
-    }
+  {
+    const lines = closureDeclLines(jsFn);
     if (lines.length) closureDecls = lines.join('\n') + '\n';
   }
 
@@ -371,17 +435,60 @@ function toStandaloneModule(validator, opts) {
     ? `function _ataParse(data) {\n  if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
     : '';
 
+  // validateJSON(): parse the text, validate, and on failure attach a
+  // dataFrame (byte offset, line, col, source line) to every error by
+  // walking the original text once. Off by default for the same reason as
+  // parse(): it costs bytes in every emitted module. Ask for it with
+  // { positions: true }. The walker is the runtime's buildDataPositionMap,
+  // embedded verbatim via toString so the two cannot drift; that is why the
+  // function in lib/data-positions.js must stay self-contained.
+  const positionsCore = !(opts && opts.positions) ? '' : `const _ataPosMap = ${buildDataPositionMap.toString()};
+function _ataFrame(p) { return { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text }; }
+function validateJSON(text) {
+  const s = String(text);
+  let data;
+  try { data = JSON.parse(s); } catch (e) {
+    const nl = s.indexOf(String.fromCharCode(10));
+    let frame = { byteOffset: 0, length: s.length, line: 1, col: 1, text: nl === -1 ? s : s.slice(0, nl) };
+    try { const m = _ataPosMap(s); if (m['']) frame = _ataFrame(m['']); } catch (_) {}
+    return { valid: false, errors: [{ code: 'ATA9001', message: 'invalid JSON document', keyword: '__parse__', path: '', instancePath: '', dataFrame: frame }] };
+  }
+  const r = validate(data);
+  if (r.valid || !r.errors || !r.errors.length) return r;
+  let map;
+  try { map = _ataPosMap(s); } catch (_) { return r; }
+  const errors = r.errors.map((e) => {
+    const ptr = e.instancePath != null ? e.instancePath : (e.path || '');
+    const p = map[ptr];
+    return p ? Object.assign({}, e, { dataFrame: _ataFrame(p) }) : e;
+  });
+  return { valid: false, errors };
+}
+`;
+
   const baseNames = cloneExpr ? 'validate, isValid' : 'validate, isValid';
-  const names = fmt.exportsSetFormats ? baseNames + ', setFormats' : baseNames;
+  // The content hash of the schema this module was compiled from, over the
+  // schema as the caller wrote it (before dialect normalization), so a build
+  // can compare it against schemaHash(currentSchema) and know the module is
+  // stale without embedding its own fingerprint.
+  const hashSrc = schemaHash(validator._rawSchema !== undefined ? validator._rawSchema : validator._schemaObj);
+  const hashDecl = `const schemaHash = ${JSON.stringify(hashSrc)};\n`;
+
+  let names = fmt.exportsSetFormats ? baseNames + ', setFormats' : baseNames;
+  names += ', schemaHash';
+  if (positionsCore) names += ', validateJSON';
   const parseAlias = cloneExpr ? ', _ataParse as parse' : '';
   const parseProp = cloneExpr ? ', parse: _ataParse' : '';
   const exports = format === 'esm'
     ? `export { ${names}${parseAlias} };\nexport default { ${names}${parseProp} };\n`
     : `module.exports = { ${names}${parseProp} };\nmodule.exports.default = module.exports;\n`;
 
+  const 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'
+    : '';
   return `// Auto-generated by ata-validator — do not edit.
 // Schema is embedded; runtime has zero dependency on ata-validator.
-'use strict';
+${degradedNote}'use strict';
 ${_CP_LEN_SOURCE}
 ${safeRePrelude(jsFn, jsErrFn)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({
@@ -398,7 +505,7 @@ ${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(
 };
 ${errCore}function isValid(data) { return _fn(data); }
 function validate(data) { ${validBody}; }
-${parseCore}${exports}`;
+${parseCore}${positionsCore}${hashDecl}${exports}`;
 }
 
 // Bundle multiple validators into a single JS file for fast startup.
@@ -504,6 +611,8 @@ function bundleStandalone(Validator, schemas, opts) {
       ? (jsFn._preambleGuard || '') + (kept.length ? kept.join('\n  ') + '\n  ' : '')
       : (jsFn._preambleSource || '');
     if (preambleSrc) preamble = preamble ? `${preamble}\n${preambleSrc}` : preambleSrc;
+    const closureSrc = closureDeclLines(jsFn, 'var').join('\n');
+    if (closureSrc) preamble = preamble ? `${preamble}\n${closureSrc}\n` : closureSrc + '\n';
     if (opts && opts.verbose) {
       // Embed the schema and a small resolver so errors carry parentSchema.
       const schemaLit = JSON.stringify(v._schemaObj);
@@ -560,6 +669,7 @@ function bundleCompact(Validator, schemas, opts) {
       guard: jsFn._preambleGuard || '',
       parts: jsFn._preambleParts || null,
       preamble: jsFn._preambleSource || '',
+      closures: closureDeclLines(jsFn, 'var').join('\n'),
       hybridBody: jsFn._hybridSource,
       err: jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : null,
       fmt: jsFn._formatClosures || null,
@@ -589,7 +699,11 @@ function bundleCompact(Validator, schemas, opts) {
     const preamble = kept !== null
       ? e.guard + (kept.length ? kept.join('\n  ') + '\n  ' : '')
       : e.preamble;
-    e.hybrid = preamble ? `${preamble}\n${e.hybridBody}` : e.hybridBody;
+    // Factory-scope code: guard state, hoisted branch helpers, and the
+    // closure declarations (regexes above all), matching where the
+    // in-process compiler places them. Keeping them per call recompiled
+    // every pattern on every validation.
+    e.factory = (preamble ? preamble + '\n' : '') + (e.closures ? e.closures + '\n' : '');
     if (e.err) for (const h of sharedDecls) e.err = e.err.split(h).join('');
   }
 
@@ -601,11 +715,15 @@ function bundleCompact(Validator, schemas, opts) {
 
   const indices = entries.map((e) => {
     if (!e) return [-1, -1];
-    let hi = bodyMap.get(e.hybrid);
+    // The dedupe key must include the factory code: two schemas can emit an
+    // identical body that references _re1 with different patterns, and the
+    // pattern now lives only in the factory-scope declaration.
+    const key = e.factory + '\u0000' + e.hybridBody;
+    let hi = bodyMap.get(key);
     if (hi === undefined) {
       hi = bodies.length;
-      bodies.push(e.hybrid);
-      bodyMap.set(e.hybrid, hi);
+      bodies.push({ factory: e.factory, body: e.hybridBody });
+      bodyMap.set(key, hi);
     }
     let ei = -1;
     if (e.err) {
@@ -648,7 +766,7 @@ function bundleCompact(Validator, schemas, opts) {
   // Shared hybrid factories
   out += `${declKW} H=[\n`;
   out += bodies
-    .map((b) => `function(R,E){return function(d){${b}}}`)
+    .map((b) => `function(R,E){${b.factory}return function(d){${b.body}}}`)
     .join(',\n');
   out += '\n];\n';
 

package/lib/data-positions.js

@@ -6,10 +6,13 @@
  * AND abortEarly is off. Zero cost on the valid path.
  */
 
-const { escapePtr } = require('./source-positions');
-
+// Self-contained on purpose: `toStandaloneModule({ positions: true })` embeds
+// this function verbatim via Function.prototype.toString, so it may not close
+// over anything in this module and may not assume Node globals. The inlined
+// escapePtr below duplicates lib/source-positions.js for that reason.
 function buildDataPositionMap (input) {
-  const text = Buffer.isBuffer(input) ? input.toString('utf8') : String(input);
+  const escapePtr = (s) => s.replace(/~/g, '~0').replace(/\//g, '~1');
+  const text = (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) ? input.toString('utf8') : String(input);
   const map = Object.create(null);
   const lines = text.split('\n');
   const lineStart = new Array(lines.length + 1);

package/lib/js-compiler.js

@@ -1610,8 +1610,14 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
       boolFn._hybridFactory = (R, E) => hybridFactory(...closureValues, R, E)
     } catch {}
 
-    // Store source for standalone compilation (includes regex inline for file output)
-    const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+    // Store source for standalone compilation. Regex declarations are NOT
+    // inlined into the body: they are carried by _closures and the emitters
+    // declare them once at load scope. Inlining them here put a
+    // `const _reN=__ataSafeRe(...)` inside the emitted function, which
+    // shadowed the module-scope binding and recompiled the pattern on every
+    // call, 25x on a schema with one pattern.
+    const emitHelpers = ctx.helperCode.filter((c) => !/^const _re\d+=(?:__ataSafeRe|new RegExp)\(/.test(c))
+    const helperStr = emitHelpers.length ? emitHelpers.join('\n  ') + '\n  ' : ''
     boolFn._source = helperStr + body
     boolFn._preambleSource = preambleStr
     boolFn._preambleGuard = guardStr
@@ -3219,6 +3225,110 @@ function childPathDynExpr(parentExpr, indexExpr) {
   return `${parentExpr}+'/'+${indexExpr}`
 }
 
+// unevaluated* differs from additionalProperties/items only through
+// annotations contributed by in-place applicators at the same schema object.
+// When every applicator subschema is provably free of the annotating keywords
+// for that kind, the keyword is exactly its plain counterpart, and the error
+// generators can emit real detail for it instead of declining. `required`
+// inside a then-branch annotates nothing, which is precisely the shape a
+// config schema has; a then-branch carrying `properties` does, and stays
+// declined. `not` never keeps its annotations, so it is skipped. A reference
+// or dependency keyword makes the node ineligible outright: resolving what
+// they might contribute is not this function's job.
+// Collects what an in-place applicator subschema can contribute: property
+// names into `names`, and the deepest tuple prefix it may evaluate into
+// `state.prefix`. Returns false when the contribution cannot be bounded
+// (patternProperties, additionalProperties, a reference, item schemas, and so
+// on), which makes the node ineligible outright.
+function unevalContributions (sub, kind, names, state, depth) {
+  if (depth > 24) return false
+  if (sub === true || sub === false) return true
+  if (typeof sub !== 'object' || sub === null) return false
+  if (kind === 'props') {
+    if (sub.patternProperties !== undefined || sub.additionalProperties !== undefined || sub.unevaluatedProperties !== undefined) return false
+    if (sub.properties !== undefined) {
+      if (typeof sub.properties !== 'object' || sub.properties === null) return false
+      for (const k of Object.keys(sub.properties)) names.add(k)
+    }
+  } else {
+    if (sub.items !== undefined || sub.additionalItems !== undefined || sub.contains !== undefined || sub.unevaluatedItems !== undefined) return false
+    if (sub.prefixItems !== undefined) {
+      if (!Array.isArray(sub.prefixItems)) return false
+      if (sub.prefixItems.length > state.prefix) state.prefix = sub.prefixItems.length
+    }
+  }
+  if (sub.$ref !== undefined || sub.$dynamicRef !== undefined || sub.$recursiveRef !== undefined) return false
+  if (sub.dependentSchemas !== undefined || sub.dependencies !== undefined) return false
+  for (const k of ['allOf', 'anyOf', 'oneOf']) {
+    if (sub[k] !== undefined) {
+      if (!Array.isArray(sub[k])) return false
+      for (const b of sub[k]) if (!unevalContributions(b, kind, names, state, depth + 1)) return false
+    }
+  }
+  for (const k of ['if', 'then', 'else']) {
+    if (sub[k] !== undefined && !unevalContributions(sub[k], kind, names, state, depth + 1)) return false
+  }
+  return true
+}
+
+// A contribution that names only what the node's own adjacent keywords
+// already evaluate unconditionally changes nothing: a key in the node's own
+// `properties` is evaluated whether or not the branch that also names it
+// passes, and a branch prefix no longer than the node's own is covered
+// position for position. Anything beyond those bounds is conditional
+// evaluation the plain counterpart cannot express, and the node stays with
+// the interpreted engine.
+function unevalLocalOk (node, key) {
+  if (node[key] !== false) return false
+  if (node.$ref !== undefined || node.$dynamicRef !== undefined || node.$recursiveRef !== undefined) return false
+  if (node.dependentSchemas !== undefined || node.dependencies !== undefined) return false
+  const kind = key === 'unevaluatedProperties' ? 'props' : 'items'
+  if (kind === 'props' && node.patternProperties !== undefined) return false
+  if (kind === 'items' && node.contains !== undefined) return false
+  const names = new Set()
+  const state = { prefix: 0 }
+  for (const k of ['allOf', 'anyOf', 'oneOf']) {
+    if (node[k] !== undefined) {
+      if (!Array.isArray(node[k])) return false
+      for (const b of node[k]) if (!unevalContributions(b, kind, names, state, 0)) return false
+    }
+  }
+  for (const k of ['if', 'then', 'else']) {
+    if (node[k] !== undefined && !unevalContributions(node[k], kind, names, state, 0)) return false
+  }
+  if (kind === 'props') {
+    const own = node.properties && typeof node.properties === 'object' ? node.properties : {}
+    for (const n of names) if (!Object.prototype.hasOwnProperty.call(own, n)) return false
+  } else {
+    const ownPrefix = Array.isArray(node.prefixItems) ? node.prefixItems.length
+      : (Array.isArray(node.items) ? node.items.length : 0)
+    if (node.items !== undefined && !Array.isArray(node.items)) { /* all evaluated; any prefix is covered */ }
+    else if (state.prefix > ownPrefix) return false
+  }
+  return true
+}
+
+// Every occurrence in the document must qualify or the generator declines the
+// whole schema, exactly as the string scan it replaces did. The walk is
+// generic and may visit data positions (an enum value, say); judging those is
+// harmless, since a data node that fails the test only makes the answer more
+// conservative and the generators never read data positions as schemas.
+function unevalAllProvablyLocal (root) {
+  const seen = new Set()
+  const stack = [root]
+  while (stack.length) {
+    const n = stack.pop()
+    if (n === null || typeof n !== 'object' || seen.has(n)) continue
+    seen.add(n)
+    if (!Array.isArray(n)) {
+      if (n.unevaluatedProperties !== undefined && !unevalLocalOk(n, 'unevaluatedProperties')) return false
+      if (n.unevaluatedItems !== undefined && !unevalLocalOk(n, 'unevaluatedItems')) return false
+    }
+    for (const k of Array.isArray(n) ? n : Object.values(n)) stack.push(k)
+  }
+  return true
+}
+
 // Detect simple prefix patterns like "^x-", "^_", "^prefix" and generate fast charCodeAt checks
 // Returns a JS expression string or null if pattern is too complex
 function fastPrefixCheck(pattern, keyVar) {
@@ -3267,10 +3377,12 @@ function genCharCodeSwitch(keys, v) {
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
 function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts) {
-  // Bail on unevaluated keywords — error codegen doesn't support them yet
+  // unevaluated* is generated only where it is provably its plain counterpart
+  // (see unevalLocalOk); any occurrence that is not keeps the whole schema on
+  // the interpreted engine's error path, exactly as before.
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
-    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+    if ((s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) && !unevalAllProvablyLocal(schema)) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -3409,7 +3521,11 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       })
     }
     return fn
-  } catch {
+  } catch (e) {
+    // Declining here is safe (the interpreter takes over) but silent, which
+    // is how every past regression in this file hid. The env hook makes the
+    // decline visible without changing behavior.
+    if (process.env.ATA_DEBUG_ERRGEN) console.error('error codegen declined:', e.message)
     return null
   }
 }
@@ -3774,6 +3890,52 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
+  // unevaluatedProperties: false, on a node where it is provably its plain
+  // counterpart (the bail above guaranteed that for every occurrence). With
+  // additionalProperties present everything is evaluated and there is nothing
+  // to emit. The error keeps the keyword's own identity: the interpreted
+  // engine reports these as unevaluatedProperties with the key named, and the
+  // two engines are pinned to identical output.
+  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined) {
+    const allowedU = Object.keys(schema.properties || {}).map(k => `${JSON.stringify(k)}`).join(',')
+    const ui = ctx.varCounter++
+    const upSp = `${schemaPrefix}/unevaluatedProperties`
+    const upLit = buildErrorLiteral({ keyword: 'unevaluatedProperties', schemaPath: upSp, sourceMap: ctx.sourceMap })
+    const patChecksU = []
+    for (const pat of Object.keys(schema.patternProperties || {})) {
+      const pattern = JSON.stringify(pat)
+      if (!ctx.regExpMap.has(pattern)) {
+        const ri = ctx.varCounter++
+        ctx.regExpMap.set(pattern, ri)
+        if (patternIsSafe(pat)) {
+          ctx.helperCode.push(`const _re${ri}=__ataSafeRe(${pattern})`)
+          ctx.usesSafeRe = true
+        } else {
+          ctx.helperCode.push(`const _re${ri}=new RegExp(${pattern})`)
+        }
+      }
+      patChecksU.push(`_re${ctx.regExpMap.get(pattern)}.test(_k${ui}[_i])`)
+    }
+    const isUneval = patChecksU.length ? `!_a${ui}.has(_k${ui}[_i])&&!(${patChecksU.join('||')})` : `!_a${ui}.has(_k${ui}[_i])`
+    const innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++){if(${isUneval}){_e.push({code:'${upLit.codeStr}',keyword:'unevaluatedProperties',instancePath:${pathExpr||'""'},schemaPath:'${upSp}'${ordinalField(ctx, `${upSp}`)},params:{unevaluatedProperty:_k${ui}[_i]},message:'must NOT have unevaluated properties',docUrl:'${upLit.docUrl}'${upLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
+    lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
+  }
+
+  // unevaluatedItems: false under the same rule. The interpreted engine
+  // reports one error for the array with the first unevaluated position as
+  // the limit; with adjacent `items` everything is evaluated. The draft-07
+  // array form of items acts as the prefix.
+  if (schema.unevaluatedItems === false) {
+    const itemsIsPrefix = Array.isArray(schema.items)
+    const allEval = schema.items !== undefined && !itemsIsPrefix
+    if (!allEval) {
+      const plen = itemsIsPrefix ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
+      const uiSp = `${schemaPrefix}/unevaluatedItems`
+      const uiLit = buildErrorLiteral({ keyword: 'unevaluatedItems', schemaPath: uiSp, sourceMap: ctx.sourceMap })
+      lines.push(`if(Array.isArray(${v})&&${v}.length>${plen}){_e.push({code:'${uiLit.codeStr}',keyword:'unevaluatedItems',instancePath:${pathExpr||'""'},schemaPath:'${uiSp}'${ordinalField(ctx, `${uiSp}`)},params:{limit:${plen}},message:'must NOT have more than ${plen} items',docUrl:'${uiLit.docUrl}'${uiLit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+    }
+  }
+
   // dependentRequired
   if (schema.dependentRequired) {
     const drSp = `${schemaPrefix}/dependentRequired`
@@ -4004,10 +4166,10 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 // Avoids double-pass (jsFn → false → errFn runs same checks again).
 // Uses type-aware optimizations: after type check passes, skip guards.
 function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
-  // Bail on unevaluated keywords — combined codegen doesn't support them yet
+  // Same provably-local rule as the error generator above.
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
-    if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
+    if ((s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) && !unevalAllProvablyLocal(schema)) return null
     // Bail on self-referencing schemas — combined codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
     // Defs on a $ref cycle compile as named functions in the boolean and
@@ -4403,6 +4565,39 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
   }
 
+  // unevaluatedProperties: false where it is provably additionalProperties
+  // (the entry bail guaranteed that), keeping the keyword's own identity so
+  // the two engines report the same error.
+  if (schema.unevaluatedProperties === false && schema.additionalProperties === undefined && !schema.patternProperties) {
+    const propKeysU = Object.keys(schema.properties || {})
+    const ui = ctx.varCounter++
+    const failU = fail('unevaluatedProperties', 'unevaluatedProperties', `{unevaluatedProperty:_k${ui}[_i]}`, "'must NOT have unevaluated properties'")
+    let innerU
+    if (propKeysU.length === 0) {
+      innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++){${failU}}`
+    } else if (propKeysU.length <= 8) {
+      const checksU = propKeysU.map(k => `_k${ui}[_i]!==${JSON.stringify(k)}`).join('&&')
+      innerU = `const _k${ui}=Object.keys(${v});for(let _i=0;_i<_k${ui}.length;_i++)if(${checksU}){${failU}}`
+    } else {
+      const allowedU = propKeysU.map(k => JSON.stringify(k)).join(',')
+      innerU = `const _k${ui}=Object.keys(${v});const _a${ui}=new Set([${allowedU}]);for(let _i=0;_i<_k${ui}.length;_i++)if(!_a${ui}.has(_k${ui}[_i])){${failU}}`
+    }
+    lines.push(isObj ? `{${innerU}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${innerU}}`)
+  }
+
+  // unevaluatedItems: false under the same rule: one error for the array,
+  // the first uncovered position as the limit. Adjacent schema-form `items`
+  // evaluates everything; the draft-07 array form acts as the prefix.
+  if (schema.unevaluatedItems === false) {
+    const itemsIsPrefixC = Array.isArray(schema.items)
+    const allEvalC = schema.items !== undefined && !itemsIsPrefixC
+    if (!allEvalC) {
+      const plenC = itemsIsPrefixC ? schema.items.length : (Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0)
+      const failI = fail('unevaluatedItems', 'unevaluatedItems', `{limit:${plenC}}`, `'must NOT have more than ${plenC} items'`)
+      lines.push(`if(Array.isArray(${v})&&${v}.length>${plenC}){${failI}}`)
+    }
+  }
+
   // dependentRequired
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
@@ -4807,4 +5002,4 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
   // not → contributes nothing (spec: annotations from not are discarded)
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, AJV_MESSAGES }
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, AJV_MESSAGES }