ata-validator 1.43.0 → 1.44.0

package/README.md

@@ -244,21 +244,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.2 KB** | 95.6 KB |
-| Time to a served request | **3.5 ms** | 7.8 ms |
+| In a bundle, gzipped | **2.1 KB** | 110.7 KB |
+| Time to a served request | **3.5 ms** | 8.2 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.36.0.
-The startup row is a Hono route on Bun 1.4, median of nine interleaved runs, from
-`benchmark/bundle`, against 3.5 ms for the same app doing no validation at all, so the
+`new Validator(schema)`, built with `bun build --minify --target=browser` on ata 1.43.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.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.** 96 KB of JavaScript on a Node or Bun
+**On a server, use whichever fits your schemas.** 111 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.
 
@@ -491,7 +491,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.2 KB gzipped, full error detail included, against 95.6 KB for the runtime bundled for the browser.
+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 110.7 KB for the runtime bundled for the browser (ata 1.43.0).
 
 ```bash
 npx ata compile schemas/user.json -o src/generated/user.validator.mjs
@@ -533,13 +533,13 @@ npx ata build 'schemas/*.json' --out-dir build/validators --check
 Run with `--watch` during development for incremental rebuilds.
 
 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.36.0:
+minified and gzipped, measured with `bun build --minify --target=browser` on ata 1.43.0:
 
 | What the app imports | Size | Notes |
 |---|---|---|
-| `Validator` from `ata-validator` | 95.6 KB | The compiler ships with it, because a runtime schema can use any keyword |
+| `Validator` from `ata-validator` | 110.7 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 | **2.0 KB** | Adds the detailed error collector |
+| `validate` from the compiled module | **1.9 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

package/index.js

@@ -434,6 +434,9 @@ function installCodegenPaths (ctx) {
     }
     return nativeText ? getNative().rawFastValidate(this._fastSlot, Buffer.from(jsonStr)) : undefined;
   };
+  // The parsed document is left on `_lastParsed` for the rich layer around
+  // validateJSON, which hands it to the rejection so reading the errors does
+  // not parse the text again (see LazyJsonRejection).
   const validateText = (jsonStr) => {
     let obj;
     try {
@@ -442,6 +445,7 @@ function installCodegenPaths (ctx) {
       if (!(e instanceof SyntaxError)) throw e;
       return _jsonSyntaxRejection(e);
     }
+    this._lastParsed = obj;
     return jsonValidateFn(obj);
   };
   this.validateJSON = useSimdjsonForLarge && !preprocess
@@ -878,8 +882,58 @@ function buildParse (self, decline, extended) {
 // preprocess pass, the JSON-text scanner, the parse() copy and the
 // ahead-of-time bundle methods. parse() and the bundle methods load on first
 // use.
+// Cold start. A validator's first COLD_CALLS calls are answered by an
+// interpreted twin, built from the same schema and options with
+// `engine: 'interpreter'`, which the test suite holds to the same answers and
+// errors as the generated code. Generating code and having V8 compile it is
+// the largest part of a first call on a large schema: from process start to
+// one rejection with its error read, SchemaStore's SARIF schema took 87 ms
+// with code generated at the first call and 31 ms with the twin answering.
+// A validator still in use after that compiles as before, so a server reaches
+// the generated code's speed within its first requests, and a command line
+// tool or a short-lived function never pays to compile. Only where compiling
+// costs enough to matter: a schema whose size with its references followed
+// passes COLD_MIN characters (expandedChars in lib/js-compiler.js). A small
+// schema compiles in about a millisecond and is generated at its first call
+// as before, which also keeps every test that compares the generated code
+// with the interpreter comparing the generated code. Not for a validator with
+// an extension (_extendValidate, _extendChecks), which the twin would not
+// carry. Returns the twin to answer this call, or null to compile.
+const COLD_CALLS = 64;
+const COLD_MIN = 16 * 1024;
+// Whether the schema may expand past `limit`, answered from its text where
+// that settles it. Without a `$ref` nothing expands, and expandedChars counts
+// at most 8 for each character of the text, so a short schema is decided
+// without walking it. The text is the one _ensureCompiled needs anyway. Walking
+// every small route schema here cost a Fastify boot of ten routes 0.15 ms.
+function mayExpandPast (self, limit) {
+  const str = self._schemaStr || (self._schemaStr = JSON.stringify(self._schemaObj));
+  if (str === undefined) return false;
+  if (str.length * 8 <= limit && !str.includes('"$ref"')) return false;
+  return jsCompiler.expandedChars(self._schemaObj, limit) > limit;
+}
+
+function coldTwin (self, Validator) {
+  const n = self._coldCalls === undefined ? 0 : self._coldCalls;
+  if (n >= COLD_CALLS || self._validateTail !== null || self._verdictTail !== null) return null;
+  let t = self._twin;
+  if (t === undefined) {
+    t = null;
+    if (!self._interpretOnly && !self._initialized && mayExpandPast(self, COLD_MIN)) {
+      try { t = new Validator(self._rawSchema, Object.assign({}, self._options, { engine: 'interpreter' })); } catch { t = null; }
+    }
+    self._twin = t;
+  }
+  if (t === null) return null;
+  self._coldCalls = n + 1;
+  return t;
+}
+
 core._registerCodegen({
   jsCompiler,
+  coldTwin,
+  // The native locator for error frames, loaded with the first frame.
+  nativePositions: () => require('./lib/native-positions').nativeTargeted,
   installPaths: installCodegenPaths,
   compileVerdict: installCodegenPaths.compileVerdict,
   installScanner: installCodegenPaths.installScanner,

package/lib/clone-emit.js

@@ -78,8 +78,11 @@ function inlineRefsForClone(root) {
     for (const k of Object.keys(cur)) {
       if (strip && k === 'default') continue;
       const v = cur[k];
-      if (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') { out[k] = v; continue; }
-      out[k] = walk(v, active, strip);
+      // A property named "__proto__" is an own key of the copy: assigned, it
+      // set the copy's prototype and the property was gone from parse().
+      const w = (_INLINE_DATA_KEYS.has(k) || k === '$defs' || k === 'definitions') ? v : walk(v, active, strip);
+      if (k === '__proto__') Object.defineProperty(out, k, { value: w, writable: true, enumerable: true, configurable: true });
+      else out[k] = w;
     }
     if (siblingDefault !== undefined) out.default = siblingDefault;
     return out;

package/lib/data-position-cache.js

@@ -2,13 +2,17 @@
 
 const { buildDataPositionMap, buildTargetedPositionMap } = require('./data-positions');
 
+
 /**
  * Memoize the position map for the duration of a single validate() call.
  * Caller passes the original buffer/string. Identity-keyed: same reference
  * == same map. No global state, caller holds the cache instance.
  */
 
-function createCache () {
+// `nativeTargeted`, when given, is a faster source of the same entries: the
+// full entry point passes lib/native-positions.js, lite passes nothing.
+function createCache (nativeTargeted) {
+  const _nativeTargeted = typeof nativeTargeted === 'function' ? nativeTargeted : null;
   const wm = new WeakMap();
   const sm = new Map(); // strings can't go in WeakMap; clear after each validate
   let lastInput = null;
@@ -32,11 +36,13 @@ function createCache () {
         ? sm.get(input)
         : (Buffer.isBuffer(input) ? wm.get(input) : undefined);
       if (already) return already;
-      let filtered;
-      try {
-        filtered = buildTargetedPositionMap(input, wanted);
-      } catch {
-        return null;
+      let filtered = _nativeTargeted === null ? null : _nativeTargeted(input, wanted);
+      if (filtered === null) {
+        try {
+          filtered = buildTargetedPositionMap(input, wanted);
+        } catch {
+          return null;
+        }
       }
       let full;
       const fallback = (key) => {

package/lib/draft7.js

@@ -49,13 +49,11 @@ function _normalize(schema) {
   // dependencies → dependentSchemas + dependentRequired
   if (schema.dependencies) {
     for (const [key, value] of Object.entries(schema.dependencies)) {
-      if (Array.isArray(value)) {
-        if (!schema.dependentRequired) schema.dependentRequired = {}
-        schema.dependentRequired[key] = value
-      } else {
-        if (!schema.dependentSchemas) schema.dependentSchemas = {}
-        schema.dependentSchemas[key] = value
-      }
+      // defineProperty: a dependency on a property named "__proto__" is an
+      // own key here, where assignment would set the map's prototype.
+      const target = Array.isArray(value) ? 'dependentRequired' : 'dependentSchemas'
+      if (!schema[target]) schema[target] = {}
+      Object.defineProperty(schema[target], key, { value, writable: true, enumerable: true, configurable: true })
     }
     delete schema.dependencies
   }

package/lib/js-compiler.js

@@ -1065,6 +1065,16 @@ function hasOwnKey (d, key) {
   return _hop.call(d, key)
 }
 
+// Writes an own key. A schema can name a property, a definition or even a
+// keyword "__proto__", and assigning that key sets the copy's prototype
+// instead: the property was gone from the copy, so a constraint on it was
+// generated as nothing and accepted anything (a schema with such a property
+// and a reference the resolver rewrites, 1.40.1 to 1.43.0).
+function setOwn (o, k, v) {
+  if (k === '__proto__') Object.defineProperty(o, k, { value: v, writable: true, enumerable: true, configurable: true })
+  else o[k] = v
+}
+
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
   'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString'])
 
@@ -1380,7 +1390,7 @@ function aliasChainEnds(def, defs) {
 // source of evaluated properties the schema has; when it does not, the
 // schema is not generated and the interpreter answers.
 function unevalPropsModeled(schema, schemaMap) {
-  const own = Object.assign({}, schema)
+  const own = { ...schema }
   delete own.$defs
   delete own.definitions
   if (/"\$(?:ref|dynamicRef|recursiveRef)"/.test(JSON.stringify(own))) return false
@@ -1399,7 +1409,7 @@ function unevalPropsModeled(schema, schemaMap) {
     if (typeof sub !== 'object' || sub === null) return false
     const r = collectEvaluated(sub, schemaMap)
     if (r.dynamic || r.allProps) return false
-    const rest = Object.assign({}, sub)
+    const rest = { ...sub }
     delete rest.patternProperties
     const j = JSON.stringify(rest)
     if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
@@ -1432,7 +1442,7 @@ function unevalPropsModeled(schema, schemaMap) {
     if (typeof schema.if !== 'object' || schema.if === null) return false
     const r = collectEvaluated(schema.if, schemaMap)
     if (r.dynamic || r.allProps || r.props.length) return false
-    const rest = Object.assign({}, schema.if)
+    const rest = { ...schema.if }
     delete rest.patternProperties
     const j = JSON.stringify(rest)
     if (j.includes('"patternProperties"') || j.includes('"unevaluatedProperties"')) return false
@@ -1486,17 +1496,7 @@ function codegenSafe(schema, schemaMap) {
   }
 
   // Keys that collide with Object.prototype
-  if (schema.required) {
-    for (const k of schema.required) {
-      if (UNSAFE_KEYS.has(k)) return false
-    }
-  }
-  if (schema.properties) {
-    for (const k of Object.keys(schema.properties)) {
-      if (UNSAFE_KEYS.has(k)) return false
-      if (k === '$ref') return false // property named "$ref" — confusing
-    }
-  }
+
 
   // Unicode property escapes in pattern need 'u' flag — codegen uses RegExp without it
 
@@ -1627,10 +1627,8 @@ function codegenSafe(schema, schemaMap) {
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return false
     }
   }
-  if (typeof schema.propertyNames === 'object' && schema.propertyNames !== null) {
-    const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
-    if (Object.keys(schema.propertyNames).some(k => k !== '$schema' && !supported.includes(k))) return false
-  }
+  if (typeof schema.propertyNames === 'object' && schema.propertyNames !== null &&
+      !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return false
 
   // Recurse into sub-schemas — bail on boolean schemas in any position
   // A boolean subschema is a constant that every generator emits at its
@@ -1968,8 +1966,21 @@ function bothDefsContainers(schema) {
     schema.definitions !== null && typeof schema.definitions === 'object'
 }
 
+// The answer depends on the schema and the map alone, and the three
+// generators ask it about the same prepared schema in turn, so the last
+// answer is kept: each check walks the whole schema, and the second and third
+// asked again what the first had found. One entry, compared by identity,
+// because a WeakMap entry per schema cost more than the walk it saved on a
+// small schema that only ever gets its verdict generated.
+let _gateSchema = null, _gateMap = null, _gateOk = false
 function sharedCodegenGate(schema, schemaMap) {
   if (typeof schema !== 'object' || schema === null) return true
+  if (schema === _gateSchema && schemaMap === _gateMap) return _gateOk
+  const ok = sharedCodegenGateUncached(schema, schemaMap)
+  _gateSchema = schema; _gateMap = schemaMap; _gateOk = ok
+  return ok
+}
+function sharedCodegenGateUncached(schema, schemaMap) {
   if (bothDefsContainers(schema)) return false
   if (hasSameInstanceRefCycle(schema)) return false
   if (!codegenSafe(schema, schemaMap)) return false
@@ -1985,6 +1996,15 @@ function sharedCodegenGate(schema, schemaMap) {
 // `type: 'string'` and annotations go, on a copy. Anything else is left as
 // written and the gate declines. Errors keep the interpreted engine's path.
 const PN_SUPPORTED = new Set(['maxLength', 'minLength', 'pattern', 'const', 'enum'])
+// Whether the generators can write `propertyNames` as checks on the key in the
+// object's own key loop. Any other subschema is applied to each key as a
+// value of its own (genPropertyNamesNode and its error and combined
+// counterparts), which is what the interpreter does.
+function isSimplePN (pn) {
+  if (pn === null || typeof pn !== 'object' || Array.isArray(pn)) return false
+  for (const k of Object.keys(pn)) if (k !== '$schema' && !PN_SUPPORTED.has(k)) return false
+  return true
+}
 const PN_ANNOTATIONS = new Set(['$schema', '$comment', 'title', 'description', 'examples', 'default', 'deprecated', 'readOnly', 'writeOnly'])
 function simplePropertyNames(pn, defs) {
   const seen = new Set()
@@ -2006,7 +2026,7 @@ function simplePropertyNames(pn, defs) {
       return null
     }
     if (!PN_SUPPORTED.has(k)) return null
-    out[k] = val
+    setOwn(out, k, val)
   }
   return out
 }
@@ -2037,14 +2057,14 @@ function normalizePropertyNamesWalk(root) {
       return out
     }
     let out = node
-    const set = (k, v) => { if (out === node) out = { ...node }; out[k] = v }
+    const set = (k, v) => { if (out === node) out = { ...node }; setOwn(out, k, v) }
     for (const k of SUBSCHEMA_MAPS) {
       const map = node[k]
       if (!map || typeof map !== 'object') continue
       let copy = map
       for (const [name, sub] of Object.entries(map)) {
         const w = walk(sub)
-        if (w !== sub) { if (copy === map) copy = { ...map }; copy[name] = w }
+        if (w !== sub) { if (copy === map) copy = { ...map }; setOwn(copy, name, w) }
       }
       if (copy !== map) set(k, copy)
     }
@@ -2162,7 +2182,7 @@ function normalizeDeepRefsWalk(root) {
     if (inner) return node
     let out = node
     memo.set(node, out)
-    const own = (k, v) => { if (out === node) { out = { ...node }; memo.set(node, out) } out[k] = v }
+    const own = (k, v) => { if (out === node) { out = { ...node }; memo.set(node, out) } setOwn(out, k, v) }
     if (typeof node.$ref === 'string' && names.has(node.$ref)) own('$ref', '#/' + defsKey + '/' + names.get(node.$ref))
     for (const k of Object.keys(node)) {
       if (k === '$ref' || k === 'enum' || k === 'const' || k === 'default' || k === 'examples') continue
@@ -2211,10 +2231,39 @@ function normalizeRefs(root, schemaMap) {
   return out
 }
 const SKIP_VALUE_KEYS = new Set(['enum', 'const', 'default', 'examples'])
+// A schema whose every reference is `#` or a plain `#/$defs/name` (or
+// `definitions`), with no `$id` or `$anchor` below the root to move the base
+// they resolve against, needs nothing from the resolver: each reference
+// already reads as the generators read it. Telling that from the text skips
+// loading the interpreted engine and indexing the schema, which was most of
+// what preparing a small schema for code generation cost.
+const LOCAL_ONLY_REF = /^#(?:\/(?:\$defs|definitions)\/[^/~%]+)?$/
+function refsAllPlainLocal (root, text) {
+  const ids = text.split('"$id":').length - 1
+  if (ids > (typeof root.$id === 'string' ? 1 : 0) || text.includes('"$anchor":')) return false
+  const re = /"\$ref":("(?:[^"\\]|\\.)*")/g
+  let m
+  while ((m = re.exec(text)) !== null) {
+    let ref
+    try { ref = JSON.parse(m[1]) } catch { return false }
+    if (!LOCAL_ONLY_REF.test(ref)) return false
+  }
+  return true
+}
+
+// What the text of a schema prepared for code generation says about its size,
+// kept from the stringify normalizeRefsWalk makes anyway: its length when it
+// holds no `$ref`, -1 when it does. expandedChars counts at most 8 for each
+// character of a schema without references, so a short one is known not to
+// reach EXPANDED_SHARE without walking it again at every compile.
+const _refFreeLength = new WeakMap()
 function normalizeRefsWalk(root, schemaMap) {
   const text = JSON.stringify(root)
-  if (!text.includes('"$ref"')) return root
+  const hasRef = text.includes('"$ref"')
+  _refFreeLength.set(root, hasRef ? -1 : text.length)
+  if (!hasRef) return root
   if (/"\$(?:dynamicRef|recursiveRef|dynamicAnchor|recursiveAnchor)"/.test(text)) return null
+  if (refsAllPlainLocal(root, text)) return root
   const { indexSchemas, resolveRef } = require('./interpreter')._refInternals
   const state = indexSchemas(root, schemaMap && schemaMap.size ? schemaMap : null)
   const rootDialect = typeof root.$schema === 'string' ? root.$schema.replace(/#$/, '') : null
@@ -2280,7 +2329,7 @@ function normalizeRefsWalk(root, schemaMap) {
         out.$ref = t === root ? '#' : '#/' + defsKey + '/' + names.get(t)
         continue
       }
-      out[k] = SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k])
+      setOwn(out, k, SKIP_VALUE_KEYS.has(k) ? node[k] : walk(node[k]))
     }
     return out
   }
@@ -2299,6 +2348,46 @@ function prepareForCodegen(schema, schemaMap) {
 }
 
 const VERDICT_SPLIT = 64 * 1024
+// The schema's size with every local reference followed, each definition
+// sized once, annotations left out. A rough measure of the expanded verdict
+// source: on SchemaStore that runs about 1.4 times it at the median, and far
+// less where allOf merges. Past EXPANDED_SHARE the verdict is generated with
+// shared definitions from the start, instead of expanded first and thrown
+// away: SARIF comes to 2.1 million, and generating its 2.8 MB of expanded
+// source only to discard it was most of a cold first validate() (70 ms of the
+// 87 a command line run took to report one error). The bound is set where
+// only schemas that split anyway reach it: SARIF 2.1 measures about 706
+// thousand, while utcm-monitor (370 thousand) and accelerator (262 thousand)
+// stay expanded and keep their speed.
+const EXPANDED_SHARE = 400 * 1024
+const SIZE_SKIPS = new Set(['$defs', 'definitions', 'description', 'title', 'examples', 'default', '$comment', 'markdownDescription', 'deprecated', 'readOnly', 'writeOnly'])
+function expandedChars (root, limit) {
+  const defs = (root && (root.$defs || root.definitions)) || {}
+  const memo = new Map()
+  const size = (n, stack) => {
+    if (n === null || typeof n !== 'object') return 8
+    let t = 2
+    if (Array.isArray(n)) { for (const x of n) { t += size(x, stack) + 1; if (t > limit) return t } return t }
+    for (const k of Object.keys(n)) {
+      if (SIZE_SKIPS.has(k)) continue
+      const v = n[k]
+      if (k === '$ref' && typeof v === 'string') {
+        const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(v)
+        if (m && defs[m[1]] !== undefined && !stack.has(m[1])) {
+          let d = memo.get(m[1])
+          if (d === undefined) { stack.add(m[1]); d = size(defs[m[1]], stack); stack.delete(m[1]); memo.set(m[1], d) }
+          t += d
+          if (t > limit) return t
+          continue
+        }
+      }
+      t += k.length + 3 + size(v, stack)
+      if (t > limit) return t
+    }
+    return t
+  }
+  return size(root, new Set())
+}
 function sourceSize (lines, ctx) {
   let n = 0
   for (const l of lines) n += l.length
@@ -2340,13 +2429,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  // propertyNames: only codegen simple string constraints
-  if (schema.propertyNames) {
-    const pn = schema.propertyNames
-    const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
-    const keys = Object.keys(pn).filter(k => k !== '$schema')
-    if (keys.some(k => !supported.includes(k))) return null
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const anchors = {}
@@ -2389,7 +2472,11 @@ function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   // (79 KB of schema) came to 2.8 MB of verdict source, and compiling it was
   // half of the first validate() call.
   let ctx, lines
-  for (const share of [false, true]) {
+  const refFree = _refFreeLength.get(inputSchema)
+  const shareFirst = refFree !== undefined && refFree >= 0 && refFree * 8 <= EXPANDED_SHARE
+    ? false
+    : expandedChars(schema, EXPANDED_SHARE) > EXPANDED_SHARE
+  for (const share of shareFirst ? [true] : [false, true]) {
     ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: inputSchema, userFormats: userFormats || null, removeNodes,
       keywords: (opts && opts.keywords) || null, kwEmitted: null, shareDefs: share }
     if (ctx.keywords) ctx.kwEmitted = new Set()
@@ -3438,6 +3525,13 @@ function genPropertyNamesNode(schema, v, lines, ctx, knownType, isObj) {
   const pn = schema.propertyNames
   const ki = ctx.varCounter++
   const guard = isObj ? '' : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
+  if (!isSimplePN(pn)) {
+    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}}`)
+    return
+  }
   lines.push(`${guard}{for(const _k${ki} in ${v}){`)
   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`)
@@ -3760,7 +3854,7 @@ function genRefNode(schema, v, lines, ctx, knownType, hasSiblings) {
 function genPatternPropertiesNode(schema, v, lines, ctx, knownType, isObj) {
   let handledPropertyNames = false
   const ppEntries = Object.entries(schema.patternProperties)
-  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pn = isSimplePN(schema.propertyNames) ? schema.propertyNames : null
   const pi = ctx.varCounter++
   const kVar = `_ppk${pi}`
 
@@ -4821,12 +4915,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  if (schema.propertyNames) {
-    const pn = schema.propertyNames
-    const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
-    const keys = Object.keys(pn).filter(k => k !== '$schema')
-    if (keys.some(k => !supported.includes(k))) return null
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const eRootDefs = schema.$defs || schema.definitions || null
@@ -5791,6 +5880,13 @@ 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}){`)
+  // The subschema checks the key as a value, and its errors are reported at
+  // the object, as the interpreter reports them.
+  if (!isSimplePN(pn)) {
+    genCodeE(pn, `_k${ki}`, pathExpr, lines, ctx, schemaPrefix + '/propertyNames')
+    lines.push(`}}`)
+    return
+  }
   if (pn.minLength !== undefined) {
     lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
   }
@@ -5978,12 +6074,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats, opts)
       if (typeof sub === 'object' && sub !== null && !codegenSafe(sub, schemaMap)) return null
     }
   }
-  if (schema.propertyNames) {
-    const pn = schema.propertyNames
-    const supported = ['maxLength', 'minLength', 'pattern', 'const', 'enum']
-    const keys = Object.keys(pn).filter(k => k !== '$schema')
-    if (keys.some(k => !supported.includes(k))) return null
-  }
+  if (schema.propertyNames && typeof schema.propertyNames === 'object' && !isSimplePN(schema.propertyNames) && !codegenSafe(schema.propertyNames, schemaMap)) return null
 
   // Build anchors map for $ref/#anchor and $dynamicRef resolution
   const cRootDefs = schema.$defs || schema.definitions || null
@@ -6135,7 +6226,7 @@ function typeMismatchRest(schema, types) {
   for (const k of Object.keys(schema)) {
     if (drop.has(k)) continue
     if (rest === null) rest = {}
-    rest[k] = schema[k]
+    setOwn(rest, k, schema[k])
   }
   if (rest === null) return null
   // A node whose reference was already written (genCodeCNode) keeps that
@@ -6236,7 +6327,7 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (Object.keys(schema).some((k) => !REF_NEUTRAL_SIBLINGS.has(k) && !k.startsWith('x-'))) {
       if (!ctx.inCombined || ctx.inBranchFn) throw DECLINE
       genCodeCNode({ $ref: schema.$ref }, v, pathExpr, lines, ctx, schemaPrefix)
-      const rest = Object.assign({}, schema)
+      const rest = { ...schema }
       Object.defineProperty(rest, REF_DONE, { value: true })
       genCodeCNode(rest, v, pathExpr, lines, ctx, schemaPrefix)
       return
@@ -6905,7 +6996,7 @@ function emitAnnot(sub, ctx) {
   ctx.annFns.set(sub, null)
   const name = `_an${ctx.varCounter++}`
   const local = {}
-  for (const k of Object.keys(sub)) if (!ANNOT_APPLICATORS.has(k)) local[k] = sub[k]
+  for (const k of Object.keys(sub)) if (!ANNOT_APPLICATORS.has(k)) setOwn(local, k, sub[k])
   const vl = []
   nestedGenCode(local, '_av', vl, ctx)
   const decls = [`function ${name}_v(_av){${vl.join('\n  ')}\n  return true}`]
@@ -7053,7 +7144,7 @@ function emitAnnotI(sub, ctx) {
   annItemHelpers(ctx)
   const name = `_ai${ctx.varCounter++}`
   const local = {}
-  for (const k of Object.keys(sub)) if (!ANNOT_ITEM_APPLICATORS.has(k)) local[k] = sub[k]
+  for (const k of Object.keys(sub)) if (!ANNOT_ITEM_APPLICATORS.has(k)) setOwn(local, k, sub[k])
   const vl = []
   nestedGenCode(local, '_av', vl, ctx)
   const decls = [`function ${name}_v(_av){${vl.join('\n  ')}\n  return true}`]
@@ -7169,7 +7260,7 @@ function genAdditionalSchemaC(schema, v, pathExpr, lines, ctx, schemaPrefix, isO
 function genPatternPropertiesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail, isObj) {
   let handledPropertyNames = false
   const ppEntries = Object.entries(schema.patternProperties)
-  const pn = schema.propertyNames && typeof schema.propertyNames === 'object' ? schema.propertyNames : null
+  const pn = isSimplePN(schema.propertyNames) ? schema.propertyNames : null
   const pi = ctx.varCounter++
 
   // Build pattern matchers: prefer charCodeAt for simple prefixes
@@ -7290,7 +7381,16 @@ function genPropertyNamesFalseC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 function genPropertyNamesC(schema, v, pathExpr, lines, ctx, schemaPrefix, fail) {
   const pn = schema.propertyNames
   const ki = ctx.varCounter++
+  // In the rich function an error carries the value it was raised on, and
+  // 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}){`)
+  if (!isSimplePN(pn)) {
+    genCodeC(pn, `_k${ki}`, pathExpr, lines, ctx, schemaPrefix + '/propertyNames')
+    lines.push(`}}`)
+    return
+  }
   if (pn.minLength !== undefined) {
     lines.push(`if(_k${ki}.length<${pn.minLength}){${fail('minLength', 'propertyNames/minLength', `{limit:${pn.minLength}}`, `'must NOT have fewer than ${pn.minLength} characters'`)}}`)
   }
@@ -7508,6 +7608,6 @@ function _collectEval(schema, result, defs, schemaMap, refStack, isRoot) {
   // not → contributes nothing (spec: annotations from not are discarded)
 }
 
-module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, AJV_MESSAGES, _setCodeBudget }
+module.exports = { compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined, collectEvaluated, unevalContributions, expandedChars, AJV_MESSAGES, _setCodeBudget }
 // 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 })

package/lib/levenshtein.js

@@ -1,7 +1,14 @@
 'use strict';
 
-// Bounded Levenshtein. Returns Infinity if distance > maxDistance.
-// Single-row DP. O(n*m) worst case but typical strings are <30 chars.
+// Bounded Levenshtein. Returns Infinity if distance > maxDistance (or, past
+// the bound, possibly some number greater than it; callers compare).
+//
+// Only the cells within the bound of the diagonal are computed: a path
+// through any other cell already costs more than the bound. A typo hint asks
+// with a bound of one or two and compares the missing name with every key
+// present, so a row is five cells instead of the whole key. Without a bound
+// the band is the whole row.
+//
 // Two rows of scratch, reused across calls. The function is not recursive
 // and the library is single-threaded, so nothing else is using them; growing
 // them once beats allocating two arrays on every comparison, which the
@@ -10,42 +17,47 @@ let scratchA = new Int32Array(64);
 let scratchB = new Int32Array(64);
 
 function levenshtein (a, b, maxDistance) {
-  const max = maxDistance == null ? Infinity : maxDistance;
   if (a === b) return 0;
-  if (Math.abs(a.length - b.length) > max) return Infinity;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  if (scratchA.length < b.length + 1) {
-    scratchA = new Int32Array(b.length + 1);
-    scratchB = new Int32Array(b.length + 1);
+  const n = a.length;
+  const m = b.length;
+  const max = maxDistance == null || maxDistance > n + m ? n + m : maxDistance;
+  if (Math.abs(n - m) > max) return Infinity;
+  if (n === 0) return m;
+  if (m === 0) return n;
+  const big = max + 1;
+  if (scratchA.length < m + 2) {
+    scratchA = new Int32Array(m + 2);
+    scratchB = new Int32Array(m + 2);
   }
   let prev = scratchA;
   let curr = scratchB;
-  const bn = b.length;
-  for (let j = 0; j <= bn; j++) prev[j] = j;
-  for (let i = 1; i <= a.length; i++) {
-    curr[0] = i;
-    let rowMin = i;
+  for (let j = 0; j <= m; j++) prev[j] = j <= max ? j : big;
+  for (let i = 1; i <= n; i++) {
+    const lo = i - max > 1 ? i - max : 1;
+    const hi = i + max < m ? i + max : m;
+    curr[lo - 1] = lo === 1 ? i : big;
+    let rowMin = curr[lo - 1];
     // charCodeAt rather than indexing: reading a character by index allocates
     // a one-character string, and this is the innermost loop.
     const ca = a.charCodeAt(i - 1);
-    for (let j = 1; j <= bn; j++) {
-      const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
-      let m = prev[j - 1] + cost;
+    for (let j = lo; j <= hi; j++) {
+      let v = prev[j - 1] + (ca === b.charCodeAt(j - 1) ? 0 : 1);
       const del = curr[j - 1] + 1;
-      if (del < m) m = del;
+      if (del < v) v = del;
       const ins = prev[j] + 1;
-      if (ins < m) m = ins;
-      curr[j] = m;
-      if (m < rowMin) rowMin = m;
+      if (ins < v) v = ins;
+      if (v > big) v = big;
+      curr[j] = v;
+      if (v < rowMin) rowMin = v;
     }
+    if (hi < m) curr[hi + 1] = big;
     if (rowMin > max) return Infinity;
     // A destructured swap builds an array per row; a temporary does not.
     const t = prev;
     prev = curr;
     curr = t;
   }
-  return prev[bn];
+  return prev[m] > max ? Infinity : prev[m];
 }
 
 module.exports = { levenshtein };

package/lib/native-positions.js

@@ -0,0 +1,100 @@
+'use strict';
+
+// The entries buildTargetedPositionMap gives, found by the native addon where
+// it can: simdjson indexes the document's structure once and walks that
+// index to each pointer, where the script walk reads every character. On a
+// 5 MB log with the error near its end that is 3.1 ms against 8.3. Only for
+// a large ASCII string, where the addon's UTF-8 byte offsets are the string's
+// indexes, and only when every wanted pointer is found; otherwise null, and
+// the caller builds the map in script as before.
+const NATIVE_MIN = 32 * 1024;
+let _native;
+function nativeTargeted (text, wanted) {
+  if (typeof text !== 'string' || text.length < NATIVE_MIN) return null;
+  if (_native === undefined) {
+    try { _native = require('./native-load')(); } catch { _native = null; }
+    if (_native && typeof _native.locatePointers !== 'function') _native = null;
+  }
+  if (_native === null || typeof Buffer === 'undefined' || Buffer.byteLength(text, 'utf8') !== text.length) return null;
+  const ptrs = Array.from(wanted);
+  let found;
+  try { found = _native.locatePointers(text, ptrs); } catch { return null; }
+  const offs = [];
+  for (let k = 0; k < ptrs.length; k++) {
+    if (!(found[2 * k] >= 0)) return null;
+    offs.push(found[2 * k]);
+  }
+  // Line starts for the offsets that are asked about, in one forward pass.
+  const needed = [];
+  for (let k = 0; k < ptrs.length; k++) {
+    needed.push(offs[k]);
+    const ks = keyStartBefore(text, offs[k]);
+    if (ks >= 0) needed.push(ks);
+  }
+  const lineOf = lineFinder(text, needed);
+  const map = Object.create(null);
+  for (let k = 0; k < ptrs.length; k++) {
+    const off = offs[k];
+    const at = lineOf(off);
+    const entry = { byteOffset: off, length: found[2 * k + 1], line: at.line, col: off - at.start + 1, text: at.text };
+    const ks = keyStartBefore(text, off);
+    if (ks >= 0 && ptrs[k] !== '') {
+      const kat = lineOf(ks);
+      entry.keyOffset = ks;
+      entry.keyLength = keyEndAfter(text, ks) - ks + 1;
+      entry.keyLine = kat.line;
+      entry.keyCol = ks - kat.start + 1;
+    }
+    map[ptrs[k]] = entry;
+  }
+  return map;
+}
+
+// The opening quote of the member name before a value at `off`, or -1 where
+// the value is an array element or the root.
+function keyStartBefore (text, off) {
+  let j = off - 1;
+  while (j >= 0) { const c = text.charCodeAt(j); if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) j--; else break; }
+  if (j < 0 || text.charCodeAt(j) !== 0x3a) return -1;
+  j--;
+  while (j >= 0) { const c = text.charCodeAt(j); if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) j--; else break; }
+  if (j < 0 || text.charCodeAt(j) !== 0x22) return -1;
+  // Back to the quote that opens the name: one not preceded by an odd run of
+  // backslashes.
+  for (let q = j - 1; q >= 0; q--) {
+    if (text.charCodeAt(q) !== 0x22) continue;
+    let b = q - 1;
+    while (b >= 0 && text.charCodeAt(b) === 0x5c) b--;
+    if (((q - 1 - b) & 1) === 0) return q;
+  }
+  return -1;
+}
+function keyEndAfter (text, start) {
+  let q = start + 1;
+  for (;;) {
+    const c = text.charCodeAt(q);
+    if (c === 0x5c) { q += 2; continue; }
+    if (c === 0x22 || q >= text.length) return q;
+    q++;
+  }
+}
+// Line number, line start and line text for any of `offsets`, from one pass.
+function lineFinder (text, offsets) {
+  const sorted = Array.from(new Set(offsets)).sort((a, b) => a - b);
+  const info = new Map();
+  let line = 1, start = 0, s = 0;
+  while (s < sorted.length) {
+    const nl = text.indexOf('\n', start);
+    const end = nl === -1 ? text.length : nl;
+    while (s < sorted.length && sorted[s] <= end) {
+      info.set(sorted[s], { line, start, text: text.slice(start, end) });
+      s++;
+    }
+    if (nl === -1) break;
+    line++;
+    start = nl + 1;
+  }
+  return (off) => info.get(off);
+}
+
+module.exports = { nativeTargeted };

package/lib/rejections.js

@@ -133,13 +133,18 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
 // touches none of it. The JSON text is held here rather than read back off the
 // validator, so the result does not depend on what the instance does next.
 class LazyJsonRejection {
-  constructor(result, jsonStr, self, enrich) {
+  // `parsed`, when given, is the document the inner path parsed from
+  // `jsonStr` and validated, after defaults, coercion and removal: reading the
+  // errors uses it instead of parsing the text again, which on a 5 MB
+  // document was a third of what reading them cost.
+  constructor(result, jsonStr, self, enrich, parsed) {
     this.valid = false;
     this._result = result;
     this._jsonStr = jsonStr;
     this._self = self;
     this._enrich = enrich;
     this._cached = null;
+    this._parsed = parsed;
   }
   toJSON() {
     return { valid: false, errors: this.errors };
@@ -159,12 +164,14 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
 
     // The enrich pass plucks `received` from the value tree and the suggestion
     // engine (required-typo, format hints, coercion nudges) walks it too.
-    let parsedData;
-    try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-    // What was checked is the document after defaults, coercion and removal,
-    // so `received` has to come from that, as it does for validate(). A
-    // default that failed its own schema has no value in the text at all.
-    if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    let parsedData = this._parsed;
+    if (parsedData === undefined) {
+      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
+      // What was checked is the document after defaults, coercion and removal,
+      // so `received` has to come from that, as it does for validate(). A
+      // default that failed its own schema has no value in the text at all.
+      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    }
 
     // Errors the inner path already enriched carry a `received` key: enrich()
     // always sets one, even when there is no value to show. `code` is not a

package/lib/suggestions.js

@@ -29,22 +29,35 @@ const FORMAT_HINTS = {
   ipv4: (val) => typeof val === 'string' ? 'expected four 0-255 octets separated by dots' : null,
 };
 
-function suggestEnumTypo (received, enumValues) {
-  if (typeof received !== 'string') return null;
-  if (!Array.isArray(enumValues) || enumValues.length === 0 || enumValues.length > 30) return null;
+// Edits that still read as a typo of a name this long. With a flat two, a
+// missing `name` was "corrected" to `age`, and `c` to `a`.
+function typoBudget (name) {
+  const n = name.length;
+  return n < 3 ? 0 : n < 5 ? 1 : 2;
+}
+
+// The one string candidate nearest `target` within the budget, or null when
+// none is near enough or two are equally near.
+function nearest (target, candidates) {
+  const budget = typoBudget(target);
   let best = null;
-  let bestDist = Infinity;
+  let bestDist = budget + 1;
   let tied = false;
-  for (const v of enumValues) {
-    if (typeof v !== 'string') continue;
-    const d = levenshtein(received, v, 2);
-    if (d < bestDist) { best = v; bestDist = d; tied = false; }
+  for (const c of candidates) {
+    if (typeof c !== 'string') continue;
+    const d = levenshtein(target, c, budget);
+    if (d === 0 || d > budget) continue;
+    if (d < bestDist) { best = c; bestDist = d; tied = false; }
     else if (d === bestDist) tied = true;
   }
-  if (best && bestDist <= 2 && !tied) {
-    return { text: `did you mean \`${best}\`?`, kind: 'typo' };
-  }
-  return null;
+  return tied ? null : best;
+}
+
+function suggestEnumTypo (received, enumValues) {
+  if (typeof received !== 'string') return null;
+  if (!Array.isArray(enumValues) || enumValues.length === 0 || enumValues.length > 30) return null;
+  const best = nearest(received, enumValues);
+  return best === null ? null : { text: `did you mean \`${best}\`?`, kind: 'typo' };
 }
 
 // The widest container a typo hint is offered on. `suggestEnumTypo` caps its
@@ -56,14 +69,8 @@ const MAX_TYPO_CANDIDATES = 64;
 function suggestRequiredTypo (missing, presentKeys) {
   if (!missing || !Array.isArray(presentKeys)) return null;
   if (presentKeys.length > MAX_TYPO_CANDIDATES) return null;
-  for (const k of presentKeys) {
-    if (typeof k !== 'string') continue;
-    const d = levenshtein(missing, k, 2);
-    if (d <= 2 && d > 0) {
-      return { text: `did you mean \`${missing}\` instead of \`${k}\`?`, kind: 'similar-key' };
-    }
-  }
-  return null;
+  const best = nearest(missing, presentKeys);
+  return best === null ? null : { text: `did you mean \`${missing}\` instead of \`${best}\`?`, kind: 'similar-key' };
 }
 
 function suggestFormat (format, raw) {

package/lib/validator-core.js

@@ -604,8 +604,10 @@ function resolveSchemaForPreprocess(schema, schemaMap) {
     if (p && typeof p === 'object' && p.$ref && !p.type) {
       const t = resolveRefForPreprocess(p.$ref, schemaMap)
       if (t && typeof t === 'object') {
-        if (!cloned) { cloned = Object.assign({}, s); cloned.properties = Object.assign({}, s.properties) }
-        cloned.properties[key] = t
+        // Spread and defineProperty: a property named "__proto__" stays an own
+        // key of the copy (assignment would set the copy's prototype).
+        if (!cloned) { cloned = { ...s }; cloned.properties = { ...s.properties } }
+        Object.defineProperty(cloned.properties, key, { value: t, writable: true, enumerable: true, configurable: true })
       }
     }
   }
@@ -775,6 +777,7 @@ class Validator {
     // to attach dataFrame entries to each enriched error.
     this._posCache = null; // created by _pos() on first use, only the JSON text path needs it
     this._lastRawInput = null;
+    this._lastParsed = undefined;
     // undefined: not built yet. null: this schema has no scanner.
     this._scanner = undefined;
     // Checks a wrapper registered through _extendChecks. Declared here so
@@ -815,7 +818,7 @@ class Validator {
   }
 
   _pos() {
-    return this._posCache || (this._posCache = require('./data-position-cache').createCache());
+    return this._posCache || (this._posCache = require('./data-position-cache').createCache(_codegen !== null && _codegen.nativePositions ? _codegen.nativePositions() : null));
   }
 
   _ensureVocabularies() {
@@ -847,7 +850,12 @@ class Validator {
     // "validate this schema against its dialect" needs no network and no
     // caller-supplied registry. Only schemas that mention json-schema.org in a
     // reference pay for the lookup.
-    if (this._schemaStr.includes('json-schema.org/draft')) {
+    // A reference, not `$schema`: nearly every schema names its dialect, and
+    // matching that loaded the vendored meta-schemas into every validator's
+    // map, 27 entries that made its compile cache key a 30 KB string, rebuilt
+    // in 20 microseconds at each compile, and sent every compile through the
+    // external-document checks.
+    if (this._schemaStr.includes('json-schema.org/') && /"\$(?:ref|dynamicRef|recursiveRef)":"[^"]*json-schema\.org\//.test(this._schemaStr)) {
       const { METASCHEMAS } = require('./metaschemas');
       this._ownSchemaMap();
       for (const [id, meta] of METASCHEMAS) {
@@ -1104,6 +1112,17 @@ class Validator {
       _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
         : (data) => run(data).valid);
+      // Parsed, then the verdict first and the errors only for a document that
+      // fails: collecting them on every document cost an accepted 5 MB one 9 ms
+      // over JSON.parse and validate(). At this layer, below the presentation
+      // that the text path wraps around it: going through validate() as it
+      // stands once every layer is in place handed the text path errors
+      // already presented, and they lost their source anchor.
+      const runText = options.abortEarly
+        ? run
+        : (preprocess
+            ? (data) => { preprocess(data); return interp.isValid(data) ? VALID_RESULT : interp.validate(data); }
+            : (data) => (interp.isValid(data) ? VALID_RESULT : interp.validate(data)));
       this.validateJSON = (jsonStr) => {
         let data;
         try {
@@ -1112,9 +1131,19 @@ class Validator {
           if (!(e instanceof SyntaxError)) throw e;
           return _jsonSyntaxRejection(e);
         }
-        return run(data);
+        this._lastParsed = data;
+        return runText(data);
+      };
+      this.isValidJSON = (jsonStr) => {
+        let data;
+        try {
+          data = JSON.parse(jsonStr);
+        } catch (e) {
+          if (!(e instanceof SyntaxError)) throw e;
+          return false;
+        }
+        return this.isValidObject(data);
       };
-      this.isValidJSON = (jsonStr) => this.validateJSON(jsonStr).valid;
     }
 
     // Error presentation, one lazy layer: declaration-order sorting, rich
@@ -1163,21 +1192,38 @@ class Validator {
           // rejection it builds. Cleared as soon as it returns: the rejection
           // carries the text itself, so nothing outlives the call.
           this._lastRawInput = jsonStr;
-          let result;
+          this._lastParsed = undefined;
+          let result, parsed;
           try {
             result = innerJson(jsonStr);
           } finally {
             this._lastRawInput = null;
+            parsed = this._lastParsed;
+            this._lastParsed = undefined;
           }
           // Every diagnostic the text path adds is deferred. Deciding here
           // whether there is anything to add would mean reading `result.errors`,
           // and on the codegen path that realizes the inner lazy layer, which is
           // the document walk this exists to avoid.
           if (result && result.valid === false) {
-            return new LazyJsonRejection(result, jsonStr, this, enrich);
+            return new LazyJsonRejection(result, jsonStr, this, enrich, parsed);
           }
           return result;
         };
+      } else if (this.validateJSON) {
+        // Without enrichment the text path still presents its errors as
+        // validate() does, in declaration order: on generated code they came
+        // out in the order the function found them, so the same document gave
+        // its errors in one order from validate() and another from here.
+        const innerJson = this.validateJSON;
+        this.validateJSON = (jsonStr) => {
+          this._lastParsed = undefined;
+          const result = innerJson(jsonStr);
+          const parsed = this._lastParsed;
+          this._lastParsed = undefined;
+          if (!(result && result.valid === false && parsed !== undefined)) return result;
+          return present(result, parsed);
+        };
       }
     }
 
@@ -1211,10 +1257,12 @@ class Validator {
     // errorMessage keep the validate hot path untouched. Layered after rich
     // enrichment so `code`/`keyword`/`path` are already final and only the
     // human-facing message changes.
+    // The module loads only for a schema that has the keyword: loading it
+    // to ask was a file read on every process's first compile.
     {
-      const emLib = require('./error-messages');
       const schemaStr = this._schemaStr || (this._schemaObj ? JSON.stringify(this._schemaObj) : '');
-      if (emLib.schemaHasErrorMessages(schemaStr)) {
+      if (schemaStr.indexOf('"errorMessage"') !== -1) {
+        const emLib = require('./error-messages');
         const root = this._schemaObj;
         const wrap = (inner) => (arg) => {
           const result = inner(arg);
@@ -2184,7 +2232,15 @@ for (const [name, pick] of [
   });
 }
 
+// Cold start: an interpreted twin answers a large schema's first calls where
+// the code generator is registered (see coldTwin in index.js). Lite has none.
+Validator.prototype._coldTwin = function () {
+  return _codegen === null || _codegen.coldTwin === undefined ? null : _codegen.coldTwin(this, Validator);
+};
+
 _defineLazyMethod('validate', (self) => (data) => {
+  const t = self._coldTwin();
+  if (t !== null) return t.validate(data);
   self._ensureCompiled();
   return self.validate(data);
 });
@@ -2195,6 +2251,7 @@ _defineLazyMethod('isValidObject', (self) => {
   // again on every call, about 200 ns, ten times the check.
   let bound = false;
   return (data) => {
+  if (!bound) { const t = self._coldTwin(); if (t !== null) return t.isValidObject(data); }
   if (bound) return self.isValidObject(data);
   bound = true;
   // A validator that rewrites its input goes through the full compile, which
@@ -2234,10 +2291,14 @@ _defineLazyMethod('isValidObject', (self) => {
   };
 });
 _defineLazyMethod('validateJSON', (self) => (jsonStr) => {
+  const t = self._coldTwin();
+  if (t !== null) return t.validateJSON(jsonStr);
   self._ensureCompiled();
   return self.validateJSON(jsonStr);
 });
 _defineLazyMethod('isValidJSON', (self) => (jsonStr) => {
+  const t = self._coldTwin();
+  if (t !== null) return t.isValidJSON(jsonStr);
   self._ensureCompiled();
   return self.isValidJSON(jsonStr);
 });

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.43.0",
+  "version": "1.44.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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "release:check": "node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_embed.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_number_text_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_compiled_extension_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_error_list_differential.js && node tests/test_output_format.js && node tests/test_standard_json_schema.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_buffer_apis_without_native.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_embed.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_regex_ecma_whitespace.js && node tests/test_regex_native_linear.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_encoded_refs.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_schema_code_injection.js && node tests/test_aot_html_safe.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_alias_definitions.js && node tests/test_property_names_ref.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_custom_keyword_codegen.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_unevaluated_differential.js && node tests/fuzz_differential.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_error_read_paths.js && node tests/test_unique_items_error_pair.js && node tests/test_rich_errors_generated.js && node tests/test_captured_verdict_stub.js && node tests/test_generated_returns_rewrite.js && node tests/test_deep_pointer_refs.js && node tests/test_uneval_props_dynamic.js && node tests/test_one_pass_no_fallback.js && node tests/test_scanner_size_cap.js && node tests/test_scanner_index_keys.js && node tests/test_both_defs_containers.js && node tests/test_uneval_branch_counts.js && node tests/test_branch_verdicts.js && node tests/test_shared_definitions.js && node tests/test_compile_cache_bound.js && node tests/test_uneval_items_dynamic.js && node tests/test_escaped_property_names.js && node tests/test_ref_siblings_combined.js && node tests/test_unicode_property_patterns.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_render_without_process.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_aot_source_frames.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node tests/test_collect_evaluated.js && node tests/test_differential_tiers.js && node tests/test_draft7.js && node tests/test_dual_path.js && node tests/test_keywords_codegen.js && node tests/test_ref_cross.js && node tests/test_shape_classifier.js && node tests/test_tier0.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_no_eval.js && node tests/test_property_dependencies.js && node tests/test_v1_dialect.js && node tests/test_buffer_path_parity.js && node tests/test_number_text_parity.js && node tests/test_text_path_errors.js && node tests/test_compiled_parity.js && node tests/test_compiled_extension_parity.js && node tests/test_buffer_gate.js && node tests/test_scanner_differential.js && node tests/test_validate_json_scanner_cost.js && node tests/test_buffer_reject_cost.js && node tests/test_nan_verdict.js && node tests/test_remove_additional_nested.js && node tests/test_exclusive_bounds.js && node tests/test_engine_differential.js && node tests/test_error_shape_differential.js && node tests/test_error_list_differential.js && node tests/test_output_format.js && node tests/test_standard_json_schema.js && node tests/test_retry_message.js && node tests/test_describe_schema.js && node tests/test_aot_parse.js && node tests/test_draft7_semantics.js && node tests/test_metaschema_ref.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_esm_exports.js && node tests/test_version_sync.js && node tests/test_native_loaded.js && node tests/test_native_lazy.js && node tests/test_buffer_apis_without_native.js && node tests/test_cold_start_modules.js && node tests/test_safe_regex_embed.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_regex_ecma_whitespace.js && node tests/test_regex_native_linear.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_format_mode.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_engine_routing.js && node tests/test_engine_option.js && node tests/test_compile_cache_order.js && node tests/test_engine_diagnostic.js && node tests/test_format_engine_parity.js && node tests/test_error_accumulator_collision.js && node tests/test_uri_helper_parity.js && node tests/test_uri_fast_path.js && node tests/test_extend_verdict.js && node tests/test_ipv4_regex.js && node tests/test_ipv6_fast_path.js && node tests/test_nested_recursion_decline.js && node tests/test_generator_error_content.js && node tests/test_inherited_key_presence.js && node tests/test_proto_accessor.js && node tests/test_hybrid_tier.js && node tests/test_first_rejection_builds_one.js && node tests/test_container_local.js && node tests/test_one_shot_validate.js && node tests/test_fixed_pattern_inline.js && node tests/test_plan_source.js && node tests/test_fused_remove_additional.js && node tests/test_runtime_parse.js && node tests/test_formats_single_pass.js && node tests/test_email_format_cost.js && node tests/test_format_single_error.js && node tests/test_defs_pointer_alias.js && node tests/test_encoded_refs.js && node tests/test_cross_doc_root_ref.js && node tests/test_codegen_entrypoint_agreement.js && node tests/test_schema_code_injection.js && node tests/test_aot_html_safe.js && node tests/test_ref_annotation_siblings.js && node tests/test_gate_wrapped_schemas.js && node tests/test_pattern_message_escape.js && node tests/test_nested_defaults_engines.js && node tests/test_nested_coercion_parity.js && node tests/test_preprocess_cache.js && node tests/test_large_schema_codegen.js && node tests/test_base_uri.js && node tests/test_hoisted_def_recursion.js && node tests/test_alias_definitions.js && node tests/test_property_names_ref.js && node tests/test_hybrid_agreement.js && node tests/test_codegen_edge_shapes.js && node tests/test_deferred_def_scope.js && node tests/test_node_scoped_ctx_flags.js && node tests/test_fast_slot_exhaustion.js && node tests/test_ajv_errors.js && node tests/test_custom_keywords.js && node tests/test_custom_keyword_codegen.js && node tests/test_strict_schema.js && node tests/test_aot_external_checks.js && node tests/test_ajv_parity.js && node tests/test_user_format_error_path.js && node tests/test_unevaluated_error_path.js && node tests/test_unevaluated_error_shape.js && node tests/test_unevaluated_differential.js && node tests/fuzz_differential.js && node tests/test_pattern_properties_errors.js && node tests/test_additional_properties_scaling.js && node tests/test_additional_props_combined_cost.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_error_code_lookup.js && node tests/test_error_order.js && node tests/test_error_order_ordinal.js && node tests/test_ref_error_order.js && node tests/test_rejection_shape.js && node tests/test_lazy_normalization.js && node tests/test_value_equality.js && node tests/test_vocabulary.js && node tests/test_schema_scan.js && node tests/test_lazy_errors.js && node tests/test_error_read_paths.js && node tests/test_unique_items_error_pair.js && node tests/test_rich_errors_generated.js && node tests/test_captured_verdict_stub.js && node tests/test_generated_returns_rewrite.js && node tests/test_deep_pointer_refs.js && node tests/test_uneval_props_dynamic.js && node tests/test_one_pass_no_fallback.js && node tests/test_scanner_size_cap.js && node tests/test_scanner_index_keys.js && node tests/test_both_defs_containers.js && node tests/test_uneval_branch_counts.js && node tests/test_branch_verdicts.js && node tests/test_property_names_subschema.js && node tests/test_property_named_ref.js && node tests/test_validate_json_engines_same_errors.js && node tests/test_prototype_property_names.js && node tests/test_proto_name_rename_invariance.js && node tests/test_shared_definitions.js && node tests/test_compile_cache_bound.js && node tests/test_uneval_items_dynamic.js && node tests/test_escaped_property_names.js && node tests/test_ref_siblings_combined.js && node tests/test_unicode_property_patterns.js && node tests/test_cold_twin.js && node tests/test_native_positions.js && node tests/test_validate_json_single_parse.js && node tests/test_single_pass_errors.js && node tests/test_lazy_json_errors.js && node tests/test_lazy_instance.js && node tests/test_cyclic_input.js && node tests/test_native_error_codes.js && node tests/test_verdict_preprocess.js && node tests/test_lite_parity.js && node tests/test_lite_bundle_size.js && node tests/test_defaults_own_keys.js && node tests/test_plan_compiler.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_enrich_received.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_malformed_json_termination.js && node tests/test_data_positions.js && node tests/test_targeted_positions.js && node tests/test_position_map_cost.js && node tests/test_targeted_positions_cost.js && node tests/test_aot_staleness.js && node tests/test_file_positions.js && node tests/test_aot_positions_cost.js && node tests/test_schema_hash.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_render_without_process.js && node tests/test_additive_fields.js && node tests/test_diagnostic_source.js && node tests/test_diagnose.js && node tests/test_correlate.js && node tests/test_diagnostics_score.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_aot_source_frames.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_levenshtein_banded.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node tests/test_collect_evaluated.js && node tests/test_differential_tiers.js && node tests/test_draft7.js && node tests/test_dual_path.js && node tests/test_keywords_codegen.js && node tests/test_ref_cross.js && node tests/test_shape_classifier.js && node tests/test_tier0.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
     "test:compat": "node tests/test_compat.js",
@@ -143,13 +143,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.43.0",
-    "@ata-validator/native-darwin-x64": "1.43.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.43.0",
-    "@ata-validator/native-linux-arm64-musl": "1.43.0",
-    "@ata-validator/native-linux-x64-gnu": "1.43.0",
-    "@ata-validator/native-linux-x64-musl": "1.43.0",
-    "@ata-validator/native-win32-x64": "1.43.0"
+    "@ata-validator/native-darwin-arm64": "1.44.0",
+    "@ata-validator/native-darwin-x64": "1.44.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.44.0",
+    "@ata-validator/native-linux-arm64-musl": "1.44.0",
+    "@ata-validator/native-linux-x64-gnu": "1.44.0",
+    "@ata-validator/native-linux-x64-musl": "1.44.0",
+    "@ata-validator/native-win32-x64": "1.44.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"