ata-validator 1.60.0 → 1.61.1

package/lib/js-compiler-errors.js

@@ -9,7 +9,7 @@ const { compileFunction } = require('./compile-fn')
 // the first call that compiles errors. Everything here was written as part
 // of js-compiler.js and reads its helpers from that module's _internal.
 const core = require('./js-compiler')
-const { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag } = core._internal
+const { ownHead, plainFlag, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag } = core._internal
 
 
 function emitPtrEsc(ctx) {
@@ -1017,7 +1017,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         const bodyLines = []
         const outerStack = ctx.refStack
         ctx.refStack = new Set()
-        try { genCodeE(ctx.rootE, 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER) } finally { ctx.refStack = outerStack }
+        try { isolatedE(ctx, () => genCodeE(ctx.rootE, 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER)) } finally { ctx.refStack = outerStack }
         let body = bodyLines.join('\n  ')
         body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
         if (body.includes(SP_PLACEHOLDER)) throw DECLINE
@@ -1056,7 +1056,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
           // string it starts. One left anywhere else declines, rather than
           // emitting a path the placeholder stands in for.
           const bodyLines = []
-          genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER)
+          isolatedE(ctx, () => genCodeE(ctx.rootDefs[defName], 'd', '_p', bodyLines, ctx, SP_PLACEHOLDER))
           let body = bodyLines.join('\n  ')
           body = body.split(`'${SP_PLACEHOLDER}`).join(`_sp+'`).split(`"${SP_PLACEHOLDER}`).join(`_sp+"`)
           if (body.includes(SP_PLACEHOLDER)) throw DECLINE
@@ -1321,12 +1321,26 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     // This function walks every node of a document that failed anywhere, so on a
     // large array the clean items were each paying for a key array.
     const gateChecks = patChecks.map((c) => c.split(`_k${ci}[_i]`).join(`_f${ci}`))
-    const gateTest = gateChecks.length ? `!_a${ci}.has(_f${ci})&&!(${gateChecks.join('||')})` : `!_a${ci}.has(_f${ci})`
+    // The gate names the declared keys outright when there are few of them: a
+    // Set lookup per key of every object of a document that failed somewhere
+    // was a third of the error path on a ten-item order (31% of the samples
+    // on that one line); three string compares are not.
+    const declaredNames = Object.keys(schema.properties || {})
+    const notDeclared = declaredNames.length > 0 && declaredNames.length <= 8
+      ? declaredNames.map((k) => `_f${ci}!==${JSON.stringify(k)}`).join('&&')
+      : `!_a${ci}.has(_f${ci})`
+    const gateTest = gateChecks.length ? `${notDeclared}&&!(${gateChecks.join('||')})` : notDeclared
     const detail = `const _k${ci}=Object.keys(${v});for(let _i=0;_i<_k${ci}.length;_i++){if(${isAdditional}){_e.push({code:'${apLit.codeStr}',keyword:'additionalProperties',instancePath:${pathExpr||'""'},schemaPath:'${apSp}'${ordinalField(ctx, `${apSp}`)},params:{additionalProperty:_k${ci}[_i]},message:'must NOT have additional properties',docUrl:'${apLit.docUrl}'${apLit.frame}});if(!_all)return{valid:false,errors:_e}}}`
     // The name set is built once per call of the error function, not at every
     // object it checks: on a list of 1723 tokens it was 1723 Sets.
     ctx.helperCode.push(`const _a${ci}=new Set([${allowed}])`)
-    const inner = `let _x${ci}=0;${ownHead(ctx, v, `_f${ci}`, 'const')}{if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
+    // The walk reads the node's plain-object flag where one is in scope
+    // (withPlain declared it for this value) instead of reading the prototype
+    // again for every object: that read was a tenth of the error path.
+    const stdHead = ownHead(ctx, v, `_f${ci}`, 'const')
+    const pk = plainFlag(ctx, v)
+    const head = pk ? `for(const _f${ci} in ${v})if(!${pk}&&!_hop.call(${v},_f${ci}))continue;else ` : stdHead
+    const inner = `let _x${ci}=0;${head}{if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -1368,12 +1382,18 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const sp = schemaPrefix+'/properties/'+ptrSeg(key)
       const from = lines.length
       // A value that is undefined is not checked (see the verdict generator).
-      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${v}[${JSON.stringify(key)}]!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
+      // The value is read once into a local and the subschema checks that:
+      // read as `${v}[key]` at every keyword below, a nested property was
+      // loaded again for each check (a getter may answer differently, so V8
+      // cannot merge the loads), and a rejected ten-item order cost 378 ns on
+      // this collector against 105 on the one-pass function.
+      const child = `_c${ctx.varCounter++}`
+      lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){const ${child}=${v}[${JSON.stringify(key)}];if(${child}!==undefined&&${ownKeyExpr(ctx, v, key)}){`)
       // A large subschema as a function of its own (emitPropFnE); false means inline.
-      if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)) {
-        genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)
+      if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, child, childPath, lines, ctx, sp)) {
+        genCodeE(prop, child, childPath, lines, ctx, sp)
       }
-      lines.push(`}`)
+      lines.push(`}}`)
       countInlineE(lines, from, ctx)
     }
   }
@@ -2008,6 +2028,10 @@ const NOT_VALIDATING = new Set(['$schema', '$id', '$anchor', '$comment', '$defs'
 function typeMismatchRest(schema, types) {
   const drop = new Set(['type', 'enum', 'const', 'anyOf', 'oneOf'])
   for (const t of types) for (const k of (TYPE_KEYWORDS[t] || [])) drop.add(k)
+  // A built-in format is written for strings only (`typeof v==='string'&&`
+  // off the string path), so for a value that failed `type: string` it can
+  // never fire: carried here it was dead code in every module that checks one.
+  if (types.includes('string') && typeof schema.format === 'string' && FORMAT_CODEGEN[schema.format]) drop.add('format')
   // A non-integer number reaches the type block already (numberToo).
   let rest = null
   for (const k of Object.keys(schema)) {
@@ -2080,11 +2104,26 @@ function propFnCandidateE (prop, ctx, schemaPrefix) {
   try { size = JSON.stringify(prop).length } catch { return false }
   return size >= SPLIT_C_SCHEMA || ((ctx.fnBytesE || 0) > SPLIT_C_BUDGET && size >= SPLIT_C_SMALL)
 }
+// A body that becomes a function of its own (a hoisted property, a
+// definition, the root through `$ref: "#"`) takes the parameter name `d` as
+// the node being written does; the ordinary-object flags that node declared
+// for its own `d` (withPlain) are out of scope in the helper and must not be
+// read there, as js-compiler's genIsolated keeps them out of the verdict's
+// helpers. Found by the SchemaStore differential: 24 schemas threw
+// `ReferenceError: _pk0 is not defined` from validate().
+function isolatedE (ctx, run) {
+  const outerPlain = ctx.plainOf
+  const outerReuse = ctx.plainReuse
+  ctx.plainOf = undefined
+  ctx.plainReuse = undefined
+  try { return run() } finally { ctx.plainOf = outerPlain; ctx.plainReuse = outerReuse }
+}
+
 function emitPropFnE (prop, v, pathExpr, lines, ctx, schemaPrefix) {
   const outerBytes = ctx.fnBytesE
   ctx.fnBytesE = 0
   const bodyLines = []
-  try { genCodeE(prop, 'd', '_p', bodyLines, ctx, schemaPrefix) } finally { ctx.fnBytesE = outerBytes }
+  try { isolatedE(ctx, () => genCodeE(prop, 'd', '_p', bodyLines, ctx, schemaPrefix)) } finally { ctx.fnBytesE = outerBytes }
   if (bodyLines.length === 0) return false
   const body = bodyLines.join('\n  ')
   if (body.includes(SP_PLACEHOLDER)) return false

package/lib/js-compiler.js

@@ -105,8 +105,8 @@ function apMembershipCheck (ctx, names, v) {
     }
   }
   // With nothing declared every key is additional; `if()` would not parse.
-  if (names.length === 0) return `for(var _k in ${v})if(${ownFail(ctx, v)})return false`
-  return `for(var _k in ${v})if(${names.map((k) => `_k!==${JSON.stringify(k)}`).join('&&')}&&${ownFail(ctx, v)})return false`
+  if (names.length === 0) return closedKeyLoop(ctx, v, `if(${ownFail(ctx, v)})return false`)
+  return closedKeyLoop(ctx, v, `if(${names.map((k) => `_k!==${JSON.stringify(k)}`).join('&&')}&&${ownFail(ctx, v)})return false`)
 }
 
 function emitDeq(ctx) {
@@ -946,12 +946,26 @@ const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '_
 // every module that asked about presence at all, about a sixth of a small
 // schema's compiled module.
 const OWN_HELPER_CODE = {
-  _PN: 'const _PN=({}).__proto__===Object.prototype;const _OP=Object.prototype;const _gp=Object.getPrototypeOf;',
+  // Whether the plain-object test reads `__proto__` (V8: the accessor is
+  // the cheaper read) or Object.getPrototypeOf (JavaScriptCore, and Bun's
+  // ahead-of-time compiler, where the accessor is a slow path: 212 against
+  // 127 ns on a ten-item order). Decided once, where the module loads.
+  // The plain-object test reads `__proto__` on V8, where the accessor is the
+  // cheaper read, and Object.getPrototypeOf on JavaScriptCore, where the
+  // accessor is a slow path under Bun's compiler (212 against 127 ns on a
+  // ten-item order). Decided per target engine when the code is generated;
+  // the V8 form still tests the accessor at load, since Deno removes it.
+  get _PN () { return TARGET_ENGINE !== 'v8' ? 'const _PN=false;const _OP=Object.prototype;const _gp=Object.getPrototypeOf;' : 'const _PN=({}).__proto__===Object.prototype;const _OP=Object.prototype;const _gp=Object.getPrototypeOf;' },
   _hop: 'const _hop=Object.prototype.hasOwnProperty;',
   _h: 'function _h(o,k){return _hop.call(o,k)}',
   _ok: 'function _ok(o,k){return (_PN?o.__proto__:_gp(o))===_OP||_hop.call(o,k)}',
   _hall: 'function _hall(o,ks){for(let i=0;i<ks.length;i++)if(!_hop.call(o,ks[i]))return false;return true}',
   _nk: 'function _nk(o,n){return (_PN?o.__proto__:_gp(o))===_OP||Object.keys(o).length!==n}',
+  // The own-key count of a closed object, and the walk over its keys, take
+  // the form of the engine the code is generated for (targetEngine below):
+  // for...in on V8, where it is the cheaper form, Object.keys on
+  // JavaScriptCore, where for...in is a slow path. One form is written, so
+  // neither engine pays for a branch per object.
 }
 const OWN_HELPER_DEPS = { _h: ['_hop'], _ok: ['_PN', '_hop'], _hall: ['_hop'], _nk: ['_PN'] }
 function useOwnHelper (ctx, name) {
@@ -1032,7 +1046,7 @@ function withPlain (schema, v, lines, ctx, run) {
 }
 // The same test at run time, for the closure compiler.
 const _hop = Object.prototype.hasOwnProperty
-const _PN = ({}).__proto__ === Object.prototype
+const _PN = typeof Bun === 'undefined' && ({}).__proto__ === Object.prototype // JavaScriptCore reads the prototype through Object.getPrototypeOf, see the _PN declaration
 // One hasOwnProperty call. From 1.31.2 to 1.33.0 this first tested the name
 // against Object.prototype's names, then `in`, then read the prototype through
 // the __proto__ accessor, on every property of every object the eval-free
@@ -3644,7 +3658,9 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       lines.push(`if(${reqChecks.join('||')})return false`)
     }
     // On an object with another prototype the typed ones may be inherited.
-    if (typed.length > 0) {
+    // Where the node's key set is proved exactly (exactKeysNode), the typed
+    // names are own by that proof and the list is not needed.
+    if (typed.length > 0 && !exactKeysNode(schema, ctx)) {
       useOwnHelper(ctx, '_hall')
       // Read directly: the object type is already established here, and a
       // flag declared for this alone costs more than it saves. The list is
@@ -3677,7 +3693,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
       if (allRequired && propCount > 0) {
         // Adaptive: for-in for <=15 keys (V8 fast path), Object.keys for >15
         if (propCount <= 15) {
-          lines.push(`var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`)
+          lines.push(exactKeys(ctx, v, knownKeys))
         } else {
           lines.push(`if(Object.keys(${v}).length!==${propCount})return false`)
         }
@@ -3817,7 +3833,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
     const allRequired = !!schema.required && declaredKeys.every((k) => req.has(k))
     const inner = allRequired
       ? (propCount <= 15
-          ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`
+          ? exactKeys(ctx, v, declaredKeys)
           : `if(Object.keys(${v}).length!==${propCount})return false`)
       : apMembershipCheck(ctx, Object.keys(schema.properties || {}), v)
         _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
@@ -4833,7 +4849,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
         if (!earlyKeyCount) {
           // Adaptive: for-in for <=15 keys, Object.keys for >15
           inner = propCount <= 15
-            ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`
+            ? exactKeys(ctx, v, knownKeys)
             : `if(Object.keys(${v}).length!==${propCount})return false`
                       _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
         }
@@ -5647,6 +5663,69 @@ function ownFail (ctx, v, k = '_k') {
   useOwnHelper(ctx, '_ok')
   return `_ok(${v},${k})`
 }
+// The engine the generated code is written for. The runtime compiles for the
+// engine it runs on; `ata build --target bun` and the plugin's Bun entry write
+// modules for JavaScriptCore (setTargetEngine). The two engines want opposite
+// forms for walking a closed object's keys: for...in is the cheaper form on
+// V8 and a slow path on JavaScriptCore (a ten-item order under Bun's
+// ahead-of-time compiler: 227 against 108 ns), and Object.keys the reverse. A
+// branch per object on a load-time flag cost V8 5 to 7% on small schemas, so
+// one form is written, chosen here.
+// 'jsc-aot' is JavaScriptCore under Bun's ahead-of-time compiler, where the
+// cheapest proof that a closed object holds exactly its declared keys is to
+// read Object.keys once and compare it with the declared list in order (the
+// order JSON.parse gives), falling back to a membership walk when the order
+// differs. On Bun's JIT that form lost 5 to 15 ns a ten-item order to the
+// plain count, and under the compiler it won 4 to 10, which brought the
+// module level with Bun's own validate<T>; so it is its own target, the one
+// `ata build --target bun` writes for.
+let TARGET_ENGINE = typeof Bun !== 'undefined' ? 'jsc' : 'v8'
+const ENGINES = ['v8', 'jsc', 'jsc-aot']
+function setTargetEngine (engine) {
+  const prev = TARGET_ENGINE
+  if (ENGINES.includes(engine)) TARGET_ENGINE = engine
+  else if (engine === null || engine === undefined) TARGET_ENGINE = typeof Bun !== 'undefined' ? 'jsc' : 'v8'
+  else throw new Error(`unknown target engine ${JSON.stringify(engine)}; expected "v8", "jsc" or "jsc-aot"`)
+  return prev
+}
+function targetEngine () { return TARGET_ENGINE }
+// `var _n=<own key count of v>;`
+function keyCount (v) {
+  return TARGET_ENGINE !== 'v8' ? `var _n=Object.keys(${v}).length;` : `var _n=0;for(var _k in ${v})_n++;`
+}
+// Whether this node's check under the compiler is the exact key list: a
+// closed object, no pattern properties, every declared key required, at
+// most fifteen of them, not one the removing verdict rewrites. The proof then
+// covers presence and ownership of the typed keys too.
+function exactKeysNode (schema, ctx) {
+  if (TARGET_ENGINE !== 'jsc-aot') return false
+  if (schema.additionalProperties !== false || schema.patternProperties || !schema.properties || !schema.required) return false
+  if (ctx.removeNodes && ctx.removeNodes.has(schema)) return false
+  const keys = Object.keys(schema.properties)
+  if (keys.length === 0 || keys.length > 15) return false
+  const req = new Set(schema.required)
+  return keys.every((k) => req.has(k))
+}
+// The check that a closed object whose declared keys are all required holds
+// exactly those keys: the count, compared against the own-key count when it
+// is off (ownCountOff), or under the compiler the key list itself.
+function exactKeys (ctx, v, keys) {
+  const n = keys.length
+  // The plain-object flag is asked for only on the counting form: asking marks
+  // it used, and the exact key list needs no prototype read at all.
+  if (TARGET_ENGINE !== 'jsc-aot' || n === 0) return `${keyCount(v)}if(_n!==${n}&&${ownCountOff(ctx, v, n, plainFlag(ctx, v))})return false`
+  const i = ctx.varCounter++
+  const names = keys.map((k) => JSON.stringify(k))
+  const inOrder = names.map((k, j) => `_ks${i}[${j}]===${k}`).join('&&')
+  const member = names.map((k) => `_k!==${k}`).join('&&')
+  return `{const _ks${i}=Object.keys(${v});if(_ks${i}.length!==${n})return false;if(!(${inOrder}))for(let _i=0;_i<${n};_i++){const _k=_ks${i}[_i];if(${member})return false}}`
+}
+// A loop over the keys of a closed object, `body` reading each as `_k`.
+function closedKeyLoop (ctx, v, body) {
+  if (TARGET_ENGINE === 'v8') return `for(var _k in ${v}){${body}}`
+  const i = ctx.varCounter++
+  return `{var _ks${i}=Object.keys(${v});for(var _ki${i}=0;_ki${i}<_ks${i}.length;_ki${i}++){var _k=_ks${i}[_ki${i}];${body}}}`
+}
 // For a key count that came out wrong: whether it is wrong counting own keys
 // only. An ordinary object's count stands; any other object is counted again.
 // A oneOf of closed objects fails its other branches here on every value, so
@@ -5677,10 +5756,10 @@ function ownHead (ctx, v, k = '_k', kind = 'var') {
 // Generate a charCodeAt(0)-based switch tree for fast key validation.
 // V8 compiles switch to jump tables — O(1) dispatch vs O(n) chain.
 function genCharCodeSwitch(keys, v, ctx) {
-  if (keys.length === 0) return `for(var _k in ${v})if(${ownFail(ctx, v)})return false`
+  if (keys.length === 0) return closedKeyLoop(ctx, v, `if(${ownFail(ctx, v)})return false`)
   if (keys.length <= 3) {
     // Small set: simple chain is faster than switch overhead
-    return `for(var _k in ${v})if(${keys.map(k => `_k!==${JSON.stringify(k)}`).join('&&')}&&${ownFail(ctx, v)})return false`
+    return closedKeyLoop(ctx, v, `if(${keys.map(k => `_k!==${JSON.stringify(k)}`).join('&&')}&&${ownFail(ctx, v)})return false`)
   }
 
   // Group keys by first charCode
@@ -5697,7 +5776,7 @@ function genCharCodeSwitch(keys, v, ctx) {
     cases += `case ${cc}:if(${cond})continue;break;`
   }
 
-  return `for(var _k in ${v}){switch(_k.charCodeAt(0)){${cases}default:break}if(${ownFail(ctx, v)})return false}`
+  return closedKeyLoop(ctx, v, `switch(_k.charCodeAt(0)){${cases}default:break}if(${ownFail(ctx, v)})return false`)
 }
 
 // The verdict form of genUnevaluatedDynamicC: the same set, built the same
@@ -6036,10 +6115,10 @@ function compileToJSCodegenWithErrors (schema, schemaMap, userFormats, sourceOpt
 function compileToJSCombined (schema, VALID_RESULT, schemaMap, userFormats, opts) { return errorsModule().compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts) }
 
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, expandedChars, AJV_MESSAGES, _setCodeBudget, _helperSources: { DEQ_HELPER, PTR_ESC_HELPER, OWN_HELPER_CODE } }
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, setTargetEngine, targetEngine, collectEvaluated, unevalContributions, expandedChars, AJV_MESSAGES, _setCodeBudget, _helperSources: { DEQ_HELPER, PTR_ESC_HELPER, OWN_HELPER_CODE } }
 // For tests: the dynamic-scope unrolling, to hold its output to the interpreter.
 Object.defineProperty(module.exports, '_expandDynamicScopes', { value: expandDynamicScopes, enumerable: false })
 // For tests/test_custom_keyword_codegen.js, which holds these copies to the interpreter's.
 Object.defineProperty(module.exports, '_kwTypeBits', { value: { kwTypeBit, kwDataBits, KW_T_ANY }, enumerable: false })
 
-module.exports._internal = { ownHead, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag }
+module.exports._internal = { ownHead, plainFlag, hasConstraints, assertEmitted, prepareForCodegen, sharedCodegenGate, codegenSafe, isSimplePN, hasUnresolvableRef, needsBaseTracking, _cpLen, sharedRt, DECLINE, bindRt, compileSafe, emitGuardState, withPlain, REF_NEUTRAL_SIBLINGS, resolveCrossSchemaRef, enumCondition, enumOperand, emitDeq, emitConstant, ownGuard, ownKeyExpr, multipleOfBad, compilePatternInline, useSafeEngine, reFlags, FORMAT_CODEGEN, PROTO_NAMES, setOwn, nestedGenCode, compileToJSCodegen, SKIP_VALUE_KEYS, skipString, CYCLE_DEPTH, cyclicDefNames, sharedDefNames, reFlagArg, hoistOnce, PTR_ESC_HELPER, unevalContributions, emitUq, uqSources, safeReClosure, fastPrefixCheck, replaceTopLevel, refTargetFor, genCode, addLocalAnnotations, addTopApplicatorAnnotations, protoIs, ANNOT_APPLICATORS, SIZE_SKIPS, emitRootGuard, emitGuardedRun, keyLoopEligible, SAME_KEYS_HELPER, seqTag }

package/lib/json-rejections.js

@@ -0,0 +1,159 @@
+'use strict';
+
+// The rejection validateJSON() returns, and the position map behind an error's
+// frame in the JSON text. Apart from lib/rejections.js so that code with no
+// JSON entry point (validate() through a compiled wrapper) does not bundle it.
+
+const { needsOrdering, sortErrorsBySchemaOrder, attachRelated, _setPositionsFor } = require('./rejections');
+const { setDiagnosticSource: attachDiagnosticSource } = require('./diagnostic-source');
+
+// The rejection validateJSON returns. Everything the text path adds over
+// validate(data), the value tree enrichment needs, the position map, the
+// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
+// touches none of it. The JSON text is held here rather than read back off the
+// validator, so the result does not depend on what the instance does next.
+class LazyJsonRejection {
+  // `parsed`, when given, is the document the inner path parsed from
+  // `jsonStr` and validated, after defaults, coercion and removal: reading the
+  // errors uses it instead of parsing the text again, which on a 5 MB
+  // document was a third of what reading them cost.
+  constructor(result, jsonStr, self, enrich, parsed) {
+    this.valid = false;
+    this._result = result;
+    this._jsonStr = jsonStr;
+    this._self = self;
+    this._enrich = enrich;
+    this._cached = null;
+    this._parsed = parsed;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+}
+Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._cached !== null) return this._cached;
+    const self = this._self;
+    const enrich = this._enrich;
+    const jsonStr = this._jsonStr;
+    // Reading the inner errors realizes the inner lazy layer, if there was one.
+    const raw = this._result.errors || [];
+    if (!raw.length) { this._cached = raw; return raw; }
+
+    // The enrich pass plucks `received` from the value tree and the suggestion
+    // engine (required-typo, format hints, coercion nudges) walks it too.
+    let parsedData = this._parsed;
+    if (parsedData === undefined) {
+      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
+      // What was checked is the document after defaults, coercion and removal,
+      // so `received` has to come from that, as it does for validate(). A
+      // default that failed its own schema has no value in the text at all.
+      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    }
+
+    // Errors the inner path already enriched carry a `received` key: enrich()
+    // always sets one, even when there is no value to show. `code` is not a
+    // safe signal, because branch-collapse attaches codes to raw errors, and
+    // `docUrl` is not either, because the generated error functions stamp it
+    // on raw errors; taking it as the signal left those errors without
+    // `received` or a suggestion on the text path while validate() had both.
+    if (!raw[0] || !('received' in raw[0])) {
+      // Declaration order, as validate() applies it; the text path used to
+      // enrich in emission order.
+      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      // The position map waits for the first read of a frame (lib/enrich-error
+      // defineLazyFrames); until then reading the list costs the enrichment alone.
+      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
+      const enrichOpts = {
+        data: parsedData,
+        positions: null,
+        lazyPositions,
+        schemaPositions: self._schemaPositions,
+        schemaFile: self._source ? self._source.path : undefined,
+      };
+      const enriched = ordered.map((e) => enrich(e, enrichOpts));
+      if (enriched.length > 1) attachRelated(enriched);
+      attachDiagnosticSource(enriched, {
+        data: parsedData,
+        text: jsonStr,
+        // Read by the diagnostic renderer only, which resolves the same map.
+        get positions () { return lazyPositions(); },
+        schema: self._schemaObj,
+        mutatesInput: self._mutatesInput === true,
+      });
+      this._cached = enriched;
+      return enriched;
+    }
+
+    // Already enriched, so the frames are usually attached too. Only a gap in
+    // them is worth another walk of the document: resolving the map to discover
+    // there was nothing to fill cost a second full walk on every rejection.
+    if (raw.some((e) => e && !e.dataFrame)) {
+      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
+      if (positions) {
+        for (const e of raw) {
+          if (e && !e.dataFrame) {
+            const path = e.path != null ? e.path : (e.instancePath || '');
+            const p = positions[path];
+            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+          }
+        }
+        self._posCache.reset();
+      }
+    }
+    if (raw.length > 1) attachRelated(raw);
+    attachDiagnosticSource(raw, {
+      data: parsedData,
+      text: jsonStr,
+      schema: self._schemaObj,
+      mutatesInput: self._mutatesInput === true,
+    });
+    this._cached = raw;
+    return raw;
+  },
+});
+
+// The targeted position map for a list, built on the first call and shared
+// by every error's frame accessor (lib/enrich-error defineLazyFrames).
+function lazyPositionsFor (self, text, errors) {
+  let done = false;
+  let positions = null;
+  return () => {
+    if (done) return positions;
+    done = true;
+    positions = self._pos().targeted(text, wantedPointersFor(errors));
+    if (positions) self._posCache.reset();
+    return positions;
+  };
+}
+
+// The pointers a set of errors will ask the position map about. lib/enrich-error
+// looks up the error's own path, and for an additional or unevaluated property
+// the child pointer named in `params`, unescaped, which is the form it asks for.
+// The escaped form goes in too: including a pointer that is never read costs
+// nothing, and the cache answers anything outside this set from the full map
+// rather than reporting no position.
+function wantedPointersFor (errors) {
+  const wanted = new Set();
+  for (const e of errors) {
+    if (!e) continue;
+    const path = e.path != null ? e.path : (e.instancePath || '');
+    wanted.add(path);
+    if (e.instancePath != null && e.instancePath !== path) wanted.add(e.instancePath);
+    const params = e.params;
+    const named = params && (params.additionalProperty || params.unevaluatedProperty);
+    if (typeof named === 'string') {
+      wanted.add(path + '/' + named);
+      if (named.indexOf('~') !== -1 || named.indexOf('/') !== -1) {
+        wanted.add(path + '/' + named.replace(/~/g, '~0').replace(/\//g, '~1'));
+      }
+    }
+  }
+  return wanted;
+}
+
+_setPositionsFor(lazyPositionsFor);
+
+module.exports = { LazyJsonRejection };

package/lib/native-codes.js

@@ -0,0 +1,67 @@
+'use strict';
+
+// A module of its own so the browser build, which has no native engine
+// (lib/native-load.browser.js), maps it to lib/native-codes.browser.js and
+// carries no table for ordinals that never reach it.
+
+const { codeFor } = require('./error-codes');
+
+// The native engine reports its own `error_code` enum from include/ata.h as an
+// ordinal. Nothing outside the addon should ever see one: an error that came
+// from there carries the same public code and keyword as the same failure from
+// the JavaScript engines. Ordinals are positional, so this table follows the
+// enum's declaration order and `tests/test_native_error_codes.js` fails if the
+// two drift apart.
+const NATIVE_KEYWORDS = [
+  null,                     // 0 ok
+  '__parse__',              // 1 invalid_json
+  '__compile__',            // 2 invalid_schema
+  'type',                   // 3 type_mismatch
+  'required',               // 4 required_property_missing
+  'additionalProperties',   // 5 additional_property_not_allowed
+  'enum',                   // 6 enum_mismatch
+  'const',                  // 7 const_mismatch
+  'minimum',                // 8 minimum_violation
+  'maximum',                // 9 maximum_violation
+  'exclusiveMinimum',       // 10 exclusive_minimum_violation
+  'exclusiveMaximum',       // 11 exclusive_maximum_violation
+  'minLength',              // 12 min_length_violation
+  'maxLength',              // 13 max_length_violation
+  'pattern',                // 14 pattern_mismatch
+  'format',                 // 15 format_mismatch
+  'minItems',               // 16 min_items_violation
+  'maxItems',               // 17 max_items_violation
+  'uniqueItems',            // 18 unique_items_violation
+  'minProperties',          // 19 min_properties_violation
+  'maxProperties',          // 20 max_properties_violation
+  'multipleOf',             // 21 multiple_of_violation
+  'allOf',                  // 22 all_of_failed
+  'anyOf',                  // 23 any_of_failed
+  'oneOf',                  // 24 one_of_failed
+  'not',                    // 25 not_failed
+  '$ref',                   // 26 ref_not_found
+  'if',                     // 27 if_then_else_failed
+  '__depth__',              // 28 depth_exceeded
+]
+
+// Keyword and public code for a native ordinal, or null when the ordinal is
+// outside the enum, which would mean the addon is newer than this table.
+function fromNative (ordinal, format) {
+  if (typeof ordinal !== 'number' || !Number.isInteger(ordinal)) return null
+  const keyword = NATIVE_KEYWORDS[ordinal]
+  if (!keyword) return null
+  // codeFor('format') answers with the first format code, which names a
+  // specific format. Without knowing which format failed, the generic one is
+  // the honest answer.
+  // The walker stopped at its depth limit and rejected the document. No
+  // public code names that: the APIs that ask the walker route schemas deep or
+  // recursive enough to reach it to validate() first (lib/buffer-gate.js), so
+  // it is the generic failure.
+  if (keyword === '__depth__') return { keyword, code: 'ATA9000' }
+  const code = keyword === 'format'
+    ? (format ? codeFor('format', format) || 'ATA3099' : 'ATA3099')
+    : codeFor(keyword) || 'ATA9001'
+  return { keyword, code }
+}
+
+module.exports = { fromNative, NATIVE_KEYWORDS };

package/lib/native-message.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// The words for an error the native engine reported without a message (it
+// reports numeric codes): the enrich pass knows them. A module of its own so
+// the browser build, which has no native engine (lib/native-load.browser.js),
+// maps it to lib/native-message.browser.js and leaves the enrichment out of
+// bundles that only reach it from here, such as ata-validator/compiled-plain.
+module.exports = (err) => require('./enrich-error').enrich(err, {}).message;

package/lib/native.browser.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Browser build of lib/native-message.js, lib/native-codes.js and
+// lib/native-positions.js, one file for all three so a page carries one module
+// for them: there is no native engine in a browser (lib/native-load.browser.js
+// returns null), so no error arrives without a message or with a native
+// ordinal, and no position is found by the addon. Kept total all the same.
+const message = (err) => (err && err.message) || 'validation failed';
+message.fromNative = message.nativeTargeted = () => null;
+message.NATIVE_KEYWORDS = [];
+module.exports = message;

package/lib/public-api.js

@@ -70,6 +70,7 @@ module.exports = {
   parseJSON: core.parseJSON,
   toTypeScript,
   defineSchema: core.defineSchema,
+  schemaOf: core.schemaOf,
   renderPretty,
   renderCompact,
   toOutput,