@factoidal/core 0.14.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## Unreleased
+
+## 0.16.0 (2026-10-26)
+
+- Node settings in the evidence (https://github.com/danbri/factoidal/issues/975). The params of `node()` are the node's settings. With a wasm module that has the new op `pipelineCheckNodes` (Lean `Wasm/Ops/PipelineNodes.lean`, `Dataflow/NodeSettings.lean`), each evidence record carries `settings` (canonical: keys sorted, defaults of absent settings that narrow the contract such as `lenient: false` and `entail: 'none'`, a Dataset value as `{nquadsSha256}`) and `settingsDigest` (`sha256:` and the hex SHA-256 of the canonical text). A setting outside the proved domain of a proved stage (a lenient reader, an evaluator with `entail` other than `none` or with `output`, a key the stage's settings table does not name) makes the node's status `unproved`, with `registryStatus` and `outside` (each setting and the reason) in the record, so `run()` reports `proved: false`. A reader's `format` must name the stage's syntax (`ttl12` selects RDF 1.2 mode, reported as `derived.mode`); an evaluator's query must parse, else `node()` rejects. Design record: `docs/designissues/2026-10-25-pipeline-settings-and-provenance.md`.
+- The output wire of a `shippedEvaluator` node follows its query form: SELECT gives `Table`, ASK `Answer`, CONSTRUCT and DESCRIBE `Dataset` (owner, 2026-10-25: "select give table? Sure"). So reader, CONSTRUCT, CONSTRUCT is well typed, and reader, SELECT, CONSTRUCT is not. Proved: every answer that meets the evaluator contract has the wire of its query form (`Dataflow.evalContract_wire`) (https://github.com/danbri/factoidal/issues/1026). The Lean wire enumeration has a new wire `table`.
+- CSVW is a registered, bound stage: `node('CSVW (tabular data to RDF)', { metadata, mode, base, url })` runs `csvwToRdf` on CSV text and gives a Dataset and an evidence record with status `tested` (the W3C csv2rdf suite; no Lean contract, so `checked: false`) (https://github.com/danbri/factoidal/issues/975). `stages()` marks a stage `bound` only when the engine also reports it runnable.
+- With the wasm of 0.15.0 or older (for example a mismatched local install), records have no settings, the evaluator's wire is the registry's `Answer`, and the CSVW stage stays `missing` and unbound.
+
+- `packSbm11(text, { syntax, base })` packs an RDF document into the files of one SBM11 generation in memory and resolves to a `Map` from file name to bytes (data files, `.merkle` sidecars, `manifest.sbm11`; no `CURRENT`); `mapReader(files)` is a reader over such files for `openSbm11(source, { reader })`. The wasm op is `sbm11PackFiles` (Lean `Storage/Sbm11/PackBytes.lean`), one call per file. The files are byte for byte those of the native `l4sbm11-pack` for the same quads: 23 of 23 files for `test/fixtures/sbm11-tiny`, and all files of 605 of 605 W3C SPARQL 1.0 and 1.1 inputs (`SBM11_PACKFILES=1 tests/sbm11/census.sh`) (https://github.com/danbri/factoidal/issues/1009 stage 2). On the wasm of 0.15.0 or older, `packSbm11` rejects with `code: 'SBM11_NO_PACK_OP'`. The whole document and every file are in memory at once. Not yet: `factoidal pack` on SBM11, and a pack that streams its input.
+- SPARQL: the inverse path `^p` keeps a pair whose object is a literal. SPARQL 1.1 §9.3 and §18.4 make `?x ^p ?y` the same as `?y p ?x`, so `?x` can bind a literal; up to 0.15.0 both evaluators (the in-memory one and the SBM11 id path) dropped those pairs, and `SELECT ?x ?y WHERE { ?x ^<http://e/p> ?y }` over `<http://e/s> <http://e/p> "v" .` gave no row. Apache Jena ARQ 5.6.0 gives the same rows as the fix (https://github.com/danbri/factoidal/issues/1023). Tests: `test/inverse-path-literal-1023.test.mjs` and the `#guard`s in `SPARQL/QueryTests.lean`. The F* tree has the same fix.
+- SPARQL: a `FROM` or `FROM NAMED` IRI that names no graph of the dataset gives a warning of class `dataset-iri-not-found` in the `warnings` member of the query envelope (`class`, `clause` (`FROM` or `FROM NAMED`), `iri`, `message`), and on standard error in the native `l4factoidal query` command. The rows do not change: the clause adds no graph, as before (https://github.com/danbri/factoidal/issues/1032). Lean: `SPARQL.datasetWarnings` beside `applyDataset`, whose merge theorem is unchanged; `#guard`s in `SPARQL/QueryTests.lean` and `Wasm/Ops/Query.lean`. Tests: `test/from-iri-not-found.test.mjs` (plain assertions; https://github.com/danbri/factoidal/issues/1038 records why an expected failure that waits for a rebuild blocked the build of this release).
+- Tests, no engine change: GeoSPARQL `geo:wktLiteral` values made with `STRDT(CONCAT("POINT(", STR(?lon), " ", STR(?lat), ")"), geo:wktLiteral)` in SELECT, in a sub-SELECT that feeds `geof:sfWithin`, and by an INSERT whose stored literal `geof:sfWithin` then tests; from a CSVW column whose datatype object is `{"@id": "http://www.opengis.net/ont/geosparql#wktLiteral", "base": "string"}`; and from an RML object map with `rml:datatype` or a `rml:datatypeMap` with `rml:constant`. `test/wkt-generation.test.mjs` (6 pass on the 0.15.0 wasm) and `#guard`s in `Wasm/Ops/Query.lean` and `Wasm/Ops/Formats.lean`.
+
+- Tests, no engine change: `test/sparql-string-arg-types.test.mjs` holds 6 expected failures for SPARQL 1.1 string functions that accept arguments the specification makes type errors, and for SUBSTR rounding (https://github.com/danbri/factoidal/issues/1036), found by porting Apache Jena ARQ expression tests (`docs/designissues/2026-10-25-jena-style-facade-feasibility.md`).
+
+## 0.15.0
+
+- `openSbm11(source)` and `registerSbm11Source(source, reader)` are back, with the wasm ops `sbm11Open`, `sbm11Query`, `sbm11Close`: SPARQL over an SBM11 generation (the Shardborough store) in Node and in the browser, reading each file at an offset through a host reader (https://github.com/danbri/factoidal/issues/1009, https://github.com/danbri/factoidal-core/pull/93). Fix: in 0.14.0 `sbm11Open` trapped (wasm `unreachable`) because the C host-read functions had a signature that differs from the generated one; the wasm build now fails on any such mismatch. Not yet: the Merkle check of each read, a generation with a delta log (refused at open), packing SBM11 from npm.
+- `lwsSbm11Reader(url, { auth, headers, transport })`: a reader for `openSbm11` of an SBM11 generation held as Linked Web Storage resources, by HTTP `Range` GETs when the server answers `206` with a matching `Content-Range`, else by whole GETs kept in memory; a changed `ETag` refuses the read, and `store.evidence` lists each resource read with its `ETag` (https://github.com/danbri/factoidal/issues/1010, https://github.com/danbri/factoidal-core/pull/90). In Lean every reader is now a storage `Medium`. `browser.d.ts` now types `openSbm11` and `registerSbm11Source`.
+- The native `l4factoidal query` command keeps a named graph with no triple (RDF 1.1 Concepts §4); before, the dataset went through an N-Quads round trip, which cannot state an empty graph (https://github.com/danbri/factoidal/issues/876 part 1, https://github.com/danbri/factoidal-core/pull/94).
+- SPARQL: a property-path alternative of IRIs (`?s p|q ?o`) is planned as the UNION of its triple patterns, so the store planners use their indexes for it; a theorem proves the two forms give the same solutions in the same order and multiplicity, and a test checks that both give the same plan and rows (https://github.com/danbri/factoidal/issues/1008, https://github.com/danbri/factoidal-core/pull/96).
+- `pipe()` and `run()` take the type check and the union of the named assumptions from the engine's op `pipelineCheck`, computed from the Lean stage registry; one theorem (`Pipeline.guarantee_sound`) gives the guarantee of every well-typed pipeline (https://github.com/danbri/factoidal/issues/1002 step 1, https://github.com/danbri/factoidal-core/pull/82). `pipe()` adds `wellTyped` and `check`; `run()` adds `wellTyped` and refuses a pipeline that is not well typed unless `{unchecked: true}`, then reports `proved: false`. `stages()` adds `params`. With a wasm build that has no op `pipelineCheck`, `wellTyped` is null and the union is computed from the nodes as before.
+
 ## 0.14.0
 
 **Checked pipelines.** Each component (reader, store, query evaluator, writer, reasoner, validator, proof checker) has one interface type whose contract against the W3C specifications is part of the type. A component cannot be added without a contract; a contract that is not proved yet is a named assumption, listed and counted in CI. A theorem states that the SPARQL answer agrees with the SPARQL 1.1 semantics for data from any source (a parsed document, a Dataset after edits, an update, a reasoner's output, a union of stores), given the listed assumptions. Status and gaps: https://github.com/danbri/factoidal/issues/975.

package/README.md

@@ -68,6 +68,10 @@ The same components are nodes you can compose. A value on a wire is
 `{graph, evidence}`; each node adds one evidence record; the result lists the
 union of the named assumptions of the nodes, so a pipeline says exactly what
 its answer depends on.
+`pipe()` and `run()` get the type check and that union from the engine
+(op `pipelineCheck`); the theorem `Pipeline.guarantee_sound` gives the
+guarantee of every well-typed pipeline, and `run()` refuses one that is not
+well typed unless `{ unchecked: true }`.
 
 ```js
 import { stages, node, pipe, run } from "@factoidal/core";

package/browser.d.ts

@@ -11,7 +11,7 @@ export type {
   DataFormat, EntailRegime, Bindings, DataInput, QueryInput, ParseOptions,
   QueryOptions, SerializeOptions, StoreReader, OpenStoreOptions,
   DeltaLogHandle, DeltaLogInspection,
-  Sbm11Reader, Sbm11Answer, Sbm11Store,
+  Sbm11Reader, Sbm11Answer, Sbm11Store, Sbm11ReadEvidence, Sbm11Transport,
   ExplainResult, StageInfo, EvidenceRecord, Wire, FactoidalNode, Pipeline, RunResult, RunOptions,
 } from './index';
 
@@ -40,6 +40,11 @@ export {
   openStore,
   queryStore,
   listStores,
+  openSbm11,
+  packSbm11,
+  mapReader,
+  registerSbm11Source,
+  lwsSbm11Reader,
   deltaLogOpen,
   deltaLogAppend,
   deltaLogReadAllHex,

package/browser.js

@@ -26,6 +26,8 @@ import { buildApi } from './lib/api.mjs';
 import { entryFromEngine } from './lib/lean-entry.mjs';
 import { browserEngine } from './lib/browser-engine.mjs';
 import { indexedDbDeltaLogStore } from './lib/delta-log-hosts.mjs';
+import { sbm11Api, registerSbm11Source, mapReader } from './lib/sbm11.mjs';
+import { lwsSbm11Reader } from './lib/sbm11-lws.mjs';
 
 const l4Engine = browserEngine('l4factoidal', new URL('./l4-assets/', import.meta.url).href);
 
@@ -59,8 +61,19 @@ const api = buildApi({
   deltaLogStore: indexedDbDeltaLogStore(),
 });
 
-// SBM11 (openSbm11, registerSbm11Source) is not exported in 0.14.0: the op
-// sbm11Open traps in the wasm build (https://github.com/danbri/factoidal/issues/1009).
+// SBM11, the Shardborough store, through host positioned reads
+// (lib/sbm11.mjs; https://github.com/danbri/factoidal/issues/1009). In a
+// browser every source needs a registered synchronous reader, for example
+// over OPFS FileSystemSyncAccessHandle in a dedicated worker.
+const sbm11 = sbm11Api(loadEngine);
+export const openSbm11 = sbm11.openSbm11;
+// Pack a document into the files of an SBM11 generation in memory, and a
+// reader over such files (issue 1009 stage 2).
+export const packSbm11 = sbm11.packSbm11;
+export { registerSbm11Source, mapReader };
+// A reader of an SBM11 generation held as LWS resources (issue 1010 KR3). In
+// a browser worker its default transport is a synchronous XMLHttpRequest.
+export { lwsSbm11Reader };
 
 // RDF and SPARQL
 export const parse = api.parse;

package/index.d.ts

@@ -701,14 +701,31 @@ export interface StageInfo {
   note: string;
   /** false exactly when status is 'missing': such a stage does not run. */
   runnable: boolean;
-  /** true when this package has a function that runs the stage as a node. */
+  /**
+   * true when this package has a function that runs the stage as a node AND
+   * the engine reports the stage runnable (an older engine that reports a
+   * stage 'missing' leaves it unbound).
+   */
   bound: boolean;
 }
 
+/**
+ * The status of a node: the registry status, or 'unproved' when the stage is
+ * 'proved' and one of the node's settings is outside its proved domain (op
+ * pipelineCheckNodes, Lean Dataflow/NodeSettings.lean).
+ */
+export type NodeStatus = StageInfo['status'] | 'unproved';
+
+/** A setting outside the proved domain of its stage, with the reason. */
+export interface OutsideSetting {
+  readonly setting: string;
+  readonly reason: string;
+}
+
 /** One evidence record: the node that ran and what it produced. */
 export interface EvidenceRecord {
   stage: string;
-  status: StageInfo['status'];
+  status: NodeStatus;
   contract: string | null;
   assumptions: string[];
   /** true iff `status` is 'proved'. */
@@ -719,6 +736,19 @@ export interface EvidenceRecord {
   reason?: string;
   /** The node's own output beside the graph: the explain result, the SHACL report, the written text, ... */
   artefact: unknown;
+  /**
+   * The node's settings in canonical form (keys sorted at every depth; the
+   * defaults of absent settings that narrow the contract, e.g. `lenient:
+   * false`, `entail: 'none'`; a Dataset value as `{nquadsSha256}`). Present
+   * when the engine has the op pipelineCheckNodes.
+   */
+  settings?: Record<string, unknown>;
+  /** `sha256:` and the hex SHA-256 of the canonical settings text. */
+  settingsDigest?: string;
+  /** With status 'unproved': the registry status ('proved'). */
+  registryStatus?: StageInfo['status'];
+  /** With status 'unproved': the settings outside the proved domain. */
+  outside?: OutsideSetting[];
 }
 
 /** The value on a wire. */
@@ -731,27 +761,82 @@ export interface Wire<G = unknown> {
 export interface FactoidalNode {
   readonly stage: string;
   readonly kind: string | null;
-  readonly status: StageInfo['status'];
+  /** The engine's status of this node with its settings (see NodeStatus). */
+  readonly status: NodeStatus;
+  /** The registry status of the stage. */
+  readonly registryStatus: StageInfo['status'];
   readonly contract: string | null;
   readonly assumptions: readonly string[];
   readonly wireIn: string;
+  /**
+   * The output wire with these settings: for shippedEvaluator, 'Table' for
+   * SELECT, 'Answer' for ASK, 'Dataset' for CONSTRUCT and DESCRIBE (Lean
+   * formWire, evalContract_wire). With an older engine, the registry wire.
+   */
   readonly wireOut: string;
   readonly runnable: boolean;
   readonly bound: boolean;
+  /** The settings as given (passed to the package function that runs the stage). */
   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>>;
+  /** The engine's canonical settings, or null with an older engine. */
+  readonly settings: Readonly<Record<string, unknown>> | null;
+  readonly settingsDigest: string | null;
+  readonly outside: readonly OutsideSetting[];
+  /** Values the engine read from the settings: `form` of a query, `mode` ('1.1' | '1.2') of a reader. */
+  readonly derived: Readonly<Record<string, string>> | null;
+}
+
+/** The engine's check of a list of stages (op pipelineCheck, Lean pipelineReport). */
+export interface PipelineCheck {
+  /** Each stage's output wire is the next stage's input wire or converts to it (Lean wellTyped_iff). */
+  readonly wellTyped: boolean;
+  readonly wireIn: string | null;
+  readonly wireOut: string | null;
+  /** The first stage `at` whose output does not feed stage `at + 1`. */
+  readonly mismatch: { readonly at: number; readonly out: string; readonly in: string } | null;
+  /** Where an output reaches the next input by a named conversion (Dataflow/Wire.lean). */
+  readonly conversions: readonly { readonly at: number; readonly from: string; readonly to: string }[];
+  /** The union of the stages' named assumptions: the premises of Pipeline.guarantee_sound. */
+  readonly assumptions: readonly string[];
+  readonly contract: { readonly theorem: string; readonly stages: readonly (string | null)[] };
+  readonly stages: readonly {
+    readonly name: string; readonly status: NodeStatus; readonly checked: boolean;
+    readonly contract: string | null; readonly assumptions: readonly string[];
+    readonly wireIn: string; readonly wireOut: string;
+    /** The fields below come from the op pipelineCheckNodes only. */
+    readonly registryStatus?: StageInfo['status'];
+    readonly settings?: Record<string, unknown>;
+    readonly settingsDigest?: string;
+    /** The role of each setting: 'parameter' | 'selects-wire' | 'inert' | 'narrows' | 'unlisted'. */
+    readonly roles?: Readonly<Record<string, string>>;
+    readonly outside?: readonly OutsideSetting[];
+    readonly derived?: Readonly<Record<string, string>>;
+  }[];
 }
 
-/** A pipeline: nodes in order; `assumptions` is the union of theirs. */
+/**
+ * A pipeline: nodes in order. `check` is the engine's op pipelineCheck;
+ * `assumptions` and `wellTyped` are its fields. With an engine that has no
+ * such op, `check` and `wellTyped` are null and `assumptions` is the union
+ * of the nodes' assumptions.
+ */
 export interface Pipeline {
   readonly nodes: readonly FactoidalNode[];
   readonly assumptions: readonly string[];
+  readonly wellTyped: boolean | null;
+  readonly check: PipelineCheck | null;
 }
 
 /** The result of run(): the last graph, one record per node, the assumption union. */
 export interface RunResult<G = unknown> extends Wire<G> {
+  /** The assumptions of the records on the input wire, then the engine's union for the pipeline (op pipelineCheck). */
   assumptions: string[];
-  /** true iff every evidence record is checked (status 'proved'). */
+  /** true iff every evidence record is checked (status 'proved') and the pipeline is well typed. */
   proved: boolean;
+  /** The engine's type check of the pipeline; null when the engine has no op pipelineCheck. */
+  wellTyped: boolean | null;
   /** The stage names of the records that are not checked. */
   uncheckedSteps: string[];
 }
@@ -784,7 +869,8 @@ 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.
+ * no package function, or when the engine's check finds the pipeline not
+ * well typed (unless `options.unchecked`; then `proved` is false).
  */
 export function run(pipeline: FactoidalNode | Pipeline, input: unknown, options?: RunOptions): Promise<RunResult>;
 
@@ -1093,10 +1179,54 @@ export interface Sbm11Store {
   generation: string;
   terms: number;
   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;
   close(): void;
 }
 
+/** 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>;
+
+/** Serve `source` with `reader`; `null` removes it. */
+export function registerSbm11Source(source: string, reader: Sbm11Reader | null): void;
+
+/** Pack an RDF document into the files of one SBM11 generation, in memory
+ * (wasm op `sbm11PackFiles`, https://github.com/danbri/factoidal/issues/1009
+ * stage 2): file name to bytes, the files `l4sbm11-pack` writes for the same
+ * quads, without `CURRENT`. Rejects with `code: 'SBM11_NO_PACK_OP'` on a wasm
+ * module that has no such op. */
+export function packSbm11(text: string | Uint8Array,
+  options: { syntax: 'turtle' | 'trig' | 'nquads' | 'ntriples' | 'rdfxml' | 'jsonld' | string; base?: string }
+): Promise<Map<string, Uint8Array>>;
+
+/** A reader over files held in memory (for example the result of `packSbm11`). */
+export function mapReader(files: Map<string, Uint8Array> | Record<string, Uint8Array>): Sbm11Reader;
+
+/** One LWS resource an SBM11 reader read (https://github.com/danbri/factoidal/issues/1010). */
+export interface Sbm11ReadEvidence {
+  resource: string;
+  etag: string;
+  lastModified: string | null;
+  /** HTTP requests made for this resource */
+  requests: number;
+  /** answers that were 206 Partial Content */
+  partial: number;
+  /** content bytes received */
+  bytes: number;
+}
+
+/** A synchronous HTTP GET: `(url, headers) -> answer`. */
+export type Sbm11Transport = (url: string, headers: Record<string, string>) =>
+  { status: number; header(name: string): string | null; bytes: Uint8Array };
 
+/** A reader of the SBM11 files held as LWS resources under the container
+ * `url` (one resource per file, CURRENT a resource too), by HTTP Range GETs
+ * when the server answers 206, else by whole GETs kept in memory. Node: the
+ * default transport is a fetch in a worker thread; close() stops it. */
+export function lwsSbm11Reader(url: string, opts?: {
+  auth?: string; headers?: Record<string, string>; transport?: Sbm11Transport; timeoutMs?: number
+}): Sbm11Reader & { evidence(): Sbm11ReadEvidence[]; errors(): string[]; close(): void };
 
 /** One query against a store: open with the query's plan, query, close. */
 export function queryStore(
@@ -1505,6 +1635,10 @@ export function capabilities(): Promise<{
   owlClosure: boolean;
   explain: boolean;
   stages: boolean;
+  /** The op pipelineCheck: pipe() and run() use the engine's type check and assumption union. */
+  pipelineCheck: boolean;
+  /** The op pipelineCheckNodes: node settings in evidence, and the evaluator's output wire from the query form. */
+  pipelineCheckNodes: boolean;
   tableau: boolean;
   rml: boolean;
   csvw: boolean;

package/index.mjs

@@ -21,6 +21,10 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { buildApi } from './lib/api.mjs';
 import { entryFromEngine } from './lib/lean-entry.mjs';
+import { sbm11Api, registerSbm11Source, setDefaultSbm11Reader, mapReader } from './lib/sbm11.mjs';
+import { nodeDefaultReaderFactory } from './lib/sbm11-node.mjs';
+import { lwsSbm11Reader as lwsSbm11ReaderWith } from './lib/sbm11-lws.mjs';
+import { nodeSyncTransport } from './lib/sync-http-node.mjs';
 
 /**
  * The loaded Lean engine handle: `call(op, args)`, `callBlob`,
@@ -66,8 +70,26 @@ export const clearExtensionFunctions = api.clearExtensionFunctions;
 export const registerServiceEndpoint = api.registerServiceEndpoint;
 export const clearServiceEndpoints = api.clearServiceEndpoints;
 
-// SBM11 (openSbm11, registerSbm11Source) is not exported in 0.14.0: the op
-// sbm11Open traps in the wasm build (https://github.com/danbri/factoidal/issues/1009).
+// SBM11, the Shardborough store, through host positioned reads
+// (lib/sbm11.mjs; https://github.com/danbri/factoidal/issues/1009). In Node a
+// source with no registered reader is a directory.
+setDefaultSbm11Reader(nodeDefaultReaderFactory());
+const sbm11 = sbm11Api(loadEngine);
+export const openSbm11 = sbm11.openSbm11;
+// Pack a document into the files of an SBM11 generation in memory, and a
+// reader over such files (issue 1009 stage 2).
+export const packSbm11 = sbm11.packSbm11;
+export { registerSbm11Source, mapReader };
+
+// A reader of an SBM11 generation held as LWS resources (lib/sbm11-lws.mjs;
+// https://github.com/danbri/factoidal/issues/1010 KR3). In Node the default
+// synchronous transport is a fetch in a worker thread (lib/sync-http-node.mjs),
+// stopped by the reader's close().
+export function lwsSbm11Reader(url, opts = {}) {
+  if (typeof opts.transport === 'function') return lwsSbm11ReaderWith(url, opts);
+  const transport = nodeSyncTransport({ timeoutMs: opts.timeoutMs });
+  return lwsSbm11ReaderWith(url, { ...opts, transport, onClose: () => transport.close() });
+}
 
 // The persisted store
 export const openStore = api.openStore;

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 = "2e65b7c2fda1";
+const WASM_VERSION = "1b10444e4416";
 
 import createModule from './l4factoidal.mjs';