ata-validator 1.51.0 → 1.52.0

package/README.md

@@ -138,18 +138,19 @@ errors (7.6M with `richErrors: false`).
 
 | Dimension | Schema | ata-AOT | runtime validator | Difference |
 |---|---|---|---|---|
-| Bundle (gzipped) | simple | 1.4 KB | 52.7 KB | 38.4x smaller |
-| Bundle (gzipped) | complex | 3.0 KB | 52.7 KB | 17.5x smaller |
-| Bundle (gzipped) | nested | 4.5 KB | 52.7 KB | 11.6x smaller |
+| Bundle (gzipped) | simple | 1.3 KB | 52.7 KB | 39.0x smaller |
+| Bundle (gzipped) | complex | 3.0 KB | 52.7 KB | 17.7x smaller |
+| Bundle (gzipped) | nested | 4.5 KB | 52.7 KB | 11.8x smaller |
 | Cold start | simple | 20 ms | 37 ms | 1.9x faster |
-| Throughput (1M ops) | simple | 289 Mops/s | 96 Mops/s | 3.0x faster |
-| Compile time | simple | 18 µs | 1.56 ms | 85x faster |
+| Throughput (1M ops) | simple | 315 Mops/s | 99 Mops/s | 3.2x faster |
+| Compile time | simple | 24 µs | 1.57 ms | 65x faster |
 
 The runtime column is the default validator most frameworks ship. Reproduce on your machine
-with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-10-06,
-on ata-validator 1.46.0. Across four runs throughput moved between 288 and 329 Mops/s against
-96 to 116, cold start between 19 and 20 ms against 37 to 39, and the compile ratio between 77x
-and 85x. The throughput row times a single one-million-call
+with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-10-11,
+on ata-validator 1.51.0. Across five runs throughput moved between 263 and 325 Mops/s against
+97 to 110, cold start between 20 and 22 ms against 37 to 40, and the compile ratio between 61x
+and 65x. The compile row is the time to write a module, a build-time cost; it was 18 µs on
+1.46.0, and modules have carried the one-pass error function since 1.47.0. The throughput row times a single one-million-call
 loop of a few milliseconds, so it moves the most from run to run; treat the last three rows as
 an order of magnitude rather than a constant.
 
@@ -279,13 +280,13 @@ is the most common way to get a misleading number out of this library.
 
 | | compiled with `ata build` | runtime `new Validator(schema)` |
 |---|---|---|
-| In a bundle, gzipped | **2.1 KB** | 126.1 KB |
+| In a bundle, gzipped | **2.1 KB** | 123.9 KB |
 | Time to a served request | **3.5 ms** | 7.6 ms |
 | Schema known when | build time | any time |
 
 The bundle row is the ten-field user schema in
 `tests/fixtures/error-dx/user.schema.json`, every export of the compiled module against
-`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.48.0.
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.51.0.
 The startup row is a Hono route on Bun 1.4, the median of three rounds of best-of-seven, from
 `benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
 compiled path costs nothing measurable to start. The runtime figure is what it is because
@@ -293,7 +294,7 @@ a schema that arrives at run time can use any keyword, so the whole engine has t
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 113 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 124 KB of JavaScript on a Node or Bun
 process is not a cost anyone notices, and the runtime API is the simpler thing to reach
 for. Speed is the same either way once warm.
 
@@ -535,7 +536,7 @@ const v = new Validator(schema, {
 
 ### Build-time compile (`ata compile`)
 
-The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.1 KB gzipped, full error detail included, against 113.3 KB for the runtime bundled for the browser (ata 1.45.0).
+The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. For the ten-field user schema in `tests/fixtures/error-dx/user.schema.json` the module is 2.1 KB gzipped, full error detail included, against 123.9 KB for the runtime bundled for the browser (ata 1.51.0).
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -581,20 +582,25 @@ error collector out of the modules: each one carries its verdict and its schema,
 its errors from one `ata-errors.mjs` the build writes beside them. The build does this only
 where it makes the output smaller, so a single small schema keeps its self-contained module.
 The errors are the ones `new Validator(schema, { richErrors: false })` reports, in the same
-order. Seven SchemaStore schemas imported into one app, minified with esbuild, go from 148.9 KB
-to 63.3 KB gzipped, and from 35.8 ms to 13.8 ms to import with code generation blocked. A
+order. Forty SchemaStore schemas imported into one app, minified with esbuild, go from 513.8 KB
+to 213.3 KB gzipped, and from 60.4 ms to 28.4 ms to import with code generation blocked. A
 rejected document costs more this way, since its errors come from an interpreted walk:
 `--errors inline` keeps every module self-contained. `--mode schema` writes each module as
 its schema and takes the verdict from the runtime too: forty SchemaStore schemas in one app
-come to 101.6 KB gzipped against 212.6 KB as compact modules, and load and check each once in
-23.0 ms against 35.5, while a check once warm costs about five times what generated code costs.
+come to 102.4 KB gzipped against 213.3 KB as compact modules, and load and check each once in
+23.9 ms against 34.5, while a check once warm costs about five times what generated code costs.
+Schemas that reference each other by `$id` are built against each other, and in schema mode
+they are written once to a shared registry that keeps only the definitions the modules reach;
+`--base-uri <uri>` names files that declare no `$id`. Eight Kubernetes kinds, whose schemas
+share one 1.1 MB definitions file, come to 32.6 KB gzipped as schema modules against 68.6 KB
+self-contained, on ata 1.51.0.
 
 Bundle sizes for the 10-field user schema in `tests/fixtures/error-dx/user.schema.json`,
-minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.45.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.51.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 113.3 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 123.9 KB | The compiler ships with it, because a runtime schema can use any keyword |
 | `isValid` from the compiled module | **1.3 KB** | Nothing else is reachable, so the error collector is dropped |
 | `validate` from the compiled module | **1.9 KB** | Adds the detailed error collector |
 
@@ -632,7 +638,7 @@ through a `setFormats()` export the module carries. `docs/API.md` has the
 details.
 
 **Fastify startup, 10 route schemas, from a cold process to the first validated request:
-ajv 19.7 ms, ata 2.75 ms, no build step required.** ata registers in 0.25 ms of that and
+ajv 19.0 ms, ata 2.81 ms, no build step required.** ata registers in 0.20 ms of that and
 compiles on the first request, so counting only registration would overstate the gap.
 Reproduce with `node benchmark/bench_fastify_boot.mjs`.
 

package/index.bundle.mjs

@@ -0,0 +1,15 @@
+// ESM entry for bundlers that target a server (Bun, esbuild or Rollup for
+// Node) and for Node before 22.10, which does not match `module-sync`: the
+// validator core with the code generator registered, as index.js, but with
+// each tool imported on its own (lib/tools.mjs), so the tools an application
+// does not import stay out of its bundle. Through index.js a bundler sees one
+// CommonJS module and keeps all of them.
+import core from './lib/validator-core.js';
+import engine from './lib/codegen-engine.js';
+import { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } from './lib/tools.mjs';
+
+core._registerCodegen(engine);
+
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, defineSchema } = core;
+export { toTypeScript, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };
+export default { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON };

package/lib/aot-impl.js

@@ -251,7 +251,7 @@ function onePassCore(validator, opts) {
   const decls = [];
   const args = [];
   const own = new Set();
-  const addOwn = (n) => { if (own.has(n)) return; own.add(n); if (n === '_h' || n === '_hall') addOwn('_hop'); if (n === '_ok') { addOwn('_PN'); addOwn('_hop'); } decls.push(OWN_HELPER_CODE[n]); };
+  const addOwn = (n) => { if (own.has(n)) return; own.add(n); if (n === '_h' || n === '_hall') addOwn('_hop'); if (n === '_ok') { addOwn('_PN'); addOwn('_hop'); } if (n === '_nk') addOwn('_PN'); decls.push(OWN_HELPER_CODE[n]); };
   let usesSafeRe = emit.usesSafeRe, usesCollapse = false;
   for (let i = 0; i < emit.names.length; i++) {
     const name = emit.names[i], val = emit.values[i];
@@ -272,7 +272,7 @@ function onePassCore(validator, opts) {
     if (name === '_VF') { args.push('null'); continue; }
     if (name === '_PN') { addOwn('_PN'); args.push('_PN'); continue; }
     if (name === '_OP' || name === '_gp') { addOwn('_PN'); args.push(name); continue; }
-    if (name === '_hop' || name === '_h' || name === '_ok' || name === '_hall') { addOwn(name); args.push(name); continue; }
+    if (name === '_hop' || name === '_h' || name === '_ok' || name === '_hall' || name === '_nk') { addOwn(name); args.push(name); continue; }
     if (name === '_pe') { decls.push(PTR_ESC_HELPER); args.push('_pe'); continue; }
     if (name === '_deq') { decls.push(DEQ_HELPER); args.push('_deq'); continue; }
     if (name === '_anT') { decls.push('function _anT(){return true}'); args.push('_anT'); continue; }

package/lib/combined-runtime.js

@@ -121,6 +121,9 @@ const _hop = Object.prototype.hasOwnProperty
 function _h (o, k) { return _hop.call(o, k) }
 function _ok (o, k) { return (_PN ? o.__proto__ : _gp(o)) === _OP || _hop.call(o, k) } // eslint-disable-line no-proto
 function _hall (o, ks) { for (let i = 0; i < ks.length; i++) if (!_hop.call(o, ks[i])) return false; return true }
+// A key count that came out wrong, counted again over own keys unless the
+// object is ordinary.
+function _nk (o, n) { return (_PN ? o.__proto__ : _gp(o)) === _OP || Object.keys(o).length !== n } // eslint-disable-line no-proto
 
 // RFC 6901 escaping for a key only known at run time (the static ones are
 // escaped when the code is written).
@@ -140,7 +143,7 @@ function _rb (S, m) { if (S.length !== m) S.length = m }
 
 module.exports = {
   apState, ap, sr, srX, multiBranch,
-  _PN, _OP, _gp, _hop, _h, _ok, _hall, _pe, _anT, _anF, _rb,
+  _PN, _OP, _gp, _hop, _h, _ok, _hall, _nk, _pe, _anT, _anF, _rb,
 }
 // Loaded when a program first asks for them: a schema without const, enum,
 // uniqueItems, oneOf or anyOf never needs these modules on its cold path.

package/lib/error-runtime.js

@@ -94,7 +94,11 @@ function errorRuntimeSource(format, version, features, schemaMode) {
     const src = OPTIONAL[name] !== undefined && !want(name)
       ? OPTIONAL[name].stub
       : dropCommentLines(fs.readFileSync(path.join(__dirname, name + '.js'), 'utf8'), name);
-    defs.push(`${JSON.stringify(name)}: function (module, exports, require) {\n${src}\n}`);
+    // The files' own require('./x') calls go to the table under another name:
+    // a tool that reads the runtime without scope (knip, a lint rule) took a
+    // local `require` for an import of a file that is not there.
+    const own = src.replace(/\brequire\((['"])\.\//g, '__ataReq($1./');
+    defs.push(`${JSON.stringify(name)}: function (module, exports, __ataReq) {\n${own}\n}`);
   }
   const { byKw, byFmt } = codeTable();
   const body = `// Auto-generated by ata-validator ${version}, do not edit.

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 { 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 } = core._internal
+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 } = core._internal
 
 
 function emitPtrEsc(ctx) {
@@ -1313,7 +1313,7 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     // 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;for(const _f${ci} in ${v}){if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
+    const inner = `let _x${ci}=0;${ownHead(ctx, v, `_f${ci}`, 'const')}{if(${gateTest}){_x${ci}=1;break}}if(_x${ci}){${detail}}`
     lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -1504,7 +1504,7 @@ function genPatternPropertiesE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     }
     const ri = ctx.regExpMap.get(pattern);
     const ki = ctx.varCounter++
-    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
+    lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k${ki}`, 'const')}{if(_re${ri}.test(_k${ki})){`)
     const _peFn = emitPtrEsc(ctx)
     const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
     // The real pointer, so source maps can locate the failing keyword.
@@ -1538,7 +1538,7 @@ function genAdditionalSchemaE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (known.length) conds.push(`!_ak${ki}.has(_k${ki})`)
   if (patTests.length) conds.push(`!(${patTests.join('||')})`)
   const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
-  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}${ownHead(ctx, v, `_k${ki}`, 'const')}{${keep}`)
   const _peFn = emitPtrEsc(ctx)
   const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
   genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
@@ -1559,13 +1559,13 @@ function genPropertyNamesFalseE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // the object that carries the name, not to `/<key>`, which is where the
   // value lives. Same placement as the object-valued propertyNames branch.
   const p = pathExpr || '""'
-  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k${ki}`, 'const')}{_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
 }
 
 function genPropertyNamesE(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
   const pn = schema.propertyNames
   const ki = ctx.varCounter++
-  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k${ki}`, 'const')}{`)
   // The subschema checks the key as a value, and its errors are reported at
   // the object, as the interpreter reports them.
   if (!isSimplePN(pn)) {
@@ -2523,14 +2523,14 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       // leave `if()`, so the test is `true`.
       const gate = propKeys.map(k => `_f${ci}!==${JSON.stringify(k)}`).join('&&') || 'true'
       const checks = propKeys.map(k => `_k${ci}[_i]!==${JSON.stringify(k)}`).join('&&') || 'true'
-      body = `let _x${ci}=0;for(const _f${ci} in ${v}){if(${gate}){_x${ci}=1;break}}if(_x${ci}){${detail(checks)}}`
+      body = `let _x${ci}=0;${ownHead(ctx, v, `_f${ci}`, 'const')}{if(${gate}){_x${ci}=1;break}}if(_x${ci}){${detail(checks)}}`
     } else {
       // The name set lives in the closure, built once with the function: built
       // in the body it was a 33-name Set on every call of this function, which
       // is where a rejected npm-badges document spent most of its 701 ns.
       ctx.closureVars.push(`_a${ci}`)
       ctx.closureVals.push(new Set(propKeys))
-      body = `let _x${ci}=0;for(const _f${ci} in ${v}){if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
+      body = `let _x${ci}=0;${ownHead(ctx, v, `_f${ci}`, 'const')}{if(!_a${ci}.has(_f${ci})){_x${ci}=1;break}}if(_x${ci}){${detail(`!_a${ci}.has(_k${ci}[_i])`)}}`
     }
     // When every declared property is required, a clean object has exactly the
     // declared keys: if the enumerated count equals the declared count and
@@ -2545,7 +2545,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const req = new Set(Array.isArray(schema.required) ? schema.required : [])
     if (propKeys.length > 0 && propKeys.every((k) => req.has(k) && !PROTO_NAMES.has(k))) {
       const present = propKeys.map((k) => `${JSON.stringify(k)} in ${v}`).join('&&')
-      body = `let _n${ci}=0;for(const _f${ci} in ${v})_n${ci}++;if(_n${ci}!==${propKeys.length}||!(${present})){${body}}`
+      body = `let _n${ci}=0;${ownHead(ctx, v, `_f${ci}`, 'const')}_n${ci}++;if(_n${ci}!==${propKeys.length}||!(${present})){${body}}`
     }
     lines.push(isObj
       ? `{${body}}`
@@ -2945,7 +2945,7 @@ function inlineUnevalBlock (schema, v, pathExpr, ctx, schemaPrefix, fail, counts
     } else {
       throw DECLINE
     }
-    if (body) out.push(`for(const ${kVar} in ${v}){if(!${ownKeyExpr(ctx, v, kVar).split(JSON.stringify(kVar)).join(kVar)})continue;let _ub${id}=0;switch(${kVar}){${cases}}if(_ub${id}!==0&&(${m}&_ub${id})!==0)continue;${allBit}${patBits}${body}}`)
+    if (body) out.push(`${ownHead(ctx, v, kVar, 'const')}{if(!${ownKeyExpr(ctx, v, kVar).split(JSON.stringify(kVar)).join(kVar)})continue;let _ub${id}=0;switch(${kVar}){${cases}}if(_ub${id}!==0&&(${m}&_ub${id})!==0)continue;${allBit}${patBits}${body}}`)
     const text = out.join(';')
     ctx.plainReuse = prevReuse
     if (prevPk === undefined) ctx.plainOf.delete(v)
@@ -3357,7 +3357,7 @@ function genAdditionalSchemaC(schema, v, pathExpr, lines, ctx, schemaPrefix, isO
   const sub = []
   genCodeC(schema.additionalProperties, `${v}[${kVar}]`, p, sub, ctx, schemaPrefix + '/additionalProperties')
   if (sub.length === 0) return
-  lines.push(`${guard}{for(const ${kVar} in ${v}){${keep}{${sub.join('\n  ')}\n  }}}`)
+  lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{${keep}{${sub.join('\n  ')}\n  }}}`)
 }
 
 function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
@@ -3397,7 +3397,7 @@ function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fa
       ctx.closureVals.push(new Set(propKeys))
     }
 
-    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{`)
     // propertyNames checks (merged)
     if (pn) {
       if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
@@ -3434,7 +3434,7 @@ function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fa
     lines.push(`}}`)
   } else {
     handledPropertyNames = !!pn
-    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{`)
     if (pn) {
       if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
       if (pn.maxLength !== undefined) lines.push(`if(${kVar}.length>${pn.maxLength}){${fail('maxLength', 'propertyNames/maxLength', `{limit:${pn.maxLength}}`, `'must NOT have more than ${pn.maxLength} characters'`)}}`)
@@ -3478,7 +3478,7 @@ function genDependentSchemasC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 function genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   const ki = ctx.varCounter++
   const p = pathExpr || '""'
-  lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){${errPushC(ctx, 'not', `${schemaPrefix}/propertyNames`, pathExpr, '{}', "'boolean schema is false'", v, `{keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'}`)}}}`)
+  lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k${ki}`, 'const')}{${errPushC(ctx, 'not', `${schemaPrefix}/propertyNames`, pathExpr, '{}', "'boolean schema is false'", v, `{keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'}`)}}}`)
 }
 
 function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
@@ -3488,7 +3488,7 @@ function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail)
   // here that would be the key where the interpreter's error points at the
   // object, so that one is left to the plain function and enrichment.
   if (!isSimplePN(pn) && ctx.rich) throw DECLINE
-  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){`)
+  lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k${ki}`, 'const')}{`)
   if (!isSimplePN(pn)) {
     genCodeC(pn, `_k${ki}`, pathExpr, lines, ctx, schemaPrefix + '/propertyNames')
     lines.push(`}}`)

package/lib/js-compiler.js

@@ -36,7 +36,7 @@ function uqSources () {
 // that would have written them.
 const SHARED_RT = {
   _deqHoisted: ['_deq'], _peHoisted: ['_pe'],
-  _own_PN: ['_PN', '_OP', '_gp'], _own_hop: ['_hop'], _own_h: ['_h'], _own_ok: ['_ok'], _own_hall: ['_hall'],
+  _own_PN: ['_PN', '_OP', '_gp'], _own_hop: ['_hop'], _own_h: ['_h'], _own_ok: ['_ok'], _own_hall: ['_hall'], _own_nk: ['_nk'],
 }
 let _rt = null
 function sharedRt () { return _rt || (_rt = require('./combined-runtime')) }
@@ -96,8 +96,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})return false`
-  return `for(var _k in ${v})if(${names.map((k) => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+  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`
 }
 
 function emitDeq(ctx) {
@@ -907,8 +907,9 @@ const OWN_HELPER_CODE = {
   _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}',
 }
-const OWN_HELPER_DEPS = { _h: ['_hop'], _ok: ['_PN', '_hop'], _hall: ['_hop'] }
+const OWN_HELPER_DEPS = { _h: ['_hop'], _ok: ['_PN', '_hop'], _hall: ['_hop'], _nk: ['_PN'] }
 function useOwnHelper (ctx, name) {
   for (const dep of OWN_HELPER_DEPS[name] || []) useOwnHelper(ctx, dep)
   hoistOnce(ctx, '_own' + name, OWN_HELPER_CODE[name])
@@ -1208,6 +1209,17 @@ function propFnCandidate (prop, ctx) {
 // inline after all": an empty body (the inline path then asserts it the
 // usual way) or one that calls the recursive entry, which is out of scope
 // in the preamble.
+// Generates a body that will become a function of its own in the preamble.
+// The ordinary-object flags withPlain declared belong to the function being
+// written now and are out of scope there; a hoisted body takes the same
+// parameter names (`d`, `_av`, `_ov`) and would otherwise read a flag the
+// enclosing node declared for a value of that name.
+function genIsolated (ctx, run) {
+  const outerPlain = ctx.plainOf
+  ctx.plainOf = undefined
+  try { return run() } finally { ctx.plainOf = outerPlain }
+}
+
 function emitPropFn (prop, ctx) {
   const bodyLines = []
   const outerDeferred = ctx.deferredChecks
@@ -1216,7 +1228,7 @@ function emitPropFn (prop, ctx) {
   ctx.plainReuse = undefined
   const outerBytes = ctx.fnBytes
   ctx.fnBytes = 0
-  try { genCode(prop, 'd', bodyLines, ctx) } finally { ctx.plainReuse = outerReuse; ctx.fnBytes = outerBytes }
+  try { genIsolated(ctx, () => genCode(prop, 'd', bodyLines, ctx)) } finally { ctx.plainReuse = outerReuse; ctx.fnBytes = outerBytes }
   if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
   ctx.deferredChecks = outerDeferred
   if (bodyLines.length === 0 || bodyLines.some((l) => /\b_validate\b/.test(l))) return null
@@ -1341,6 +1353,54 @@ function sharedDefNames (root, defs) {
 // known trade: on that shape the shared function costs 27 ns a call.
 const SHARED_DEF_MIN_CHARS = 120
 
+// A small definition applied at many places is called with objects of many
+// shapes, one or two per place, and V8 gives a function's property reads up
+// to four shapes before it falls back to a generic lookup several times
+// slower: SchemaStore's detekt sends 72 shapes through one four-property rule
+// definition. Such a definition is emitted as several functions with the same
+// body, each serving at most SITES_PER_COPY references, so every copy stays
+// within four shapes. Only small bodies are copied, so the source grows by a
+// bounded amount; a large or rarely referenced definition keeps one function.
+const SITES_PER_COPY = 4
+const COPY_MIN_SITES = 16
+const COPY_MAX_BODY = 1500
+function sharedDefCopy (ctx, defName, fnName) {
+  const body = ctx.sharedDefBody && ctx.sharedDefBody.get(fnName)
+  if (body === undefined || body.length > COPY_MAX_BODY) return fnName
+  // Only a definition that reads properties gains: a string, a number or a
+  // wrapper around another reference has no shapes to keep apart, and more
+  // copies only mean more functions to warm up.
+  const def = ctx.rootDefs && ctx.rootDefs[defName]
+  if (def === null || typeof def !== 'object' || typeof def.properties !== 'object' || def.properties === null) return fnName
+  if (!ctx.sharedDefSites) ctx.sharedDefSites = new Map()
+  if (ctx.sharedDefSiteCounts === undefined) ctx.sharedDefSiteCounts = refCounts(ctx.rootSchema)
+  if ((ctx.sharedDefSiteCounts.get(defName) || 0) < COPY_MIN_SITES) return fnName
+  const site = ctx.sharedDefSites.get(fnName) || 0
+  ctx.sharedDefSites.set(fnName, site + 1)
+  const copy = Math.floor(site / SITES_PER_COPY)
+  if (copy === 0) return fnName
+  const name = `${fnName}_c${copy}`
+  if (site % SITES_PER_COPY === 0) hoist(ctx, `function ${name}(d){${body}\n  return true}`)
+  return name
+}
+
+// How many `$ref`s name each local definition, by name.
+function refCounts (root) {
+  const counts = new Map()
+  const seen = new WeakSet()
+  const walk = (node) => {
+    if (node === null || typeof node !== 'object' || seen.has(node)) return
+    seen.add(node)
+    if (typeof node.$ref === 'string') {
+      const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(node.$ref)
+      if (m) counts.set(m[1], (counts.get(m[1]) || 0) + 1)
+    }
+    for (const v of Object.values(node)) walk(v)
+  }
+  walk(root)
+  return counts
+}
+
 function cyclicDefNames (defs) {
   const out = new Set()
   if (!defs || typeof defs !== 'object') return out
@@ -3419,7 +3479,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})return false`)
+          lines.push(`var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`)
         } else {
           lines.push(`if(Object.keys(${v}).length!==${propCount})return false`)
         }
@@ -3534,7 +3594,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   if (schema.additionalProperties === false && schema.properties && !schema.patternProperties && ctx.removeNodes && ctx.removeNodes.has(schema)) {
     const kv = `_rk${ctx.varCounter++}`
     const declared = Object.keys(schema.properties)
-    let loop = `for(var ${kv} in ${v})if(${declared.map((k) => `${kv}!==${JSON.stringify(k)}`).join('&&')})delete ${v}[${kv}]`
+    let loop = `${ownHead(ctx, v, kv, 'var')}if(${declared.map((k) => `${kv}!==${JSON.stringify(k)}`).join('&&')})delete ${v}[${kv}]`
     // When every declared property is required, the verdict has already
     // established they are all there, so a key count equal to the declared
     // count means nothing is extra and the deleting walk, which compares every
@@ -3542,7 +3602,7 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
     const req = new Set(schema.required || [])
     if (declared.length <= 15 && declared.every((k) => req.has(k))) {
       const n = `_rn${ctx.varCounter++}`
-      loop = `{var ${n}=0;for(var ${kv} in ${v})${n}++;if(${n}!==${declared.length}){${loop}}}`
+      loop = `{var ${n}=0;${ownHead(ctx, v, kv, 'var')}${n}++;if(${n}!==${declared.length}){${loop}}}`
     }
     _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
   } else if (schema.additionalProperties === false && !schema.patternProperties) {
@@ -3559,7 +3619,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})return false`
+          ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`
           : `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}}`)
@@ -3590,8 +3650,8 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // propertyNames: false rejects any key at all; true constrains nothing.
   if (schema.propertyNames === false) {
     lines.push(isObj
-      ? `for(const _k in ${v})return false`
-      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k in ${v})return false}`)
+      ? `${ownHead(ctx, v, `_k`, 'const')}return false`
+      : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, `_k`, 'const')}return false}`)
   }
 
   // propertyNames — only emit if not already merged into patternProperties loop
@@ -3779,8 +3839,8 @@ function genAdditionalSchemaNode(schema, v, lines, ctx, knownType, isObj) {
   if (subLines.length > 0) {
     const body = subLines.join(';')
     const loop = skipCheck
-      ? `for(var ${kVar} in ${v}){if(${skipCheck})continue;const ${avVar}=${v}[${kVar}];${body}}`
-      : `for(var ${kVar} in ${v}){const ${avVar}=${v}[${kVar}];${body}}`
+      ? `${ownHead(ctx, v, kVar, 'var')}{if(${skipCheck})continue;const ${avVar}=${v}[${kVar}];${body}}`
+      : `${ownHead(ctx, v, kVar, 'var')}{const ${avVar}=${v}[${kVar}];${body}}`
     _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
   }
 }
@@ -3804,10 +3864,10 @@ function genPropertyNamesNode(schema, v, lines, ctx, knownType, isObj) {
     const sub = []
     genCode(pn, '_pv', sub, ctx)
     if (sub.length === 0) return
-    lines.push(`${guard}{const _pnf${ki}=function(_pv){${sub.join(';')};return true};for(const _k${ki} in ${v}){if(!_pnf${ki}(_k${ki}))return false}}`)
+    lines.push(`${guard}{const _pnf${ki}=function(_pv){${sub.join(';')};return true};${ownHead(ctx, v, `_k${ki}`, 'const')}{if(!_pnf${ki}(_k${ki}))return false}}`)
     return
   }
-  lines.push(`${guard}{for(const _k${ki} in ${v}){`)
+  lines.push(`${guard}{${ownHead(ctx, v, `_k${ki}`, 'const')}{`)
   if (pn.minLength !== undefined) lines.push(`if(_k${ki}.length<${pn.minLength})return false`)
   if (pn.maxLength !== undefined) lines.push(`if(_k${ki}.length>${pn.maxLength})return false`)
   if (pn.pattern) {
@@ -3878,7 +3938,8 @@ function genAnyOfNode(schema, v, lines, ctx, knownType) {
       continue
     }
     const subLines = []
-    genCode(sub, '_av', subLines, ctx)
+    if (canHoist) genIsolated(ctx, () => genCode(sub, '_av', subLines, ctx))
+    else genCode(sub, '_av', subLines, ctx)
     const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
     if (/\b_validate\b/.test(body)) canHoist = false
     branchBodies.push(body)
@@ -3916,6 +3977,35 @@ function branchKey (sub, ctx) {
   return sub
 }
 
+// A oneOf whose branches each allow only their own properties, the way
+// Traefik's middlewares and many tagged unions are written: every branch is
+// `{ properties: {...}, additionalProperties: false }` (an object `type` and
+// annotations aside), and no property belongs to two branches. Then an
+// object passes a branch only if every key it has is that branch's, so its
+// first key names the one branch that can pass, and an object with no keys
+// passes all of them. Returns the branch index per property name, or null.
+const KEYED_BRANCH_KEYS = new Set(['properties', 'additionalProperties', 'type', 'title', 'description', '$comment'])
+function keyedBranches (branches) {
+  if (branches.length < 4) return null
+  const owner = new Map()
+  for (let i = 0; i < branches.length; i++) {
+    const b = branches[i]
+    if (typeof b !== 'object' || b === null || Array.isArray(b)) return null
+    for (const k of Object.keys(b)) if (!KEYED_BRANCH_KEYS.has(k)) return null
+    if (b.additionalProperties !== false) return null
+    if (b.type !== undefined && b.type !== 'object') return null
+    const props = b.properties
+    if (typeof props !== 'object' || props === null || Array.isArray(props)) return null
+    const names = Object.keys(props)
+    if (names.length === 0) return null
+    for (const n of names) {
+      if (owner.has(n)) return null
+      owner.set(n, i)
+    }
+  }
+  return owner
+}
+
 function genOneOfNode(schema, v, lines, ctx, knownType) {
   const fi = ctx.varCounter++
   const branchBodies = []
@@ -3939,7 +4029,8 @@ function genOneOfNode(schema, v, lines, ctx, knownType) {
       continue
     }
     const subLines = []
-    genCode(sub, '_ov', subLines, ctx)
+    if (canHoist) genIsolated(ctx, () => genCode(sub, '_ov', subLines, ctx))
+    else genCode(sub, '_ov', subLines, ctx)
     const body = subLines.length === 0 ? 'return true' : `${subLines.join(';')};return true`
     // _validate is the recursive entry — hoisting branches above it breaks scope.
     if (/\b_validate\b/.test(body)) canHoist = false
@@ -3955,6 +4046,17 @@ function genOneOfNode(schema, v, lines, ctx, knownType) {
       return name
     })
     const calls = names.map(n => `if(${n}(${v})){_oc${fi}++;if(_oc${fi}>1)return false}`).join(';')
+    const owner = keyedBranches(schema.oneOf)
+    if (owner !== null) {
+      // An object goes to the branch its first key names; anything else, and
+      // an object with no keys, takes the loop over every branch.
+      const entries = [...owner].map(([k, i]) => `[${JSON.stringify(k)},${names[i]}]`).join(',')
+      hoist(ctx, `const _ofm${fi}=new Map([${entries}])`)
+      lines.push(`{let _ofk${fi};if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${ownHead(ctx, v, '_q', 'const')}{_ofk${fi}=_q;break}}` +
+        `if(_ofk${fi}!==undefined){const _ob${fi}=_ofm${fi}.get(_ofk${fi});if(_ob${fi}===undefined||!_ob${fi}(${v}))return false}` +
+        `else{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}}`)
+      return
+    }
     lines.push(`{let _oc${fi}=0;${calls};if(_oc${fi}!==1)return false}`)
   } else {
     const fns = branchBodies.map(body => `function(_ov){${body}}`)
@@ -4032,7 +4134,7 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         ctx.deferredChecks = null
         const outerReuse = ctx.plainReuse
         ctx.plainReuse = undefined
-        try { genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx) } finally { ctx.plainReuse = outerReuse }
+        try { genIsolated(ctx, () => genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)) } finally { ctx.plainReuse = outerReuse }
         if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
         ctx.deferredChecks = outerDeferred
         // The def is hoisted above the entry function, where the recursive
@@ -4070,7 +4172,7 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         const outerReuse = ctx.plainReuse
         ctx.plainReuse = undefined
         try {
-          genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx)
+          genIsolated(ctx, () => genCode(ctx.rootDefs[defName], 'd', bodyLines, ctx))
         } finally {
           ctx.refStack.delete(schema.$ref)
           ctx.plainReuse = outerReuse
@@ -4078,9 +4180,12 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
         if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
         ctx.deferredChecks = outerDeferred
         if (bodyLines.some((l) => /\b_validate\b/.test(l))) throw DECLINE
-        hoist(ctx, `function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
+        const body = bodyLines.join('\n  ')
+        hoist(ctx, `function ${fnName}(d){${body}\n  return true}`)
+        if (!ctx.sharedDefBody) ctx.sharedDefBody = new Map()
+        ctx.sharedDefBody.set(fnName, body)
       }
-      lines.push(`if(!${fnName}(${v}))return false`)
+      lines.push(`if(!${sharedDefCopy(ctx, defName, fnName)}(${v}))return false`)
       if (!hasSiblings) return true
     } else if (ctx.refStack.has(schema.$ref)) { if (ctx.nestedBoolean) throw DECLINE; if (!hasSiblings) return true }
     else {
@@ -4177,7 +4282,7 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
       genCode(apSchema, `_apv${pi}`, apLines, ctx)
       apCheck = apLines.join(';')
     }
-    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{`)
     // propertyNames checks (merged into same loop)
     if (pn) {
       if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
@@ -4228,7 +4333,7 @@ function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
   } else {
     // No additionalProperties: validate matching keys + propertyNames
     handledPropertyNames = !!pn
-    lines.push(`${guard}{for(const ${kVar} in ${v}){`)
+    lines.push(`${guard}{${ownHead(ctx, v, kVar, 'const')}{`)
     // propertyNames checks (merged)
     if (pn) {
       if (pn.minLength !== undefined) lines.push(`if(${kVar}.length<${pn.minLength})return false`)
@@ -4307,7 +4412,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})return false`
+            ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount}&&${ownCountOff(ctx, v, propCount, plainFlag(ctx, v))})return false`
             : `if(Object.keys(${v}).length!==${propCount})return false`
                       _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
         }
@@ -4320,10 +4425,10 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
         // document. The hoisted name lookup is the same cure it was there.
         inner = propCount >= AP_LOOKUP_MIN
           ? apMembershipCheck(ctx, knownKeys, v)
-          : genCharCodeSwitch(knownKeys, v)
+          : genCharCodeSwitch(knownKeys, v, ctx)
                   _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
       } else {
-        inner = `for(var _k in ${v})return false`
+        inner = `for(var _k in ${v})if(${ownFail(ctx, v)})return false`
                   _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
       }
     } else if (typeof schema.unevaluatedProperties === 'object') {
@@ -4341,7 +4446,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
         } else if (knownKeys.length > 0) {
           skipKnown = `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
         }
-        const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
+        const inner = `${ownHead(ctx, v, ukVar, 'var')}{${skipKnown}${check}}`
                   _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
       }
     }
@@ -4386,8 +4491,8 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
         const uniqueThen = [...new Set([...baseProps, ...ifProps, ...(thenEval.props || [])])]
         const uniqueElse = [...new Set([...baseProps, ...(elseEval.props || [])])]
 
-        const thenCheck = genCharCodeSwitch(uniqueThen, v)
-        const elseCheck = genCharCodeSwitch(uniqueElse, v)
+        const thenCheck = genCharCodeSwitch(uniqueThen, v, ctx)
+        const elseCheck = genCharCodeSwitch(uniqueElse, v, ctx)
         const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
         lines.push(`${guard}{const _uif${ufi}=${ifFn2};if(_uif${ufi}(${v})){${thenCheck}}else{${elseCheck}}}`)
       } else if (branchKeyword) {
@@ -4458,8 +4563,8 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
           }
           const dynamicCheck = `switch(_k.charCodeAt(0)){${switchCases}default:break}`
           const inner = staticCheck
-            ? `for(var _k in ${v}){if(${staticCheck})continue;${dynamicCheck}return false}`
-            : `for(var _k in ${v}){${dynamicCheck}return false}`
+            ? `for(var _k in ${v}){if(${staticCheck})continue;${dynamicCheck}if(${ownFail(ctx, v)})return false}`
+            : `for(var _k in ${v}){${dynamicCheck}if(${ownFail(ctx, v)})return false}`
                       _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         } else {
           // Fallback: plain object tracking
@@ -4484,7 +4589,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
             // Single pass: validate anyOf (at least one) + track all matching
             lines.push(`let _am${bfi}=false;for(let _bi=0;_bi<_bf${bfi}.length;_bi++){if(_bf${bfi}[_bi](${v})){_am${bfi}=true;for(const _p of _bk${bfi}[_bi])${evVar}[_p]=1}}if(!_am${bfi})return false`)
           }
-          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+          const inner = `for(var _k in ${v}){if(!${evVar}[_k]&&${ownFail(ctx, v)})return false}`
                       _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         }
       } else if (schema.dependentSchemas) {
@@ -4499,7 +4604,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
             lines.push(`if(${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
           }
         }
-        const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+        const inner = `for(var _k in ${v}){if(!${evVar}[_k]&&${ownFail(ctx, v)})return false}`
                   _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
       } else {
         // General fallback: collect all patternProperties from root + allOf sub-schemas + if
@@ -4559,10 +4664,10 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
             }
             const rootPatCheck = rootReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
             const ifPatCheck = ifReVars.map(rv => `if(${rv}.test(_k))continue;`).join('')
-            const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}return false}}`
+            const inner = `const _uif${ufi}=${ifFn};if(_uif${ufi}(${v})){for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}${ifPatCheck}if(${ownFail(ctx, v)})return false}}else{for(var _k in ${v}){if(${evVar}[_k])continue;${rootPatCheck}if(${ownFail(ctx, v)})return false}}`
                           _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
           } else {
-            const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}return false}`
+            const inner = `for(var _k in ${v}){if(${evVar}[_k])continue;${reVars.map(rv => `if(${rv}.test(_k)){${evVar}[_k]=1;continue}`).join('')}if(${ownFail(ctx, v)})return false}`
                           _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
           }
         } else {
@@ -4573,7 +4678,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
           const evVar = `_ev${ei}`
           lines.push(`{const ${evVar}={}`)
           for (const k of baseProps) lines.push(`${evVar}[${JSON.stringify(k)}]=1`)
-          const inner = `for(var _k in ${v}){if(!${evVar}[_k])return false}`
+          const inner = `for(var _k in ${v}){if(!${evVar}[_k]&&${ownFail(ctx, v)})return false}`
           _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
         }
       }
@@ -4613,7 +4718,7 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
       genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines2, ctx)
       if (subLines2.length > 0) {
         const check = subLines2.join(';')
-        const inner = `for(var ${ukVar} in ${v}){if(${evVar}[${ukVar}])continue;${check}}`
+        const inner = `${ownHead(ctx, v, ukVar, 'var')}{if(${evVar}[${ukVar}])continue;${check}}`
                   _deferOrInline(ctx, lines, v, isObj ? inner + '}' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}}`)
       } else {
         lines.push('}')
@@ -5051,13 +5156,57 @@ function fastPrefixCheck(pattern, keyVar) {
   return `${keyVar}.startsWith(${JSON.stringify(prefix)})`
 }
 
+// The head of a loop over the own enumerable keys of `v`, written as
+// `for...in`, the fast way to walk an object, which also visits enumerable
+// keys its prototype carries. An ordinary object's prototype is
+// Object.prototype, and its keys are taken as they come; any other object, a
+// class instance or one made with Object.create, has each key checked as its
+// own, as the interpreter reads them. One statement, so the body that follows
+// is written as it was: `for(var _k in v)if(...)continue;else BODY`.
+// For a loop whose only work is to reject on a key it does not expect: the
+// key is the object's own, or the object is ordinary, whose prototype's keys
+// are taken as they come. Read only on the way to `return false`, so an
+// object that has only expected keys pays nothing.
+// `_ok` reads the prototype rather than the node's flag: this check can land
+// in a hoisted branch function the flag is not declared in.
+function ownFail (ctx, v, k = '_k') {
+  useOwnHelper(ctx, '_ok')
+  return `_ok(${v},${k})`
+}
+// 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
+// this is not only a cold path.
+function ownCountOff (ctx, v, n, pk) {
+  // A call to a shared helper rather than the test written in place: a oneOf
+  // branch this small is inlined into its caller by V8, and the longer
+  // bytecode cost that, 8% on a document of patch operations. The node's
+  // ordinary-object flag is not used: this can land in a hoisted branch
+  // function it is not declared in.
+  useOwnHelper(ctx, '_nk')
+  // `pk`: the node's own ordinary-object flag, where the caller holds it in
+  // the same function as this check. An ordinary object needs no recount.
+  return pk ? `(${pk}||_nk(${v},${n}))` : `_nk(${v},${n})`
+}
+
+function ownHead (ctx, v, k = '_k', kind = 'var') {
+  useOwnHelper(ctx, '_hop')
+  // Read here rather than taken from the node's flag: generated bodies that
+  // become functions of their own (branches, annotations, definitions) take
+  // the same parameter names and do not see the flag. Written in place, not
+  // through a shared helper, which would see every object shape of the
+  // document and read the prototype megamorphically: 7% on validate().
+  const i = ctx.varCounter++
+  return `var _pl${i}=${v}!==null&&typeof ${v}==='object'&&${protoIs(ctx, v)};for(${kind} ${k} in ${v})if(!_pl${i}&&!_hop.call(${v},${k}))continue;else `
+}
+
 // 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) {
-  if (keys.length === 0) return `for(var _k in ${v})return false`
+function genCharCodeSwitch(keys, v, ctx) {
+  if (keys.length === 0) return `for(var _k in ${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('&&')})return false`
+    return `for(var _k in ${v})if(${keys.map(k => `_k!==${JSON.stringify(k)}`).join('&&')}&&${ownFail(ctx, v)})return false`
   }
 
   // Group keys by first charCode
@@ -5074,7 +5223,7 @@ function genCharCodeSwitch(keys, v) {
     cases += `case ${cc}:if(${cond})continue;break;`
   }
 
-  return `for(var _k in ${v}){switch(_k.charCodeAt(0)){${cases}default:break}return false}`
+  return `for(var _k in ${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
@@ -5120,7 +5269,7 @@ function genUnevalDynamicVerdict(schema, v, lines, ctx, isObj, nonObjApplicators
 // additionalProperties is there.
 function addLocalAnnotations(node, v, S, out, ctx) {
   if (node.additionalProperties !== undefined) {
-    out.push(`for(const _ka in ${v})${S}.push(_ka)`)
+    out.push(`${ownHead(ctx, v, `_ka`, 'const')}${S}.push(_ka)`)
     return
   }
   for (const k of Object.keys(node.properties || {})) out.push(`if(Object.prototype.hasOwnProperty.call(${v},${JSON.stringify(k)}))${S}.push(${JSON.stringify(k)})`)
@@ -5136,7 +5285,7 @@ function addLocalAnnotations(node, v, S, out, ctx) {
       ctx.closureVals.push(safeReClosure(ctx, pat))
       tests.push(`_re${ri}.test(${kv})`)
     }
-    out.push(`for(const ${kv} in ${v})if(${tests.join('||')})${S}.push(${kv})`)
+    out.push(`${ownHead(ctx, v, kv, 'const')}if(${tests.join('||')})${S}.push(${kv})`)
   }
 }
 
@@ -5419,4 +5568,4 @@ Object.defineProperty(module.exports, '_expandDynamicScopes', { value: expandDyn
 // 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 = { 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 }
+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 }

package/lib/safe-regex.js

@@ -381,6 +381,24 @@ function __ataSafeRegex () {
     const states = []
     const stateIds = new Map()
     let overflow = false
+    // Transitions in one flat table per end flag, 128 slots per state (ASCII),
+    // -2 for not computed yet, -1 for overflow; `flags` holds isMatch (1) and
+    // dead (2) per state. The loop below then reads two typed arrays per
+    // character instead of a state object and the tables hanging off it. The
+    // tables grow with the states, so a pattern with few states stays small.
+    // State ids stay below MAX_STATES, so 16 bits hold them and the two
+    // sentinels: half the memory of the per-state tables this replaced.
+    let cap = 0
+    let trans = new Int16Array(0)
+    let transEnd = new Int16Array(0)
+    let flags = new Uint8Array(0)
+    function grow () {
+      const next = cap === 0 ? 2 : cap * 2
+      const t = new Int16Array(next * 128).fill(-2); t.set(trans); trans = t
+      const te = new Int16Array(next * 128).fill(-2); te.set(transEnd); transEnd = te
+      const f = new Uint8Array(next); f.set(flags); flags = f
+      cap = next
+    }
 
     function closure (list, count, pc, atStart, atEnd) {
       // Same walk as addThread, with the position replaced by the two flags.
@@ -411,7 +429,9 @@ function __ataSafeRegex () {
       let isMatch = false
       for (let k = 0; k < pcs.length; k++) if (ops[pcs[k]] === OP_MATCH) { isMatch = true; break }
       // `dead`: an anchored match with no thread left cannot recover.
-      states.push({ pcs: Int32Array.from(pcs), isMatch, dead: anchored && pcs.length === 0, next: new Int32Array(128).fill(-2), nextEnd: new Int32Array(128).fill(-2) })
+      states.push({ pcs: Int32Array.from(pcs) })
+      if (id >= cap) grow()
+      flags[id] = (isMatch ? 1 : 0) | (anchored && pcs.length === 0 ? 2 : 0)
       stateIds.set(key, id)
       return id
     }
@@ -452,37 +472,36 @@ function __ataSafeRegex () {
         id = startNonEmpty
       }
       if (id < 0) return testNFA(s)
-      let state = states[id]
-      if (len === 0) return state.isMatch
+      if (len === 0) return (flags[id] & 1) === 1
       // The last character is stepped with the end-of-input flag set and is
       // handled after the loop, so the loop body selects no table and tests
       // no position.
       const last = len - 1
       for (let pos = 0; pos < last; pos++) {
-        if (state.isMatch) return true
+        if ((flags[id] & 1) === 1) return true
         const c = s.charCodeAt(pos)
         let nid
         if (c < 128) {
-          nid = state.next[c]
-          if (nid === -2) { nid = step(state, c, false); state.next[c] = nid }
+          nid = trans[(id << 7) | c]
+          if (nid === -2) { nid = step(states[id], c, false); if (nid >= 0 || overflow) trans[(id << 7) | c] = nid }
         } else {
-          nid = step(state, c, false)
+          nid = step(states[id], c, false)
         }
         if (nid < 0) return testNFA(s)
-        state = states[nid]
-        if (state.dead) return false
+        id = nid
+        if ((flags[id] & 2) === 2) return false
       }
-      if (state.isMatch) return true
+      if ((flags[id] & 1) === 1) return true
       const c = s.charCodeAt(last)
       let nid
       if (c < 128) {
-        nid = state.nextEnd[c]
-        if (nid === -2) { nid = step(state, c, true); state.nextEnd[c] = nid }
+        nid = transEnd[(id << 7) | c]
+        if (nid === -2) { nid = step(states[id], c, true); if (nid >= 0 || overflow) transEnd[(id << 7) | c] = nid }
       } else {
-        nid = step(state, c, true)
+        nid = step(states[id], c, true)
       }
       if (nid < 0) return testNFA(s)
-      return states[nid].isMatch
+      return (flags[nid] & 1) === 1
     }
 
     return function test (s) {

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -24,6 +24,7 @@
         "require": "./index.js"
       },
       "import": {
+        "module": "./index.bundle.mjs",
         "module-sync": "./index.node.mjs",
         "default": "./index.mjs"
       },
@@ -137,6 +138,7 @@
     "index.js",
     "index.mjs",
     "index.node.mjs",
+    "index.bundle.mjs",
     "index.browser.mjs",
     "index.edge.js",
     "index.edge.mjs",
@@ -172,13 +174,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.51.0",
-    "@ata-validator/native-darwin-x64": "1.51.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.51.0",
-    "@ata-validator/native-linux-arm64-musl": "1.51.0",
-    "@ata-validator/native-linux-x64-gnu": "1.51.0",
-    "@ata-validator/native-linux-x64-musl": "1.51.0",
-    "@ata-validator/native-win32-x64": "1.51.0"
+    "@ata-validator/native-darwin-arm64": "1.52.0",
+    "@ata-validator/native-darwin-x64": "1.52.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.52.0",
+    "@ata-validator/native-linux-arm64-musl": "1.52.0",
+    "@ata-validator/native-linux-x64-gnu": "1.52.0",
+    "@ata-validator/native-linux-x64-musl": "1.52.0",
+    "@ata-validator/native-win32-x64": "1.52.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"