@nuggetslife/vc 0.0.30 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuggetslife/vc",
-  "version": "0.0.30",
+  "version": "0.1.0",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
@@ -41,11 +41,11 @@
   },
   "packageManager": "yarn@4.3.1",
   "optionalDependencies": {
-    "@nuggetslife/vc-darwin-arm64": "0.0.30",
-    "@nuggetslife/vc-linux-arm64-gnu": "0.0.30",
-    "@nuggetslife/vc-linux-arm64-musl": "0.0.30",
-    "@nuggetslife/vc-linux-x64-gnu": "0.0.30",
-    "@nuggetslife/vc-linux-x64-musl": "0.0.30"
+    "@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

@@ -12,6 +12,9 @@ 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
 
@@ -25,4 +28,9 @@ if [ ! -d rdf-canon ]; then
 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));
 });
 
 

package/test_w3c_conformance.mjs

@@ -32,6 +32,7 @@ const updateBaseline = flag('--update');
 
 const TESTS_ROOT = resolve(__dirname, 'tmp-w3c-tests');
 const JLD_TESTS = join(TESTS_ROOT, 'json-ld-api', 'tests');
+const JLD_FRAMING_TESTS = join(TESTS_ROOT, 'json-ld-framing', 'tests');
 const RDFC_TESTS = join(TESTS_ROOT, 'rdf-canon', 'tests');
 const JLD_BASE = 'https://w3c.github.io/json-ld-api/tests/';
 const BASELINE_PATH = join(__dirname, 'w3c-baseline.json');
@@ -70,6 +71,7 @@ function preloadJldContexts() {
         }
     }
     walk(JLD_TESTS, '');
+    if (existsSync(JLD_FRAMING_TESTS)) walk(JLD_FRAMING_TESTS, '');
     return ctxs;
 }
 
@@ -84,6 +86,25 @@ const normNQuads = (s) => typeof s === 'string'
     ? s.split('\n').map(l => l.trim()).filter(Boolean).sort().join('\n')
     : s;
 
+// W3C toRdf expected fixtures contain post-URDNA2015 blank-node labels
+// (e.g. `_:c14n0`), but the spec itself defines toRdf as producing
+// pre-canonical labels (e.g. `_:b0`). jsonld.js exhibits the same
+// pre-canonical output. To compare semantically we run URDNA2015 on both
+// sides before string-matching. Falls back to normNQuads if either side
+// can't be canonicalized (so a bug in the processor still surfaces).
+const canonProc = new JsonLd();
+async function nquadsEqual(got, expected) {
+    if (typeof got !== 'string' || typeof expected !== 'string') return false;
+    try {
+        const opts = { algorithm: 'URDNA2015', inputFormat: 'application/n-quads', format: 'application/n-quads' };
+        const a = await canonProc.canonize(got, opts);
+        const b = await canonProc.canonize(expected, opts);
+        return a === b;
+    } catch {
+        return normNQuads(got) === normNQuads(expected);
+    }
+}
+
 const DENYLIST_PATH = join(__dirname, 'w3c-denylist.json');
 let DENYLIST = {};
 if (existsSync(DENYLIST_PATH)) {
@@ -144,10 +165,18 @@ async function runJld(algo, methodName) {
         const opt = entry.option || {};
         const callOpts = { base: opt.base || inputUrl };
         if (opt.processingMode) callOpts.processingMode = opt.processingMode;
+        else if (opt.specVersion) callOpts.processingMode = opt.specVersion;
         if (opt.expandContext) {
             const ctxUrl = JLD_BASE + opt.expandContext;
             callOpts.expandContext = contexts[ctxUrl] || ctxUrl;
         }
+        // toRdf-specific options from W3C test entries
+        if (opt.rdfDirection) callOpts.rdfDirection = opt.rdfDirection;
+        if (opt.produceGeneralizedRdf != null) callOpts.produceGeneralizedRdf = opt.produceGeneralizedRdf;
+        if (opt.compactArrays != null) callOpts.compactArrays = opt.compactArrays;
+        // fromRDF-specific options
+        if (opt.useNativeTypes != null) callOpts.useNativeTypes = opt.useNativeTypes;
+        if (opt.useRdfType != null) callOpts.useRdfType = opt.useRdfType;
 
         try {
             const input = methodName === 'fromRDF' ? loadText(inputPath) : loadJson(inputPath);
@@ -172,7 +201,7 @@ async function runJld(algo, methodName) {
             const expected = methodName === 'toRDF' ? loadText(expectPath) : loadJson(expectPath);
 
             const ok = methodName === 'toRDF'
-                ? normNQuads(napiResult) === normNQuads(expected)
+                ? await nquadsEqual(napiResult, expected)
                 : jsonEqual(napiResult, expected);
             record(algo, id, ok ? 'pass' : 'fail');
         } catch (e) {
@@ -229,20 +258,64 @@ async function runOnce(algo) {
     else if (algo === 'flatten') await runJld('flatten', 'flatten');
     else if (algo === 'toRdf') await runJld('toRdf', 'toRDF');
     else if (algo === 'fromRdf') await runJld('fromRdf', 'fromRDF');
+    else if (algo === 'frame') await runFraming();
 }
 
+async function runFraming() {
+    const manifestPath = join(JLD_FRAMING_TESTS, 'frame-manifest.jsonld');
+    if (!existsSync(manifestPath)) return;
+    const manifest = loadJson(manifestPath);
+    const contexts = preloadJldContexts();
+    const proc = new JsonLd({ contexts });
+    let seen = 0;
+    for (const entry of manifest.sequence) {
+        const types = Array.isArray(entry['@type']) ? entry['@type'] : [entry['@type']];
+        if (!types.includes('jld:PositiveEvaluationTest') && !types.includes('jld:NegativeEvaluationTest')) continue;
+        const id = entry['@id'];
+        if (isDenied('frame', id)) continue;
+        if (!isInCheckScope('frame', id)) continue;
+        seen += 1;
+        if (seen % PROGRESS_EVERY === 0) process.stderr.write(`  frame: ${seen} tests processed\n`);
+        if (!entry.input || !entry.frame) { record('frame', id, 'err'); continue; }
+        const inputPath = join(JLD_FRAMING_TESTS, entry.input);
+        const framePath = join(JLD_FRAMING_TESTS, entry.frame);
+        const expectPath = entry.expect ? join(JLD_FRAMING_TESTS, entry.expect) : null;
+        if (!existsSync(inputPath) || !existsSync(framePath)) { record('frame', id, 'err'); continue; }
+        const opt = entry.option || {};
+        const inputUrl = 'https://w3c.github.io/json-ld-framing/tests/' + entry.input;
+        const callOpts = { base: opt.base || inputUrl };
+        if (opt.processingMode) callOpts.processingMode = opt.processingMode;
+        else if (opt.specVersion) callOpts.processingMode = opt.specVersion;
+        if (opt.omitGraph != null) callOpts.omitGraph = opt.omitGraph;
+        if (opt.requireAll != null) callOpts.requireAll = opt.requireAll;
+        try {
+            const input = loadJson(inputPath);
+            const frame = loadJson(framePath);
+            const napiResult = await withTimeout(proc.frame(input, frame, callOpts), id);
+            if (!expectPath || !existsSync(expectPath)) { record('frame', id, 'err'); continue; }
+            const expected = loadJson(expectPath);
+            record('frame', id, jsonEqual(napiResult, expected) ? 'pass' : 'fail');
+        } catch (e) {
+            const isTimeout = e && /^timeout:/.test(e.message || '');
+            record('frame', id, isTimeout ? 'err' : 'err');
+        }
+    }
+}
+
+
 async function main() {
     if (!existsSync(JLD_TESTS) || !existsSync(RDFC_TESTS)) {
         console.error('W3C test suites not found at ' + TESTS_ROOT);
         console.error('Run: vc/js/scripts/fetch-w3c-tests.sh');
         process.exit(2);
     }
-    // flatten and toRdf are not in the default run because clientffi has
-    // Rust-level deadlocks in those algos. Pass --only flatten or --only toRdf
-    // to opt in when investigating. They'll move into the default list once
-    // their hangs are fixed.
-    const algos = ['canonize', 'fromRdf', 'expand', 'compact'];
-    const allAlgos = ['expand', 'compact', 'flatten', 'toRdf', 'fromRdf', 'canonize'];
+    // flatten and toRdf are gated by V2: the v1 path has Rust-level deadlocks
+    // (sync block_on bridging into tokio::sync locks in the document loader and
+    // node_map). The v2 path (jsonld_v2::flatten_v2 / to_nquads_v2) uses a
+    // pre-resolved HashMap loader with no tokio sync primitives and runs the
+    // suite without hangs, so it is included in the default list.
+    const algos = ['canonize', 'fromRdf', 'expand', 'compact', 'flatten', 'toRdf', 'frame'];
+    const allAlgos = ['expand', 'compact', 'flatten', 'toRdf', 'fromRdf', 'canonize', 'frame'];
     if (onlyArg && !allAlgos.includes(onlyArg)) {
         console.error(`Invalid --only value: ${onlyArg}. Expected one of: ${allAlgos.join(', ')}`);
         process.exit(2);