@factoidal/core 0.10.0 → 0.11.0

package/lib/api.mjs

@@ -22,66 +22,36 @@
 // JSDoc note "entry_jsoo.ml's X" below names that lineage. The Lean op of
 // the same name serves X now (formal/lean4/Wasm/Dispatch.lean lists them).
 
-import { dataFactory, termFromSrj, quadToNQuads } from '../rdfjs.mjs';
+import { dataFactory, termFromSrj, termToJson, quadToJson, _setTextEngine } from '../rdfjs.mjs';
 import { Dataset, INTERNAL, checkOptions, makeRegistry, WRITER_TAGS } from './dataset.mjs';
 import { version as packageVersion } from './version.mjs';
 import { openGeneration, readRegion, manifestKeys, hexOfBytes } from './store.mjs';
 import { fullEngineMessage } from './lean-entry.mjs';
 import { memoryDeltaLogStore } from './delta-log-hosts.mjs';
 
-const DATA_FORMAT_EXT = {
-  turtle:    'ttl',
-  ttl:       'ttl',
-  ntriples:  'nt',
-  nt:        'nt',
-  nquads:    'nq',
-  nq:        'nq',
-  trig:      'trig',
-  rdfxml:    'rdf',
-  'rdf-xml': 'rdf',
-  rdf:       'rdf',
-  jsonld:    'jsonld',
-  'json-ld': 'jsonld',
-  // RDF 1.2 opt-in: these select the engine's RDF 1.2 parsers (triple
-  // terms <<( s p o )>>, ~ reifiers, {| |} annotations, VERSION,
-  // directional literals "x"@lang--dir; Wasm/Ops/Parse.lean's
-  // `Mode.rdf12`); the plain names above stay RDF 1.1.
-  turtle12:   'ttl12',
-  ttl12:      'ttl12',
-  ntriples12: 'nt12',
-  nt12:       'nt12',
-  nquads12:   'nq12',
-  nq12:       'nq12',
-  trig12:     'trig12',
-};
-
-// Canonical format tag for the engine's parse ops (parseToDatasetJson,
-// datasetOpen); the *12 tags select the RDF 1.2 mode.
-const DATA_FORMAT_TAG = {
-  ttl: 'turtle', nt: 'ntriples', nq: 'nquads', trig: 'trig', rdf: 'rdfxml',
-  jsonld: 'jsonld',
-  ttl12: 'turtle12', nt12: 'ntriples12', nq12: 'nquads12', trig12: 'trig12',
-};
-
-const ENTAIL_VALUES = new Set(['none', 'RDFS', 'OWL-RL', 'x-rdfscore', 'x-rdfsplus']);
-
-// queryRaw's options (op queryRaw, Wasm/Ops/QueryExtras.lean).
-const RAW_OUTPUT_FORMATS = new Set(['json', 'csv', 'tsv', 'xml', 'table', 'ntriples']);
-const RAW_DATA_FORMATS = {
-  turtle: 'turtle', ttl: 'turtle', ntriples: 'ntriples', nt: 'ntriples',
-  nquads: 'nquads', nq: 'nquads', trig: 'trig', rdfxml: 'rdfxml',
-  'rdf-xml': 'rdfxml', rdf: 'rdfxml',
-};
+// The format names, regimes and query outputs are the engine's tables (op
+// engineTables, formal/lean4/Wasm/Ops/Handles.lean), read once per engine:
+// no host copy (https://github.com/danbri/factoidal/issues/894 item 5).
 
-function extForFormat(fmt) {
+// The parse tag a format name selects, from the engine's table.
+function parseTagOf(tables, fmt) {
   const key = String(fmt || 'turtle').toLowerCase();
-  if (!(key in DATA_FORMAT_EXT)) {
+  const tag = tables.parseFormats[key];
+  if (tag === undefined) {
     throw new TypeError(
-      `Unknown format '${fmt}'. Expected one of: ` +
-      Object.keys(DATA_FORMAT_EXT).join(', ')
-    );
+      `Unknown format '${fmt}'. Expected one of: ` + Object.keys(tables.parseFormats).join(', '));
   }
-  return DATA_FORMAT_EXT[key];
+  return tag;
+}
+
+// The engine's refusal of a regime name (table refusedRegimePrefixes), or null.
+function iklRefusalOf(tables, who, regime) {
+  if (regime == null) return null;
+  const r = String(regime);
+  for (const [prefix, message] of Object.entries(tables.refusedRegimePrefixes)) {
+    if (r.toLowerCase().startsWith(prefix)) return message.replace('WHO', who).replace('REGIME', r);
+  }
+  return null;
 }
 
 // Where a function takes an options object, a bare string names the
@@ -114,16 +84,13 @@ function missingOpError(what, e, op) {
     'current build.');
 }
 
-// Detect the query form for result-shape dispatch. IRIs and comments
-// are blanked first so '#' inside a PREFIX IRI cannot hide the verb.
-// The engine's SPARQL parser remains the authority — this only picks
-// the output shape.
-function sniffQueryForm(sparql) {
-  const cleaned = String(sparql)
-    .replace(/<[^>]*>/g, ' ')
-    .replace(/#[^\n]*/g, ' ');
-  const m = cleaned.match(/\b(select|ask|construct|describe)\b/i);
-  return m ? m[1].toLowerCase() : 'select';
+// The query form, from the engine's SPARQL parser (op queryForm). A query
+// the parser rejects answers 'select'; the query op then reports the parse
+// error itself.
+function queryFormOf(e, sparql) {
+  if (typeof e.queryForm !== 'function') return 'select';
+  const r = JSON.parse(e.queryForm(String(sparql)));
+  return r.ok ? r.kind : 'select';
 }
 
 // Bytes for an op that reads the byte region (queryHdt, storeOpen): a
@@ -585,15 +552,16 @@ function buildApi(driver) {
     return out;
   }
 
-  // A ShEx focus/shape-label argument is either a raw string (an IRI,
-  // or "_:label" for a blank node -- the entry ABI's own convention)
-  // or an RDF/JS term (NamedNode/BlankNode); accepting both lets a
-  // caller pass a term straight out of a query() binding.
+  // A ShEx focus/shape-label argument is a string in N-Triples term syntax
+  // ("<http://...>" or "_:label"), which the engine reads with its one
+  // term-string reader, or an RDF/JS term (NamedNode/BlankNode); accepting
+  // both lets a caller pass a term straight out of a query() binding.
   function shexTermToString(t, who) {
-    if (typeof t === 'string') return t;
+    if (typeof t === 'string') return JSON.stringify(termToJson(t));
     if (t && typeof t.termType === 'string') {
-      if (t.termType === 'BlankNode') return `_:${t.value}`;
-      if (t.termType === 'NamedNode') return t.value;
+      if (t.termType === 'BlankNode' || t.termType === 'NamedNode') {
+        return JSON.stringify(termToJson(t)); // the engine writes the node
+      }
       throw new TypeError(`${who}: expected an IRI or blank node term`);
     }
     throw new TypeError(`${who}: expected a string or an RDF/JS term`);
@@ -613,9 +581,19 @@ function buildApi(driver) {
   async function ctx() {
     const e = await entry();
     if (ctxCache && ctxCache.e === e) return ctxCache;
+    let tablesCache = null;
     const c = {
       e,
       registry,
+      tables() {
+        if (!tablesCache) {
+          requireEntryFn(e, 'engineTables', 'format and regime tables');
+          tablesCache = entryResult(e.engineTables(), 'engineTables').tables;
+          for (const k of Object.keys(WRITER_TAGS)) delete WRITER_TAGS[k];
+          Object.assign(WRITER_TAGS, tablesCache.writerFormats);
+        }
+        return tablesCache;
+      },
       missing: (what, op) => missingOpError(what, e, op),
       wrap(r, prefixes, extra) {
         const { ok: _ok, handle, count, prefixes: own, ...info } = r;
@@ -638,16 +616,34 @@ function buildApi(driver) {
       async closure(ds, regime) { return closureOnHandle(c, ds, regime); },
     };
     ctxCache = c;
+    installTextEngine(e);
     return c;
   }
 
+  // rdfjs.mjs's N-Quads text functions (nquadsToQuads, quadsToNQuads,
+  // termToNQuads, DatasetCore.fromNQuads/toNQuads) call these engine ops.
+  function installTextEngine(e) {
+    if (typeof e.parseQuadsJson !== 'function') return;
+    _setTextEngine({
+      parseQuads(text) {
+        return parseResult(e.parseQuadsJson(text, 'nquads12', ''), 'nquadsToQuads', text).quads;
+      },
+      writeQuads(quadsJson) {
+        return entryResult(e.quadsToNQuads(JSON.stringify(quadsJson)), 'quadsToNQuads').nquads;
+      },
+      termTokens(termsJson) {
+        return entryResult(e.termsToNTriples(JSON.stringify(termsJson)), 'termToNQuads').tokens;
+      },
+    });
+  }
+
   // The parse tag of `format`, or the engine's inference when it is omitted.
   function formatTagOf(c, text, format, who) {
     if (format === undefined || format === null || format === '') {
       requireEntryFn(c.e, 'detectFormat', `${who} (format inference)`);
       return { tag: entryResult(c.e.detectFormat(text), who).format, inferred: true };
     }
-    return { tag: DATA_FORMAT_TAG[extForFormat(format)], inferred: false };
+    return { tag: parseTagOf(c.tables(), format), inferred: false };
   }
 
   // Open `text` as a Dataset. A parse error names the format and says
@@ -714,17 +710,11 @@ function buildApi(driver) {
   async function queryDatasetHandle(c, ds, sparql, opts) {
     if (typeof sparql !== 'string') throw new TypeError('query: sparql must be a string');
     const entail = opts.entail || 'none';
-    if (/^x-ikl/i.test(entail)) {
-      throw new TypeError(
-        `query: entail '${entail}' is not implemented. The x-ikl-* ` +
-        "entailment regimes are the owner's design " +
-        "(danbri/factoidal#581); the Lean engine's dispatch for them " +
-        'was deleted on 2026-08-26 as collateral of the IKL-to-RDF ' +
-        'projection purge (danbri/factoidal#626). This is not a ' +
-        'policy exclusion.');
-    }
-    if (!ENTAIL_VALUES.has(entail)) {
-      throw new TypeError(`query: entail must be one of ${[...ENTAIL_VALUES].join(', ')}`);
+    const tables = c.tables();
+    const ikl = iklRefusalOf(tables, 'query', entail);
+    if (ikl) throw new TypeError(ikl);
+    if (!tables.entailRegimes.includes(entail)) {
+      throw new TypeError(`query: entail must be one of ${tables.entailRegimes.join(', ')}`);
     }
     if (opts.version !== undefined && !['1.1', '1.2'].includes(String(opts.version))) {
       throw new TypeError("query: version must be '1.1' or '1.2'");
@@ -739,10 +729,10 @@ function buildApi(driver) {
           "query: entail/output and SPARQL 1.2 cannot be combined; that path reads SPARQL 1.1");
       }
       const output = opts.output || 'json';
-      if (!RAW_OUTPUT_FORMATS.has(output)) {
-        throw new TypeError(`query: output must be one of ${[...RAW_OUTPUT_FORMATS].join(', ')}`);
+      if (!tables.queryOutputs.includes(output)) {
+        throw new TypeError(`query: output must be one of ${tables.queryOutputs.join(', ')}`);
       }
-      const form = sniffQueryForm(sparql);
+      const form = queryFormOf(e, sparql);
       const graphForm = form === 'construct' || form === 'describe';
       requireEntryFn(e, 'datasetQueryRaw', `query {entail/output}`);
       if (opts.output === undefined) {
@@ -791,14 +781,8 @@ function buildApi(driver) {
       c.e.datasetShexValidate(ds.handle, schema, focusStr, shapeStr), 'shexValidate').verdict;
   }
 
-  const CLOSURE_REGIMES = {
-    rdfs: 'rdfs', 'owl-rl': 'owl-rl', owlrl: 'owl-rl', owl_rl: 'owl-rl',
-    'rho-df': 'rho-df', rhodf: 'rho-df', 'core-rdfs': 'rho-df',
-    'rdfs-plus': 'rdfs-plus', rdfsplus: 'rdfs-plus',
-  };
-
   async function closureOnHandle(c, ds, regime) {
-    const r0 = CLOSURE_REGIMES[String(regime || '').toLowerCase()];
+    const r0 = c.tables().closureAliases[String(regime || '').toLowerCase()];
     if (!r0) {
       throw new TypeError(
         `closure: regime must be one of rdfs, owl-rl, rho-df, rdfs-plus (got '${regime}')`);
@@ -892,15 +876,11 @@ function buildApi(driver) {
     if (typeof sparql !== 'string') {
       throw new TypeError('queryHdt: sparql must be a string');
     }
-    const form = sniffQueryForm(sparql);
-    if (form === 'construct' || form === 'describe') {
-      throw new TypeError(
-        `queryHdt: ${form.toUpperCase()} is not supported over an HDT file (SELECT/ASK only)`);
-    }
     const e = await entry();
     requireEntryFn(e, 'queryHdt', 'queryHdt');
     const r = entryResult(e.queryHdt(bytesToUint8Array(hdtBytes, 'queryHdt'), sparql), 'queryHdt');
     if (r.kind === 'ask') return r.boolean;
+    if (r.kind === 'construct' || r.kind === 'describe') return (await ctx()).fromNQuads(r.nquads, {});
     return bindingsFromSrj(r.srj);
   }
 
@@ -942,9 +922,10 @@ function buildApi(driver) {
       ['format', 'version', 'prefixes', 'literalShorthand', 'useNativeTypes',
         'useRdfType', 'rdfDirection', 'inputFormat', 'baseIRI']);
     const { inputFormat, baseIRI, ...writeOpts } = opts;
-    if (writeOpts.format !== undefined && !WRITER_TAGS[String(writeOpts.format).toLowerCase()]) {
+    const writerTags = (await ctx()).tables().writerFormats;
+    if (writeOpts.format !== undefined && !writerTags[String(writeOpts.format).toLowerCase()]) {
       throw new TypeError(`serialize: unknown format '${writeOpts.format}'. Known formats: ` +
-        [...new Set(Object.values(WRITER_TAGS))].join(', '));
+        [...new Set(Object.values(writerTags))].join(', '));
     }
     return withDataset(data, { format: inputFormat, baseIRI }, 'serialize',
       (_c, ds) => ds.serialize(writeOpts));
@@ -965,24 +946,24 @@ function buildApi(driver) {
    * The named graphs of a Dataset, each as a Dataset (default graph
    * excluded, first-seen order).
    * @param {Dataset} dataset
-   * @returns {Array<[iri: string, graph: Dataset]>}
+   * @returns {Array<[name: NamedNode|BlankNode, graph: Dataset]>}
    */
   function graphs(dataset) {
     if (!(dataset instanceof Dataset)) throw new TypeError('graphs: expected a Dataset');
-    const seen = new Map();
-    for (const q of dataset) {
-      const g = q.graph;
-      if (!g || g.termType === 'DefaultGraph') continue;
-      if (!seen.has(g.value)) seen.set(g.value, g);
-    }
-    const out = [];
-    for (const [iri, gTerm] of seen) out.push([iri, dataset.match(null, null, null, gTerm)]);
-    return out;
+    dataset.size; // throws the disposed error
+    const c = dataset._ctx;
+    requireEntryFn(c.e, 'datasetGraphNames', 'graphs');
+    const names = entryResult(c.e.datasetGraphNames(dataset.handle), 'graphs').graphs;
+    return names.map((g) => {
+      const term = termFromSrj(g);
+      return [term, dataset.match(null, null, null, term)];
+    });
   }
 
   /**
    * RDFC-1.0 canonical N-Quads of one graph: every quad's graph name is
-   * dropped first. Text, not a digest.
+   * dropped first (op datasetGraphAsDefault with the union of the graphs).
+   * Text, not a digest.
    * @param {Dataset} datasetOrGraph
    * @returns {Promise<string>}
    */
@@ -990,9 +971,59 @@ function buildApi(driver) {
     if (!(datasetOrGraph instanceof Dataset)) {
       throw new TypeError('canonicalHash: expected a Dataset (e.g. one entry of graphs())');
     }
-    const asDefault = datasetOrGraph.toArray()
-      .map((q) => quadToNQuads(dataFactory.quad(q.subject, q.predicate, q.object))).join('');
-    return canonicalize(asDefault, { format: 'nquads' });
+    datasetOrGraph.size; // throws the disposed error
+    const c = datasetOrGraph._ctx;
+    requireEntryFn(c.e, 'datasetGraphAsDefault', 'canonicalHash');
+    const merged = c.wrap(entryResult(c.e.datasetGraphAsDefault(datasetOrGraph.handle,
+      JSON.stringify({ type: 'union' })), 'canonicalHash'), {});
+    try {
+      return merged.toString('rdfc');
+    } finally {
+      merged.dispose();
+    }
+  }
+
+  /**
+   * Whether two datasets are isomorphic (RDF 1.1 Concepts 3.6 and 4; blank
+   * nodes inside RDF 1.2 triple terms included): the engine's
+   * Dataset.isomorphicOutcome (op datasetIsomorphic). Rejects when the
+   * blank-node search budget is exceeded.
+   * @param {Dataset|string|Array} a
+   * @param {Dataset|string|Array} b
+   * @param {{format?: string, baseIRI?: string}} [options] read text arguments
+   * @returns {Promise<boolean>}
+   */
+  async function isomorphic(a, b, options) {
+    const opts = checkOptions('isomorphic', optionsOf('isomorphic', options), ['format', 'baseIRI']);
+    return withDataset(a, opts, 'isomorphic', (c, da) =>
+      withDataset(b, opts, 'isomorphic', (_c, db) => {
+        requireEntryFn(c.e, 'datasetIsomorphic', 'isomorphic');
+        return entryResult(c.e.datasetIsomorphic(da.handle, db.handle), 'isomorphic').isomorphic;
+      }));
+  }
+
+  /**
+   * A Dataset holding RDF/JS quads (op datasetFromQuadsJson). Each term is
+   * sent as its components; the engine reads no text.
+   * @param {Iterable<object>} quads
+   * @returns {Promise<Dataset>}
+   */
+  async function fromQuads(quads) {
+    const c = await ctx();
+    requireEntryFn(c.e, 'datasetFromQuadsJson', 'fromQuads');
+    const arr = [];
+    for (const q of quads) arr.push(quadToJson(q));
+    return c.wrap(entryResult(c.e.datasetFromQuadsJson(JSON.stringify(arr)), 'fromQuads'), {});
+  }
+
+  /** Load the engine; afterwards the N-Quads text functions of `@factoidal/core/rdfjs` work. */
+  async function ready() {
+    await ctx();
+  }
+
+  /** The engine's name tables (formats, regimes, query outputs, pack syntaxes). */
+  async function engineTables() {
+    return (await ctx()).tables();
   }
 
   // A wasm module older than this package can lack an op: `e[fnName]` is
@@ -1051,7 +1082,8 @@ function buildApi(driver) {
    */
   async function owlClosure(data, mode, options) {
     const m = String(mode || '').toLowerCase();
-    if (!['rdfs', 'owl-rl', 'owlrl', 'owl_rl'].includes(m)) {
+    const aliases = (await ctx()).tables().closureAliases;
+    if (!['rdfs', 'owl-rl'].includes(aliases[m])) {
       throw new TypeError(`owlClosure: mode must be 'RDFS' or 'OWL-RL' (got '${mode}')`);
     }
     return closure(data, m, options);
@@ -1984,19 +2016,20 @@ function buildApi(driver) {
     const dataFormat = String(opts.dataFormat || 'turtle').toLowerCase();
     const entail = opts.entail || 'none';
     const output = opts.output || 'json';
-    if (!(dataFormat in RAW_DATA_FORMATS)) {
+    const tables = (await ctx()).tables();
+    if (!(dataFormat in tables.rawDataFormats)) {
       throw new TypeError(`queryRaw: unknown dataFormat '${opts.dataFormat}'`);
     }
-    if (!ENTAIL_VALUES.has(entail)) {
-      throw new TypeError(`queryRaw: entail must be one of ${[...ENTAIL_VALUES].join(', ')}`);
+    if (!tables.entailRegimes.includes(entail)) {
+      throw new TypeError(`queryRaw: entail must be one of ${tables.entailRegimes.join(', ')}`);
     }
-    if (!RAW_OUTPUT_FORMATS.has(output)) {
-      throw new TypeError(`queryRaw: output must be one of ${[...RAW_OUTPUT_FORMATS].join(', ')}`);
+    if (!tables.queryOutputs.includes(output)) {
+      throw new TypeError(`queryRaw: output must be one of ${tables.queryOutputs.join(', ')}`);
     }
     const e = await entry();
     requireEntryFn(e, 'queryRaw', 'queryRaw');
     const r = JSON.parse(e.queryRaw(dataString, queryString,
-      JSON.stringify({ dataFormat: RAW_DATA_FORMATS[dataFormat], entail, output })));
+      JSON.stringify({ dataFormat: tables.rawDataFormats[dataFormat], entail, output })));
     if (!r.ok) {
       const err = new Error('SPARQL query failed: ' + r.error);
       err.stderr = String(r.error);
@@ -2280,6 +2313,10 @@ function buildApi(driver) {
     deltaLogDestroy,
     _deltaLogCorruptLastForTest,
     queryRaw,
+    isomorphic,
+    fromQuads,
+    ready,
+    engineTables,
     Dataset,
     DatasetHandle,
     Store,
@@ -2295,6 +2332,6 @@ function buildApi(driver) {
 }
 
 export {
-  buildApi, sniffQueryForm, bindingsFromSrj, entryResult, parseResult,
+  buildApi, bindingsFromSrj, entryResult, parseResult,
   utf16OffsetOf, missingOpError, ParseError, DatasetHandle, Store,
 };

package/lib/dataset.mjs

@@ -15,21 +15,16 @@
 // released by a FinalizationRegistry callback. Every method of a disposed
 // Dataset throws a TypeError that names the method.
 
-import { nquadsLineToQuad, quadToNQuads, termToNQuads, termFromSrj } from '../rdfjs.mjs';
+import { dataFactory, quadFromJson, quadToJson, termToJson, termFromSrj, Literal, NamedNode } from '../rdfjs.mjs';
 
 const INTERNAL = Symbol('factoidal.Dataset.internal');
 
-// Writer names (lower case) -> the engine's writer tag. JSON-LD is served
+// Writer names (lower case) -> the engine's writer tag: the engine's table
+// (op engineTables, `writerFormats`), read once per engine. JSON-LD is served
 // by the op datasetToJsonLd; the SPARQL results formats are query outputs.
-const WRITER_TAGS = {
-  nquads: 'nquads', nq: 'nquads', 'n-quads': 'nquads',
-  ntriples: 'ntriples', nt: 'ntriples', 'n-triples': 'ntriples',
-  turtle: 'turtle', ttl: 'turtle',
-  trig: 'trig',
-  rdfxml: 'rdfxml', 'rdf-xml': 'rdfxml', rdf: 'rdfxml',
-  jsonld: 'jsonld', 'json-ld': 'jsonld',
-  rdfc: 'rdfc', canonical: 'rdfc', 'rdfc-1.0': 'rdfc',
-};
+// `WRITER_TAGS` stays exported for callers that read it; it is filled from
+// the engine on the first Dataset.
+const WRITER_TAGS = {};
 
 const VERSIONS = { '1.1': '11', '1.2': '12' };
 
@@ -57,6 +52,84 @@ function envelope(jsonText, what) {
 const SERIALIZE_OPTIONS = ['format', 'version', 'prefixes', 'literalShorthand',
   'useNativeTypes', 'useRdfType', 'rdfDirection'];
 
+// The quads of the compact answer of datasetQuadsJson: each distinct term is
+// built once and shared (TermJson.compactCertified).
+function quadsFromCompact(terms, ixs) {
+  const ts = terms.map(termFromSrj);
+  const dg = dataFactory.defaultGraph();
+  return ixs.map((ix) => dataFactory.quad(ts[ix[0]], ts[ix[1]], ts[ix[2]],
+    ix.length > 3 ? ts[ix[3]] : dg));
+}
+
+// The region of op datasetQuadsBin, read as the engine wrote it
+// (formal/lean4/L4Factoidal/RDF/QuadsBin.lean: `binSpec` is the layout,
+// `decodeBin` the reader this function follows, `decodeBin_quadsBin` the
+// theorem that the region reads back as exactly the quads). Every number is a
+// u32 little-endian; each term is in the term codec of DLOG version 2, which
+// names the term kind, the datatype IRI, the language tag and the base
+// direction explicitly, so this function copies fields and decides nothing.
+const UTF8 = new TextDecoder('utf-8', { fatal: true });
+const DIRECTION = ['', 'ltr', 'rtl'];
+
+function quadsFromRegion(bytes, out) {
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length < 12 || v.getUint32(0, true) !== 0x31425146) {
+    throw new Error('iterate: the engine answered no datasetQuadsBin region');
+  }
+  const nTerms = v.getUint32(4, true);
+  const nQuads = v.getUint32(8, true);
+  let p = 12;
+  // UTF-8 bytes to a string; a short run of bytes below 0x80 (one UTF-16
+  // unit each) is copied without a TextDecoder call.
+  const str = () => {
+    const n = v.getUint32(p, true);
+    const a = p + 4;
+    p = a + n;
+    if (n <= 64) {
+      let i = a;
+      while (i < p && bytes[i] < 0x80) i++;
+      if (i === p) return String.fromCharCode.apply(null, bytes.subarray(a, p));
+    }
+    return UTF8.decode(bytes.subarray(a, p));
+  };
+  const datatypes = new Map();
+  const term = () => {
+    switch (bytes[p++]) {
+      case 0: return new NamedNode(str());
+      case 1: return dataFactory.blankNode(str());
+      case 2: {
+        const lexical = str();
+        const dt = str();
+        let datatype = datatypes.get(dt);
+        if (datatype === undefined) { datatype = new NamedNode(dt); datatypes.set(dt, datatype); }
+        const flag = bytes[p++];
+        const language = flag === 0 ? '' : str();
+        const direction = flag === 2 ? DIRECTION[bytes[p++]] : '';
+        return new Literal(lexical, language, datatype, direction);
+      }
+      case 3: {
+        const s = term();
+        const pr = term();
+        return dataFactory.quad(s, pr, term());
+      }
+      default: throw new Error('iterate: a term tag outside the DLOG version 2 codec');
+    }
+  };
+  const ts = new Array(nTerms);
+  for (let i = 0; i < nTerms; i++) ts[i] = term();
+  const dg = dataFactory.defaultGraph();
+  for (let i = 0; i < nQuads; i++, p += 16) {
+    const g = v.getUint32(p + 12, true);
+    out.push(dataFactory.quad(ts[v.getUint32(p, true)], ts[v.getUint32(p + 4, true)],
+      ts[v.getUint32(p + 8, true)], g === 0 ? dg : ts[g - 1]));
+  }
+  return nQuads;
+}
+
+// Quads of the first datasetQuadsBin call while iterating: an iteration that
+// stops early reads this many; the rest come in one more call.
+const FIRST_PAGE = 4096;
+
 class Dataset {
   /** @private Datasets come from parse(), csvwToRdf() and the other producers. */
   constructor(token, ctx, handle, size, prefixes, extra) {
@@ -214,11 +287,12 @@ class Dataset {
   _write(opts) {
     const e = this._ctx.e;
     const name = String(opts.format || 'nquads').toLowerCase();
-    const tag = WRITER_TAGS[name];
+    const writerTags = this._ctx.tables().writerFormats;
+    const tag = writerTags[name];
     if (!tag) {
       throw new TypeError(
         `Dataset.serialize: unknown format '${opts.format}'. Known formats: ` +
-        [...new Set(Object.values(WRITER_TAGS))].join(', '));
+        [...new Set(Object.values(writerTags))].join(', '));
     }
     let suffix = '';
     if (opts.version !== undefined) {
@@ -273,40 +347,58 @@ class Dataset {
   }
 
   /**
-   * RDF/JS quads, read from the engine's N-Quads text one line at a time.
+   * RDF/JS quads, built from the engine's term objects (op datasetQuadsJson),
+   * in the line order of toNQuads(). No N-Quads text is read here.
    * @returns {Iterator<object>}
    */
   *[Symbol.iterator]() {
     this._open('iterate');
     if (this._quads) { yield* this._quads; return; }
-    const text = this.toNQuads();
-    let start = 0;
-    let lineNo = 0;
-    while (start < text.length) {
-      let end = text.indexOf('\n', start);
-      if (end < 0) end = text.length;
-      lineNo += 1;
-      const line = text.slice(start, end);
-      start = end + 1;
-      const q = nquadsLineToQuad(line, lineNo);
-      if (q) yield q;
+    const e = this._ctx.e;
+    if (typeof e.datasetQuadsBin !== 'function') { yield* this._allQuads(); return; }
+    // The engine's region (op datasetQuadsBin) in two calls, a first page and
+    // the rest; the whole list is cached when the rest is read.
+    const acc = [];
+    const first = e.datasetQuadsBin(this._handle, `{"offset":0,"limit":${FIRST_PAGE}}`);
+    quadsFromRegion(first.bytes, acc);
+    for (let i = 0; i < acc.length; i++) yield acc[i];
+    if (acc.length < first.envelope.total) {
+      const rest = e.datasetQuadsBin(this._handle, `{"offset":${acc.length}}`);
+      const from = acc.length;
+      quadsFromRegion(rest.bytes, acc);
+      for (let i = from; i < acc.length; i++) yield acc[i];
+    }
+    if (!this._quads) this._quads = Object.freeze(acc);
+  }
+
+  // Every quad, read once and cached.
+  _allQuads() {
+    if (!this._quads) {
+      const e = this._ctx.e;
+      if (typeof e.datasetQuadsBin === 'function') {
+        const acc = [];
+        quadsFromRegion(e.datasetQuadsBin(this._handle, '').bytes, acc);
+        this._quads = Object.freeze(acc);
+      } else {
+        const r = envelope(e.datasetQuadsJson(this._handle, '{"compact":true}'), 'iterate');
+        this._quads = Object.freeze(r.ixs ? quadsFromCompact(r.terms, r.ixs) : r.quads.map((q) => quadFromJson(q)));
+      }
     }
+    return this._quads;
   }
 
   /** Every quad as an array. */
   toArray() {
     this._open('toArray');
-    if (!this._quads) this._quads = Object.freeze([...this]);
-    return this._quads.slice();
+    return this._allQuads().slice();
   }
 
   // A quad pattern for the ops datasetMatch and datasetMatchCount: four
-  // N-Triples term tokens, '' for an unbound position, 'DEFAULT' for the
-  // default graph.
+  // engine term objects, null for an unbound position, {type:'default'} for
+  // the default graph.
   _pattern(subject, predicate, object, graph) {
-    const tok = (t) => (t == null ? '' : termToNQuads(t));
-    const g = graph == null ? '' : (graph.termType === 'DefaultGraph' ? 'DEFAULT' : termToNQuads(graph));
-    return JSON.stringify([tok(subject), tok(predicate), tok(object), g]);
+    return JSON.stringify([termToJson(subject), termToJson(predicate), termToJson(object),
+      termToJson(graph)]);
   }
 
   /** RDF/JS DatasetCore.has: one indexed lookup in the engine. */
@@ -336,7 +428,8 @@ class Dataset {
    */
   add(quad) {
     this._open('add');
-    const r = envelope(this._ctx.e.datasetAddQuads(this._handle, quadToNQuads(quad)), 'add');
+    const r = envelope(this._ctx.e.datasetAddQuadsJson(this._handle,
+      JSON.stringify([quadToJson(quad)])), 'add');
     this._changed(r.count);
     return this;
   }
@@ -344,7 +437,8 @@ class Dataset {
   /** RDF/JS DatasetCore.delete: remove one quad. */
   delete(quad) {
     this._open('delete');
-    const r = envelope(this._ctx.e.datasetDeleteQuads(this._handle, quadToNQuads(quad)), 'delete');
+    const r = envelope(this._ctx.e.datasetDeleteQuadsJson(this._handle,
+      JSON.stringify([quadToJson(quad)])), 'delete');
     this._changed(r.count);
     return this;
   }