ata-validator 1.54.0 → 1.55.0

package/README.md

@@ -138,18 +138,18 @@ errors (7.6M with `richErrors: false`).
 
 | Dimension | Schema | ata-AOT | runtime validator | Difference |
 |---|---|---|---|---|
-| 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 | 315 Mops/s | 99 Mops/s | 3.2x faster |
-| Compile time | simple | 24 µs | 1.57 ms | 65x faster |
+| Bundle (gzipped) | simple | 1.4 KB | 52.7 KB | 38.3x smaller |
+| Bundle (gzipped) | complex | 3.1 KB | 52.7 KB | 16.8x smaller |
+| Bundle (gzipped) | nested | 4.7 KB | 52.7 KB | 11.3x smaller |
+| Cold start | simple | 20 ms | 38 ms | 1.9x faster |
+| Throughput (1M ops) | simple | 308 Mops/s | 115 Mops/s | 2.7x faster |
+| Compile time | simple | 25 µs | 1.42 ms | 56x 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-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
+with `npm run bench:aot-vs-ajv`. Numbers from one run on Apple M4 Pro, Node 25.2.1, 2026-10-15,
+on ata-validator 1.54.0. On 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.
@@ -280,21 +280,21 @@ 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** | 123.9 KB |
-| Time to a served request | **3.5 ms** | 7.6 ms |
+| In a bundle, gzipped | **2.2 KB** | 131.1 KB |
+| Time to a served request | **3.5 ms** | 6.9 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.51.0.
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.54.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
+`benchmark/bundle`, against 3.4 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
 a schema that arrives at run time can use any keyword, so the whole engine has to be
 there. The compiled module imports nothing and contains only the checks your schema asks
 for.
 
-**On a server, use whichever fits your schemas.** 124 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 131 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.
 
@@ -589,13 +589,15 @@ 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. 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
+order. Forty SchemaStore schemas imported into one app, minified with esbuild, go from 571.7 KB
+to 224.9 KB gzipped, and from 61.5 ms to 29.5 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 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.
+come to 104.4 KB gzipped against 224.9 KB as compact modules, and load and check each once in
+23.4 ms against 35.8, while a check once warm costs about five times what generated code costs.
+These are ata 1.54.0 figures; 1.51.0 measured 513.8, 213.3 and 102.4 KB, and the growth is the
+RFC 3986 walk that every module with a `uri` or `uri-reference` field now carries.
 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
@@ -603,13 +605,13 @@ share one 1.1 MB definitions file, come to 32.6 KB gzipped as schema modules aga
 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.51.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.54.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `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 |
+| `Validator` from `ata-validator` | 131.1 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `isValid` from the compiled module | **1.4 KB** | Nothing else is reachable, so the error collector is dropped |
+| `validate` from the compiled module | **2.0 KB** | Adds the detailed error collector |
 
 `--abort-early` makes the generated source about three times smaller, and after
 bundling it makes no difference: importing only `isValid` already leaves the error
@@ -645,7 +647,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.0 ms, ata 2.81 ms, no build step required.** ata registers in 0.20 ms of that and
+ajv 18.3 ms, ata 2.67 ms, no build step required.** ata registers in 0.22 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`.
 
@@ -754,7 +756,7 @@ Copy-paste recipes for the common frameworks. Most need 10-20 lines of glue. See
 
 ### Dialects
 
-`$schema` selects the dialect. Draft 2020-12 is the default; draft-07, draft-06 and Draft 2019-09 are rewritten to the 2020-12 spelling on the way in (draft-06 as draft-07 without `if`/`then`/`else`, 2019-09's tuple `items` and `$recursiveRef` as `prefixItems` and `$dynamicRef`); and `https://json-schema.org/v1` (or the dated `https://json-schema.org/v1/2026`) selects JSON Schema v1. The official suite passes in full on all five: 1301 of 1301 on 2020-12, 1261 of 1261 on 2019-09, 929 of 929 on draft-07, 841 of 841 on draft-06 and 1135 of 1135 on v1, with code generation allowed and blocked. Draft-04 and earlier are not supported; draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum` is read wherever it appears.
+`$schema` selects the dialect. Draft 2020-12 is the default; draft-07, draft-06, draft-04 and Draft 2019-09 are rewritten to the 2020-12 spelling on the way in (draft-06 as draft-07 without `if`/`then`/`else`, draft-04 as draft-06 with `id` for `$id` and without `const`, `contains` and `propertyNames`, 2019-09's tuple `items` and `$recursiveRef` as `prefixItems` and `$dynamicRef`); and `https://json-schema.org/v1` (or the dated `https://json-schema.org/v1/2026`) selects JSON Schema v1. The official suite passes in full on all five: 1301 of 1301 on 2020-12, 1261 of 1261 on 2019-09, 929 of 929 on draft-07, 841 of 841 on draft-06 and 1135 of 1135 on v1, with code generation allowed and blocked. Draft-04 and earlier are not supported; draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum` is read wherever it appears.
 
 Two things differ under v1. `propertyDependencies` selects a subschema by the value of a property rather than by its presence, which is what `dependentSchemas` does. And `$dynamicRef` no longer requires bookending: the reference resolves through the dynamic scope whether or not the schema it first lands on carries a matching `$dynamicAnchor`, so the outermost matching anchor still in scope wins. Everything else ata implements is identical under both dialects, so a schema that declares no `$schema` behaves exactly as before.
 
@@ -766,7 +768,7 @@ Both are implemented in the interpreted engine, so a v1 schema that uses `$dynam
 
 ### Known limitations
 
-Running the whole Draft 2020-12 suite with nothing excluded, `format` and `default` under specification semantics (`assertFormat: false`, `useDefaults: false`), gives 1301 of 1301 cases. Draft 7 gives 929 of 929. The v1 dialect gives 1135 of 1135. `npm run test:suite` reproduces all three.
+Running the whole Draft 2020-12 suite with nothing excluded, `format` and `default` under specification semantics (`assertFormat: false`, `useDefaults: false`), gives 1301 of 1301 cases. Draft 2019-09 gives 1261 of 1261, draft 7 929 of 929, draft-06 841 of 841, draft-04 618 of 618. The v1 dialect gives 1135 of 1135. `npm run test:suite` reproduces all three.
 
 Areas that remain deliberate scope decisions for 1.x:
 

package/error-runtime.d.ts

@@ -20,5 +20,12 @@ export function createErrors(schema: object, options?: { v1?: boolean }): (data:
 /** The linear-time pattern engine compact modules share (the RegExp-like object it returns has `test`). */
 export function compileSafe(source: string): { test(input: string): boolean };
 
+/**
+ * The RFC 3986 walk behind the `uri`, `uri-reference`, `iri` and
+ * `iri-reference` formats, which compact modules share. `mode` bit 1 asks
+ * for a scheme, bit 2 admits non-ASCII.
+ */
+export function uriWalk(input: string, mode: 0 | 1 | 2 | 3): boolean;
+
 /** The ata-validator version this runtime belongs to. */
 export const ataVersion: string;

package/error-runtime.js

@@ -24,6 +24,15 @@ function compileSafe(src) {
   return _safe(src);
 }
 
+// The RFC 3986 walk behind the uri, uri-reference, iri and iri-reference
+// formats, which a compact module imports from here instead of carrying the
+// factory's text; `mode` as lib/uri-core.js reads it.
+let _walk = null;
+function uriWalk(s, mode) {
+  if (_walk === null) _walk = require('./lib/formats.js').uriWalk;
+  return _walk(s, mode);
+}
+
 // Warm-up, in a browser only: the runtime's code compiles on its first use,
 // which a page would otherwise pay for on its first rejected document, about
 // a millisecond. When the browser is idle, one small error list is built here
@@ -37,4 +46,4 @@ if (typeof requestIdleCallback === 'function') { try { requestIdleCallback(warm)
 // once never runs it, and a server has it done before its first request.
 else if (typeof process === 'object' && process !== null && process.versions && process.versions.node && typeof setTimeout === 'function') { try { const t = setTimeout(warm, 0); if (t && typeof t.unref === 'function') t.unref(); } catch (_) {} }
 
-module.exports = { createErrors, compileSafe, ataVersion };
+module.exports = { createErrors, compileSafe, uriWalk, ataVersion };

package/error-runtime.mjs

@@ -1,3 +1,3 @@
 import mod from './error-runtime.js';
-export const { createErrors, compileSafe, ataVersion } = mod;
+export const { createErrors, compileSafe, uriWalk, ataVersion } = mod;
 export default mod;

package/lib/aot-impl.js

@@ -469,12 +469,24 @@ function toStandaloneModule(validator, opts) {
       for (const h of sharedDecls) errCore = errCore.split(h).join('');
     }
   }
+  // A compact module takes the URI walk from the runtime it imports rather
+  // than carrying the factory's text (about 1.3 KB gzipped per module).
+  let usesUriWalk = false;
+  // The texts as hoisted, which the preamble filter below matches against.
+  const sharedHoisted = sharedDecls.slice();
+  if (errorRuntime !== null && sharedDecls.length) {
+    const fs0 = require('./formats-source');
+    const full = fs0.uriHelperSource('_uri');
+    for (let i = 0; i < sharedDecls.length; i++) {
+      if (sharedDecls[i] === full) { sharedDecls[i] = fs0.uriHelperCompactSource('_uri'); usesUriWalk = true; }
+    }
+  }
   const sharedBlock = sharedDecls.length ? sharedDecls.join('\n') + '\n' : '';
 
   // Hoisted oneOf/anyOf branch checks live in the boolean fn's preamble (the
   // runtime emits them before the function). The standalone module must declare
   // them at module scope too, or _fn references undefined names (e.g. _af1_b0).
-  const sharedSet = new Set(sharedDecls);
+  const sharedSet = new Set(sharedHoisted);
   const preambleParts = jsFn._preambleParts
     ? jsFn._preambleParts.filter((part) => !sharedSet.has(part))
     : null;
@@ -631,7 +643,7 @@ function validateJSON(text) {
 ${errorRuntime === null ? '// Schema is embedded; runtime has zero dependency on ata-validator.' : '// Compact module: the verdict and the schema; errors come from the runtime it imports.'}
 // Re-run the build after upgrading ata: the version above is what wrote this.
 ${degradedNote}'use strict';
-${errorRuntime === null ? '' : format === 'esm' ? `import { createErrors as _ataCreateErrors${usesSafeRe ? ', compileSafe as _ataCompileSafe' : ''} } from ${JSON.stringify(errorRuntime)};\n` : `const { createErrors: _ataCreateErrors${usesSafeRe ? ', compileSafe: _ataCompileSafe' : ''} } = require(${JSON.stringify(errorRuntime)});\n`}${_CP_LEN_SOURCE}
+${errorRuntime === null ? '' : format === 'esm' ? `import { createErrors as _ataCreateErrors${usesSafeRe ? ', compileSafe as _ataCompileSafe' : ''}${usesUriWalk ? ', uriWalk as _ataUriWalk' : ''} } from ${JSON.stringify(errorRuntime)};\n` : `const { createErrors: _ataCreateErrors${usesSafeRe ? ', compileSafe: _ataCompileSafe' : ''}${usesUriWalk ? ', uriWalk: _ataUriWalk' : ''} } = require(${JSON.stringify(errorRuntime)});\n`}${_CP_LEN_SOURCE}
 ${errorRuntime !== null ? (usesSafeRe ? 'const __ataSafeRe = _ataCompileSafe;\n' : '') : safeRePrelude(jsFn, jsErrFn, onePass !== null && onePass.usesSafeRe ? { _usesSafeRe: true } : null)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({
   valid: false,
@@ -938,7 +950,12 @@ function bundleStandalone(Validator, schemas, opts) {
     return `(function(R){${preamble}var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
   });
   const arr = `[${fns.join(',')}]`;
-  const safeEmbed = (bundleUsesSafeRe ? getSafeRegexEmbed() + '\n' : '') +
+  // The code-point counter the length checks call. toStandaloneModule embeds
+  // it; the bundles did not, so a bundled minLength or maxLength threw a
+  // ReferenceError on the first string whose length its fast bounds left
+  // open (one character under minLength: 1, for one).
+  const cpLenEmbed = /\b_cpLen\(/.test(arr) && !/function _cpLen\b/.test(arr) ? _CP_LEN_SOURCE + '\n' : '';
+  const safeEmbed = (bundleUsesSafeRe ? getSafeRegexEmbed() + '\n' : '') + cpLenEmbed +
     (sharedDecls.length ? sharedDecls.join('\n') + '\n' : '');
   const registry = bundleInjects
     ? `var __formats=Object.create(null);\nfunction setFormats(map){for(var k in map)__formats[k]=map[k]}\n`
@@ -1108,6 +1125,12 @@ function bundleCompact(Validator, schemas, opts) {
     if (fmtOut.exportsSetFormats) out += 'module.exports.setFormats=setFormats;\n';
   }
 
+  // The code-point counter, as in bundleStandalone.
+  if (/\b_cpLen\(/.test(out) && !/function _cpLen\b/.test(out)) {
+    const head = isEsm ? 0 : out.indexOf("'use strict';\n") + "'use strict';\n".length;
+    const at = isEsm ? out.indexOf('\n') + 1 : head;
+    out = out.slice(0, at) + _CP_LEN_SOURCE + '\n' + out.slice(at);
+  }
   return out;
 }
 

package/lib/error-runtime.js

@@ -134,6 +134,7 @@ function _ataCode(k, f) {
 // The modules are evaluated on the first call, not when this file loads.
 function createErrors(schema, options) { return _ataRequire('error-runtime-entry').createErrors(schema, _ataCode, options); }
 function compileSafe(src) { return _ataRequire('safe-regex').compileSafe(src); }
+function uriWalk(s, m) { return _ataRequire('formats').uriWalk(s, m); }
 ${schemaMode ? "function createValidator(schema, options) { return _ataRequire('schema-runtime-entry').createValidator(schema, _ataCode, options); }\n" : ''}
 const ataVersion = ${JSON.stringify(version)};
 
@@ -151,8 +152,8 @@ if (typeof requestIdleCallback === 'function') { try { requestIdleCallback(warm)
 else if (typeof process === 'object' && process !== null && process.versions && process.versions.node && typeof setTimeout === 'function') { try { const t = setTimeout(warm, 0); if (t && typeof t.unref === 'function') t.unref(); } catch (_) {} }
 `;
   const out = format === 'cjs'
-    ? body + `module.exports = { createErrors, compileSafe, ${schemaMode ? 'createValidator, ' : ''}ataVersion };\n`
-    : body + `export { createErrors, compileSafe, ${schemaMode ? 'createValidator, ' : ''}ataVersion };\n`;
+    ? body + `module.exports = { createErrors, compileSafe, uriWalk, ${schemaMode ? 'createValidator, ' : ''}ataVersion };\n`
+    : body + `export { createErrors, compileSafe, uriWalk, ${schemaMode ? 'createValidator, ' : ''}ataVersion };\n`;
   _cache.set(key, out);
   return out;
 }

package/lib/formats-source.js

@@ -166,10 +166,17 @@ const uriWalkText = () => _uriSrc !== null ? _uriSrc : (_uriSrc = require('./uri
 const uriWalkSource = () => `(${uriWalkText()})(function(_s){${ipv6Source('_s', true)}return true})`
 // `_uri(s)` is the uri check, `_urif(s, mode)` the other three (the
 // expression in front for an iri), `_uriw(s, mode)` the walk alone.
-const uriHelperSource = (name) =>
-  'const _ufa=/' + _formats().URI_FAST.source + '/;const ' + name + 'w=' + uriWalkSource() + ';' +
+const uriHelperTail = (name) =>
   'function ' + name + '(_s){if(_ufa.test(_s))return true;return ' + name + 'w(_s,1)}' +
   'function ' + name + 'f(_s,_m){if((_m&1)===1&&_ufa.test(_s))return true;return ' + name + 'w(_s,_m)}'
+const uriHelperSource = (name) =>
+  'const _ufa=/' + _formats().URI_FAST.source + '/;const ' + name + 'w=' + uriWalkSource() + ';' + uriHelperTail(name)
+// The same helper for a compact module, which imports the walk from the
+// error runtime it already loads (`uriWalk as _ataUriWalk`) instead of
+// carrying the factory's text: forty SchemaStore schemas built that way
+// carried forty copies.
+const uriHelperCompactSource = (name) =>
+  'const _ufa=/' + _formats().URI_FAST.source + '/;const ' + name + 'w=_ataUriWalk;' + uriHelperTail(name)
 // The inline forms, for a caller with no function to hoist into: the walk is
 // built in place, which costs a factory per call, so the generators hoist.
 function uriSource (v, isStr) { return guard(v, isStr, `if(!/${_formats().URI_FAST.source}/.test(${v})&&!${uriWalkSource()}(${v},1))return false`) }
@@ -297,4 +304,4 @@ function durationSource (v, isStr) {
   const inner = `if(!${_formats().DURATION_RE.toString()}.test(${v}))return false`;
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
-module.exports = { uriHelperSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

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, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };
+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 };

package/lib/interpreter-core.js

@@ -876,7 +876,14 @@ class Interpreter {
     if (this._fast === undefined) {
       const compile = planCompiler();
       if (compile === null) this._fast = null;
-      else try { this._fast = compile(this); } catch { this._fast = null; }
+      else {
+        try { this._fast = compile(this); } catch (e) {
+          // The plain walk answers instead, which tests cannot tell apart;
+          // tests/test_plan_compiles.js holds the compiler to the suite.
+          if (typeof process === 'object' && process !== null && process.env && process.env.ATA_DEBUG) console.error('ata: plan compiler failed, plain walk used:', e && e.message);
+          this._fast = null;
+        }
+      }
     }
     return this._fast;
   }
@@ -1502,7 +1509,7 @@ function planCompiler() {
     compileInterpreter = loadPlanCompiler()({
       Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
       deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
-      T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
+      T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
     }).compileInterpreter;
   }
   return compileInterpreter;

package/lib/plan-compiler.js

@@ -53,7 +53,7 @@ const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string'
 function install(deps) {
   const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
           deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
-          T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
+          T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
   // `leaf`: the node compiled no subschema of its own (see compileNode). A
@@ -169,12 +169,21 @@ function install(deps) {
     }
     if (P.enum !== null) {
       if (P.enum.length === 0) checks.push(() => false);
+      else if (P.enumObjs.length === 0) { const prims = P.enumPrims; checks.push((data) => prims.has(data)); }
       else checks.push((data) => enumMember(P, data));
     }
     if (P.hasConst) {
       const c = P.const;
       checks.push((data) => deepEqual(c, data));
     }
+    // The value checks of each type, folded to one call or null. A node of
+    // one type and nothing but that type's keywords (the common leaf: a
+    // string with a length, an integer with a bound) is answered by one
+    // closure over typeof and that call, with no type bits computed and no
+    // chain of guarded checks: the interpreted engine spent a fifth of a
+    // document in those calls.
+    const reqFolded = P.required !== null && P.requiredUndef === null && P.properties !== null;
+    let numsRun = null;
     if (P.hasNumber) {
       const nums = [];
       if (P.minimum !== undefined) { const m = P.minimum; nums.push((d) => d >= m); }
@@ -182,36 +191,32 @@ function install(deps) {
       if (P.exclusiveMinimum !== undefined) { const m = P.exclusiveMinimum; nums.push((d) => d > m); }
       if (P.exclusiveMaximum !== undefined) { const m = P.exclusiveMaximum; nums.push((d) => d < m); }
       if (P.multipleOf !== undefined) { const m = P.multipleOf; nums.push((d) => multipleOfOk(d, m)); }
-      const run = combineValue(nums);
-      // A non-finite number is not of type `number` here: dataBits() gives it
-      // no type bit, and an empty schema accepts it. So the numeric keywords
-      // must not apply to it either, or `{ minimum: 3 }` rejects a value that
-      // `{}` accepts and the compiled engine admits.
-      if (run !== null) checks.push((data) => !Number.isFinite(data) || run(data));
+      numsRun = combineValue(nums);
     }
+    let strsRun = null;
     if (P.hasString) {
       const strs = [];
-      if (P.minLength !== undefined) { const m = P.minLength; strs.push((d) => cpAtLeast(d, m)); }
-      if (P.maxLength !== undefined) { const m = P.maxLength; strs.push((d) => cpAtMost(d, m)); }
+      if (P.minLength !== undefined && P.maxLength !== undefined) {
+        const lo = P.minLength, hi = P.maxLength;
+        strs.push((d) => { const n = d.length; return (n >= 2 * lo && n <= hi) || (cpAtLeast(d, lo) && cpAtMost(d, hi)); });
+      } else if (P.minLength !== undefined) { const m = P.minLength; strs.push((d) => cpAtLeast(d, m)); }
+      else if (P.maxLength !== undefined) { const m = P.maxLength; strs.push((d) => cpAtMost(d, m)); }
       if (P.pattern !== null) { const re = P.pattern; strs.push((d) => re.test(d)); }
       if (P.formatFn !== null) { const f = P.formatFn; strs.push((d) => f(d)); }
-      const run = combineValue(strs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_STRING || run(data)); }
+      strsRun = combineValue(strs);
     }
-    // `hasArray` also covers prefixItems/items/contains, which are not leaf
-    // keywords; only the three value-level ones belong here, exactly as
-    // evalLeafV() reads them.
+    let arrsRun = null;
     if (P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems) {
       const arrs = [];
       if (P.minItems !== undefined) { const m = P.minItems; arrs.push((d) => d.length >= m); }
       if (P.maxItems !== undefined) { const m = P.maxItems; arrs.push((d) => d.length <= m); }
       if (P.uniqueItems) arrs.push(allDistinct);
-      const run = combineValue(arrs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
+      arrsRun = combineValue(arrs);
     }
-    if (P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
+    let objsRun = null;
+    if ((P.required !== null && !reqFolded) || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
       const objs = [];
-      if (P.required !== null) {
+      if (P.required !== null && !reqFolded) {
         const req = P.required;
         // A required key holding undefined is missing; for a declared
         // property the property step finds it (requiredInProps).
@@ -239,9 +244,34 @@ function install(deps) {
           return true;
         });
       }
-      const run = combineValue(objs);
-      if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_OBJECT || run(data)); }
+      objsRun = combineValue(objs);
     }
+    if (P.hasType && P.enum === null && !P.hasConst && !P.hasCustom && checks.length === 1) {
+      const m = P.typeMask;
+      // The run of the type's own keywords, and whether any other type's are present.
+      const own = m === T_STRING ? strsRun : m === T_INTEGER || m === T_NUMBER ? numsRun : m === T_OBJECT ? objsRun : m === T_ARRAY ? arrsRun : null;
+      const foreign = (numsRun !== null && m !== T_INTEGER && m !== T_NUMBER) || (strsRun !== null && m !== T_STRING) || (arrsRun !== null && m !== T_ARRAY) || (objsRun !== null && m !== T_OBJECT);
+      if (!foreign) {
+        const r = own;
+        switch (m) {
+          case T_STRING: return r === null ? (d) => typeof d === 'string' : (d) => typeof d === 'string' && r(d);
+          case T_INTEGER: return r === null ? (d) => Number.isInteger(d) : (d) => Number.isInteger(d) && r(d);
+          case T_NUMBER: return r === null ? (d) => typeof d === 'number' && isFinite(d) : (d) => typeof d === 'number' && isFinite(d) && r(d);
+          case T_BOOLEAN: return (d) => typeof d === 'boolean';
+          case T_NULL: return (d) => d === null;
+          case T_OBJECT: return r === null ? (d) => typeof d === 'object' && d !== null && !Array.isArray(d) : (d) => typeof d === 'object' && d !== null && !Array.isArray(d) && r(d);
+          case T_ARRAY: return r === null ? (d) => Array.isArray(d) : (d) => Array.isArray(d) && r(d);
+        }
+      }
+    }
+    // A non-finite number is not of type `number` here: dataBits() gives it
+    // no type bit, and an empty schema accepts it. So the numeric keywords
+    // must not apply to it either, or `{ minimum: 3 }` rejects a value that
+    // `{}` accepts and the compiled engine admits.
+    if (numsRun !== null) { const run = numsRun; checks.push((data) => !Number.isFinite(data) || run(data)); }
+    if (strsRun !== null) { const run = strsRun; needsBits = true; checks.push((data, bits) => bits !== T_STRING || run(data)); }
+    if (arrsRun !== null) { const run = arrsRun; needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
+    if (objsRun !== null) { const run = objsRun; needsBits = true; checks.push((data, bits) => bits !== T_OBJECT || run(data)); }
 
     if (P.hasCustom) {
       needsBits = true;
@@ -317,6 +347,7 @@ function install(deps) {
 
     const steps = [];   // collect variant: (data, errors, ip, sp, stack, rec)
     const vsteps = [];  // verdict variant: (data, stack, rec)
+    let leafV = TRUE_FN;
 
     // $ref / $dynamicRef, resolved at compile time.
     for (let which = 0; which < 2; which++) {
@@ -392,7 +423,8 @@ function install(deps) {
         P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined ||
         P.dependentRequired !== null || P.hasCustom) {
       steps.push((data, errors, instancePath, schemaPath) => evalLeaf(P, data, errors, instancePath, schemaPath));
-      vsteps.push(compileLeafV(P));
+      leafV = compileLeafV(P);
+      if (leafV !== TRUE_FN) vsteps.push(leafV);
     }
 
     // Arrays
@@ -512,6 +544,10 @@ function install(deps) {
         ? P.patternProperties.map((e) => ({ re: e.re, src: e.src, fn: child(e.node) }))
         : null;
       const apFn = P.additionalProperties !== undefined ? child(P.additionalProperties) : null;
+      // The node's value checks, when they are the step before this one,
+      // run inside it: one closure call per object instead of two, and the
+      // composition above it goes away.
+      const fusedLeaf = vsteps.length > 0 && vsteps[vsteps.length - 1] === leafV && leafV !== TRUE_FN ? vsteps.pop() : null;
       // `additionalProperties: false` is a boolean subschema, but its error is
       // not the generic "boolean schema is false": every consumer switches on
       // keyword === 'additionalProperties' and reads params.additionalProperty
@@ -591,24 +627,49 @@ function install(deps) {
         // not mistaken for data. A long list walks the data's keys instead,
         // since the data usually carries far fewer.
         const n = propKeys.length;
+        // On an ordinary object (its prototype is Object.prototype) a key
+        // that names nothing on that prototype is read directly: a value
+        // means the key is the object's own, undefined means absent or held
+        // undefined, which the schema treats alike. Other objects, and keys
+        // such as `constructor` or `toString`, keep the own-property test.
+        const direct = propKeys.map((k) => !(k in Object.prototype));
+        const assertsObject = fusedLeaf !== null && P.hasType && P.typeMask === T_OBJECT;
         vsteps.push((data, stack, rec) => {
-          if (dataBits(data) !== T_OBJECT) return true;
+          if (fusedLeaf !== null && !fusedLeaf(data)) return false;
+          if (!assertsObject && dataBits(data) !== T_OBJECT) return true;
+          const plain = Object.getPrototypeOf(data) === Object.prototype;
           for (let i = 0; i < n; i++) {
             const key = propKeys[i];
-            if (!Object.hasOwn(data, key)) continue;
-            const value = data[key];
-            if (value !== undefined) { if (!propList[i].fn.v(value, stack)) return false; }
-            else if (propList[i].req) return false;
+            let value;
+            if (plain && direct[i]) {
+              value = data[key];
+              // Absent or held undefined: missing when required (the leaf
+              // step no longer checks it, reqFolded in compileLeafV). A key
+              // held undefined still counts as evaluated for the record.
+              if (value === undefined) { if (propList[i].req) return false; if (collect && Object.hasOwn(data, key)) addProp(rec, key); continue; }
+            } else {
+              if (!Object.hasOwn(data, key)) { if (propList[i].req) return false; continue; }
+              value = data[key];
+              if (value === undefined) { if (propList[i].req) return false; if (collect) addProp(rec, key); continue; }
+            }
+            if (!propList[i].fn.v(value, stack)) return false;
             if (collect) addProp(rec, key);
           }
           return true;
         });
-      } else vsteps.push((data, stack, rec) => {
+      } else {
+        // Required keys that are declared properties are counted as the walk
+        // meets them (reqFolded in compileLeafV); one short at the end means
+        // one is missing.
+        const reqN = P.required !== null && P.requiredUndef === null && P.requiredInProps !== null ? P.requiredInProps.size : 0;
+        vsteps.push((data, stack, rec) => {
+        if (fusedLeaf !== null && !fusedLeaf(data)) return false;
         if (dataBits(data) !== T_OBJECT) return true;
         const keys = collect ? keysOf(rec, data) : Object.keys(data);
         if (pnFn !== null) {
           for (const k of keys) if (!pnFn.v(k, stack)) return false;
         }
+        let seenReq = 0;
         for (let k = 0; k < keys.length; k++) {
           const key = keys[k];
           let evaluated = false;
@@ -617,6 +678,7 @@ function install(deps) {
             const value = data[key];
             if (value !== undefined) { if (!prop.fn.v(value, stack)) return false; }
             else if (prop.req) return false;
+            if (prop.req) seenReq++;
             evaluated = true;
           }
           if (patterns !== null) {
@@ -634,8 +696,9 @@ function install(deps) {
           }
           if (evaluated && collect) addProp(rec, key);
         }
-        return true;
+        return seenReq === reqN;
       });
+      }
     }
     if (P.dependentSchemas !== null) {
       const entries = P.dependentSchemas.map(([k, v]) => [k, inPlace(v, base), escapePointer(k)]);

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.54.0",
+  "version": "1.55.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",
@@ -174,13 +174,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.54.0",
-    "@ata-validator/native-darwin-x64": "1.54.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.54.0",
-    "@ata-validator/native-linux-arm64-musl": "1.54.0",
-    "@ata-validator/native-linux-x64-gnu": "1.54.0",
-    "@ata-validator/native-linux-x64-musl": "1.54.0",
-    "@ata-validator/native-win32-x64": "1.54.0"
+    "@ata-validator/native-darwin-arm64": "1.55.0",
+    "@ata-validator/native-darwin-x64": "1.55.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.55.0",
+    "@ata-validator/native-linux-arm64-musl": "1.55.0",
+    "@ata-validator/native-linux-x64-gnu": "1.55.0",
+    "@ata-validator/native-linux-x64-musl": "1.55.0",
+    "@ata-validator/native-win32-x64": "1.55.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"