rete-graph 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! rete-graph v0.1.0 | Apache-2.0 | https://github.com/caviri/rete */
+/*! rete-graph v0.3.0 | Apache-2.0 | https://github.com/caviri/rete */
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -41,13 +41,64 @@ var init_node_sync_xhr = __esm({
   "src/node-sync-xhr.js"() {
     WORKER_SRC = `
 const { parentPort } = require("node:worker_threads");
+const fs = require("node:fs");
+const { fileURLToPath } = require("node:url");
+
+// One open descriptor per file, reused across the many small range reads a
+// query makes (reopening per read would dominate the cost).
+const fds = new Map();
+const fdFor = (path) => {
+  let fd = fds.get(path);
+  if (fd === undefined) {
+    fd = fs.openSync(path, "r");
+    fds.set(path, fd);
+  }
+  return fd;
+};
+
+function readFile(method, url, headers, result) {
+  const path = fileURLToPath(url);
+  const size = fs.fstatSync(fdFor(path)).size;
+  if (method === "HEAD") {
+    result.status = 200;
+    result.headers["content-length"] = String(size);
+    result.body = new ArrayBuffer(0);
+    return;
+  }
+  const range = /bytes=(\\d+)-(\\d*)/.exec(headers.Range || headers.range || "");
+  const start = range ? Number(range[1]) : 0;
+  const end = range && range[2] ? Math.min(Number(range[2]), size - 1) : size - 1;
+  if (start >= size) {
+    result.status = 416;
+    result.headers["content-range"] = "bytes */" + size;
+    result.body = new ArrayBuffer(0);
+    return;
+  }
+  const len = Math.max(0, end - start + 1);
+  const buf = Buffer.allocUnsafe(len);
+  let got = 0;
+  while (got < len) {
+    const n = fs.readSync(fdFor(path), buf, got, len - got, start + got);
+    if (n <= 0) break;
+    got += n;
+  }
+  result.status = range ? 206 : 200;
+  result.headers["content-length"] = String(got);
+  if (range) result.headers["content-range"] = "bytes " + start + "-" + (start + got - 1) + "/" + size;
+  result.body = buf.buffer.slice(buf.byteOffset, buf.byteOffset + got);
+}
+
 parentPort.on("message", async ({ port, signal, method, url, headers, body }) => {
   const result = { status: 0, headers: {}, body: null, error: null };
   try {
-    const resp = await fetch(url, { method, headers, body: body ?? undefined });
-    result.status = resp.status;
-    for (const [k, v] of resp.headers) result.headers[k.toLowerCase()] = v;
-    result.body = await resp.arrayBuffer();
+    if (url.startsWith("file:")) {
+      readFile(method, url, headers, result);
+    } else {
+      const resp = await fetch(url, { method, headers, body: body ?? undefined });
+      result.status = resp.status;
+      for (const [k, v] of resp.headers) result.headers[k.toLowerCase()] = v;
+      result.body = await resp.arrayBuffer();
+    }
   } catch (e) {
     result.error = String(e);
   }
@@ -95,6 +146,47 @@ parentPort.on("message", async ({ port, signal, method, url, headers, body }) =>
 });
 
 // vendor/pkg/rete_wasm.js
+var rete_wasm_exports = {};
+__export(rete_wasm_exports, {
+  Graph: () => Graph,
+  RemoteGraph: () => RemoteGraph,
+  __start: () => __start,
+  build: () => build,
+  card: () => card,
+  card_url: () => card_url,
+  check_schema: () => check_schema,
+  check_schema_url: () => check_schema_url,
+  communities: () => communities,
+  default: () => __wbg_init,
+  file_layout: () => file_layout,
+  graph_names: () => graph_names,
+  header_ranges: () => header_ranges,
+  info: () => info,
+  initSync: () => initSync,
+  prefix_search: () => prefix_search,
+  progressive_query: () => progressive_query,
+  pyramid_tree: () => pyramid_tree,
+  query: () => query,
+  query_communities: () => query_communities,
+  query_sparql: () => query_sparql,
+  query_triples: () => query_triples,
+  reach: () => reach,
+  reach_url: () => reach_url,
+  reason: () => reason,
+  reason_construct_url: () => reason_construct_url,
+  reason_url: () => reason_url,
+  schema: () => schema,
+  schema_packed: () => schema_packed,
+  schema_url: () => schema_url,
+  shacl: () => shacl,
+  shacl_construct_url: () => shacl_construct_url,
+  shacl_url: () => shacl_url,
+  sparql_url: () => sparql_url,
+  summary_overview: () => summary_overview,
+  text_search: () => text_search,
+  why_triples: () => why_triples,
+  why_url: () => why_url
+});
 var Graph = class {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
@@ -106,6 +198,19 @@ var Graph = class {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_graph_free(ptr, 0);
   }
+  /**
+   * See [`card`] — the Dataset Card of the resident file.
+   * @returns {string | undefined}
+   */
+  card() {
+    const ret = wasm.graph_card(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
   /**
    * See [`file_layout`].
    * @returns {string}
@@ -239,11 +344,11 @@ var Graph = class {
    * @param {string} format
    * @returns {string}
    */
-  query(query, format) {
+  query(query2, format) {
     let deferred4_0;
     let deferred4_1;
     try {
-      const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len1 = WASM_VECTOR_LEN;
@@ -268,11 +373,11 @@ var Graph = class {
    * @param {number | null} [round]
    * @returns {string}
    */
-  query_communities(query, round) {
+  query_communities(query2, round) {
     let deferred3_0;
     let deferred3_1;
     try {
-      const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ret = wasm.graph_query_communities(this.__wbg_ptr, ptr0, len0, isLikeNone(round) ? Number.MAX_SAFE_INTEGER : round >>> 0);
       var ptr2 = ret[0];
@@ -296,11 +401,11 @@ var Graph = class {
    * @param {string} format
    * @returns {string}
    */
-  query_reasoned(query, format) {
+  query_reasoned(query2, format) {
     let deferred4_0;
     let deferred4_1;
     try {
-      const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len1 = WASM_VECTOR_LEN;
@@ -531,6 +636,23 @@ var RemoteGraph = class {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_remotegraph_free(ptr, 0);
   }
+  /**
+   * See [`card_url`] — the Dataset Card, over the resident handle's reader
+   * (so the header range it already fetched is served from the block cache).
+   * @returns {string | undefined}
+   */
+  card() {
+    const ret = wasm.remotegraph_card(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
   /**
    * The file's content hash (blake3-16, hex). The worker keys its session
    * cache by this rather than the URL, so two URLs of the same file share the
@@ -550,6 +672,45 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+  /**
+   * See [`graph_names`].
+   * @returns {string}
+   */
+  graph_names() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.remotegraph_graph_names(this.__wbg_ptr);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * See [`info`] — read from the resident header, no extra fetch.
+   * @returns {string}
+   */
+  info() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.remotegraph_info(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
   /**
    * Open a remote `.rete` over HTTP range and keep it resident for repeated
    * querying. The first query faults in the dictionary chunks + index tiles it
@@ -598,15 +759,19 @@ var RemoteGraph = class {
   }
   /**
    * See [`sparql_url`] — same query, but over the resident, cached handle.
+   * The incompleteness verdict is PER QUERY: reset the sticky failure flags
+   * first, so one transient fetch failure fails only the query it happened
+   * in — not every later query on this session (failed tiles/chunks are
+   * never cached, so they retry here).
    * @param {string} query
    * @param {string} format
    * @returns {string}
    */
-  query(query, format) {
+  query(query2, format) {
     let deferred4_0;
     let deferred4_1;
     try {
-      const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len1 = WASM_VECTOR_LEN;
@@ -632,11 +797,11 @@ var RemoteGraph = class {
    * @param {string} format
    * @returns {string}
    */
-  query_reasoned(query, format) {
+  query_reasoned(query2, format) {
     let deferred4_0;
     let deferred4_1;
     try {
-      const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len1 = WASM_VECTOR_LEN;
@@ -655,6 +820,65 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * See [`schema_url`] — the **baked** schema pyramid over the resident
+   * handle. Deliberately never falls back to the scanning [`schema`]: that
+   * would drag the whole remote file across the wire.
+   * @returns {string}
+   */
+  schema() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.remotegraph_schema(this.__wbg_ptr);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * See [`shacl_url`] — validate over the resident handle. The default graph
+   * validates lazily against the index (only the shapes' targets are
+   * fetched), so a shape over a huge remote file stays cheap.
+   * @param {string} shapes_turtle
+   * @param {string | null | undefined} graph
+   * @param {string} format
+   * @returns {string}
+   */
+  shacl(shapes_turtle, graph, format) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+      const ptr0 = passStringToWasm0(shapes_turtle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      var ptr1 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      const ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len2 = WASM_VECTOR_LEN;
+      const ret = wasm.remotegraph_shacl(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+      var ptr4 = ret[0];
+      var len4 = ret[1];
+      if (ret[3]) {
+        ptr4 = 0;
+        len4 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred5_0 = ptr4;
+      deferred5_1 = len4;
+      return getStringFromWasm0(ptr4, len4);
+    } finally {
+      wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+  }
   /**
    * `{ fileLength, bytes, requests }` — CUMULATIVE physical fetches since this
    * session opened. The worker diffs successive calls to report a single
@@ -707,6 +931,9 @@ var RemoteGraph = class {
   }
 };
 if (Symbol.dispose) RemoteGraph.prototype[Symbol.dispose] = RemoteGraph.prototype.free;
+function __start() {
+  wasm.__start();
+}
 function build(text, format) {
   const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -720,6 +947,734 @@ function build(text, format) {
   wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
   return v3;
 }
+function card(bytes) {
+  const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.card(ptr0, len0);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  let v2;
+  if (ret[0] !== 0) {
+    v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  }
+  return v2;
+}
+function card_url(url) {
+  const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.card_url(ptr0, len0);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  let v2;
+  if (ret[0] !== 0) {
+    v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  }
+  return v2;
+}
+function check_schema(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.check_schema(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function check_schema_url(url) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.check_schema_url(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function communities(bytes, round) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.communities(ptr0, len0, isLikeNone(round) ? Number.MAX_SAFE_INTEGER : round >>> 0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function file_layout(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.file_layout(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function graph_names(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.graph_names(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function header_ranges(head) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(head, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.header_ranges(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function info(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.info(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function prefix_search(bytes, prefix, limit) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.prefix_search(ptr0, len0, ptr1, len1, limit);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function progressive_query(bytes, query2) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.progressive_query(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function pyramid_tree(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pyramid_tree(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function query(bytes, query2, format) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.query(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function query_communities(bytes, query2, round) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.query_communities(ptr0, len0, ptr1, len1, isLikeNone(round) ? Number.MAX_SAFE_INTEGER : round >>> 0);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function query_sparql(bytes, query2) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.query_sparql(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function query_triples(bytes, subject, predicate, object) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(subject) ? 0 : passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(predicate) ? 0 : passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(object) ? 0 : passStringToWasm0(object, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.query_triples(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function reach(bytes, predicate, seeds, reverse) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(seeds, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.reach(ptr0, len0, ptr1, len1, ptr2, len2, reverse);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function reach_url(url, predicate, seeds, reverse) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(seeds, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.reach_url(ptr0, len0, ptr1, len1, ptr2, len2, reverse);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function reason(bytes, graph) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reason(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function reason_construct_url(url, construct) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(construct, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reason_construct_url(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function reason_url(url, graph) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.reason_url(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function schema(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.schema(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function schema_packed(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.schema_packed(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function schema_url(url) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.schema_url(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function shacl(bytes, shapes_turtle, graph, format) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(shapes_turtle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.shacl(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function shacl_construct_url(url, construct, shapes_turtle, format) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(construct, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(shapes_turtle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.shacl_construct_url(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function shacl_url(url, shapes_turtle, graph, format) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(shapes_turtle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.shacl_url(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function sparql_url(url, query2, format) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(query2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.sparql_url(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function summary_overview(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.summary_overview(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function text_search(bytes, words, contains_prefix, limit) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(words, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(contains_prefix) ? 0 : passStringToWasm0(contains_prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.text_search(ptr0, len0, ptr1, len1, ptr2, len2, limit);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+function why_triples(bytes, subject, predicate, object) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(subject) ? 0 : passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(predicate) ? 0 : passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(object) ? 0 : passStringToWasm0(object, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.why_triples(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function why_url(url, subject, predicate, object) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(subject) ? 0 : passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(predicate) ? 0 : passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(object) ? 0 : passStringToWasm0(object, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.why_url(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
 function __wbg_get_imports() {
   const import0 = {
     __proto__: null,
@@ -1176,6 +2131,22 @@ async function __wbg_load(module2, imports) {
     return false;
   }
 }
+function initSync(module2) {
+  if (wasm !== void 0) return wasm;
+  if (module2 !== void 0) {
+    if (Object.getPrototypeOf(module2) === Object.prototype) {
+      ({ module: module2 } = module2);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module2 instanceof WebAssembly.Module)) {
+    module2 = new WebAssembly.Module(module2);
+  }
+  const instance = new WebAssembly.Instance(module2, imports);
+  return __wbg_finalize_init(instance, module2);
+}
 async function __wbg_init(module_or_path) {
   if (wasm !== void 0) return wasm;
   if (module_or_path !== void 0) {
@@ -1196,6 +2167,257 @@ async function __wbg_init(module_or_path) {
   return __wbg_finalize_init(instance, module2);
 }
 
+// src/comunica.js
+var BaseTerm = class {
+  equals(other) {
+    return !!other && other.termType === this.termType && other.value === this.value && (this.termType !== "Literal" || other.language === this.language && other.datatype.value === this.datatype.value);
+  }
+};
+var NamedNode = class extends BaseTerm {
+  constructor(value) {
+    super();
+    this.termType = "NamedNode";
+    this.value = value;
+  }
+};
+var BlankNode = class extends BaseTerm {
+  constructor(label) {
+    super();
+    this.termType = "BlankNode";
+    this.value = label;
+  }
+};
+var Literal = class extends BaseTerm {
+  constructor(value, languageOrDatatype) {
+    super();
+    this.termType = "Literal";
+    this.value = value;
+    if (typeof languageOrDatatype === "string") {
+      this.language = languageOrDatatype;
+      this.datatype = new NamedNode(
+        "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
+      );
+    } else {
+      this.language = "";
+      this.datatype = languageOrDatatype ?? new NamedNode("http://www.w3.org/2001/XMLSchema#string");
+    }
+  }
+};
+var DefaultGraph = class extends BaseTerm {
+  constructor() {
+    super();
+    this.termType = "DefaultGraph";
+    this.value = "";
+  }
+};
+var Quad = class {
+  constructor(subject, predicate, object, graph) {
+    this.termType = "Quad";
+    this.value = "";
+    this.subject = subject;
+    this.predicate = predicate;
+    this.object = object;
+    this.graph = graph ?? new DefaultGraph();
+  }
+  equals(other) {
+    return !!other && other.termType === "Quad" && this.subject.equals(other.subject) && this.predicate.equals(other.predicate) && this.object.equals(other.object) && this.graph.equals(other.graph);
+  }
+};
+function toRdfjs(t) {
+  const term = t instanceof Term ? t : Term.parse(t);
+  switch (term.kind) {
+    case "iri":
+      return new NamedNode(term.value);
+    case "bnode":
+      return new BlankNode(term.value.replace(/^_:/, ""));
+    case "triple": {
+      const [s, p, o] = splitQuoted(term.value);
+      return new Quad(toRdfjs(s), toRdfjs(p), toRdfjs(o));
+    }
+    default:
+      if (term.lang) return new Literal(term.value, term.lang);
+      if (term.datatype) return new Literal(term.value, new NamedNode(term.datatype));
+      return new Literal(term.value);
+  }
+}
+function splitQuoted(token) {
+  const inner = token.slice(2, -2).trim();
+  const parts = [];
+  let depth = 0, inString = false, start = 0;
+  for (let i = 0; i < inner.length; i += 1) {
+    const c = inner[i];
+    if (inString) {
+      if (c === "\\") i += 1;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') inString = true;
+    else if (inner.startsWith("<<", i)) {
+      depth += 1;
+      i += 1;
+    } else if (inner.startsWith(">>", i)) {
+      depth -= 1;
+      i += 1;
+    } else if (c === " " && depth === 0) {
+      if (i > start) parts.push(inner.slice(start, i));
+      start = i + 1;
+      if (parts.length === 2) {
+        parts.push(inner.slice(start));
+        break;
+      }
+    }
+  }
+  if (parts.length < 3) parts.push(inner.slice(start));
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+function toN3(term) {
+  switch (term.termType) {
+    case "NamedNode":
+      return `<${term.value}>`;
+    case "Literal": {
+      const dt = term.language || !term.datatype || term.datatype.value === XSD_STRING ? null : term.datatype.value;
+      return new Term("literal", term.value, dt, term.language || null).n3;
+    }
+    case "Quad":
+      return `<< ${toN3(term.subject)} ${toN3(term.predicate)} ${toN3(term.object)} >>`;
+    default:
+      throw new TypeError(`cannot serialize ${term.termType} into a pattern`);
+  }
+}
+var isVarish = (t) => t == null || t.termType === "Variable";
+var QuadStream = class {
+  #quads;
+  #i = 0;
+  #handlers = { readable: [], end: [], error: [], data: [] };
+  #error;
+  constructor(quads, error = null) {
+    this.#quads = quads;
+    this.#error = error;
+    queueMicrotask(() => {
+      if (this.#error) return this.#emit("error", this.#error);
+      this.#emit("readable");
+      if (this.#i >= this.#quads.length) this.#emit("end");
+    });
+  }
+  read() {
+    if (this.#i < this.#quads.length) {
+      const q = this.#quads[this.#i];
+      this.#i += 1;
+      if (this.#i >= this.#quads.length) queueMicrotask(() => this.#emit("end"));
+      return q;
+    }
+    return null;
+  }
+  on(event, handler) {
+    (this.#handlers[event] ??= []).push(handler);
+    return this;
+  }
+  once(event, handler) {
+    const stream = this;
+    const wrap = function(...a) {
+      stream.removeListener(event, wrap);
+      handler.call(this, ...a);
+    };
+    return this.on(event, wrap);
+  }
+  addListener(event, handler) {
+    return this.on(event, handler);
+  }
+  removeListener(event, handler) {
+    const list = this.#handlers[event] ?? [];
+    const at = list.indexOf(handler);
+    if (at >= 0) list.splice(at, 1);
+    return this;
+  }
+  emit() {
+    return false;
+  }
+  // external emits are ignored
+  destroy() {
+    this.#i = this.#quads.length;
+    return this;
+  }
+  #emit(event, ...args) {
+    for (const h of [...this.#handlers[event] ?? []]) h.call(this, ...args);
+  }
+};
+var ReteSource = class {
+  /** @param {import("./index.js").Graph} graph */
+  constructor(graph) {
+    this.graph = graph;
+  }
+  /** All quads matching the pattern, as an RDF/JS quad stream. */
+  match(subject, predicate, object, graph) {
+    try {
+      return new QuadStream(this.#matchArray(subject, predicate, object, graph));
+    } catch (error) {
+      return new QuadStream([], error);
+    }
+  }
+  /** Number of matching quads (used by query planners for join ordering). */
+  countQuads(subject, predicate, object, graph) {
+    return this.#matchArray(subject, predicate, object, graph).length;
+  }
+  #matchArray(subject, predicate, object, graph) {
+    const wantBnode = (term) => term != null && term.termType === "BlankNode" ? `_:${term.value}` : null;
+    const wantS = wantBnode(subject), wantO = wantBnode(object);
+    const free = {
+      s: isVarish(subject) || subject.termType === "BlankNode",
+      p: isVarish(predicate),
+      o: isVarish(object) || object.termType === "BlankNode"
+    };
+    const pattern = [
+      free.s ? "?s" : toN3(subject),
+      free.p ? "?p" : toN3(predicate),
+      free.o ? "?o" : toN3(object)
+    ].join(" ");
+    const fullyBound = !free.s && !free.p && !free.o;
+    const rows = [];
+    const defaultGraph = new DefaultGraph();
+    const runDefault = () => {
+      if (fullyBound) {
+        if (this.graph.query(`ASK { ${pattern} }`)) rows.push({ row: {}, graphTerm: defaultGraph });
+        return;
+      }
+      for (const row of this.graph.query(`SELECT * WHERE { ${pattern} }`)) {
+        rows.push({ row, graphTerm: defaultGraph });
+      }
+    };
+    const runNamed = (g) => {
+      if (g && fullyBound) {
+        if (this.graph.query(`ASK { GRAPH <${g.value}> { ${pattern} } }`))
+          rows.push({ row: {}, graphTerm: g });
+        return;
+      }
+      const clause = g ? `GRAPH <${g.value}>` : "GRAPH ?g";
+      for (const row of this.graph.query(`SELECT * WHERE { ${clause} { ${pattern} } }`)) {
+        rows.push({ row, graphTerm: g ?? toRdfjs(row.g) });
+      }
+    };
+    if (graph == null || graph.termType === "Variable") {
+      runDefault();
+      runNamed(null);
+    } else if (graph.termType === "DefaultGraph") {
+      runDefault();
+    } else if (graph.termType === "NamedNode") {
+      runNamed(graph);
+    } else {
+      throw new TypeError(`cannot match graph term ${graph.termType}`);
+    }
+    const out = [];
+    for (const { row, graphTerm } of rows) {
+      const s = row.s ? toRdfjs(row.s) : subject;
+      const p = row.p ? toRdfjs(row.p) : predicate;
+      const o = row.o ? toRdfjs(row.o) : object;
+      if (wantS && (s.termType !== "BlankNode" || `_:${s.value}` !== wantS)) continue;
+      if (wantO && (o.termType !== "BlankNode" || `_:${o.value}` !== wantO)) continue;
+      out.push(new Quad(s, p, o, graphTerm));
+    }
+    return out;
+  }
+};
+
 // src/index.js
 var XSD = "http://www.w3.org/2001/XMLSchema#";
 var INT_TYPES = new Set(
@@ -1333,8 +2555,8 @@ var Graph2 = class {
     this.#remote = remote;
   }
   /** The engine's raw JSON result envelope. */
-  queryRaw(query, { reason = false } = {}) {
-    const s = reason ? this.#g.query_reasoned(query, "json") : this.#g.query(query, "json");
+  queryRaw(query2, { reason: reason2 = false } = {}) {
+    const s = reason2 ? this.#g.query_reasoned(query2, "json") : this.#g.query(query2, "json");
     return JSON.parse(s);
   }
   /**
@@ -1342,8 +2564,8 @@ var Graph2 = class {
    * CONSTRUCT/DESCRIBE → array of `[s, p, o]` Term triples.
    * `reason: true` turns on OWL 2 QL entailment by query rewriting.
    */
-  query(query, opts = {}) {
-    const env = this.queryRaw(query, opts);
+  query(query2, opts = {}) {
+    const env = this.queryRaw(query2, opts);
     switch (env.kind) {
       case "select":
         return env.rows.map(
@@ -1382,6 +2604,37 @@ var Graph2 = class {
   info() {
     return JSON.parse(this.#g.info?.() ?? "{}");
   }
+  /**
+   * The embedded Dataset Card — the file's own self-description (title,
+   * description, license, provenance, counts, example queries) — or `null`
+   * when the file carries none. On a remote graph this is the index-free CARD
+   * tier: the metadata section's byte range, nothing else.
+   */
+  card() {
+    const s = this.#g.card();
+    return s ? JSON.parse(s) : null;
+  }
+  /**
+   * The example SPARQL queries the file ships with. Rich entries carry
+   * `title`/`question`/`dimension`/`tier` alongside `sparql`; run one with
+   * `g.query(g.examples()[0].sparql)`. Empty when the file has no card.
+   */
+  examples() {
+    const card2 = this.card() ?? {};
+    return [
+      ...(card2.queries ?? []).map((q) => ({ ...q })),
+      ...(card2.example_queries ?? []).map((sparql) => ({ sparql }))
+    ];
+  }
+  /**
+   * Validate SHACL Core shapes (Turtle) against the graph. Returns the
+   * report as `"json"` (default) or `"text"`. Over a remote graph the default
+   * graph validates lazily — only the shapes' target nodes are fetched.
+   */
+  shacl(shapesTurtle, { graph = null, format = "json" } = {}) {
+    const out = this.#g.shacl(shapesTurtle, graph ?? void 0, format);
+    return format === "json" ? JSON.parse(out) : out;
+  }
   get quads() {
     return this.info().quads;
   }
@@ -1403,9 +2656,14 @@ async function open(source, { headers } = {}) {
   if (headers) {
     throw new Error("custom headers are not supported by the JS client yet");
   }
-  if (typeof source === "string" && /^https?:\/\//.test(source)) {
-    if (typeof XMLHttpRequest === "undefined") {
-      if (typeof process !== "undefined" && process.versions?.node) {
+  if (typeof source === "string" && /^(https?|file):\/\//.test(source)) {
+    const isFile = source.startsWith("file:");
+    const node = typeof process !== "undefined" && !!process.versions?.node;
+    if (isFile && !node) {
+      throw new Error("file:// .rete opens are Node-only; pass bytes in the browser");
+    }
+    if (typeof XMLHttpRequest === "undefined" || isFile) {
+      if (node) {
         const { install: install2 } = await Promise.resolve().then(() => (init_node_sync_xhr(), node_sync_xhr_exports));
         install2();
       } else {
@@ -1428,9 +2686,11 @@ async function build2(text, format = "nt") {
 }
 export {
   Graph2 as Graph,
+  ReteSource,
   Term,
   __setWasmSource,
   build2 as build,
   init,
-  open
+  open,
+  rete_wasm_exports as wasm
 };