rete-graph 0.1.0

package/dist/index.js

@@ -0,0 +1,1436 @@
+/*! rete-graph v0.1.0 | Apache-2.0 | https://github.com/caviri/rete */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/node-sync-xhr.js
+var node_sync_xhr_exports = {};
+__export(node_sync_xhr_exports, {
+  NodeSyncXMLHttpRequest: () => NodeSyncXMLHttpRequest,
+  install: () => install
+});
+import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
+function syncFetch(method, url, headers, body) {
+  if (!worker) {
+    worker = new Worker(WORKER_SRC, { eval: true });
+    worker.unref();
+  }
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  const { port1, port2 } = new MessageChannel();
+  worker.postMessage({ port: port2, signal, method, url, headers, body }, [port2]);
+  Atomics.wait(signal, 0, 0);
+  const msg = receiveMessageOnPort(port1);
+  port1.close();
+  if (!msg) throw new Error(`sync fetch: no response for ${method} ${url}`);
+  if (msg.message.error) throw new Error(`sync fetch failed: ${msg.message.error}`);
+  return msg.message;
+}
+function install() {
+  if (typeof globalThis.XMLHttpRequest === "undefined") {
+    globalThis.XMLHttpRequest = NodeSyncXMLHttpRequest;
+  }
+}
+var WORKER_SRC, worker, NodeSyncXMLHttpRequest;
+var init_node_sync_xhr = __esm({
+  "src/node-sync-xhr.js"() {
+    WORKER_SRC = `
+const { parentPort } = require("node:worker_threads");
+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();
+  } catch (e) {
+    result.error = String(e);
+  }
+  port.postMessage(result, result.body ? [result.body] : []);
+  port.close();
+  Atomics.store(signal, 0, 1);
+  Atomics.notify(signal, 0);
+});
+`;
+    worker = null;
+    NodeSyncXMLHttpRequest = class {
+      #method;
+      #url;
+      #headers = {};
+      #resp = null;
+      responseType = "";
+      open(method, url, async = false) {
+        if (async) throw new Error("NodeSyncXMLHttpRequest only supports synchronous mode");
+        this.#method = method;
+        this.#url = url;
+      }
+      setRequestHeader(name, value) {
+        this.#headers[name] = value;
+      }
+      overrideMimeType() {
+      }
+      send(body = null) {
+        this.#resp = syncFetch(this.#method, this.#url, this.#headers, body);
+      }
+      get status() {
+        return this.#resp?.status ?? 0;
+      }
+      getResponseHeader(name) {
+        return this.#resp?.headers[String(name).toLowerCase()] ?? null;
+      }
+      get responseText() {
+        return new TextDecoder().decode(this.#resp?.body ?? new ArrayBuffer(0));
+      }
+      get response() {
+        if (this.responseType === "arraybuffer") return this.#resp?.body ?? new ArrayBuffer(0);
+        return this.responseText;
+      }
+    };
+  }
+});
+
+// vendor/pkg/rete_wasm.js
+var Graph = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    GraphFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_graph_free(ptr, 0);
+  }
+  /**
+   * See [`file_layout`].
+   * @returns {string}
+   */
+  file_layout() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.graph_file_layout(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 [`graph_names`].
+   * @returns {string}
+   */
+  graph_names() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.graph_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`].
+   * @returns {string}
+   */
+  info() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.graph_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 `.rete` image and keep it resident for repeated querying.
+   * @param {Uint8Array} bytes
+   */
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.graph_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0];
+    GraphFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * See [`prefix_search`].
+   * @param {string} prefix
+   * @param {number} limit
+   * @returns {string}
+   */
+  prefix_search(prefix, limit) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_prefix_search(this.__wbg_ptr, ptr0, len0, limit);
+      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);
+    }
+  }
+  /**
+   * See [`pyramid_tree`].
+   * @returns {string}
+   */
+  pyramid_tree() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.graph_pyramid_tree(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 [`query`].
+   * @param {string} query
+   * @param {string} format
+   * @returns {string}
+   */
+  query(query, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(query, 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;
+      const ret = wasm.graph_query(this.__wbg_ptr, 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);
+    }
+  }
+  /**
+   * See [`query_communities`].
+   * @param {string} query
+   * @param {number | null} [round]
+   * @returns {string}
+   */
+  query_communities(query, round) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(query, 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];
+      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);
+    }
+  }
+  /**
+   * As [`query`], with OWL 2 QL entailment on (`rdfs:subClassOf` /
+   * `subPropertyOf` / `domain` / `range` reasoning by query rewriting).
+   * @param {string} query
+   * @param {string} format
+   * @returns {string}
+   */
+  query_reasoned(query, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(query, 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;
+      const ret = wasm.graph_query_reasoned(this.__wbg_ptr, 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);
+    }
+  }
+  /**
+   * See [`query_triples`].
+   * @param {string | null} [subject]
+   * @param {string | null} [predicate]
+   * @param {string | null} [object]
+   * @returns {string}
+   */
+  query_triples(subject, predicate, object) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+      var ptr0 = isLikeNone(subject) ? 0 : passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ptr1 = isLikeNone(predicate) ? 0 : passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      var ptr2 = isLikeNone(object) ? 0 : passStringToWasm0(object, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len2 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_query_triples(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);
+    }
+  }
+  /**
+   * See [`reach`].
+   * @param {string} predicate
+   * @param {string} seeds
+   * @param {boolean} reverse
+   * @returns {string}
+   */
+  reach(predicate, seeds, reverse) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(seeds, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_reach(this.__wbg_ptr, ptr0, len0, ptr1, len1, reverse);
+      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);
+    }
+  }
+  /**
+   * See [`reason`].
+   * @param {string | null} [graph]
+   * @returns {string}
+   */
+  reason(graph) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      var ptr0 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_reason(this.__wbg_ptr, ptr0, len0);
+      deferred2_0 = ret[0];
+      deferred2_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * See [`schema`] — the live (scanning) profile; prefer `schema_packed` when
+   * the file carries a pyramid.
+   * @returns {string}
+   */
+  schema() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.graph_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`].
+   * @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.graph_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);
+    }
+  }
+  /**
+   * See [`text_search`].
+   * @param {string[]} words
+   * @param {string | null | undefined} contains_prefix
+   * @param {number} limit
+   * @returns {string}
+   */
+  text_search(words, contains_prefix, limit) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passArrayJsValueToWasm0(words, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      var ptr1 = isLikeNone(contains_prefix) ? 0 : passStringToWasm0(contains_prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_text_search(this.__wbg_ptr, 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);
+    }
+  }
+  /**
+   * See [`why_triples`].
+   * @param {string | null} [subject]
+   * @param {string | null} [predicate]
+   * @param {string | null} [object]
+   * @returns {string}
+   */
+  why_triples(subject, predicate, object) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+      var ptr0 = isLikeNone(subject) ? 0 : passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ptr1 = isLikeNone(predicate) ? 0 : passStringToWasm0(predicate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      var ptr2 = isLikeNone(object) ? 0 : passStringToWasm0(object, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len2 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_why_triples(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);
+    }
+  }
+};
+if (Symbol.dispose) Graph.prototype[Symbol.dispose] = Graph.prototype.free;
+var RemoteGraph = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RemoteGraphFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_remotegraph_free(ptr, 0);
+  }
+  /**
+   * 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
+   * cache — and it's the stable key a future IndexedDB block store (L3) needs
+   * to survive page reloads.
+   * @returns {string}
+   */
+  content_hash() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.remotegraph_content_hash(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
+   * needs; later queries on this handle reuse them and the block cache.
+   * @param {string} url
+   */
+  constructor(url) {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.remotegraph_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0];
+    RemoteGraphFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * See [`prefix_search`] — over the resident, cached remote handle. Faults the
+   * pyramid (where the label index lives) on the first call, then serves the
+   * search from memory.
+   * @param {string} prefix
+   * @param {number} limit
+   * @returns {string}
+   */
+  prefix_search(prefix, limit) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.remotegraph_prefix_search(this.__wbg_ptr, ptr0, len0, limit);
+      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);
+    }
+  }
+  /**
+   * See [`sparql_url`] — same query, but over the resident, cached handle.
+   * @param {string} query
+   * @param {string} format
+   * @returns {string}
+   */
+  query(query, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(query, 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;
+      const ret = wasm.remotegraph_query(this.__wbg_ptr, 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);
+    }
+  }
+  /**
+   * As [`query`], with OWL 2 QL entailment on (reason over the ontology while
+   * reading only the bytes the rewritten query touches).
+   * @param {string} query
+   * @param {string} format
+   * @returns {string}
+   */
+  query_reasoned(query, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(query, 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;
+      const ret = wasm.remotegraph_query_reasoned(this.__wbg_ptr, 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);
+    }
+  }
+  /**
+   * `{ fileLength, bytes, requests }` — CUMULATIVE physical fetches since this
+   * session opened. The worker diffs successive calls to report a single
+   * query's traffic (a fully cached re-run adds ~0).
+   * @returns {string}
+   */
+  stats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.remotegraph_stats(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);
+    }
+  }
+  /**
+   * See [`text_search`] — over the resident remote handle. Faults the TEXT_INDEX
+   * token table on the first call, then fetches only the queried posting lists
+   * (never the whole postings blob), serving repeat searches from memory.
+   * @param {string[]} words
+   * @param {string | null | undefined} contains_prefix
+   * @param {number} limit
+   * @returns {string}
+   */
+  text_search(words, contains_prefix, limit) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passArrayJsValueToWasm0(words, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      var ptr1 = isLikeNone(contains_prefix) ? 0 : passStringToWasm0(contains_prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      const ret = wasm.remotegraph_text_search(this.__wbg_ptr, 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);
+    }
+  }
+};
+if (Symbol.dispose) RemoteGraph.prototype[Symbol.dispose] = RemoteGraph.prototype.free;
+function build(text, format) {
+  const ptr0 = passStringToWasm0(text, 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;
+  const ret = wasm.build(ptr0, len0, ptr1, len1);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v3;
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+      const ret = debugString(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_null_87c3bfe968c6a5ad: function(arg0) {
+      const ret = arg0 === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_c236cabd84a4d769: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_call_6e37a87ff352da3d: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_9c758de292015997: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_crypto_38df2bab126b63dc: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __wbg_encodeURIComponent_9ff907ad9d03c7bb: function(arg0, arg1) {
+      const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_error_78ff5b3a29b770e0: function(arg0) {
+      console.error(arg0);
+    },
+    __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_getResponseHeader_db1ae5b1693dd680: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg1.getResponseHeader(getStringFromWasm0(arg2, arg3));
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+      }, arguments);
+    },
+    __wbg_get_de6a0f7d4d18a304: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_length_4a591ecaa01354d9: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_2ee370dca414d926: function() {
+      return handleError(function() {
+        const ret = new XMLHttpRequest();
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_50bb5ebeecef71a8: function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_578aeef4b6b94378: function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    },
+    __wbg_new_with_length_36a4998e27b014c5: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_length_b4a87ccced374381: function(arg0) {
+      const ret = new Float64Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_node_84ea875411254db1: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_open_837bab9ccb9e06da: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        arg0.open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
+      }, arguments);
+    },
+    __wbg_process_44c7a14e11e9f69e: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_randomFillSync_6c25eac9869eb53c: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_require_b4edbdcf3e2a1ef0: function() {
+      return handleError(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_responseText_266ec252b6be1e56: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg1.responseText;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+      }, arguments);
+    },
+    __wbg_response_8ec82c168e320475: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.response;
+        return ret;
+      }, arguments);
+    },
+    __wbg_send_4e22a258e556a44c: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        arg0.send(arg1 === 0 ? void 0 : getStringFromWasm0(arg1, arg2));
+      }, arguments);
+    },
+    __wbg_send_dce79f146638dfda: function() {
+      return handleError(function(arg0) {
+        arg0.send();
+      }, arguments);
+    },
+    __wbg_setRequestHeader_b5e8e6d03614f3e5: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        arg0.setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+      }, arguments);
+    },
+    __wbg_set_index_c69336ea758c0507: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_set_responseType_cfb49ea8269f8317: function(arg0, arg1) {
+      arg0.responseType = __wbindgen_enum_XmlHttpRequestResponseType[arg1];
+    },
+    __wbg_static_accessor_GLOBAL_9d53f2689e622ca1: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_a1a35cec07001a8a: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_SELF_4c59f6c7ea29a144: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_WINDOW_e70ae9f2eb052253: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_status_214edd0820ca76fc: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.status;
+        return ret;
+      }, arguments);
+    },
+    __wbg_subarray_4aa221f6a4f5ab22: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_versions_276b2795b1c6a219: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./rete_wasm_bg.js": import0
+  };
+}
+var __wbindgen_enum_XmlHttpRequestResponseType = ["", "arraybuffer", "blob", "document", "json", "text"];
+var GraphFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_graph_free(ptr, 1));
+var RemoteGraphFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_remotegraph_free(ptr, 1));
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return decodeText(ptr >>> 0, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passArrayJsValueToWasm0(array, malloc) {
+  const ptr = malloc(array.length * 4, 4) >>> 0;
+  for (let i = 0; i < array.length; i++) {
+    const add = addToExternrefTable0(array[i]);
+    getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+  }
+  WASM_VECTOR_LEN = array.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasmInstance;
+var wasm;
+function __wbg_finalize_init(instance, module2) {
+  wasmInstance = instance;
+  wasm = instance.exports;
+  wasmModule = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && expectedResponseType(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("rete_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+
+// src/index.js
+var XSD = "http://www.w3.org/2001/XMLSchema#";
+var INT_TYPES = new Set(
+  [
+    "integer",
+    "long",
+    "int",
+    "short",
+    "byte",
+    "nonNegativeInteger",
+    "nonPositiveInteger",
+    "negativeInteger",
+    "positiveInteger",
+    "unsignedLong",
+    "unsignedInt",
+    "unsignedShort",
+    "unsignedByte"
+  ].map((t) => XSD + t)
+);
+var FLOAT_TYPES = new Set(["decimal", "double", "float"].map((t) => XSD + t));
+var Term = class _Term {
+  /** @param {string} kind @param {string} value */
+  constructor(kind, value, datatype = null, lang = null) {
+    this.kind = kind;
+    this.value = value;
+    this.datatype = datatype;
+    this.lang = lang;
+  }
+  /** Parse an N-Triples-style term token as emitted by the engine. */
+  static parse(token) {
+    if (token.startsWith("<<")) return new _Term("triple", token);
+    if (token.startsWith("<") && token.endsWith(">"))
+      return new _Term("iri", token.slice(1, -1));
+    if (token.startsWith("_:")) return new _Term("bnode", token);
+    if (token.startsWith('"')) return parseLiteral(token);
+    return new _Term("literal", token);
+  }
+  /** The closest JS value: number/boolean/BigInt for common XSD types. */
+  toJS() {
+    if (this.kind === "literal" && this.datatype) {
+      if (INT_TYPES.has(this.datatype)) {
+        const n = Number(this.value);
+        return Number.isSafeInteger(n) ? n : BigInt(this.value);
+      }
+      if (FLOAT_TYPES.has(this.datatype)) return Number(this.value);
+      if (this.datatype === XSD + "boolean") return this.value === "true";
+    }
+    return this.value;
+  }
+  /** The term back in N-Triples surface form. */
+  get n3() {
+    if (this.kind === "iri") return `<${this.value}>`;
+    if (this.kind === "bnode" || this.kind === "triple") return this.value;
+    const body = this.value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("\r", "\\r");
+    if (this.lang) return `"${body}"@${this.lang}`;
+    if (this.datatype) return `"${body}"^^<${this.datatype}>`;
+    return `"${body}"`;
+  }
+  toString() {
+    return this.value;
+  }
+};
+function unescapeNt(s) {
+  if (!s.includes("\\")) return s;
+  const simple = { t: "	", b: "\b", n: "\n", r: "\r", f: "\f", '"': '"', "'": "'", "\\": "\\" };
+  let out = "";
+  for (let i = 0; i < s.length; ) {
+    const c = s[i];
+    if (c !== "\\" || i + 1 >= s.length) {
+      out += c;
+      i += 1;
+      continue;
+    }
+    const e = s[i + 1];
+    if (e in simple) {
+      out += simple[e];
+      i += 2;
+    } else if (e === "u" && i + 6 <= s.length) {
+      out += String.fromCharCode(parseInt(s.slice(i + 2, i + 6), 16));
+      i += 6;
+    } else if (e === "U" && i + 10 <= s.length) {
+      out += String.fromCodePoint(parseInt(s.slice(i + 2, i + 10), 16));
+      i += 10;
+    } else {
+      out += c;
+      i += 1;
+    }
+  }
+  return out;
+}
+function parseLiteral(token) {
+  let i = 1;
+  while (i < token.length) {
+    if (token[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (token[i] === '"') break;
+    i += 1;
+  }
+  const lex = unescapeNt(token.slice(1, i));
+  const rest = token.slice(i + 1);
+  if (rest.startsWith("@")) return new Term("literal", lex, null, rest.slice(1));
+  if (rest.startsWith("^^<") && rest.endsWith(">"))
+    return new Term("literal", lex, rest.slice(3, -1));
+  return new Term("literal", lex);
+}
+var cleanIri = (token) => Term.parse(token).value;
+var embeddedWasm = null;
+var ready = null;
+function __setWasmSource(bytes) {
+  embeddedWasm = bytes;
+}
+function init(source = null) {
+  ready ??= (async () => {
+    const src = source ?? embeddedWasm;
+    if (src) {
+      await __wbg_init({ module_or_path: src });
+    } else if (typeof process !== "undefined" && process.versions?.node) {
+      const { readFile } = await import("node:fs/promises");
+      const bytes = await readFile(new URL("./rete_wasm_bg.wasm", import.meta.url));
+      await __wbg_init({ module_or_path: bytes });
+    } else {
+      await __wbg_init();
+    }
+  })();
+  return ready;
+}
+var Graph2 = class {
+  #g;
+  #remote;
+  constructor(inner, source, remote) {
+    this.#g = inner;
+    this.source = source;
+    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");
+    return JSON.parse(s);
+  }
+  /**
+   * Run a SPARQL query: SELECT → array of `{var: Term}` rows, ASK → boolean,
+   * 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);
+    switch (env.kind) {
+      case "select":
+        return env.rows.map(
+          (row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, Term.parse(v)]))
+        );
+      case "ask":
+        return env.boolean;
+      case "construct":
+        return env.triples.map((t) => t.map((tok) => Term.parse(tok)));
+      default:
+        throw new Error(`unexpected result kind: ${env.kind}`);
+    }
+  }
+  /** Label prefix search: `[{label, subject}]` with clean IRIs. */
+  prefixSearch(prefix, limit = 20) {
+    return JSON.parse(this.#g.prefix_search(prefix, limit)).map(({ label, subject }) => ({
+      label,
+      subject: cleanIri(subject)
+    }));
+  }
+  /** Full-text search over the file's TEXT_INDEX; returns subject IRIs. */
+  textSearch(words, { contains = null, limit = 100 } = {}) {
+    const list = typeof words === "string" ? words.split(/\s+/).filter(Boolean) : words;
+    return JSON.parse(this.#g.text_search(list, contains ?? void 0, limit)).map(
+      (h) => cleanIri(h.subject)
+    );
+  }
+  /** Class/predicate profile: `{classes: [[iri, n]], relations: [[s,p,o,n]]}`. */
+  schema() {
+    const env = JSON.parse(this.#g.schema());
+    return {
+      classes: env.classes.map(([c, n]) => [cleanIri(c), n]),
+      relations: env.relations.map(([s, p, o, n]) => [cleanIri(s), cleanIri(p), cleanIri(o), n])
+    };
+  }
+  info() {
+    return JSON.parse(this.#g.info?.() ?? "{}");
+  }
+  get quads() {
+    return this.info().quads;
+  }
+  graphNames() {
+    return JSON.parse(this.#g.graph_names()).map(cleanIri);
+  }
+  /** Remote graphs: cumulative physical fetch counters; null for bytes. */
+  stats() {
+    return this.#remote ? JSON.parse(this.#g.stats()) : null;
+  }
+  /** Remote graphs: blake3-16 hex content hash; null for bytes. */
+  contentHash() {
+    return this.#remote ? this.#g.content_hash() : null;
+  }
+};
+var isBytes = (s) => s instanceof Uint8Array || s instanceof ArrayBuffer || ArrayBuffer.isView(s);
+async function open(source, { headers } = {}) {
+  await init();
+  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) {
+        const { install: install2 } = await Promise.resolve().then(() => (init_node_sync_xhr(), node_sync_xhr_exports));
+        install2();
+      } else {
+        throw new Error(
+          "remote .rete opens need synchronous XHR: run inside a web worker (browser main threads forbid it) or in Node"
+        );
+      }
+    }
+    return new Graph2(new RemoteGraph(source), source, true);
+  }
+  if (isBytes(source)) {
+    const bytes = source instanceof Uint8Array ? source : new Uint8Array(source instanceof ArrayBuffer ? source : source.buffer);
+    return new Graph2(new Graph(bytes), "<bytes>", false);
+  }
+  throw new TypeError("open() takes a Uint8Array/ArrayBuffer or an http(s):// URL");
+}
+async function build2(text, format = "nt") {
+  await init();
+  return build(text, format);
+}
+export {
+  Graph2 as Graph,
+  Term,
+  __setWasmSource,
+  build2 as build,
+  init,
+  open
+};