ata-validator 1.21.0 → 1.22.1

package/lib/formats.js

@@ -224,24 +224,102 @@ function hostname (s) {
   return labelLength !== 0 && previous !== 45;
 }
 
-// A scheme followed by a colon, and no control characters or spaces after it.
-// Two expressions became one pass: the scheme is read from the front and the
-// rest of the string is scanned once for characters a URI cannot hold.
+// Character classes as tables rather than comparison chains. Nine `===` tests
+// per character more than doubled the cost of the scan they guarded, measured
+// against the same loop doing a single range check; an indexed byte read costs
+// the same whatever the class holds.
+const URI_CHAR = new Uint8Array(128);
+for (let i = 33; i < 127; i++) URI_CHAR[i] = 1;
+// " < > \ ^ ` { | } are printable and still not allowed in a URI.
+for (const c of [34, 60, 62, 92, 94, 96, 123, 124, 125]) URI_CHAR[c] = 0;
+const HEX_CHAR = new Uint8Array(128);
+for (let i = 48; i < 58; i++) HEX_CHAR[i] = 1;
+for (let i = 97; i < 103; i++) HEX_CHAR[i] = 1;
+for (let i = 65; i < 71; i++) HEX_CHAR[i] = 1;
+// Scheme characters: letters, digits, "+", "-", ".".
+const SCHEME_CHAR = new Uint8Array(128);
+for (let i = 48; i < 58; i++) SCHEME_CHAR[i] = 1;
+for (let i = 97; i < 123; i++) SCHEME_CHAR[i] = 1;
+for (let i = 65; i < 91; i++) SCHEME_CHAR[i] = 1;
+SCHEME_CHAR[43] = 1; SCHEME_CHAR[45] = 1; SCHEME_CHAR[46] = 1;
+
+// A scheme followed by a colon, an optional authority, and no character a URI
+// cannot hold anywhere after the colon.
+//
+// One walk answers all of it. The authority's landmarks, the last "@", the
+// colons after it and whether a bracket appeared before it, are recorded while
+// the characters are being checked, so the authority is never cut out of the
+// string or scanned again. Reading it out with `slice` and asking the copy for
+// `lastIndexOf` and two regular expressions allocated a string per URI, and a
+// document carrying a handful of URLs paid that per field.
 function uri (s) {
   const n = s.length;
   if (n === 0) return false;
-  const first = s.charCodeAt(0);
-  if (!((first >= 97 && first <= 122) || (first >= 65 && first <= 90))) return false;
+  let c = s.charCodeAt(0);
+  // A scheme opens with a letter, never a digit or a sign.
+  if (c > 127 || SCHEME_CHAR[c] === 0 || (c >= 48 && c <= 57) || c === 43 || c === 45 || c === 46) return false;
   let colon = -1;
   for (let i = 1; i < n; i++) {
-    const c = s.charCodeAt(i);
+    c = s.charCodeAt(i);
     if (c === 58) { colon = i; break; }
-    // scheme characters: letters, digits, "+", "-", "."
-    if (!(isDigit(c) || (c >= 97 && c <= 122) || (c >= 65 && c <= 90) ||
-      c === 43 || c === 45 || c === 46)) return false;
+    if (c > 127 || SCHEME_CHAR[c] === 0) return false;
   }
   if (colon === -1) return false;
-  return uriChars(s, colon + 1) && uriAuthority(s, colon + 1);
+
+  let i = colon + 1;
+  let authEnd = n;
+  if (s.charCodeAt(i) === 47 && s.charCodeAt(i + 1) === 47) {
+    const authStart = i + 2;
+    let at = -1, firstColon = -1, lastColon = -1, sawBracket = 0, bracketBeforeAt = 0;
+    let hostStart = authStart;
+    authEnd = -1;
+    for (i = authStart; i < n; i++) {
+      c = s.charCodeAt(i);
+      if (c > 127 || URI_CHAR[c] === 0) return false;
+      if (c === 47 || c === 63 || c === 35) { authEnd = i; break; }
+      if (c === 37) {
+        const h1 = s.charCodeAt(i + 1), h2 = s.charCodeAt(i + 2);
+        // A "%" at the end of the string reads as NaN, which no comparison
+        // admits; `<= 127` is written that way so NaN takes the reject.
+        if (!(h1 <= 127) || !(h2 <= 127) || HEX_CHAR[h1] === 0 || HEX_CHAR[h2] === 0) return false;
+        i += 2;
+        continue;
+      }
+      // The last "@" ends userinfo, so everything recorded before it belongs
+      // to a part that has its own rules and is dropped here.
+      if (c === 64) { bracketBeforeAt = sawBracket; at = i; firstColon = -1; lastColon = -1; hostStart = i + 1; }
+      else if (c === 58) { if (firstColon === -1) firstColon = i; lastColon = i; }
+      else if (c === 91 || c === 93) { sawBracket = 1; }
+    }
+    if (authEnd === -1) authEnd = n;
+    // Brackets belong to the host, so one before the "@" is not userinfo.
+    if (at !== -1 && bracketBeforeAt) return false;
+    if (s.charCodeAt(hostStart) === 91) { // '['
+      let close = -1;
+      for (let j = hostStart + 1; j < authEnd; j++) { if (s.charCodeAt(j) === 93) { close = j; break; } }
+      if (close === -1) return false;
+      if (close + 1 !== authEnd) {
+        if (s.charCodeAt(close + 1) !== 58) return false;
+        if (!allDigits(s, close + 2, authEnd)) return false;
+      }
+    } else if (lastColon !== -1) {
+      // A host holding more than one colon is an IPv6 address, and those must
+      // be bracketed. Without that rule the last group reads as a port number.
+      if (firstColon !== lastColon) return false;
+      if (!allDigits(s, lastColon + 1, authEnd)) return false;
+    }
+    i = authEnd;
+  }
+  for (; i < n; i++) {
+    c = s.charCodeAt(i);
+    if (c > 127 || URI_CHAR[c] === 0) return false;
+    if (c === 37) {
+      const h1 = s.charCodeAt(i + 1), h2 = s.charCodeAt(i + 2);
+      if (!(h1 <= 127) || !(h2 <= 127) || HEX_CHAR[h1] === 0 || HEX_CHAR[h2] === 0) return false;
+      i += 2;
+    }
+  }
+  return true;
 }
 
 // The characters a URI cannot hold: C0 controls, space, DEL, and the rest of
@@ -287,34 +365,68 @@ const uriCharsSource = (v, from) =>
   'if(!((_h1>=48&&_h1<=57)||(_h1>=97&&_h1<=102)||(_h1>=65&&_h1<=70))||' +
   '!((_h2>=48&&_h2<=57)||(_h2>=97&&_h2<=102)||(_h2>=65&&_h2<=70)))return false;_ri+=2}}';
 
+function allDigits (s, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+}
+
 // The authority sits between "//" and the next "/", "?" or "#". A bracketed
 // host must close, and a port is digits.
+//
+// Everything here reads the original string through index bounds. Cutting the
+// authority out with `slice` and asking it for `lastIndexOf` and two regular
+// expressions allocated a string for every URI validated, and a document
+// carrying a handful of URLs paid that per field; the authority of an ordinary
+// URL is a dozen characters, so walking it twice costs less than copying it
+// once.
 function uriAuthority (s, start) {
   if (s.charCodeAt(start) !== 47 || s.charCodeAt(start + 1) !== 47) return true;
-  let end = s.length;
-  for (let i = start + 2; i < s.length; i++) {
+  const n = s.length;
+  const authStart = start + 2;
+  let authEnd = n;
+  for (let i = authStart; i < n; i++) {
     const c = s.charCodeAt(i);
-    if (c === 47 || c === 63 || c === 35) { end = i; break; }
-  }
-  const auth = s.slice(start + 2, end);
-  const at = auth.lastIndexOf('@');
-  // Brackets belong to the host, so one before the "@" is not userinfo.
-  if (at !== -1 && /[[\]]/.test(auth.slice(0, at))) return false;
-  const hostPort = at === -1 ? auth : auth.slice(at + 1);
-  if (hostPort.charCodeAt(0) === 91) { // '['
-    const close = hostPort.indexOf(']');
+    if (c === 47 || c === 63 || c === 35) { authEnd = i; break; }
+  }
+  // The last "@" splits userinfo from the host. Brackets belong to the host,
+  // so one before the "@" is not userinfo.
+  let at = -1;
+  for (let i = authEnd - 1; i >= authStart; i--) {
+    if (s.charCodeAt(i) === 64) { at = i; break; }
+  }
+  if (at !== -1) {
+    for (let i = authStart; i < at; i++) {
+      const c = s.charCodeAt(i);
+      if (c === 91 || c === 93) return false;
+    }
+  }
+  const hpStart = at === -1 ? authStart : at + 1;
+  if (s.charCodeAt(hpStart) === 91) { // '['
+    let close = -1;
+    for (let i = hpStart + 1; i < authEnd; i++) {
+      if (s.charCodeAt(i) === 93) { close = i; break; }
+    }
     if (close === -1) return false;
-    const rest = hostPort.slice(close + 1);
-    if (rest === '') return true;
-    if (rest.charCodeAt(0) !== 58) return false;
-    return /^[0-9]*$/.test(rest.slice(1));
+    if (close + 1 === authEnd) return true;
+    if (s.charCodeAt(close + 1) !== 58) return false;
+    return allDigits(s, close + 2, authEnd);
+  }
+  let firstColon = -1;
+  let lastColon = -1;
+  for (let i = hpStart; i < authEnd; i++) {
+    if (s.charCodeAt(i) === 58) {
+      if (firstColon === -1) firstColon = i;
+      lastColon = i;
+    }
   }
-  const colon = hostPort.lastIndexOf(':');
-  if (colon === -1) return true;
+  if (lastColon === -1) return true;
   // A host holding more than one colon is an IPv6 address, and those must be
   // bracketed. Without that rule the last group reads as a port number.
-  if (hostPort.indexOf(':') !== colon) return false;
-  return /^[0-9]*$/.test(hostPort.slice(colon + 1));
+  if (firstColon !== lastColon) return false;
+  return allDigits(s, lastColon + 1, authEnd);
 }
 const uriAuthoritySource = (v, start) =>
   `if(${v}.charCodeAt(${start})===47&&${v}.charCodeAt(${start}+1)===47){` +
@@ -622,6 +734,22 @@ function timeSource (v, isStr) {
     'if(_u!==1439)return false}');
 }
 
+// The same walk as `uri` above, as source, for the code generator to hoist
+// once per compiled function and call. Two copies of one algorithm is what
+// this file has always done for every format, so they sit together here and
+// tests/test_uri_helper_parity.js holds them to the same answer over a corpus
+// built from the walk's own boundaries.
+const URI_HELPER_TABLES = 'const _uct=new Uint8Array(128);for(let _i=33;_i<127;_i++)_uct[_i]=1;' +
+  '_uct[34]=_uct[60]=_uct[62]=_uct[92]=_uct[94]=_uct[96]=_uct[123]=_uct[124]=_uct[125]=0;' +
+  'const _uch=new Uint8Array(128);for(let _i=48;_i<58;_i++)_uch[_i]=1;' +
+  'for(let _i=97;_i<103;_i++)_uch[_i]=1;for(let _i=65;_i<71;_i++)_uch[_i]=1;' +
+  'const _ucs=new Uint8Array(128);for(let _i=48;_i<58;_i++)_ucs[_i]=1;' +
+  'for(let _i=97;_i<123;_i++)_ucs[_i]=1;for(let _i=65;_i<91;_i++)_ucs[_i]=1;' +
+  '_ucs[43]=1;_ucs[45]=1;_ucs[46]=1';
+const URI_HELPER_BODY = 'const _n=_s.length;if(_n===0)return false;let _c=_s.charCodeAt(0);if(_c>127||_ucs[_c]===0||(_c>=48&&_c<=57)||_c===43||_c===45||_c===46)return false;let _co=-1;for(let _i=1;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c===58){_co=_i;break}if(_c>127||_ucs[_c]===0)return false}if(_co===-1)return false;let _i=_co+1;let _ae=_n;if(_s.charCodeAt(_i)===47&&_s.charCodeAt(_i+1)===47){const _as=_i+2;let _at=-1,_fc=-1,_lc=-1,_br=0,_ba=0,_hs=_as;_ae=-1;for(_i=_as;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===47||_c===63||_c===35){_ae=_i;break}if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2;continue}if(_c===64){_ba=_br;_at=_i;_fc=-1;_lc=-1;_hs=_i+1}else if(_c===58){if(_fc===-1)_fc=_i;_lc=_i}else if(_c===91||_c===93){_br=1}}if(_ae===-1)_ae=_n;if(_at!==-1&&_ba)return false;if(_s.charCodeAt(_hs)===91){let _cl=-1;for(let _j=_hs+1;_j<_ae;_j++){if(_s.charCodeAt(_j)===93){_cl=_j;break}}if(_cl===-1)return false;if(_cl+1!==_ae){if(_s.charCodeAt(_cl+1)!==58)return false;for(let _j=_cl+2;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}}else if(_lc!==-1){if(_fc!==_lc)return false;for(let _j=_lc+1;_j<_ae;_j++){const _d=_s.charCodeAt(_j);if(_d<48||_d>57)return false}}_i=_ae}for(;_i<_n;_i++){_c=_s.charCodeAt(_i);if(_c>127||_uct[_c]===0)return false;if(_c===37){const _h1=_s.charCodeAt(_i+1),_h2=_s.charCodeAt(_i+2);if(!(_h1<=127)||!(_h2<=127)||_uch[_h1]===0||_uch[_h2]===0)return false;_i+=2}}return true;';
+const uriHelperSource = (name) =>
+  URI_HELPER_TABLES + ';function ' + name + '(_s){' + URI_HELPER_BODY + '}';
+
 function uriSource (v, isStr) {
   return guard(v, isStr, `const _n=${v}.length;if(_n===0)return false;` +
     `const _f=${v}.charCodeAt(0);if(!((_f>=97&&_f<=122)||(_f>=65&&_f<=90)))return false;` +
@@ -814,4 +942,4 @@ function durationSource (v, isStr) {
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
 
-module.exports = { date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, uriChars, uriAuthority, uriCharsSource, uriAuthoritySource, iri, iriReference, idnEmail, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { uriHelperSource, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, uriChars, uriAuthority, uriCharsSource, uriAuthoritySource, iri, iriReference, idnEmail, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/interpreter.js

@@ -461,6 +461,11 @@ class Plan {
 
     this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
     this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
+    // A `false` here rejects the member outright, and the error belongs to this
+    // keyword on this object, not to a boolean schema that happens to sit
+    // under it. Recorded at compile time so the check below is one test.
+    this.unevaluatedPropertiesFalse = schema.unevaluatedProperties === false;
+    this.unevaluatedItemsFalse = schema.unevaluatedItems === false;
     this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
 
     // Custom keywords present on this node, in schema order. Each op holds
@@ -1183,7 +1188,14 @@ class Interpreter {
       if (P.unevaluatedProperties !== undefined && bits === T_OBJECT) {
         for (const key of Object.keys(data)) {
           if (local.props && local.props.has(key)) continue;
-          if (!this.eval(P.unevaluatedProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack, DISCARD)) valid = false;
+          if (P.unevaluatedPropertiesFalse) {
+            // The name is what is wrong, so the error names it and sits on the
+            // object holding it. Descending instead reported a false boolean
+            // schema at the member's own path, which says nothing about which
+            // key was unexpected and left `params` empty.
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('unevaluatedProperties', 'unevaluatedProperties', instancePath, schemaPath + '/unevaluatedProperties', { unevaluatedProperty: key }, 'must NOT have unevaluated properties'));
+          } else if (!this.eval(P.unevaluatedProperties, data[key], base, dynScope, errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack, DISCARD)) valid = false;
           if (!local.props) local.props = new Set();
           local.props.add(key);
         }
@@ -1191,6 +1203,13 @@ class Interpreter {
       if (P.unevaluatedItems !== undefined && bits === T_ARRAY) {
         for (let i = 0; i < data.length; i++) {
           if (local.items && local.items.has(i)) continue;
+          if (P.unevaluatedItemsFalse) {
+            // One error for the array, not one per trailing element: what the
+            // array got wrong is its length past the last evaluated position.
+            valid = false;
+            if (errors !== NOERRORS) errors.push(err('unevaluatedItems', 'unevaluatedItems', instancePath, schemaPath + '/unevaluatedItems', { limit: i }, 'must NOT have more than ' + i + ' items'));
+            break;
+          }
           if (!this.eval(P.unevaluatedItems, data[i], base, dynScope, errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack, DISCARD)) valid = false;
           if (!local.items) local.items = new Set();
           local.items.add(i);

package/lib/js-compiler.js

@@ -35,6 +35,46 @@ function hoistOnce(ctx, key, code) {
   else if (ctx.helperCode) ctx.helperCode.push(code)
 }
 
+// Above this many declared names, asking whether a key is one of them by
+// testing it against each name in turn costs a comparison per name per key,
+// which is quadratic in the number of properties: a 1000-property schema with
+// `additionalProperties: false` spent 75 us where the same schema without the
+// keyword took 3, and doubling the properties quadrupled that. Below this many
+// the two are the same within noise and the chain allocates nothing, so it
+// stays. Cross-process medians, one variant per process, properties of type
+// string: 3 to 100 names are a tie; 250 names 8.76 us against 5.49, 500 26.29
+// against 12.47, and with no per-property work 2000 names 273 against 49.
+const AP_LOOKUP_MIN = 128
+
+// A name set built once per compiled function rather than once per call, as
+// source text so the standalone output carries it the same way. A null
+// prototype means a key called `toString` is not a member by accident, and a
+// plain property read measured faster than `Set#has` at every size tried.
+function emitNameLookup (ctx, names) {
+  const id = `_apn${ctx.varCounter++}`
+  const list = names.map((n) => JSON.stringify(n)).join(',')
+  const decl = `const ${id}=Object.create(null);for(const _apx of [${list}])${id}[_apx]=1`
+  if (ctx.preamble) ctx.preamble.push(decl)
+  else if (ctx.helperCode) ctx.helperCode.push(decl)
+  else return null
+  return id
+}
+
+// "every own key of `v` is one of `names`", as a `return false` check. A
+// hoisted lookup above the crossover, the comparison chain below it.
+function apMembershipCheck (ctx, names, v) {
+  if (names.length >= AP_LOOKUP_MIN) {
+    const id = emitNameLookup(ctx, names)
+    if (id !== null) {
+      // An indexed loop over `Object.keys`, not `for...in`: it allocates the key
+      // array but measured faster at every size tried, by about a quarter.
+      const i = ctx.varCounter++
+      return `var _apk${i}=Object.keys(${v});for(var _api${i}=0;_api${i}<_apk${i}.length;_api${i}++)if(${id}[_apk${i}[_api${i}]]===undefined)return false`
+    }
+  }
+  return `for(var _k in ${v})if(${names.map((k) => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+}
+
 function emitDeq(ctx) {
   hoistOnce(ctx, '_deqHoisted', DEQ_HELPER)
   return '_deq'
@@ -2147,7 +2187,7 @@ function genCode(schema, v, lines, ctx, knownType) {
       ? (propCount <= 15
           ? `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
           : `if(Object.keys(${v}).length!==${propCount})return false`)
-      : `for(var _k in ${v})if(${Object.keys(schema.properties).map(k => `_k!==${JSON.stringify(k)}`).join('&&')})return false`
+      : apMembershipCheck(ctx, Object.keys(schema.properties), v)
         _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
@@ -3037,6 +3077,13 @@ function genCode(schema, v, lines, ctx, knownType) {
 // the check was inlined at each of them.
 const EMAIL_HELPER = `function _em(_s){${_formats.emailSource('_s', true)}return true}`
 
+// `uri` is the most expensive format an ordinary document carries: a schema
+// with a handful of URL fields spent more time here than on every structural
+// check put together. The walk reads its character classes out of hoisted
+// tables, so it is declared once per compiled function rather than inlined at
+// each call site, where the tables would have to be rebuilt.
+const URI_HELPER = _formats.uriHelperSource('_uri')
+
 const FORMAT_CODEGEN = {
   email: (v, isStr, ctx) => {
     if (!ctx) return _formats.emailSource(v, isStr)
@@ -3058,7 +3105,11 @@ const FORMAT_CODEGEN = {
   'date-time': _formats.dateTimeSource,
   time: _formats.timeSource,
   duration: _formats.durationSource,
-  uri: _formats.uriSource,
+  uri: (v, isStr, ctx) => {
+    if (!ctx) return _formats.uriSource(v, isStr)
+    hoistOnce(ctx, '_uriHoisted', URI_HELPER)
+    return isStr ? `if(!_uri(${v}))return false` : `if(typeof ${v}==='string'&&!_uri(${v}))return false`
+  },
   'uri-reference': (v, isStr) => isStr
     ? `{${_formats.uriCharsSource(v, '0')}}`
     : `if(typeof ${v}==='string'){${_formats.uriCharsSource(v, '0')}}`,

package/lib/levenshtein.js

@@ -21,19 +21,31 @@ function levenshtein (a, b, maxDistance) {
   }
   let prev = scratchA;
   let curr = scratchB;
-  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  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 = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
-      if (curr[j] < rowMin) rowMin = curr[j];
+    // 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;
+      const del = curr[j - 1] + 1;
+      if (del < m) m = del;
+      const ins = prev[j] + 1;
+      if (ins < m) m = ins;
+      curr[j] = m;
+      if (m < rowMin) rowMin = m;
     }
     if (rowMin > max) return Infinity;
-    [prev, curr] = [curr, prev];
+    // A destructured swap builds an array per row; a temporary does not.
+    const t = prev;
+    prev = curr;
+    curr = t;
   }
-  return prev[b.length];
+  return prev[bn];
 }
 
 module.exports = { levenshtein };

package/lib/plan-compiler.js

@@ -894,6 +894,27 @@ function install(deps) {
     // unevaluated*: run last, against the annotations of everything above.
     if (P.unevaluatedProperties !== undefined) {
       const fn = child(P.unevaluatedProperties);
+      if (fn === FALSE_PAIR) {
+        // `false` rejects the member outright, and what is wrong is the name.
+        // Running the boolean schema against the value instead reported a
+        // false schema at the member's own path with empty params, which does
+        // not say which key was unexpected. The error belongs to this keyword,
+        // on the object holding the key, and it carries the key.
+        steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
+          if (dataBits(data) !== T_OBJECT) return true;
+          let ok = true;
+          const keys = keysOf(rec, data);
+          for (let k = 0; k < keys.length; k++) {
+            const key = keys[k];
+            if (hasProp(rec, key)) continue;
+            ok = false;
+            if (errors === NOERRORS) return false;
+            errors.push(err('unevaluatedProperties', 'unevaluatedProperties', instancePath, schemaPath + '/unevaluatedProperties', { unevaluatedProperty: key }, 'must NOT have unevaluated properties'));
+            addProp(rec, key);
+          }
+          return ok;
+        });
+      } else {
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         if (dataBits(data) !== T_OBJECT) return true;
         let ok = true;
@@ -909,6 +930,7 @@ function install(deps) {
         }
         return ok;
       });
+      }
       if (fn === FALSE_PAIR) {
         // Every key must already be evaluated; on success there is nothing
         // new to record.
@@ -936,6 +958,21 @@ function install(deps) {
     }
     if (P.unevaluatedItems !== undefined) {
       const fn = child(P.unevaluatedItems);
+      if (fn === FALSE_PAIR) {
+        // One error for the array rather than one per trailing element: what
+        // the array got wrong is its length past the last evaluated position.
+        steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
+          if (dataBits(data) !== T_ARRAY) return true;
+          for (let i = 0; i < data.length; i++) {
+            if (hasItem(rec, i)) continue;
+            if (errors !== NOERRORS) errors.push(err('unevaluatedItems', 'unevaluatedItems', instancePath, schemaPath + '/unevaluatedItems', { limit: i }, 'must NOT have more than ' + i + ' items'));
+            if (data.length > rec.n) rec.n = data.length;
+            return false;
+          }
+          if (data.length > rec.n) rec.n = data.length;
+          return true;
+        });
+      } else {
       steps.push((data, errors, instancePath, schemaPath, stack, rec) => {
         if (dataBits(data) !== T_ARRAY) return true;
         let ok = true;
@@ -949,6 +986,7 @@ function install(deps) {
         if (data.length > rec.n) rec.n = data.length;
         return ok;
       });
+      }
       if (fn === FALSE_PAIR) {
         vsteps.push((data, stack, rec) => {
           if (dataBits(data) !== T_ARRAY) return true;

package/lib/pointer.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * Resolve a JSON pointer against a document, for the diagnostic paths that run
+ * once per error on a rejected payload.
+ *
+ * Segments are read straight out of the pointer string: no leading-slash
+ * regex, no parts array, and no unescape pass on the segments that carry no
+ * `~`. A pointer that leaves the document returns rather than throwing,
+ * because a diagnostic must not fail where validation succeeded.
+ *
+ * `missing` separates the two ways a pointer yields nothing: a key that is
+ * absent from a container that exists resolves to undefined, while a pointer
+ * that walks through a null or a primitive returns `missing`. Callers that
+ * format the value need that apart, since the first is a value worth printing
+ * and the second is a path that was never in the document.
+ *
+ * @param {*} data the document the pointer is read against
+ * @param {string} pointer an RFC 6901 pointer, '' for the document itself
+ * @param {*} [missing] returned when the walk leaves the document
+ * @returns {*} the value at the pointer, `missing` if the walk broke
+ */
+function resolvePointer (data, pointer, missing) {
+  if (!pointer) return data;
+  const len = pointer.length;
+  let cur = data;
+  let i = pointer.charCodeAt(0) === 47 ? 1 : 0; // 47 is '/'
+  for (;;) {
+    let j = pointer.indexOf('/', i);
+    if (j === -1) j = len;
+    let seg = pointer.slice(i, j);
+    if (seg.indexOf('~') !== -1) seg = seg.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (cur == null) return missing;
+    cur = cur[seg];
+    if (j === len) break;
+    i = j + 1;
+  }
+  return cur;
+}
+
+// Passed where a caller has no resolved value to offer, which is not the same
+// as resolving to undefined: the first means walk it yourself, the second
+// means the document really holds nothing there.
+const UNRESOLVED = Symbol('ata.pointer.unresolved');
+
+module.exports = { resolvePointer, UNRESOLVED };

package/lib/retry-message.js

@@ -22,15 +22,39 @@
 // `received`. The trap is that joining `message`, which is the obvious thing to
 // do, throws both away. So this is one call that does not.
 
+// `multipleOf: 0.01` is how a schema says money, and a model acts on "rounded
+// to 2 decimal places" where it does not reliably act on "a multiple of 0.01".
+// describeSchema found that by measurement; the same wording belongs here, or
+// the two halves of the loop describe the same rule differently.
+function phrase (error) {
+  const p = error.params || {};
+  if (error.keyword === 'multipleOf' && typeof p.multipleOf === 'number') {
+    const m = p.multipleOf;
+    if (m > 0 && m < 1) {
+      const places = Math.round(Math.log10(1 / m));
+      if (Math.abs(Math.pow(10, -places) - m) < Number.EPSILON * 8) {
+        return `must be rounded to ${places} decimal place${places === 1 ? '' : 's'}`;
+      }
+    }
+  }
+  return null;
+}
+
 function line (error) {
   const where = error.instancePath || error.path || '';
-  const body = typeof error.detail === 'string' && error.detail ? error.detail : error.message;
+  const body = phrase(error) ||
+    (typeof error.detail === 'string' && error.detail ? error.detail : error.message);
   // `detail` usually quotes the offending value already; saying it twice reads
   // like a stutter in a string that is going into a prompt. A container is
   // summarised as `[object, ~0.1KB]` rather than shown, which tells a model
   // nothing it cannot see in its own output, so that is left out too.
   const raw = error.received === undefined || error.received === null ? '' : String(error.received);
-  const useless = raw.charAt(0) === '[' && /^\[(object|array)\b/.test(raw);
+  // A container tells a model nothing its own output does not already show,
+  // and it is the most expensive thing you can put in a prompt. That covers
+  // both the `[object, ~0.1KB]` summary and a whole serialized object.
+  const head = raw.charAt(0);
+  const useless = (head === '[' && /^\[(object|array)\b/.test(raw)) || head === '{' ||
+    (head === '[' && raw.charAt(raw.length - 1) === ']');
   const received = useless ? '' : raw;
   const got = received && body && !body.includes(received) ? `, got ${received}` : '';
   return `${where || '/'}: ${body}${got}`;