ata-validator 1.53.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,24 +280,31 @@ 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.
 
+**On Node 22 or later, a process that starts often can keep V8's compiled code between
+starts.** Point `NODE_COMPILE_CACHE` at a directory that survives the restart, or call
+`module.enableCompileCache()` in your entry. Measured on an Apple M4 Pro, Node 25.2.1:
+loading ata goes from 4.9 to 2.7 ms, and a fresh process reaches its first validated
+document in 5.3 ms instead of 7.8. This is Node's feature, it covers every module the
+process loads, and ata does not turn it on for you.
+
 **In a browser, on an edge runtime, or anywhere cold starts are charged, compile.** This
 is where the difference is the whole story, and it is also where `new Function` is often
 blocked outright, which the compiled module does not need. With a bundler, adding `@ata-project/unplugin`
@@ -582,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
@@ -596,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
@@ -638,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`.
 
@@ -747,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.
 
@@ -759,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/compat.js

@@ -21,6 +21,9 @@ const { resolvePointer } = require('./lib/pointer.js');
 // `strictTuples` and `strictRequired` are accepted and ignored.
 
 const { Validator } = require('./index');
+// The interpreted engine's coercion where each type is checked and its
+// discriminator, which only compat asks for (see lib/interpreter-compat.js).
+require('./lib/interpreter-core')._setCompat(require('./lib/interpreter-compat'));
 const { METASCHEMAS } = require('./lib/metaschemas');
 const { normalizeExclusiveBounds } = require('./lib/draft7');
 const { createShaper, asReferenceKeyword } = require('./lib/compat-errors');
@@ -680,8 +683,16 @@ function fragmentKey(key) {
 // What a schema holds anywhere below it, read from the walk normalization
 // makes of it anyway (lib/schema-scan.js), which remembers it per object.
 const _scan = require('./lib/schema-scan');
-const F_BEYOND = _scan.BEYOND_ITEMS, F_DISCR = _scan.DISCRIMINATOR, F_DEFAULT = _scan.HAS_DEFAULT;
-const F_REF = _scan.HAS_REF, F_ALLOF = _scan.HAS_ALLOF, F_FORMAT = _scan.HAS_FORMAT;
+const F_REF = 1 << 16, F_BEYOND = 1 << 17, F_DISCR = 1 << 18, F_DEFAULT = 1 << 19, F_ALLOF = 1 << 20, F_FORMAT = 1 << 21;
+_scan._setExtraKeys(new Map([
+  ['$ref', F_REF | F_BEYOND], ['$dynamicRef', F_BEYOND], ['allOf', F_ALLOF | F_BEYOND],
+  ['anyOf', F_BEYOND], ['oneOf', F_BEYOND], ['not', F_BEYOND], ['if', F_BEYOND],
+  ['then', F_BEYOND], ['else', F_BEYOND], ['additionalProperties', F_BEYOND],
+  ['patternProperties', F_BEYOND], ['prefixItems', F_BEYOND], ['additionalItems', F_BEYOND],
+  ['contains', F_BEYOND], ['dependentSchemas', F_BEYOND], ['dependencies', F_BEYOND],
+  ['propertyNames', F_BEYOND], ['unevaluatedProperties', F_BEYOND], ['unevaluatedItems', F_BEYOND],
+  ['discriminator', F_DISCR], ['default', F_DEFAULT], ['format', F_FORMAT],
+]));
 const features = _scan.scan;
 
 const _metaValidators = new Map();

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/codegen-engine.js

@@ -69,7 +69,8 @@ function richBuilder(combRich, root, presentFallback, fallback, plain, cleanPlai
   return (data) => {
     const r = combRich(data);
     if (r.valid || !r.errors || !r.errors.length) return presentFallback(fallback, data);
-    const out = _needsOrdering(r.errors) ? _sortErrors(root, r.errors) : r.errors;
+    // `mo`: the list came out in the reader's order (see compileToJSCombined).
+    const out = r.mo === true || !_needsOrdering(r.errors) ? r.errors : _sortErrors(root, r.errors);
     // A collapsed oneOf or anyOf comes out plain (no docUrl) and is enriched
     // here, its branch errors with it, as presentErrors would.
     for (let i = 0; i < out.length; i++) {

package/lib/dialect.js

@@ -28,4 +28,39 @@ function isV1Dialect(schema) {
   return V1_DIALECTS.has(uri);
 }
 
-module.exports = { isV1Dialect, V1_DIALECTS };
+// The earlier dialects by their meta-schema URIs. draftCode is asked of every
+// schema, so it lives here, in a file every validator loads, and the
+// normalizers in draft7.js load only for a schema that declares one of these.
+// draft-06 is read through the draft-07 rules (see draft7.js).
+const DRAFT7_SCHEMAS = new Set([
+  'http://json-schema.org/draft-07/schema#',
+  'http://json-schema.org/draft-07/schema',
+  'http://json-schema.org/draft-06/schema#',
+  'http://json-schema.org/draft-06/schema',
+]);
+const DRAFT6_SCHEMAS = new Set([
+  'http://json-schema.org/draft-06/schema#',
+  'http://json-schema.org/draft-06/schema',
+]);
+// draft-04 is read through the draft-06 rules plus its own: `id` for `$id`,
+// and no `const`, `contains` or `propertyNames` (see draft7.js).
+const DRAFT4_SCHEMAS = new Set([
+  'http://json-schema.org/draft-04/schema#',
+  'http://json-schema.org/draft-04/schema',
+]);
+const DRAFT2019_SCHEMAS = new Set([
+  'https://json-schema.org/draft/2019-09/schema',
+  'https://json-schema.org/draft/2019-09/schema#',
+]);
+
+// 0 for 2020-12 and later, 1 draft-07, 2 draft-06, 3 2019-09, 4 draft-04.
+function draftCode(uri) {
+  if (typeof uri !== 'string') return 0;
+  if (DRAFT4_SCHEMAS.has(uri)) return 4;
+  if (DRAFT6_SCHEMAS.has(uri)) return 2;
+  if (DRAFT7_SCHEMAS.has(uri)) return 1;
+  if (DRAFT2019_SCHEMAS.has(uri)) return 3;
+  return 0;
+}
+
+module.exports = { isV1Dialect, V1_DIALECTS, DRAFT7_SCHEMAS, DRAFT6_SCHEMAS, DRAFT4_SCHEMAS, DRAFT2019_SCHEMAS, draftCode };

package/lib/draft7.js

@@ -6,16 +6,7 @@
 // this, a draft-06 schema was read under 2020-12 and its tuple `items`,
 // `additionalItems` and `dependencies` were not applied: 30 cases of the
 // official draft-06 suite accepted documents they must reject.
-const DRAFT7_SCHEMAS = new Set([
-  'http://json-schema.org/draft-07/schema#',
-  'http://json-schema.org/draft-07/schema',
-  'http://json-schema.org/draft-06/schema#',
-  'http://json-schema.org/draft-06/schema',
-])
-const DRAFT6_SCHEMAS = new Set([
-  'http://json-schema.org/draft-06/schema#',
-  'http://json-schema.org/draft-06/schema',
-])
+const { DRAFT7_SCHEMAS, DRAFT6_SCHEMAS, DRAFT4_SCHEMAS, DRAFT2019_SCHEMAS, draftCode } = require('./dialect')
 
 function isDraft7(schema) {
   return !!(schema && typeof schema.$schema === 'string' && DRAFT7_SCHEMAS.has(schema.$schema))
@@ -28,9 +19,11 @@ function isDraft6(schema) {
 // `force` applies the draft-07 rules to a document that declares no dialect
 // of its own, which is how a retrieved schema inherits the root's draft.
 // `draft6` says the document, or the root it inherits from, is draft-06.
-function normalizeDraft7(schema, force, draft6) {
+// `draft4`: draft-04, read as draft-06 plus its own differences (below).
+function normalizeDraft7(schema, force, draft6, draft4) {
   if (!force && !isDraft7(schema)) return schema
-  _normalize(schema, draft6 === true || isDraft6(schema))
+  const d4 = draft4 === true || (typeof schema.$schema === 'string' && DRAFT4_SCHEMAS.has(schema.$schema))
+  _normalize(schema, d4 || draft6 === true || isDraft6(schema), d4)
   return schema
 }
 
@@ -38,13 +31,21 @@ function normalizeDraft7(schema, force, draft6) {
 // definitions are addressable by pointer, annotations are inert.
 const REF_SIBLINGS_KEPT = new Set(['$ref', '$defs', 'definitions', '$schema', '$comment', 'title', 'description', 'examples', 'default', 'readOnly', 'writeOnly'])
 
-function _normalize(schema, d6) {
+function _normalize(schema, d6, d4) {
   if (typeof schema !== 'object' || schema === null) return
 
   // draft-06 has no conditional: `if`, `then` and `else` are unknown keywords
   // there, so they are dropped rather than applied.
   if (d6) { delete schema.if; delete schema.then; delete schema.else }
 
+  // draft-04 names a schema's identifier `id`, and has none of draft-06's
+  // `const`, `contains` or `propertyNames`: unknown keywords there.
+  if (d4) {
+    delete schema.const; delete schema.contains; delete schema.propertyNames
+    if (typeof schema.id === 'string' && schema.$id === undefined && typeof schema.$ref !== 'string') schema.$id = schema.id
+    delete schema.id
+  }
+
   // In draft-07 an object with `$ref` is that reference and nothing else:
   // sibling keywords, `$id` included, are ignored. Dropping them here gives
   // every engine the same reading without each having to know the draft.
@@ -97,7 +98,7 @@ function _normalize(schema, d6) {
       for (const k in m) {
         if (!Object.prototype.hasOwnProperty.call(m, k)) continue
         const v = m[k]
-        if (typeof v === 'object' && v !== null) _normalize(v, d6)
+        if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
       }
     }
   }
@@ -108,7 +109,7 @@ function _normalize(schema, d6) {
     if (Array.isArray(a)) {
       for (let i = 0; i < a.length; i++) {
         const v = a[i]
-        if (typeof v === 'object' && v !== null) _normalize(v, d6)
+        if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
       }
     }
   }
@@ -116,7 +117,7 @@ function _normalize(schema, d6) {
   // Recurse into single sub-schemas
   for (const key of D7_SINGLE_SUBS) {
     const v = schema[key]
-    if (typeof v === 'object' && v !== null) _normalize(v, d6)
+    if (typeof v === 'object' && v !== null) _normalize(v, d6, d4)
   }
 }
 // The schema-bearing keywords _normalize walks, built once rather than per node.
@@ -313,10 +314,6 @@ function _stripFormat(schema, seen) {
 // carries the anchor, and a plain `$ref: "#"` when it does not, which is what
 // 2019-09 says it means then. The outward search for the outermost anchored
 // resource is the same rule in both drafts.
-const DRAFT2019_SCHEMAS = new Set([
-  'https://json-schema.org/draft/2019-09/schema',
-  'https://json-schema.org/draft/2019-09/schema#',
-])
 const RECURSIVE_ANCHOR = '__ata_recursive_anchor'
 
 function isDraft2019(schema) {
@@ -368,12 +365,4 @@ function _normalize2019(node, resourceRoot, isRoot) {
 // The draft a `$schema` value names, for the normalizers: 2 draft-06,
 // 1 draft-07, 3 2019-09, 0 anything else. Takes the string so the caller
 // reads the property once.
-function draftCode(uri) {
-  if (typeof uri !== 'string') return 0
-  if (DRAFT6_SCHEMAS.has(uri)) return 2
-  if (DRAFT7_SCHEMAS.has(uri)) return 1
-  if (DRAFT2019_SCHEMAS.has(uri)) return 3
-  return 0
-}
-
 module.exports = { draftCode, isDraft7, isDraft6, isDraft2019, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions }

package/lib/enrich-site.js

@@ -16,9 +16,31 @@ const { reprValue, expectedFor, detailFor, rankFor, MISSING, DOC_BASE } = requir
 // output. A module of its own because only the code generator reaches it, and
 // ata-validator/lite, which enriches through `enrich`, should not carry it.
 const NO_EXPECTED = {};
+// `detail` (see detailFor in lib/enrich-error.js), worked out at the site as
+// far as the site allows: the whole string when it depends only on the
+// params, its fixed head when only the received value is left to append, and
+// neither when it depends on the value (type) or the params are not fixed.
+const DETAIL_AT_RUN = 0;
+const DETAIL_FIXED = 1;
+const DETAIL_HEAD = 2;
+const RANGE_KEYWORDS = new Set(['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'minLength', 'maxLength']);
+function siteDetail (keyword, params, expected) {
+  if (params === undefined || keyword === 'type') return [DETAIL_AT_RUN, undefined];
+  switch (keyword) {
+    case 'required': return [DETAIL_FIXED, `missing required property "${params.missingProperty}"`];
+    case 'additionalProperties': return [DETAIL_FIXED, `unknown property "${params.additionalProperty}"`];
+    case 'unevaluatedProperties': return [DETAIL_FIXED, `unevaluated property "${params.unevaluatedProperty}"`];
+    case 'format': return [DETAIL_HEAD, `not a valid ${params.format}: `];
+  }
+  if (RANGE_KEYWORDS.has(keyword) || expected) return [DETAIL_HEAD, `expected ${expected}, found `];
+  return [DETAIL_FIXED, undefined];
+}
+
 function errorSite (keyword, schemaPath, params, format) {
   const dependent = keyword === 'required' && typeof schemaPath === 'string' && schemaPath.endsWith('/dependentRequired');
   const code = (dependent && 'ATA7005') || codeFor(keyword, format) || 'ATA9001';
+  const expected = params === undefined ? NO_EXPECTED : expectedFor({ keyword, params });
+  const [detailKind, detail] = siteDetail(keyword, params, expected);
   return {
     code,
     keyword,
@@ -26,7 +48,9 @@ function errorSite (keyword, schemaPath, params, format) {
     docUrl: DOC_BASE + code,
     rank: rankFor(keyword),
     headline: (CODES[code] && CODES[code].headline) || 'validation failed',
-    expected: params === undefined ? NO_EXPECTED : expectedFor({ keyword, params }),
+    expected,
+    detailKind,
+    detail,
   };
 }
 
@@ -49,7 +73,10 @@ function makeRich (site, path, params, message, value, root, spPrefix) {
   };
   const sugg = suggestFor(out, root, at === MISSING ? undefined : at);
   if (sugg) out.suggestion = sugg;
-  const detail = detailFor({ keyword: site.keyword, params }, out, at);
+  const kind = site.detailKind;
+  const detail = kind === DETAIL_FIXED ? site.detail
+    : kind === DETAIL_HEAD ? site.detail + out.received
+      : detailFor({ keyword: site.keyword, params }, out, at);
   if (detail !== undefined) out.detail = detail;
   out.rank = site.rank;
   return out;

package/lib/error-runtime.js

@@ -23,6 +23,8 @@ const FILES = [
   'safe-regex',
   'unique-items',
   'formats',
+  // The URI walk formats.js loads; left out with formats (see OPTIONAL).
+  'uri-core',
 ];
 // The parts a build can leave out when none of its schemas needs them. The
 // decision is made on the schemas the runtime walks (as embedded, see
@@ -91,8 +93,10 @@ function errorRuntimeSource(format, version, features, schemaMode) {
   if (hit !== undefined) return hit;
   const defs = [];
   for (const name of schemaMode ? FILES.concat(SCHEMA_FILES) : FILES) {
-    const src = OPTIONAL[name] !== undefined && !want(name)
-      ? OPTIONAL[name].stub
+    // uri-core goes with formats: only formats.js requires it.
+    const part = name === 'uri-core' ? 'formats' : name;
+    const src = OPTIONAL[part] !== undefined && !want(part)
+      ? (name === 'uri-core' ? 'module.exports = {};' : OPTIONAL[part].stub)
       : dropCommentLines(fs.readFileSync(path.join(__dirname, name + '.js'), 'utf8'), name);
     // 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
@@ -130,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)};
 
@@ -147,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;
 }