@factoidal/core 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.20.0 (2026-10-27)
+
+- **Breaking:** in a checked pipeline (`node`, `pipe`, `run`), each node now puts a value of its output wire on the wire: text after a writer, the rows after SELECT, a boolean after ASK, the report after `shaclValidator`, `[canonical, sha256]` after `rdfcStage`, the result after `rdfsExplainGraphStage`. Before, such a node left its input Dataset on the wire, so a well-typed reader → writer → reader pipeline failed at run time. `run()` rejects a runner value that is not of the node's `wireOut`. `rdfcStage` as a node takes a Dataset only (https://github.com/danbri/factoidal-core/pull/155).
+- `node()` keeps its own copy of its settings (frozen at every depth; a Dataset is cloned). A change to the caller's objects after `node()` no longer changes what runs while the evidence keeps the old `settingsDigest`. `run()` rejects a node whose settings changed through `node.params` (https://github.com/danbri/factoidal-core/pull/155).
+- **Breaking:** `canonicalHash(dataset)` keeps graph names: it is the SHA-256 of the text `canonicalize()` answers. 0.17.0 to 0.19.0 dropped graph names, so datasets that differ only in graph names got one hash. New `asDefaultGraph(dataset)`; `canonicalHash(asDefaultGraph(g))` gives a graph's hash whatever its name (https://github.com/danbri/factoidal-core/pull/155).
+- SBM11 stores opened with `openSbm11` (and the wasm ops `sbm11Open` / `sbm11Query`) are checked against their Merkle roots by default: the open admits each file's `.merkle` sidecar against `manifest.sbm11`, and every byte a query decodes comes from a 65,536-byte chunk checked by its Merkle proof. A changed data file, sidecar or Merkle reference in the manifest fails the open or the query with an error that names the file (before, a changed `dict.gdv1` was answered as data). `openSbm11(source, { verify: 'none' })` keeps the earlier length-only check; `store.verify` says which mode is in use. Measured cost: within run-to-run noise on stores of 1 to 6 MB (https://github.com/danbri/factoidal-core/pull/157).
+- Parse is faster again after the IRI check of 0.19.0 (https://github.com/danbri/factoidal/issues/1057): the check tests bytes, and a repeated IRI is not checked again. Parse of 100,000 triples is now about 3% slower than 0.18.0 (it was 10% to 19%). The IRIs that are accepted and refused do not change (https://github.com/danbri/factoidal-core/pull/158).
+- CID 1.0 (Controlled Identifiers, W3C Recommendation 2025-05-15): new Lean module `L4Factoidal/CID/` with the section 2 data model (one named error per MUST), Multikey and JsonWebKey material, the five verification relationships, Fragment Resolution, Retrieve Verification Method and the section 3.5 processing errors. The CID context is vendored. Authorization server, CID suite (lws10-authn-ssi-cid): the subject document is checked as a whole and the method is found by Retrieve Verification Method with `authentication`; `expires`/`revoked` need a time zone; `Accept` starts with `application/cid`. VC Data Integrity (Lean): `verificationMethod` can be a method in a controlled identifier document (not only an Ed25519 did:key), and it must be in the relationship that `proofPurpose` names. No npm functions yet (https://github.com/danbri/factoidal/issues/1100, https://github.com/danbri/factoidal-core/pull/161).
+- `parse` takes the option `rdfstar` for JSON-LD, as the 0.18.0 changelog says: `parse(text, { format: 'jsonld', rdfstar: true })` reads `@triple`, `@reifies` and `@annotation` as RDF 1.2 triple terms and reifiers, as `jsonldToRdf` does. 0.18.0 and 0.19.0 refused the option with `option.unknown`. `rdfstar` with another format, or with `lenient`, is refused with `option.conflict` (https://github.com/danbri/factoidal/issues/1091, https://github.com/danbri/factoidal-core/pull/152).
+- Docs: hub page "JSON-LD-star and JSON-LD 1.3" (`docs/web/hub/jsonld-star.md`), with live cells on 0.19.0; the hub pages load 0.19.0 (were 0.16.0).
+- Value matching (https://github.com/danbri/factoidal/issues/1052): new `sameValue(a, b)` is SPARQL 1.1 `=` on two terms (sections 17.3, 17.4.1.7), decided by the engine (Lean `SPARQL/SameValue.lean`). It answers `true`, `false`, or `null` for incomparable (the type error of `=`). `Dataset.has`, `match` and `delete` take `{match: 'value'}`: a literal object then matches each object literal of the same value (`"1"^^xsd:int` finds `"01"^^xsd:integer` and `"1.0"^^xsd:decimal`), through an index of the literals by value. Term matching stays the default. New wasm op `sameValue`; `datasetMatch`, `datasetMatchCount` and `datasetDeleteQuadsJson` take an optional options argument.
+- Syntax names (https://github.com/danbri/factoidal/issues/1053): new `syntaxFor(fileName)` and `syntaxFor({fileName, mediaType})` give the syntax of a document from the W3C registrations (Lean `RDF/MediaType.lean`), or `null`. Each row of `formats()` has `mediaTypes` and `extensions` from the same table (README format table: two new columns). New wasm op `syntaxFor`.
+- IRIs, vocabularies, lists and containers (https://github.com/danbri/factoidal/issues/1051 items 4 to 6): new `splitIri(iri)` (namespace and the longest XML NCName suffix), `isNCName(text)`, `vocabularies()` (rdf, rdfs, xsd and owl with their terms; foaf, dcterms, dc and schema namespaces), `memberIri(n)` and `memberOrdinal(iri)` (`rdf:_n`). Dataset methods `listItems(head, graph?)` (refuses a list that is not well formed, with the reason), `containerItems(node, graph?)` and `addList(items, graph?)`. Lean `RDF/IriSplit.lean`, `RDF/VocabularyTable.lean`, `RDF/Collections.lean`. New wasm ops `splitIri`, `isNCName`, `vocabularies`, `memberIri`, `memberOrdinal`, `datasetListItems`, `datasetContainerItems`, `datasetAddList`. These need a wasm built from this source.
+- Literal values (https://github.com/danbri/factoidal/issues/1051 items 1 to 3). New functions `literalValue(term)`, `isValidLiteral(term)`, `canonicalLiteral(term)` and `literalFromValue(value, {datatype?})`, synchronous after `ready()` (API.md "Literal values"). `literalValue` gives the XSD 1.1 lexical-to-value mapping of a literal for every XSD built-in the engine has (numeric types and the derived integer types with their bounds, boolean, the string types, date/time and `g*` types, durations, binary, lists) and for `rdf:langString`, `rdf:dirLangString`, `rdf:XMLLiteral`, `rdf:JSON`: `{datatype, recognized, valid, value?, canonical?}`, with the value as JSON-safe data (a number that a JavaScript number does not hold exactly is a decimal string). `valid: false` is an ill-typed literal; `recognized: false` is a datatype the engine does not have. `literalFromValue` maps a boolean, number, bigint, string or Date to a typed literal with one engine table (safe integer `xsd:integer`, other number `xsd:double`, bigint `xsd:integer`, Date `xsd:dateTime` in UTC), or to a named datatype (`{datatype: 'int'}`) when the value is in its value space, else a `FactoidalError` with the new code `literal.value`. New wasm ops `literalValue` and `literalFromValue` (Lean `L4Factoidal/RDF/LiteralValue.lean`, `Wasm/Ops/LiteralValue.lean`). An extension function may now answer a `Date` (an `xsd:dateTime`).
+- The canonical form of an `xsd:float` or `xsd:double` value is now the XSD 1.1 Part 2 §3.3.4.2/§3.3.5.2 form (algorithm §E.1): the fewest significant digits that map back to the value. `"0.1"^^xsd:double` has the canonical form `1.0E-1`; before, it was the exact binary expansion `1.000000000000000055511151231257827021181583404541015625E-1`. It is the `canonical` member of `literalValue` and RML's canonical form of a double (RML-Core natural mapping). SPARQL casts do not change (`xsd:double("0.1")` is still `"0.1"^^xsd:double`). Theorems `double_canonical_roundTrip`, `float_canonical_roundTrip`, `integer_canonical_roundTrip` (`XSD/CanonicalTheorems.lean`).
+
 ## 0.19.0 (2026-10-27)
 
 - Notice (owner decision, 2026-10-27): "EXPERIMENTAL UNREVIEWED CODE - USE WITH CARE - DO NOT CREATE PUBLIC SERVICES USING THIS WITHOUT CAREFUL INDEPENDENT EXPERT REVIEW." It is at the top of both READMEs and the hub, in the package description, in every `factoidal` help text, and on standard error when `serve`, `lws-serve`, `solid-serve`, `solid-client`, `lws-client`, `authz-serve`, `authz-keys`, `xmpp-serve` or `webdav-serve` starts.

package/README.md

@@ -38,10 +38,14 @@ every consumer accepts one, so a pipeline does not re-parse between steps.
 An unknown option key throws. With no `format`, the format is inferred and
 reported in `dataset.format`; an explicit `format` is never overridden.
 RDF 1.2 input uses `turtle12`, `ntriples12`, `nquads12` or `trig12`.
+RDF 1.2 in JSON-LD (JSON-LD-star: `@triple`, `@reifies`, `@annotation`,
+`@direction`) needs the option `rdfstar`: `jsonldToRdf(text, { rdfstar: true })`
+and `dataset.serialize({ format: 'jsonld', rdfstar: true })`.
 
 ## What it does
 
 - Syntaxes: N-Triples, N-Quads, Turtle, TriG, RDF/XML, JSON-LD; RDF 1.1 and 1.2
+  (RDF 1.2 in JSON-LD through the JSON-LD-star draft, option `rdfstar`)
 - SPARQL 1.1 and 1.2 query and update; GeoSPARQL functions, text search,
   JavaScript extension functions, SERVICE
 - Reasoning: RDFS, OWL 2 RL closure, restricted checked OWL consistency,
@@ -118,19 +122,19 @@ and marks those steps in the evidence. Details: API.md, "Stages as nodes" and
 Formats (generated from `formats()`):
 
 <!-- formats-table:start (generated by test/formats-table.test.mjs) -->
-| format | read RDF 1.1 | read RDF 1.2 | write RDF 1.1 | write RDF 1.2 | engine |
-|---|---|---|---|---|---|
-| nquads | yes | yes | yes | yes | core |
-| ntriples | yes | yes | yes | yes | core |
-| turtle | yes | yes | yes | yes | core |
-| trig | yes | yes | yes | yes | core |
-| rdfxml | yes | no | yes | no | core |
-| jsonld | yes | no | yes | no | full |
-| rdfc | no | no | yes | no | core |
-| sparql-results-json | no | no | yes | yes | core |
-| sparql-results-xml | no | no | yes | yes | core |
-| sparql-results-csv | no | no | yes | yes | core |
-| sparql-results-tsv | no | no | yes | yes | core |
+| format | read RDF 1.1 | read RDF 1.2 | write RDF 1.1 | write RDF 1.2 | engine | media type | extension |
+|---|---|---|---|---|---|---|---|
+| nquads | yes | yes | yes | yes | core | `application/n-quads` | `.nq` |
+| ntriples | yes | yes | yes | yes | core | `application/n-triples` | `.nt` |
+| turtle | yes | yes | yes | yes | core | `text/turtle` | `.ttl` |
+| trig | yes | yes | yes | yes | core | `application/trig` | `.trig` |
+| rdfxml | yes | no | yes | no | core | `application/rdf+xml` | `.rdf` |
+| jsonld | yes | no | yes | no | full | `application/ld+json` | `.jsonld` |
+| rdfc | no | no | yes | no | core |  |  |
+| sparql-results-json | no | no | yes | yes | core |  |  |
+| sparql-results-xml | no | no | yes | yes | core |  |  |
+| sparql-results-csv | no | no | yes | yes | core |  |  |
+| sparql-results-tsv | no | no | yes | yes | core |  |  |
 <!-- formats-table:end -->
 
 Missing writers (HDT, N3, RDFa): https://github.com/danbri/factoidal/issues/883.
@@ -160,6 +164,7 @@ Codes (generated from `engineTables().errorCodes`):
 | `term.invalid-iri` | <https://www.w3.org/TR/rdf12-concepts/#section-IRIs> | A term that must be an IRI is not one. |
 | `term.invalid-langtag` | <https://www.w3.org/TR/rdf12-concepts/#section-Graph-Literal> | A language tag is not well-formed (BCP 47). |
 | `term.invalid` | <https://www.w3.org/TR/sparql11-results-json/#select-encode-terms> | A term or quad given as JSON is not an RDF term or quad. |
+| `literal.value` | <https://www.w3.org/TR/xmlschema11-2/#value-space> | The value is not in the value space of the named datatype, or the datatype is not one the engine has. |
 | `query.syntax` | <https://www.w3.org/TR/sparql11-query/#grammar> | The SPARQL query does not match the SPARQL grammar. |
 | `query.failed` | <https://www.w3.org/TR/sparql11-query/#sparqlDefinition> | The SPARQL query parsed but its evaluation was refused. |
 | `update.syntax` | <https://www.w3.org/TR/sparql11-update/#grammar> | The SPARQL update does not match the SPARQL Update grammar. |
@@ -239,6 +244,8 @@ and the [assurance record](https://github.com/danbri/factoidal-core/blob/main/do
 | JSON-LD 1.1 toRdf, expand, flatten | 910 / 0 / 910 |
 | JSON-LD 1.1 compact, fromRdf | 298 / 0 / 300 (2 not run) |
 | JSON-LD 1.1 Framing | 29 / 63 / 92 |
+| JSON-LD-star draft (RDF 1.2), option `rdfstar` | 168 / 1 / 171 (2 local override; 170 of 171 with them) [J] |
+| RDF 1.2 eval tests written as JSON-LD-star and read back | 140 / 0 / 140 [J] |
 | RDFC-1.0 | 86 / 0 / 86 |
 | OWL 2 RL | 126 / 0 / 126 |
 | OWL 2 DL type-inconsistency | 116 / 11 / 128 (1 other) |
@@ -262,6 +269,7 @@ and the [assurance record](https://github.com/danbri/factoidal-core/blob/main/do
 [L] 2026-10-22, https://github.com/danbri/factoidal-core/blob/2b9d2e39af53be31ed92463b58d3e132e65c4fe4/docs/designissues/2026-10-21-lws-touchstone-run.md (with server options, 220 of 221 pass in at least one configuration)
 [S] 2026-10-21, the current W3C manifest (29 active tests), https://github.com/danbri/factoidal-core/blob/2b9d2e39af53be31ed92463b58d3e132e65c4fe4/docs/claude-rules/current-state.md
 [C] 2026-10-21, validation test308, https://github.com/danbri/factoidal/issues/700
+[J] 2026-10-27, tests of https://github.com/json-ld/json-ld-star/pull/61; the fail is a defective fixture (fromRdf tst07), https://github.com/danbri/factoidal-core/blob/2a656d7bfb4af329d77669afb5e62eb00625bd15/docs/designissues/2026-10-26-jsonld-star.md
 
 ## Limits
 

package/browser.d.ts

@@ -12,6 +12,7 @@ export type {
   QueryOptions, SerializeOptions, StoreReader, OpenStoreOptions,
   DeltaLogHandle, DeltaLogInspection,
   Sbm11Reader, Sbm11Answer, Sbm11Store, Sbm11ReadEvidence, Sbm11Transport,
+  LiteralValueData, LiteralValueResult,
   ExplainResult, StageInfo, EvidenceRecord, Wire, FactoidalNode, Pipeline, RunResult, RunOptions,
 } from './index';
 
@@ -23,10 +24,22 @@ export {
   canonicalize,
   graphs,
   canonicalHash,
+  asDefaultGraph,
   isomorphic,
   fromQuads,
+  literalValue,
+  isValidLiteral,
+  canonicalLiteral,
+  literalFromValue,
   ready,
   engineTables,
+  sameValue,
+  syntaxFor,
+  splitIri,
+  isNCName,
+  vocabularies,
+  memberIri,
+  memberOrdinal,
   openDataset,
   closure,
   formats,

package/browser.js

@@ -83,10 +83,24 @@ export const serialize = api.serialize;
 export const canonicalize = api.canonicalize;
 export const graphs = api.graphs;
 export const canonicalHash = api.canonicalHash;
+export const asDefaultGraph = api.asDefaultGraph;
 export const isomorphic = api.isomorphic;
 export const fromQuads = api.fromQuads;
+// Literal values (https://github.com/danbri/factoidal/issues/1051): synchronous
+// after the engine is loaded.
+export const literalValue = api.literalValue;
+export const isValidLiteral = api.isValidLiteral;
+export const canonicalLiteral = api.canonicalLiteral;
+export const literalFromValue = api.literalFromValue;
 export const ready = api.ready;
 export const engineTables = api.engineTables;
+export const sameValue = api.sameValue;
+export const syntaxFor = api.syntaxFor;
+export const splitIri = api.splitIri;
+export const isNCName = api.isNCName;
+export const vocabularies = api.vocabularies;
+export const memberIri = api.memberIri;
+export const memberOrdinal = api.memberOrdinal;
 export const openDataset = api.openDataset;
 export const closure = api.closure;
 export const formats = api.formats;

package/index.d.ts

@@ -99,6 +99,7 @@ export type FactoidalErrorCode =
   | 'term.invalid-iri'
   | 'term.invalid-langtag'
   | 'term.invalid'
+  | 'literal.value'
   | 'query.syntax'
   | 'query.failed'
   | 'update.syntax'
@@ -236,6 +237,10 @@ export interface FormatCapability {
   write12: boolean;
   /** 'core' when both engines serve it; 'full' when only the full engine does. */
   engine: 'core' | 'full';
+  /** The registered media types (W3C registration; empty for a row with none). syntaxFor() reads the same table. */
+  mediaTypes: string[];
+  /** The registered file extensions, with the leading dot ('.ttl'). */
+  extensions: string[];
 }
 
 /**
@@ -283,11 +288,31 @@ export class Dataset implements Iterable<Quad> {
   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;
+  /**
+   * RDF/JS DatasetCore (https://rdf.js.org/dataset-spec/); match and has use
+   * the engine indexes. `{match: 'value'}`: a literal object matches every
+   * object literal that is the same term or has the same value (sameValue());
+   * the other positions match by term.
+   */
+  has(quad: Quad, options?: MatchOptions): boolean;
   add(quad: Quad): this;
-  delete(quad: Quad): this;
-  match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Dataset;
+  /** With `{match: 'value'}`: remove every quad of the same subject, predicate
+   *  and graph whose object has the same value as the quad's literal object. */
+  delete(quad: Quad, options?: MatchOptions): this;
+  match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null,
+    options?: MatchOptions): Dataset;
+  /**
+   * The items of the RDF list (rdf:first/rdf:rest) at `head`, in order
+   * (https://github.com/danbri/factoidal/issues/1051 item 6). `rdf:nil` is
+   * the empty list. A list that is not well formed (a node with no or with two
+   * rdf:first or rdf:rest, or a cycle) is a FactoidalError, code `op.failed`.
+   * `graph`: omitted, null or the DefaultGraph for the default graph.
+   */
+  listItems(head: Term, graph?: Term | null): Term[];
+  /** The members rdf:_1, rdf:_2, ... of `node`, sorted by n, and its kind (rdf:Bag, rdf:Seq, rdf:Alt) from its rdf:type. */
+  containerItems(node: Term, graph?: Term | null): { kind: NamedNode | null; items: Array<{ ordinal: number; term: Term }> };
+  /** Add a new RDF list of `items` on fresh blank nodes; answers its head (rdf:nil for no items). */
+  addList(items: Iterable<Term>, graph?: Term | null): Term;
   toArray(): Quad[];
   [Symbol.iterator](): Iterator<Quad>;
   dispose(): void;
@@ -380,6 +405,12 @@ export interface ParseOptions {
    * with one diagnostic of class 'too-many-errors'. Default: no limit.
    */
   maxErrors?: number;
+  /**
+   * Read JSON-LD as JSON-LD-star (`@triple`, `@reifies`, `@annotation` as
+   * RDF 1.2 triple terms and reifiers), as `jsonldToRdf` does. Format
+   * 'jsonld' only (given or inferred); not with `lenient`. Default: false.
+   */
+  rdfstar?: boolean;
 }
 
 export interface QueryOptions extends DatasetQueryOptions {
@@ -535,17 +566,24 @@ export function canonicalize(
 export function graphs(dataset: Dataset): Array<[name: NamedNode | BlankNode, graph: Dataset]>;
 
 /**
- * The RDFC-1.0 canonical hash of a single graph: the SHA-256 of its
- * canonical N-Quads document, as 64 lowercase hexadecimal digits (RDF
- * Dataset Canonicalization 1.0, section 4.4 note 2). The engine computes
- * the canonical form and the digest. Every quad's graph component is
- * dropped first, so isomorphic graphs (including under blank-node
- * relabeling) give the same hash whatever graph name they were extracted
- * from. Typically called with one entry of graphs()'s output. For the
- * canonical text, use canonicalize(). Rejects when the input holds an
- * RDF 1.2 triple term or the section 4.4 call budget is exceeded.
+ * The RDFC-1.0 canonical hash of a dataset: the SHA-256, as 64 lowercase
+ * hexadecimal digits, of the canonical N-Quads document that canonicalize()
+ * answers (RDF Dataset Canonicalization 1.0, section 4.4 note 2), graph names
+ * included. The engine computes the canonical form and the digest. Since
+ * 0.20.0; 0.17.0 to 0.19.x dropped every graph name first, so datasets that
+ * differ only in their graph names got the same hash. To hash a graph
+ * whatever its name (for example one entry of graphs()), use
+ * canonicalHash(asDefaultGraph(g)). Rejects when the input holds an RDF 1.2
+ * triple term or the section 4.4 call budget is exceeded.
+ */
+export function canonicalHash(dataset: Dataset): Promise<string>;
+
+/**
+ * A new Dataset with the triples of every graph of `dataset`, all in the
+ * default graph (the engine's union of the graphs). With one entry of
+ * graphs(), it is that graph without its name. Dispose of it when done.
  */
-export function canonicalHash(datasetOrGraph: Dataset): Promise<string>;
+export function asDefaultGraph(dataset: Dataset): Dataset;
 
 /**
  * Whether two datasets are isomorphic (RDF 1.1 Concepts 3.6 and 4; blank
@@ -561,9 +599,137 @@ export function fromQuads(quads: Iterable<Quad>): Promise<Dataset>;
 /** Load the engine. Afterwards the N-Quads text functions of `@factoidal/core/rdfjs` work. */
 export function ready(): Promise<void>;
 
+// ---------------------------------------------------------------------
+// Literal values (https://github.com/danbri/factoidal/issues/1051 items 1-3).
+// Synchronous after the engine is loaded (`await ready()` or any other call);
+// before that they throw a FactoidalError. The engine decides everything
+// (formal/lean4/L4Factoidal/RDF/LiteralValue.lean). API.md "Literal values".
+// ---------------------------------------------------------------------
+
+/**
+ * The value of a literal, as JSON-safe data. A number that a JavaScript
+ * number may not hold exactly is a decimal string; `number` is present only
+ * when the value is exactly a binary64 value. Integer components are numbers
+ * when |n| <= 2^53 - 1, else decimal strings.
+ */
+export type LiteralValueData =
+  | { kind: 'string' | 'anyURI'; string: string }
+  | { kind: 'boolean'; boolean: boolean }
+  | { kind: 'decimal'; decimal: string; integer: boolean; number?: number }
+  | { kind: 'float' | 'double'; decimal?: string; number: number;
+      negativeZero?: true; special?: 'NaN' | 'INF' | '-INF' }
+  | { kind: 'duration'; months: number | string; seconds: string }
+  | { kind: 'dateTime' | 'time' | 'date' | 'gYearMonth' | 'gYear' | 'gMonthDay' | 'gDay' | 'gMonth';
+      year?: number | string; month?: number; day?: number; hour?: number;
+      minute?: number; second?: string; timezoneOffset?: number }
+  | { kind: 'hexBinary' | 'base64Binary'; hex: string }
+  | { kind: 'QName' | 'NOTATION'; prefix: string; localName: string }
+  | { kind: 'list'; items: LiteralValueData[] }
+  | { kind: 'langString'; string: string; language: string; direction?: 'ltr' | 'rtl' };
+
+export interface LiteralValueResult {
+  /** The datatype IRI. */
+  datatype: string;
+  /** false: the engine has no lexical space for this datatype. */
+  recognized: boolean;
+  /** The lexical form is in the lexical space (null when not recognized). */
+  valid: boolean | null;
+  /** Present for a valid literal of a datatype with a value model. */
+  value?: LiteralValueData;
+  /** The canonical lexical form (XSD 1.1 Part 2 section 2.3.1), when known. */
+  canonical?: string;
+}
+
+/** The XSD lexical-to-value mapping of a literal (RDF 1.1 Semantics section 7: no whiteSpace processing). */
+export function literalValue(term: Literal): LiteralValueResult;
+
+/** Whether the lexical form is in the datatype's lexical space; null when the engine has no lexical space for the datatype. */
+export function isValidLiteral(term: Literal): boolean | null;
+
+/** The literal with the canonical form of its value; null when it is not valid or has no canonical mapping. */
+export function canonicalLiteral(term: Literal): Literal | null;
+
+/**
+ * The literal of a JavaScript value. With no datatype the engine's table
+ * chooses: boolean xsd:boolean, string xsd:string, bigint xsd:integer, a safe
+ * integer Number xsd:integer, any other Number xsd:double, Date xsd:dateTime
+ * (UTC). `datatype` (an IRI, a NamedNode, or an XSD local name such as 'int')
+ * names the datatype; the value must be in its value space, else a
+ * FactoidalError with code 'literal.value'.
+ */
+export function literalFromValue(
+  value: boolean | number | bigint | string | Date,
+  options?: { datatype?: string | NamedNode }
+): Literal;
+
 /** The engine's name tables: format names, entailment regimes, query outputs, pack syntaxes. */
 export function engineTables(): Promise<Record<string, unknown>>;
 
+/**
+ * How Dataset.has, match and delete compare the object position
+ * (https://github.com/danbri/factoidal/issues/1052). 'term' (the default):
+ * RDF term equality. 'value': a literal object matches by value (sameValue()).
+ */
+export interface MatchOptions {
+  match?: 'term' | 'value';
+}
+
+/**
+ * SPARQL 1.1 `=` on two RDF terms (sections 17.3 and 17.4.1.7), decided by the
+ * engine: `true` the same value (`"01"^^xsd:integer` and `"1.0"^^xsd:decimal`),
+ * `false` different values, `null` incomparable (the operator's type error:
+ * two different literals of an unknown datatype, an ill-typed literal and
+ * another literal, `xsd:integer` and `xsd:boolean`). `"NaN"^^xsd:double` is
+ * not the same value as itself. A term is an RDF/JS term or an N-Triples term
+ * string. Synchronous: the engine must be loaded (`await ready()`).
+ */
+export function sameValue(a: Term | string, b: Term | string): boolean | null;
+
+/**
+ * The syntax of a document by its file name (or IRI path; the query and the
+ * fragment are ignored) and its media type, from the engine's table of the
+ * W3C registrations (https://github.com/danbri/factoidal/issues/1053): Turtle
+ * `text/turtle` `.ttl`, N-Triples `application/n-triples` `.nt`, N-Quads
+ * `application/n-quads` `.nq`, TriG `application/trig` `.trig`, RDF/XML
+ * `application/rdf+xml` `.rdf`, JSON-LD `application/ld+json` `.jsonld`. The
+ * media type wins when it is given (its parameters are ignored); an unknown
+ * media type does not fall back to the name. Answers a `name` of formats(),
+ * or `null`. Synchronous: the engine must be loaded (`await ready()`).
+ */
+export function syntaxFor(what: string | { fileName?: string; mediaType?: string }): string | null;
+
+/**
+ * An IRI as a namespace and a local name: the local name is the longest
+ * suffix that is an XML NCName (what an RDF/XML QName can carry), `''` when
+ * there is none; `namespace + localName` is the IRI
+ * (https://github.com/danbri/factoidal/issues/1051 item 4). Synchronous.
+ */
+export function splitIri(iri: string | NamedNode): { namespace: string; localName: string };
+
+/** Is the text an XML NCName (Namespaces in XML 1.0, production [4])? A prefix label check. Synchronous. */
+export function isNCName(text: string): boolean;
+
+/** One row of the engine's vocabulary table. A term IRI is `namespace + term`. */
+export interface VocabularyRow {
+  prefix: string;
+  namespace: string;
+  /** Local names; empty for a namespace whose vocabulary is not in the engine table. */
+  terms: string[];
+}
+
+/**
+ * The engine's vocabulary table (https://github.com/danbri/factoidal/issues/1051
+ * item 5): rdf, rdfs, xsd and owl with their terms; foaf, dcterms, dc and
+ * schema as namespaces only. The prefixes are those of the Turtle writer. Synchronous.
+ */
+export function vocabularies(): VocabularyRow[];
+
+/** The container membership property `rdf:_n` (n >= 1). Synchronous. */
+export function memberIri(n: number): NamedNode;
+
+/** The `n` of `rdf:_n` (no leading zero, n >= 1), or `null` for any other IRI. Synchronous. */
+export function memberOrdinal(iri: string | NamedNode): number | null;
+
 /** A SHACL validation-report term (see shaclValidate). */
 export interface ShaclValidateResult {
   conforms: boolean;
@@ -758,7 +924,14 @@ export interface EvidenceRecord {
   outside?: OutsideSetting[];
 }
 
-/** The value on a wire. */
+/**
+ * The value on a wire. After a node, `graph` is a value of the node's
+ * `wireOut`: a Dataset for the graph wires, text for String (a writer), the
+ * rows for Table (SELECT), a boolean for Answer (ASK), `[canonical, sha256]`
+ * for String × String (rdfcStage), the report object for ValidationReport,
+ * the explain result for ExplainGraphResult. Since 0.20.0; before, a node
+ * whose output was not a Dataset left its input on the wire.
+ */
 export interface Wire<G = unknown> {
   graph: G;
   evidence: EvidenceRecord[];
@@ -783,7 +956,12 @@ export interface FactoidalNode {
   readonly wireOut: string;
   readonly runnable: boolean;
   readonly bound: boolean;
-  /** The settings as given (passed to the package function that runs the stage). */
+  /**
+   * The node's own copy of the settings as given (passed to the package
+   * function that runs the stage): frozen at every depth, a Dataset cloned,
+   * taken when node() checked them. A later change to the caller's objects
+   * does not reach the node; a change to a Dataset here makes run() refuse.
+   */
   readonly params: Readonly<Record<string, unknown>>;
   /** The settings as sent to the engine: JSON values, a Dataset as {$nquads}. */
   readonly settingsWire: Readonly<Record<string, unknown>>;
@@ -876,8 +1054,11 @@ export function pipe(...nodes: Array<FactoidalNode | Pipeline>): Pipeline;
  * Run a node or pipeline on `input` (a Wire, or the graph: text for a
  * reader, else a Dataset or data input). Rejects before any node runs when
  * a node's stage has status 'missing' (unless `options.unchecked`) or has
- * no package function, or when the engine's check finds the pipeline not
- * well typed (unless `options.unchecked`; then `proved` is false).
+ * no package function, when the engine's check finds the pipeline not
+ * well typed (unless `options.unchecked`; then `proved` is false), or when a
+ * node's settings changed after node() checked them. Rejects with code
+ * 'op.failed' when a node's runner gives a value that is not of the node's
+ * `wireOut` (see Wire).
  */
 export function run(pipeline: FactoidalNode | Pipeline, input: unknown, options?: RunOptions): Promise<RunResult>;
 
@@ -1191,6 +1372,8 @@ export interface Sbm11Store {
   /** the generation CURRENT names, or "" when the source is a generation */
   generation: string;
   terms: number;
+  /** how the engine checks reads; undefined from a wasm module built before the Merkle check */
+  verify: 'merkle' | 'none' | undefined;
   query(sparql: string, options?: { base?: string; sparql12?: boolean; reference?: boolean }): Sbm11Answer;
   /** the resources the reader read, when its reader records them (lwsSbm11Reader) */
   readonly evidence: Sbm11ReadEvidence[] | undefined;
@@ -1198,8 +1381,11 @@ export interface Sbm11Store {
 }
 
 /** Open an SBM11 generation (https://github.com/danbri/factoidal/issues/1009).
- * Node: `source` is a directory unless a reader is given or registered. */
-export function openSbm11(source: string, options?: { reader?: Sbm11Reader }): Promise<Sbm11Store>;
+ * Node: `source` is a directory unless a reader is given or registered.
+ * `verify` (default 'merkle'): the engine checks every byte it decodes against
+ * the manifest's Merkle roots and refuses a changed file with its name;
+ * 'none' checks lengths only. */
+export function openSbm11(source: string, options?: { reader?: Sbm11Reader; verify?: 'merkle' | 'none' }): Promise<Sbm11Store>;
 
 /** Serve `source` with `reader`; `null` removes it. */
 export function registerSbm11Source(source: string, reader: Sbm11Reader | null): void;
@@ -1679,6 +1865,8 @@ export function capabilities(): Promise<{
   store: boolean;
   /** The deltaLog* functions (deltaLogEncode, deltaLogDecode, deltaLogMerge). */
   deltaLog: boolean;
+  /** ops literalValue and literalFromValue (issue 1051). */
+  literalValues: boolean;
   /** 'full': the whole library is in the wasm module. */
   profile: 'full' | string;
   /** The dispatch ABI version string of the loaded wasm module. */
@@ -1762,10 +1950,18 @@ declare const _default: {
   canonicalize: typeof canonicalize;
   graphs: typeof graphs;
   canonicalHash: typeof canonicalHash;
+  asDefaultGraph: typeof asDefaultGraph;
   isomorphic: typeof isomorphic;
   fromQuads: typeof fromQuads;
   ready: typeof ready;
   engineTables: typeof engineTables;
+  sameValue: typeof sameValue;
+  syntaxFor: typeof syntaxFor;
+  splitIri: typeof splitIri;
+  isNCName: typeof isNCName;
+  vocabularies: typeof vocabularies;
+  memberIri: typeof memberIri;
+  memberOrdinal: typeof memberOrdinal;
   shaclValidate: typeof shaclValidate;
   shexValidate: typeof shexValidate;
   owlClosure: typeof owlClosure;
@@ -1821,6 +2017,10 @@ declare const _default: {
   FactoidalError: typeof FactoidalError;
   dataFactory: DataFactory;
   queryRaw: typeof queryRaw;
+  literalValue: typeof literalValue;
+  isValidLiteral: typeof isValidLiteral;
+  canonicalLiteral: typeof canonicalLiteral;
+  literalFromValue: typeof literalFromValue;
   version: string;
   engine: string;
 };

package/index.mjs

@@ -55,10 +55,24 @@ export const serialize = api.serialize;
 export const canonicalize = api.canonicalize;
 export const graphs = api.graphs;
 export const canonicalHash = api.canonicalHash;
+export const asDefaultGraph = api.asDefaultGraph;
 export const isomorphic = api.isomorphic;
 export const fromQuads = api.fromQuads;
+// Literal values (https://github.com/danbri/factoidal/issues/1051): synchronous
+// after the engine is loaded.
+export const literalValue = api.literalValue;
+export const isValidLiteral = api.isValidLiteral;
+export const canonicalLiteral = api.canonicalLiteral;
+export const literalFromValue = api.literalFromValue;
 export const ready = api.ready;
 export const engineTables = api.engineTables;
+export const sameValue = api.sameValue;
+export const syntaxFor = api.syntaxFor;
+export const splitIri = api.splitIri;
+export const isNCName = api.isNCName;
+export const vocabularies = api.vocabularies;
+export const memberIri = api.memberIri;
+export const memberOrdinal = api.memberOrdinal;
 export const openDataset = api.openDataset;
 export const closure = api.closure;
 export const formats = api.formats;

package/l4-assets/l4factoidal.js

@@ -37,7 +37,7 @@
 // bytes change.
 
 // Stamped by formal/lean4/Wasm/build-wasm.sh step 9 -- do not hand-edit.
-const WASM_VERSION = "6dbf38660cb9";
+const WASM_VERSION = "43c334ec5335";
 
 import createModule from './l4factoidal.mjs';
 

package/l4-assets/version.json

@@ -2,17 +2,17 @@
   "engine": "lean4",
   "note": "The Lean 4 (L4Factoidal) engine build provenance and claims: the only engine of @factoidal/core since 0.9.0 (issue 713). This committed file is a placeholder. tools/fetch-builds.sh --set web (through tools/stamp-l4-version.mjs) writes the provenance members from the danbri/factoidal-builds release that built the wasm; formal/lean4/Wasm/build-wasm.sh step 9 writes them for a local build. Do not commit a stamped copy.",
   "stamped": true,
-  "release": "danbri/factoidal-builds build-b8c6b64b8dc1-web",
-  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/40525043015",
-  "gitSha": "b8c6b64b8dc18a6daa2151a61e28dbb9a4707ade",
-  "builtAt": "2026-10-27T15:28:08Z",
+  "release": "danbri/factoidal-builds build-0c9a222bdb25-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/40662145237",
+  "gitSha": "0c9a222bdb25ff70456611d3fbc87a41902d8324",
+  "builtAt": "2026-10-28T09:52:07Z",
   "leanToolchain": "leanprover/lean4:v4.33.1",
   "emscripten": "6.0.8",
   "abiVersion": "1",
   "engineVersion": "l4factoidal-wasm 0.2.0 (dispatch: RDF parse/serialize, SPARQL query+update, RDFS/OWL-RL closures, RDFC-1.0, CL/IKL)",
   "version": "l4factoidal-wasm 0.2.0 (dispatch: RDF parse/serialize, SPARQL query+update, RDFS/OWL-RL closures, RDFC-1.0, CL/IKL)",
-  "wasmSha256": "6dbf38660cb9966ae7c65ecdb68a38e83d09c1283415c1486b618f203f3f2f39",
-  "wasmBytes": 17694204,
+  "wasmSha256": "43c334ec53357cd40339f693d303bda3e422ac92e94ad335cb6b0e83ec4eafbd",
+  "wasmBytes": 17958911,
   "claims": {
     "source": "formal/lean4 (L4Factoidal): no sorry, no user axioms, no native_decide; W3C behaviour pinned by build-time #guard",
     "suitesAtBuildSha": "see docs/test-results and formal/lean4/PORT_NOTES.md at gitSha"