@factoidal/core 0.7.1 → 0.10.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,7 +25,7 @@ const crypto = require('node:crypto');
 
 const engineApi = require('./index.js');
 const {
-  Dataset,
+  DatasetCore,
   dataFactory,
   quadToNQuads,
   quadsToNQuads,
@@ -92,10 +92,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())
@@ -147,14 +171,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 +195,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.openDataset({ text: quadsToNQuads(ds.toArray()), format: 'nquads' });
+    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 +285,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). */
@@ -291,31 +329,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
@@ -326,10 +355,10 @@ async function query(ds, sparql, options) {
  */
 // 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.
+// 'OWL-RL'); anything else (including already-correct casing, or a value
+// that names no regime) passes through unchanged, so engineApi.query's own
+// validation reports the error and this function does not guess what the
+// caller meant.
 const ENTAIL_REGIME_ALIASES = {
   none: 'none', rdfs: 'RDFS', 'owl-rl': 'OWL-RL', owlrl: 'OWL-RL', owl_rl: 'OWL-RL',
 };
@@ -380,15 +409,14 @@ function rejectIklRegime(regime, who) {
 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 }',
+  const rows = await engineApi.query((await engineOf(ds)), 'SELECT ?s ?p ?o WHERE { ?s ?p ?o }',
     { entail: normalizeEntailRegime(regime) });
   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 +429,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 +448,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 +465,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 +488,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 +502,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 +515,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 +523,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 +539,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 +552,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 +572,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 +581,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 +616,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 +624,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 +634,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;
     });
@@ -719,60 +738,6 @@ async function equals(a, 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);
-    },
-  };
-}
-
-/**
- * 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
@@ -780,8 +745,11 @@ async function toCottas(ds) {
  */
 function graphs(ds) {
   assertFnDataset(ds, 'graphs');
-  return engineApi.graphs(toDataset(ds))
-    .map(([iri, graphDataset]) => [iri, fromDataset(graphDataset)]);
+  const seen = new Map();
+  for (const q of ds) {
+    if (q.graph.termType !== 'DefaultGraph' && !seen.has(q.graph.value)) seen.set(q.graph.value, q.graph);
+  }
+  return [...seen].map(([iri, g]) => [iri, ds.match(null, null, null, g)]);
 }
 
 // ---------------------------------------------------------------------
@@ -860,7 +828,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 +843,6 @@ const {
   toanSimplify,
   toanDiff,
   toanSubst,
-  matrixDeterminant,
-  matrixScalarProduct,
-  matrixVectorProduct,
-  matrixOuterProduct,
-  sigmoidPoints,
-  sigmoidFormulaMathml,
   vcSha256Hex,
   vcEd25519SecretToPublic,
   vcEd25519Sign,
@@ -921,8 +883,6 @@ module.exports = {
   canonicalize,
   hash,
   equals,
-  openCottas,
-  toCottas,
   graphs,
   cell,
   derive,
@@ -938,12 +898,6 @@ module.exports = {
   toanSimplify,
   toanDiff,
   toanSubst,
-  matrixDeterminant,
-  matrixScalarProduct,
-  matrixVectorProduct,
-  matrixOuterProduct,
-  sigmoidPoints,
-  sigmoidFormulaMathml,
   vcSha256Hex,
   vcEd25519SecretToPublic,
   vcEd25519Sign,