@factoidal/core 0.7.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,620 @@
 # Changelog
 
+## 0.11.0 — 2026-10-21
+
+No RDF, SPARQL, datatype or IRI decision is made in JavaScript any more
+(https://github.com/danbri/factoidal/issues/894; owner, 2026-10-21: "The ja
+leak fix is p0"). The engine parses, writes, escapes, compares and chooses
+datatypes; the JavaScript copies term components and calls ops.
+`tools/host-purity-lint.sh` group 3 scans the npm and hub JavaScript for RDF
+syntax and runs in `npm test`.
+
+### Breaking changes
+
+These shapes could not be kept:
+
+- `shexValidate` and `Dataset.validateShex`: a focus or shape given as a
+  string is read as one RDF 1.2 N-Triples term (`'<http://…>'` or `'_:b'`);
+  a bare IRI string is refused. Every API that takes a term as a string
+  now reads it through one engine reader (`TermJson.readTermString`), so
+  `_:x` is always a blank node and `<…>` always an IRI.
+- `graphs()` returns `[NamedNode|BlankNode, Dataset]` pairs, not
+  `[string, Dataset]`, so an IRI graph and a blank-node graph with the same
+  text are never confused.
+- A literal with a language and a direction has datatype
+  `rdf:dirLangString` (RDF 1.2 Concepts; RDF/JS Data Model); before, the
+  RDF/JS default gave `rdf:langString`.
+
+- `factoidal lws-serve` and `@factoidal/core/lws` enforce storage-server
+  authorization from the LWS editor's draft (401 with
+  `WWW-Authenticate: Bearer resource_metadata`, the RFC 9728 metadata
+  document, Bearer JWT access tokens checked for signature, `iss`, `aud`,
+  `exp`, `nbf` and `iat`, then Web Access Control). `lws-serve` needs
+  `--issuer IRI`, `--auth-config FILE` or, for development only,
+  `--insecure-no-auth`; `listen()` with neither `auth` nor
+  `insecureNoAuth` serves only what the ACLs give to the public. New op
+  `lwsFetched`. https://github.com/danbri/factoidal/issues/886
+
+- The N-Quads text functions of `@factoidal/core/rdfjs` (`nquadsToQuads`,
+  `nquadsLineToQuad`, `quadsToNQuads`, `quadToNQuads`, `termToNQuads`,
+  `DatasetCore.fromNQuads`, `DatasetCore.prototype.toNQuads`) call the engine.
+  They throw until the engine is loaded: `await ready()` (new) or any other
+  `@factoidal/core` call first. `nquadsToQuads` now rejects a line the
+  N-Quads grammar rejects (before, `<http://e/a b>` was read as an IRI), and
+  the writers escape as the engine's canonical N-Triples form does (before,
+  `\b`, `\f` and other control characters were written raw).
+- A JavaScript number answered by a registered extension function becomes
+  `xsd:integer` only for an integer within ±(2^53 − 1); every other number is
+  an `xsd:double` in the XSD 1.1 canonical form (`1e21` is `"1.0E21"`, before
+  `"1e+21"^^xsd:integer`; `0.1` is `"1.0E-1"`, before `"0.1"`). `NaN`,
+  `Infinity` and `-Infinity` answer `"NaN"`, `"INF"`, `"-INF"`; before they
+  were the §17.6 error. A `bigint` answers `xsd:integer`
+  (`L4Factoidal.XSD.JsValue.jsLiteral`).
+- `queryHdt` answers a Dataset for CONSTRUCT and DESCRIBE; before it threw a
+  TypeError chosen by a regular expression over the query text.
+- `Literal` has a `direction` member (`''`, `'ltr'`, `'rtl'`), and a
+  directional language-tagged string from the engine keeps its direction and
+  its `rdf:dirLangString` datatype; `equals` compares it.
+
+### New
+
+- `isomorphic(a, b)`: dataset isomorphism by the engine
+  (`Dataset.isomorphicOutcome`, blank nodes in triple terms included).
+  `@factoidal/core/fn`'s `equals` uses it.
+- `fromQuads(quads)`: a Dataset from RDF/JS quads, sent as term components.
+- `ready()`: load the engine. `engineTables()`: the engine's format,
+  regime, query-output and pack-syntax name tables.
+- Ops (formal/lean4/Wasm/Ops/Handles.lean): `datasetQuadsJson`,
+  `datasetAddQuadsJson`, `datasetDeleteQuadsJson`, `datasetFromQuadsJson`,
+  `datasetGraphNames`, `datasetGraphAsDefault`, `datasetIsomorphic`,
+  `parseQuadsJson`, `quadsToNQuads`, `termsToNTriples`, `resolveIri`,
+  `queryForm`, `engineTables`; `datasetMatch`/`datasetMatchCount` take term
+  objects. Theorems: `TermJson.decodeTerm_encodeTerm`,
+  `TermJson.decodeQuad_encodeQuad`, `TermJson.mem_quadList_default`,
+  `TermJson.mem_quadList_named`, `TermJson.toCanonicalNQuads_eq_quadList`,
+  `TermJson.quadPage_append`, `XSD.JsValue.doubleLexical_inLexicalSpace`,
+  `XSD.JsValue.integerLexical_inLexicalSpace`,
+  `XSD.JsValue.jsLiteral_number_double`, `XSD.JsValue.jsLiteral_number_integer`.
+
+### Added
+
+- An extension function may answer an exact term: an RDF/JS term
+  (Literal, NamedNode, BlankNode, or a Quad as an RDF 1.2 triple term), or
+  `{value, datatype}`, or `{value, language, direction?}`. The lexical form
+  and the datatype IRI are kept as given, ill-typed literals included (RDF
+  1.1 Concepts §3.3). The engine checks only what RDF requires: absolute
+  IRIs, a well-formed BCP 47 language tag, direction `ltr` or `rtl`; a term
+  that fails is the §17.6 error for that call. A plain JS number still gets
+  its datatype from `jsLiteral`. Theorem `TermJson.extAnswerJson_encodeTerm`:
+  an app-supplied term is the answer, unchanged.
+
+### Performance
+
+- Dataset iteration reads the quads from the engine as one byte region (op
+  `datasetQuadsBin`: a term table in the delta-log v2 term codec and four
+  u32 indices per quad), decoded in JavaScript with `DataView` and
+  `TextDecoder`. 60,000 quads: 178–205 ms under load, against 214–280 ms in
+  0.10.0 and about the time of the N-Quads writer op in the same run.
+  Theorems `decodeBin_quadsBin` and `quadsBin_binSpec`
+  (`formal/lean4/L4Factoidal/RDF/QuadsBinTheorems.lean`) prove the region
+  reads back as exactly the dataset's quads, so no run-time check is made.
+  https://github.com/danbri/factoidal/issues/900
+
+### Fixed
+
+- `graphs()` (both APIs) no longer merges an IRI graph and a blank-node graph
+  whose strings are equal.
+- `Dataset` iteration builds its quads from the engine's term objects; it no
+  longer parses N-Quads text in JavaScript.
+- The Solid client resolves a relative target against `baseIri` by RFC 3986
+  §5.2 (op `resolveIri`); before it concatenated strings.
+- `factoidal query` table cells and `factoidal inspect` graph names are the
+  engine's canonical N-Triples forms (escaped); `factoidal pack` reads its
+  suffix table from the engine and detects the syntax of a file with an
+  unknown suffix from its content.
+
+## 0.10.0 — 2026-10-21
+
+### Breaking changes
+
+One wasm carries every capability (owner, 2026-10-20: "all this stuff goes
+into a single mod we call Factoidal/core and a dingle wasm"):
+
+- The duplicate smaller wasm (`l4-assets/l4factoidal-core.{wasm,mjs,js}`) and
+  its `./core` and `./core-browser` subpaths are gone. `l4factoidal.wasm`
+  serves every function of the package; import `@factoidal/core`.
+  `l4-assets/version.json` has no `coreWasmSha256`/`coreWasmBytes`.
+- No demonstration triples ship (owner: "All the CLIs are still bundled i
+  just didn't want any actual demo triples cluttering the file"): the
+  4,434-triple `sample-store/` directory is gone. `factoidal sample-store
+  [DIR]` and `sampleStorePath([dir])` now pack 15 triples held in
+  `sample-store.mjs` into a store under DIR or the temporary directory and
+  return its path; `sampleStoreFacts` describes that store.
+- The demonstration functions `matrixDeterminant`, `matrixScalarProduct`,
+  `matrixVectorProduct`, `matrixOuterProduct`, `sigmoidPoints` and
+  `sigmoidFormulaMathml` (and `capabilities().matrix`/`.sigmoid`) left the
+  JavaScript API, `@factoidal/core/fn` and the types. The Lean ops stay and
+  answer through `loadEngine().call(op, args)`.
+
+One `Dataset` class whose data stays in the engine
+(https://github.com/danbri/factoidal/issues/882 item 1):
+
+- `Dataset` is a handle into the engine's dataset store; it no longer holds
+  N-Quads text. `new Dataset(...)` and `Dataset.fromNQuads(...)` are gone:
+  make one with `parse`, `openDataset` or another producer. It still implements RDF/JS DatasetCore:
+  `add`, `delete`, `has` and `match` run in the engine (`match` and `has` use
+  its indexes; `match` answers a new Dataset). The in-memory RDF/JS DatasetCore is
+  `DatasetCore` in `@factoidal/core/rdfjs` (that subpath no longer exports
+  `Dataset`).
+- `DatasetHandle` is a deprecated alias of `Dataset` (removed in 0.11.0).
+  `handle.close()`, `handle.closed` and `handle.toDataset()` are replaced by
+  `dispose()`, `disposed` and the Dataset itself. Using a disposed Dataset
+  throws a `TypeError`.
+- `openDataset` answers a `Dataset` (a Dataset argument is cloned).
+- `coreRdfsClosure`/`rhoDfClosure` and `rdfsPlusClosure` answer a `Dataset`
+  (before: `{ok, ntriples}` and `{ok, ntriples, rounds}`; `rounds` is gone).
+  `fn.coreRdfsClosure` and `fn.rdfsPlusClosure` drop `rounds` too.
+- Text input with no `format` is no longer read as Turtle: the engine infers
+  the format (op `detectFormat`: JSON-LD, RDF/XML, TriG or Turtle, in RDF
+  1.2 mode) and reports it in `dataset.format` / `dataset.formatInferred`, or
+  in the error message. N-Quads is never inferred; name it.
+- Every function throws a `TypeError` for an unknown option key.
+- `update(dataset, text)` answers a new Dataset and leaves its argument
+  unchanged (as before); `dataset.update(text)` changes it in place.
+- `fn.toDataset` answers a DatasetCore; `fn.fromDataset` takes a `Dataset`
+  or a DatasetCore.
+
+### New
+
+- `Dataset` methods: `query` (with `entail` and `output`: SPARQL results
+  JSON, XML, CSV, TSV), `update`, `validateShacl`, `validateShex`,
+  `closure(regime)`, `canonicalize`, `serialize({format, version})`,
+  `toString(format)`, `clone`, `has`, `match`, lazy RDF/JS quad iteration,
+  `dispose`, `[Symbol.dispose]`; a `FinalizationRegistry` releases a
+  collected Dataset.
+- `serialize` writes every writer the engine has: N-Quads, N-Triples,
+  Turtle, TriG, RDF/XML, JSON-LD, RDFC-1.0 canonical N-Quads, each with
+  `version: '1.1'` (refuses RDF 1.2 terms) or `'1.2'`. `formats()` gives the
+  engine's list; the README table is generated from it. Writers the engine
+  lacks: https://github.com/danbri/factoidal/issues/883.
+- `closure(data, regime)`.
+- Engine ops (Lean, `Wasm/Ops/Handles.lean`, `Wasm/Ops/DatasetFull.lean`):
+  `datasetClone`, `datasetCanonicalize`, `datasetClosure`,
+  `datasetShaclValidate`, `datasetQueryRaw`, `datasetFormats`,
+  `detectFormat`, `datasetFromCsvw`, `datasetFromRml`, `datasetFromJsonLd`,
+  `datasetToJsonLd`, `datasetShexValidate`, `datasetRifEval`; and
+  `datasetSerialize` writes N-Triples, TriG, RDF/XML and RDFC-1.0.
+- Every example in README.md and API.md is executed by
+  `test/doc-examples.test.mjs`.
+
+### Other changes
+
+- The README is a short summary: what the package is, a usage example, the
+  JavaScript API and command list, the specifications covered with test
+  scores and their sources, and measured strengths and gaps. The previous
+  README is `API.md` in the repository (not in the tarball).
+- New pure functions over engine ops that had no JavaScript function:
+  `aeadSeal`, `aeadOpen` (ChaCha20-Poly1305, RFC 8439), `hpkeSeal`,
+  `hpkeOpen` (RFC 9180 base mode), `proofCheck`, `proofInspect` (FPP0 proof
+  bundles), `canonicalizeNQuads` and `normalizeNQuads` (N-Quads text in, text
+  out). Tests: `test/pure-and-serve.test.mjs`.
+- New `serveStore(root, {port, host})`: the `factoidal serve` SPARQL 1.1
+  Protocol server as a function, `{url, port, close()}`. Node only.
+- `factoidal serve --file DATA /ds`, the `fuseki-server --file` form, and
+  the Fuseki service names `/ds/query`, `/ds/update` and `/ds/get` beside
+  `/ds/sparql` (decided in `StoreEndpoint.lean`). Record and gaps:
+  `docs/fuseki-replacement.md`; tests `test/fuseki-compat.test.mjs`. W3C live
+  protocol run: 50 pass, 0 fail (out of 50).
+- The wasm is rebuilt from `main`; the package carries the Lean 4 engine only.
+  Package suite: 432 pass, 0 fail (out of 432); 4 of them are expected
+  failures naming issues 829, 830 and 831.
+- Removed: the 0.9.x subpath aliases `@factoidal/core/l4` and
+  `@factoidal/core/l4-core` (files `l4.js`, `l4.d.ts`, `l4-core.js`,
+  `l4-core.d.ts`), as announced in 0.9.0. Import `@factoidal/core`; the
+  low-level engine handle is `loadEngine()`.
+- `l4-assets/version.json` is written at release from the
+  `danbri/factoidal-builds` release that built the wasm
+  (`tools/fetch-builds.sh --set web`): source commit, build time, sha256 and
+  size of both wasm files, and the engine's own version. The committed file
+  is a placeholder. `factoidal version` prints the stamp and the loaded
+  engine's `version()`, and exits 1 when the stamped sha256 differs from the
+  installed wasm.
+- RDF 1.2 format tags `turtle12`, `ntriples12`, `nquads12`, `trig12` are in
+  the `DataFormat` type.
+- Includes the entries listed under "Unreleased" below.
+
+## Unreleased (included in 0.10.0)
+
+- **The durable update log in the browser, on the Lean engine**
+  ([issue 728](https://github.com/danbri/factoidal/issues/728); hub post 18).
+  `deltaLogOpen`, `deltaLogAppend`, `deltaLogReadAllHex`, `deltaLogMerge`,
+  `deltaLogDestroy` and `_deltaLogCorruptLastForTest` are back, with the names
+  and result shapes of the F\* browser entry before 0.9.0, and
+  `deltaLogInspect` and the capability `deltaLog` are new. One record per
+  update, in the DLB1 format of the store's delta log; the engine ops
+  `deltaLogEncode`, `deltaLogDecode` and `deltaLogMerge` make every decision
+  about the bytes (checksums, a torn last record, merge on read), with
+  theorems in `formal/lean4/L4Factoidal/Storage/BrowserLogTheorems.lean`.
+  The browser entries keep the records in IndexedDB; the Node entries keep
+  them in the memory of the process. A record that does not verify, and
+  every record after it, is not applied.
+
+- **SPARQL `SERVICE` failures inside `EXISTS` and under an outer `SILENT`**
+  ([issue 735](https://github.com/danbri/factoidal/issues/735); SPARQL 1.1
+  Federated Query §2.3 and §3.2). A failed `SERVICE` call without `SILENT`
+  inside `EXISTS` or `NOT EXISTS` (in `FILTER`, `BIND`, an `OPTIONAL`
+  condition, `HAVING`, `ORDER BY` or a `SELECT` expression) now fails the
+  query, as the same call in a graph pattern does. A failed `SERVICE` call
+  nested in the body of an outer `SERVICE SILENT` is a failure of the outer
+  call, so the outer call gives one solution with no bindings; without
+  `SILENT` on the outer call the query fails. The two expected-failure cases
+  in `test/l4-parity.test.js` are now assertions.
+
+- **`factoidal serve STORE --port N`: a SPARQL 1.1 endpoint over an activated
+  store** ([issue 669](https://github.com/danbri/factoidal/issues/669), step
+  1). SPARQL 1.1 Protocol query and update at `/sparql`, the Service
+  Description on a GET there with no query string, and the Graph Store HTTP
+  Protocol at `/data`. An update or a Graph Store write is appended to the
+  generation's delta log as one batch, synced, before it is answered. The
+  request framing, routing, status codes, negotiation and the delta-log batch
+  are decided by the engine (`storeServeKeys`, `storeServeOpen`,
+  `storeServeRequest`, `storeServeCommit`, `storeServeClose`); `bin/serve.mjs`
+  moves bytes. W3C protocol, graph-store and service-description tests over
+  a live socket: 50 pass, 0 fail (out of 50). Open gap: a quad generation's
+  delta log is not replayed by the native quad reader
+  ([issue 770](https://github.com/danbri/factoidal/issues/770)).
+- **`@factoidal/core/core`: the core engine** ([issue 713](https://github.com/danbri/factoidal/issues/713),
+  stage 4). `l4factoidal-core.wasm` (5.68 MB, 1.07 MB with gzip; the full
+  engine is 10.54 MB, 2.07 MB) serves parse and serialize (Turtle, TriG,
+  N-Triples, N-Quads, RDF/XML, lenient), SPARQL 1.1 and 1.2 query and update
+  over text and dataset handles, canonicalization, the RDFS and OWL 2 RL
+  closures and SHACL. The entry has the same exports as `.`; a function
+  outside that subset rejects naming `@factoidal/core`, and
+  `capabilities().profile` is `'core'` (`'full'` on the other entries).
+  Files: `core.mjs`, `core.js`, `core-browser.js`, `core.d.ts`,
+  `core-browser.d.ts`, `l4-assets/l4factoidal-core.{js,mjs,wasm}`.
+- A SELECT of more than about 11,000 solutions, and `canonicalize()` of more
+  than about 20,000 blank-node quads, no longer fail under Node's default
+  stack with "Maximum call stack size exceeded". Four functions of the Lean
+  library recursed once per row or per quad (`SPARQL.numberRows`,
+  `SPARQL.rowsJoined`, `RDF.Canonical.collapseKeyedQQuads`, `dedupAdj`);
+  each now compiles to an accumulator form proved equal to it. The Results
+  JSON writer had also copied the rest of the document once per row.
+- `NOW()` is bound ([issue 743](https://github.com/danbri/factoidal/issues/743)).
+  Through `query()`, `update()`, dataset handles, the entailment path,
+  `queryHdt()` and the store queries, SPARQL `NOW()` answered an error and left
+  its variable unbound (W3C `functions/now01.rq` answered `false`). The engine
+  now reads the system clock once per query or update and gives every `NOW()` of
+  that execution the same `xsd:dateTime` value in UTC (SPARQL 1.1 §17.4.5.1).
+  The wasm modules grow by about 82 KB (full) and 89 KB (core).
+- The pure dispatch entries take the instant of `NOW()` as an optional last
+  argument ([issue 748](https://github.com/danbri/factoidal/issues/748)).
+  `call` and `callBlob` read no clock, so a host that uses them got an error
+  for `NOW()`. `queryDataset` and `updateDataset` (fourth, after the base IRI),
+  `queryRaw` and `storeQuery` (fourth) and `queryHdt` (second) now accept an
+  `xsd:dateTime` lexical form such as `2026-10-10T12:34:56Z`; an empty string
+  means none, and a text that is not a dateTime lexical form is an error. Hosts
+  that pass fewer arguments do not change. `callIO` and `callBlobIO` still read
+  the clock themselves.
+- `Dataset` (`./rdfjs`) adds and looks up a quad in constant time. It
+  scanned every quad it held, so `parse()` of 12,000 quads spent 3.1 s
+  building the result; it now takes 0.35 s.
+
+## 0.9.0 — 2026-10-10
+
+**One engine: the Lean 4 build.** ([issue 713](https://github.com/danbri/factoidal/issues/713),
+stage 3.) Owner, 2026-10-10: "We should make the main module Lean4-based.
+Private builds might compare this with F\* (or indeed different wasms from
+different toolchains)." The main entry (`.`: `index.js`, `index.mjs`),
+`./api`, `./fn` and `./browser` now load the Lean 4 library `L4Factoidal`
+compiled to WebAssembly (`l4-assets/`). Every function is a dispatch op of
+that module behind the typed wrapper the F\* engine had, with the same
+signatures and result shapes except where the list below says otherwise.
+
+Removed, with no replacement shim (there are no users):
+
+- the F\* bundles (`factoidal.js`, `factoidal.wasm.js`,
+  `factoidal-npm-entry*.js` and their wasm assets) and the entry points
+  that loaded them: `./wasm`, `./lite`, `./browser-wasm`, `./select`, and the
+  `./factoidal*.js` subpaths. The F\* bundles stay build artifacts of
+  `danbri/factoidal-builds`, for private comparison builds:
+  `tests/engine-compare/run.sh PATH/TO/factoidal-npm-entry.js`.
+- `hacl-wasm/` and `hacl-init.js`: Ed25519 is HACL\*'s C code compiled into
+  the Lean wasm module, SHA-256 is the Lean hash, and there is no
+  initialisation step.
+- the COTTAS functions `openCottas`, `queryCottas`, `closeCottas` and
+  `toCottas` (on the main entry and on `./fn`), and the browser delta log
+  (`deltaLogOpen` ... `deltaLogDestroy`), which wrote COTTAS batches. The
+  owner ruled the F\* COTTAS store essentially unused
+  ([issue 566](https://github.com/danbri/factoidal/issues/566)). The
+  Lean persisted store replaces them (below); its update path in JavaScript
+  is [issue 641](https://github.com/danbri/factoidal/issues/641).
+- the F\* `version.json` with its claims block. `l4-assets/version.json` is
+  the engine's provenance.
+
+New:
+
+- **The persisted store on the main entry**: `openStore(source, options)`
+  answers a `Store` (a store handle inside the engine: every artifact
+  verified against its manifest's SHA-256 once, then queried from the
+  retained blocks), `queryStore(source, sparql)`, `listStores()`, and
+  `sampleStorePath()` / `sampleStoreFacts`. `source` is a collection root
+  path (Node) or a reader function `(path) => bytes`, which is how a page
+  reads a store over `fetch()`.
+- `shaclValidate` and `shexValidate` on the Lean engine (ops of
+  `formal/lean4/Wasm/Ops/Validate.lean`): SHACL Core, SHACL-SPARQL and SHACL
+  1.2 node expressions; ShExJ or ShExC schemas. `shexValidate` answers a
+  boolean (the F\* engine answered `null` outside its decidable fragment).
+- SPARQL 1.2 queries: `query(data, q, {sparql12: true})` and
+  `handle.query(q, {sparql12: true})` (ops `queryDataset12`,
+  `datasetQuery12`): triple-term patterns, reified triples, annotations,
+  `TRIPLE`/`isTRIPLE`/`SUBJECT`/`PREDICATE`/`OBJECT`.
+- `query(data, q, {entail})` with `RDFS`, `OWL-RL`, `x-rdfscore` or
+  `x-rdfsplus` runs in the engine (op `queryRaw`): the default graph is
+  closed under the regime, then the query is answered. SELECT, ASK,
+  CONSTRUCT and DESCRIBE.
+- `loadEngine()`: the low-level engine handle (`call(op, args)`), for the
+  dispatch ops the typed layer does not wrap.
+- Common Logic: `clParse`, `clSerialize`, `clAlphaNorm`, `clNormalize` on the
+  main entry (they were on `./l4-core` only).
+- `browser.js` loads the wasm with `fetch` and
+  `WebAssembly.instantiateStreaming`; `setAssetsUrl()` names another
+  directory for the engine's three files.
+- `parse(text, {lenient: true})` (op `parseDocument`,
+  [issue 716](https://github.com/danbri/factoidal/issues/716)): the Turtle,
+  TriG, N-Triples and N-Quads parsers skip each bad statement, keep the good
+  ones and list one diagnostic per skipped statement in
+  `dataset.diagnostics`: `message`, `line`, `column`, `offset` (a UTF-16
+  index, as `ParseError.offset`) and a stable `class` (for example
+  `undefined-prefix`, `bad-escape`, `unexpected-token`). The new option
+  `maxErrors` stops the parse after that many diagnostics with one
+  `too-many-errors` diagnostic. `capabilities().parseDiagnostics` is `true`.
+  A document with no error gives the strict result and no diagnostics (a
+  theorem in the Lean source). RDF/XML and JSON-LD parse strictly.
+
+Changed:
+
+- **`ParseError.offset` is a UTF-16 code-unit index into the input string**,
+  so `text.slice(err.offset)` starts at the error. The F\* engine counted
+  UTF-8 bytes; the Lean engine counts Unicode scalar values and the wrapper
+  converts. (`line` is 1-based; `column` counts Unicode scalar values.) This
+  unit is a coordinator default, recorded in
+  `docs/designissues/2026-10-10-npm-lean-only.md`.
+- Each SELECT solution `Map` iterates in the order of the SELECT clause
+  (`head.vars`); it followed the member order of the engine's JSON binding
+  objects, which carries no meaning.
+- DESCRIBE answers the Concise Bounded Description of each named resource
+  (the F\* engine answered the empty graph,
+  [issue 702](https://github.com/danbri/factoidal/issues/702)).
+- `serialize(data, {format: 'ntriples'})` answers the engine's N-Quads text
+  and refuses data with a named graph (N-Triples has no graph term).
+- `xmlWellformed` reads a DOCTYPE with an internal subset (the F\* parser
+  answered `false` for any DOCTYPE); `xpathEval` is the full XPath 1.0
+  evaluator and its node kinds include `root` and `namespace`;
+  `mathmlEval` also evaluates `vector` and `matrix`; `rifEval`'s envelope
+  has no `rounds`/`engineMs`; `tableauMaterialise` adds `budgetHit`;
+  `rmlMap` reads the iteration format from the mapping's
+  `rml:referenceFormulation`. Record:
+  `docs/designissues/2026-10-10-npm-lean-only.md` section 6.
+- `capabilities()` reports what the loaded wasm serves: new members
+  `entailment`, `hdt`, `sparql12`, `store`; `cottasBytesStore` is gone.
+- `engines.node` is `>=22.12`: `index.js` hands the ES module `index.mjs`
+  to `require()`, so CommonJS and ES module callers share one engine and
+  one `Dataset` class. (Node 20 reached end of life on 2026-04-30.)
+
+Open, each with an expected-failure test:
+
+- A failed `SERVICE` call without `SILENT` inside `EXISTS`, and a failed
+  nested `SERVICE` under an outer `SILENT`
+  ([issue 735](https://github.com/danbri/factoidal/issues/735)). A failed
+  `SERVICE` call without `SILENT` elsewhere now fails the query
+  ([issue 717](https://github.com/danbri/factoidal/issues/717), fixed).
+
+Deprecated: `./l4` and `./l4-core` are aliases of `.` in 0.9.x and go in
+0.10.0. (`./l4` was the low-level loader; `loadEngine()` replaces it.)
+
+### Earlier in 0.9.0 (before the switch; `./l4-core` was the Lean entry then)
+
+**Lean engine (`factoidal/l4-core`): 26 more functions of the main
+entry** ([issue 713](https://github.com/danbri/factoidal/issues/713),
+stage 1 of making the package Lean-only). `jsonldToRdf`,
+`jsonldFromRdf`, `rmlMap`, `csvwToRdf`, `xmlWellformed`, `xpathEval`,
+`xsltTransform`, `schematronValidate`, `jsonSchemaValidate`,
+`mathmlEval`, `xformsRecalc`, `rifEval`, `queryHdt`,
+`tableauMaterialise`, `tableauDlInconsistent`, `queryRaw`, the three
+extension-function and two SERVICE-endpoint registry functions, and the
+five `toan*` functions now run over the Lean wasm. Signatures and
+result shapes are the F\* engine's. `parse(text, {format: 'jsonld'})`
+now works on this engine. `tableauMaterialise` also returns `budgetHit`
+on the Lean engine. The main entry (`index.js`) is unchanged.
+
+**`factoidal/l4-core` serves the maths, VC and DID functions, and matches the
+F\* engine's envelopes** (stage 2 of
+[issue 713](https://github.com/danbri/factoidal/issues/713)). New on the Lean
+engine, with the signatures and result shapes `index.d.ts` declares:
+`matrixDeterminant`, `matrixScalarProduct`, `matrixVectorProduct`,
+`matrixOuterProduct`, `sigmoidPoints`, `sigmoidFormulaMathml`, `vcSha256Hex`,
+`vcEd25519SecretToPublic`, `vcEd25519Sign`, `vcEd25519Verify`,
+`vcEddsaCreateFromCanonical`, `vcEddsaVerifyFromCanonical`, `vcCheckCredential`,
+`vcCheckCredentialSubject`, `vcCheckNoDataLoss`,
+`vcCheckRelatedResourceDigests` and `didKeyResolve`. The Ed25519 operations run
+HACL\* compiled into the wasm module; they need no `initHacl()` call. Envelope
+parity ([issue 685](https://github.com/danbri/factoidal/issues/685)): a Turtle,
+TriG, N-Triples or N-Quads syntax error rejects with a `ParseError` carrying
+`line`, `column`, `offset` and `format` (the Lean `offset` counts Unicode scalar
+values, the F\* `offset` counts UTF-8 bytes); `parse()` and `openDataset()`
+record the prefixes of a Turtle or TriG document; Turtle output accepts the
+`prefixes` and `literalShorthand` options and prints bare numeric and boolean
+literals by default; and each document that is parsed gets its own blank-node
+scope, so merging two documents that both write `_:b0` keeps two nodes. The
+Lean engine still has no `{lenient: true}` parse and no SPARQL 1.2 handle
+query.
+
+**Store format: the literal index is renamed LGI3 and LGI4; re-pack older
+generations.** The literal search index folds each lexical form before it takes
+character 3-grams. On 2026-10-10 the fold changed from ASCII-only to the Unicode
+case mapping that SPARQL `LCASE` uses
+([issue 706](https://github.com/danbri/factoidal/issues/706)), so the grams of a
+non-ASCII literal differ and an index written under the old fold lacks rows the
+Unicode `LCASE` keeps. The two layouts are now named LGI3 (was LGI1, sidecar
+`.lgi3`) and LGI4 (was LGI2, sidecar `.lgi4`), and the manifest layout labels
+changed with them. A generation packed earlier names LGI1 or LGI2; `storeOpen`,
+`storeManifestInspect`, `storeQueryPlan`, `storeQuery`, `l4block-shard-activate`
+and `l4block-quad-query` refuse it with the cause and ask for a re-pack.
+`storeOpen` and `storeHandleList` also report `literalIndexes` and
+`geoIndexes`, the number of retained blocks that hold a decoded index of each
+kind. Record: `docs/designissues/2026-10-10-literal-index-lgi3.md`.
+
+## 0.8.0 — 2026-09-16
+
+**Behaviour change: parsing is strict by default.** `parse()` (and
+every function that parses text input) now rejects on a syntax error,
+an undeclared prefix, or a relative IRI with no `baseIRI` in effect,
+instead of silently dropping the affected statements. The error is a
+new `class ParseError extends Error` (`name`, `line`, `column`,
+`offset`, `format` — position fields present for Turtle/TriG/
+N-Triples/N-Quads, absent for RDF/XML and JSON-LD, which carry a
+message only), exported from every entry point (`index.js`/`.mjs`,
+`wasm.js`, `l4-core.js`, `api.js`/`.mjs`, `lite.js`/`.mjs`, and
+`browser.js`, which declares its own copy since it has no imports).
+Pass `{lenient: true}` to `parse()` to recover instead: the returned
+Dataset holds whatever the parser recovered, and the new
+`dataset.diagnostics` array lists what was skipped (needs the
+npm-entry engine bundle's `parseDocument` export). Issues
+[344](https://github.com/danbri/factoidal/issues/344),
+[680](https://github.com/danbri/factoidal/issues/680),
+[681](https://github.com/danbri/factoidal/issues/681).
+
+**Dataset handles.** `openDataset(data, {format?, baseIRI?})` parses
+once and keeps the result indexed in the engine, so repeated
+`query()`/`update()`/`serialize()` calls against the returned
+`DatasetHandle` skip both the re-parse and the SPARQL-index rebuild a
+fresh `query(ds, ...)` call pays every time (measured ~2x faster per
+call on a 2,000-triple two-pattern join in this session — see
+`tests/perf/npm_handle_vs_stateless.mjs`). `query(data, sparql,
+options)`, `serialize(data, options)` and `canonicalize(data)` also
+accept a `DatasetHandle` directly; `update(handle, ...)` rejects with
+a `TypeError`, since `update()` always returns a fresh Dataset while
+`handle.update()` mutates the handle in place. `select.js` (the F*/
+Lean backend selector) deliberately does not route `openDataset()` —
+a handle is opened against one engine's own entry object, so there is
+no "same handle on the other engine" to fall through to.
+
+**Prefixes and Turtle literal shorthand.** `Dataset` gains `.prefixes`
+(the declared map from parsing, `{}` for N-Triples/N-Quads) and
+`.diagnostics` (own, non-enumerable properties, so `JSON.stringify()`/
+`toArray()` are unaffected either way). `serialize(data, {format:
+'turtle', prefixes?, literalShorthand?})` uses caller prefix pairs
+(dropping unused caller namespaces, skipping caller labels when
+auto-generating `nsN:` ones) when given, or automatically when `data`
+is a Dataset with non-empty `.prefixes`; `literalShorthand` (default
+`true`) controls whether `xsd:integer`/`decimal`/`double`/`boolean`
+literals with a Turtle-grammar-matching lexical form print bare.
+`DatasetHandle.serialize()` has the same options.
+
+**New entry point `@factoidal/core/lite`** (`lite.js`/`.mjs`/`.d.ts`):
+a smaller npm-entry ABI bundle (`factoidal-npm-entry-lite.js`, about
+half the gzip size of the full bundle — see README.md's "Choosing a
+bundle: full or lite") implementing the core surface (`parse`,
+`query`, `update`, `serialize`, `canonicalize`, `graphs`,
+`canonicalHash`, `openDataset`/`DatasetHandle`, the extension-function
+and SERVICE-endpoint registration functions, `capabilities`) with no
+SHACL, ShEx, OWL closure, JSON-LD, RDF/XML, CSVW, RML, RIF, XML,
+XPath, VC crypto, COTTAS, or CLI bundle (no entailment regimes, no
+`queryHdt`). `capabilities()` gains `profile` (`'full'` | `'lite'`),
+`abiVersion`, `datasetHandles`, `parseDiagnostics`, `turtlePrefixes`.
+Issue [684](https://github.com/danbri/factoidal/issues/684).
+
+**`browser.js`: `query()` and `toRdf()` route through the npm-entry
+ABI.** Whenever the persistent ABI bundle is available (already on
+`globalThis`, or fetched by `loadNpmEntry()`), `query()` with `entail:
+'none'` and `output: 'json'` (both defaults), and every `toRdf()`
+call, now go through it instead of the eval-per-call CLI bundle —
+falling back to the CLI bundle only when loading the ABI fails. This
+makes the classic-`<script>` route (README.md's "Bundlers and Content
+Security Policy" §b) CSP-safe for parsing and SELECT/ASK too, not only
+for the operations already ABI-routed. New `openDataset(text,
+{format?, baseIRI?})` on `browser.js` returns a handle with `query`/
+`update`/`serialize`/`close` over the same ABI. Issue
+[682](https://github.com/danbri/factoidal/issues/682) (second half).
+
+Three new entry points, for two storage protocols:
+
+* `@factoidal/core/lws` — a Node `http` server for the
+  [Linked Web Storage Protocol 1.0 core](https://w3c.github.io/lws-protocol/lws10-core/);
+* `@factoidal/core/solid/server` — the same shape for the
+  [Solid Protocol v0.11.0](https://solidproject.org/TR/protocol) server
+  conformance class, including the CORS preflight and the storage root;
+* `@factoidal/core/solid/client` — the client conformance class over
+  `fetch`, whose every request is built by the engine and whose every
+  response is read by it.
+
+Three commands: `factoidal lws-serve DIR`, `factoidal solid-serve DIR`
+and `factoidal solid-client <get|put|post|delete|discover> URL`.
+
+Every protocol decision is the Lean engine's; the hosts move bytes. The
+operations are `lwsOpen`/`lwsStep`/`lwsClose`,
+`solidOpen`/`solidStep`/`solidClose` and
+`solidClientRequest`/`solidClientResponse` on the WebAssembly dispatch
+ABI. **A module built before they landed answers `unknown op`**: the
+entry points report it through their `…OpsAvailable(engine)` probe and
+the commands exit 3. `DIR` is not read or written yet — the resource tree
+lives in the engine handle — and Solid-OIDC token verification is not
+built, so the first slice serves public resources and unauthenticated
+writes. Issue
+[659](https://github.com/danbri/factoidal/issues/659).
+
+New entry point `@factoidal/core/api`: `createApi(entry, options?)`
+wires the typed `parse`/`query`/`serialize`/... surface around an
+already-loaded npm-entry ABI object, with no `fetch` and no `new
+Function(src)` eval — the route for a bundler (esbuild, webpack,
+Rollup) or a page under `Content-Security-Policy: script-src 'self'`.
+`entry` accepts the `factoidalNpmEntry` object itself, a Promise of
+it, or a zero-argument function returning either. `browser.js`'s
+`loadNpmEntry()` now checks `globalThis.factoidalNpmEntry` before
+fetching anything, so a classic `<script src="factoidal-npm-entry.js">`
+tag (or the new `setNpmEntry(abi)`) makes every `browser.js` operation
+already routed through that ABI CSP-safe too. `package.json`'s
+`exports` map gains `./api` and direct subpaths for
+`factoidal-npm-entry.js`/`.wasm.js`/`.wasm.assets/*` (already shipped
+in `files`, not previously importable as package subpaths). Every
+typed entry point (`factoidal`, `factoidal/wasm`, `factoidal/api`,
+`factoidal/l4-core`) now reports `version` and `engine`. See
+README.md's "Bundlers and Content Security Policy" section. Proved
+against a real headless-Chromium page under that CSP header
+(`tests/web-demos/bundler_csp_smoke.sh`) and against esbuild's bundler
+(`test/bundler-esbuild.test.mjs`). Issue
+[682](https://github.com/danbri/factoidal/issues/682).
+
+README.md documents `parse()`'s output order (canonical/sorted
+N-Quads, not document order) and the blank-node label scheme
+(`_anonN` in document order for anonymous nodes, `p<k>_d<n>_` scope
+prefixes, no RDF meaning beyond within-dataset identity), pinned by
+`test/parse-order.test.js`. No behavior changed. Issue
+[683](https://github.com/danbri/factoidal/issues/683).
+
+A bare string where `parse`, `query`, `update`, `openDataset`,
+`serialize`, `canonicalize` or `DatasetHandle.serialize` take an
+options object now means `{ format: <string> }`, so
+`serialize(ds, 'turtle')` is `serialize(ds, { format: 'turtle' })`.
+Until now the string was read as an empty options object and
+`serialize(ds, 'turtle')` returned N-Quads with no error (found by the
+0.8.0 release probe). Any other non-object value throws a `TypeError`
+naming the function. Pinned by `test/options-format-string.test.js`.
+
+The shipped bundles are built from a fresh extraction of the F\* OWL
+closure source. The committed OCaml for `OWL.Closure` and
+`OWL.DirectMapping.Filter` had lagged the `.fst` files since the
+2026-09-07 OWL soundness audit (commit 709f3c4; the "Check F\* Extraction"
+workflow was red on `claude/main` from that date, runs 200 and 201),
+so 0.7.1 was built from the pre-audit rules. Observable in this
+release: the rule that derived `owl:sameAs` between named classes
+from `owl:equivalentClass` is removed, datatype-range clashes are
+decided by XSD value-space disjointness (`xsd_value_spaces_disjoint`),
+and the direct-mapping filter also excludes the built-in OWL annotation
+properties, not only declared ones. The npm-publish workflow re-extracts and refuses drift,
+so this correction is a precondition of the release.
+
 ## 0.7.1 — 2026-09-06
 
 `factoidal pack --batch-bytes N` was documented in 0.7.0 and refused by the
@@ -567,7 +1182,7 @@ Known limits, measured:
   format-compatibility gate rejected stores written by the current js
   bundle (caught by the wasm/js parity test in `test/`).
 
-## Unreleased
+## Between 0.1.0-alpha.0 and 0.1.0 — unpublished
 
 - Package renamed from the placeholder `@danbri/foafos` to `factoidal`
   (issue #403). The package was never published under the old name, so

package/NOTICE

@@ -3,27 +3,8 @@
 
 The code in this package is Apache-2.0; see LICENSE.
 
-sample-store/
--------------
-
-The bundled sample Shardborough store holds five IPTC NewsCodes
-vocabularies, converted from the publisher's RDF/XML and packed into
-IBK3 predicate blocks:
-
-  spamfstat, videoqualifier, subjectqualifier, videocodec, spct
-
-  Publisher: International Press Telecommunications Council
-             https://iptc.org/
-  Licence:   Creative Commons Attribution 4.0 International (CC BY 4.0)
-             https://creativecommons.org/licenses/by/4.0/
-  Obtained through: https://github.com/danbri/skosdex third_party/skos
-
-The IRIs, labels and structure are the IPTC's. The block layout, the
-dictionary, the indexes and the manifest are this package's encoding of
-them. Redistribution of the vocabulary content stays under CC BY 4.0.
-
-hacl-wasm/
-----------
+HACL* (compiled into l4factoidal.wasm)
+--------------------------------------
 
 HACL* verified cryptographic primitives, from
 https://github.com/hacl-star/hacl-star, Apache-2.0 / MIT. See the