ata-validator 1.44.0 → 1.46.0

package/lib/migrate.js

@@ -0,0 +1,253 @@
+'use strict';
+
+// `ata migrate`: what switching a project from ajv to ata-validator/compat
+// would change, and what it cannot translate. The report comes first and
+// touches nothing; `--write` applies only the two mechanical rewrites (the
+// import specifier, and the `addFormats()` call compat refuses on purpose),
+// so a site the report flags is never changed behind the reader's back.
+//
+// Sources are read through a small masker that blanks comments and the
+// insides of string and template literals, so a specifier is matched only
+// where it is code: `require('ajv')` in a comment or in a longer string is
+// not an import. Regular expression literals are not recognised; a pattern
+// such as /from 'ajv'/ would be read as code, which only ever adds a line to
+// the report, never a rewrite the report did not show.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SOURCE_EXT = new Set(['.js', '.mjs', '.cjs', '.jsx', '.ts', '.mts', '.cts', '.tsx']);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.nuxt', 'out', '.turbo', '.cache']);
+
+// Module specifiers and what each means for the switch.
+const SPECIFIERS = {
+  ajv: { kind: 'rewrite', to: 'ata-validator/compat' },
+  'ajv/dist/ajv': { kind: 'rewrite', to: 'ata-validator/compat' },
+  'ajv/dist/2020': { kind: 'rewrite-note', to: 'ata-validator/compat', note: 'compat reads a schema with no $schema as draft-07, where this import read it as Draft 2020-12: give each such schema a $schema, or keep this import until it has one' },
+  'ajv/dist/2019': { kind: 'rewrite-note', to: 'ata-validator/compat', note: 'compat reads a schema with no $schema as draft-07, where this import read it as Draft 2019-09, which ata does not implement: give each such schema a Draft 2020-12 or draft-07 $schema first' },
+  'ajv/dist/jtd': { kind: 'refuse', note: 'JSON Type Definition is not JSON Schema; ata has no equivalent' },
+  'ajv-formats': { kind: 'delete-import', note: 'the formats this plugin adds are built into ata; the import and the addFormats() call go' },
+  'ajv-errors': { kind: 'refuse', note: 'ata reads the errorMessage keyword natively (docs/migration-from-ajv.md, "Error UX"); the plugin call must be removed by hand and the keyword stays as it is' },
+  'ajv-keywords': { kind: 'refuse', note: 'not supported; each keyword used needs a definition through addKeyword with validate, compile or macro' },
+  'ajv-i18n': { kind: 'refuse', note: 'not supported; messages are English' },
+  'ajv-merge-patch': { kind: 'refuse', note: '$merge and $patch are not supported' },
+};
+
+// Masks comments and string contents with spaces, keeping every index and
+// line break where it was, so matches in the mask map back to the source.
+function mask (src) {
+  const out = src.split('');
+  const n = src.length;
+  let i = 0;
+  const blank = (from, to) => { for (let k = from; k < to; k++) if (out[k] !== '\n') out[k] = ' '; };
+  while (i < n) {
+    const c = src[i];
+    const d = src[i + 1];
+    if (c === '/' && d === '/') {
+      let j = i;
+      while (j < n && src[j] !== '\n') j++;
+      blank(i, j); i = j; continue;
+    }
+    if (c === '/' && d === '*') {
+      let j = src.indexOf('*/', i + 2);
+      if (j < 0) j = n; else j += 2;
+      blank(i, j); i = j; continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      let j = i + 1;
+      while (j < n) {
+        if (src[j] === '\\') { j += 2; continue; }
+        if (src[j] === c) break;
+        if (c !== '`' && src[j] === '\n') break;
+        j++;
+      }
+      blank(i + 1, j); i = j + 1; continue;
+    }
+    i++;
+  }
+  return out.join('');
+}
+
+function lineOf (src, index) {
+  let line = 1;
+  for (let i = 0; i < index; i++) if (src.charCodeAt(i) === 10) line++;
+  return line;
+}
+
+// Every module specifier in `src`: the string following `from`, inside
+// `require(` or `import(`, and in a bare `import '...'`. Returns the span of
+// the string contents, so a rewrite replaces only the specifier.
+function specifiers (src) {
+  const m = mask(src);
+  const found = [];
+  const re = /(\bfrom\s*|\brequire\s*\(\s*|\bimport\s*\(\s*|\bimport\s+)(['"])/g;
+  let x;
+  while ((x = re.exec(m)) !== null) {
+    const quote = x[2];
+    const start = x.index + x[0].length;
+    const end = src.indexOf(quote, start);
+    if (end < 0) continue;
+    found.push({ start, end, value: src.slice(start, end), line: lineOf(src, start) });
+  }
+  return found;
+}
+
+// `addFormats(x)` call statements, with the span to delete when the call is a
+// statement on its own.
+function addFormatsCalls (src) {
+  const m = mask(src);
+  const calls = [];
+  const re = /\baddFormats\s*\(/g;
+  let x;
+  while ((x = re.exec(m)) !== null) {
+    let depth = 1;
+    let j = x.index + x[0].length;
+    while (j < m.length && depth > 0) { if (m[j] === '(') depth++; else if (m[j] === ')') depth--; j++; }
+    let end = j;
+    if (m[end] === ';') end++;
+    // A statement of its own: only whitespace between the previous line
+    // break and the call, and between the call and the next one.
+    let ls = x.index;
+    while (ls > 0 && m[ls - 1] !== '\n') ls--;
+    let le = end;
+    while (le < m.length && m[le] !== '\n') le++;
+    const alone = /^\s*$/.test(m.slice(ls, x.index)) && /^\s*$/.test(m.slice(end, le));
+    calls.push({ start: x.index, end, lineStart: ls, lineEnd: le < m.length ? le + 1 : le, alone, line: lineOf(src, x.index) });
+  }
+  return calls;
+}
+
+// `$data` as an object key, bare or quoted. Read from the source rather than
+// the mask, since a quoted key is a string the mask blanks.
+function usesDollarData (src) {
+  const re = /(['"])\$data\1\s*:|\$data\s*:/g;
+  const lines = [];
+  let x;
+  while ((x = re.exec(src)) !== null) lines.push(lineOf(src, x.index));
+  return [...new Set(lines)];
+}
+
+function walk (dir, files) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return files; }
+  for (const e of entries) {
+    if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(path.join(dir, e.name), files); continue; }
+    if (e.isFile() && SOURCE_EXT.has(path.extname(e.name))) files.push(path.join(dir, e.name));
+  }
+  return files;
+}
+
+// One file. Returns null when the file mentions nothing of ajv. A file that
+// already imports ata-validator/compat is read too: what compat refuses
+// ($data, a code keyword, addFormats) is still a finding there, so a second
+// run after --write, or a CI check, keeps reporting it until it is fixed.
+const COMPAT = 'ata-validator/compat';
+function inspectFile (file, src) {
+  const specs = specifiers(src).filter((s) => s.value === 'ajv' || s.value.startsWith('ajv/') || s.value.startsWith('ajv-') || s.value === COMPAT);
+  if (specs.length === 0) return null;
+  const findings = [];
+  for (const s of specs) {
+    if (s.value === COMPAT) continue;
+    const rule = SPECIFIERS[s.value];
+    if (!rule) {
+      findings.push({ line: s.line, kind: 'flag', text: `import of "${s.value}": no translation known; check docs/migration-from-ajv.md` });
+      continue;
+    }
+    if (rule.kind === 'rewrite') findings.push({ line: s.line, kind: 'rewrite', text: `"${s.value}" becomes "${rule.to}"`, span: s, to: rule.to });
+    else if (rule.kind === 'rewrite-note') findings.push({ line: s.line, kind: 'rewrite', text: `"${s.value}" becomes "${rule.to}"; ${rule.note}`, span: s, to: rule.to, note: true });
+    else if (rule.kind === 'delete-import') findings.push({ line: s.line, kind: 'delete', text: `import of "${s.value}" goes: ${rule.note}`, span: s, deleteImport: true });
+    else findings.push({ line: s.line, kind: 'flag', text: `import of "${s.value}": ${rule.note}` });
+  }
+  const usesAjv = specs.some((s) => s.value === 'ajv' || s.value.startsWith('ajv/') || s.value === COMPAT);
+  if (usesAjv) {
+    for (const c of addFormatsCalls(src)) {
+      if (c.alone) findings.push({ line: c.line, kind: 'delete', text: 'addFormats() call goes: these formats are built in, and compat refuses the call', call: c });
+      else findings.push({ line: c.line, kind: 'flag', text: 'addFormats() is part of a larger statement; remove it by hand' });
+    }
+  }
+  if (usesAjv) {
+    for (const line of usesDollarData(src)) findings.push({ line, kind: 'flag', text: '$data reference: compat refuses $data; rewrite the constraint without it' });
+    const m = mask(src);
+    const kw = /\.addKeyword\s*\(/g;
+    let x;
+    while ((x = kw.exec(m)) !== null) {
+      // The definition object follows; a `code:` key in it is the form compat
+      // cannot take. Looked for up to the matching parenthesis.
+      let depth = 1; let j = x.index + x[0].length;
+      while (j < m.length && depth > 0) { if (m[j] === '(') depth++; else if (m[j] === ')') depth--; j++; }
+      if (/\bcode\s*[:(]/.test(m.slice(x.index, j))) findings.push({ line: lineOf(src, x.index), kind: 'flag', text: 'addKeyword with a code-generating definition: compat takes validate, compile or macro only' });
+    }
+  }
+  if (findings.length === 0) return null;
+  findings.sort((a, b) => a.line - b.line);
+  return findings;
+}
+
+// The source with the mechanical rewrites applied: specifiers replaced,
+// standalone addFormats() statements removed, and the ajv-formats import
+// line removed when its binding has no other use.
+function rewriteFile (src, findings) {
+  const edits = [];
+  for (const f of findings) {
+    if (f.kind === 'rewrite') edits.push({ start: f.span.start, end: f.span.end, text: f.to });
+    else if (f.kind === 'delete' && f.call) edits.push({ start: f.call.lineStart, end: f.call.lineEnd, text: '' });
+    else if (f.kind === 'delete' && f.deleteImport) {
+      let ls = f.span.start; while (ls > 0 && src[ls - 1] !== '\n') ls--;
+      let le = f.span.end; while (le < src.length && src[le] !== '\n') le++;
+      if (le < src.length) le++;
+      const stmt = src.slice(ls, le);
+      // Only a whole import or require statement on its own line.
+      if (/^\s*(import\b[^;\n]*from\s*['"]ajv-formats['"]\s*;?\s*\n?|(const|let|var)\s+\w+\s*=\s*require\s*\(\s*['"]ajv-formats['"]\s*\)\s*;?\s*\n?)$/.test(stmt)) edits.push({ start: ls, end: le, text: '' });
+    }
+  }
+  edits.sort((a, b) => b.start - a.start);
+  let out = src;
+  for (const e of edits) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  return out;
+}
+
+function migrate (dir, opts = {}) {
+  const root = path.resolve(dir || '.');
+  const files = walk(root, []);
+  const report = [];
+  let flagged = 0;
+  let written = 0;
+  for (const file of files) {
+    let src;
+    try { src = fs.readFileSync(file, 'utf8'); } catch { continue; }
+    const findings = inspectFile(file, src);
+    if (findings === null) continue;
+    // Forward slashes on every platform: the path is for people to read and
+    // paste, and Windows gave `src\\plain.js` where the report and its test
+    // name `src/plain.js`.
+    report.push({ file: path.relative(root, file).split(path.sep).join('/'), findings });
+    flagged += findings.filter((f) => f.kind === 'flag').length;
+    if (opts.write && findings.some((f) => f.kind !== 'flag')) {
+      const out = rewriteFile(src, findings);
+      if (out !== src) { fs.writeFileSync(file, out); written++; }
+    }
+  }
+  return { root, scanned: files.length, report, flagged, written };
+}
+
+function formatReport (result, opts = {}) {
+  const lines = [];
+  if (result.report.length === 0) {
+    lines.push(`no use of ajv found in ${result.scanned} source files under ${result.root}`);
+    return lines.join('\n');
+  }
+  const label = { rewrite: 'rewrite', delete: 'delete ', flag: 'flag   ' };
+  for (const r of result.report) {
+    lines.push(r.file);
+    for (const f of r.findings) lines.push(`  ${label[f.kind]}  line ${String(f.line).padStart(4)}  ${f.text}`);
+  }
+  const rewrites = result.report.reduce((n, r) => n + r.findings.filter((f) => f.kind !== 'flag').length, 0);
+  lines.push('');
+  lines.push(`${result.report.length} of ${result.scanned} source files use ajv: ${rewrites} mechanical change${rewrites === 1 ? '' : 's'}, ${result.flagged} site${result.flagged === 1 ? '' : 's'} to look at by hand`);
+  if (opts.write) lines.push(`${result.written} file${result.written === 1 ? '' : 's'} written; flagged sites were left as they are`);
+  else if (rewrites > 0) lines.push('nothing was changed; run again with --write to apply the mechanical changes');
+  if (result.flagged > 0) lines.push('each flagged site is explained in docs/migration-from-ajv.md');
+  return lines.join('\n');
+}
+
+module.exports = { migrate, formatReport, inspectFile, rewriteFile, mask, specifiers, SPECIFIERS };

package/lib/plan-compiler.js

@@ -52,12 +52,16 @@ const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string'
 
 function install(deps) {
   const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
-          deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
+          deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
           T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
-  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN };
+  // `leaf`: the node compiled no subschema of its own (see compileNode). A
+  // collecting caller asks a leaf for its verdict first and builds the paths
+  // for its errors only when it fails.
+  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN, leaf: true };
   const FALSE_PAIR = {
+    leaf: true,
     v: () => false,
     c: (data, errors, instancePath, schemaPath) => {
       if (errors !== NOERRORS) errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is false'));
@@ -164,12 +168,8 @@ function install(deps) {
       checks.push((data, bits) => (bits & mask) !== 0);
     }
     if (P.enum !== null) {
-      const vals = P.enum;
-      if (vals.length === 0) checks.push(() => false);
-      else checks.push((data) => {
-        for (let i = 0; i < vals.length; i++) if (deepEqual(vals[i], data)) return true;
-        return false;
-      });
+      if (P.enum.length === 0) checks.push(() => false);
+      else checks.push((data) => enumMember(P, data));
     }
     if (P.hasConst) {
       const c = P.const;
@@ -205,14 +205,7 @@ function install(deps) {
       const arrs = [];
       if (P.minItems !== undefined) { const m = P.minItems; arrs.push((d) => d.length >= m); }
       if (P.maxItems !== undefined) { const m = P.maxItems; arrs.push((d) => d.length <= m); }
-      if (P.uniqueItems) {
-        arrs.push((d) => {
-          for (let i = 0; i < d.length; i++) {
-            for (let j = i + 1; j < d.length; j++) if (deepEqual(d[i], d[j])) return false;
-          }
-          return true;
-        });
-      }
+      if (P.uniqueItems) arrs.push(allDistinct);
       const run = combineValue(arrs);
       if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
     }
@@ -300,6 +293,7 @@ function install(deps) {
     const box = { v: null, c: null };
     const pair = {
       open: true,
+      leaf: false,
       v: (d, st, rec) => box.v(d, st, rec),
       c: (d, e, ip, sp, st, rec) => box.c(d, e, ip, sp, st, rec),
     };
@@ -308,8 +302,11 @@ function install(deps) {
     // In-place children collect when this node does; child applicators
     // never do. `rec` is threaded as the trailing argument of every step
     // and is undefined on non-collecting nodes, where nothing reads it.
-    const inPlace = (n, b) => compileNode(ctx, n, b, chain, collect);
-    const child = (n) => compileNode(ctx, n, base, chain, false);
+    // Whether this node compiles any subschema: a node that does not is a
+    // leaf, whose verdict is a few comparisons.
+    let nested = false;
+    const inPlace = (n, b) => { nested = true; return compileNode(ctx, n, b, chain, collect); };
+    const child = (n) => { nested = true; return compileNode(ctx, n, base, chain, false); };
 
     const steps = [];   // collect variant: (data, errors, ip, sp, stack, rec)
     const vsteps = [];  // verdict variant: (data, stack, rec)
@@ -399,7 +396,7 @@ function install(deps) {
         let ok = true;
         const n = Math.min(fns.length, data.length);
         for (let i = 0; i < n; i++) {
-          if (!fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack)) {
+          if (!((fns[i].leaf && fns[i].v(data[i], stack)) || fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -422,7 +419,7 @@ function install(deps) {
         if (dataBits(data) !== T_ARRAY) return true;
         let ok = true;
         for (let i = start; i < data.length; i++) {
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -536,7 +533,7 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
-            if (!prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack)) {
+            if (!((prop.fn.leaf && prop.fn.v(data[key], stack)) || prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -546,7 +543,7 @@ function install(deps) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
-                if (!pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack)) {
+                if (!((pp.fn.leaf && pp.fn.v(data[key], stack)) || pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack))) {
                   ok = false;
                   if (errors === NOERRORS) return false;
                 }
@@ -559,7 +556,7 @@ function install(deps) {
               ok = false;
               if (errors === NOERRORS) return false;
               errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
-            } else if (!apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack)) {
+            } else if (!((apFn.leaf && apFn.v(data[key], stack)) || apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -927,7 +924,7 @@ function install(deps) {
         for (let k = 0; k < keys.length; k++) {
           const key = keys[k];
           if (hasProp(rec, key)) continue;
-          if (!fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack)) {
+          if (!((fn.leaf && fn.v(data[key], stack)) || fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -983,7 +980,7 @@ function install(deps) {
         let ok = true;
         for (let i = 0; i < data.length; i++) {
           if (hasItem(rec, i)) continue;
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -1068,6 +1065,7 @@ function install(deps) {
     box.v = vfn;
     pair.c = cfn;
     pair.v = vfn;
+    pair.leaf = !nested;
     pair.open = false;
     return pair;
   }

package/lib/regex-linear.js

@@ -3,10 +3,12 @@
 const { parse } = require('./safe-regex')
 
 // True when the platform RegExp, a backtracking engine, also runs `src` in
-// linear time, so it can take the pattern: every quantifier on one character,
-// class or `.`; at most one unbounded, and then anchored with `^`; few bounded
-// choices; only escapes both engines read alike; nothing outside the BMP, so
-// both see the same UTF-16 units. tests/test_regex_native_linear.js holds it.
+// linear time, so it can take the pattern: every unbounded quantifier on one
+// character, class or `.`; at most one of them, and then anchored with `^`;
+// a finite repeat may cover a group that holds no unbounded quantifier; few
+// bounded choices in all; only escapes both engines read alike; nothing
+// outside the BMP, so both see the same UTF-16 units.
+// tests/test_regex_native_linear.js holds it.
 const NATIVE_ESCAPES = new Set(['d', 'D', 'w', 'W', 's', 'S', 'n', 'r', 't', 'f', 'v', '.', '\\', '/', '^', '$', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}', '-', 'x', 'u'])
 function nativeIsLinear (src) {
   if (typeof src !== 'string' || src.length > 512) return false
@@ -23,33 +25,40 @@ function nativeIsLinear (src) {
   }
   let ast
   try { ast = parse(src) } catch { return false }
-  let unbounded = 0
-  let bounded = 0
-  let ok = true
+  // Per subtree: how many unbounded quantifiers it holds (`u`) and how many
+  // bounded choices a backtracking engine could try (`b`), or null where the
+  // shape is not provably linear. A finite repeat of a group is linear when
+  // the group holds no unbounded quantifier: `(?:[A-F0-9]{2}:){31}` has
+  // nothing to retry, and its choices multiply through the nesting.
   const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
-  const walk = (n) => {
-    if (!ok) return
+  const info = (n) => {
     switch (n.t) {
       case 'star': case 'plus':
-        if (!atom(n.child)) ok = false
-        unbounded++
-        break
-      case 'quest':
-        if (!atom(n.child)) ok = false
-        bounded += 1
-        break
-      case 'repeat':
-        if (!atom(n.child)) ok = false
-        if (n.max === Infinity) unbounded++
-        else bounded += n.max - n.min
-        break
-      case 'group': walk(n.child); break
-      case 'concat': n.parts.forEach(walk); break
-      case 'alt': n.opts.forEach(walk); break
-      default: break
+        return atom(n.child) ? { u: 1, b: 0 } : null
+      case 'quest': {
+        if (atom(n.child)) return { u: 0, b: 1 }
+        const c = info(n.child)
+        return c === null || c.u > 0 ? null : { u: 0, b: 1 + c.b }
+      }
+      case 'repeat': {
+        if (atom(n.child)) return n.max === Infinity ? { u: 1, b: 0 } : { u: 0, b: n.max - n.min }
+        if (n.max === Infinity) return null
+        const c = info(n.child)
+        return c === null || c.u > 0 ? null : { u: 0, b: (n.max - n.min) + n.max * c.b }
+      }
+      case 'group': return info(n.child)
+      case 'concat': case 'alt': {
+        let u = 0, b = 0
+        for (const part of (n.t === 'concat' ? n.parts : n.opts)) { const c = info(part); if (c === null) return null; u += c.u; b += c.b }
+        return { u, b }
+      }
+      default: return { u: 0, b: 0 }
     }
   }
-  walk(ast)
+  const r = info(ast)
+  const ok = r !== null
+  const unbounded = ok ? r.u : 0
+  const bounded = ok ? r.b : 0
   if (!ok || unbounded > 1 || bounded > 64) return false
   if (unbounded === 1) {
     // Anchored at the start on every top-level branch.

package/lib/unique-items.js

@@ -0,0 +1,139 @@
+'use strict';
+
+// uniqueItems for every engine. These are real functions: the interpreted
+// engine calls them, and the code generator emits their source text
+// (`String(fn)`) into the function it builds, so both run the same code.
+// They read only each other, `_deq` and `_uqpI`, which the generator emits
+// beside them.
+//
+// Short arrays compare pairwise and allocate nothing. Longer arrays of
+// primitives key a Set or Map by the value itself. Longer arrays that hold an
+// object key a Map by a numeric structural hash, and only items whose hashes
+// collide are compared with `_deq`. Equal values always hash alike: numbers
+// by value (so 1 and 1.0, 0 and -0 agree), strings by their characters,
+// arrays by position, and objects by the sum of their own key-value hashes,
+// whatever the key order. The hash replaced a sorted-key canonical string
+// built for every item on every call, which was over a quarter of the time a
+// generated verdict spent on SchemaStore's sample documents.
+
+// JSON equality, the same function the generator hoists as DEQ_HELPER.
+function _deq(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  var aa = Array.isArray(a);
+  if (aa !== Array.isArray(b)) return false;
+  var i;
+  if (aa) {
+    if (a.length !== b.length) return false;
+    for (i = 0; i < a.length; i++) if (!_deq(a[i], b[i])) return false;
+    return true;
+  }
+  var ka = Object.keys(a);
+  if (ka.length !== Object.keys(b).length) return false;
+  for (i = 0; i < ka.length; i++) {
+    var k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k) || !_deq(a[k], b[k])) return false;
+  }
+  return true;
+}
+
+function _uqh(x) {
+  if (x === null) return 1;
+  var t = typeof x, h, i;
+  if (t === 'boolean') return x ? 2 : 3;
+  if (t === 'number') {
+    if (x === 0) return 4;
+    h = x | 0;
+    return Math.imul(h ^ (((x - h) * 1e9) | 0), 0x9e3779b1) ^ 5;
+  }
+  if (t === 'string') {
+    h = 0x811c9dc5 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ x.charCodeAt(i), 16777619);
+    return h;
+  }
+  if (t !== 'object') return 6;
+  if (Array.isArray(x)) {
+    h = 0x2545f491 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ _uqh(x[i]), 16777619);
+    return h;
+  }
+  var ks = Object.keys(x);
+  h = 0x6c8e9cf5 ^ ks.length;
+  for (i = 0; i < ks.length; i++) h = (h + Math.imul(_uqh(ks[i]) ^ Math.imul(_uqh(x[ks[i]]), 0x5bd1e995), 0x27d4eb2d)) | 0;
+  return h;
+}
+
+// Whether every item is distinct.
+function _uq(a) {
+  var n = a.length, i, k;
+  if (n < 2) return true;
+  if (n <= 12) {
+    for (i = 1; i < n; i++) for (k = 0; k < i; k++) if (_deq(a[i], a[k])) return false;
+    return true;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  if (prim) {
+    var s = new Set();
+    for (i = 0; i < n; i++) { if (s.has(a[i])) return false; s.add(a[i]); }
+    return true;
+  }
+  var m = new Map();
+  for (i = 0; i < n; i++) {
+    var hh = _uqh(a[i]), b = m.get(hh);
+    if (b === undefined) m.set(hh, i);
+    else if (typeof b === 'number') { if (_deq(a[b], a[i])) return false; m.set(hh, [b, i]); }
+    else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) return false; b.push(i); }
+  }
+  return true;
+}
+
+// The duplicate pair an error reports: the first item that has a later
+// equal, and its first later equal. Returns that later index and leaves the
+// first in _uqpI, or returns -1 when every item is distinct.
+var _uqpI = 0;
+function _uqp(a) {
+  var n = a.length, i, k;
+  if (n < 2) return -1;
+  if (n <= 12) {
+    for (i = 0; i < n - 1; i++) for (k = i + 1; k < n; k++) if (_deq(a[i], a[k])) { _uqpI = i; return k; }
+    return -1;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  var bi = -1, bj = -1, m = new Map();
+  if (prim) {
+    for (i = 0; i < n; i++) {
+      var p = m.get(a[i]);
+      if (p === undefined) m.set(a[i], i);
+      else if (p >= 0) { if (bi < 0 || p < bi) { bi = p; bj = i; } m.set(a[i], -1); }
+    }
+  } else {
+    // Each bucket holds the first occurrence of every distinct value that
+    // hashed there, in index order; a value is paired with its first later
+    // equal only once.
+    var paired = null;
+    for (i = 0; i < n; i++) {
+      var hh = _uqh(a[i]), b = m.get(hh), r = -1;
+      if (b === undefined) { m.set(hh, i); continue; }
+      if (typeof b === 'number') { if (_deq(a[b], a[i])) r = b; else m.set(hh, [b, i]); }
+      else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) { r = b[k]; break; } if (r < 0) b.push(i); }
+      if (r >= 0) {
+        if (paired === null) paired = new Set();
+        if (!paired.has(r)) { paired.add(r); if (bi < 0 || r < bi) { bi = r; bj = i; } }
+      }
+    }
+  }
+  if (bi < 0) return -1;
+  _uqpI = bi;
+  return bj;
+}
+
+// For the interpreted engine.
+function allDistinct(a) { return _uq(a); }
+function duplicatePair(a) {
+  var j = _uqp(a);
+  return j < 0 ? null : [_uqpI, j];
+}
+
+module.exports = { allDistinct, duplicatePair, _deq, _uqh, _uq, _uqp };