@factoidal/core 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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.

package/browser.d.ts

@@ -41,6 +41,8 @@ export {
   queryStore,
   listStores,
   openSbm11,
+  packSbm11,
+  mapReader,
   registerSbm11Source,
   lwsSbm11Reader,
   deltaLogOpen,

package/browser.js

@@ -26,7 +26,7 @@ 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 } from './lib/sbm11.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);
@@ -65,8 +65,12 @@ const api = buildApi({
 // (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.
-export const openSbm11 = sbm11Api(loadEngine).openSbm11;
-export { registerSbm11Source };
+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 };

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,14 +761,31 @@ 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). */
@@ -755,9 +802,17 @@ export interface PipelineCheck {
   readonly assumptions: readonly string[];
   readonly contract: { readonly theorem: string; readonly stages: readonly (string | null)[] };
   readonly stages: readonly {
-    readonly name: string; readonly status: StageInfo['status']; readonly checked: boolean;
+    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>>;
   }[];
 }
 
@@ -1136,6 +1191,18 @@ export function openSbm11(source: string, options?: { reader?: Sbm11Reader }): P
 /** 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;
@@ -1570,6 +1637,8 @@ export function capabilities(): Promise<{
   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,7 +21,7 @@ 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 } from './lib/sbm11.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';
@@ -74,8 +74,12 @@ export const clearServiceEndpoints = api.clearServiceEndpoints;
 // (lib/sbm11.mjs; https://github.com/danbri/factoidal/issues/1009). In Node a
 // source with no registered reader is a directory.
 setDefaultSbm11Reader(nodeDefaultReaderFactory());
-export const openSbm11 = sbm11Api(loadEngine).openSbm11;
-export { registerSbm11Source };
+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

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 = "06c67c273257";
+const WASM_VERSION = "1b10444e4416";
 
 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-e5d9a26f3b19-web",
-  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/40198875683",
-  "gitSha": "e5d9a26f3b1931ed70fc3f6a8df3fc78ff1699a4",
-  "builtAt": "2026-10-25T14:18:06Z",
+  "release": "danbri/factoidal-builds build-0069da82efd7-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/40281606727",
+  "gitSha": "0069da82efd75cc3bfe10785ef8853bd84931957",
+  "builtAt": "2026-10-26T08:11:18Z",
   "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": "06c67c273257118abb3cebdbc249e27d20ba98e87b278b7291c1a9934faecdc4",
-  "wasmBytes": 16918397,
+  "wasmSha256": "1b10444e44160b8689ebd5375c074509196930b1927ce4c9fbc829a73d9b58ac",
+  "wasmBytes": 17034490,
   "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"

package/lib/api.mjs

@@ -684,7 +684,15 @@ function buildApi(driver) {
     if (r.kind === 'construct' || r.kind === 'describe') {
       return c.fromNQuads(r.nquads, ds.prefixes);
     }
-    return bindingsFromSrj(r.srj);
+    const rows = bindingsFromSrj(r.srj);
+    // The engine's warnings (class dataset-iri-not-found for a FROM or FROM
+    // NAMED IRI that names no graph, https://github.com/danbri/factoidal/issues/1032),
+    // passed through unchanged as a non-enumerable `warnings` property, so
+    // the rows themselves are unchanged.
+    if (Array.isArray(r.warnings) && r.warnings.length > 0) {
+      Object.defineProperty(rows, 'warnings', { value: r.warnings, enumerable: false });
+    }
+    return rows;
   }
 
   async function shaclOnHandle(c, ds, shapes, opts) {
@@ -2140,6 +2148,7 @@ function buildApi(driver) {
       explain: has('explainGraph'),
       stages: has('stageList'),
       pipelineCheck: has('pipelineCheck'),
+      pipelineCheckNodes: has('pipelineCheckNodes'),
       entailment: has('queryRaw'),
       tableau: has('tableauMaterialise') && has('tableauDlInconsistent'),
       rml: has('rmlMap'),
@@ -2176,7 +2185,7 @@ function buildApi(driver) {
   // The node-composition API (lib/nodes.mjs, issue 1002 step 2).
   const nodeApi = buildNodes({
     entry, entryResult, requireEntryFn, Dataset,
-    parse, closure, shaclValidate, query, serialize, canonicalize, explain,
+    parse, closure, shaclValidate, query, serialize, canonicalize, explain, csvwToRdf,
   });
 
   return {

package/lib/evidence.mjs

@@ -16,6 +16,10 @@ export const isChecked = (status) => status === 'proved';
 /** The reason text of an unchecked step. */
 export function reasonOf(n) {
   if (n.status === 'missing') return 'no contract';
+  if (n.status === 'unproved' && n.outside && n.outside.length > 0) {
+    return `status unproved (registry status ${n.registryStatus || 'proved'}); settings outside ` +
+      `the proved domain: ${n.outside.map((o) => `${o.setting} (${o.reason})`).join('; ')}`;
+  }
   return n.assumptions.length > 0
     ? `status ${n.status}; assumptions: ${n.assumptions.join(', ')}`
     : `status ${n.status}`;
@@ -43,7 +47,10 @@ export function refusalFor(n, unchecked, hasRunner) {
 /**
  * One evidence record. `checked` is true iff the status is `proved`.
  * A step that ran under the opt-in and is not checked also carries
- * `unchecked: true` and `reason`.
+ * `unchecked: true` and `reason`. When the engine read the node's settings
+ * (op pipelineCheckNodes), the record also carries `settings` (canonical)
+ * and `settingsDigest`, and, when a setting left the proved domain,
+ * `registryStatus` and `outside`; its `status` is then `unproved`.
  */
 export function makeRecord(n, artefact, unchecked) {
   const checked = isChecked(n.status);
@@ -55,6 +62,14 @@ export function makeRecord(n, artefact, unchecked) {
     checked,
     artefact: artefact === undefined ? null : artefact,
   };
+  if (n.settingsDigest) {
+    base.settings = n.settings;
+    base.settingsDigest = n.settingsDigest;
+  }
+  if (n.outside && n.outside.length > 0) {
+    base.registryStatus = n.registryStatus;
+    base.outside = n.outside;
+  }
   if (unchecked && !checked) {
     base.unchecked = true;
     base.reason = reasonOf(n);

package/lib/nodes.mjs

@@ -26,6 +26,18 @@
 // built before the op, pipe() and run() fall back to the union of the
 // nodes' fields and report `wellTyped: null`.
 //
+// Node settings (https://github.com/danbri/factoidal/issues/975,
+// https://github.com/danbri/factoidal/issues/1026): the params of node()
+// are the node's settings. When the engine has the op pipelineCheckNodes
+// (formal/lean4/Wasm/Ops/PipelineNodes.lean), the engine decides, per node:
+// the settings in canonical form with their SHA-256 digest, the role of each
+// setting in the stage's contract, the settings outside the proved domain
+// (a proved stage with one is `unproved`), and the output wire the settings
+// select (SELECT gives a Table, ASK an Answer, CONSTRUCT and DESCRIBE a
+// Dataset, so a CONSTRUCT node can feed the next node). This file only marshals: a Dataset setting is sent as
+// {"$nquads": its N-Quads text}. With an older engine, records carry no
+// settings and the evaluator's output wire is the registry's.
+//
 // ES module, no Node built-ins: the browser loads this file as it is.
 
 import { FactoidalError } from './errors.mjs';
@@ -37,7 +49,7 @@ import { refusalFor, makeRecord, summarize, unionAssumptions, unionLists } from
  */
 export function buildNodes(deps) {
   const { entry, entryResult, requireEntryFn, Dataset,
-    parse, closure, shaclValidate, query, serialize, canonicalize, explain } = deps;
+    parse, closure, shaclValidate, query, serialize, canonicalize, explain, csvwToRdf } = deps;
 
   const reader = (format) => async (wire, params) => {
     if (typeof wire.graph !== 'string') {
@@ -88,6 +100,14 @@ export function buildNodes(deps) {
     rdfcStage: async (wire, params) => ({
       artefact: { canonical: await canonicalize(wire.graph, params) },
     }),
+    'CSVW (tabular data to RDF)': async (wire, params) => {
+      if (typeof wire.graph !== 'string') {
+        throw new TypeError(`node CSVW: the stage takes CSV text on its wire (got ${typeof wire.graph})`);
+      }
+      const { metadata, ...opts } = params;
+      const meta = metadata === undefined || typeof metadata === 'string' ? metadata : JSON.stringify(metadata);
+      return { graph: await csvwToRdf(wire.graph, meta, opts), artefact: { tabular: 'csv' } };
+    },
     rdfsExplainGraphStage: async (wire, params) => {
       const { description, ...opts } = params;
       if (description === undefined) {
@@ -116,7 +136,10 @@ export function buildNodes(deps) {
           theorems: Object.freeze([...s.theorems]),
           assumptions: Object.freeze([...s.assumptions]),
           tests: Object.freeze([...s.tests]),
-          bound: Object.prototype.hasOwnProperty.call(RUNNERS, s.name),
+          // bound: the package has a runner AND the engine lets the stage
+          // run. A runner for a stage that an older engine reports as
+          // `missing` is not bound (the engine's registry decides).
+          bound: s.runnable && Object.prototype.hasOwnProperty.call(RUNNERS, s.name),
         })));
       })();
       stageCache.catch(() => { stageCache = null; });
@@ -126,6 +149,32 @@ export function buildNodes(deps) {
 
   const NODE = Symbol('factoidal.node');
 
+  // The settings as the engine reads them: JSON values, a Dataset as
+  // {"$nquads": text}. Anything else is refused.
+  function marshal(v, path) {
+    if (v === null || typeof v === 'string' || typeof v === 'boolean') return v;
+    if (typeof v === 'number') {
+      if (!Number.isFinite(v)) throw new TypeError(`node: setting ${path} is not a finite number`);
+      return v;
+    }
+    if (v instanceof Dataset) return { $nquads: v.toNQuads() };
+    if (Array.isArray(v)) return v.map((x, i) => marshal(x, `${path}[${i}]`));
+    if (typeof v === 'object' && Object.getPrototypeOf(v) === Object.prototype) {
+      const out = {};
+      for (const [k, x] of Object.entries(v)) if (x !== undefined) out[k] = marshal(x, `${path}.${k}`);
+      return out;
+    }
+    throw new TypeError(`node: setting ${path} must be a JSON value or a Dataset (got ${typeof v})`);
+  }
+
+  const hasNodeCheck = () => !!engine && typeof engine.pipelineCheckNodes === 'function';
+
+  // The engine's check of nodes with settings (op pipelineCheckNodes).
+  function nodeCheck(items) {
+    return entryResult(engine.pipelineCheckNodes(JSON.stringify(
+      items.map((n) => ({ stage: n.stage, settings: n.settingsWire })))), 'pipelineCheckNodes');
+  }
+
   /**
    * A node for the registered stage `name`, with its parameters (the
    * second argument of the package function it calls, e.g. `{shapes}`,
@@ -144,18 +193,28 @@ export function buildNodes(deps) {
       throw new FactoidalError(`node: no registered stage named '${name}' (see stages())`,
         { code: 'option.invalid-value' });
     }
+    const settingsWire = marshal({ ...(params || {}) }, 'params');
+    // The engine's reading of the settings, when it has the op.
+    let s = null;
+    if (hasNodeCheck()) s = nodeCheck([{ stage: info.name, settingsWire }]).stages[0];
     return Object.freeze({
       [NODE]: true,
       stage: info.name,
       kind: info.kind,
-      status: info.status,
+      status: s ? s.status : info.status,
+      registryStatus: info.status,
       contract: info.contract,
       assumptions: info.assumptions,
       wireIn: info.wireIn,
-      wireOut: info.wireOut,
+      wireOut: s ? s.wireOut : info.wireOut,
       runnable: info.runnable,
       bound: info.bound,
       params: Object.freeze({ ...(params || {}) }),
+      settingsWire,
+      settings: s ? s.settings : null,
+      settingsDigest: s ? s.settingsDigest : null,
+      outside: Object.freeze(s ? s.outside.map((o) => Object.freeze({ ...o })) : []),
+      derived: s ? Object.freeze({ ...s.derived }) : null,
     });
   }
 
@@ -174,8 +233,11 @@ export function buildNodes(deps) {
    * or null when the loaded engine has no such op.
    */
   function check(nodes) {
-    if (!engine || typeof engine.pipelineCheck !== 'function') return null;
-    const r = entryResult(engine.pipelineCheck(JSON.stringify(nodes.map((n) => n.stage))), 'pipelineCheck');
+    let r;
+    if (hasNodeCheck()) r = nodeCheck(nodes);
+    else if (engine && typeof engine.pipelineCheck === 'function') {
+      r = entryResult(engine.pipelineCheck(JSON.stringify(nodes.map((n) => n.stage))), 'pipelineCheck');
+    } else return null;
     return Object.freeze({
       wellTyped: r.wellTyped,
       wireIn: r.wireIn,
@@ -184,7 +246,11 @@ export function buildNodes(deps) {
       conversions: Object.freeze(r.conversions.map((c) => Object.freeze({ ...c }))),
       assumptions: Object.freeze([...r.assumptions]),
       contract: Object.freeze({ theorem: r.contract.theorem, stages: Object.freeze([...r.contract.stages]) }),
-      stages: Object.freeze(r.stages.map((s) => Object.freeze({ ...s, assumptions: Object.freeze([...s.assumptions]) }))),
+      stages: Object.freeze(r.stages.map((s) => Object.freeze({
+        ...s,
+        assumptions: Object.freeze([...s.assumptions]),
+        ...(s.outside ? { outside: Object.freeze(s.outside.map((o) => Object.freeze({ ...o }))) } : {}),
+      }))),
     });
   }
 

package/lib/sbm11.mjs

@@ -68,6 +68,32 @@ export function setDefaultSbm11Reader (factory) {
   defaultReader = factory
 }
 
+/**
+ * A reader over files held in memory: `files` is a Map (or a plain object)
+ * from file name to Uint8Array, for example the result of packSbm11. It
+ * moves bytes only; a read past the end of a file, or of a file it does not
+ * hold, answers null, and the engine refuses it with the file name.
+ */
+export function mapReader (files) {
+  const m = files instanceof Map ? files : new Map(Object.entries(files || {}))
+  return {
+    readAt (file, offset, length) {
+      const b = m.get(file)
+      if (!b || offset < 0 || length < 0 || offset + length > b.length) return null
+      return b.subarray(offset, offset + length)
+    },
+    size (file) {
+      const b = m.get(file)
+      return b ? b.length : null
+    }
+  }
+}
+
+function opsReflection (eng) {
+  const r = eng.call('ops', [])
+  return typeof r === 'string' ? JSON.parse(r) : r
+}
+
 function envelope (raw) {
   const j = typeof raw === 'string' ? JSON.parse(raw) : raw
   if (!j || j.ok !== true) {
@@ -151,5 +177,44 @@ export function sbm11Api (loadEngine) {
       }
     }
   }
-  return { openSbm11 }
+  /**
+   * Pack an RDF document into the files of one SBM11 generation, in memory
+   * (the wasm op sbm11PackFiles, formal/lean4/Wasm/Ops/Sbm11Pack.lean;
+   * https://github.com/danbri/factoidal/issues/1009 stage 2). `text` is a
+   * string or UTF-8 bytes; `options.syntax` is turtle, trig, nquads,
+   * ntriples, rdfxml or jsonld; `options.base` the base IRI. Resolves to a
+   * Map from file name to Uint8Array: the files `l4sbm11-pack` writes for the
+   * same quads (data files, `.merkle` sidecars, `manifest.sbm11`), without
+   * `CURRENT`. Open them with `openSbm11(name, { reader: mapReader(files) })`,
+   * or write each under its name into one directory. The engine names every
+   * file and computes every byte (iron rule 7).
+   */
+  async function packSbm11 (text, options = {}) {
+    const syntax = options.syntax ?? options.format
+    if (typeof syntax !== 'string' || syntax === '') {
+      throw new TypeError('packSbm11: options.syntax is required (turtle, trig, nquads, ntriples, rdfxml or jsonld)')
+    }
+    const eng = await loadEngine()
+    const refl = opsReflection(eng)
+    const blobIoOps = Array.isArray(refl && refl.blobIoOps) ? refl.blobIoOps : []
+    if (typeof eng.callBlobIO !== 'function' || !blobIoOps.includes('sbm11PackFiles')) {
+      const e = new Error('packSbm11: this wasm module has no sbm11PackFiles op (it was built before ' +
+        'https://github.com/danbri/factoidal/issues/1009 stage 2)')
+      e.code = 'SBM11_NO_PACK_OP'
+      throw e
+    }
+    const bytes = typeof text === 'string' ? new TextEncoder().encode(text) : new Uint8Array(text)
+    const base = options.base == null ? '' : String(options.base)
+    const files = new Map()
+    let count = 1
+    for (let i = 0; i < count; i++) {
+      const answer = eng.callBlobIO('sbm11PackFiles', [syntax, base, String(i)], bytes)
+      const j = envelope(answer.envelope)
+      count = Number(j.count)
+      files.set(j.name, answer.bytes)
+    }
+    return files
+  }
+
+  return { openSbm11, packSbm11 }
 }

package/lib/version.mjs

@@ -2,4 +2,4 @@
 // needs import attributes, which not every runtime this package targets
 // reads). test/dts-drift.test.js checks that it equals package.json's
 // `version`.
-export const version = '0.15.0';
+export const version = '0.16.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factoidal/core",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "RDF parsing and writing (Turtle, TriG, N-Triples, N-Quads, RDF/XML, JSON-LD), SPARQL 1.1 and 1.2, RDFS and OWL reasoning, SHACL and ShEx validation, CSVW and RML mapping, RDFC-1.0, and SPARQL, LWS and Solid servers, for Node, Deno and browsers.",
   "keywords": [
     "sparql",