@factoidal/core 0.7.1 → 0.11.0

package/fn.js

@@ -1,7 +1,7 @@
 // factoidal/fn — a strictly functional dataset API.
 //
-// Every extracted engine operation is a value-to-value function (F*
-// has no mutation to expose); RDF/JS DatasetCore's add/delete is
+// Every engine operation is a value-to-value function (the Lean
+// library has no mutation to expose); RDF/JS DatasetCore's add/delete is
 // wrapper-side skeuomorphism on top of that. This module makes the JS
 // contract match the verified one: FnDataset is a frozen snapshot, all
 // operations are free functions that return new values, and content
@@ -25,9 +25,10 @@ const crypto = require('node:crypto');
 
 const engineApi = require('./index.js');
 const {
-  Dataset,
+  DatasetCore,
   dataFactory,
-  quadToNQuads,
+  quadKey,
+  termKey,
   quadsToNQuads,
 } = require('./rdfjs.js');
 
@@ -92,10 +93,34 @@ function arrayBackend(quads) {
     kind: 'array',
     size: quads.length,
     quads: () => quads,
+    engine: null,
     precomputedHash: null,
   };
 }
 
+// The engine backend (0.10.0, issue 882 of danbri/factoidal): the quads are
+// an engine Dataset (lib/dataset.mjs) that this module never changes. Every
+// engine operation takes that Dataset itself, so no N-Quads text crosses
+// between steps. The JS quad array is read once, on demand.
+function engineBackend(eds) {
+  let quads = null;
+  return {
+    kind: 'engine',
+    size: eds.size,
+    quads: () => (quads ||= Object.freeze(eds.toArray())),
+    engine: eds,
+    precomputedHash: null,
+  };
+}
+
+// An FnDataset over an engine Dataset this module made and never shares.
+function wrapEngine(eds) {
+  return new FnDataset(engineBackend(eds));
+}
+
+// ds (array-backed FnDataset) -> engine Dataset, opened once from its quads.
+const ENGINE_CACHE = new WeakMap();
+
 // Build a de-duplicated FnDataset from any iterable of RDF/JS quads.
 // Every public constructor path (fromDataset, union, difference,
 // filter, mapQuads, query's CONSTRUCT wrapping, builder().finish())
@@ -108,7 +133,7 @@ function makeFnDataset(quadsIterable) {
   const out = [];
   for (const q of quadsIterable) {
     const frozen = dataFactory.fromQuad(q); // normalizes + (re)freezes
-    const key = quadToNQuads(frozen);
+    const key = quadKey(frozen); // RDF/JS Term.equals identity, no syntax
     if (seen.has(key)) continue;
     seen.add(key);
     out.push(frozen);
@@ -147,14 +172,15 @@ class FnDataset {
   toNQuads() {
     let cached = NQUADS_CACHE.get(this);
     if (cached === undefined) {
-      cached = quadsToNQuads(this.toArray());
+      cached = this._backend.engine ? this._backend.engine.toNQuads() : quadsToNQuads(this.toArray());
       NQUADS_CACHE.set(this, cached);
     }
     return cached;
   }
 
-  /** Read-only quad-pattern match (RDF/JS DatasetCore shape), no engine call. */
+  /** Read-only quad-pattern match (RDF/JS DatasetCore shape); the engine's indexes for an engine-backed dataset. */
   match(subject, predicate, object, graph) {
+    if (this._backend.engine) return wrapEngine(this._backend.engine.match(subject, predicate, object, graph));
     return makeFnDataset(this.toArray().filter((q) =>
       (!subject || subject.equals(q.subject)) &&
       (!predicate || predicate.equals(q.predicate)) &&
@@ -170,18 +196,31 @@ const EMPTY = new FnDataset(arrayBackend(Object.freeze([])));
 // Interop with the mutable RDF/JS layer.
 // ---------------------------------------------------------------------
 
-/** Snapshot a (possibly mutable) RDF/JS Dataset into an FnDataset. */
+/** Snapshot a Dataset (the engine's, or an RDF/JS DatasetCore) into an FnDataset. */
 function fromDataset(dataset) {
-  if (!(dataset instanceof Dataset)) {
-    throw new TypeError('fromDataset: expected an RDF/JS Dataset');
+  if (dataset instanceof engineApi.Dataset) return wrapEngine(dataset.clone());
+  if (!(dataset instanceof DatasetCore)) {
+    throw new TypeError('fromDataset: expected a Dataset or an RDF/JS DatasetCore');
   }
   return makeFnDataset(dataset);
 }
 
-/** Materialize an FnDataset into a fresh, independently-mutable Dataset. */
+// The engine Dataset of an FnDataset: its own, or (for one built from JS
+// quads) one opened from its quads once and kept.
+async function engineOf(ds) {
+  if (ds._backend.engine) return ds._backend.engine;
+  let eds = ENGINE_CACHE.get(ds);
+  if (!eds) {
+    eds = await engineApi.fromQuads(ds.toArray());
+    ENGINE_CACHE.set(ds, eds);
+  }
+  return eds;
+}
+
+/** Materialize an FnDataset into a fresh, independently-mutable RDF/JS DatasetCore. */
 function toDataset(ds) {
   assertFnDataset(ds, 'toDataset');
-  return new Dataset(ds.toArray());
+  return new DatasetCore(ds.toArray());
 }
 
 // ---------------------------------------------------------------------
@@ -247,7 +286,7 @@ async function fromChunks(chunks) {
 
 /** Parse one RDF document into an FnDataset. Mirrors index.js's parse(). */
 async function parse(text, options) {
-  return fromDataset(await engineApi.parse(text, options));
+  return wrapEngine(await engineApi.parse(text, options));
 }
 
 /** Set union, first-seen order (a's quads, then b's not already present). */
@@ -259,8 +298,8 @@ function union(a, b) {
 /** Quads in a that are not in b. */
 function difference(a, b) {
   assertFnDataset(a, 'difference'); assertFnDataset(b, 'difference');
-  const bKeys = new Set(b.toArray().map(quadToNQuads));
-  return makeFnDataset(a.toArray().filter((q) => !bKeys.has(quadToNQuads(q))));
+  const bKeys = new Set(b.toArray().map(quadKey));
+  return makeFnDataset(a.toArray().filter((q) => !bKeys.has(quadKey(q))));
 }
 
 /** Keep quads matching quadPred(quad) => boolean. */
@@ -291,31 +330,22 @@ function mapQuads(ds, f) {
 
 /**
  * Run a SPARQL 1.1 query. SELECT -> Bindings[]; ASK -> boolean;
- * CONSTRUCT -> FnDataset. Delegates entirely to index.js's query() —
- * same capability gating (CONSTRUCT needs the npm-entry bundle; its
- * absence throws the existing "pending npm-entry build" Error).
+ * CONSTRUCT and DESCRIBE -> FnDataset. Delegates entirely to index.js's
+ * query().
  */
 async function query(ds, sparql, options) {
   assertFnDataset(ds, 'query');
-  const result = await engineApi.query(toDataset(ds), sparql, options);
-  return result instanceof Dataset ? fromDataset(result) : result;
+  const result = await engineApi.query((await engineOf(ds)), sparql, options);
+  return result instanceof engineApi.Dataset ? wrapEngine(result) : result;
 }
 
 /**
  * Materialize an entailment closure as a new FnDataset.
  *
- * Reuses query()'s existing entailment support rather than adding new
- * engine plumbing — but *not* via CONSTRUCT: the npm-entry ABI's
- * queryDataset has no entailment parameter (entailment closure stays
- * on the CLI path, per lib/api.js), and the CLI path does not support
- * CONSTRUCT at all, so "CONSTRUCT ... WHERE ... { entail }" is not
- * reachable through the existing API today. Instead this runs
- * `SELECT ?s ?p ?o WHERE { ?s ?p ?o }` with the entailment option
- * (exactly the combination test/api.test.js's "query: entail RDFS
- * infers subclass instances" already exercises) and repackages each
- * solution row as a quad — pure JS reshaping of already-materialized
- * bindings, not new RDF/SPARQL semantics, so it works with the CLI
- * bundle alone (no npm-entry bundle required).
+ * Reuses query()'s entailment support: it runs
+ * `SELECT ?s ?p ?o WHERE { ?s ?p ?o }` with the entailment option (the
+ * engine closes the default graph under the regime, then answers the
+ * query; op queryRaw) and repackages each solution row as a quad.
  *
  * Scope limitation (documented, not silent): like a bare
  * `WHERE { ?s ?p ?o }` in SPARQL generally, this closes over the
@@ -324,71 +354,32 @@ async function query(ds, sparql, options) {
  * per-graph closure semantics that the underlying query() does not
  * define today.
  */
-// Case-insensitive regime aliases ('rdfs', 'owl-rl', 'owlrl', 'owl_rl')
-// normalized to the engine's exact-case ENTAIL_VALUES spelling ('RDFS',
-// 'OWL-RL'); anything else (including already-correct casing, or a
-// genuinely invalid value) passes through unchanged so engineApi.query's
-// own validation reports the honest error rather than this function
-// guessing at what the caller meant.
-const ENTAIL_REGIME_ALIASES = {
-  none: 'none', rdfs: 'RDFS', 'owl-rl': 'OWL-RL', owlrl: 'OWL-RL', owl_rl: 'OWL-RL',
-};
-
-function normalizeEntailRegime(regime) {
-  const key = String(regime == null ? 'none' : regime).toLowerCase();
-  return ENTAIL_REGIME_ALIASES[key] || regime;
-}
-
-// x-ikl-* is NOT IMPLEMENTED. It is not withheld by policy.
-//
-// CORRECTION 2026-08-26: an earlier version of this comment said the
-// family was withheld by owner decision, citing the direction-B ruling
-// of https://github.com/danbri/factoidal/issues/618. That ruling was
-// about the IKL-to-RDF projection, not about this regime family, and
-// attributing it here misstated a decision the owner did not make.
-//
-// The x-ikl-* family is the OWNER'S design
-// (https://github.com/danbri/factoidal/issues/581). Its Lean dispatch
-// was deleted on 2026-08-26 as collateral of the projection purge
-// (https://github.com/danbri/factoidal/issues/626), not as its target.
-// The SEMANTICS survived: Unified/ClBridge.lean's asserted_merge_sound
-// is this regime's soundness statement -- lifting asserted named-graph
-// content into the default graph -- and it carries no naming scheme.
-// Restoring the family is a dispatch branch plus flipping this guard.
-//
-// The owner's own statement of what IKL does not supply, 2026-08-26:
-// no profiles, no entailment procedures, no mapping from RDF datasets.
-// Checked the same day against the IKL GUIDE and Hayes 2009: correct.
-//
-// engineApi.query() (lib/api.js) already rejects this, but
-// normalizeEntailRegime() above passes any unrecognised string through
-// UNCHANGED before it gets there — check explicitly here too, so this
-// function's own contract states the rule rather than depending on a
-// downstream check someone could relax without noticing this call
-// site. Case-insensitive, any suffix; see test/select.test.js.
-function rejectIklRegime(regime, who) {
-  if (regime != null && /^x-ikl/i.test(String(regime))) {
-    throw new TypeError(
-      `${who}: entail '${regime}' 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.');
+// The regime names, their case-insensitive aliases and the x-ikl-* refusal
+// are the engine's tables (op engineTables): no host copy
+// (https://github.com/danbri/factoidal/issues/894 item 5). A name with no
+// alias passes through unchanged and engineApi.query reports it.
+async function regimeOf(regime, who) {
+  const t = await engineApi.engineTables();
+  const r = regime == null ? 'none' : String(regime);
+  for (const [prefix, message] of Object.entries(t.refusedRegimePrefixes)) {
+    if (r.toLowerCase().startsWith(prefix)) {
+      throw new TypeError(message.replace('WHO', who).replace('REGIME', r));
+    }
   }
+  return t.entailAliases[r.toLowerCase()] || regime;
 }
 
 async function entail(ds, regime) {
   assertFnDataset(ds, 'entail');
-  rejectIklRegime(regime, 'entail');
-  const rows = await engineApi.query(
-    toDataset(ds), 'SELECT ?s ?p ?o WHERE { ?s ?p ?o }',
-    { entail: normalizeEntailRegime(regime) });
+  const entailRegime = await regimeOf(regime, 'entail');
+  const rows = await engineApi.query((await engineOf(ds)), 'SELECT ?s ?p ?o WHERE { ?s ?p ?o }',
+    { entail: entailRegime });
   return makeFnDataset(
     rows.map((row) => dataFactory.quad(row.get('s'), row.get('p'), row.get('o'))));
 }
 
 /**
- * SHACL Core validation. Needs the npm-entry engine bundle. Neither
+ * SHACL Core validation. Neither
  * argument is mutated or consumed -- both stay valid FnDatasets after
  * the call, same as every other op in this module.
  *
@@ -401,13 +392,13 @@ async function entail(ds, regime) {
 async function validate(ds, shapes) {
   assertFnDataset(ds, 'validate');
   assertFnDataset(shapes, 'validate');
-  const r = await engineApi.shaclValidate(toDataset(ds), toDataset(shapes));
-  return { conforms: r.conforms, report: fromDataset(r.report) };
+  const r = await engineApi.shaclValidate((await engineOf(ds)), (await engineOf(shapes)));
+  return { conforms: r.conforms, report: wrapEngine(r.report) };
 }
 
 /**
  * ShEx (Shape Expressions) validation of one focus node against one
- * shape. Needs the npm-entry engine bundle.
+ * shape.
  *
  * @param {FnDataset} ds the data graph
  * @param {string} schema ShExJ (JSON Schema form), as text
@@ -420,14 +411,13 @@ async function validate(ds, shapes) {
  */
 async function shex(ds, schema, focus, shape) {
   assertFnDataset(ds, 'shex');
-  return engineApi.shexValidate(toDataset(ds), schema, focus, shape);
+  return engineApi.shexValidate((await engineOf(ds)), schema, focus, shape);
 }
 
 /**
  * Evaluate an RML mapping graph against one logical source's raw
- * data, materializing the generated triples as a new FnDataset. Needs
- * the npm-entry engine bundle. Scope cut (documented, not silent):
- * every triples map in `mapping` reads the SAME `source` -- joins
+ * data, materializing the generated triples as a new FnDataset. Every
+ * triples map in `mapping` reads the SAME `source` -- joins
  * across two different logical sources are not reachable through this
  * one-source entry point (see engineApi.rmlMap's doc comment).
  *
@@ -438,13 +428,13 @@ async function shex(ds, schema, focus, shape) {
  */
 async function fromMapping(mapping, source, kind) {
   assertFnDataset(mapping, 'fromMapping');
-  return fromDataset(await engineApi.rmlMap(toDataset(mapping), source, kind));
+  return wrapEngine(await engineApi.rmlMap((await engineOf(mapping)), source, kind));
 }
 
 /**
  * CSVW csv2rdf conversion (w3.org/TR/csv2rdf): convert raw tabular
  * data plus an optional CSVW metadata document into a new FnDataset.
- * Needs the npm-entry engine bundle. Unlike fromMapping there is no
+ * Unlike fromMapping there is no
  * FnDataset input -- both arguments are raw text (CSVW's metadata
  * format is JSON, not RDF). Scope cut (documented, not silent --
  * mirrors fromMapping's one-source cut): every table in a multi-table
@@ -461,14 +451,13 @@ async function fromMapping(mapping, source, kind) {
  * @returns {Promise<FnDataset>}
  */
 async function fromCsvw(csv, metadata, options) {
-  return fromDataset(await engineApi.csvwToRdf(csv, metadata, options));
+  return wrapEngine(await engineApi.csvwToRdf(csv, metadata, options));
 }
 
 /**
  * RIF Core forward-chaining saturation, materialized as a new
  * FnDataset (input triples + derived triples, default graph only --
- * RIF Core has no named-graph notion). Needs the npm-entry engine
- * bundle.
+ * RIF Core has no named-graph notion).
  *
  * @param {FnDataset} ds the premise graph
  * @param {string} rules a RIF Core XML rule document
@@ -476,7 +465,7 @@ async function fromCsvw(csv, metadata, options) {
  */
 async function rif(ds, rules) {
   assertFnDataset(ds, 'rif');
-  return fromDataset(await engineApi.rifEval(toDataset(ds), rules));
+  return wrapEngine(await engineApi.rifEval((await engineOf(ds)), rules));
 }
 
 /**
@@ -489,8 +478,7 @@ async function rif(ds, rules) {
  * Gutierrez, "Simple and Efficient Minimal RDFS", J. Web Semantics
  * 7(3), 2009). Mirrors engineApi.coreRdfsClosure's `{ok, ntriples}`
  * result, with `ntriples` parsed into an FnDataset via
- * Dataset.fromNQuads — pure JS, no extra engine round-trip. Needs the
- * npm-entry engine bundle. `rhoDfClosure` is kept below as a
+ * the engine Dataset of the closure. `rhoDfClosure` is kept below as a
  * literature-name alias.
  * @param {FnDataset} ds
  * @param {{format?: string}} [options]
@@ -498,17 +486,15 @@ async function rif(ds, rules) {
  */
 async function coreRdfsClosure(ds, options) {
   assertFnDataset(ds, 'coreRdfsClosure');
-  const r = await engineApi.coreRdfsClosure(toDataset(ds), options);
-  return { ok: r.ok, dataset: fromDataset(Dataset.fromNQuads(r.ntriples)) };
+  const r = await engineApi.coreRdfsClosure((await engineOf(ds)), options);
+  return { ok: true, dataset: wrapEngine(r) };
 }
 /** Literature-name alias for coreRdfsClosure (ρdf; see above). */
 const rhoDfClosure = coreRdfsClosure;
 
 /**
- * Decidable core-RDFS fragment check (`is_rho_df_frag`, tied by an F*
- * lemma to the prop the regime theorems quantify over): does the
- * certified coreRdfsClosure guarantee apply to `ds`? Needs the
- * npm-entry engine bundle. `rhoDfFragmentCheck` is kept below as a
+ * Decidable core-RDFS fragment check (L4Factoidal/RDFS, `isRhoDfFrag`):
+ * is `ds` in the core-RDFS fragment coreRdfsClosure is defined for? `rhoDfFragmentCheck` is kept below as a
  * literature-name alias.
  * @param {FnDataset} ds
  * @param {{format?: string}} [options]
@@ -516,7 +502,7 @@ const rhoDfClosure = coreRdfsClosure;
  */
 async function coreRdfsCheck(ds, options) {
   assertFnDataset(ds, 'coreRdfsCheck');
-  return engineApi.coreRdfsCheck(toDataset(ds), options);
+  return engineApi.coreRdfsCheck((await engineOf(ds)), options);
 }
 /** Literature-name alias for coreRdfsCheck (ρdf; see above). */
 const rhoDfFragmentCheck = coreRdfsCheck;
@@ -529,19 +515,17 @@ const rhoDfFragmentCheck = coreRdfsCheck;
  * Allemang & Hendler 2008; "RDFS++", AllegroGraph). Every OWL row
  * carries a proved licensing + truth lemma; no chain-level
  * completeness claim (theorem registry) — weaker than
- * coreRdfsClosure's decides-iff guarantee. Needs the npm-entry engine
- * bundle.
+ * coreRdfsClosure's decides-iff guarantee.
  * @param {FnDataset} ds
  * @param {{format?: string}} [options]
- * @returns {Promise<{ok: boolean, dataset: FnDataset, rounds: number}>}
+ * @returns {Promise<{ok: boolean, dataset: FnDataset}>}
  */
 async function rdfsPlusClosure(ds, options) {
   assertFnDataset(ds, 'rdfsPlusClosure');
-  const r = await engineApi.rdfsPlusClosure(toDataset(ds), options);
+  const r = await engineApi.rdfsPlusClosure((await engineOf(ds)), options);
   return {
-    ok: r.ok,
-    dataset: fromDataset(Dataset.fromNQuads(r.ntriples)),
-    rounds: r.rounds,
+    ok: true,
+    dataset: wrapEngine(r),
   };
 }
 
@@ -551,7 +535,7 @@ async function rdfsPlusClosure(ds, options) {
  * individual the model-construction reasoner proves is a member of an
  * OWL class expression (someValuesFrom / hasValue / unionOf /
  * intersectionOf, and the named class an equivalentClass restriction
- * defines). Needs the npm-entry engine bundle. Default graph only.
+ * defines). Default graph only.
  *
  * @param {FnDataset} ds the ontology + ABox graph
  * @returns {Promise<{dataset: FnDataset, addedCount: number}>} dataset
@@ -560,31 +544,29 @@ async function rdfsPlusClosure(ds, options) {
  */
 async function tableauMaterialise(ds) {
   assertFnDataset(ds, 'tableauMaterialise');
-  const r = await engineApi.tableauMaterialise(toDataset(ds));
-  return { dataset: fromDataset(r.dataset), addedCount: r.addedCount };
+  const r = await engineApi.tableauMaterialise((await engineOf(ds)));
+  return { dataset: wrapEngine(r.dataset), addedCount: r.addedCount };
 }
 
 /**
  * OWL DL inconsistency verdict (bin/owl-runner's DL pipeline: OWL-RL
  * closure -> tableau materialise -> OWL-RL closure -> is_inconsistent).
  * `rlAlone` is the plain OWL-RL verdict on the same input, so a caller
- * can see the cases the tableau adds. Needs the npm-entry engine
- * bundle. Default graph only.
+ * can see the cases the tableau adds. Default graph only.
  *
  * @param {FnDataset} ds the ontology + ABox graph
  * @returns {Promise<{inconsistent: boolean, rlAlone: boolean}>}
  */
 async function tableauDlInconsistent(ds) {
   assertFnDataset(ds, 'tableauDlInconsistent');
-  return engineApi.tableauDlInconsistent(toDataset(ds));
+  return engineApi.tableauDlInconsistent((await engineOf(ds)));
 }
 
 /**
  * OWL DL consistency verdict via the verified clash-detecting tableau
  * (formal/fstar/Tableau.Refute.fst's `tableau_consistent` over the
  * OWL-RL closure -- the pure verified chain bin/owl-runner runs under
- * `--regime dl`, minus its native-only z3 oracle). Needs the npm-entry
- * bundle. Default graph only.
+ * `--regime dl`, minus its native-only z3 oracle). Default graph only.
  *
  * `consistent` is three-valued: `false` (a clash on every tableau
  * branch), `true` (a model was constructed), or `null` -- the refuter
@@ -597,7 +579,7 @@ async function tableauDlInconsistent(ds) {
  * @returns {Promise<{consistent: boolean|null, reason?: string}>}
  */
 async function owlIsConsistent(ontology, options) {
-  const data = ontology instanceof FnDataset ? toDataset(ontology) : ontology;
+  const data = ontology instanceof FnDataset ? (await engineOf(ontology)) : ontology;
   return engineApi.owlIsConsistent(data, options);
 }
 
@@ -605,7 +587,7 @@ async function owlIsConsistent(ontology, options) {
  * OWL entailment check: does `premise` entail `conclusion`? Verified
  * two-path dispatch (`via: "closure"` for the OWL-RL closure path,
  * `via: "refutation"` for negate-and-refute), mirroring bin/owl-runner.
- * Needs the npm-entry bundle. Default graph only. `entailed` is
+ * Default graph only. `entailed` is
  * three-valued (`true` / `false` / `null` budget-out, `reason` names the
  * cap).
  *
@@ -615,20 +597,20 @@ async function owlIsConsistent(ontology, options) {
  * @returns {Promise<{entailed: boolean|null, via: 'closure'|'refutation', reason?: string}>}
  */
 async function owlEntails(premise, conclusion, options) {
-  const p = premise instanceof FnDataset ? toDataset(premise) : premise;
-  const c = conclusion instanceof FnDataset ? toDataset(conclusion) : conclusion;
+  const p = premise instanceof FnDataset ? (await engineOf(premise)) : premise;
+  const c = conclusion instanceof FnDataset ? (await engineOf(conclusion)) : conclusion;
   return engineApi.owlEntails(p, c, options);
 }
 
 /**
- * RDFC-1.0 canonicalization: canonical N-Quads text. Needs the
- * npm-entry bundle (same gating as index.js's canonicalize()).
+ * RDFC-1.0 canonicalization: canonical N-Quads text (index.js's
+ * canonicalize()).
  */
 async function canonicalize(ds) {
   assertFnDataset(ds, 'canonicalize');
   let cached = CANON_CACHE.get(ds);
   if (cached === undefined) {
-    const p = engineApi.canonicalize(toDataset(ds)).then((text) => {
+    const p = engineApi.canonicalize((await engineOf(ds))).then((text) => {
       CANON_CACHE.set(ds, text); // replace the in-flight promise
       return text;
     });
@@ -677,111 +659,34 @@ function peekHash(ds) {
   return typeof c === 'string' ? c : null;
 }
 
-function hasBlankNode(ds) {
-  for (const q of ds) {
-    if (q.subject.termType === 'BlankNode') return true;
-    if (q.object.termType === 'BlankNode') return true;
-    if (q.graph.termType === 'BlankNode') return true;
-  }
-  return false;
-}
-
 /**
- * Structural equality, cheapest-correct-path first (see the design
- * doc's cost model section for the full argument):
- *
- *  1. Different sizes -> not equal, O(1).
- *  2. Both sides already have a memoized hash -> compare those, O(1).
- *  3. Exact quad-set match (same terms, same labels) -> equal, O(n).
- *     This is sound regardless of blank nodes: identical tokens can
- *     never be a false positive.
- *  4. No blank nodes anywhere -> the step-3 negative is authoritative
- *     (ground quads have no relabeling to hide behind) -> not equal.
- *  5. Otherwise (blank nodes present, step 3 was inconclusive) ->
- *     the only sound test left is RDFC-1.0 canonical-hash equality,
- *     which is exactly the O(n log n) canonicalize() cost this module
- *     tries to avoid paying twice.
+ * Dataset isomorphism (RDF 1.1 Concepts 3.6 and 4, blank nodes inside RDF
+ * 1.2 triple terms included), decided by the engine
+ * (Dataset.isomorphicOutcome, op datasetIsomorphic). The same FnDataset is
+ * equal to itself without a call.
  */
 async function equals(a, b) {
   assertFnDataset(a, 'equals'); assertFnDataset(b, 'equals');
   if (a === b) return true;
-  if (a.size !== b.size) return false;
-  const ha = peekHash(a);
-  const hb = peekHash(b);
-  if (ha !== null && hb !== null) return ha === hb;
-  const aKeys = new Set(a.toArray().map(quadToNQuads));
-  const bTokens = b.toArray().map(quadToNQuads);
-  const exact = bTokens.length === aKeys.size &&
-    bTokens.every((t) => aKeys.has(t));
-  if (exact) return true;
-  if (!hasBlankNode(a) && !hasBlankNode(b)) return false;
-  const [h1, h2] = await Promise.all([hash(a), hash(b)]);
-  return h1 === h2;
-}
-
-/**
- * Open a COTTAS/Parquet artifact's raw bytes as a queryable, read-only
- * store (docs/designissues/2026-07-06-inmemory-bytes-store.md, browser
- * call site). Needs the npm-entry engine bundle. Unlike every other
- * constructor in this module, the returned object is NOT an FnDataset:
- * the whole point of the design is that rows decode lazily as a query
- * touches them, never materializing the corpus into heap FnDataset
- * quads (measured 64-161 B/quad vs. an FnDataset/heap Dataset's
- * ~877 B/quad for the same data, in the design doc's native numbers).
- *
- * @param {string|Uint8Array|ArrayBuffer} bytes whole `.cottas` file contents
- * @returns {Promise<{handle: string,
- *   query: (sparql: string) => Promise<Array<Map<string,object>>|boolean|FnDataset>,
- *   close: () => Promise<void>}>}
- *   query() divergences from fn.query() (documented, not silent): no
- *   entail option, no write/--delta-log overlay (read-only), and a
- *   query shape the backend executor can't push down rejects instead
- *   of silently falling back to a full materialize (see
- *   engineApi.queryCottas's doc comment). CONSTRUCT still returns an
- *   FnDataset (materialized once for that query only).
- */
-async function openCottas(bytes) {
-  const handle = await engineApi.openCottas(bytes);
-  let closed = false;
-  return {
-    handle,
-    async query(sparql) {
-      if (closed) throw new Error('openCottas store: query() called after close()');
-      const result = await engineApi.queryCottas(handle, sparql);
-      return result instanceof Dataset ? fromDataset(result) : result;
-    },
-    async close() {
-      if (closed) return;
-      closed = true;
-      await engineApi.closeCottas(handle);
-    },
-  };
+  return engineApi.isomorphic(await engineOf(a), await engineOf(b));
 }
 
 /**
- * Serialize an FnDataset to COTTAS/Parquet bytes via the native writer
- * (the same pure `Tot` F* function `factoidal compact --native-writer`
- * uses). Needs the npm-entry engine bundle. Round-trips through
- * openCottas(): feeding the result straight back into openCottas()
- * reproduces the same queryable store.
- *
- * @param {FnDataset} ds
- * @returns {Promise<Uint8Array>}
- */
-async function toCottas(ds) {
-  assertFnDataset(ds, 'toCottas');
-  return engineApi.toCottas(toDataset(ds));
-}
-
-/**
- * Enumerate named graphs (default graph excluded), first-seen order.
- * Reuses index.js's graphs() enumeration; wraps each per-graph
- * Dataset back into an FnDataset.
+ * Enumerate named graphs (default graph excluded), first-seen order. An
+ * engine-backed dataset asks the engine (op datasetGraphNames); an array of
+ * JS quads groups by RDF/JS Term.equals identity, so an IRI and a blank node
+ * with the same string are two graphs.
  */
 function graphs(ds) {
   assertFnDataset(ds, 'graphs');
-  return engineApi.graphs(toDataset(ds))
-    .map(([iri, graphDataset]) => [iri, fromDataset(graphDataset)]);
+  if (ds._backend.engine) {
+    return engineApi.graphs(ds._backend.engine).map(([name, g]) => [name, wrapEngine(g)]);
+  }
+  const seen = new Map();
+  for (const q of ds) {
+    if (q.graph.termType !== 'DefaultGraph' && !seen.has(termKey(q.graph))) seen.set(termKey(q.graph), q.graph);
+  }
+  return [...seen.values()].map((g) => [g, ds.match(null, null, null, g)]);
 }
 
 // ---------------------------------------------------------------------
@@ -860,7 +765,7 @@ function pipe(...fns) {
 // -----------------------------------------------------------------
 // Typed engine functions (#74). Re-exported unchanged from the JS
 // engine api — each is already a pure, value-in / value-out function
-// over one F*-extracted engine (XSLT, MathML, XForms, JSON Schema,
+// over one engine op (XSLT, MathML, XForms, JSON Schema,
 // Schematron, TOAN CAS, matrix algebra), so they belong in the
 // functional surface as-is. See index.d.ts / fn.d.ts for signatures.
 // -----------------------------------------------------------------
@@ -875,12 +780,6 @@ const {
   toanSimplify,
   toanDiff,
   toanSubst,
-  matrixDeterminant,
-  matrixScalarProduct,
-  matrixVectorProduct,
-  matrixOuterProduct,
-  sigmoidPoints,
-  sigmoidFormulaMathml,
   vcSha256Hex,
   vcEd25519SecretToPublic,
   vcEd25519Sign,
@@ -921,8 +820,6 @@ module.exports = {
   canonicalize,
   hash,
   equals,
-  openCottas,
-  toCottas,
   graphs,
   cell,
   derive,
@@ -938,12 +835,6 @@ module.exports = {
   toanSimplify,
   toanDiff,
   toanSubst,
-  matrixDeterminant,
-  matrixScalarProduct,
-  matrixVectorProduct,
-  matrixOuterProduct,
-  sigmoidPoints,
-  sigmoidFormulaMathml,
   vcSha256Hex,
   vcEd25519SecretToPublic,
   vcEd25519Sign,