ata-validator 1.18.1 → 1.20.0

package/lib/js-compiler.js

@@ -25,6 +25,12 @@ const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return type
 function hoistOnce(ctx, key, code) {
   if (ctx[key]) return
   ctx[key] = true
+  // Recorded as shared: the text is a constant and the name it declares is
+  // fixed, so several compiled schemas in one bundle can use one copy. The
+  // rest of the preamble cannot move, because emitConstant and the generated
+  // branch checks name things per compilation (_kv0, _av3) and two schemas
+  // would collide.
+  if (ctx.shared) ctx.shared.push(code)
   if (ctx.preamble) ctx.preamble.push(code)
   else if (ctx.helperCode) ctx.helperCode.push(code)
 }
@@ -34,6 +40,18 @@ function emitDeq(ctx) {
   return '_deq'
 }
 
+// RFC 6901: a property key reaching an instancePath has to have `~` and `/`
+// escaped, or the pointer splits into the wrong segments. Static keys are
+// escaped at compile time with ptrSeg; a key only known at run time needs
+// this. It mirrors interpreter.js escapePointer, including skipping the two
+// regex passes for the keys that need nothing, which is almost all of them.
+const PTR_ESC_HELPER = "function _pe(s){for(let i=0;i<s.length;i++){const c=s.charCodeAt(i);if(c===126||c===47)return s.replace(/~/g,'~0').replace(/\\//g,'~1')}return s}"
+
+function emitPtrEsc(ctx) {
+  hoistOnce(ctx, '_peHoisted', PTR_ESC_HELPER)
+  return '_pe'
+}
+
 // `_uq` compares items with `_deq`, so it can never be hoisted alone.
 function emitUq(ctx) {
   emitDeq(ctx)
@@ -404,29 +422,33 @@ function compileToJS(schema, defs, schemaMap) {
     })
   }
 
-  // numeric
+  // numeric. A non-finite number carries no type here, so an empty schema
+  // accepts it and these must let it through for the same reason: otherwise
+  // `{ minimum: 3 }` turns away a value `{}` admits, and the two engines
+  // answer differently for it.
   if (schema.minimum !== undefined) {
     const min = schema.minimum
-    checks.push((d) => typeof d !== 'number' || d >= min)
+    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d >= min)
   }
   if (schema.maximum !== undefined) {
     const max = schema.maximum
-    checks.push((d) => typeof d !== 'number' || d <= max)
+    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d <= max)
   }
   if (schema.exclusiveMinimum !== undefined) {
     const min = schema.exclusiveMinimum
-    checks.push((d) => typeof d !== 'number' || d > min)
+    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d > min)
   }
   if (schema.exclusiveMaximum !== undefined) {
     const max = schema.exclusiveMaximum
-    checks.push((d) => typeof d !== 'number' || d < max)
+    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d < max)
   }
   if (schema.multipleOf !== undefined) {
     const div = schema.multipleOf
     checks.push((d) => {
-      if (typeof d !== 'number') return true
-      const r = d % div
-      return Math.abs(r) <= 1e-8 || Math.abs(r - div) <= 1e-8
+      if (typeof d !== 'number' || !isFinite(d)) return true
+      if (div === 0) return false
+      const q = d / div
+      return Number.isInteger(q) || Math.abs(q - Math.round(q)) < 1e-9
     })
   }
 
@@ -750,6 +772,21 @@ function buildTypeCheck(types) {
   }
 }
 
+// `multipleOf` as the interpreter reads it: divide and ask whether the
+// quotient is a whole number. The remainder form this replaces answered -1 %
+// 0.1 with -0.09999999999999995, which is neither near zero nor near the
+// divisor, so it called -1 not a multiple of 0.1 when -1 / 0.1 is exactly -10.
+// Emitted from one place because the expression stood in six.
+function multipleOfBad(v, m) {
+  if (m === 0) return 'true'
+  // Negated rather than written as "the distance is too large": a quotient
+  // that overflows to Infinity makes the distance NaN, and every comparison
+  // with NaN is false, so the direct form called 1e308 a multiple of
+  // 0.123456789. Asking whether it is good and negating keeps that case a
+  // rejection, which is what the suite wants and what the closure form does.
+  return `!(Number.isInteger(${v}/${m})||Math.abs(${v}/${m}-Math.round(${v}/${m}))<1e-9)`
+}
+
 const TYPE_CHECKS = {
   string: (d) => typeof d === 'string',
   number: (d) => typeof d === 'number' && isFinite(d),
@@ -768,12 +805,30 @@ function _canonical(x) {
 }
 
 const _formats = require('./formats')
+// The closure path's formats. It carried its own idea of an email and knew
+// five formats in all, so a schema that reached it was told "valid" for
+// anything the other engines turned away; the first call on a fresh validator
+// is the one that lands here. Every entry now names the same function the
+// other two paths use, and the list is the list they implement.
 const FORMAT_CHECKS = {
-  email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1 },
+  email: _formats.email,
+  'idn-email': _formats.idnEmail,
   date: _formats.date,
+  'date-time': _formats.dateTime,
+  time: _formats.time,
+  duration: _formats.duration,
   uuid: _formats.uuid,
+  uri: _formats.uri,
+  'uri-reference': _formats.uriReference,
+  'uri-template': _formats.uriTemplate,
+  iri: _formats.iri,
+  'iri-reference': _formats.iriReference,
   ipv4: _formats.ipv4,
+  ipv6: _formats.ipv6,
   hostname: _formats.hostname,
+  'json-pointer': _formats.jsonPointer,
+  'relative-json-pointer': _formats.relativeJsonPointer,
+  regex: (s) => { try { new RegExp(s, 'u'); return true } catch { return false } },
 }
 
 // Dangerous JS property names that exist on Object.prototype
@@ -1437,7 +1492,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -1519,6 +1574,9 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
     boolFn._source = helperStr + body
     boolFn._preambleSource = preambleStr
+    boolFn._preambleGuard = guardStr
+    boolFn._preambleParts = ctx.preamble ? ctx.preamble.slice() : []
+    boolFn._sharedHelpers = ctx.shared ? ctx.shared.slice() : []
     boolFn._hybridSource = helperStr + hybridBody
     boolFn._usesSafeRe = !!ctx.usesSafeRe
     // Custom-format closure entries that the bundle output needs to recreate.
@@ -1685,7 +1743,7 @@ function tryGenCombined(schema, access, ctx) {
     if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
     if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
     if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
-    if (schema.multipleOf !== undefined) conds.push(`(Math.abs(_v%${schema.multipleOf})>1e-8&&Math.abs(_v%${schema.multipleOf}-${schema.multipleOf})>1e-8)`)
+    if (schema.multipleOf !== undefined) conds.push(`(${multipleOfBad('_v', schema.multipleOf)})`)
     if (conds.length < 2) return null
     return bind(conds)
   }
@@ -1696,7 +1754,7 @@ function tryGenCombined(schema, access, ctx) {
     if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
     if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
     if (schema.exclusiveMaximum !== undefined) conds.push(`_v>=${schema.exclusiveMaximum}`)
-    if (schema.multipleOf !== undefined) conds.push(`(Math.abs(_v%${schema.multipleOf})>1e-8&&Math.abs(_v%${schema.multipleOf}-${schema.multipleOf})>1e-8)`)
+    if (schema.multipleOf !== undefined) conds.push(`(${multipleOfBad('_v', schema.multipleOf)})`)
     if (conds.length < 2) return null
     return bind(conds)
   }
@@ -1956,14 +2014,19 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 
   // numeric — skip type guard if known numeric
-  if (schema.minimum !== undefined) lines.push(isNum ? `if(${v}<${schema.minimum})return false` : `if(typeof ${v}==='number'&&${v}<${schema.minimum})return false`)
-  if (schema.maximum !== undefined) lines.push(isNum ? `if(${v}>${schema.maximum})return false` : `if(typeof ${v}==='number'&&${v}>${schema.maximum})return false`)
-  if (schema.exclusiveMinimum !== undefined) lines.push(isNum ? `if(${v}<=${schema.exclusiveMinimum})return false` : `if(typeof ${v}==='number'&&${v}<=${schema.exclusiveMinimum})return false`)
-  if (schema.exclusiveMaximum !== undefined) lines.push(isNum ? `if(${v}>=${schema.exclusiveMaximum})return false` : `if(typeof ${v}==='number'&&${v}>=${schema.exclusiveMaximum})return false`)
+  // Without `type: number` beside it, a numeric keyword has to let a
+  // non-finite value through: it carries no type, an empty schema accepts it,
+  // and the interpreted engine reads it the same way. With `type: number` the
+  // type check has already turned it away, so the guard is only needed here.
+  const numGuard = isNum ? '' : `typeof ${v}==='number'&&isFinite(${v})&&`
+  if (schema.minimum !== undefined) lines.push(`if(${numGuard}${v}<${schema.minimum})return false`)
+  if (schema.maximum !== undefined) lines.push(`if(${numGuard}${v}>${schema.maximum})return false`)
+  if (schema.exclusiveMinimum !== undefined) lines.push(`if(${numGuard}${v}<=${schema.exclusiveMinimum})return false`)
+  if (schema.exclusiveMaximum !== undefined) lines.push(`if(${numGuard}${v}>=${schema.exclusiveMaximum})return false`)
   if (schema.multipleOf !== undefined) {
     const m = schema.multipleOf
-    const bad = `(Math.abs(${v}%${m})>1e-8&&Math.abs(${v}%${m}-${m})>1e-8)`
-    lines.push(isNum ? `if${bad}return false` : `if(typeof ${v}==='number'&&${bad})return false`)
+    const bad = `(${multipleOfBad(v, m)})`
+    lines.push(`if(${numGuard}${bad})return false`)
   }
 
   // string length — skip type guard if known string.
@@ -3202,7 +3265,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   if (hasUnresolvableRef(schema, eRootDefs, eAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null,
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, shared: [], refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null,
                 // Custom format checkers referenced by the body, bound as
                 // closure parameters below the way the other entry points do.
                 closureVars: [], closureVals: [],
@@ -3222,7 +3285,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
   // AOT output small for schemas that don't compose. Standalone modules can't
   // require('./branch-collapse'), so the helper body is embedded verbatim.
   if (ctx.usesBranchCollapse) {
-    ctx.helperCode.push("const __ATA_SEVERITY={type:10,const:8,enum:8,required:5,format:3,minLength:3,maxLength:3,minimum:3,maximum:3,pattern:3,additionalProperties:2,unevaluatedProperties:2,unevaluatedItems:2};function __ataScore(errs){if(!errs||!errs.length)return 0;let s=0;for(const e of errs)s+=__ATA_SEVERITY[e.keyword]||4;return errs.length*100+s}function __ataCollapse(kw,br,pp,sp,o){const pass=br.filter(b=>b.valid);if(kw==='oneOf'){if(pass.length===1)return null;if(pass.length>1)return{code:'ATA4002',keyword:'oneOf',instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched '+pass.length+' of '+br.length+' oneOf variants, expected exactly one',params:{matched:pass.length,total:br.length}}}else{if(pass.length>=1)return null}let bi=0,bs=Infinity;for(let i=0;i<br.length;i++){const s=__ataScore(br[i].errors);if(s<bs){bs=s;bi=i}}const code=kw==='oneOf'?'ATA4001':'ATA4003';const best=br[bi];return{code,keyword:kw,instancePath:pp||'',path:pp||'',schemaPath:sp,_o:o,message:'value matched 0 of '+br.length+' '+kw+' variants',params:{variants:br.length,closest:bi,closestName:best.title||('variant '+(bi+1))},branchErrors:best.errors}}")
+        ctx.helperCode.push(require('./branch-collapse').embedSource())
   }
   if (lines.length === 0) return (d) => ({ valid: true, errors: [] })
 
@@ -3272,6 +3335,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap, userFormats, sourceOpts
       fn = new Function('d', '_all', body)
     }
     fn._errSource = body
+    fn._sharedHelpers = ctx.shared ? ctx.shared.slice() : []
     fn._usesSafeRe = !!ctx.usesSafeRe
     if (cvars.length) {
       fn._formatClosures = cvars.map((name, i) => {
@@ -3448,10 +3512,11 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
+    const expectedParam = types.length === 1 ? `'${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:'${expected}'},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 ${expected}',docUrl:'${lit.docUrl}'${lit.frame}});if(!_all)return{valid:false,errors:_e}}`)
     }
   }
 
@@ -3514,7 +3579,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const m = schema.multipleOf
     const ci = ctx.varCounter++
     // Use tolerance-based check for floating point (matches C++ behavior)
-    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
+    lines.push(`{if(typeof ${v}==='number'&&${multipleOfBad(v, m)}){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
   // string length — same s.length fast paths as the boolean codegen above.
@@ -3661,9 +3726,9 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // properties — always guard (error mode, data may not be an object or may be array)
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
-      const childPath = childPathExpr(pathExpr, esc(key))
+      const childPath = childPathExpr(pathExpr, ptrSeg(key))
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+      genCodeE(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
@@ -3685,7 +3750,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       const ri = ctx.regExpMap.get(pattern);
       const ki = ctx.varCounter++
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){if(_re${ri}.test(_k${ki})){`)
-      const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+      const _peFn = emitPtrEsc(ctx)
+      const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
       // The real pointer, so source maps can locate the failing keyword.
       genCodeE(sub, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/patternProperties/' + pat.replace(/~/g, '~0').replace(/\//g, '~1'))
       lines.push(`}}}`)
@@ -3721,7 +3787,8 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (patTests.length) conds.push(`!(${patTests.join('||')})`)
     const keep = conds.length ? `if(${conds.join('&&')}){` : `{`
     lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${guard}for(const _k${ki} in ${v}){${keep}`)
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    const _peFn = emitPtrEsc(ctx)
+    const p = pathExpr ? `${pathExpr}+'/'+${_peFn}(_k${ki})` : `'/'+${_peFn}(_k${ki})`
     genCodeE(schema.additionalProperties, `${v}[_k${ki}]`, p, lines, ctx, schemaPrefix + '/additionalProperties')
     lines.push(`}}}`)
   }
@@ -3730,7 +3797,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
+      genCodeE(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
@@ -3739,7 +3806,10 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   // interpreter does (plan-compiler: instancePath + '/' + key).
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    // The subschema is applied to the property NAME, so the failure belongs to
+    // the object that carries the name, not to `/<key>`, which is where the
+    // value lives. Same placement as the object-valued propertyNames branch.
+    const p = pathExpr || '""'
     lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){_e.push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'});if(!_all)return{valid:false,errors:_e}}}`)
   }
 
@@ -3811,9 +3881,9 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
     lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
     if (maxC !== undefined) {
-      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+      lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     }
     lines.push(`}`)
   }
@@ -3949,7 +4019,7 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, cRootDefs, cAnchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helperCode: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
+  const ctx = { varCounter: 0, helperCode: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen],
                 rootDefs: cRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: cAnchors, rootSchema: schema, userFormats: userFormats || null }
   const lines = []
   genCodeC(schema, 'd', '', lines, ctx, '#')
@@ -4095,10 +4165,11 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
     })
     const expected = types.join(', ')
+    const expectedParam = types.length === 1 ? `'${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:'${expected}'}`, `'must be ${expected}'`)}}`)
+    lines.push(`if(!${typeOk}){${fail('type', 'type', `{type:${expectedParam}}`, `'must be ${expected}'`)}}`)
     // Subsequent optimized code runs inside if(typeOk){...}
     if (types.length === 1) {
       isObj = types[0] === 'object'
@@ -4174,7 +4245,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.multipleOf !== undefined) {
     const m = schema.multipleOf
     const ci = ctx.varCounter++
-    lines.push(`{const _r${ci}=typeof ${v}==='number'?${v}%${m}:NaN;if(typeof ${v}==='number'&&Math.abs(_r${ci})>1e-8&&Math.abs(_r${ci}-${m})>1e-8){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
+    lines.push(`{if(typeof ${v}==='number'&&${multipleOfBad(v, m)}){${fail('multipleOf', 'multipleOf', `{multipleOf:${m}}`, `'must be multiple of ${m}'`)}}}`)
   }
 
   // string length — s.length fast paths, _cpLen only in the uncertain band.
@@ -4293,19 +4364,19 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
       const pv = hoisted[key] || `${v}[${JSON.stringify(key)}]`
-      const childPath = childPathExpr(pathExpr, esc(key))
+      const childPath = childPathExpr(pathExpr, ptrSeg(key))
       if (requiredSet.has(key) && isObj) {
         lines.push(`if(${pv}!==undefined){`)
-        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, pv, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       } else if (isObj) {
         const oi = ctx.varCounter++
         lines.push(`{const _o${oi}=${v}[${JSON.stringify(key)}];if(_o${oi}!==undefined){`)
-        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, `_o${oi}`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}}`)
       } else {
         lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+key)
+        genCodeC(prop, `${v}[${JSON.stringify(key)}]`, childPath, lines, ctx, schemaPrefix+'/properties/'+ptrSeg(key))
         lines.push(`}`)
       }
     }
@@ -4378,7 +4449,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         // The subschema is generated in place so its own keywords report
         // the real instance path and schema pointer.
         lines.push(`if(${matchers[i].check}){_m${pi}=true;{const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, kVar), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
         lines.push(`}}`)
       }
       lines.push(`if(!_m${pi}){${fail('additionalProperties', 'additionalProperties', `{additionalProperty:${kVar}}`, "'must NOT have additional properties'")}}`)
@@ -4410,7 +4481,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       }
       for (let i = 0; i < ppEntries.length; i++) {
         lines.push(`if(${matchers[i].check}){const _ppv${pi}_${i}=${v}[${kVar}]`)
-        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, kVar), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
+        genCodeC(ppEntries[i][1], `_ppv${pi}_${i}`, childPathDynExpr(pathExpr, `${emitPtrEsc(ctx)}(${kVar})`), lines, ctx, schemaPrefix + '/patternProperties/' + ptrSeg(ppEntries[i][0]))
         lines.push(`}`)
       }
       lines.push(`}}`)
@@ -4421,14 +4492,14 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (schema.dependentSchemas) {
     for (const [key, depSchema] of Object.entries(schema.dependentSchemas)) {
       lines.push(`if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})&&${JSON.stringify(key)} in ${v}){`)
-      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+key)
+      genCodeC(depSchema, v, pathExpr, lines, ctx, schemaPrefix+'/dependentSchemas/'+ptrSeg(key))
       lines.push(`}`)
     }
   }
 
   if (schema.propertyNames === false) {
     const ki = ctx.varCounter++
-    const p = pathExpr ? `${pathExpr}+'/'+_k${ki}` : `'/'+_k${ki}`
+    const p = pathExpr || '""'
     lines.push(`;if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){for(const _k${ki} in ${v}){(_e||(_e=[])).push({keyword:'not',instancePath:${p},schemaPath:'${schemaPrefix}/propertyNames'${ordinalField(ctx, `${schemaPrefix}/propertyNames`)},params:{},message:'boolean schema is false'})}}`)
   }
 
@@ -4491,8 +4562,8 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     const minC = schema.minContains !== undefined ? schema.minContains : 1
     const maxC = schema.maxContains
     lines.push(`if(Array.isArray(${v})){const _cf${ci}=function(_cv){${fnBody}};let _cc${ci}=0;for(let _ci${ci}=0;_ci${ci}<${v}.length;_ci${ci}++){if(_cf${ci}(${v}[_ci${ci}]))_cc${ci}++}`)
-    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{limit:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
-    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{limit:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
+    lines.push(`if(_cc${ci}<${minC}){${fail('contains', 'contains', `{minContains:${minC}}`, `'contains: need at least ${minC} match(es)'`)}}`)
+    if (maxC !== undefined) lines.push(`if(_cc${ci}>${maxC}){${fail('contains', 'contains', `{minContains:${minC},maxContains:${maxC}}`, `'contains: at most ${maxC} match(es)'`)}}`)
     lines.push(`}`)
   }
 

package/lib/output-format.js

@@ -0,0 +1,140 @@
+'use strict';
+
+// The standardised output format from draft 2019-09 and 2020-12.
+//
+// ata reports errors in its own shape, the one consumers and the compat entry
+// expect. The specification also defines an output format of its own, with
+// `keywordLocation`, `absoluteKeywordLocation` and `instanceLocation`, and the
+// official test suite has a small set of tests for it under `output-tests/`.
+// This produces that shape from a validation, so those tests can be run and so
+// a caller that wants spec output can have it.
+//
+// `flag` and `basic` are implemented. `detailed` and `verbose` are not: they
+// need the full applicator tree, including the subschemas that passed, which
+// the engines do not keep. The v1 `list` format is not implemented either; it
+// is still moving, and the suite's own v1 output schema does not yet define it.
+//
+// Annotations are collected only when validation succeeded. That is not a
+// shortcut: a subschema that fails contributes no annotations, and the output
+// is rooted at the root schema, so a failing root drops all of them.
+
+// Keywords whose value is the annotation they produce.
+const METADATA_KEYWORDS = [
+  'title', 'description', 'default', 'deprecated', 'readOnly', 'writeOnly',
+  'examples', 'format', 'contentEncoding', 'contentMediaType', 'contentSchema',
+];
+
+function pointerSegment (s) {
+  return String(s).replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+// The root $id, which absoluteKeywordLocation is resolved against.
+function baseUri (schema) {
+  if (schema && typeof schema === 'object' && typeof schema.$id === 'string') {
+    return schema.$id.split('#')[0];
+  }
+  return null;
+}
+
+function unitFor (error, base) {
+  const keywordLocation = typeof error.schemaPath === 'string' && error.schemaPath.charAt(0) === '#'
+    ? error.schemaPath.slice(1)
+    : (error.schemaPath || '');
+  const unit = {
+    valid: false,
+    keywordLocation,
+    instanceLocation: error.instancePath || '',
+  };
+  if (base) unit.absoluteKeywordLocation = base + '#' + keywordLocation;
+  if (typeof error.message === 'string') unit.error = error.message;
+  return unit;
+}
+
+// Walk the schema beside the instance, collecting metadata annotations from
+// the subschemas that applied. Only reached when the whole validation passed,
+// so every applicator followed here is one that succeeded, except the
+// alternatives of anyOf/oneOf/if, which are checked before being followed.
+function collectAnnotations (schema, data, keywordLocation, instanceLocation, base, out, isValid, depth) {
+  if (schema === true || schema === false || schema === null || typeof schema !== 'object' || depth > 64) return;
+
+  for (const kw of METADATA_KEYWORDS) {
+    if (Object.prototype.hasOwnProperty.call(schema, kw)) {
+      const unit = {
+        valid: true,
+        keywordLocation: keywordLocation + '/' + kw,
+        instanceLocation,
+        annotation: schema[kw],
+      };
+      if (base) unit.absoluteKeywordLocation = base + '#' + keywordLocation + '/' + kw;
+      out.push(unit);
+    }
+  }
+
+  const down = (sub, kwSeg, value, instSeg) => collectAnnotations(
+    sub, value, keywordLocation + kwSeg, instanceLocation + (instSeg || ''), base, out, isValid, depth + 1,
+  );
+
+  if (schema.properties && data !== null && typeof data === 'object' && !Array.isArray(data)) {
+    for (const key of Object.keys(schema.properties)) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        down(schema.properties[key], '/properties/' + pointerSegment(key), data[key], '/' + pointerSegment(key));
+      }
+    }
+  }
+  if (Array.isArray(schema.prefixItems) && Array.isArray(data)) {
+    for (let i = 0; i < schema.prefixItems.length && i < data.length; i++) {
+      down(schema.prefixItems[i], '/prefixItems/' + i, data[i], '/' + i);
+    }
+  }
+  if (schema.items && typeof schema.items === 'object' && Array.isArray(data)) {
+    const start = Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0;
+    for (let i = start; i < data.length; i++) down(schema.items, '/items', data[i], '/' + i);
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (let i = 0; i < schema.allOf.length; i++) down(schema.allOf[i], '/allOf/' + i, data, '');
+  }
+  for (const kw of ['anyOf', 'oneOf']) {
+    if (Array.isArray(schema[kw])) {
+      for (let i = 0; i < schema[kw].length; i++) {
+        if (isValid(schema[kw][i], data)) down(schema[kw][i], '/' + kw + '/' + i, data, '');
+      }
+    }
+  }
+  if (schema.if !== undefined) {
+    const taken = isValid(schema.if, data);
+    if (taken && schema.then !== undefined) down(schema.then, '/then', data, '');
+    if (!taken && schema.else !== undefined) down(schema.else, '/else', data, '');
+  }
+}
+
+// Produce spec output for `data` under `validator`.
+//   format: 'flag' | 'basic' (default 'basic')
+function toOutput (validator, data, opts) {
+  const format = (opts && opts.format) || 'basic';
+  const result = validator.validate(data);
+  if (format === 'flag') return { valid: result.valid };
+  if (format !== 'basic') {
+    throw new Error(`toOutput: unsupported format "${format}". Supported: "flag", "basic".`);
+  }
+
+  const schema = validator._schemaObj !== undefined ? validator._schemaObj : validator._rawSchema;
+  const base = baseUri(schema);
+  const out = { valid: result.valid };
+
+  if (!result.valid) {
+    const errors = [];
+    for (const e of result.errors) errors.push(unitFor(e, base));
+    out.errors = errors;
+    return out;
+  }
+
+  const annotations = [];
+  const isValid = (sub, value) => {
+    try { return new validator.constructor(sub).isValidObject(value); } catch { return false; }
+  };
+  collectAnnotations(schema, data, '', '', base, annotations, isValid, 0);
+  if (annotations.length) out.annotations = annotations;
+  return out;
+}
+
+module.exports = { toOutput, METADATA_KEYWORDS };