@blackcatinformatics/purrdf 0.3.2 → 0.4.0

package/README.md

@@ -14,6 +14,10 @@ It is the same engine, byte-for-byte behavior, that ships as the `purrdf`
 Rust crates, the `purrdf` PyPI package, and `libpurrdf` — PurRDF's rule is
 **one engine, one behavior, every language**.
 
+> **Try it live** — the [RDF-1.2 playground](https://blackcat-informatics.github.io/purrdf/playground/)
+> runs this package in your browser: parse, SPARQL, SHACL, serialize, and
+> canonicalize/compare RDF-1.2 graphs client-side, with no install.
+
 ## Why this instead of an incumbent RDF/JS library?
 
 No incumbent RDF/JS library carries the RDF 1.2 features:
@@ -73,7 +77,11 @@ const reparsed = Dataset.parse(nq, "nquads");
   `fromTerm`, `fromQuad`.
 - `Dataset` — `Dataset.parse(input, format, base?)`, `serialize(format)`,
   `add` / `delete` / `has` / `match` / `quads` / `size`, iteration.
-  Formats: `turtle`, `ntriples`, `nquads`, `trig`, `rdfxml`.
+  Formats: `turtle`, `ntriples`, `nquads`, `trig`, `rdfxml` (`serialize` also `jsonld`).
+- `Dataset.canonicalize()` / `Dataset.isomorphic(other)` — RDFC-1.0 canonical N-Quads
+  and RDF graph-identity (isomorphism under blank-node relabeling).
+- `shaclValidateToSarif(shapesTtl, dataNt)` / `shaclEntail(shapesTtl, dataNt)` — SHACL
+  validation to a SARIF 2.1.0 report and SHACL-AF `sh:rule` entailment to N-Triples.
 - `Sink`, `datasetToStream`, `streamToDataset` — the async RDF/JS
   Stream/Sink primitives over the synchronous engine surface.
 - SPARQL evaluation over the in-memory dataset (no server required).
@@ -83,8 +91,8 @@ Full typings ship in `index.d.ts`.
 ## Scope
 
 In-memory only, by design: no persistent store and no network I/O inside the
-wasm module. For the container transport (GTS), SHACL validation, SPARQL
-result serializers, and the rest of the toolkit, see the
+wasm module. For the container transport (GTS), SPARQL result serializers, and the
+rest of the toolkit, see the
 [main repository](https://github.com/Blackcat-Informatics/purrdf).
 
 ## Supply chain

package/index.d.ts

@@ -1,12 +1,17 @@
 // SPDX-FileCopyrightText: 2026 Blackcat Informatics® Inc. <paudley@blackcatinformatics.ca>
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-// The wasm-bindgen-generated class declarations (DataFactory/Dataset/Quad/Sink/Term
-// and the free `version()` function) are the source of truth for the engine surface.
+// The wasm-bindgen-generated class declarations (DataFactory/Dataset/Quad/Sink/Term)
+// and the free functions (`version()`, `shaclValidateToSarif`, `shaclEntail`) are the
+// source of truth for the engine surface — the whole `#[wasm_bindgen]` surface is
+// re-exported from the package root (Dataset.canonicalize()/isomorphic() ship on the
+// Dataset class itself).
 export {
   DataFactory,
   Dataset,
   Quad,
+  shaclEntail,
+  shaclValidateToSarif,
   Sink,
   Term,
   version,

package/index.mjs

@@ -3,8 +3,11 @@
 
 // purrdf — the idiomatic RDF/JS surface over the wasm engine.
 //
-// The wasm-bindgen-generated classes (DataFactory/Dataset/Quad/Sink/Term) are
-// re-exported as-is; this wrapper adds the isomorphic glue that the synchronous
+// The wasm-bindgen-generated classes (DataFactory/Dataset/Quad/Sink/Term) and the
+// free functions (version, shaclValidateToSarif, shaclEntail) are re-exported as-is —
+// the whole `#[wasm_bindgen]` surface is reachable from the package root, so
+// SHACL validation/entailment and Dataset.canonicalize()/isomorphic() need no deep
+// `./pkg/` import. This wrapper adds the isomorphic glue that the synchronous
 // wasm boundary cannot express in Rust:
 //   * `ready()` — one-time async wasm instantiation (required for the `web` target).
 //   * the polymorphic RDF/JS `DataFactory.literal(value, languageOrDatatype)` —
@@ -18,6 +21,8 @@ import init, {
   DataFactory,
   Dataset,
   Quad,
+  shaclEntail,
+  shaclValidateToSarif,
   Sink,
   Term,
   version,
@@ -125,4 +130,13 @@ export async function streamToDataset(quadStream) {
   return sink.finish();
 }
 
-export { DataFactory, Dataset, Quad, Sink, Term, version };
+export {
+  DataFactory,
+  Dataset,
+  Quad,
+  shaclEntail,
+  shaclValidateToSarif,
+  Sink,
+  Term,
+  version,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackcatinformatics/purrdf",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "A wasm32, in-memory RDF 1.2 engine with an idiomatic RDF/JS (DataFactory/Dataset/Stream) API. Quoted-triple terms and directional literals included.",
   "type": "module",
   "license": "MIT OR Apache-2.0",

package/pkg/purrdf_wasm.d.ts

@@ -45,6 +45,9 @@ export class DataFactory {
      * `namedNode(value)` → a `NamedNode` term.
      */
     namedNode(value: string): Term;
+    /**
+     * `new DataFactory()` — a fresh factory with its blank-node counter at zero.
+     */
     constructor();
     /**
      * `quad(subject, predicate, object, graph?)` → a `Quad`. The graph defaults to the
@@ -80,6 +83,15 @@ export class Dataset {
      * `add(quad)` → insert a quad. Returns `true` if the effective set changed.
      */
     add(quad: Quad): boolean;
+    /**
+     * `canonicalize()` → the dataset as canonical, flat N-Quads under RDFC-1.0
+     * (SHA-256).
+     *
+     * The deterministic identity string for the graph: two datasets denote the same
+     * RDF graph (under blank-node relabeling) iff their canonical forms are
+     * byte-identical. This is the same RDFC-1.0 output the conformance gate pins.
+     */
+    canonicalize(): string;
     /**
      * `delete(quad)` → remove a quad. Returns `true` if the effective set changed.
      */
@@ -88,6 +100,16 @@ export class Dataset {
      * `has(quad)` → whether the quad is in the dataset.
      */
     has(quad: Quad): boolean;
+    /**
+     * `isomorphic(other)` → whether this dataset and `other` are the same RDF graph
+     * under blank-node relabeling.
+     *
+     * The formal RDF graph-identity check, backed by full RDFC-1.0 canonicalization:
+     * an exact oracle with no false positives or false negatives. Equivalent to
+     * comparing the two [`canonicalize`](Self::canonicalize) strings, but avoids
+     * materializing them for obviously-different inputs.
+     */
+    isomorphic(other: Dataset): boolean;
     /**
      * `match(subject?, predicate?, object?, graph?)` → a new dataset of the matching
      * quads. An omitted (`undefined`) position is a wildcard; `defaultGraph()` matches
@@ -150,9 +172,21 @@ export class Quad {
      * Structural RDF/JS quad equality.
      */
     equals(other: Quad): boolean;
+    /**
+     * The graph [`Term`] of the quad (`DefaultGraph` when unnamed).
+     */
     readonly graph: Term;
+    /**
+     * The object [`Term`] of the quad.
+     */
     readonly object: Term;
+    /**
+     * The predicate [`Term`] of the quad.
+     */
     readonly predicate: Term;
+    /**
+     * The subject [`Term`] of the quad.
+     */
     readonly subject: Term;
     /**
      * Always `"Quad"` (a Quad is itself an RDF/JS term).
@@ -176,6 +210,9 @@ export class Sink {
      * resulting dataset. The sink is consumed; further `push`/`finish` is an error.
      */
     finish(): Dataset;
+    /**
+     * `new Sink()` — an empty sink ready to accept quads via `push`.
+     */
     constructor();
     /**
      * `push(quad)` — stream one quad into the sink (interned via the event protocol).
@@ -284,8 +321,10 @@ export interface InitOutput {
     readonly datafactory_typedLiteral: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly datafactory_variable: (a: number, b: number, c: number) => number;
     readonly dataset_add: (a: number, b: number, c: number) => void;
+    readonly dataset_canonicalize: (a: number, b: number) => void;
     readonly dataset_delete: (a: number, b: number, c: number) => void;
     readonly dataset_has: (a: number, b: number, c: number) => void;
+    readonly dataset_isomorphic: (a: number, b: number, c: number) => void;
     readonly dataset_match: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly dataset_new: (a: number) => void;
     readonly dataset_parse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;

package/pkg/purrdf_wasm.js

@@ -116,6 +116,9 @@ export class DataFactory {
         const ret = wasm.datafactory_namedNode(this.__wbg_ptr, ptr0, len0);
         return Term.__wrap(ret);
     }
+    /**
+     * `new DataFactory()` — a fresh factory with its blank-node counter at zero.
+     */
     constructor() {
         const ret = wasm.datafactory_new();
         this.__wbg_ptr = ret;
@@ -252,6 +255,39 @@ export class Dataset {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `canonicalize()` → the dataset as canonical, flat N-Quads under RDFC-1.0
+     * (SHA-256).
+     *
+     * The deterministic identity string for the graph: two datasets denote the same
+     * RDF graph (under blank-node relabeling) iff their canonical forms are
+     * byte-identical. This is the same RDFC-1.0 output the conformance gate pins.
+     * @returns {string}
+     */
+    canonicalize() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dataset_canonicalize(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * `delete(quad)` → remove a quad. Returns `true` if the effective set changed.
      * @param {Quad} quad
@@ -294,6 +330,33 @@ export class Dataset {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `isomorphic(other)` → whether this dataset and `other` are the same RDF graph
+     * under blank-node relabeling.
+     *
+     * The formal RDF graph-identity check, backed by full RDFC-1.0 canonicalization:
+     * an exact oracle with no false positives or false negatives. Equivalent to
+     * comparing the two [`canonicalize`](Self::canonicalize) strings, but avoids
+     * materializing them for obviously-different inputs.
+     * @param {Dataset} other
+     * @returns {boolean}
+     */
+    isomorphic(other) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(other, Dataset);
+            wasm.dataset_isomorphic(retptr, this.__wbg_ptr, other.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * `match(subject?, predicate?, object?, graph?)` → a new dataset of the matching
      * quads. An omitted (`undefined`) position is a wildcard; `defaultGraph()` matches
@@ -550,6 +613,7 @@ export class Quad {
         return ret !== 0;
     }
     /**
+     * The graph [`Term`] of the quad (`DefaultGraph` when unnamed).
      * @returns {Term}
      */
     get graph() {
@@ -557,6 +621,7 @@ export class Quad {
         return Term.__wrap(ret);
     }
     /**
+     * The object [`Term`] of the quad.
      * @returns {Term}
      */
     get object() {
@@ -564,6 +629,7 @@ export class Quad {
         return Term.__wrap(ret);
     }
     /**
+     * The predicate [`Term`] of the quad.
      * @returns {Term}
      */
     get predicate() {
@@ -571,6 +637,7 @@ export class Quad {
         return Term.__wrap(ret);
     }
     /**
+     * The subject [`Term`] of the quad.
      * @returns {Term}
      */
     get subject() {
@@ -655,6 +722,9 @@ export class Sink {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `new Sink()` — an empty sink ready to accept quads via `push`.
+     */
     constructor() {
         const ret = wasm.sink_new();
         this.__wbg_ptr = ret;

package/pkg/purrdf_wasm_bg.wasm.d.ts

@@ -19,8 +19,10 @@ export const datafactory_quotedTriple: (a: number, b: number, c: number, d: numb
 export const datafactory_typedLiteral: (a: number, b: number, c: number, d: number, e: number) => void;
 export const datafactory_variable: (a: number, b: number, c: number) => number;
 export const dataset_add: (a: number, b: number, c: number) => void;
+export const dataset_canonicalize: (a: number, b: number) => void;
 export const dataset_delete: (a: number, b: number, c: number) => void;
 export const dataset_has: (a: number, b: number, c: number) => void;
+export const dataset_isomorphic: (a: number, b: number, c: number) => void;
 export const dataset_match: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const dataset_new: (a: number) => void;
 export const dataset_parse: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;