rete-graph 0.3.2 → 0.3.5

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! rete-graph v0.3.2 | Apache-2.0 | https://github.com/caviri/rete */
+/*! rete-graph v0.3.5 | Apache-2.0 | https://github.com/caviri/rete */
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -149,18 +149,27 @@ parentPort.on("message", async ({ port, signal, method, url, headers, body }) =>
 var rete_wasm_exports = {};
 __export(rete_wasm_exports, {
   Graph: () => Graph,
+  QuadCursor: () => QuadCursor,
   RemoteGraph: () => RemoteGraph,
   __start: () => __start,
   build: () => build,
+  build_with_card: () => build_with_card,
+  build_with_card_syntax: () => build_with_card_syntax,
+  build_with_derived_card: () => build_with_derived_card,
   card: () => card,
+  card_and_build: () => card_and_build,
+  card_and_build_url: () => card_and_build_url,
   card_url: () => card_url,
   check_schema: () => check_schema,
   check_schema_url: () => check_schema_url,
   communities: () => communities,
   default: () => __wbg_init,
   file_layout: () => file_layout,
+  file_len_url: () => file_len_url,
+  forget_local_file: () => forget_local_file,
   graph_names: () => graph_names,
   header_ranges: () => header_ranges,
+  heap_bytes: () => heap_bytes,
   info: () => info,
   initSync: () => initSync,
   prefix_search: () => prefix_search,
@@ -175,6 +184,7 @@ __export(rete_wasm_exports, {
   reason: () => reason,
   reason_construct_url: () => reason_construct_url,
   reason_url: () => reason_url,
+  register_local_file: () => register_local_file,
   schema: () => schema,
   schema_packed: () => schema_packed,
   schema_url: () => schema_url,
@@ -184,6 +194,7 @@ __export(rete_wasm_exports, {
   sparql_url: () => sparql_url,
   summary_overview: () => summary_overview,
   text_search: () => text_search,
+  validate_card: () => validate_card,
   why_triples: () => why_triples,
   why_url: () => why_url
 });
@@ -211,6 +222,24 @@ var Graph = class {
     }
     return v1;
   }
+  /**
+   * See [`card_and_build`] — the card and the build record of the resident
+   * file, in the same envelope the remote path returns, so one caller
+   * handles both sources.
+   * @returns {string}
+   */
+  card_and_build() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.graph_card_and_build(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 [`file_layout`].
    * @returns {string}
@@ -338,6 +367,30 @@ var Graph = class {
       wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
   }
+  /**
+   * A **lazy, resumable cursor** over the quads of this graph — the streaming
+   * export path. See [`QuadCursor`]; `graph` selects one graph (`""` = the
+   * default graph), `None` streams the default graph followed by every named
+   * graph. `s` / `p` / `o` optionally restrict the dump to a triple pattern,
+   * which **prunes tiles** rather than filtering rows.
+   * @param {string | null} [graph]
+   * @param {string | null} [s]
+   * @param {string | null} [p]
+   * @param {string | null} [o]
+   * @returns {QuadCursor}
+   */
+  quads(graph, s, p, o) {
+    var ptr0 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(s) ? 0 : passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(p) ? 0 : passStringToWasm0(p, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(o) ? 0 : passStringToWasm0(o, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.graph_quads(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    return QuadCursor.__wrap(ret);
+  }
   /**
    * See [`query`].
    * @param {string} query
@@ -394,6 +447,41 @@ var Graph = class {
       wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
   }
+  /**
+   * As [`query`], with explicit opt-in toggles: `reason` (OWL 2 QL
+   * entailment) and `union_default` (union default graph — a pattern
+   * outside `GRAPH` matches the merge of the default graph and every named
+   * graph, the Virtuoso / GraphDB / Jena TDB mode; non-standard, so plain
+   * [`Graph::query`] never does this).
+   * @param {string} query
+   * @param {string} format
+   * @param {boolean} reason
+   * @param {boolean} union_default
+   * @returns {string}
+   */
+  query_opts(query2, format, reason2, union_default) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      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;
+      const ret = wasm.graph_query_opts(this.__wbg_ptr, ptr0, len0, ptr1, len1, reason2, union_default);
+      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 (`rdfs:subClassOf` /
    * `subPropertyOf` / `domain` / `range` reasoning by query rewriting).
@@ -456,6 +544,23 @@ var Graph = class {
       wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
     }
   }
+  /**
+   * The card's `signals.quoted_triples` for this file, from its header: does
+   * it hold quoted triples, and in which surfaces can an export write them.
+   * @returns {string}
+   */
+  quoted_triples_signal() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.graph_quoted_triples_signal(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 [`reach`].
    * @param {string} predicate
@@ -561,6 +666,34 @@ var Graph = class {
       wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
     }
   }
+  /**
+   * Byte length of the TEXT_INDEX section, `0` when the file has none — a
+   * header read, never a fault. The UI asks this to decide whether to offer
+   * full-text search at all, and to state the cost before the first one.
+   * `f64` because the section outgrows `u32`: causenet's is 1.88 GB.
+   * @returns {number}
+   */
+  text_index_len() {
+    const ret = wasm.graph_text_index_len(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Byte length of the TEXT_INDEX's leading **token table** — what a first
+   * [`Graph::text_search_one`] actually faults, and therefore the only honest
+   * number to quote as its cost. [`Graph::text_index_len`] is the whole
+   * section, postings blob included, and overstates it 6.5× on
+   * `epfl-infoscience` (195 MB section, 29 MB token table); the postings are
+   * only ever fetched one list at a time. `0` when the file has no text index
+   * or the length could not be read — the caller must then say nothing about
+   * a token table rather than pass the section length off as one.
+   * `f64` for the same reason as the section length: causenet's table is
+   * 1.88 GB.
+   * @returns {number}
+   */
+  text_index_token_table_len() {
+    const ret = wasm.graph_text_index_token_table_len(this.__wbg_ptr);
+    return ret;
+  }
   /**
    * See [`text_search`].
    * @param {string[]} words
@@ -591,6 +724,37 @@ var Graph = class {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * [`Graph::text_search`] from ONE phrase: whitespace splits it into words
+   * and **every** word must match (AND), like `rete search --contains a b`.
+   * One string in, one string out — that is what the remote twin's
+   * hand-marshaled asyncify path can carry (a JS array marshaled raw is what
+   * traps), and the UI is a single text box either way. Same JSON envelope.
+   * @param {string} phrase
+   * @param {number} limit
+   * @returns {string}
+   */
+  text_search_one(phrase, limit) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(phrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.graph_text_search_one(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 [`why_triples`].
    * @param {string | null} [subject]
@@ -625,6 +789,107 @@ var Graph = class {
   }
 };
 if (Symbol.dispose) Graph.prototype[Symbol.dispose] = Graph.prototype.free;
+var QuadCursor = class _QuadCursor {
+  static __wrap(ptr) {
+    const obj = Object.create(_QuadCursor.prototype);
+    obj.__wbg_ptr = ptr;
+    QuadCursorFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    QuadCursorFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_quadcursor_free(ptr, 0);
+  }
+  /**
+   * Whether every selected graph has been streamed to its end.
+   * @returns {boolean}
+   */
+  done() {
+    const ret = wasm.quadcursor_done(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * Up to `max` quads as a **flat** `string[]` of `[s, p, o, g, s, p, o, g, …]`
+   * N-Triples term tokens, `g` being `""` for the default graph. Flat because
+   * a nested array would allocate one JS array per quad for no gain — the
+   * caller slices it into tuples as it yields them.
+   *
+   * An empty array means the stream is finished; keep calling until you get
+   * one (that final call is what verifies no range fetch failed mid-dump).
+   * @param {number | null} [max]
+   * @returns {string[]}
+   */
+  next_batch(max) {
+    const ret = wasm.quadcursor_next_batch(this.__wbg_ptr, isLikeNone(max) ? Number.MAX_SAFE_INTEGER : max >>> 0);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * Up to `max` quads already serialized as N-Quads lines in **one** string —
+   * the `.rete` → Oxigraph / N-Quads-file path. One string crossing per batch
+   * instead of four per quad: no per-term JS string, no re-serialization in
+   * JavaScript, and the terms are already canonical N-Triples tokens, so the
+   * lines are emitted verbatim.
+   *
+   * An empty string means the stream is finished.
+   * @param {number | null} [max]
+   * @returns {string}
+   */
+  next_nquads(max) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.quadcursor_next_nquads(this.__wbg_ptr, isLikeNone(max) ? Number.MAX_SAFE_INTEGER : max >>> 0);
+      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);
+    }
+  }
+  /**
+   * How [`next_nquads`](Self::next_nquads) spells a quoted triple — the
+   * values of `rete export --quoted-triple-syntax`:
+   *
+   * - `"rdf-star"` (or `""`; the cursor's initial state): `<<s p o>>`, the
+   *   stored token, verbatim — what this cursor always wrote.
+   * - `"rdf12"`: the RDF 1.2 triple term `<<( s p o )>>`, nested terms too,
+   *   which current RDF 1.2 parsers (Oxigraph 0.5, Jena 5) load. RDF 1.2
+   *   admits a triple term in object position only, so a quoted triple in a
+   *   statement's subject/predicate (or in another's subject) makes the next
+   *   call fail by name instead of writing a line nothing parses.
+   *
+   * Anything else is refused. A file whose header records no quoted triple
+   * is written byte-for-byte the same under both.
+   * @param {string} syntax
+   */
+  set_quoted_triple_syntax(syntax) {
+    const ptr0 = passStringToWasm0(syntax, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.quadcursor_set_quoted_triple_syntax(this.__wbg_ptr, ptr0, len0);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+};
+if (Symbol.dispose) QuadCursor.prototype[Symbol.dispose] = QuadCursor.prototype.free;
 var RemoteGraph = class {
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
@@ -653,6 +918,31 @@ var RemoteGraph = class {
     }
     return v1;
   }
+  /**
+   * See [`card_and_build_url`] — card + build record over the resident
+   * handle's reader, still one coalesced range (and served from the block
+   * cache when the header range is already there).
+   * @returns {string}
+   */
+  card_and_build() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.remotegraph_card_and_build(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);
+    }
+  }
   /**
    * 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
@@ -757,6 +1047,36 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
   }
+  /**
+   * See [`Graph::quads`] — the SAME lazy cursor, over the lazily range-read
+   * remote handle.
+   *
+   * An **unfiltered** dump is not network-lazy and cannot be: it resolves
+   * every term and visits every tile, so it ends up fetching essentially the
+   * whole file (and what it faults stays resident). A **filtered** one is:
+   * pass `s` / `p` / `o` and the scan routes to one permutation, keeps only
+   * the tiles whose synopsis admits the bound components, and fetches those.
+   * On `cordis.rete` (801 MB) one predicate of one named graph costs 16 MB
+   * instead of 376 MB. To peek at an unfiltered graph, still prefer a `LIMIT`
+   * query. Worker-only in the browser, like every other read here.
+   * @param {string | null} [graph]
+   * @param {string | null} [s]
+   * @param {string | null} [p]
+   * @param {string | null} [o]
+   * @returns {QuadCursor}
+   */
+  quads(graph, s, p, o) {
+    var ptr0 = isLikeNone(graph) ? 0 : passStringToWasm0(graph, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(s) ? 0 : passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(p) ? 0 : passStringToWasm0(p, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(o) ? 0 : passStringToWasm0(o, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.remotegraph_quads(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    return QuadCursor.__wrap(ret);
+  }
   /**
    * See [`sparql_url`] — same query, but over the resident, cached handle.
    * The incompleteness verdict is PER QUERY: reset the sticky failure flags
@@ -790,6 +1110,39 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * As [`query`], with explicit opt-in toggles — see [`Graph::query_opts`].
+   * With `union_default` on, a lazy remote read may fault the index tiles of
+   * every named graph the union touches (the merge is strictly opt-in).
+   * @param {string} query
+   * @param {string} format
+   * @param {boolean} reason
+   * @param {boolean} union_default
+   * @returns {string}
+   */
+  query_opts(query2, format, reason2, union_default) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      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;
+      const ret = wasm.remotegraph_query_opts(this.__wbg_ptr, ptr0, len0, ptr1, len1, reason2, union_default);
+      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).
@@ -820,6 +1173,23 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * See [`Graph::quoted_triples_signal`] — from the header the open already
+   * holds, so no range read at all.
+   * @returns {string}
+   */
+  quoted_triples_signal() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.remotegraph_quoted_triples_signal(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 [`schema_url`] — the **baked** schema pyramid over the resident
    * handle. Deliberately never falls back to the scanning [`schema`]: that
@@ -880,9 +1250,11 @@ var RemoteGraph = class {
     }
   }
   /**
-   * `{ 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).
+   * `{ fileLength, bytes, requests, base }` — 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). `fileLength` is
+   * the **graph's** length and `base` the byte offset it starts at: `0` for an
+   * ordinary `.rete`, and the size of the HTML shell for a polyglot file.
    * @returns {string}
    */
   stats() {
@@ -897,6 +1269,34 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+  /**
+   * See [`Graph::text_index_len`] — read from the resident header, so it
+   * costs no fetch at all. Worth asking before [`RemoteGraph::text_search`]:
+   * it is the size of the section the first search starts pulling over the
+   * wire, so the UI can warn instead of surprising the user.
+   * @returns {number}
+   */
+  text_index_len() {
+    const ret = wasm.remotegraph_text_index_len(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * See [`Graph::text_index_token_table_len`] — the figure to quote before
+   * [`RemoteGraph::text_search`], because it is what that first search pulls
+   * over the wire; the section length would promise the user several times
+   * the real bill.
+   *
+   * Unlike [`RemoteGraph::text_index_len`] this is not free: the token
+   * table's length lives in the section's first bytes, not the header, so it
+   * costs ONE ≤10-byte range read (memoized). Trivial next to the table it
+   * measures — but it *is* IO, so the asyncify path must drive this call
+   * rather than treat it as a header field.
+   * @returns {number}
+   */
+  text_index_token_table_len() {
+    const ret = wasm.remotegraph_text_index_token_table_len(this.__wbg_ptr);
+    return ret;
+  }
   /**
    * 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
@@ -929,6 +1329,36 @@ var RemoteGraph = class {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * See [`Graph::text_search_one`] — over the resident remote handle, with
+   * the same token-table-then-posting-lists fault pattern as
+   * [`RemoteGraph::text_search`]. This is the shape the playground's raw
+   * asyncify glue drives: one string in, one string out, marshaled once.
+   * @param {string} phrase
+   * @param {number} limit
+   * @returns {string}
+   */
+  text_search_one(phrase, limit) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(phrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.remotegraph_text_search_one(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);
+    }
+  }
 };
 if (Symbol.dispose) RemoteGraph.prototype[Symbol.dispose] = RemoteGraph.prototype.free;
 function __start() {
@@ -947,6 +1377,53 @@ function build(text, format) {
   wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
   return v3;
 }
+function build_with_card(text, format, card_json) {
+  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 ptr2 = passStringToWasm0(card_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.build_with_card(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v4;
+}
+function build_with_card_syntax(text, format, card_json, quoted_triple_syntax) {
+  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 ptr2 = passStringToWasm0(card_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ptr3 = passStringToWasm0(quoted_triple_syntax, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len3 = WASM_VECTOR_LEN;
+  const ret = wasm.build_with_card_syntax(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v5;
+}
+function build_with_derived_card(text, format, card_json) {
+  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 ptr2 = passStringToWasm0(card_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.build_with_derived_card(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v4;
+}
 function card(bytes) {
   const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
   const len0 = WASM_VECTOR_LEN;
@@ -961,6 +1438,48 @@ function card(bytes) {
   }
   return v2;
 }
+function card_and_build(bytes) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.card_and_build(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 card_and_build_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.card_and_build_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 card_url(url) {
   const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -1059,6 +1578,33 @@ function file_layout(bytes) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
+function file_len_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.file_len_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 forget_local_file(url) {
+  const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.forget_local_file(ptr0, len0);
+  return ret !== 0;
+}
 function graph_names(bytes) {
   let deferred3_0;
   let deferred3_1;
@@ -1101,6 +1647,10 @@ function header_ranges(head) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
+function heap_bytes() {
+  const ret = wasm.heap_bytes();
+  return ret;
+}
 function info(bytes) {
   let deferred3_0;
   let deferred3_1;
@@ -1406,6 +1956,14 @@ function reason_url(url, graph) {
     wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
   }
 }
+function register_local_file(url, blob) {
+  const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.register_local_file(ptr0, len0, blob);
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
 function schema(bytes) {
   let deferred3_0;
   let deferred3_1;
@@ -1621,6 +2179,20 @@ function text_search(bytes, words, contains_prefix, limit) {
     wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
   }
 }
+function validate_card(card_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(card_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_card(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);
+  }
+}
 function why_triples(bytes, subject, predicate, object) {
   let deferred6_0;
   let deferred6_1;
@@ -1740,6 +2312,11 @@ function __wbg_get_imports() {
     __wbg_error_78ff5b3a29b770e0: function(arg0) {
       console.error(arg0);
     },
+    __wbg_getRandomValues_3f44b700395062e5: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
     __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
       return handleError(function(arg0, arg1) {
         arg0.getRandomValues(arg1);
@@ -1782,6 +2359,16 @@ function __wbg_get_imports() {
       const ret = new Uint8Array(arg0);
       return ret;
     },
+    __wbg_new_a1b9f645bba64f0f: function() {
+      return handleError(function() {
+        const ret = new FileReaderSync();
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_d90091b82fdf5b91: function() {
+      const ret = new Array();
+      return ret;
+    },
     __wbg_new_with_length_36a4998e27b014c5: function(arg0) {
       const ret = new Uint8Array(arg0 >>> 0);
       return ret;
@@ -1806,11 +2393,21 @@ function __wbg_get_imports() {
     __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
       Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     },
+    __wbg_push_a6822215aa43e71c: function(arg0, arg1) {
+      const ret = arg0.push(arg1);
+      return ret;
+    },
     __wbg_randomFillSync_6c25eac9869eb53c: function() {
       return handleError(function(arg0, arg1) {
         arg0.randomFillSync(arg1);
       }, arguments);
     },
+    __wbg_readAsArrayBuffer_f1b8da05559618d9: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.readAsArrayBuffer(arg1);
+        return ret;
+      }, arguments);
+    },
     __wbg_require_b4edbdcf3e2a1ef0: function() {
       return handleError(function() {
         const ret = module.require;
@@ -1853,6 +2450,16 @@ function __wbg_get_imports() {
     __wbg_set_responseType_cfb49ea8269f8317: function(arg0, arg1) {
       arg0.responseType = __wbindgen_enum_XmlHttpRequestResponseType[arg1];
     },
+    __wbg_size_9970092b88b1094c: function(arg0) {
+      const ret = arg0.size;
+      return ret;
+    },
+    __wbg_slice_02bb778501725738: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.slice(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
     __wbg_static_accessor_GLOBAL_9d53f2689e622ca1: function() {
       const ret = typeof global === "undefined" ? null : global;
       return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1914,6 +2521,9 @@ var __wbindgen_enum_XmlHttpRequestResponseType = ["", "arraybuffer", "blob", "do
 var GraphFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_graph_free(ptr, 1));
+var QuadCursorFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_quadcursor_free(ptr, 1));
 var RemoteGraphFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_remotegraph_free(ptr, 1));
@@ -1978,6 +2588,16 @@ ${val.stack}`;
   }
   return className;
 }
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+  }
+  wasm.__externref_drop_slice(ptr, len);
+  return result;
+}
 function getArrayU8FromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -2224,20 +2844,20 @@ var Quad = class {
   }
 };
 function toRdfjs(t) {
-  const term = t instanceof Term ? t : Term.parse(t);
-  switch (term.kind) {
+  const term2 = t instanceof Term ? t : Term.parse(t);
+  switch (term2.kind) {
     case "iri":
-      return new NamedNode(term.value);
+      return new NamedNode(term2.value);
     case "bnode":
-      return new BlankNode(term.value.replace(/^_:/, ""));
+      return new BlankNode(term2.value.replace(/^_:/, ""));
     case "triple": {
-      const [s, p, o] = splitQuoted(term.value);
+      const [s, p, o] = splitQuoted(term2.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);
+      if (term2.lang) return new Literal(term2.value, term2.lang);
+      if (term2.datatype) return new Literal(term2.value, new NamedNode(term2.datatype));
+      return new Literal(term2.value);
   }
 }
 function splitQuoted(token) {
@@ -2271,18 +2891,18 @@ function splitQuoted(token) {
   return parts.map((p) => p.trim()).filter(Boolean);
 }
 var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
-function toN3(term) {
-  switch (term.termType) {
+function toN3(term2) {
+  switch (term2.termType) {
     case "NamedNode":
-      return `<${term.value}>`;
+      return `<${term2.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;
+      const dt = term2.language || !term2.datatype || term2.datatype.value === XSD_STRING ? null : term2.datatype.value;
+      return new Term("literal", term2.value, dt, term2.language || null).n3;
     }
     case "Quad":
-      return `<< ${toN3(term.subject)} ${toN3(term.predicate)} ${toN3(term.object)} >>`;
+      return `<< ${toN3(term2.subject)} ${toN3(term2.predicate)} ${toN3(term2.object)} >>`;
     default:
-      throw new TypeError(`cannot serialize ${term.termType} into a pattern`);
+      throw new TypeError(`cannot serialize ${term2.termType} into a pattern`);
   }
 }
 var isVarish = (t) => t == null || t.termType === "Variable";
@@ -2360,7 +2980,7 @@ var ReteSource = class {
     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 wantBnode = (term2) => term2 != null && term2.termType === "BlankNode" ? `_:${term2.value}` : null;
     const wantS = wantBnode(subject), wantO = wantBnode(object);
     const free = {
       s: isVarish(subject) || subject.termType === "BlankNode",
@@ -2419,6 +3039,7 @@ var ReteSource = class {
 };
 
 // src/index.js
+var DUMP_BATCH = 1e4;
 var XSD = "http://www.w3.org/2001/XMLSchema#";
 var INT_TYPES = new Set(
   [
@@ -2526,6 +3147,14 @@ function parseLiteral(token) {
   return new Term("literal", lex);
 }
 var cleanIri = (token) => Term.parse(token).value;
+function term(value, what) {
+  if (value === void 0 || value === null) return "";
+  if (value instanceof Term) return value.n3;
+  if (typeof value !== "string")
+    throw new TypeError(`the \`${what}\` option takes an IRI string, a Term, null, or undefined`);
+  if (value.startsWith("<") || value.startsWith('"') || value.startsWith("_:")) return value;
+  return `<${value}>`;
+}
 var embeddedWasm = null;
 var ready = null;
 function __setWasmSource(bytes) {
@@ -2533,10 +3162,15 @@ function __setWasmSource(bytes) {
 }
 function init(source = null) {
   ready ??= (async () => {
+    const node = typeof process !== "undefined" && !!process.versions?.node;
+    if (node && typeof globalThis.crypto?.getRandomValues !== "function") {
+      const { webcrypto } = await import("node:crypto");
+      Object.defineProperty(globalThis, "crypto", { value: webcrypto, configurable: true });
+    }
     const src = source ?? embeddedWasm;
     if (src) {
       await __wbg_init({ module_or_path: src });
-    } else if (typeof process !== "undefined" && process.versions?.node) {
+    } else if (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 });
@@ -2549,15 +3183,34 @@ function init(source = null) {
 var Graph2 = class {
   #g;
   #remote;
+  #warnings = [];
   constructor(inner, source, remote) {
     this.#g = inner;
     this.source = source;
     this.#remote = remote;
   }
-  /** The engine's raw JSON result envelope. */
+  /**
+   * The engine's raw JSON result envelope. Carries a `warnings` array when the
+   * query raised type errors (see {@link Graph#lastWarnings}).
+   */
   queryRaw(query2, { reason: reason2 = false } = {}) {
+    this.#warnings = [];
     const s = reason2 ? this.#g.query_reasoned(query2, "json") : this.#g.query(query2, "json");
-    return JSON.parse(s);
+    const env = JSON.parse(s);
+    this.#warnings = env.warnings ?? [];
+    return env;
+  }
+  /**
+   * Diagnostics from the most recent `query()` / `queryRaw()` on this graph:
+   * the SPARQL type errors a FILTER silently turned into `false` (CONTAINS on
+   * an IRI, STRSTARTS on a number, a language-tag mismatch, an invalid regex,
+   * …), each `{severity, function, argument, argKind, count, sample, hint,
+   * message}`, plus an optional case-sensitivity hint (`severity: "hint"`) for
+   * an empty result. Empty when there is nothing to report. Results themselves
+   * are never changed.
+   */
+  lastWarnings() {
+    return this.#warnings.map((w) => ({ ...w }));
   }
   /**
    * Run a SPARQL query: SELECT → array of `{var: Term}` rows, ASK → boolean,
@@ -2612,7 +3265,11 @@ var Graph2 = class {
    */
   card() {
     const s = this.#g.card();
-    return s ? JSON.parse(s) : null;
+    if (!s) return null;
+    const card2 = JSON.parse(s);
+    if (!card2.signals || typeof card2.signals !== "object") card2.signals = {};
+    card2.signals.quoted_triples = JSON.parse(this.#g.quoted_triples_signal());
+    return card2;
   }
   /**
    * The example SPARQL queries the file ships with. Rich entries carry
@@ -2638,6 +3295,146 @@ var Graph2 = class {
   get quads() {
     return this.info().quads;
   }
+  // -------------------------------------------------------------------------
+  // Streaming dump. See DUMP_BATCH for why this crosses the wasm boundary in
+  // batches rather than one quad — or one whole graph — at a time.
+  /**
+   * Every quad of the graph, streamed lazily:
+   * `for await (const [s, p, o, g] of graph.dump())`.
+   *
+   * (Named `dump()`, not `quads()`, because `graph.quads` is already this
+   * client's quad **count** — the engine calls the streaming scan a dump too.)
+   *
+   * `g` is the graph Term, or `null` for the default graph. Nothing is ever
+   * materialized: the engine decodes one triple per step and the wrapper holds
+   * at most `batch` of them, so this runs in memory independent of the graph's
+   * size — a billion-quad file streams in the same footprint as a thousand.
+   *
+   * Options:
+   * - `graph`: omit (or `undefined`) for the default graph **followed by every
+   *   named graph**; `null` for the default graph only; an IRI string for that
+   *   named graph only.
+   * - `raw: true` yields the engine's N-Triples term tokens (`"<urn:a>"`,
+   *   `'"x"@en'`) instead of `Term` objects — no per-term parsing, for when you
+   *   are re-serializing rather than inspecting.
+   * - `batch`: quads fetched per wasm call (default 10 000).
+   */
+  async *dump({ graph, subject, predicate, object, raw = false, batch = DUMP_BATCH } = {}) {
+    const cursor = this.#cursor({ graph, subject, predicate, object });
+    try {
+      for (; ; ) {
+        const flat = cursor.next_batch(batch);
+        if (flat.length === 0) return;
+        for (let i = 0; i < flat.length; i += 4) {
+          const g = flat[i + 3];
+          yield raw ? [flat[i], flat[i + 1], flat[i + 2], g === "" ? null : g] : [
+            Term.parse(flat[i]),
+            Term.parse(flat[i + 1]),
+            Term.parse(flat[i + 2]),
+            g === "" ? null : Term.parse(g)
+          ];
+        }
+      }
+    } finally {
+      cursor.free();
+    }
+  }
+  /**
+   * The graph as N-Quads text, in chunks — the constant-memory serialization
+   * path. Each chunk is a batch's worth of complete lines (`\n`-terminated), so
+   * chunks can be concatenated or written straight through:
+   *
+   * ```js
+   * for await (const chunk of graph.nquads()) out.write(chunk);
+   * ```
+   *
+   * Terms are already canonical N-Triples tokens inside the file, so the engine
+   * emits the lines directly: one string per batch crosses the wasm boundary
+   * instead of four per quad, and nothing is re-serialized in JavaScript.
+   * Takes the same `graph` / `batch` options as {@link dump}.
+   *
+   * `quotedTripleSyntax` is how a quoted triple is spelled, with the values and
+   * default of `rete export --quoted-triple-syntax`: `"rdf12"` (default) writes
+   * the RDF 1.2 triple term `<<( s p o )>>`, which current parsers (Oxigraph
+   * 0.5, Jena 5) load; `"rdf-star"` writes rete's stored `<<s p o>>`. RDF 1.2
+   * has no triple term in subject position, so such a statement makes the
+   * stream throw under `"rdf12"` (chunks already yielded stay yielded). A graph
+   * with no quoted triples is written byte-for-byte the same either way.
+   */
+  async *nquads({
+    graph,
+    subject,
+    predicate,
+    object,
+    batch = DUMP_BATCH,
+    quotedTripleSyntax = "rdf12"
+  } = {}) {
+    const cursor = this.#cursor({ graph, subject, predicate, object });
+    try {
+      cursor.set_quoted_triple_syntax(quotedTripleSyntax);
+      for (; ; ) {
+        const chunk = cursor.next_nquads(batch);
+        if (chunk.length === 0) return;
+        yield chunk;
+      }
+    } finally {
+      cursor.free();
+    }
+  }
+  /**
+   * Write the whole graph as N-Quads into `sink`, and return the byte length
+   * written. `sink` may be a Node `Writable`, a WHATWG `WritableStream`, or any
+   * function taking a string chunk — so:
+   *
+   * ```js
+   * await graph.writeNQuads(createWriteStream("out.nq"));   // Node
+   * const parts = []; await graph.writeNQuads((c) => parts.push(c));
+   * ```
+   *
+   * Memory stays flat: one batch of text is live at a time, and backpressure is
+   * honored on both stream kinds.
+   */
+  async writeNQuads(sink, options = {}) {
+    const write = sinkWriter(sink);
+    let bytes = 0;
+    for await (const chunk of this.nquads(options)) {
+      bytes += chunk.length;
+      await write(chunk);
+    }
+    await write(null);
+    return bytes;
+  }
+  /**
+   * The whole graph as ONE N-Quads string — the ready-to-load form for
+   * `store.load(text, {format: "application/n-quads"})` (Oxigraph, N3.js, …).
+   *
+   * Unlike {@link nquads} this necessarily holds the entire serialization in
+   * memory, so it is for graphs you are willing to materialize; stream with
+   * {@link nquads} / {@link writeNQuads} for anything large.
+   */
+  async toNQuads(options = {}) {
+    const parts = [];
+    for await (const chunk of this.nquads(options)) parts.push(chunk);
+    return parts.join("");
+  }
+  /**
+   * Open an engine-side cursor for the `graph` / `subject` / `predicate` /
+   * `object` options of the dump methods.
+   *
+   * The three term filters are not a row test the wrapper applies — they go into
+   * the engine's scan as a triple pattern, which routes to one permutation and
+   * drops every index tile whose synopsis proves it cannot match *before*
+   * fetching it. That is what makes a filtered dump of a remote graph cost the
+   * slice rather than the graph.
+   */
+  #cursor({ graph, subject, predicate, object }) {
+    let slot;
+    if (graph === void 0) slot = void 0;
+    else if (graph === null) slot = "";
+    else if (typeof graph === "string") slot = graph;
+    else throw new TypeError("the `graph` option takes an IRI string, null, or undefined");
+    return this.#g.quads(slot, term(subject, "subject"), term(predicate, "predicate"), term(object, "object"));
+  }
   graphNames() {
     return JSON.parse(this.#g.graph_names()).map(cleanIri);
   }
@@ -2650,6 +3447,25 @@ var Graph2 = class {
     return this.#remote ? this.#g.content_hash() : null;
   }
 };
+function sinkWriter(sink) {
+  if (typeof sink === "function") return async (chunk) => chunk === null ? void 0 : sink(chunk);
+  if (typeof sink?.getWriter === "function") {
+    const writer = sink.getWriter();
+    return async (chunk) => {
+      if (chunk === null) return writer.releaseLock();
+      await writer.ready;
+      return writer.write(chunk);
+    };
+  }
+  if (typeof sink?.write === "function") {
+    return async (chunk) => {
+      if (chunk === null) return void 0;
+      if (sink.write(chunk) === false)
+        await new Promise((resolve) => sink.once("drain", resolve));
+    };
+  }
+  throw new TypeError("writeNQuads() takes a Writable, a WritableStream, or a function(chunk)");
+}
 var isBytes = (s) => s instanceof Uint8Array || s instanceof ArrayBuffer || ArrayBuffer.isView(s);
 async function open(source, { headers } = {}) {
   await init();
@@ -2680,9 +3496,12 @@ async function open(source, { headers } = {}) {
   }
   throw new TypeError("open() takes a Uint8Array/ArrayBuffer or an http(s):// URL");
 }
-async function build2(text, format = "nt") {
+async function build2(text, format = "nt", { quotedTripleSyntax = "rdf-star" } = {}) {
   await init();
-  return build(text, format);
+  return build_with_card_syntax(text, format, "", quotedTripleSyntax);
+}
+function heapBytes() {
+  return heap_bytes();
 }
 export {
   Graph2 as Graph,
@@ -2690,6 +3509,7 @@ export {
   Term,
   __setWasmSource,
   build2 as build,
+  heapBytes,
   init,
   open,
   rete_wasm_exports as wasm