@nuggetslife/vc 0.0.29 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuggetslife/vc",
-  "version": "0.0.29",
+  "version": "0.1.0",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
@@ -34,15 +34,18 @@
     "prepublishOnly": "napi prepublish -t npm",
     "test": "node test.mjs && node test_jose.mjs && node test_sd_jwt.mjs && node test_bbs_ietf.mjs && node test_bbs_2023.mjs && node test_jsonld_crossverify.mjs && node test_backward_compat.mjs",
     "universal": "napi universal",
-    "version": "napi version"
+    "version": "napi version",
+    "test:w3c": "node test_w3c_conformance.mjs --check",
+    "test:w3c:update": "node test_w3c_conformance.mjs --update",
+    "fetch:w3c-tests": "bash scripts/fetch-w3c-tests.sh"
   },
   "packageManager": "yarn@4.3.1",
   "optionalDependencies": {
-    "@nuggetslife/vc-darwin-arm64": "0.0.29",
-    "@nuggetslife/vc-linux-arm64-gnu": "0.0.29",
-    "@nuggetslife/vc-linux-arm64-musl": "0.0.29",
-    "@nuggetslife/vc-linux-x64-gnu": "0.0.29",
-    "@nuggetslife/vc-linux-x64-musl": "0.0.29"
+    "@nuggetslife/vc-darwin-arm64": "0.1.0",
+    "@nuggetslife/vc-linux-arm64-gnu": "0.1.0",
+    "@nuggetslife/vc-linux-arm64-musl": "0.1.0",
+    "@nuggetslife/vc-linux-x64-gnu": "0.1.0",
+    "@nuggetslife/vc-linux-x64-musl": "0.1.0"
   },
   "dependencies": {}
 }

package/scripts/fetch-w3c-tests.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Clone the W3C JSON-LD 1.1 API and RDF Dataset Canonicalization test suites
+# into vc/js/tmp-w3c-tests/. Pinned to specific commits for reproducibility.
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+JLD_API_REPO="https://github.com/w3c/json-ld-api.git"
+JLD_API_SHA="04a4eb7dc7cbc313f3f5be7ad9a3b06e87741693"
+
+RDF_CANON_REPO="https://github.com/w3c/rdf-canon.git"
+RDF_CANON_SHA="15619df2fda7a4ca88308733789b6774517f9638"
+
+JLD_FRAMING_REPO="https://github.com/w3c/json-ld-framing.git"
+JLD_FRAMING_SHA="fa228743e890499c35bc61aabf01e44cf5bbc3bc"
+
+mkdir -p tmp-w3c-tests
+cd tmp-w3c-tests
+
+if [ ! -d json-ld-api ]; then
+    git clone --filter=blob:none "$JLD_API_REPO"
+fi
+(cd json-ld-api && git fetch --depth=1 origin "$JLD_API_SHA" && git checkout --detach "$JLD_API_SHA")
+
+if [ ! -d rdf-canon ]; then
+    git clone --filter=blob:none "$RDF_CANON_REPO"
+fi
+(cd rdf-canon && git fetch --depth=1 origin "$RDF_CANON_SHA" && git checkout --detach "$RDF_CANON_SHA")
+
+if [ ! -d json-ld-framing ]; then
+    git clone --filter=blob:none "$JLD_FRAMING_REPO"
+fi
+(cd json-ld-framing && git fetch --depth=1 origin "$JLD_FRAMING_SHA" && git checkout --detach "$JLD_FRAMING_SHA")
+
+echo "W3C suites fetched at pinned SHAs."

package/src/jsonld.rs

@@ -1,12 +1,13 @@
 use serde_json::{json, Value};
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use vc::{
-    document_loader::nuggets::DocumentLoader,
-    jsonld::{self, context_resolver::ContextResolver},
+  document_loader::nuggets::DocumentLoader,
+  jsonld::{self, context_resolver::ContextResolver},
 };
 
-use crate::ld_signatures::loader_from_contexts;
+use crate::ld_signatures::create_document_loader;
 
 /// JSON-LD processor — drop-in replacement for the jsonld.js API.
 ///
@@ -20,159 +21,228 @@ use crate::ld_signatures::loader_from_contexts;
 /// ```
 #[napi]
 pub struct JsonLd {
-    loader: Arc<DocumentLoader>,
-    cr: Arc<ContextResolver>,
+  loader: Arc<DocumentLoader>,
+  cr: Arc<ContextResolver>,
+  additional_contexts: Arc<HashMap<String, Value>>,
+}
+
+impl JsonLd {
+  fn additional_contexts(&self) -> Arc<HashMap<String, Value>> {
+    Arc::clone(&self.additional_contexts)
+  }
 }
 
 #[napi]
 impl JsonLd {
-    /// Create a new JSON-LD processor.
-    ///
-    /// Accepts optional `{ contexts?: Record<string, any> }` to register
-    /// additional URL → document mappings in the document loader (on top
-    /// of the built-in nuggets contexts).
-    #[napi(constructor)]
-    pub fn new(options: Option<Value>) -> Self {
-        let contexts = options.as_ref().and_then(|o| o.get("contexts"));
-        let (loader, cr) = loader_from_contexts(contexts);
-        Self { loader, cr }
+  /// Create a new JSON-LD processor.
+  ///
+  /// Accepts optional `{ contexts?: Record<string, any> }` to register
+  /// additional URL → document mappings in the document loader (on top
+  /// of the built-in nuggets contexts).
+  #[napi(constructor)]
+  pub fn new(options: Option<Value>) -> Self {
+    let additional_contexts: HashMap<String, Value> = options
+      .as_ref()
+      .and_then(|o| o.get("contexts"))
+      .and_then(|v| v.as_object())
+      .map(|obj| obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
+      .unwrap_or_default();
+    let (loader, cr) = create_document_loader(additional_contexts.clone());
+    Self {
+      loader,
+      cr,
+      additional_contexts: Arc::new(additional_contexts),
     }
+  }
 
-    /// Expand a JSON-LD document.
-    ///
-    /// `options` can include: `base`, `expandContext`, `keepFreeFloatingNodes`,
-    /// `processingMode`.
-    ///
-    /// Returns an array of expanded JSON-LD objects.
-    #[napi]
-    pub async fn expand(
-        &self,
-        input: Value,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        jsonld::expand(input, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("expand failed: {e}")))
+  /// Expand a JSON-LD document.
+  ///
+  /// `options` can include: `base`, `expandContext`, `keepFreeFloatingNodes`,
+  /// `processingMode`.
+  ///
+  /// Returns an array of expanded JSON-LD objects.
+  #[napi]
+  pub async fn expand(&self, input: Value, options: Option<Value>) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    if vc::jsonld_v2::use_v2() {
+      let additional = self.additional_contexts();
+      vc::jsonld_v2::expand_v2_sync(input, &additional, opts)
+        .map_err(|e| napi::Error::from_reason(format!("expand (v2) failed: {e}")))
+    } else {
+      jsonld::expand(input, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("expand failed: {e}")))
     }
+  }
 
-    /// Compact a JSON-LD document using a context.
-    ///
-    /// `ctx` — the compaction context (object, array, or string URL).
-    /// `options` can include: `base`, `compactArrays`, `graph`,
-    /// `skipExpansion`, `processingMode`.
-    ///
-    /// Returns the compacted JSON-LD object.
-    #[napi]
-    pub async fn compact(
-        &self,
-        input: Value,
-        ctx: Value,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        jsonld::compact_api(input, ctx, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("compact failed: {e}")))
+  /// Compact a JSON-LD document using a context.
+  ///
+  /// `ctx` — the compaction context (object, array, or string URL).
+  /// `options` can include: `base`, `compactArrays`, `graph`,
+  /// `skipExpansion`, `processingMode`.
+  ///
+  /// Returns the compacted JSON-LD object.
+  #[napi]
+  pub async fn compact(
+    &self,
+    input: Value,
+    ctx: Value,
+    options: Option<Value>,
+  ) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    if vc::jsonld_v2::use_v2() {
+      let additional = self.additional_contexts();
+      vc::jsonld_v2::compact_v2_sync(input, ctx, &additional, opts)
+        .map_err(|e| napi::Error::from_reason(format!("compact (v2) failed: {e}")))
+    } else {
+      jsonld::compact_api(input, ctx, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("compact failed: {e}")))
     }
+  }
 
-    /// Flatten a JSON-LD document.
-    ///
-    /// `ctx` — optional context for compacting the flattened result.
-    ///   Pass `null` to get the flattened expanded form.
-    /// `options` can include: `base`, `expandContext`, `processingMode`.
-    ///
-    /// Returns flattened array (no context) or compacted object (with context).
-    #[napi]
-    pub async fn flatten(
-        &self,
-        input: Value,
-        ctx: Option<Value>,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        // Filter out null ctx (JS passes null, Rust expects None)
-        let ctx = ctx.filter(|v| !v.is_null());
-        jsonld::flatten(input, ctx, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("flatten failed: {e}")))
+  /// Flatten a JSON-LD document.
+  ///
+  /// `ctx` — optional context for compacting the flattened result.
+  ///   Pass `null` to get the flattened expanded form.
+  /// `options` can include: `base`, `expandContext`, `processingMode`.
+  ///
+  /// Returns flattened array (no context) or compacted object (with context).
+  #[napi]
+  pub async fn flatten(
+    &self,
+    input: Value,
+    ctx: Option<Value>,
+    options: Option<Value>,
+  ) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    // Filter out null ctx (JS passes null, Rust expects None)
+    let ctx = ctx.filter(|v| !v.is_null());
+    if vc::jsonld_v2::use_v2() {
+      let additional = self.additional_contexts();
+      vc::jsonld_v2::flatten_v2_sync(input, ctx, &additional, opts)
+        .map_err(|e| napi::Error::from_reason(format!("flatten (v2) failed: {e}")))
+    } else {
+      jsonld::flatten(input, ctx, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("flatten failed: {e}")))
     }
+  }
 
-    /// Frame a JSON-LD document.
-    ///
-    /// `frame` — the framing template.
-    /// `options` can include: `base`, `embed`, `explicit`, `requireAll`,
-    /// `omitDefault`, `omitGraph`, `processingMode`.
-    ///
-    /// Returns the framed JSON-LD object.
-    #[napi]
-    pub async fn frame(
-        &self,
-        input: Value,
-        frame: Value,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        jsonld::frame(input, frame, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("frame failed: {e}")))
+  /// Frame a JSON-LD document.
+  ///
+  /// `frame` — the framing template.
+  /// `options` can include: `base`, `embed`, `explicit`, `requireAll`,
+  /// `omitDefault`, `omitGraph`, `processingMode`.
+  ///
+  /// Returns the framed JSON-LD object.
+  #[napi]
+  pub async fn frame(
+    &self,
+    input: Value,
+    frame: Value,
+    options: Option<Value>,
+  ) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    if vc::jsonld_v2::use_v2() {
+      // Sprint 3 Phase D cutover: V2 frame is always the native typed-tree
+      // walker. CLIENTFFI_FRAME_NATIVE / CLIENTFFI_FRAME_FAST flags are no
+      // longer consulted — frame_v2 / frame_v2_fast public APIs were
+      // retired in this commit.
+      let loader = self.loader.clone();
+      let cr = self.cr.clone();
+      let join = tokio::task::spawn_blocking(move || {
+        vc::jsonld_v2::frame_native_sync(input, frame, loader, cr, opts)
+          .map_err(|e| napi::Error::from_reason(format!("frame (native) failed: {e}")))
+      });
+      join
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("frame (v2) join: {e}")))?
+    } else {
+      jsonld::frame(input, frame, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("frame failed: {e}")))
     }
+  }
 
-    /// Convert a JSON-LD document to an RDF dataset.
-    ///
-    /// `options` can include: `base`, `expandContext`, `skipExpansion`,
-    /// `format` (`"application/n-quads"` for string output), `processingMode`.
-    ///
-    /// Returns an array of quads or an N-Quads string (depending on `format`).
-    #[napi(js_name = "toRDF")]
-    pub async fn to_rdf(
-        &self,
-        input: Value,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        jsonld::to_rdf(input, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("toRDF failed: {e}")))
+  /// Convert a JSON-LD document to an RDF dataset.
+  ///
+  /// `options` can include: `base`, `expandContext`, `skipExpansion`,
+  /// `format` (`"application/n-quads"` for string output), `processingMode`.
+  ///
+  /// Returns an array of quads or an N-Quads string (depending on `format`).
+  #[napi(js_name = "toRDF")]
+  pub async fn to_rdf(&self, input: Value, options: Option<Value>) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    // v2 only produces N-Quads string output. If caller expects
+    // a quads-array (default when format is omitted), fall back to v1.
+    let wants_nquads = opts
+      .get("format")
+      .and_then(|v| v.as_str())
+      .map(|s| s == "application/n-quads")
+      .unwrap_or(false);
+    if vc::jsonld_v2::use_v2() && wants_nquads {
+      let additional = self.additional_contexts();
+      let nquads = vc::jsonld_v2::to_nquads_v2_sync(input, &additional, opts)
+        .map_err(|e| napi::Error::from_reason(format!("toRDF (v2) failed: {e}")))?;
+      Ok(Value::String(nquads))
+    } else {
+      jsonld::to_rdf(input, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("toRDF failed: {e}")))
     }
+  }
 
-    /// Convert an RDF dataset to a JSON-LD document.
-    ///
-    /// `dataset` — N-Quads string or array of quads.
-    /// `options` can include: `useRdfType`, `useNativeTypes`, `rdfDirection`.
-    ///
-    /// Returns an array of JSON-LD objects.
-    #[napi(js_name = "fromRDF")]
-    pub fn from_rdf(&self, dataset: Value, options: Option<Value>) -> napi::Result<Value> {
-        let opts = options.unwrap_or(json!({}));
-        jsonld::from_rdf_api(dataset, opts)
-            .map_err(|e| napi::Error::from_reason(format!("fromRDF failed: {e}")))
-    }
+  /// Convert an RDF dataset to a JSON-LD document.
+  ///
+  /// `dataset` — N-Quads string or array of quads.
+  /// `options` can include: `useRdfType`, `useNativeTypes`, `rdfDirection`.
+  ///
+  /// Returns an array of JSON-LD objects.
+  #[napi(js_name = "fromRDF")]
+  pub fn from_rdf(&self, dataset: Value, options: Option<Value>) -> napi::Result<Value> {
+    let opts = options.unwrap_or(json!({}));
+    jsonld::from_rdf_api(dataset, opts)
+      .map_err(|e| napi::Error::from_reason(format!("fromRDF failed: {e}")))
+  }
 
-    /// Canonize (normalize) a JSON-LD document.
-    ///
-    /// `options` can include: `base`, `expandContext`, `skipExpansion`,
-    /// `inputFormat` (`"application/n-quads"`), `format`, `algorithm`,
-    /// `processingMode`.
-    ///
-    /// Returns the canonical N-Quads string.
-    #[napi]
-    pub async fn canonize(
-        &self,
-        input: Value,
-        options: Option<Value>,
-    ) -> napi::Result<Value> {
-        let mut opts = options.unwrap_or(json!({}));
-        // Defaults matching JS jsonld.js canonize()
-        if opts.get("algorithm").is_none() {
-            opts["algorithm"] = json!("RDFC-1.0");
-        }
-        if opts.get("format").is_none() {
-            opts["format"] = json!("application/n-quads");
-        }
-        let result = jsonld::canonize(input, self.loader.clone(), self.cr.clone(), opts)
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("canonize failed: {e}")))?;
-        Ok(Value::String(result))
+  /// Canonize (normalize) a JSON-LD document.
+  ///
+  /// `options` can include: `base`, `expandContext`, `skipExpansion`,
+  /// `inputFormat` (`"application/n-quads"`), `format`, `algorithm`,
+  /// `processingMode`.
+  ///
+  /// Returns the canonical N-Quads string.
+  #[napi]
+  pub async fn canonize(&self, input: Value, options: Option<Value>) -> napi::Result<Value> {
+    let mut opts = options.unwrap_or(json!({}));
+    // Defaults matching JS jsonld.js canonize()
+    if opts.get("algorithm").is_none() {
+      opts["algorithm"] = json!("RDFC-1.0");
+    }
+    if opts.get("format").is_none() {
+      opts["format"] = json!("application/n-quads");
     }
+    let input_is_nquads = opts
+      .get("inputFormat")
+      .and_then(|v| v.as_str())
+      .map(|s| s == "application/n-quads")
+      .unwrap_or(false);
+    let result = if vc::jsonld_v2::use_v2() && !input_is_nquads {
+      let additional = self.additional_contexts();
+      vc::jsonld_v2::canonize_v2_sync(
+        input,
+        &additional,
+        self.loader.clone(),
+        self.cr.clone(),
+        opts,
+      )
+      .map_err(|e| napi::Error::from_reason(format!("canonize (v2) failed: {e}")))?
+    } else {
+      jsonld::canonize(input, self.loader.clone(), self.cr.clone(), opts)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("canonize failed: {e}")))?
+    };
+    Ok(Value::String(result))
+  }
 }

package/test_jsonld_crossverify.mjs

@@ -135,7 +135,10 @@ test('cross-verify: flatten(inputDocument, null) matches JS reference', async ()
     const napiResult = await proc.flatten(inputDocument, null);
     const jsResult = await jsonld.flatten(inputDocument, null, { documentLoader });
 
-    assert.deepStrictEqual(napiResult, jsResult);
+    // Flatten without compaction returns an unordered set of node objects
+    // (each keyed by @id). Sort by @id before comparing.
+    const sortById = arr => [...arr].sort((a, b) => String(a['@id'] || '').localeCompare(String(b['@id'] || '')));
+    assert.deepStrictEqual(sortById(napiResult), sortById(jsResult));
 });
 
 
@@ -171,7 +174,10 @@ test('cross-verify: toRDF(inputDocument, n-quads) matches JS reference', async (
     const napiResult = await proc.toRDF(inputDocument, { format: 'application/n-quads' });
     const jsResult = await jsonld.toRDF(inputDocument, { documentLoader, format: 'application/n-quads' });
 
-    assert.strictEqual(napiResult, jsResult);
+    // toRDF triple order is implementation-defined (RDFC-1.0 normalises it later).
+    // Compare as a set: split into lines, drop empties, sort.
+    const norm = s => s.split('\n').filter(l => l.length).sort().join('\n');
+    assert.strictEqual(norm(napiResult), norm(jsResult));
 });
 
 
@@ -328,3 +334,105 @@ test('cross-verify: canonize preserves nested typed objects without @id', async
 
     assert.strictEqual(napiResult, jsResult);
 });
+
+//
+// Regression: terms with @type: "@json" must produce JSON literal quads
+// (parity with jsonld@3.1.0 / jsonld@8.3.3 — the libs that sign Nuggets VCs)
+//
+
+test('cross-verify: expand emits JSON literal for term with @type: @json (flat context)', async () => {
+    const doc = {
+        '@context': {
+            '@version': 1.1,
+            inner: { '@id': 'https://example.com/inner', '@type': '@json' }
+        },
+        inner: { hello: 'world' }
+    };
+
+    const proc = new JsonLd();
+    const napiResult = await proc.expand(doc);
+    const jsResult = await jsonld.expand(doc);
+
+    assert.deepStrictEqual(napiResult, jsResult);
+});
+
+test('cross-verify: expand emits JSON literal for term with @type: @json (term-scoped context)', async () => {
+    // Mirrors the KYB v1 shape where `dnbData` is defined inside `result`'s
+    // term-scoped context. See packages/document-loader/context/kybV1.json.
+    const doc = {
+        '@context': {
+            '@version': 1.1,
+            outer: {
+                '@id': 'https://example.com/outer',
+                '@context': {
+                    '@version': 1.1,
+                    inner: { '@id': 'https://example.com/inner', '@type': '@json' }
+                }
+            }
+        },
+        outer: { inner: { organization: { primaryName: 'Acme' } } }
+    };
+
+    const proc = new JsonLd();
+    const napiResult = await proc.expand(doc);
+    const jsResult = await jsonld.expand(doc);
+
+    assert.deepStrictEqual(napiResult, jsResult);
+});
+
+test('cross-verify: canonize emits JSON literal quad for term with @type: @json', async () => {
+    const doc = {
+        '@context': {
+            '@version': 1.1,
+            inner: { '@id': 'https://example.com/inner', '@type': '@json' }
+        },
+        inner: { b: 2, a: 1 }
+    };
+
+    const proc = new JsonLd();
+    const napiResult = await proc.canonize(doc);
+    const jsResult = await jsonld.canonize(doc, {
+        algorithm: 'URDNA2015',
+        format: 'application/n-quads',
+        safe: false,
+    });
+
+    assert.strictEqual(napiResult, jsResult);
+});
+
+//
+// Regression: blank-node objects (no @id) in arrays must each produce a
+// distinct quad. Earlier `add_value` deduped equal serde Values, collapsing
+// `[{}, {}, {}]` to a single blank node and silently shrinking signed
+// message sets — breaking any BBS+ proof over arrays that contain repeats.
+//
+
+test('cross-verify: array of empty objects keeps each blank node distinct', async () => {
+    const doc = {
+        '@context': { items: { '@id': 'https://example.com/items' } },
+        items: [{}, {}, {}]
+    };
+
+    const proc = new JsonLd();
+    const napiResult = await proc.expand(doc);
+    const jsResult = await jsonld.expand(doc);
+
+    assert.deepStrictEqual(napiResult, jsResult);
+});
+
+test('cross-verify: toRDF with array of empty objects emits one quad per element', async () => {
+    const doc = {
+        '@context': { items: { '@id': 'https://example.com/items' } },
+        items: [{}, {}, 'a', {}]
+    };
+
+    const proc = new JsonLd();
+    const napiNquads = await proc.toRDF(doc, { format: 'application/n-quads' });
+    const jsNquads = await jsonld.toRDF(doc, { format: 'application/n-quads' });
+
+    const napiCount = napiNquads.split('\n').filter(Boolean).length;
+    const jsCount = jsNquads.split('\n').filter(Boolean).length;
+
+    assert.strictEqual(napiCount, jsCount,
+        `expected ${jsCount} quads (one per array element), got ${napiCount}`);
+});