ata-validator 1.7.1 → 1.7.3

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 1.7.3 - 2026-08-26
+
+### Added
+
+- A prebuilt native engine for Intel macOS again, `@ata-validator/native-darwin-x64`. The target was dropped in 0.13.4 because GitHub's x64 macOS runners had stopped being reliably available; `macos-15-intel` brought them back, so the matrix is now seven targets: darwin arm64 and x64, linux x64 and arm64 on both glibc and musl, and win32 x64. Intel Macs went to the pure-JS engine in the meantime, which validates identically but leaves the buffer APIs unavailable, so this only changes speed and reach, not answers.
+
+## 1.7.2 - 2026-08-24
+
+### Fixed
+
+- `enum` compared object members by their serialized form, so `{"b": 2, "a": 1}` was rejected against `enum: [{"a": 1, "b": 2}]`. JSON Schema compares instances by value: two objects with the same members are equal whatever order their keys were written in. All three code generation paths did this, so they agreed with each other and disagreed with the interpreted engine, which has always compared structurally. `const` was already correct but reached the answer by building a canonical string on every call. Both now use one structural comparison hoisted per compiled function. The official suite does not cover reordered keys for `enum`, and the entry-point agreement test compares the generators against each other, so neither would have caught this; `tests/test_value_equality.js` pins the answer through every engine that can produce one and runs as part of `npm test`.
+- A draft-07 document passed through the `schemas` option was rejected with "Schema in schemas option must have $id" whenever it carried `$ref` next to `$id`. Draft-07 ignores every keyword sitting beside `$ref`, so normalization drops them and `$id` goes with them, which is the right reading for evaluation: the reference resolves against the URI the document was retrieved from, not the `$id` it declares. It is the wrong reading for registration, where `$id` is the only name the caller gave the document. The identity is now read from what the caller passed when normalization has dropped it, so such a document registers under its `$id` in the array form and is addressable by both its retrieval URI and its `$id` in the map form. A document that declares no `$id` at all is still refused, and a fragment-only `$id` is still an anchor rather than a document name. This is what made all 23 remote-reference cases of the draft-07 suite error out in the Bowtie compliance report; they now answer, and answer correctly.
+
+### Changed
+
+- The closure-tree compiler now covers every schema the interpreted engine accepts. It previously declined `unevaluatedProperties`/`unevaluatedItems` and `$dynamicRef` in any schema with more than one resource, which left 192 of the 987 suite schemas walking the generic evaluator; that count is now zero. Annotations flow through the compiled tree: the compiler decides at compile time which nodes anyone reads annotations from, and those nodes carry a record that in-place children write into directly, with a failed child rolled back by truncating the record rather than by allocating a fresh one per child. `$dynamicRef` resolves against the dynamic scope computed at compile time, so multi-resource schemas no longer search it per call. A schema whose compiled graph has no cycle drops the recursion guard and the `(schema, data)` stack entirely. An unresolvable `$ref` compiles into the same runtime rejection the evaluator produces instead of declining the schema.
+- Measured on the official suite with prebuilt validators, several runs each on the same machine: draft 2020-12 went from 94 ns to 77-80 ns per case overall, and the cases that route to the interpreted engine from about 240 ns to about 125 ns when they accept and 235 ns to 160 ns when they reject. Draft 7 went from 59 ns to 49 ns overall. The metaschema-validation case, the worst outlier in the suite, went from 5.5 µs to about 1.4 µs. On a longer steady-state loop over the same suite, where construction is not part of what is timed, draft 2020-12 went from 46 ns to 43 ns per case and draft 7 from 33 ns to 29 ns.
+- The value-level keywords of a schema node are compiled into closures over their own operands instead of being answered by a generic evaluator that re-reads a dozen presence flags off the plan on every call. The type of the value is computed once per node rather than once per keyword group, and a node whose keywords never need it does not compute it at all.
+- `uniqueItems` on arrays whose item type is not known ahead of time no longer builds a canonicalizing closure and a `Set` on every call. The helpers are hoisted once per compiled function; arrays of twelve items or fewer compare pairwise with a structural equality that ignores key order and allocates nothing, and longer arrays keep the `Set`, using canonical strings only once an object actually appears. Over the draft 7 suite the `uniqueItems` cases went from 125 ns to 24 ns each.
+- `ARCHITECTURE.md` documents the interpreted engine and the closure-tree compiler, and no longer claims `$dynamicRef` falls back to the native engine, which stopped being true in 1.7.1.
+
 ## 1.7.1 - 2026-08-23
 
 ### Added

package/README.md

@@ -64,9 +64,10 @@ passes, and a rejection costs more than a verdict: ata builds an error carrying
 offending value, a documentation link and a suggestion. On a five-field object schema a
 passing payload costs about 17 ns and a rejected one about 155 ns. `abortEarly: true` or
 `isValidObject()` skips that work when only the verdict matters. Schemas ata declines to
-compile, mostly cross-document `$ref`, `$dynamicRef` and `unevaluated*`, run on the
-interpreted engine: about 343 ns for a passing payload on a six-field object schema, eight
-times the compiled path, measured warm on the same machine.
+compile, mostly cross-document `$ref`, `$dynamicRef` and the harder `unevaluated*` shapes,
+run on the interpreted engine. That engine compiles each schema into a tree of closures, so
+on a six-field object schema a passing payload costs about 136 ns against 8 ns for the same
+shape on the compiled path, both measured warm in one run on the same machine.
 
 ## Error messages
 
@@ -560,11 +561,28 @@ npm test
 npm run test:suite
 ```
 
+## Project
+
+- [CONTRIBUTING.md](CONTRIBUTING.md) explains how to build the project and what a
+  pull request needs before it can be merged.
+- [GOVERNANCE.md](GOVERNANCE.md) says who decides what, which changes the project
+  will not accept and why, how releases are cut, and how someone becomes a
+  maintainer. It states the bus factor plainly rather than leaving you to find
+  it out.
+- [SECURITY.md](SECURITY.md) is where vulnerabilities go. Not the issue tracker.
+- [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) applies everywhere the project is
+  discussed.
+
 ## License
 
 MIT
 
-## Authors
+## Contributors
+
+[@mertcanaltin](https://github.com/mertcanaltin) ·
+[@SukeshP1995](https://github.com/SukeshP1995) ·
+[@lemire](https://github.com/lemire) ·
+[@armagandalkiran](https://github.com/armagandalkiran) ·
+[@pnodet](https://github.com/pnodet)
 
-[Mert Can Altin](https://github.com/mertcanaltin)
-[Daniel Lemire](https://github.com/lemire)
+Missing from this list after landing a patch? Send a pull request.

package/index.js

@@ -468,6 +468,23 @@ function _normalizeCallerSchema(s, inheritDraft7) {
   return JSON.stringify(copy) === str ? s : copy
 }
 
+// The identity a document is registered under. Draft-07 ignores every
+// keyword sitting next to `$ref`, so normalization drops them, `$id` among
+// them: that is the right reading for evaluation, where the reference
+// resolves against the retrieval URI rather than the declared `$id`. It is
+// the wrong reading for registration, since `$id` is how the caller names
+// the document. So the identity is read from the normalized copy first and
+// from what the caller passed second. A bare-fragment `$id` is a draft-07
+// anchor rather than a document identity, and normalization has already
+// turned it into `$anchor`, so it is not used here.
+function declaredId(original, normalized) {
+  const n = normalized && typeof normalized === 'object' ? normalized.$id : undefined
+  if (typeof n === 'string' && n !== '') return n
+  const o = original && typeof original === 'object' ? original.$id : undefined
+  if (typeof o === 'string' && o !== '' && o[0] !== '#') return o
+  return undefined
+}
+
 // `inheritDraft7` is true when the root schema is draft-07: a retrieved
 // document that declares no dialect is read under the root's draft.
 function buildSchemaMap(schemas, inheritDraft7) {
@@ -476,7 +493,7 @@ function buildSchemaMap(schemas, inheritDraft7) {
   if (Array.isArray(schemas)) {
     for (const s of schemas) {
       const normalized = _normalizeCallerSchema(s, inheritDraft7)
-      const id = normalized.$id
+      const id = declaredId(s, normalized)
       if (!id) throw new Error('Schema in schemas option must have $id')
       map.set(id, normalized)
     }
@@ -487,7 +504,8 @@ function buildSchemaMap(schemas, inheritDraft7) {
       // under and by the $id it declares. Registering only the $id makes
       // references to the retrieval URI unresolvable.
       map.set(key, normalized)
-      if (normalized.$id && normalized.$id !== key) map.set(normalized.$id, normalized)
+      const id = declaredId(s, normalized)
+      if (id && id !== key) map.set(id, normalized)
     }
   }
   return map

package/lib/interpreter.js

@@ -607,9 +607,10 @@ class Interpreter {
     this._fast = undefined;
   }
 
-  // The closure-tree compiler covers single-resource schemas without
-  // unevaluated keywords; everything else stays on eval(). Compiled lazily so
-  // construction stays cheap for schemas that never validate.
+  // The closure-tree compiler covers every schema the interpreter accepts;
+  // eval() stays as the reference the compiled tree is diffed against.
+  // Compiled lazily so construction stays cheap for schemas that never
+  // validate.
   _fastRoot() {
     if (this._fast === undefined) {
       try { this._fast = compileInterpreter(this); } catch { this._fast = null; }
@@ -690,7 +691,7 @@ class Interpreter {
   // Verdict only: same walk as validate(), no error construction at all.
   isValid(data) {
     const fast = this._fastRoot();
-    if (fast !== null) return fast.v(data, []);
+    if (fast !== null) return fast.v(data, fast.cyclic ? [] : null);
     const dynScope = [this.state.rootBase];
     return this.eval(this.rootNode, data, this.state.rootBase, dynScope, NOERRORS, '', '#', [], DISCARD);
   }
@@ -699,7 +700,7 @@ class Interpreter {
     const fast = this._fastRoot();
     if (fast !== null) {
       const errors = [];
-      const valid = fast.c(data, errors, '', '#', []);
+      const valid = fast.c(data, errors, '', '#', fast.cyclic ? [] : null);
       return valid ? { valid: true, data, errors: [] } : { valid: false, errors };
     }
     const errors = [];
@@ -1080,7 +1081,8 @@ function err(code, keyword, instancePath, schemaPath, params, message) {
 }
 
 const { compileInterpreter } = require('./plan-compiler').install({
-  Plan, NOERRORS, err, evalLeaf, evalLeafV, deepEqual, dataBits, escapePointer,
+  Plan, NOERRORS, err, evalLeaf, evalLeafV, dataBits, escapePointer,
+  deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
   T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri,
 });
 

package/lib/js-compiler.js

@@ -1,5 +1,77 @@
 'use strict'
 
+// uniqueItems helpers for the boolean generator, hoisted once per compiled
+// function (and carried into standalone output through the preamble).
+// _deq is JSON equality: numbers by value, objects by own keys regardless of
+// order, arrays positionally. _uq answers whether every item is distinct.
+// Structural JSON equality, hoisted once per compiled function. `const` and
+// `enum` compare instances by value: two objects with the same members are
+// equal whatever order their keys were written in. Comparing serialized
+// 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;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}"
+
+// uniqueItems helpers for the boolean generator. `_uq` answers whether every
+// item is distinct: short arrays compare pairwise and allocate nothing,
+// longer ones use a Set of primitives and fall back to sorted-key canonical
+// strings only once an object actually appears.
+const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn(x[k])}).join(',')+'}'}" +
+  "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 s=new Set();for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object')break;if(s.has(x))return false;s.add(x)}if(i===n)return true;s=new Set();for(i=0;i<n;i++){var c=_cn(a[i]);if(s.has(c))return false;s.add(c)}return true}"
+
+// Where a generator hoists a declaration so it runs once per compiled
+// function rather than once per call. The boolean generator has a preamble
+// for exactly this; the error and combined generators emit `helperCode` into
+// their function source. The boolean generator's `helperCode` is only
+// scanned for regex entries and must not be used here.
+function hoistOnce(ctx, key, code) {
+  if (ctx[key]) return
+  ctx[key] = true
+  if (ctx.preamble) ctx.preamble.push(code)
+  else if (ctx.helperCode) ctx.helperCode.push(code)
+}
+
+function emitDeq(ctx) {
+  hoistOnce(ctx, '_deqHoisted', DEQ_HELPER)
+  return '_deq'
+}
+
+// `_uq` compares items with `_deq`, so it can never be hoisted alone.
+function emitUq(ctx) {
+  emitDeq(ctx)
+  hoistOnce(ctx, '_uqHoisted', UQ_HELPERS)
+  return '_uq'
+}
+
+// The compared value, parsed once at compile time. `JSON.parse` rather than a
+// JS object literal so a `__proto__` member stays an ordinary property.
+function emitConstant(ctx, value) {
+  if (!ctx._constPool) ctx._constPool = new Map()
+  const json = JSON.stringify(value)
+  let name = ctx._constPool.get(json)
+  if (name === undefined) {
+    name = '_kv' + ctx._constPool.size
+    ctx._constPool.set(json, name)
+    const decl = `const ${name}=JSON.parse(${JSON.stringify(json)})`
+    if (ctx.preamble) ctx.preamble.push(decl)
+    else if (ctx.helperCode) ctx.helperCode.push(decl)
+  }
+  return name
+}
+
+// One `enum` test: primitives compare with `===`, which needs no call, and
+// object members go through structural equality.
+function enumCondition(ctx, vals, v) {
+  const parts = []
+  const prims = vals.filter((x) => x === null || typeof x !== 'object')
+  const objs = vals.filter((x) => x !== null && typeof x === 'object')
+  if (prims.length) parts.push(prims.map((x) => `${v}===${JSON.stringify(x)}`).join('||'))
+  if (objs.length) {
+    const deq = emitDeq(ctx)
+    parts.push(objs.map((o) => `${deq}(${v},${emitConstant(ctx, o)})`).join('||'))
+  }
+  return parts.filter(Boolean).join('||') || 'false'
+}
+
+
 const { codeFor } = require('./error-codes')
 const { compileSafe, patternIsSafe } = require('./safe-regex')
 
@@ -1707,13 +1779,7 @@ function genCode(schema, v, lines, ctx, knownType) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'}))return false`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)}))return false`)
   }
 
   // const
@@ -1722,12 +1788,9 @@ function genCode(schema, v, lines, ctx, knownType) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)})return false`)
     } else {
-      // Key-order independent comparison, defined inline so every emitter
-      // (runtime, hybrid, standalone) carries it.
-      const ci = ctx.varCounter++
-      const canonFn = `_cnB${ci}`
-      const expected = _canonical(cv)
-      lines.push(`{const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};if(${canonFn}(${v})!==${JSON.stringify(expected)})return false}`)
+      // Structural comparison against a value parsed once, so the hot path
+      // neither builds a closure nor serializes the instance.
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)}))return false`)
     }
   }
 
@@ -1882,11 +1945,22 @@ function genCode(schema, v, lines, ctx, knownType) {
     const maxItems = schema.maxItems
     // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
     // No allocation, no hash computation — just direct === comparison
-    const inner = isPrimItems && maxItems && maxItems <= 16
-      ? `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
-      : isPrimItems
-        ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
-        : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+    let inner
+    if (isPrimItems && maxItems && maxItems <= 16) {
+      inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
+    } else if (isPrimItems) {
+      inner = `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
+    } else if (ctx.preamble) {
+      // Unknown item types: one hoisted helper per compiled function. Short
+      // arrays compare pairwise with a structural equality that ignores key
+      // order and allocates nothing; longer ones fall back to a Set of
+      // primitives, or to sorted-key canonical strings once an object shows
+      // up. The previous form built the canonical closure and a Set on
+      // every call, even for [1, 2, 3].
+      inner = `if(!${emitUq(ctx)}(${v}))return false`
+    } else {
+      inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+    }
     lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
   }
 
@@ -3188,13 +3262,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const — use canonical (sorted-key) comparison for objects
@@ -3203,12 +3271,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
-      // Pre-compute canonical form of const value
-      const ci = ctx.varCounter++
-      const canonFn = `_cnE${ci}`
-      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      const expected = canonFn + '(JSON.parse(' + JSON.stringify(JSON.stringify(cv)) + '))'
-      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -3798,13 +3861,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const
@@ -3813,10 +3870,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
-      const ci = ctx.varCounter++
-      const canonFn = `_cn${ci}`
-      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      lines.push(`if(${canonFn}(${v})!==${canonFn}(JSON.parse(${JSON.stringify(JSON.stringify(cv))}))){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }
 

package/lib/native-load.js

@@ -14,7 +14,10 @@
 const VERSION = require('./version');
 
 function nativePackageName(platform, arch, isMusl) {
-  if (platform === 'darwin') return arch === 'arm64' ? '@ata-validator/native-darwin-arm64' : null;
+  if (platform === 'darwin') {
+    if (arch !== 'x64' && arch !== 'arm64') return null;
+    return `@ata-validator/native-darwin-${arch}`;
+  }
   if (platform === 'win32') return arch === 'x64' ? '@ata-validator/native-win32-x64' : null;
   if (platform === 'linux') {
     if (arch !== 'x64' && arch !== 'arm64') return null;