@factoidal/core 0.7.0 → 0.10.0

package/index.d.ts

@@ -1,4 +1,8 @@
-// TypeScript declarations for factoidal.
+// TypeScript declarations for @factoidal/core 0.9: one engine, the Lean 4
+// library L4Factoidal compiled to WebAssembly (formal/lean4). Every
+// function below is a dispatch op of that module (Wasm/Dispatch.lean)
+// behind a typed wrapper (lib/api.mjs). The same declarations describe
+// browser.js (browser.d.ts re-exports them).
 //
 // Self-contained: the RDF/JS interfaces below are structurally
 // compatible with @rdfjs/types (same names and shapes) but declared
@@ -80,31 +84,156 @@ export interface DataFactory {
 export const dataFactory: DataFactory;
 
 /**
- * An in-memory RDF/JS DatasetCore
- * (https://rdf.js.org/dataset-spec/#datasetcore-interface) that also
- * round-trips to the engine's N-Quads interchange text.
+ * A parse failure that carries a position (issue #344): `line`/
+ * `column`/`offset` are set when the failing engine call reported one
+ * (Turtle, TriG, N-Triples, N-Quads); `undefined` for an RDF/XML or
+ * JSON-LD failure, or any non-parse engine error, which stay a plain
+ * `Error`. `name` is `'ParseError'`.
+ */
+export class ParseError extends Error {
+  readonly name: 'ParseError';
+  /** 1-based line of the error. */
+  readonly line?: number;
+  /** 1-based column of the error, counted in Unicode scalar values. */
+  readonly column?: number;
+  /**
+   * The position of the error as a UTF-16 code-unit index into the input
+   * JavaScript string: `text.slice(err.offset)` starts at the error. A
+   * character outside the Basic Multilingual Plane (U+10000 and above)
+   * counts 2, as in every JavaScript string index. (The engine reports a
+   * count of Unicode scalar values; the wrapper converts.)
+   */
+  readonly offset?: number;
+  readonly format?: string;
+}
+
+/** One recoverable-parse diagnostic from a `{lenient:true}` parse() call. */
+export interface ParseDiagnostic {
+  message: string;
+  /**
+   * The position of the error as a UTF-16 code-unit index into the input
+   * JavaScript string, as ParseError.offset: `text.slice(d.offset)` starts
+   * at the error.
+   */
+  offset: number;
+  /** 1-based; a line ends at each LINE FEED (CR LF is one line end). */
+  line: number;
+  /** 1-based, counted in Unicode scalar values from the start of the line. */
+  column: number;
+  /**
+   * The stable error class (https://github.com/danbri/factoidal/issues/716):
+   * 'undefined-prefix', 'relative-iri', 'bad-iri', 'bad-escape',
+   * 'unterminated-string', 'bad-literal', 'bad-blank-node',
+   * 'bad-prefixed-name', 'bad-directive', 'bad-graph-name', 'rdf12-syntax',
+   * 'unclosed-group', 'nesting-limit', 'unexpected-token', 'internal' or
+   * 'too-many-errors'.
+   */
+  class: string;
+}
+
+/** Every options key of Dataset.serialize(), serialize() and toString(). */
+export interface WriteOptions {
+  /**
+   * 'nquads' (default; sorted line order), 'ntriples' (refused when the
+   * dataset has a named graph), 'turtle', 'trig', 'rdfxml', 'jsonld'
+   * (expanded JSON-LD 1.1), 'rdfc' (RDFC-1.0 canonical N-Quads). Turtle and
+   * RDF/XML write the named graphs as one graph. `formats()` lists what
+   * each writer supports.
+   */
+  format?: WriteFormat;
+  /** '1.1' refuses a dataset with an RDF 1.2 term; '1.2' (default) writes it. */
+  version?: '1.1' | '1.2';
+  /** 'turtle' only: prefix label -> namespace IRI, merged over `dataset.prefixes`. */
+  prefixes?: Record<string, string>;
+  /** 'turtle' only. Default true: integers, decimals, doubles and booleans print bare. */
+  literalShorthand?: boolean;
+  /** 'jsonld' only (JSON-LD 1.1 API section 8). */
+  useNativeTypes?: boolean;
+  /** 'jsonld' only. */
+  useRdfType?: boolean;
+  /** 'jsonld' only. */
+  rdfDirection?: string;
+}
+
+export type WriteFormat =
+  | 'nquads' | 'nq' | 'ntriples' | 'nt' | 'turtle' | 'ttl' | 'trig'
+  | 'rdfxml' | 'rdf-xml' | 'rdf' | 'jsonld' | 'json-ld' | 'rdfc' | 'canonical';
+
+/** Results formats of query() with `output`. */
+export type ResultsFormat = 'json' | 'xml' | 'csv' | 'tsv' | 'table' | 'ntriples';
+
+/** One row of formats(). */
+export interface FormatCapability {
+  name: string;
+  read11: boolean;
+  read12: boolean;
+  write11: boolean;
+  write12: boolean;
+  /** 'core' when both engines serve it; 'full' when only the full engine does. */
+  engine: 'core' | 'full';
+}
+
+/**
+ * An RDF dataset held inside the engine (https://github.com/danbri/factoidal/issues/882).
+ * Every producer (parse, csvwToRdf, rmlMap, jsonldToRdf, the closures,
+ * rifEval, CONSTRUCT) answers one; every consumer accepts one. The data
+ * stays in the wasm memory: a method sends the handle id, not the data.
+ * Release it with dispose() or `using`; a Dataset collected without
+ * dispose() is released by a FinalizationRegistry. A method of a disposed
+ * Dataset throws a TypeError.
  */
 export class Dataset implements Iterable<Quad> {
-  constructor(quads?: Iterable<Quad>);
+  private constructor();
+  /** The engine's handle id (opaque). */
+  readonly handle: string;
+  /** Number of quads. */
   readonly size: number;
+  /** Prefixes the source document declared (label -> namespace IRI). */
+  readonly prefixes: Record<string, string>;
+  /** Diagnostics of a `{lenient:true}` parse; else empty. */
+  readonly diagnostics: ParseDiagnostic[];
+  /** The parse format tag, when the data was read from text. */
+  readonly format: string | undefined;
+  /** True when `format` was inferred because the caller gave none. */
+  readonly formatInferred: boolean;
+  /** True after dispose(). */
+  readonly disposed: boolean;
+  /** Members the producing op reported: `rounds` (rho-df, RDFS-Plus closures); `inputCount`, `derivedCount`, `fuel` (rifEval). */
+  readonly info: Record<string, unknown>;
+  query(sparql: string, options?: DatasetQueryOptions): Promise<Bindings[] | boolean | Dataset | string | object>;
+  /** SPARQL 1.1 Update in place; answers this Dataset. */
+  update(updateText: string, options?: Record<string, never>): Promise<this>;
+  validateShacl(shapes: DataInput, options?: { format?: DataFormat; baseIRI?: string }): Promise<ShaclValidateResult>;
+  validateShex(schema: string, options: { focus: string | NamedNode | BlankNode; shape?: string | NamedNode | BlankNode | null }): Promise<boolean>;
+  closure(regime: ClosureRegime): Promise<Dataset>;
+  canonicalize(): Promise<string>;
+  serialize(options?: WriteOptions): Promise<string>;
+  toString(formatOrOptions?: WriteFormat | WriteOptions): string;
+  toNQuads(): string;
+  clone(): Dataset;
+  /** RDF/JS DatasetCore (https://rdf.js.org/dataset-spec/); match and has use the engine indexes. */
+  has(quad: Quad): boolean;
   add(quad: Quad): this;
   delete(quad: Quad): this;
-  has(quad: Quad): boolean;
-  match(
-    subject?: Term | null,
-    predicate?: Term | null,
-    object?: Term | null,
-    graph?: Term | null
-  ): Dataset;
-  [Symbol.iterator](): Iterator<Quad>;
+  match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Dataset;
   toArray(): Quad[];
-  /** N-Quads serialization of the quads (the engine interchange form). */
-  toNQuads(): string;
-  toString(): string;
-  static fromNQuads(
-    text: string,
-    options?: { blankNodePrefix?: string; factory?: DataFactory }
-  ): Dataset;
+  [Symbol.iterator](): Iterator<Quad>;
+  dispose(): void;
+  [Symbol.dispose](): void;
+}
+
+/** @deprecated The name of Dataset before 0.10.0; removed in 0.11.0. */
+export const DatasetHandle: typeof Dataset;
+
+export type ClosureRegime = 'rdfs' | 'owl-rl' | 'rho-df' | 'rdfs-plus';
+
+export interface DatasetQueryOptions {
+  sparql12?: boolean;
+  version?: '1.1' | '1.2';
+  /** Close the default graph under a regime before the query. */
+  entail?: EntailRegime;
+  /** Answer the results document in this format (text; 'json' parsed). */
+  output?: ResultsFormat;
 }
 
 // ---------------------------------------------------------------------
@@ -118,7 +247,14 @@ export type DataFormat =
   | 'nquads' | 'nq'
   | 'trig'
   | 'rdfxml' | 'rdf-xml' | 'rdf'
-  | 'jsonld' | 'json-ld';
+  | 'jsonld' | 'json-ld'
+  // RDF 1.2 parsers (triple terms, reifiers, annotations, VERSION,
+  // directional language tags). The names above parse RDF 1.1 and reject
+  // RDF 1.2 syntax with "requires RDF 1.2 mode".
+  | 'turtle12' | 'ttl12'
+  | 'ntriples12' | 'nt12'
+  | 'nquads12' | 'nq12'
+  | 'trig12';
 
 /** Entailment regime applied to the data before evaluation. */
 /**
@@ -133,52 +269,89 @@ export type EntailRegime = 'none' | 'RDFS' | 'OWL-RL' | 'x-rdfscore' | 'x-rdfspl
 
 /**
  * One SELECT solution: a Map from variable name (no leading '?') to
- * the bound RDF/JS term. Unbound variables are absent from the Map.
+ * the bound RDF/JS term. Unbound variables are absent from the Map. The
+ * Map iterates in the order of the SELECT clause (the `head.vars` of the
+ * SPARQL 1.1 Query Results JSON Format, section 3.1).
  */
 export type Bindings = Map<string, Term>;
 
-/** Input data: a Dataset, a document string, or several of either. */
+/**
+ * Input data: a Dataset, a document string, or several of either. Text
+ * is read in `options.format`; with no format the engine infers one and
+ * the error (or `dataset.format`) reports it.
+ */
 export type DataInput =
   | Dataset
   | string
-  | { text: string; format?: DataFormat }
-  | Array<Dataset | string | { text: string; format?: DataFormat }>;
+  | { text: string; format?: DataFormat; baseIRI?: string }
+  | Array<Dataset | string | { text: string; format?: DataFormat; baseIRI?: string }>;
+
+/** Same as DataInput (kept for 0.9 type imports). */
+export type QueryInput = DataInput;
 
 export interface ParseOptions {
-  /** Default: 'turtle'. */
+  /** Omitted: inferred by the engine (op detectFormat), reported in `dataset.format`. */
   format?: DataFormat;
   /** Base IRI for resolving relative IRIs (Turtle/TriG/RDF-XML). */
   baseIRI?: string;
+  /**
+   * Recover instead of rejecting on the first syntax error
+   * (https://github.com/danbri/factoidal/issues/716, engine op
+   * `parseDocument`): Turtle, TriG, N-Triples and N-Quads skip each bad
+   * statement and keep every good one; `dataset.diagnostics` has one
+   * entry per skipped statement. RDF/XML and JSON-LD parse strictly. A
+   * document with no error gives the strict result and no diagnostics.
+   * Default: false (strict; a syntax error, an undeclared prefix, or an
+   * unresolvable relative IRI rejects the whole parse with a ParseError).
+   */
+  lenient?: boolean;
+  /**
+   * With `lenient`: stop after this many diagnostics; the parse then ends
+   * with one diagnostic of class 'too-many-errors'. Default: no limit.
+   */
+  maxErrors?: number;
 }
 
-export interface QueryOptions {
-  /** Format tag for string data inputs. Default: 'turtle'. */
+export interface QueryOptions extends DatasetQueryOptions {
+  /** Format tag for string data inputs; omitted: inferred. */
   format?: DataFormat;
-  /** Default: 'none'. */
-  entail?: EntailRegime;
+  baseIRI?: string;
 }
 
-/** Parse one RDF document into a Dataset. */
-export function parse(text: string, options?: ParseOptions): Promise<Dataset>;
+/**
+ * Parse one RDF document into a Dataset. The returned Dataset's quad
+ * order is sorted (canonical N-Quads order), not document order;
+ * anonymous blank-node labels (`_anonN`) DO reflect document order.
+ * See README.md's "Blank nodes, labels and statement order". Strict
+ * by default (issue #344): a syntax error rejects with a ParseError
+ * (`line`/`column`/`offset` for Turtle/TriG/N-Triples/N-Quads; a
+ * message only for RDF/XML and JSON-LD). `options.lenient` recovers
+ * instead; see ParseOptions.
+ */
+export function parse(text: string, options?: ParseOptions | DataFormat): Promise<Dataset>;
 
 /**
- * Run a SPARQL 1.1 query.
+ * Run a SPARQL 1.1 query (or 1.2, with `sparql12`).
  * SELECT resolves to Bindings[]; ASK resolves to a boolean;
- * CONSTRUCT resolves to a Dataset (needs the npm-entry engine bundle
- * — rejects with an Error mentioning "pending npm-entry build" when
- * only the CLI bundle is available).
+ * CONSTRUCT and DESCRIBE resolve to a Dataset (DESCRIBE answers the
+ * Concise Bounded Description of each resource named). A `SERVICE <iri>`
+ * whose IRI no registerServiceEndpoint() call named answers no
+ * solutions even without SILENT
+ * (https://github.com/danbri/factoidal/issues/717). `data` may be a DatasetHandle
+ * from openDataset(), in which case this routes to `data.query()` and
+ * `options.entail` must be 'none' or omitted (a handle carries no
+ * entailment-closure step).
  */
 export function query(
-  data: DataInput,
+  data: QueryInput,
   sparql: string,
-  options?: QueryOptions
-): Promise<Bindings[] | boolean | Dataset>;
+  options?: QueryOptions | DataFormat
+): Promise<Bindings[] | boolean | Dataset | string | object>;
 
 /**
  * Run a SPARQL 1.1 query against a read-only HDT (Header-Dictionary-
- * Triples) artifact's raw bytes (factoidal_cli.ml's `--data-hdt`
- * backend). No npm-entry engine bundle needed -- CLI-only. Default
- * graph only, SELECT/ASK only (no CONSTRUCT, no named graphs).
+ * Triples) file's raw bytes (op queryHdt; the bytes cross into the
+ * engine with no encoding). Default graph only, SELECT/ASK only.
  * @param hdtBytes whole .hdt file contents
  */
 export function queryHdt(
@@ -230,48 +403,56 @@ export function clearExtensionFunctions(): Promise<void>;
 export function registerServiceEndpoint(
   iri: string,
   data: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<{ ok: true; count: number }>;
 
 /** Remove every registered SERVICE endpoint snapshot. */
 export function clearServiceEndpoints(): Promise<void>;
 
-/**
- * Apply a SPARQL 1.1 Update, returning the updated Dataset.
- * Needs the npm-entry engine bundle.
- */
+/** Apply a SPARQL 1.1 Update and answer a NEW Dataset; a Dataset argument is unchanged. */
 export function update(
   data: DataInput,
   updateText: string,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string } | DataFormat
 ): Promise<Dataset>;
 
-export interface SerializeOptions {
-  /**
-   * Output format. Default: 'nquads'. 'turtle' (prefix-compacted,
-   * subject-grouped) needs the npm-entry bundle and flattens every
-   * named graph into the default graph — use 'nquads' when graph names
-   * must survive.
-   */
-  format?: 'nquads' | 'ntriples' | 'turtle' | 'ttl';
-  /** Format tag for string data inputs. Default: 'turtle'. */
+/** Open `data` as a Dataset (a Dataset argument is cloned). */
+export function openDataset(
+  data: DataInput,
+  options?: { format?: DataFormat; baseIRI?: string } | DataFormat
+): Promise<Dataset>;
+
+/** Closure of the default graph under `regime`, as a new Dataset. */
+export function closure(
+  data: DataInput,
+  regime: ClosureRegime,
+  options?: { format?: DataFormat; baseIRI?: string }
+): Promise<Dataset>;
+
+/** The syntaxes the engine reads and writes, from the engine (op datasetFormats). */
+export function formats(): Promise<FormatCapability[]>;
+
+export interface SerializeOptions extends WriteOptions {
+  /** Format of string `data`; omitted: inferred. */
   inputFormat?: DataFormat;
+  baseIRI?: string;
 }
 
-/** Serialize a dataset (engine-produced, sorted N-Quads order). */
+/** Write a dataset in a concrete syntax (see WriteOptions). */
 export function serialize(
   data: DataInput,
-  options?: SerializeOptions
+  options?: SerializeOptions | WriteFormat
 ): Promise<string>;
 
 /**
  * RDFC-1.0 dataset canonicalization: canonical blank-node labels plus
  * sorted canonical N-Quads. Two isomorphic inputs canonicalize to the
- * same string.
+ * same string. `data` may be a DatasetHandle, in which case this
+ * routes to `data.canonicalize()` (options are ignored for a handle).
  */
 export function canonicalize(
   data: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string } | DataFormat
 ): Promise<string>;
 
 /**
@@ -284,10 +465,12 @@ export function canonicalize(
 export function graphs(dataset: Dataset): Array<[iri: string, graph: Dataset]>;
 
 /**
- * RDFC-1.0 canonical hash of a single graph -- the graph-scoped
- * sibling of canonicalize(). Every quad's graph component is dropped
+ * RDFC-1.0 canonical form of a single graph -- the graph-scoped
+ * sibling of canonicalize(). It returns the canonical N-Quads TEXT, not
+ * a digest: hash the string yourself (for example `vcSha256Hex`) when a
+ * fixed-length value is needed. Every quad's graph component is dropped
  * before canonicalizing, so isomorphic graphs (including under
- * blank-node relabeling) hash to the same string regardless of what
+ * blank-node relabeling) give the same string regardless of what
  * graph name they were extracted from. Typically called with one
  * entry of graphs()'s output.
  */
@@ -296,27 +479,33 @@ export function canonicalHash(datasetOrGraph: Dataset): Promise<string>;
 /** A SHACL validation-report term (see shaclValidate). */
 export interface ShaclValidateResult {
   conforms: boolean;
-  /** SHACL_Validation.validation_report_to_graph's graph as a Dataset. */
+  /** The validation report graph: one sh:ValidationReport with
+   *  sh:conforms, and one sh:result per validation result. */
   report: Dataset;
 }
 
 /**
- * SHACL Core validation. Needs the npm-entry engine bundle.
+ * SHACL validation (SHACL Core, SHACL-SPARQL constraints, SHACL 1.2 node
+ * expressions) of the data graph's default graph. A shapes graph that
+ * uses the SPARQL-based target of SHACL-AF, and a validation failure in
+ * the sense of SHACL 5.3.2, reject.
  * @param data the data graph
  * @param shapes the shapes graph
  */
 export function shaclValidate(
   data: DataInput,
   shapes: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<ShaclValidateResult>;
 
 /**
  * ShEx (Shape Expressions) validation of one focus node against one
- * shape. Needs the npm-entry engine bundle. `null` means "deferred" --
- * outside this engine's decidable ShEx fragment, never a guessed
- * answer.
- * @param schemaJson ShExJ (JSON Schema form), as text
+ * shape, over the default graph of `data`. The Lean validator decides
+ * every schema it reads, so the answer is a boolean (the type keeps
+ * `null`, which an engine that defers a schema would answer). An
+ * `IMPORT` in the schema is not followed.
+ * @param schemaJson the schema as text: ShExJ when its first
+ *   non-whitespace character is '{', ShExC otherwise
  * @param focus an IRI, "_:label", or an RDF/JS NamedNode/BlankNode term
  * @param shape a shape label (same shapes as focus); omit/null for the
  *   schema's own `start`
@@ -326,18 +515,17 @@ export function shexValidate(
   schemaJson: string,
   focus: string | NamedNode | BlankNode,
   shape?: string | NamedNode | BlankNode | null,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<boolean | null>;
 
 /**
  * RDFS or OWL-RL entailment closure, materialized as a new Dataset
- * (input triples + derived triples). Needs the npm-entry engine
- * bundle. Default graph only.
+ * (input triples + derived triples). Default graph only.
  */
 export function owlClosure(
   data: DataInput,
   mode: 'RDFS' | 'OWL-RL',
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<Dataset>;
 
 /**
@@ -346,7 +534,7 @@ export function owlClosure(
  * `rho_df_closure`): rdfs2/3/5/7/9/11 only, with the machine-checked
  * decides-iff — on fragment inputs the result's simple query answers
  * are exactly the entailed consequences (see
- * docs/theorem-registry.md). Returns N-Triples text plus status.
+ * docs/theorem-registry.md). Returns the closure as a new Dataset.
  * "corerdfs" is this project's API name for the fragment the
  * literature calls ρdf (subPropertyOf/subClassOf/type/domain/range —
  * Muñoz, Pérez & Gutierrez, "Simple and Efficient Minimal RDFS",
@@ -354,29 +542,28 @@ export function owlClosure(
  */
 export function coreRdfsClosure(
   data: DataInput,
-  options?: { format?: DataFormat }
-): Promise<{ ok: boolean; ntriples: string }>;
+  options?: { format?: DataFormat; baseIRI?: string }
+): Promise<Dataset>;
 
 /**
- * Decidable core-RDFS fragment check (`is_rho_df_frag`, with its F*
- * lemma tying it to the prop the regime theorems quantify over): does
- * the certified path's guarantee apply to this data?
+ * Decidable core-RDFS fragment check (L4Factoidal/RDFS, `isRhoDfFrag`):
+ * is the data in the core-RDFS fragment coreRdfsClosure is defined for?
  */
 export function coreRdfsCheck(
   data: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<{ ok: boolean; fragment: boolean }>;
 
 /** Literature-name alias for coreRdfsClosure (ρdf). */
 export function rhoDfClosure(
   data: DataInput,
-  options?: { format?: DataFormat }
-): Promise<{ ok: boolean; ntriples: string }>;
+  options?: { format?: DataFormat; baseIRI?: string }
+): Promise<Dataset>;
 
 /** Literature-name alias for coreRdfsCheck (ρdf). */
 export function rhoDfFragmentCheck(
   data: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<{ ok: boolean; fragment: boolean }>;
 
 /**
@@ -389,41 +576,39 @@ export function rhoDfFragmentCheck(
  */
 export function rdfsPlusClosure(
   data: DataInput,
-  options?: { format?: DataFormat }
-): Promise<{ ok: boolean; ntriples: string; rounds: number }>;
+  options?: { format?: DataFormat; baseIRI?: string }
+): Promise<Dataset>;
 
 /**
- * OWL tableau materialisation (formal/fstar/Tableau.fst's
- * `tableau_materialise`): add `i rdf:type <ClassExpression>` for every
+ * OWL tableau materialisation (L4Factoidal/OWL/Materialise.lean,
+ * `materialiseWithBudget`): add `i rdf:type <ClassExpression>` for every
  * 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.
  * `dataset` is input + tableau-derived triples; `addedCount` is how
- * many triples the tableau added.
+ * many triples the tableau added; `budgetHit` is true when the work
+ * budget ran out, so an absent membership is then a cap, not a proof.
  */
 export function tableauMaterialise(
   data: DataInput,
-  options?: { format?: DataFormat }
-): Promise<{ dataset: Dataset; addedCount: number }>;
+  options?: { format?: DataFormat; baseIRI?: string }
+): Promise<{ dataset: Dataset; addedCount: number; budgetHit?: boolean }>;
 
 /**
- * OWL DL inconsistency verdict (bin/owl-runner's DL pipeline: OWL-RL
- * closure -> tableau materialise -> OWL-RL closure -> is_inconsistent).
+ * OWL DL inconsistency verdict: OWL RL closure, one class-expression
+ * materialisation pass, OWL RL closure again, then the clash decision.
  * `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.
  */
 export function tableauDlInconsistent(
   data: DataInput,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<{ inconsistent: boolean; rlAlone: boolean }>;
 
 /**
- * OWL DL consistency verdict via the verified clash-detecting tableau
- * (Tableau.Refute.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 engine bundle.
+ * OWL DL consistency verdict via the clash-detecting tableau
+ * (L4Factoidal/OWL/Refute.lean) over the OWL RL closure.
  * Default graph only. `consistent` is three-valued: `false` (a clash on
  * every branch), `true` (a model built), or `null` -- a budget-out, with
  * `reason` naming the fuel cap (never a silent false).
@@ -434,11 +619,9 @@ export function owlIsConsistent(
 ): Promise<{ consistent: boolean | null; reason?: string }>;
 
 /**
- * OWL entailment check: does `premise` entail `conclusion`? Verified
- * two-path dispatch: `via: "closure"` (the conclusion is in the OWL-RL
+ * OWL entailment check: does `premise` entail `conclusion`? Two paths: `via: "closure"` (the conclusion is in the OWL-RL
  * closure of the premise) or `via: "refutation"` (the negated
- * conclusion is refuted on every goal). Needs the npm-entry engine
- * bundle. Default graph only. `entailed` is `true`, `false`, or `null`
+ * conclusion is refuted on every goal). Default graph only. `entailed` is `true`, `false`, or `null`
  * (a refutation budget-out, with `reason` naming the cap).
  */
 export function owlEntails(
@@ -449,8 +632,7 @@ export function owlEntails(
 
 /**
  * Evaluate an RML mapping graph against one logical source's raw data,
- * returning the generated triples as a Dataset. Needs the npm-entry
- * engine bundle. Every triples map in `mapping` reads the SAME
+ * returning the generated triples as a Dataset. Every triples map in `mapping` reads the SAME
  * `sourceData` -- joins across two different logical sources are out
  * of scope for this entry point.
  * @param mapping the RML mapping graph (Turtle by default)
@@ -460,7 +642,7 @@ export function rmlMap(
   mapping: DataInput,
   sourceData: string,
   sourceKind: 'json' | 'csv',
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<Dataset>;
 
 export interface CsvwOptions {
@@ -480,7 +662,7 @@ export interface CsvwOptions {
  * CSVW csv2rdf conversion (w3.org/TR/csv2rdf): convert raw tabular
  * data plus an optional CSVW metadata document (JSON text -- '' or
  * omitted infers the schema from the CSV's own header row) into a
- * Dataset. Needs the npm-entry engine bundle. Every table in a
+ * Dataset. Every table in a
  * multi-table `tables` group reads the SAME `csvText`.
  */
 export function csvwToRdf(
@@ -498,9 +680,9 @@ export interface JsonLdOptions {
 
 /**
  * Parse a JSON-LD document into a Dataset, with JSON-LD-specific
- * options `parse()` has no room for. Needs the npm-entry engine
- * bundle (plain `parse(text, {format:'jsonld'})` also works for the
- * common case).
+ * options `parse()` has no room for (plain `parse(text,
+ * {format:'jsonld'})` also works for the common case). A remote
+ * `@context` is not fetched.
  */
 export function jsonldToRdf(
   jsonldText: string,
@@ -516,8 +698,7 @@ export interface JsonLdFromRdfOptions {
 /**
  * Serialize an RDF dataset as an expanded-form JSON-LD document -- the
  * reverse of jsonldToRdf (the verified JSONLD.FromRdf.from_rdf).
- * Returns the parsed JSON-LD value (an array of node objects). Needs
- * the npm-entry engine bundle.
+ * Returns the parsed JSON-LD value (an array of node objects).
  */
 export function jsonldFromRdf(
   data: DataInput,
@@ -527,14 +708,14 @@ export function jsonldFromRdf(
 /**
  * did:key resolution: resolve a `did:key:z6Mk...` (Ed25519) to its DID
  * Document, returned as a Dataset (the verified DID_Key.did_key_document).
- * Needs the npm-entry engine bundle.
+ *
  */
 export function didKeyResolve(didString: string): Promise<Dataset>;
 
 /**
- * Test whether an XML document is well-formed (Parser_XML). The
- * byte-oriented parser has no DOCTYPE/DTD production, so a document
- * containing a DOCTYPE reports false. Needs the npm-entry engine bundle.
+ * Test whether an XML document is well-formed (XML 1.0). A DOCTYPE with
+ * an internal subset is read (XML 1.0 section 2.8); an external DTD is
+ * not fetched.
  */
 export function xmlWellformed(xmlText: string): Promise<boolean>;
 
@@ -543,13 +724,16 @@ export interface XPathResult {
   resultType: 'nodeset' | 'string' | 'number' | 'boolean';
   count?: number;
   stringValue?: string;
+  /** `kind` includes 'root' and 'namespace' as well as 'element',
+   *  'attribute', 'text', 'comment' and 'processing-instruction'. */
   nodes?: Array<{ kind: string; name: string; value: string }>;
   value?: string | number | boolean;
 }
 
 /**
- * Evaluate an XPath 1.0 expression over an XML document
- * (XPath_Eval.eval_xpath_from_root). Needs the npm-entry engine bundle.
+ * Evaluate an XPath 1.0 expression over an XML document (the full
+ * XPath 1.0 function library). A number result is its XPath string form
+ * when it is not finite ('Infinity', 'NaN').
  */
 export function xpathEval(
   xmlText: string,
@@ -558,53 +742,228 @@ export function xpathEval(
 
 /**
  * RIF Core forward-chaining saturation, materialized as a new Dataset
- * (input triples + derived triples, default graph only). Needs the
- * npm-entry engine bundle.
+ * (input triples + derived triples, default graph only).
  * @param data the premise graph
  * @param rifRulesXml a RIF Core XML rule document
  */
 export function rifEval(
   data: DataInput,
   rifRulesXml: string,
-  options?: { format?: DataFormat }
+  options?: { format?: DataFormat; baseIRI?: string }
 ): Promise<Dataset>;
 
 // ---------------------------------------------------------------------
-// In-memory COTTAS bytes store (docs/designissues/2026-07-06-inmemory-
-// bytes-store.md). openCottas()'s handle is NOT a Dataset: rows decode
-// lazily as queryCottas() touches them, never materializing the whole
-// corpus onto the heap. Needs the npm-entry engine bundle.
+// The persisted store: Shardborough generations (IBK3, IBK4 and IBK5
+// blocks with their index sidecars) that `factoidal pack` or the native
+// l4block-shard-pack wrote. skills/shardborough-storage describes the
+// format. A Store is a store handle inside the engine: every artifact it
+// read was checked against the SHA-256 its manifest commits, once, and
+// every query answers from the decoded, indexed blocks it retains.
 // ---------------------------------------------------------------------
 
-/** Open a COTTAS/Parquet artifact's raw bytes as a queryable, read-only store. */
-export function openCottas(bytes: Uint8Array | ArrayBuffer | string): Promise<string>;
+/**
+ * Reads one file of a store: `path` is relative to the collection root
+ * ('CURRENT', 'gen-1/manifest.sbm2', 'gen-1/predicate-0.ibk3', ...). In a
+ * browser, a reader over fetch():
+ * `(p) => fetch(base + p).then((r) => r.arrayBuffer())`.
+ */
+export type StoreReader =
+  (path: string) => Uint8Array | ArrayBuffer | Promise<Uint8Array | ArrayBuffer>;
+
+export interface OpenStoreOptions {
+  /** Open this generation directory instead of the one CURRENT names. */
+  generation?: string;
+  /** Read only the artifacts this query's plan names. */
+  sparql?: string;
+  /** Read exactly these artifact keys. */
+  keys?: string[];
+}
+
+/** An open store handle (op storeOpen). */
+export class Store {
+  readonly handle: string;
+  readonly generation: string;
+  /** True when the generation was opened through CURRENT. */
+  readonly activated: boolean;
+  readonly identity: string;
+  /** The manifest layout label, e.g. 'predicate-ibk3-ptd1-sri2-tli1-oli2-merkle-v0'. */
+  readonly layout: string;
+  readonly wireVersion: number;
+  /** Artifacts read and verified. */
+  readonly artifacts: number;
+  /** Artifact bytes read. */
+  readonly bytes: number;
+  /** Rows the handle retains. */
+  readonly rows: number;
+  readonly closed: boolean;
+  /** One SPARQL 1.1 query against the retained blocks. The engine refuses
+   *  a query whose plan needs a block the handle did not read. */
+  query(sparql: string): Promise<Bindings[] | boolean | Dataset>;
+  /** The manifest, decoded by the engine (op storeManifestInspect). */
+  inspect(): Promise<Record<string, unknown>>;
+  /** Release the handle. Idempotent. */
+  close(): Promise<void>;
+}
 
 /**
- * Run a SPARQL 1.1 query against a store opened by openCottas(). No
- * `entail` option and no write overlay (read-only) -- see
- * npm/factoidal/lib/api.js's queryCottas doc comment for the full
- * divergence list from query().
- * @param handle from openCottas()
+ * Open a store. `source` is a collection root path (Node; the directory
+ * holding CURRENT) or a StoreReader (any runtime). With no options every
+ * artifact the manifest declares is read. Large collections need a
+ * deeper call stack than Node's default: see
+ * `@factoidal/core/store-worker` (README "The persisted store").
  */
-export function queryCottas(
-  handle: string,
-  sparql: string
+export function openStore(source: string | StoreReader, options?: OpenStoreOptions): Promise<Store>;
+
+/** One query against a store: open with the query's plan, query, close. */
+export function queryStore(
+  source: string | StoreReader,
+  sparql: string,
+  options?: { generation?: string }
 ): Promise<Bindings[] | boolean | Dataset>;
 
-/** Release a store opened by openCottas(). */
-export function closeCottas(handle: string): Promise<void>;
+/** The store handles this engine instance holds open, with the residency caps (op storeHandleList). */
+export function listStores(): Promise<Record<string, unknown>>;
+
+/**
+ * A durable update log (hub post 18): the object deltaLogOpen() returns.
+ * In the browser the log is an IndexedDB database named `dbName`; under
+ * Node it lives in the memory of the process.
+ */
+export interface DeltaLogHandle {
+  dbName: string;
+}
+
+/** What deltaLogInspect() reports (op deltaLogDecode). */
+export interface DeltaLogInspection {
+  /** Batches (records) that verify, from the start of the log. */
+  batches: number;
+  /** Entries in those batches. */
+  entries: number;
+  /** The log ends with a torn final record: an append that did not complete. */
+  torn: boolean;
+  /** Bytes of that torn record (0 when the log is not torn). */
+  tornBytes: number;
+  /** Bytes of the whole log. */
+  logBytes: number;
+  records: Array<{ seq: number; epoch: number; entries: number }>;
+}
+
+/** Open (create when absent) a durable update log. Default name 'factoidal-delta-log'. */
+export function deltaLogOpen(dbName?: string): Promise<DeltaLogHandle>;
+
+/**
+ * Append one SPARQL Update request as one record (op deltaLogEncode).
+ * INSERT DATA, DELETE DATA, CLEAR DEFAULT, CLEAR GRAPH, DROP GRAPH and
+ * CREATE GRAPH are admitted; any other form rejects and nothing is written.
+ */
+export function deltaLogAppend(
+  handle: DeltaLogHandle,
+  sparqlUpdate: string,
+  options?: { epoch?: number }
+): Promise<{ seq: number; opCount: number }>;
+
+/** The records of the log, in commit order, as hexadecimal text joined by "\n". */
+export function deltaLogReadAllHex(handle: DeltaLogHandle): Promise<string>;
+
+/**
+ * Merge on read (op deltaLogMerge): `baseNQuads` with the batches of the log
+ * applied in commit order, as N-Quads. A torn final record (an append that
+ * did not complete) is not applied. A damaged record, or a record whose
+ * entries the engine cannot decode, makes the merge reject: the records after
+ * it would otherwise be lost (https://github.com/danbri/factoidal/issues/843).
+ */
+export function deltaLogMerge(handle: DeltaLogHandle, baseNQuads: string): Promise<string>;
 
 /**
- * Serialize a dataset to COTTAS/Parquet bytes via the native writer
- * (RDF.CottasStore.BaseWriter.serialize_cottas_v2). Round-trips into
- * openCottas().
+ * What the log holds, record by record (op deltaLogDecode). Rejects for a
+ * damaged record or a record whose entries the engine cannot decode.
  */
-export function toCottas(data: DataInput): Promise<Uint8Array>;
+export function deltaLogInspect(handle: DeltaLogHandle): Promise<DeltaLogInspection>;
+
+/** Remove the log and its records. */
+export function deltaLogDestroy(handle: DeltaLogHandle): Promise<void>;
+
+/** TEST ONLY: cut the last 4 bytes of the last record, as a torn write would. False when the log is empty. */
+export function _deltaLogCorruptLastForTest(handle: DeltaLogHandle): Promise<boolean>;
+
+
+
+// ---------------------------------------------------------------------
+// Common Logic (ISO/IEC 24707:2018) and IKL
+// ---------------------------------------------------------------------
+
+// Reads Common Logic Interchange Format
+// text (ISO/IEC 24707:2018), with the IKL `that`-operator extension,
+// and reports its shape -- it never produces RDF. `pureCL` is a
+// DIALECT flag, not a validity or quality signal: true while the text
+// stays inside ISO/IEC 24707 Common Logic, false once it uses IKL's
+// `that` operator. A CLIF text that fails to parse rejects instead of
+// returning either value.
+export function clParse(clifText: string): Promise<{
+  ok: boolean;
+  sentences: number;
+  pureCL: boolean;
+  normalized: string;
+}>;
+
+// Reads CLIF text and writes it
+// back out in canonical spacing. `roundTripProved` is ALWAYS `false`:
+// `clif_roundTrip` (CL/ClifAdequacy.lean) is an OPEN lemma -- the
+// fragment boundary `marksLexable` is MEASURED, not proved. The field
+// is surfaced, not dropped or defaulted away, so a caller does not
+// have to go find that out.
+export function clSerialize(clifText: string): Promise<{
+  ok: boolean;
+  clif: string;
+  sentences: number;
+  roundTripProved: false;
+}>;
+
+// Alpha-normalises CLIF text: the
+// canonical representative of each sentence's bound-variable-renaming
+// equivalence class -- IKL GUIDE Appendix B condition (1), renaming a
+// bound variable does not change the proposition expressed. Two
+// sentences that differ only in bound-variable names produce
+// byte-identical `clif` output.
+export function clAlphaNorm(clifText: string): Promise<{
+  ok: boolean;
+  clif: string;
+  sentences: number;
+}>;
+
+// Hayes's reduction of IKL to
+// Common Logic (danbri/factoidal#625), over a whole text.
+//
+// `preserves: "satisfiability"` -- the reduction preserves
+// satisfiability, NOT equivalence. It suits entailment and consistency
+// testing; it is not a transformation to apply to data you intend to
+// keep.
+//
+// `noIntrusion` IS the proof hypothesis `CL.noIntrSs [] []` decides,
+// not a paraphrase of it. The transformation runs and returns output
+// either way; when `noIntrusion` is `false`, `tails_satisfiable` /
+// `normalize_preserves` do not cover that output.
+export function clNormalize(clifText: string): Promise<{
+  ok: boolean;
+  head: string[];
+  tail: string[];
+  clif: string;
+  sentences: number;
+  thatCount: number;
+  noIntrusion: boolean;
+  preserves: 'satisfiability';
+  provedUnder: string;
+}>;
+
+// clFiniteSat is DEFERRED from this typed surface (owner decision,
+// 2026-08-26), not excluded: it takes a caller-supplied finite-
+// interpretation JSON encoding that has no user yet. Reachable only
+// through the raw dispatch ABI (`(await loadEngine()).call('clFiniteSat',
+// [interpJson, clifText])`), which needs no typed shape commitment here.
 
 // ---------------------------------------------------------------------
 // Typed engine functions (#74 npm FP surface). Each is a pure,
-// value-in / value-out wrapper over one F*-extracted engine; all need
-// the npm-entry bundle.
+// value-in / value-out wrapper over one engine op.
 // ---------------------------------------------------------------------
 
 /**
@@ -743,100 +1102,17 @@ export function toanSubst(
   value: ToanExpr
 ): Promise<string>;
 
-/** A matrix/vector cell: an integer or an exact [num, den] rational. */
-export type MatrixCell = number | [number, number];
-
-/** The rendered result of a matrix/vector operation. */
-export interface MatrixResult {
-  /** Math.Matrix.mres_to_string of the result ("undef" on failure). */
-  result: string;
-  /** The diagnostic reason when the result is undefined, else "". */
-  reason: string;
-}
-
-/** Exact determinant of a square matrix (Math.Matrix.dyn_determinant). */
-export function matrixDeterminant(
-  matrix: MatrixCell[][]
-): Promise<MatrixResult>;
-
-/** Dot product of two vectors (Math.Matrix.dyn_scalarproduct). */
-export function matrixScalarProduct(
-  a: MatrixCell[],
-  b: MatrixCell[]
-): Promise<MatrixResult>;
-
-/** Cross product of two 3-vectors (Math.Matrix.dyn_vectorproduct). */
-export function matrixVectorProduct(
-  a: MatrixCell[],
-  b: MatrixCell[]
-): Promise<MatrixResult>;
-
-/** Outer product of two vectors (Math.Matrix.dyn_outerproduct). */
-export function matrixOuterProduct(
-  a: MatrixCell[],
-  b: MatrixCell[]
-): Promise<MatrixResult>;
-
-/**
- * A fixed-precision decimal (Math.Sigmoid.scaled: mantissa / 10^scale),
- * the same (mantissa, scale) convention SPARQL11.Algebra.parse_to_scaled
- * uses for xsd:decimal literals. `decimal` is the same pair formatted
- * back to a string by SPARQL11_Algebra.format_scaled_value.
- */
-export interface ScaledValue {
-  mantissa: string;
-  scale: string;
-  decimal: string;
-}
 
-/** Parameters for {@link sigmoidPoints}: decimal-literal strings/numbers. */
-export interface SigmoidParams {
-  k: number | string;
-  x0: number | string;
-  l: number | string;
-  xmin: number | string;
-  xmax: number | string;
-  n: number | string;
-}
-
-/**
- * n+1 evenly spaced samples of the logistic sigmoid
- * L / (1 + exp(-k*(x - x0))) over [xmin, xmax] (Math.Sigmoid.
- * sigmoid_points). All arithmetic -- argument reduction, the
- * truncated Taylor series, repeated squaring, and the x samples
- * themselves -- runs as exact rational arithmetic inside
- * Math.Sigmoid.fst; see that module's header for the documented error
- * bound on the returned (rounded) values.
- */
-export function sigmoidPoints(
-  params: SigmoidParams
-): Promise<Array<{ x: ScaledValue; y: ScaledValue }>>;
-
-/**
- * Presentation MathML for the sigmoid formula L / (1 + exp(-k*(x - x0))),
- * engine-serialized (MathML.Present.to_presentation_mathml applied to a
- * fixed Math.Expr.expr) -- never hand-written MathML.
- */
-export function sigmoidFormulaMathml(): Promise<string>;
 
 // ---------------------------------------------------------------------
-// VC Data Integrity crypto (eddsa-rdfc-2022) — the F*-extracted
-// VC_DataIntegrity pipeline, its four crypto assume vals realised by
-// HACL*'s OWN official WebAssembly build (hacl-wasm). All need the
-// npm-entry bundle AND the HACL* wasm backend.
-//
-// Init story: on the Node entries (index.js/index.mjs and the /wasm
-// entry) these typed wrappers AUTO-AWAIT initHacl() on the first VC
-// call — a caller never has to remember the init step. In the browser
-// (browser.js) the page must initialise HACL* itself first (the
-// hacl-wasm URL is page-specific); see browser.js's VC section. Either
-// way, an uninitialised backend makes verify THROW, never silently
-// return true (#286, the throw-on-uninit contract).
+// VC Data Integrity crypto (eddsa-rdfc-2022), the ops of
+// formal/lean4/Wasm/Ops/Vc.lean. Ed25519 is HACL*'s C code compiled into
+// the wasm module; SHA-256 is the Lean hash. No initialisation step.
 // ---------------------------------------------------------------------
 
 /**
  * SHA-256 of a message string's bytes, as a lowercase hex digest
- * (VC_DataIntegrity.hash_sha256_hex, HACL* SHA-2).
+ * (the Lean SHA-256).
  */
 export function vcSha256Hex(message: string): Promise<string>;
 
@@ -885,7 +1161,7 @@ export function vcEddsaVerifyFromCanonical(
 
 /**
  * VC Data Model 2.0 structural conformance check (VC.Credential.fst's
- * vc_check_from_string, F*-verified — 117 pass, 0 fail on the offline
+ * vc_check_from_string, ported to L4Factoidal/VC/Credential.lean — 117 pass, 0 fail on the offline
  * vc_stage1 fixture suite). Pure structural validation, no crypto.
  * `v2ctxJson` is the vendored VCDM v2 base context document's raw JSON
  * text (third_party/contexts/credentials-v2.jsonld); `credentialJson`
@@ -928,7 +1204,11 @@ export function vcCheckRelatedResourceDigests(
   credentialJson: string
 ): Promise<{ valid: boolean; reason?: string }>;
 
-/** Feature probe for the currently available engine bundles. */
+/**
+ * Feature probe: which ops the loaded wasm module serves. A module older
+ * than this package can lack some; an operation whose op is missing
+ * rejects naming it.
+ */
 export function capabilities(): Promise<{
   entry: boolean;
   construct: boolean;
@@ -954,21 +1234,32 @@ export function capabilities(): Promise<{
   jsonSchema: boolean;
   schematron: boolean;
   toan: boolean;
-  matrix: boolean;
-  /** The sigmoid (Math.Sigmoid) ABI exports are present. */
-  sigmoid: boolean;
-  /**
-   * The VC Data Integrity crypto ABI exports are present. Note: the
-   * HACL* wasm backend is still initialised at call time — this flag
-   * reports export availability, not that init has run.
-   */
+  /** The VC Data Integrity crypto ops are present. */
   vcCrypto: boolean;
-  /** The in-memory COTTAS bytes store exports are present. */
-  cottasBytesStore: boolean;
+  /** query()'s `entail` regimes (op queryRaw) are served. */
+  entailment: boolean;
+  /** queryHdt() (op queryHdt) is served. */
+  hdt: boolean;
+  /** query()'s `sparql12` and DatasetHandle.query's (queryDataset12, datasetQuery12). */
+  sparql12: boolean;
+  /** openStore() and the Store methods (storeOpen, storeHandleQuery). */
+  store: boolean;
+  /** The deltaLog* functions (deltaLogEncode, deltaLogDecode, deltaLogMerge). */
+  deltaLog: boolean;
+  /** 'full': the whole library is in the wasm module. */
+  profile: 'full' | string;
+  /** The dispatch ABI version string of the loaded wasm module. */
+  abiVersion: string;
+  /** openDataset()/DatasetHandle (datasetOpen/Query/Update/Serialize/Close) are present. */
+  datasetHandles: boolean;
+  /** parse()'s `{lenient:true}` (parseDocument) is present. */
+  parseDiagnostics: boolean;
+  /** serialize()'s `{prefixes, literalShorthand}` (serializeTurtleWith) is present. */
+  turtlePrefixes: boolean;
 }>;
 
 // ---------------------------------------------------------------------
-// Legacy raw surface (single-shot CLI shapes)
+// One call, serialised answer (op queryRaw)
 // ---------------------------------------------------------------------
 
 /** SPARQL Results JSON term (https://www.w3.org/TR/sparql11-results-json/). */
@@ -989,8 +1280,13 @@ export type OutputFormat =
   | 'json' | 'csv' | 'tsv' | 'xml' | 'table' | 'ntriples';
 
 /**
- * Legacy single-shot API: returns parsed SPARQL Results JSON when
- * output is 'json' (default), the raw output string otherwise.
+ * One call, serialised answer: parse `dataString`, close the default
+ * graph under `entail`, run the query. Resolves to parsed SPARQL Results
+ * JSON when output is 'json' (default), the text otherwise. 'csv', 'tsv'
+ * and 'xml' are the W3C SPARQL results formats (CSV and TSV have no ASK
+ * encoding, so an ASK with those rejects); 'table' and 'ntriples' are
+ * display formats. A CONSTRUCT or DESCRIBE answer is a graph and takes
+ * 'ntriples' or 'table' only.
  */
 export function queryRaw(
   dataString: string,
@@ -1002,14 +1298,33 @@ export function queryRaw(
   }
 ): Promise<SparqlResultsJson | string>;
 
-/** Package version string, e.g. '0.1.0-alpha.0'. */
+/** Package version string, e.g. '0.9.0'. */
 export const version: string;
 
+/** The engine: 'lean4-wasm'. */
+export const engine: string;
+
+/**
+ * The loaded Lean engine handle, for the dispatch ops this package does
+ * not wrap: `call(op, args)` answers the parsed envelope and throws on
+ * {"ok":false}; `call('ops', [])` lists the op names. Node: index.mjs;
+ * browser: browser.js.
+ */
+export function loadEngine(): Promise<{
+  version(): string;
+  call(op: string, args: string[]): any;
+  callBlob(op: string, args: string[], bytes: Uint8Array | ArrayBuffer): any;
+  callBlobIO(op: string, args: string[], bytes?: Uint8Array | ArrayBuffer): { envelope: any; bytes: Uint8Array };
+}>;
+
 declare const _default: {
   parse: typeof parse;
   query: typeof query;
   queryHdt: typeof queryHdt;
   update: typeof update;
+  openDataset: typeof openDataset;
+  closure: typeof closure;
+  formats: typeof formats;
   serialize: typeof serialize;
   canonicalize: typeof canonicalize;
   graphs: typeof graphs;
@@ -1029,10 +1344,20 @@ declare const _default: {
   xmlWellformed: typeof xmlWellformed;
   xpathEval: typeof xpathEval;
   rifEval: typeof rifEval;
-  openCottas: typeof openCottas;
-  queryCottas: typeof queryCottas;
-  closeCottas: typeof closeCottas;
-  toCottas: typeof toCottas;
+  clParse: typeof clParse;
+  clSerialize: typeof clSerialize;
+  clAlphaNorm: typeof clAlphaNorm;
+  clNormalize: typeof clNormalize;
+  openStore: typeof openStore;
+  queryStore: typeof queryStore;
+  listStores: typeof listStores;
+  deltaLogOpen: typeof deltaLogOpen;
+  deltaLogAppend: typeof deltaLogAppend;
+  deltaLogReadAllHex: typeof deltaLogReadAllHex;
+  deltaLogMerge: typeof deltaLogMerge;
+  deltaLogInspect: typeof deltaLogInspect;
+  deltaLogDestroy: typeof deltaLogDestroy;
+  _deltaLogCorruptLastForTest: typeof _deltaLogCorruptLastForTest;
   xsltTransform: typeof xsltTransform;
   mathmlEval: typeof mathmlEval;
   xformsRecalc: typeof xformsRecalc;
@@ -1043,12 +1368,6 @@ declare const _default: {
   toanSimplify: typeof toanSimplify;
   toanDiff: typeof toanDiff;
   toanSubst: typeof toanSubst;
-  matrixDeterminant: typeof matrixDeterminant;
-  matrixScalarProduct: typeof matrixScalarProduct;
-  matrixVectorProduct: typeof matrixVectorProduct;
-  matrixOuterProduct: typeof matrixOuterProduct;
-  sigmoidPoints: typeof sigmoidPoints;
-  sigmoidFormulaMathml: typeof sigmoidFormulaMathml;
   vcSha256Hex: typeof vcSha256Hex;
   vcEd25519SecretToPublic: typeof vcEd25519SecretToPublic;
   vcEd25519Sign: typeof vcEd25519Sign;
@@ -1061,8 +1380,28 @@ declare const _default: {
   vcCheckRelatedResourceDigests: typeof vcCheckRelatedResourceDigests;
   capabilities: typeof capabilities;
   Dataset: typeof Dataset;
+  DatasetHandle: typeof DatasetHandle;
+  Store: typeof Store;
+  ParseError: typeof ParseError;
   dataFactory: DataFactory;
   queryRaw: typeof queryRaw;
   version: string;
+  engine: string;
 };
 export default _default;
+
+// Added in 0.10.0 (lib/pure.mjs).
+export function aeadSeal(a: { key: Uint8Array; nonce: Uint8Array; plaintext?: Uint8Array; aad?: Uint8Array }): Promise<Uint8Array>;
+export function aeadOpen(a: { key: Uint8Array; nonce: Uint8Array; ciphertext: Uint8Array; aad?: Uint8Array }): Promise<Uint8Array>;
+export function hpkeSeal(a: { skE: Uint8Array; pkR: Uint8Array; plaintext?: Uint8Array; info?: Uint8Array; aad?: Uint8Array }): Promise<{ message: Uint8Array; enc: Uint8Array; ciphertext: Uint8Array }>;
+export function hpkeOpen(a: { skR: Uint8Array; message: Uint8Array; info?: Uint8Array; aad?: Uint8Array }): Promise<Uint8Array>;
+export function proofCheck(bundleJson: string): Promise<Record<string, unknown>>;
+export function proofInspect(bundleJson: string): Promise<Record<string, unknown>>;
+export function canonicalizeNQuads(nquads: string): Promise<string>;
+export function normalizeNQuads(nquads: string): Promise<string>;
+export function serveStore(root: string, options?: { port?: number; host?: string; queryPath?: string; gspPath?: string; tdb2?: boolean }): Promise<{ url: string; port: number; close(): Promise<void> }>;
+
+/** Pack a small built-in store (Node only) under dir or a temporary directory; returns the collection root. */
+export function sampleStorePath(dir?: string): string;
+/** What the sample store holds. */
+export const sampleStoreFacts: Readonly<{ triples: number; source: string; layout: string }>;