ata-validator 1.59.0 → 1.61.0

package/lib/compiled.js

@@ -17,6 +17,7 @@
 
 const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
 const { COMPILED_OPTIONS, prepare, parse, installExtension, extendJSON, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -99,6 +100,11 @@ function fromCompiled(mod, schema, options) {
       isValidJSON: json.isValidJSON,
     };
   });
+  // Standard Schema V1, as the runtime Validator hands it out, so a validator
+  // the build compiled away still works where the runtime one did (a form
+  // library, a router, an RPC layer). The schema it publishes is the one the
+  // module was built from, as the runtime reads it.
+  installStandard(api, () => schema, (self, value) => self.validate(value));
   return api;
 }
 

package/lib/formats.js

@@ -538,4 +538,4 @@ function email(s) {
 const DURATION_RE = /^P(?:\d+W|(?:\d+Y(?:\d+M(?:\d+D)?)?|\d+M(?:\d+D)?|\d+D)(?:T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))?|T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))$/;
 function duration (s) { return DURATION_RE.test(s); }
 
-module.exports = { IPV4, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };
+module.exports = { IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };

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)
     }
   }
@@ -2080,11 +2100,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/public-api.js

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

package/lib/standard-schema.js

@@ -0,0 +1,145 @@
+'use strict';
+
+// Standard Schema V1 for a validator: the `~standard` member a form library,
+// a router or an RPC layer reads instead of ata's own API. One module, so the
+// runtime Validator (lib/validator-core.js) and the wrapper around a module
+// written ahead of time (lib/compiled.js) hand out the same object built the
+// same way, and a validator the build compiled away still works where the
+// runtime one did.
+
+// Paths repeat across rejections of the same shape, so the parsed segment
+// list is cached per path string. Entries are frozen: the same array is
+// handed to every issue that names the path.
+//
+// The cache is bucketed by length and searched with ===, not keyed in a Map.
+// A path with an array index in it is concatenated afresh by every rejection,
+// and a Map has to hash each such string from scratch before it can look
+// anything up; that hashing was 30% of a Standard Schema rejection with
+// sixteen issues. Comparing against the few paths of the same length costs
+// less. Both levels are bounded so a stream of array indexes cannot grow it
+// without limit: a full bucket stops caching, too many lengths clear it.
+const _pathBuckets = new Map();
+const PATH_BUCKET_MAX = 32;
+const PATH_LENGTHS_MAX = 256;
+const EMPTY_PATH = Object.freeze([]);
+function parsePointerPath(path) {
+  if (!path) return EMPTY_PATH;
+  const n = path.length;
+  let bucket = _pathBuckets.get(n);
+  if (bucket !== undefined) {
+    for (let i = 0; i < bucket.length; i += 2) if (bucket[i] === path) return bucket[i + 1];
+  } else {
+    if (_pathBuckets.size >= PATH_LENGTHS_MAX) _pathBuckets.clear();
+    bucket = [];
+    _pathBuckets.set(n, bucket);
+  }
+  const segs = Object.freeze(parsePointerPathUncached(path));
+  if (bucket.length < PATH_BUCKET_MAX * 2) bucket.push(path, segs);
+  return segs;
+}
+
+function parsePointerPathUncached(path) {
+  // One pass, no intermediate arrays. Per Standard Schema V1 an array index
+  // is emitted as a number and an object key as a string; a segment is an
+  // index when it is all digits with no leading zero.
+  const out = [];
+  const n = path.length;
+  let start = 1;
+  for (let i = 1; i <= n; i++) {
+    if (i !== n && path.charCodeAt(i) !== 47) continue;
+    if (i > start) {
+      let seg = path.slice(start, i);
+      if (seg.indexOf('~') >= 0) seg = seg.replace(/~1/g, '/').replace(/~0/g, '~');
+      const c0 = seg.charCodeAt(0);
+      let numeric = c0 >= 48 && c0 <= 57 && (seg.length === 1 || c0 !== 48);
+      if (numeric) {
+        for (let k = 1; k < seg.length; k++) {
+          const c = seg.charCodeAt(k);
+          if (c < 48 || c > 57) { numeric = false; break; }
+        }
+      }
+      out.push({ key: numeric ? Number(seg) : seg });
+    }
+    start = i + 1;
+  }
+  return out;
+}
+
+// Standard JSON Schema, the `jsonSchema` member of `~standard`: what a consumer
+// such as the MCP SDK reads to publish a schema, from `input({ target })`.
+// ata validates the JSON Schema it was given and does not transform values, so
+// input and output are the same document, handed back as a copy when the
+// target is the schema's dialect: draft-07 when it declares draft-07, 2020-12
+// when it declares 2020-12 or nothing, as ata reads it. Any other target
+// throws, as the specification asks, rather than returning a document that
+// would mean something else there.
+function standardJsonSchema(getSchema) {
+  const convert = (options) => {
+    const target = options && options.target;
+    const schema = getSchema();
+    if (schema === true) return {};
+    if (schema === false) return { not: {} };
+    const declared = typeof schema.$schema === 'string' ? schema.$schema : '';
+    const dialect = declared === '' || declared.includes('draft/2020-12/schema') ? 'draft-2020-12'
+      : declared.includes('draft-07/schema') ? 'draft-07' : declared;
+    if (target !== dialect) {
+      throw new TypeError(`ata-validator cannot provide a ${dialect} schema as ${String(target)}; it does not convert between dialects`);
+    }
+    return JSON.parse(JSON.stringify(schema));
+  };
+  return Object.freeze({ input: convert, output: convert });
+}
+
+// The `~standard` object for `self`, a validator whose validate(value)
+// answers as ata's does: `getSchema(self)` returns the schema as the caller
+// wrote it, `validate(self, value)` is called each time, so an extension
+// installed later counts.
+function standardSchemaFor(self, getSchema, validate) {
+  return Object.freeze({
+    version: 1,
+    vendor: 'ata-validator',
+    jsonSchema: standardJsonSchema(() => getSchema(self)),
+    validate(value) {
+      const result = validate(self, value);
+      if (result.valid) {
+        return { value };
+      }
+      // An issue carries a message and a path and nothing else, so the
+      // suggestion and source-frame work the rich error path does would be
+      // thrown away here. Take the raw, schema-ordered list when the result
+      // offers one; fall back to the public list otherwise.
+      const raw = typeof result._ataRaw === 'function' ? result._ataRaw() : result.errors;
+      const issues = new Array(raw.length);
+      for (let i = 0; i < raw.length; i++) {
+        const err = raw[i];
+        const path = err.instancePath != null ? err.instancePath : (err.path || '');
+        let message = err.message;
+        if (!message) {
+          // The native engine reports numeric codes without a message; the
+          // enrich pass knows how to word those. Rare, so required lazily.
+          message = require('./enrich-error').enrich(err, {}).message;
+        }
+        issues[i] = { message, path: parsePointerPath(path) };
+      }
+      return { issues };
+    },
+  });
+}
+
+// Installs `~standard` on `target` (an instance, or a prototype) as a lazy
+// accessor: built on first read for the object it is read from, then pinned
+// to that object as a plain, non-enumerable value, so a validator nobody asks
+// never builds it.
+function installStandard(target, getSchema, validate) {
+  Object.defineProperty(target, '~standard', {
+    configurable: true,
+    enumerable: false,
+    get() {
+      const std = standardSchemaFor(this, getSchema, validate);
+      Object.defineProperty(this, '~standard', { value: std, writable: false, enumerable: false, configurable: false });
+      return std;
+    },
+  });
+}
+
+module.exports = { parsePointerPath, standardJsonSchema, standardSchemaFor, installStandard };

package/lib/tier0.js

@@ -47,7 +47,7 @@ const F_MULT = 16;
 const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
 const _hop = Object.prototype.hasOwnProperty;
 // Deno removes the __proto__ accessor; read the prototype another way there.
-const _PN = ({}).__proto__ === Object.prototype;
+const _PN = typeof Bun === 'undefined' && ({}).__proto__ === Object.prototype; // JavaScriptCore goes through Object.getPrototypeOf, see js-compiler's _PN
 
 function primConstraint(key, propSchema) {
   const t = propSchema.type;