ata-validator 1.47.0 → 1.48.0

package/README.md

@@ -43,6 +43,16 @@ npm install ata-validator --omit=optional
 
 or set `ATA_NO_NATIVE=1` at runtime. Typical schemas compile to specialized JS; shapes the compiler cannot represent (some `$dynamicRef`, cyclic `$ref`, unusual keyword interactions) fall back to an interpreted engine, so every schema validates in every environment. The pure-JS setup scores the same on the official suite as the native one, 1301 of 1301 Draft 2020-12 cases. The buffer and parallel APIs (`isValid` on raw buffers, `isValidPrepadded`, `isValidNDJSON`, `isValidParallel`, `countValid`, `batchIsValid`, `validateAndParse`) work without the addon too, answering through the same checks as `isValidJSON()`, slower than the addon: 177 ns against 92 for a small document on Node 25. In a browser, which has no `Buffer`, they throw and name the methods to use instead.
 
+Where the size of what ships matters more than nanoseconds per call, `ata-validator/lite` is
+the same `Validator` on the interpreted engine alone, without the code generator: the same
+verdicts and errors, 58 KB gzipped in a bundled worker against 136 KB for the full entry.
+It leaves out what needs the generator, `parse()` and the ahead-of-time bundle methods.
+
+On Deno the same package is `npm:ata-validator` or `jsr:@ata/validator`; the JSR package
+re-exports the npm one at the same version, and CI runs the official suite under Deno. The
+details, and what Deno Deploy's refusal of dynamic code means for it, are in
+[docs/edge-runtimes.md](docs/edge-runtimes.md).
+
 Those four now agree with `validate()` on every case of the official suite, 3365 across three dialects. The native walker behind them does not handle every shape (`contains`, `unevaluatedProperties`, `patternProperties`, tuple `items`, cross-document `$ref`, a few formats), so for schemas using one of those the buffer APIs parse the bytes and answer through `validate()`; the list is in `lib/buffer-gate.js`. Typical request schemas stay on the zero-copy path. `npm test` holds the disagreement count at zero.
 
 Where `new Function` is refused altogether, on Cloudflare Workers, Deno Deploy or under a strict Content-Security-Policy, ata drops to the interpreted engine and scores the same 1301 of 1301 with code generation blocked. No flags, and on Workers no `nodejs_compat` either. See [docs/edge-runtimes.md](docs/edge-runtimes.md).
@@ -280,6 +290,15 @@ const result = v.validate(data)
 
 The runtime API is unchanged from previous releases. Code written against the default validator's class keeps working through `ata-validator/compat`, which covers `compile`, `addSchema`, `addFormat`, `addKeyword`, `errorsText` and the rest of that surface, and reports errors in the same shape and order. `npx ata migrate` reports what the switch would change in a project, and what it cannot translate, before anything is written. See [docs/migration-from-ajv.md](docs/migration-from-ajv.md).
 
+Coming from the default validator, one command reports what the switch touches and a second applies the mechanical part:
+
+```bash
+npx ata migrate            # per file: imports to rewrite, addFormats() calls that go, sites to look at by hand
+npx ata migrate --write    # rewrites the imports to ata-validator/compat and removes the calls, leaves the rest
+```
+
+Coercion, defaults, `allErrors` and the error objects behave as before; the details and the limits are in [docs/migration-from-ajv.md](docs/migration-from-ajv.md).
+
 ## Usage
 
 ### Node.js

package/lib/enrich-error.js

@@ -254,9 +254,17 @@ function enrich (rawErr, opts) {
   // that answered wrote, the generator's internal ordering key included.
   if (rawErr.branchErrors) out.branchErrors = rawErr.branchErrors.map((b) => enrich(b, data !== undefined ? { data } : null));
 
+  // The frames come from the position map, which is a walk of the document.
+  // Given lazily (validateJSON's rejections), the walk waits for the first
+  // read of any error's `dataFrame` or `anchor`: a caller that reads the
+  // messages and paths never pays for it, and one that reads every frame
+  // pays once, as before. Given eagerly, the fields are set as before.
+  const named = (rawErr.params && (rawErr.params.additionalProperty || rawErr.params.unevaluatedProperty)) || null;
   if (positions && positions[path]) {
     const p = positions[path];
     out.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+  } else if (!positions && opts && opts.lazyPositions) {
+    defineLazyFrames(out, path, named, opts.lazyPositions);
   }
 
   // Attach schema source frame when the validator was constructed with a
@@ -286,7 +294,6 @@ function enrich (rawErr, opts) {
   // adds the key span so a caret can sit on the property that is wrong rather
   // than on the object containing it.
   if (opts && opts.positions) {
-    const named = (rawErr.params && (rawErr.params.additionalProperty || rawErr.params.unevaluatedProperty)) || null;
     const own = opts.positions[path];
     const child = named ? opts.positions[(path === '' ? '' : path) + '/' + named] : null;
     const src = child || own;
@@ -303,4 +310,42 @@ function enrich (rawErr, opts) {
   return out;
 }
 
+// `dataFrame` and `anchor` as accessors that resolve the position map on the
+// first read of either, on any error of the list (the map is shared through
+// `lazy`), and then become plain data properties, or go away when the map has
+// no entry for the error, which is the shape the eager path gives. Both are
+// enumerable, so JSON.stringify and a deep comparison read them as values;
+// a write replaces the accessor the way an assignment to a plain field would.
+function defineLazyFrames (out, path, named, lazy) {
+  let done = false;
+  let frames = null;
+  const resolve = () => {
+    if (done) return frames;
+    done = true;
+    const positions = lazy();
+    const own = positions ? positions[path] : null;
+    const dataFrame = own ? { byteOffset: own.byteOffset, length: own.length, line: own.line, col: own.col, text: own.text } : undefined;
+    const child = positions && named ? positions[(path === '' ? '' : path) + '/' + named] : null;
+    const src = child || own;
+    let anchor;
+    if (src) {
+      anchor = { line: src.line, col: src.col, length: src.length };
+      if (src.keyOffset !== undefined) {
+        anchor.keyLine = src.keyLine;
+        anchor.keyCol = src.keyCol;
+        anchor.keyLength = src.keyLength;
+      }
+    }
+    frames = { dataFrame, anchor };
+    if (dataFrame !== undefined) Object.defineProperty(out, 'dataFrame', { value: dataFrame, enumerable: true, configurable: true, writable: true });
+    else delete out.dataFrame;
+    if (anchor !== undefined) Object.defineProperty(out, 'anchor', { value: anchor, enumerable: true, configurable: true, writable: true });
+    else delete out.anchor;
+    return frames;
+  };
+  const settable = (name) => (v) => Object.defineProperty(out, name, { value: v, enumerable: true, configurable: true, writable: true });
+  Object.defineProperty(out, 'dataFrame', { get () { return resolve().dataFrame; }, set: settable('dataFrame'), enumerable: true, configurable: true });
+  Object.defineProperty(out, 'anchor', { get () { return resolve().anchor; }, set: settable('anchor'), enumerable: true, configurable: true });
+}
+
 module.exports = { enrich, reprValue, expectedFor, detailFor, rankFor, MISSING, DOC_BASE };

package/lib/js-compiler-errors.js

@@ -1351,9 +1351,15 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
+      const sp = schemaPrefix+'/properties/'+ptrSeg(key)
+      const from = lines.length
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+      // A large subschema as a function of its own (emitPropFnE); false means inline.
+      if (!propFnCandidateE(prop, ctx, sp) || !emitPropFnE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)) {
+        genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, sp)
+      }
       lines.push(`}`)
+      countInlineE(lines, from, ctx)
     }
   }
 
@@ -2039,6 +2045,86 @@ function emitSharedDefC(defName, v, pathExpr, lines, ctx, schemaPrefix) {
   return true
 }
 
+// The same split for the error collector (genCodeE): a large property
+// subschema becomes `_pe<n>(d,_p,_all,_e)` in the helper code, pushing into
+// the caller's list as an inlined body would, generated against the real
+// schema path since it has one call site. Not inside a shared definition's
+// body, whose placeholder path is substituted after the fact.
+function propFnCandidateE (prop, ctx, schemaPrefix) {
+  if (!ctx || ctx.nestedBoolean || ctx.condDepth) return false
+  if (typeof schemaPrefix !== 'string' || schemaPrefix.includes(SP_PLACEHOLDER)) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  let size = 0
+  try { size = JSON.stringify(prop).length } catch { return false }
+  return size >= SPLIT_C_SCHEMA || ((ctx.fnBytesE || 0) > SPLIT_C_BUDGET && size >= SPLIT_C_SMALL)
+}
+function emitPropFnE (prop, v, pathExpr, lines, ctx, schemaPrefix) {
+  const outerBytes = ctx.fnBytesE
+  ctx.fnBytesE = 0
+  const bodyLines = []
+  try { genCodeE(prop, 'd', '_p', bodyLines, ctx, schemaPrefix) } finally { ctx.fnBytesE = outerBytes }
+  if (bodyLines.length === 0) return false
+  const body = bodyLines.join('\n  ')
+  if (body.includes(SP_PLACEHOLDER)) return false
+  const fnName = '_pe' + (ctx.propFnsE = (ctx.propFnsE || 0) + 1)
+  ctx.helperCode.push(`function ${fnName}(d,_p,_all,_e){${body}}`)
+  lines.push(`${fnName}(${v},${pathExpr || '""'},_all,_e);if(!_all&&_e.length)return{valid:false,errors:_e}`)
+  return true
+}
+function countInlineE (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytesE = (ctx.fnBytesE || 0) + n
+}
+
+// A large property subschema as a function of its own, for the reason the
+// verdict generator has (emitPropFn in js-compiler.js): one function per
+// schema outgrew what V8 optimizes, and a 167 KB configuration schema's
+// one-pass function was 3.8 MB of source that ran in the interpreter. The
+// function is used at one site, so it is generated against the real schema
+// path and its errors keep their precise ordinal keys; it is not written
+// inside a shared definition's body, whose placeholder path is substituted
+// after the fact and would not reach a helper of its own.
+const SPLIT_C_SCHEMA = 1500
+const SPLIT_C_SMALL = 160
+const SPLIT_C_BUDGET = 16 * 1024
+function propFnCandidateC (prop, ctx, schemaPrefix) {
+  if (!ctx || ctx.inDefC || ctx.nestedBoolean || ctx.condDepth) return false
+  if (typeof schemaPrefix !== 'string' || schemaPrefix.includes(SP_PLACEHOLDER)) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  let size = 0
+  try { size = JSON.stringify(prop).length } catch { return false }
+  return size >= SPLIT_C_SCHEMA || ((ctx.fnBytesC || 0) > SPLIT_C_BUDGET && size >= SPLIT_C_SMALL)
+}
+function emitPropFnC (prop, v, pathExpr, lines, ctx, schemaPrefix) {
+  const outerHoisted = ctx.hoisted
+  ctx.hoisted = []
+  const outerBytes = ctx.fnBytesC
+  ctx.fnBytesC = 0
+  const bodyLines = []
+  let hoisted
+  try {
+    genGuardedC(prop, '_dv', '_p', bodyLines, ctx, schemaPrefix)
+  } finally {
+    hoisted = ctx.hoisted
+    ctx.hoisted = outerHoisted
+    ctx.fnBytesC = outerBytes
+  }
+  if (bodyLines.length === 0) return false
+  const body = bodyLines.join('\n  ')
+  if (body.includes(SP_PLACEHOLDER) || /\b_so\b/.test(body)) return false
+  const decl = hoisted.length ? `let ${hoisted.map((n) => n + '=null').join(',')};` : ''
+  const fnName = '_pc' + (ctx.propFnsC = (ctx.propFnsC || 0) + 1)
+  ctx.helperCode.push(`function ${fnName}(_dv,_p,d){const _all=true;${decl}let _e;\n  ${body}\n  return _e}`)
+  lines.push(`{const _r=${fnName}(${v},${pathExpr || '""'},d);if(_r!==undefined){if(_e===undefined)_e=_r;else for(let _i=0;_i<_r.length;_i++)_e.push(_r[_i])}}`)
+  return true
+}
+function countInlineC (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytesC = (ctx.fnBytesC || 0) + n
+}
+
 // One schema as a function of its own in the combined function (see
 // emitSharedDefC). The name is registered before the body is written, so a
 // reference back to it inside becomes a call. One that can re-enter itself,
@@ -2507,21 +2593,28 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
       const childPath = childPathExpr(pathExpr, ptrSeg(key))
+      const sp = schemaPrefix+'/properties/'+ptrSeg(key)
+      const from = lines.length
+      const split = propFnCandidateC(prop, ctx, sp)
+      // A large subschema as a function of its own (emitPropFnC), called
+      // where the inline code would be; false means it is written inline.
+      const sub = (pvExpr) => { if (!split || !emitPropFnC(prop, pvExpr, childPath, lines, ctx, sp)) genGuardedC(prop, pvExpr, childPath, lines, ctx, sp) }
       if (requiredSet.has(key) && isObj) {
         // A hoisted local was already cleared if the value is only inherited.
         lines.push(`if(${pv}!==undefined${hoisted[key] ? '' : '&&' + ownGuard(ctx, v, key)}){`)
-        genGuardedC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(pv)
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined&&${ownGuard(ctx, v, key)}){`)
-        genGuardedC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(`_o${oi}`)
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${ownKeyExpr(ctx, v, key)}){`)
-        genGuardedC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
+        sub(`${v}[${JSON.stringify(key)}]`)
         lines.push(`}`)
       }
+      countInlineC(lines, from, ctx)
     }
   }
 

package/lib/js-compiler.js

@@ -1161,6 +1161,60 @@ function _setCodeBudget (n) { codeBudget = n === undefined ? CODE_BUDGET : n }
 // document that reached it, and the second cut the cycle, so the reference
 // checked nothing. While `nestedBoolean` is set, genCode declines at those
 // points instead, and the caller's generator declines the schema.
+// A property whose subschema is large becomes a function of its own in the
+// preamble, called where the property is checked, instead of its code inline.
+// V8 does not optimize a function past its bytecode budget (about 60 KB), and
+// a configuration schema of a few hundred properties compiled to one function
+// of a megabyte or more that ran in the interpreter for its whole life: on a
+// 167 KB schema the verdict took 407 us where the same checks in functions of
+// their own take 40. The threshold is on the schema's own size, which is
+// known before any code is written, so nothing is generated twice. A
+// property moves out on its own only when its schema is plainly large; the
+// usual case is the budget: once a function holds SPLIT_FN_BUDGET bytes of
+// inline code, every property past SPLIT_PROP_SMALL moves out, so a schema
+// of many middling properties splits after its first functions' worth and a
+// small or medium one, whose whole program fits the budget, never does and
+// pays no call.
+const SPLIT_PROP_SCHEMA = 2000
+const SPLIT_PROP_SMALL = 220
+const SPLIT_FN_BUDGET = 24 * 1024
+function propSchemaSize (prop) {
+  try { return JSON.stringify(prop).length } catch { return 0 }
+}
+function propFnCandidate (prop, ctx) {
+  if (!ctx.preamble || ctx.nestedBoolean || ctx.condDepth) return false
+  if (!prop || typeof prop !== 'object' || Array.isArray(prop)) return false
+  const size = propSchemaSize(prop)
+  return size >= SPLIT_PROP_SCHEMA || ((ctx.fnBytes || 0) > SPLIT_FN_BUDGET && size >= SPLIT_PROP_SMALL)
+}
+// Generated over its own `d`, the way a shared definition is (see the $ref
+// case in genCodeNode): the deferred checks belong to this body, and the
+// plain-object reuse state must not leak in or out. Null means "write it
+// inline after all": an empty body (the inline path then asserts it the
+// usual way) or one that calls the recursive entry, which is out of scope
+// in the preamble.
+function emitPropFn (prop, ctx) {
+  const bodyLines = []
+  const outerDeferred = ctx.deferredChecks
+  ctx.deferredChecks = null
+  const outerReuse = ctx.plainReuse
+  ctx.plainReuse = undefined
+  const outerBytes = ctx.fnBytes
+  ctx.fnBytes = 0
+  try { genCode(prop, 'd', bodyLines, ctx) } finally { ctx.plainReuse = outerReuse; ctx.fnBytes = outerBytes }
+  if (ctx.deferredChecks) for (const dc of ctx.deferredChecks) bodyLines.push(dc)
+  ctx.deferredChecks = outerDeferred
+  if (bodyLines.length === 0 || bodyLines.some((l) => /\b_validate\b/.test(l))) return null
+  const fnName = '_pf' + (ctx.propFns = (ctx.propFns || 0) + 1)
+  hoist(ctx, `function ${fnName}(d){${bodyLines.join('\n  ')}\n  return true}`)
+  return fnName
+}
+function countInline (lines, from, ctx) {
+  let n = 0
+  for (let i = from; i < lines.length; i++) n += lines[i].length
+  ctx.fnBytes = (ctx.fnBytes || 0) + n
+}
+
 function nestedGenCode(schema, v, lines, ctx) {
   ctx.nestedBoolean = (ctx.nestedBoolean || 0) + 1
   const before = lines.length
@@ -3498,11 +3552,17 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
   // properties — use hoisted vars for required props, hoist optional to locals too
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
+      const from = lines.length
+      // A large subschema as a function of its own (emitPropFn); the call
+      // takes the place of the inline code in each of the three shapes below.
+      const fn = propFnCandidate(prop, ctx) ? emitPropFn(prop, ctx) : null
       if (requiredSet.has(key) && isObj) {
         // Required + type:object — hoist to local to reduce repeated property lookups
         const access = hoisted[key] || `${v}[${JSON.stringify(key)}]`
-        const combined = tryGenCombined(prop, access, ctx)
-        if (combined) {
+        const combined = fn ? null : tryGenCombined(prop, access, ctx)
+        if (fn) {
+          lines.push(`if(!${fn}(${access}))return false`)
+        } else if (combined) {
           lines.push(combined)
         } else if (needsLocal(prop) || isPlainContainer(prop)) {
           const oi = ctx.varCounter++
@@ -3518,8 +3578,10 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         const oi = ctx.varCounter++
         const local = `_o${oi}`
         lines.push(`{const ${local}=${v}[${JSON.stringify(key)}];if(${local}!==undefined&&${ownGuard(ctx, v, key)}){`)
-        const combined = tryGenCombined(prop, local, ctx)
-        if (combined) {
+        const combined = fn ? null : tryGenCombined(prop, local, ctx)
+        if (fn) {
+          lines.push(`if(!${fn}(${local}))return false`)
+        } else if (combined) {
           lines.push(combined)
         } else {
           genCode(prop, local, lines, ctx)
@@ -3527,9 +3589,11 @@ function genCodeNode(schema, v, lines, ctx, knownType) {
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${ownKeyExpr(ctx, v, key)}){`)
-        genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
+        if (fn) lines.push(`if(!${fn}(${v}[${JSON.stringify(key)}]))return false`)
+        else genCode(prop, `${v}[${JSON.stringify(key)}]`, lines, ctx)
         lines.push(`}`)
       }
+      countInline(lines, from, ctx)
     }
   }
 

package/lib/rejections.js

@@ -84,17 +84,16 @@ class RichRejection {
 // legacy key set, or enriched. Shared by both rejection classes below.
 function presentErrors(raw, data, rawInput, self, root, enrich) {
   if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(root, raw);
-  // The position map, resolved now that an error is actually being read.
-  let positions = null;
-  if (enrich && raw.length && rawInput != null) {
-    positions = self._pos().targeted(rawInput, wantedPointersFor(raw));
-    if (positions) self._posCache.reset();
-  }
+  // The position map, resolved on the first read of an error's frame (see
+  // defineLazyFrames in lib/enrich-error.js): a walk of the document that a
+  // caller reading messages and paths never needs.
+  const lazyPositions = enrich && raw.length && rawInput != null ? lazyPositionsFor(self, rawInput, raw) : null;
   // One options object for the whole list, not one per error.
   const opts = enrich && raw.length
     ? {
         data,
-        positions,
+        positions: null,
+        lazyPositions,
         schemaPositions: self._schemaPositions,
         schemaFile: self._source ? self._source.path : undefined,
       }
@@ -180,13 +179,16 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
     // on raw errors; taking it as the signal left those errors without
     // `received` or a suggestion on the text path while validate() had both.
     if (!raw[0] || !('received' in raw[0])) {
-      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw));
       // Declaration order, as validate() applies it; the text path used to
       // enrich in emission order.
       const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      // The position map waits for the first read of a frame (lib/enrich-error
+      // defineLazyFrames); until then reading the list costs the enrichment alone.
+      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
       const enrichOpts = {
         data: parsedData,
-        positions,
+        positions: null,
+        lazyPositions,
         schemaPositions: self._schemaPositions,
         schemaFile: self._source ? self._source.path : undefined,
       };
@@ -195,11 +197,11 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
       attachDiagnosticSource(enriched, {
         data: parsedData,
         text: jsonStr,
-        positions,
+        // Read by the diagnostic renderer only, which resolves the same map.
+        get positions () { return lazyPositions(); },
         schema: self._schemaObj,
         mutatesInput: self._mutatesInput === true,
       });
-      if (positions) self._posCache.reset();
       this._cached = enriched;
       return enriched;
     }
@@ -232,6 +234,20 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
   },
 });
 
+// The targeted position map for a list, built on the first call and shared
+// by every error's frame accessor (lib/enrich-error defineLazyFrames).
+function lazyPositionsFor (self, text, errors) {
+  let done = false;
+  let positions = null;
+  return () => {
+    if (done) return positions;
+    done = true;
+    positions = self._pos().targeted(text, wantedPointersFor(errors));
+    if (positions) self._posCache.reset();
+    return positions;
+  };
+}
+
 // The pointers a set of errors will ask the position map about. lib/enrich-error
 // looks up the error's own path, and for an additional or unevaluated property
 // the child pointer named in `params`, unescaped, which is the form it asks for.

package/lib/scan-compiler.js

@@ -892,7 +892,7 @@ function emitArray(schema, ctx, out, depth) {
 // Every `return 0` inside the member becomes that record, which is also how
 // the rule reaches nested objects: an inner object's own verdict is a value
 // failure at the level above it.
-function emitMember(sub, ctx, out, depth, objId) {
+function emitMember(sub, ctx, out, depth, objId, kn) {
   let lines = [];
   emitValue(sub, ctx, lines, depth + 1);
   // A large member value becomes a function of its own, so no one function
@@ -921,9 +921,17 @@ function emitMember(sub, ctx, out, depth, objId) {
   out.push(label + ':{');
   out.push(body.split('return 0;').join('{_f' + objId + '=2;break ' + label + ';}'));
   out.push('}');
-  // Resync from where the value started: a scan that stopped partway through
-  // one cannot say where it ends, and the skipper can.
-  out.push('if(_f' + objId + '===2){_f' + objId + '=1;i=_r.skipValue(s,_vs' + label + ');if(i<0)return 0;c=s.charCodeAt(i);}');
+  // A failed member is the verdict unless this object repeats the key later,
+  // since the parser keeps the last value. Whether it can is answered by two
+  // native searches over the rest of the text, for the key as written and
+  // for any backslash, which is the only way to spell that key differently:
+  // when neither is there the scan ends here, and a 69 KB body with a bad
+  // first item is refused in the time of an indexOf rather than a full pass.
+  // Otherwise resync from where the value started, since a scan that stopped
+  // partway through one cannot say where it ends and the skipper can, and
+  // go on, so a repeat still bails to the parser.
+  out.push('if(_f' + objId + '===2){if(s.indexOf(s.slice(_p' + kn + '-1,_e' + kn + '+1),i)<0&&s.indexOf("\\\\",i)<0)return 0;');
+  out.push('_f' + objId + '=1;i=_r.skipValue(s,_vs' + label + ');if(i<0)return 0;c=s.charCodeAt(i);}');
 }
 
 function emitObject(schema, ctx, out, depth) {
@@ -1111,7 +1119,7 @@ function emitObject(schema, ctx, out, depth) {
       const cond = gi === bounds.length - 1 ? '' : 'if(_kid' + kn + '<' + g.end + ')';
       out.push((gi === 0 ? '' : 'else ') + cond + '{');
       if (g.sub === undefined) out.push(addH);
-      else emitMember(g.sub, ctx, out, depth, n);
+      else emitMember(g.sub, ctx, out, depth, n, kn);
       out.push('}');
       prev = g.end;
     });
@@ -1160,7 +1168,7 @@ function emitObject(schema, ctx, out, depth) {
       out.push('_s' + n + '_' + slot.w + '|=' + slot.b + ';');
       const sub = props && Object.prototype.hasOwnProperty.call(props, name) ? props[name] : undefined;
       if (sub === undefined) out.push(additional.join('\n'));
-      else emitMember(sub, ctx, out, depth, n);
+      else emitMember(sub, ctx, out, depth, n, kn);
       out.push('}');
     }
     out.push('else{' + additional.join('\n') + '}');

package/lib/validator-core.js

@@ -1802,8 +1802,12 @@ Validator.loadBundle = function (mods, schemas, opts) {
 // simdjson when the addon is there, JSON.parse otherwise; the addon loads on
 // the first call rather than when the package is required.
 function parseJSON(input) {
+  // The addon has not carried parseJSON since the per-platform packages
+  // (1.1.0); the call threw a TypeError whenever the engine was loaded and
+  // returned JSON.parse's answer otherwise. A Buffer is decoded first.
   const native = getNative();
-  return native ? native.parseJSON(input) : JSON.parse(input);
+  if (native && typeof native.parseJSON === 'function') return native.parseJSON(input);
+  return JSON.parse(typeof input === 'string' ? input : String(input));
 }
 
 // Ultra-fast compile: returns validate function directly, no Validator wrapper

package/lib/version.js

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

package/lite.d.ts

@@ -0,0 +1,12 @@
+// ata-validator/lite: the same Validator and one-shot functions as
+// ata-validator, on the interpreted engine and without the code generator.
+// Validator#parse and the static bundle methods throw a TypeError here.
+export {
+  Validator,
+  validate,
+  validateAsync,
+  parseAsync,
+  defineSchema,
+  version,
+} from './index.js';
+export type * from './index.js';

package/lite.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// ata-validator/lite: the Validator without the code generator. Every schema
+// runs on the interpreted engine, which passes the same official test suite as
+// the compiled path and never calls `new Function`, so it also runs under a
+// strict Content-Security-Policy. The results are the ones `ata-validator`
+// gives: the same verdicts, the same errors. What it leaves out is what needs
+// the code generator (parse(), the ahead-of-time bundle methods) and the tools
+// no Validator calls (TypeScript generation, the renderers). Made for pages
+// where the size of what ships matters more than nanoseconds per call.
+const core = require('./lib/validator-core.js');
+
+module.exports = {
+  Validator: core.Validator,
+  validate: core.validate,
+  validateAsync: core.validateAsync,
+  parseAsync: core.parseAsync,
+  defineSchema: core.defineSchema,
+  version: core.version,
+};

package/lite.mjs

@@ -0,0 +1,3 @@
+import mod from './lite.js';
+export const { Validator, validate, validateAsync, parseAsync, defineSchema, version } = mod;
+export default mod;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "ata-validator",
-  "version": "1.47.0",
+  "version": "1.48.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
+  "type": "commonjs",
   "main": "index.js",
   "module": "index.mjs",
   "types": "index.d.ts",
@@ -48,6 +49,11 @@
       "import": "./compiled-verdict.mjs",
       "require": "./compiled-verdict.js"
     },
+    "./lite": {
+      "types": "./lite.d.ts",
+      "import": "./lite.mjs",
+      "require": "./lite.js"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -138,18 +144,21 @@
     "compiled-verdict.js",
     "compiled-verdict.mjs",
     "compiled-verdict.d.ts",
+    "lite.js",
+    "lite.mjs",
+    "lite.d.ts",
     "bin/",
     "README.md",
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.47.0",
-    "@ata-validator/native-darwin-x64": "1.47.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.47.0",
-    "@ata-validator/native-linux-arm64-musl": "1.47.0",
-    "@ata-validator/native-linux-x64-gnu": "1.47.0",
-    "@ata-validator/native-linux-x64-musl": "1.47.0",
-    "@ata-validator/native-win32-x64": "1.47.0"
+    "@ata-validator/native-darwin-arm64": "1.48.0",
+    "@ata-validator/native-darwin-x64": "1.48.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.48.0",
+    "@ata-validator/native-linux-arm64-musl": "1.48.0",
+    "@ata-validator/native-linux-x64-gnu": "1.48.0",
+    "@ata-validator/native-linux-x64-musl": "1.48.0",
+    "@ata-validator/native-win32-x64": "1.48.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"