ata-validator 1.26.0 → 1.27.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 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

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

@@ -279,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 ||
@@ -307,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) {
@@ -336,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};`;
@@ -385,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) {
@@ -419,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' }
       );
     }
   }
@@ -501,7 +560,8 @@ function toStandaloneModule(validator, opts) {
     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, or an additionalProperties schema makes it someone else\'s decision. The module ships without a parse export; validate and strip with the runtime Validator instead.'
+        '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' }
       );
     }
   }

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}}`)
     }
   }
@@ -2251,7 +2258,7 @@ function genCode(schema, v, lines, ctx, knownType) {
     for (let i = 0; i < ppEntries.length; i++) {
       const [, sub] = ppEntries[i]
       const subLines = []
-      genCode(sub, `_ppv`, subLines, ctx)
+      genCode(sub, `_ppv${pi}`, subLines, ctx)
       subChecks.push(subLines.join(';'))
     }
 
@@ -2269,7 +2276,7 @@ function genCode(schema, v, lines, ctx, knownType) {
       let apCheck = null
       if (apSchema) {
         const apLines = []
-        genCode(apSchema, '_apv', apLines, ctx)
+        genCode(apSchema, `_apv${pi}`, apLines, ctx)
         apCheck = apLines.join(';')
       }
       lines.push(`${guard}{for(const ${kVar} in ${v}){`)
@@ -2304,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;const _ppv=${v}[${kVar}];${subChecks[i]}}`)
+          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 = apCheck !== null ? `const _apv=${v}[${kVar}];${apCheck}` : `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('')
@@ -2348,7 +2355,7 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
       }
       for (let i = 0; i < ppEntries.length; i++) {
-        lines.push(`if(${matchers[i].check}){const _ppv=${v}[${kVar}];${subChecks[i]}}`)
+        lines.push(`if(${matchers[i].check}){const _ppv${pi}=${v}[${kVar}];${subChecks[i]}}`)
       }
       lines.push(`}}`)
     }

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.26.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.26.0",
-    "@ata-validator/native-darwin-x64": "1.26.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.26.0",
-    "@ata-validator/native-linux-arm64-musl": "1.26.0",
-    "@ata-validator/native-linux-x64-gnu": "1.26.0",
-    "@ata-validator/native-linux-x64-musl": "1.26.0",
-    "@ata-validator/native-win32-x64": "1.26.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"