ata-validator 1.63.1 → 1.63.3

package/bin/ata.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 const { env } = require('../lib/env');
+// Text that comes from a schema file (a $ref, a keyword name in a warning) is
+// written with its control characters as escapes, as `ata validate` writes
+// it: a schema could otherwise clear the screen or forge an `ata:` line.
+const term = (t) => require('../lib/diagnose').term(String(t));
 
 const fs = require('fs');
 const path = require('path');
@@ -299,7 +303,7 @@ function cmdCompile(args) {
       for (const w of compileWarnings) reportCompileError(input, w);
       process.exit(1);
     }
-    for (const w of compileWarnings) process.stderr.write(`ata: warning: ${input}: ${w}\n`);
+    for (const w of compileWarnings) process.stderr.write(`ata: warning: ${input}: ${term(w)}\n`);
   }
   if (!src) {
     reportCompileError(input, 'schema is too complex for standalone compilation');
@@ -397,7 +401,7 @@ function cmdBuild(args) {
     for (const c of report.compiled) {
       process.stdout.write(`ata: ${c.input} -> ${c.output} (${c.bytes.toLocaleString()} bytes${c.errors === 'compact' ? ', shared errors' : c.errors === 'schema' ? ', schema module' : ''})\n`);
       for (const t of (report.bunTargets || []).filter((t) => t.input === c.input)) process.stdout.write(`ata: bun target -> ${t.output} (for bun build --compile --aot)\n`);
-      for (const d of (report.bunDeclined || []).filter((d) => d.input === c.input)) process.stderr.write(`ata: warning: ${d.input}: ${d.reason}\n`);
+      for (const d of (report.bunDeclined || []).filter((d) => d.input === c.input)) process.stderr.write(`ata: warning: ${d.input}: ${term(d.reason)}\n`);
     }
     if (report.runtime) {
       process.stdout.write(`ata: error runtime -> ${report.runtime.output} (${report.runtime.bytes.toLocaleString()} bytes, shared by the modules above)\n`);
@@ -412,7 +416,7 @@ function cmdBuild(args) {
         noDetail++;
         process.stderr.write(`ata: warning ${w.input}: no error detail, failures report the single ATA9000 error (the verdict is exact)\n`);
       } else {
-        process.stderr.write(`ata: warning ${w.input}: ${w.warning}\n`);
+        process.stderr.write(`ata: warning ${w.input}: ${term(w.warning)}\n`);
       }
     }
     if (noDetail > 0 && args.opts.mode !== 'schema') {
@@ -422,7 +426,7 @@ function cmdBuild(args) {
       process.stdout.write(`ata: cached  ${c.input}\n`);
     }
     for (const s of report.skipped) {
-      process.stdout.write(`ata: skipped ${s.input}: ${s.reason}\n`);
+      process.stdout.write(`ata: skipped ${s.input}: ${term(s.reason)}\n`);
     }
     for (const f of report.failed) {
       reportCompileError(f.input, f.error);

package/lib/branch-collapse.js

@@ -9,9 +9,12 @@
 // module imports nothing, so the generated code cannot require this file; it
 // carries a copy emitted by `embedSource()` from these very functions instead
 // of a second hand-written one. That is why the internals are written in the
-// positional form the generated code calls, and why `__ataCollapse` may close
-// over nothing but `__ataScore` and the severity table: whatever it reaches
-// has to be in the embed too.
+// positional form the generated code calls, and why each function reaches the
+// others only through properties on itself (`__ataCollapse.F`, `.M`,
+// `__ataScore.S`): a bundler that minifies names renames a function and every
+// call to it, and the text toString() gives then called names the embed did
+// not declare. A function's reference to its own name stays consistent, and
+// property names are not renamed.
 
 // How much a failing keyword says about intent. A branch that fails on `type`
 // was probably not the branch the author meant; one that fails on `minLength`
@@ -35,10 +38,12 @@ const __ATA_SEVERITY = {
 
 function __ataScore (errs) {
   if (!errs || !errs.length) return 0;
+  const sev = __ataScore.S;
   let s = 0;
-  for (const e of errs) s += __ATA_SEVERITY[e.keyword] || 4;
+  for (const e of errs) s += sev[e.keyword] || 4;
   return errs.length * 100 + s; // primary: count, secondary: severity
 }
+__ataScore.S = __ATA_SEVERITY;
 
 // `br` is one entry per branch in declaration order: {valid, errors} and a
 // `title`, or the titles in `titles` when given (the generated code passes
@@ -68,7 +73,7 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
     if (pass.length > 1) {
       const passIdx = [];
       for (let i = 0; i < br.length; i++) if (br[i].valid) passIdx.push(i);
-      return __ataMulti(passIdx, br.length, pp, sp, o);
+      return __ataCollapse.M(passIdx, br.length, pp, sp, o);
     }
   } else if (pass.length >= 1) {
     return null;
@@ -76,7 +81,7 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
   let bi = 0;
   let bs = Infinity;
   for (let i = 0; i < br.length; i++) {
-    const s = __ataScore(br[i].errors);
+    const s = __ataCollapse.F(br[i].errors);
     if (s < bs) { bs = s; bi = i; }
   }
   const best = br[bi];
@@ -97,6 +102,9 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
   return none;
 }
 
+__ataCollapse.M = __ataMulti;
+__ataCollapse.F = __ataScore;
+
 // The named-argument form the interpreter and the tests call.
 function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPath, ordinal }) {
   return __ataCollapse(keyword, branchResults, parentPath, parentSchemaPath, ordinal === undefined ? null : ordinal);
@@ -107,9 +115,9 @@ function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPat
 // cannot miss the other. `tests/test_branch_collapse.js` runs both.
 function embedSource () {
   return 'const __ATA_SEVERITY=' + JSON.stringify(__ATA_SEVERITY) + ';' +
-    'const __ataScore=' + __ataScore.toString() + ';' +
+    'const __ataScore=' + __ataScore.toString() + ';__ataScore.S=__ATA_SEVERITY;' +
     'const __ataMulti=' + __ataMulti.toString() + ';' +
-    'const __ataCollapse=' + __ataCollapse.toString() + ';';
+    'const __ataCollapse=' + __ataCollapse.toString() + ';__ataCollapse.M=__ataMulti;__ataCollapse.F=__ataScore;';
 }
 
 module.exports = { collapseBranches, scoreBranch: __ataScore, SEVERITY: __ATA_SEVERITY, embedSource, _collapse: __ataCollapse, _multi: __ataMulti };

package/lib/draft7.js

@@ -20,6 +20,7 @@ function isDraft6(schema) {
 // of its own, which is how a retrieved schema inherits the root's draft.
 // `draft6` says the document, or the root it inherits from, is draft-06.
 // `draft4`: draft-04, read as draft-06 plus its own differences (below).
+const PLAIN_NAME_ID = /^#[A-Za-z][A-Za-z0-9_.:-]*$/
 function normalizeDraft7(schema, force, draft6, draft4) {
   if (!force && !isDraft7(schema)) return schema
   const d4 = draft4 === true || (typeof schema.$schema === 'string' && DRAFT4_SCHEMAS.has(schema.$schema))
@@ -57,7 +58,7 @@ function _normalize(schema, d6, d4) {
 
   // A fragment-only `$id` is a plain-name anchor in draft-07; 2020-12 spells
   // it `$anchor`, which every engine already resolves.
-  if (typeof schema.$id === 'string' && /^#[A-Za-z][A-Za-z0-9_.:-]*$/.test(schema.$id)) {
+  if (typeof schema.$id === 'string' && PLAIN_NAME_ID.test(schema.$id)) {
     if (schema.$anchor === undefined) schema.$anchor = schema.$id.slice(1)
     delete schema.$id
   }
@@ -214,6 +215,18 @@ function _normalizeNullable(schema, st) {
     }
   }
   if ('nullable' in schema) delete schema.nullable
+  // A fragment-only `$id` (`#name`) is draft-07's spelling of an anchor, and
+  // schemas that declare no dialect are written with it too. normalizeDraft7
+  // folds it into `$anchor` under a declared older dialect; without one each
+  // engine read it its own way: the code generators took it as an anchor on
+  // the root and the root's definitions only, and where such a schema
+  // referred to itself they wrote nothing at the cycle, so every constraint
+  // past the first level was dropped and the document accepted. Folded here,
+  // on the walk every dialect runs, there is one spelling for every engine.
+  if (typeof schema.$id === 'string' && PLAIN_NAME_ID.test(schema.$id)) {
+    if (schema.$anchor === undefined) schema.$anchor = schema.$id.slice(1)
+    delete schema.$id
+  }
   // A JSON Pointer in a URI fragment is percent-encoded, so a definition named
   // `Node<Row>` is reached by `#/definitions/Node%3CRow%3E` (RFC 6901, section
   // 6). The interpreter decodes the fragment; the code generator compared the

package/lib/ir/emit.mjs

@@ -16,8 +16,16 @@ const FAST = {
   pattern: (n, x) => compilePatternInline(n, x),
   // A string has between length/2 and length code points, so the length
   // alone settles most cases and the count runs only near the bound.
-  minLength: (n, x) => `${x}.length>=${2 * n}||${x}.length>=${n}&&cpLen(${x})>=${n}`,
-  maxLength: (n, x) => `${x}.length<=${n}||${x}.length<=${2 * n}&&cpLen(${x})<=${n}`,
+  // The bound is written into the module as a number, so it has to be one: a
+  // schema that gave a string here had it written as source, and what the
+  // string said ran in whatever imported the module. Refused, as the closure
+  // writer refuses it.
+  minLength: (n, x) => { const b = bound(n, 'minLength'); return `${x}.length>=${2 * b}||${x}.length>=${b}&&cpLen(${x})>=${b}` },
+  maxLength: (n, x) => { const b = bound(n, 'maxLength'); return `${x}.length<=${b}||${x}.length<=${2 * b}&&cpLen(${x})<=${b}` },
+}
+function bound (n, k) {
+  if (typeof n !== 'number' || !Number.isFinite(n)) throw new Error(`ir: ${k} is not a number`)
+  return n
 }
 // enum and const with only primitive values need no deep equality: the
 // value is one of them exactly when it is === one of them (JSON numbers have
@@ -40,7 +48,11 @@ function inline (fn, vExpr, nExpr) {
   const src = fn.toString()
   const m = /^\(\s*v\s*(?:,\s*n\s*)?\)\s*=>\s*([\s\S]+)$/.exec(src)
   if (!m) throw new Error('ir: kernel ok() must be (v, n) => expression: ' + src)
-  return '(' + m[1].replace(/\bv\b/g, vExpr).replace(/\bn\b/g, nExpr) + ')'
+  // One pass, by function: the expressions carry text from the schema (a
+  // property name inside `d["..."]`), which a second pass would search for
+  // `n`, and which replace() would search for `$&` and its kin if it were
+  // given as the replacement itself.
+  return '(' + m[1].replace(/\b[vn]\b/g, (x) => x === 'v' ? vExpr : nExpr) + ')'
 }
 
 // How many names an object must list before a module visits the object's own
@@ -677,14 +689,16 @@ export function specialize (schema, opts = {}) {
   const own = typeof opts.fillSource === 'function' && !opts.schemas ? opts.fillSource(schema) : null
   if (typeof own === 'string') {
     return src
-      .replace('export function isValid(d){return ', `function FILL(d){\n${own}\n}\nexport function isValid(d){FILL(d);return `)
+      .replace('export function isValid(d){return ', () => `function FILL(d){\n${own}\n}\nexport function isValid(d){FILL(d);return `)
       .replace('export function validate(d){', 'export function validate(d){FILL(d);')
   }
   // The shared default pass (lib/defaults.js), built from the normalized
   // schema at load.
   return src
     .replace(/^import \{([^}]*)\} from /m, (m, list) => `import {${['buildDefaultsApplier', ...list.split(',')].filter(Boolean).sort().join(',')}} from `)
-    .replace('export function isValid(d){return ', `const FILL=buildDefaultsApplier(${JSON.stringify(ir.schema)})\nexport function isValid(d){FILL(d);return `)
+    // By function: a replacement given as text is searched for `$&`, `` $` ``,
+    // `$'` and `$$`, and a schema's descriptions and defaults hold them.
+    .replace('export function isValid(d){return ', () => `const FILL=buildDefaultsApplier(${JSON.stringify(ir.schema)})\nexport function isValid(d){FILL(d);return `)
     .replace('export function validate(d){', 'export function validate(d){FILL(d);')
 }
 

package/lib/js-compiler-errors.js

@@ -683,7 +683,7 @@ function countingBody (body) {
       j++
     }
     if (depth !== 0) return null
-    body = body.slice(0, b) + (unknown ? 'return -1' : '(_n++,_s+=4)') + body.slice(j)
+    body = body.slice(0, b) + (unknown ? 'return -1' : '(_scn++,_scs+=4)') + body.slice(j)
   }
   if (/\b(?:_defE\d|__ataCollapse|__ataMulti|_brf\d|_bsf\d)/.test(body)) return null
   const SEV = require('./branch-collapse').SEVERITY
@@ -691,7 +691,8 @@ function countingBody (body) {
   let i = 0
   const head = 'const _e=[];'
   if (!body.startsWith(head)) return null
-  out += 'let _n=0,_s=0;'
+  // Not `_n`: the inline format checks declare it as a const.
+  out += 'let _scn=0,_scs=0;'
   i = head.length
   while (i < body.length) {
     const ch = body[i]
@@ -711,13 +712,13 @@ function countingBody (body) {
       // The literal may still carry its `code` (the shape pass strips it).
       const m = /^\{(?:code:'ATA\d{4}',)?keyword:'([A-Za-z$][\w$]*)',/.exec(arg)
       if (m === null) return null
-      out += `(_n++,_s+=${SEV[m[1]] || 4})`
+      out += `(_scn++,_scs+=${SEV[m[1]] || 4})`
       i = j
       continue
     }
-    if (body.startsWith('return{valid:false,errors:_e}', i)) { out += 'return _n*100+_s'; i += 29; continue }
-    if (body.startsWith('return{valid:_e.length===0,errors:_e}', i)) { out += 'return _n*100+_s'; i += 37; continue }
-    if (body.startsWith('_e.length', i)) { out += '_n'; i += 9; continue }
+    if (body.startsWith('return{valid:false,errors:_e}', i)) { out += 'return _scn*100+_scs'; i += 29; continue }
+    if (body.startsWith('return{valid:_e.length===0,errors:_e}', i)) { out += 'return _scn*100+_scs'; i += 37; continue }
+    if (body.startsWith('_e.length', i)) { out += '_scn'; i += 9; continue }
     out += ch
     i++
   }
@@ -1147,11 +1148,16 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const expected = types.join(', ')
     // As written: a one-element array stays an array, as the interpreted engine
     // reports it.
-    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
+    // Escaped like every other schema string written into this source: a
+    // type name is the schema author's text, and a quote in one that is not
+    // a JSON Schema type closed the literal and ran what followed as code,
+    // in the process that compiled the schema and in the module written
+    // from it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${esc(String(types[0]))}'` : JSON.stringify(types)
     {
       const typeSp = `${schemaPrefix}/type`
       const lit = buildErrorLiteral({ keyword: 'type', schemaPath: typeSp, sourceMap: ctx.sourceMap })
-      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:${expectedParam}},message:'must be ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
+      lines.push(`if(!(${conds.join('||')})){_e.push({code:'${lit.codeStr}',keyword:'type',instancePath:${pathExpr||'""'},schemaPath:'${typeSp}'${ordinalField(ctx, `${typeSp}`)},params:{type:${expectedParam}},message:'must be ${esc(expected)}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -1270,7 +1276,11 @@ function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     // let every later statement of the same check push the same error again.
     if (fc) {
       const ri = ctx.varCounter++
-      const fmtCode = fc(v, isStr, ctx).replace(/return false/g, `{${failPush};break _fmt${ri}}`)
+      // By function: the pushed error carries the property's name in its
+      // paths, and a replacement given as text is searched for `$&` and its
+      // kin (a property named `a$&b` reported `/areturn falseb`).
+      const fmtFail = `{${failPush};break _fmt${ri}}`
+      const fmtCode = fc(v, isStr, ctx).replace(/return false/g, () => fmtFail)
       lines.push(`_fmt${ri}:{${fmtCode}}`)
     } else if (uf !== null) {
       // User-supplied format checker on the error path: the same closure
@@ -2038,7 +2048,9 @@ TYPE_KEYWORDS.integer = TYPE_KEYWORDS.number
 const NOT_VALIDATING = new Set(['$schema', '$id', '$anchor', '$comment', '$defs', 'definitions', 'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly', '$vocabulary'])
 function typeMismatchRest(schema, types) {
   const drop = new Set(['type', 'enum', 'const', 'anyOf', 'oneOf'])
-  for (const t of types) for (const k of (TYPE_KEYWORDS[t] || [])) drop.add(k)
+  // Own names only: a type called `constructor` or `__proto__` read
+  // Object.prototype's member here and threw while compiling.
+  for (const t of types) if (Object.prototype.hasOwnProperty.call(TYPE_KEYWORDS, t)) for (const k of TYPE_KEYWORDS[t]) drop.add(k)
   // A built-in format is written for strings only (`typeof v==='string'&&`
   // off the string path), so for a value that failed `type: string` it can
   // never fire: carried here it was dead code in every module that checks one.
@@ -2435,11 +2447,16 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const expected = types.join(', ')
     // As written: a one-element array stays an array, as the interpreted engine
     // reports it.
-    const expectedParam = !Array.isArray(schema.type) ? `'${types[0]}'` : JSON.stringify(types)
+    // Escaped like every other schema string written into this source: a
+    // type name is the schema author's text, and a quote in one that is not
+    // a JSON Schema type closed the literal and ran what followed as code,
+    // in the process that compiled the schema and in the module written
+    // from it.
+    const expectedParam = !Array.isArray(schema.type) ? `'${esc(String(types[0]))}'` : JSON.stringify(types)
     // Type check: push error but continue — wrap remaining in type-success block
     const typeOk = `_tok${ctx.varCounter++}`
     lines.push(`const ${typeOk}=${conds.join('||')}`)
-    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${expected}'`)}}`)
+    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${esc(expected)}'`)}}`)
     // Subsequent optimized code runs inside if(typeOk){...}
     if (types.length === 1) {
       isObj = types[0] === 'object'
@@ -2551,7 +2568,8 @@ function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       // Same rule as the error codegen: one violation, one error. The first
       // failing statement pushes and leaves the labeled block.
       const ri = ctx.varCounter++
-      const code = fc(v, isStr, ctx).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`)
+      const fmtFail = `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`
+      const code = fc(v, isStr, ctx).replace(/return false/g, () => fmtFail)
       lines.push(`_fmt${ri}:{${code}}`)
     } else if (uf !== null) {
       const closureName = bindUserFormat(ctx, schema.format, uf)

package/lib/js-compiler.js

@@ -20,18 +20,16 @@ const seqTag = () => `/*${++_compileSeq}*/`
 // forms answers a different question and costs a string per call.
 const 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,k,x,y;if(aa){if(a.length!==b.length)return false;for(i=a.length;i--!==0;)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=ka.length;i--!==0;){k=ka[i];if(!Object.prototype.hasOwnProperty.call(b,k))return false;x=a[k];y=b[k];if(x!==y&&(x===null||y===null||typeof x!=='object'||typeof y!=='object'))return false}for(i=ka.length;i--!==0;){k=ka[i];x=a[k];if(x!==null&&typeof x==='object'&&!_deq(x,b[k]))return false}return true}"
 
-// uniqueItems helpers, emitted from the functions the interpreted engine
+// uniqueItems helpers, the text of the functions the interpreted engine
 // calls (lib/unique-items.js): `_uq` answers whether every item is distinct.
-// Loaded at the first schema with uniqueItems, not on every cold start.
-// Comment lines and indentation are dropped: the text lands in every
-// generated function and ahead-of-time module that checks uniqueItems.
+// The text is written at build time (lib/unique-items-source.js) rather than
+// read with String(fn) here: in a bundle whose identifiers were minified the
+// functions and their calls to each other had other names, and generated
+// code that called `_uq` threw on every array. Loaded at the first schema
+// with uniqueItems, not on every cold start.
 let _uqSources = null
 function uqSources () {
-  if (_uqSources === null) {
-    const u = require('./unique-items')
-    const compact = (fn) => String(fn).replace(/\n\s*\/\/[^\n]*/g, '').replace(/\n\s*/g, '\n')
-    _uqSources = { uq: compact(u._uqh) + compact(u._uq), uqp: 'var _uqpI=0;' + compact(u._uqp) }
-  }
+  if (_uqSources === null) _uqSources = require('./unique-items-source')
   return _uqSources
 }
 
@@ -832,9 +830,9 @@ function resolveRef(ref, defs, schemaMap) {
 
 function buildTypeCheck(types) {
   if (types.length === 1) {
-    return TYPE_CHECKS[types[0]] || (() => true)
+    return typeCheckOf(types[0]) || (() => true)
   }
-  const fns = types.map(t => TYPE_CHECKS[t]).filter(Boolean)
+  const fns = types.map(typeCheckOf).filter(Boolean)
   return (d) => {
     for (let i = 0; i < fns.length; i++) {
       if (fns[i](d)) return true
@@ -902,6 +900,10 @@ function multipleOfBad(v, m) {
   return `!(Number.isInteger(${v}/${m})||Math.abs(${v}/${m}-Math.round(${v}/${m}))<1e-9)`
 }
 
+// Own names only: a type called `__proto__` or `valueOf` read
+// Object.prototype's member and was handed out as the check, and the
+// Validator then threw on the first document (`_fast is not a function`).
+const typeCheckOf = (t) => (Object.prototype.hasOwnProperty.call(TYPE_CHECKS, t) ? TYPE_CHECKS[t] : undefined)
 const TYPE_CHECKS = {
   string: (d) => typeof d === 'string',
   number: (d) => Number.isFinite(d),
@@ -3467,7 +3469,7 @@ function tryGenCombined(schema, access, ctx) {
   // or similar), skip the `{const _v = access}` wrapping and use it directly.
   const isIdent = /^_[a-zA-Z]\w*$/.test(access)
   const bind = (conds) => isIdent
-    ? `if(${conds.join('||').replace(/\b_v\b/g, access)})return false`
+    ? `if(${conds.join('||').replace(/\b_v\b/g, () => access)})return false`
     : `{const _v=${access};if(${conds.join('||')})return false}`
 
   if (t === 'string') {
@@ -4198,7 +4200,11 @@ function genDynamicRefNode(schema, v, lines, ctx, knownType) {
 function genUniqueItemsNode(schema, v, lines, ctx, knownType, hoisted, isArr, types) {
   const si = ctx.varCounter++
   const itemType = schema.items && typeof schema.items === 'object' && schema.items.type
-  const isPrimItems = itemType === 'string' || itemType === 'number' || itemType === 'integer'
+  // `items` speaks for the elements after the tuple only: with `prefixItems`
+  // the first positions may hold objects, and comparing those by identity
+  // took two equal objects for different ones and accepted the array.
+  const noTuple = !Array.isArray(schema.prefixItems) || schema.prefixItems.length === 0
+  const isPrimItems = noTuple && (itemType === 'string' || itemType === 'number' || itemType === 'integer')
   const maxItems = schema.maxItems
   // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
   // No allocation, no hash computation — just direct === comparison
@@ -4339,7 +4345,7 @@ function inlineBranchBody (body, param, label, local) {
   else return null
   if (/\breturn\b(?! false\b)/.test(core)) return null
   const re = new RegExp('\\b' + param + '\\b', 'g')
-  return core.replace(/\breturn false\b/g, 'break ' + label).replace(re, local)
+  return core.replace(/\breturn false\b/g, () => 'break ' + label).replace(re, () => local)
 }
 
 // A single-branch anyOf or oneOf holds exactly when its branch does, so the
@@ -5169,7 +5175,8 @@ function genUnevaluatedPropertiesNode(schema, v, lines, ctx, knownType, isObj, h
         for (const [trigger, depSchema] of Object.entries(schema.dependentSchemas)) {
           const depResult = collectEvaluated(depSchema, ctx.schemaMap, ctx.rootDefs)
           if (depResult.props && depResult.props.length > 0) {
-            lines.push(`if(${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
+            // Asked of an object only: untyped, the document may be null.
+            lines.push(`if(${isObj ? '' : `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&`}${ownKeyExpr(ctx, v, trigger)}){${depResult.props.map(k => `${evVar}[${JSON.stringify(k)}]=1`).join(';')}}`)
           }
         }
         const inner = `for(var _k in ${v}){if(!${evVar}[_k]&&${ownFail(ctx, v)})return false}`
@@ -5364,7 +5371,8 @@ function genUnevaluatedItemsNode(schema, v, lines, ctx, knownType, isArr) {
       lines.push(`{let ${evVar}=${baseIdx}`)
       lines.push(`const _bf${bfi}=[${fns.join(',')}]`)
       const maxExprs = branchMaxIdx.map((m, i) => {
-        if (branchAllItems[i]) return `_bi===${i}?${v}.length`
+        // An array's length only: `items` passes null too.
+        if (branchAllItems[i]) return isArr ? `_bi===${i}?${v}.length` : `_bi===${i}?(Array.isArray(${v})?${v}.length:0)`
         return `_bi===${i}?${Math.max(m, baseIdx)}`
       }).join(':') + `:${baseIdx}`
       if (branchKeyword === 'oneOf') {
@@ -5543,6 +5551,26 @@ const FORMAT_CODEGEN = Object.assign(Object.create(null), {
   hostname: (...a) => getFormats().hostnameSource(...a),
 })
 
+// An inline check declares locals (`_n`, `_c2`), and the generator names the
+// value it reads (`_c2` for a property). Where the two are one name the
+// check's declaration shadows its own input and throws, so that value is
+// renamed first. Only then; tests/test_no_throw_on_any_document.js.
+function declares (code, name) {
+  for (const before of ['const ', 'let ', 'var ', ',']) {
+    const text = before + name + '='
+    for (let i = code.indexOf(text); i !== -1; i = code.indexOf(text, i + 1)) if (code[i + text.length] !== '=') return true
+  }
+  return false
+}
+for (const name of Object.keys(FORMAT_CODEGEN)) {
+  const write = FORMAT_CODEGEN[name]
+  FORMAT_CODEGEN[name] = (v, isStr, ctx) => {
+    const code = write(v, isStr, ctx)
+    if (!/^[A-Za-z_$][\w$]*$/.test(v) || !declares(code, v)) return code
+    return `{const _fmv=${v};${write('_fmv', isStr, ctx)}}`
+  }
+}
+
 // `^[class]+$`, `^[class]{m,n}$` and `^[class]{n}$` for a class of ASCII
 // letters, digits, `_` and `-`: a function in the preamble that reads each
 // character once and looks it up in a 128-entry table. The inline form below

package/lib/kernels/collapse.mjs

@@ -9,9 +9,12 @@
 // module imports nothing, so the generated code cannot require this file; it
 // carries a copy emitted by `embedSource()` from these very functions instead
 // of a second hand-written one. That is why the internals are written in the
-// positional form the generated code calls, and why `__ataCollapse` may close
-// over nothing but `__ataScore` and the severity table: whatever it reaches
-// has to be in the embed too.
+// positional form the generated code calls, and why each function reaches the
+// others only through properties on itself (`__ataCollapse.F`, `.M`,
+// `__ataScore.S`): a bundler that minifies names renames a function and every
+// call to it, and the text toString() gives then called names the embed did
+// not declare. A function's reference to its own name stays consistent, and
+// property names are not renamed.
 
 // How much a failing keyword says about intent. A branch that fails on `type`
 // was probably not the branch the author meant; one that fails on `minLength`
@@ -35,10 +38,12 @@ const __ATA_SEVERITY = {
 
 function __ataScore (errs) {
   if (!errs || !errs.length) return 0;
+  const sev = __ataScore.S;
   let s = 0;
-  for (const e of errs) s += __ATA_SEVERITY[e.keyword] || 4;
+  for (const e of errs) s += sev[e.keyword] || 4;
   return errs.length * 100 + s; // primary: count, secondary: severity
 }
+__ataScore.S = __ATA_SEVERITY;
 
 // `br` is one entry per branch in declaration order: {valid, errors} and a
 // `title`, or the titles in `titles` when given (the generated code passes
@@ -68,7 +73,7 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
     if (pass.length > 1) {
       const passIdx = [];
       for (let i = 0; i < br.length; i++) if (br[i].valid) passIdx.push(i);
-      return __ataMulti(passIdx, br.length, pp, sp, o);
+      return __ataCollapse.M(passIdx, br.length, pp, sp, o);
     }
   } else if (pass.length >= 1) {
     return null;
@@ -76,7 +81,7 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
   let bi = 0;
   let bs = Infinity;
   for (let i = 0; i < br.length; i++) {
-    const s = __ataScore(br[i].errors);
+    const s = __ataCollapse.F(br[i].errors);
     if (s < bs) { bs = s; bi = i; }
   }
   const best = br[bi];
@@ -97,6 +102,9 @@ function __ataCollapse (kw, br, pp, sp, o, titles) {
   return none;
 }
 
+__ataCollapse.M = __ataMulti;
+__ataCollapse.F = __ataScore;
+
 // The named-argument form the interpreter and the tests call.
 function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPath, ordinal }) {
   return __ataCollapse(keyword, branchResults, parentPath, parentSchemaPath, ordinal === undefined ? null : ordinal);
@@ -107,8 +115,8 @@ function collapseBranches ({ keyword, branchResults, parentPath, parentSchemaPat
 // cannot miss the other. `tests/test_branch_collapse.js` runs both.
 function embedSource () {
   return 'const __ATA_SEVERITY=' + JSON.stringify(__ATA_SEVERITY) + ';' +
-    'const __ataScore=' + __ataScore.toString() + ';' +
+    'const __ataScore=' + __ataScore.toString() + ';__ataScore.S=__ATA_SEVERITY;' +
     'const __ataMulti=' + __ataMulti.toString() + ';' +
-    'const __ataCollapse=' + __ataCollapse.toString() + ';';
+    'const __ataCollapse=' + __ataCollapse.toString() + ';__ataCollapse.M=__ataMulti;__ataCollapse.F=__ataScore;';
 }
 export { __ataCollapse };

package/lib/regex-linear.js

@@ -36,6 +36,15 @@ const { parse } = require('./safe-regex')
 // holds them: every accepted pattern answers as the linear engine does and
 // stays fast on inputs built to make a backtracking engine retry.
 const NATIVE_ESCAPES = new Set(['d', 'D', 'w', 'W', 's', 'S', 'n', 'r', 't', 'f', 'v', '.', '\\', '/', '^', '$', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}', '-', 'x', 'u'])
+// How many ways a backtracking engine can split one string over the bounded
+// choices of a pattern. Choices in a row multiply: `(a?){30}` is thirty
+// choices and two to the thirtieth ways, which the engine walks through on a
+// string that does not match. The count used to be a sum capped at 64, so
+// that pattern and `^([a-z]?){64}$` passed as linear and a string of 17
+// characters ran for more than half a minute. Now the product, capped where
+// the worst case stays under a millisecond for a hundred characters.
+const MAX_WAYS = 4096
+// The sum of bounded choices, which both rules below also hold to.
 const MAX_BOUNDED_CHOICES = 64
 
 const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
@@ -52,7 +61,9 @@ function anchored (ast) {
 function simpleRule (ast) {
   // 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.
+  // shape is not provably linear. The choices are held to a sum
+  // (MAX_BOUNDED_CHOICES: a long counted run is slow to compile and to
+  // unwind) and to a product (MAX_WAYS, waysOf below).
   const info = (n) => {
     switch (n.t) {
       case 'star': case 'plus':
@@ -78,7 +89,7 @@ function simpleRule (ast) {
     }
   }
   const r = info(ast)
-  if (r === null || r.u > 1 || r.b > MAX_BOUNDED_CHOICES) return false
+  if (r === null || r.u > 1 || r.b > MAX_BOUNDED_CHOICES || !(waysOf(ast) <= MAX_WAYS)) return false
   return r.u === 0 || anchored(ast)
 }
 
@@ -207,9 +218,31 @@ function deterministicRule (ast) {
   for (let p = 0; p < sets.length && ok; p++) disjoint(follow[p])
   if (!ok) return false
   if (bounded > MAX_BOUNDED_CHOICES) return false
+  // A counted repeat of a body that can end in more than one place is not a
+  // loop to the walk above (`(a?){30}`, `(a{1,8}){8}`), and it is where the
+  // ways multiply: the same product as the simple rule holds here too.
+  if (!(waysOf(ast) <= MAX_WAYS)) return false
   return unbounded === 0 || anchored(ast)
 }
 
+// The product the simple rule counts, over any shape: an unbounded
+// quantifier adds no bounded choice of its own.
+function waysOf (n) {
+  switch (n.t) {
+    case 'star': case 'plus': return waysOf(n.child)
+    case 'quest': return atom(n.child) ? 2 : 1 + waysOf(n.child)
+    case 'repeat': {
+      if (n.max === Infinity) return waysOf(n.child)
+      if (atom(n.child)) return n.max - n.min + 1
+      return (n.max - n.min + 1) * Math.pow(waysOf(n.child), n.max)
+    }
+    case 'group': return waysOf(n.child)
+    case 'concat': { let w = 1; for (const part of n.parts) w *= waysOf(part); return w }
+    case 'alt': { let w = 0; for (const part of n.opts) w += waysOf(part); return w }
+    default: return 1
+  }
+}
+
 // Two more shapes the rules above decline, both anchored with `^` and `$`
 // around one top-level sequence.
 //
@@ -393,6 +426,11 @@ function nativeIsLinear (src) {
   }
   let ast
   try { ast = parse(src) } catch { return false }
+  // The product of the bounded choices holds for every rule below, so it is
+  // asked here, once: the one-choice and delimited-loop rules did not ask it,
+  // and `^(a*b)*` followed by thirty `a?` reached the platform RegExp, where
+  // each `a?` more doubles the time on a string that does not match.
+  if (!(waysOf(ast) <= MAX_WAYS)) return false
   return simpleRule(ast) || deterministicRule(ast) || oneChoiceRule(ast) || delimitedLoopRule(ast)
 }
 

package/lib/scan-compiler.js

@@ -981,6 +981,12 @@ function emitObject(schema, ctx, out, depth) {
   const reqMasks = new Array(words).fill(0);
   if (required) for (const k of required) { const x = bit.get(k); reqMasks[x.w] |= x.b; }
 
+  // Many names are dispatched on a hash of the key, and two names with one
+  // hash cannot be: the code below then took the other branch, which reads
+  // variables only the few-names form declares, and the scanner threw a
+  // ReferenceError on every document that carried a declared key. Such a
+  // schema is left to the parser.
+  if (names.length >= HASH_DISPATCH_MIN && new Set(names.map(spanHash)).size !== names.length) decline('properties:hash-collision');
   out.push('c=s.charCodeAt(++i);');
   const useHash = names.length >= HASH_DISPATCH_MIN;
   if (useHash) {

package/lib/schema-scan.js

@@ -118,8 +118,9 @@ function needsNormalization(schema, isDraft7) {
   // The boolean form of the exclusive bounds is draft-04's, and it is
   // unambiguous wherever it appears: no later dialect gives a boolean any
   // meaning there. Percent-encoded fragments mean the same in every dialect
-  // too. Neither is gated on the declared dialect.
-  if (bits & (NULLABLE | EXCLUSIVE_BOOL | ENCODED_REF)) return true;
+  // too. A fragment-only `$id` is folded into `$anchor` in every dialect, by
+  // the walk that folds `nullable`. None is gated on the declared dialect.
+  if (bits & (NULLABLE | EXCLUSIVE_BOOL | ENCODED_REF | ANCHOR_ID)) return true;
   return isDraft7 ? (bits & DRAFT7_WORK) !== 0 : false;
 }
 

package/lib/unique-items-source.js

@@ -0,0 +1,3 @@
+'use strict';
+// Generated by scripts/gen-unique-items-source.js from lib/unique-items.js. Do not edit.
+module.exports = { uq: "function _uqh(x) {\nif (x === null) return 1;\nvar t = typeof x, h, i;\nif (t === 'boolean') return x ? 2 : 3;\nif (t === 'number') {\nif (x === 0) return 4;\nh = x | 0;\nif (h === x) return Math.imul(h, 0x9e3779b1) ^ 5;\nvar f = _uqh.f || (_uqh.f = new Float64Array(1)), w = _uqh.w || (_uqh.w = new Uint32Array(f.buffer));\nf[0] = x;\nreturn Math.imul(w[0] ^ Math.imul(w[1], 0x9e3779b1), 0x85ebca6b) ^ 5;\n}\nif (t === 'string') {\nh = 0x811c9dc5 ^ x.length;\nfor (i = 0; i < x.length; i++) h = Math.imul(h ^ x.charCodeAt(i), 16777619);\nreturn h;\n}\nif (t !== 'object') return 6;\nif (Array.isArray(x)) {\nh = 0x2545f491 ^ x.length;\nfor (i = 0; i < x.length; i++) h = Math.imul(h ^ _uqh(x[i]), 16777619);\nreturn h;\n}\nvar ks = Object.keys(x);\nh = 0x6c8e9cf5 ^ ks.length;\nfor (i = 0; i < ks.length; i++) h = (h + Math.imul(_uqh(ks[i]) ^ Math.imul(_uqh(x[ks[i]]), 0x5bd1e995), 0x27d4eb2d)) | 0;\nreturn h;\n}function _uq(a) {\nvar n = a.length, i, k;\nif (n < 2) return true;\nif (n <= 12) {\nfor (i = 1; i < n; i++) for (k = 0; k < i; k++) if (_deq(a[i], a[k])) return false;\nreturn true;\n}\nvar prim = true;\nfor (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }\nif (prim) {\nvar s = new Set();\nfor (i = 0; i < n; i++) { if (s.has(a[i])) return false; s.add(a[i]); }\nreturn true;\n}\nvar m = new Map();\nfor (i = 0; i < n; i++) {\nvar hh = _uqh(a[i]), b = m.get(hh);\nif (b === undefined) m.set(hh, i);\nelse if (typeof b === 'number') { if (_deq(a[b], a[i])) return false; m.set(hh, [b, i]); }\nelse { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) return false; b.push(i); }\n}\nreturn true;\n}", uqp: "var _uqpI=0;function _uqp(a) {\nvar n = a.length, i, k;\nif (n < 2) return -1;\nif (n <= 12) {\nfor (i = 0; i < n - 1; i++) for (k = i + 1; k < n; k++) if (_deq(a[i], a[k])) { _uqpI = i; return k; }\nreturn -1;\n}\nvar prim = true;\nfor (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }\nvar bi = -1, bj = -1, m = new Map();\nif (prim) {\nfor (i = 0; i < n; i++) {\nvar p = m.get(a[i]);\nif (p === undefined) m.set(a[i], i);\nelse if (p >= 0) { if (bi < 0 || p < bi) { bi = p; bj = i; } m.set(a[i], -1); }\n}\n} else {\nvar paired = null;\nfor (i = 0; i < n; i++) {\nvar hh = _uqh(a[i]), b = m.get(hh), r = -1;\nif (b === undefined) { m.set(hh, i); continue; }\nif (typeof b === 'number') { if (_deq(a[b], a[i])) r = b; else m.set(hh, [b, i]); }\nelse { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) { r = b[k]; break; } if (r < 0) b.push(i); }\nif (r >= 0) {\nif (paired === null) paired = new Set();\nif (!paired.has(r)) { paired.add(r); if (bi < 0 || r < bi) { bi = r; bj = i; } }\n}\n}\n}\nif (bi < 0) return -1;\n_uqpI = bi;\nreturn bj;\n}" };

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.63.1",
+  "version": "1.63.3",
   "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",
@@ -266,13 +266,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.63.1",
-    "@ata-validator/native-darwin-x64": "1.63.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.63.1",
-    "@ata-validator/native-linux-arm64-musl": "1.63.1",
-    "@ata-validator/native-linux-x64-gnu": "1.63.1",
-    "@ata-validator/native-linux-x64-musl": "1.63.1",
-    "@ata-validator/native-win32-x64": "1.63.1"
+    "@ata-validator/native-darwin-arm64": "1.63.3",
+    "@ata-validator/native-darwin-x64": "1.63.3",
+    "@ata-validator/native-linux-arm64-gnu": "1.63.3",
+    "@ata-validator/native-linux-arm64-musl": "1.63.3",
+    "@ata-validator/native-linux-x64-gnu": "1.63.3",
+    "@ata-validator/native-linux-x64-musl": "1.63.3",
+    "@ata-validator/native-win32-x64": "1.63.3"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"