@factoidal/core 0.15.0 → 0.17.0

package/bin/pack-host.mjs

@@ -42,11 +42,12 @@
 // route rescues an in-page packer. See the closing section of
 // `docs/designissues/2026-09-03-npm-pack-in-wasm.md`.
 
-import { StoreHostError, listGeneration, readWhole } from '../store-host/index.mjs'
+import { StoreHostError, listGeneration, readWhole, writeNew } from '../store-host/index.mjs'
 import { fileUrlToPath, joinPath } from '../store-host/paths.mjs'
 import { loadEngine } from './engine.mjs'
 import { PackError, packFile, packSupported, verifyGeneration } from './pack.mjs'
 import { StoreOperationError, openStore } from './store.mjs'
+import { sbm11Api } from '../lib/sbm11.mjs'
 
 const isDeno = typeof globalThis.Deno !== 'undefined'
 
@@ -207,6 +208,7 @@ export function isStackOverflow (error) {
  */
 export async function packHere (task, onProgress) {
   const engine = await loadEngine()
+  if (task.kind === 'packSbm11') return await packSbm11Here(engine, task)
   if (!packSupported(engine)) return { notWired: true }
   if (task.kind === 'activate') {
     return { report: activateHere(engine, task) }
@@ -221,6 +223,34 @@ export async function packHere (task, onProgress) {
   return { report }
 }
 
+/**
+ * Pack one document into the files of one SBM11 generation (op
+ * sbm11PackFiles, through lib/sbm11.mjs packSbm11) and write each file
+ * under the name the engine gave it. The document is read whole: the op
+ * takes the whole document, and refuses one above its limit.
+ *
+ * @returns {{notWired: true}|{report: object}}
+ */
+async function packSbm11Here (engine, task) {
+  const { packSbm11 } = sbm11Api(async () => engine)
+  const bytes = readWhole(task.input)
+  let files
+  try {
+    files = await packSbm11(bytes, { syntax: task.syntax, base: task.base })
+  } catch (error) {
+    if (error && error.code === 'SBM11_NO_PACK_OP') return { notWired: true }
+    throw error
+  }
+  const written = []
+  let bytesWritten = 0
+  for (const [name, fileBytes] of files) {
+    writeNew(joinPath(task.output, name), fileBytes)
+    written.push(name)
+    bytesWritten += fileBytes.length
+  }
+  return { report: { bytesRead: bytes.length, written, bytesWritten } }
+}
+
 /**
  * Verify one generation and answer the engine's verdict.
  *

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

@@ -529,14 +529,15 @@ export function canonicalize(
 export function graphs(dataset: Dataset): Array<[name: NamedNode | BlankNode, graph: Dataset]>;
 
 /**
- * RDFC-1.0 canonical form of a single graph -- the graph-scoped
- * sibling of canonicalize(). It returns the canonical N-Quads TEXT, not
- * a digest: hash the string yourself (for example `vcSha256Hex`) when a
- * fixed-length value is needed. Every quad's graph component is dropped
- * before canonicalizing, so isomorphic graphs (including under
- * blank-node relabeling) give the same string regardless of what
- * graph name they were extracted from. Typically called with one
- * entry of graphs()'s output.
+ * The RDFC-1.0 canonical hash of a single graph: the SHA-256 of its
+ * canonical N-Quads document, as 64 lowercase hexadecimal digits (RDF
+ * Dataset Canonicalization 1.0, section 4.4 note 2). The engine computes
+ * the canonical form and the digest. Every quad's graph component is
+ * dropped first, so isomorphic graphs (including under blank-node
+ * relabeling) give the same hash whatever graph name they were extracted
+ * from. Typically called with one entry of graphs()'s output. For the
+ * canonical text, use canonicalize(). Rejects when the input holds an
+ * RDF 1.2 triple term or the section 4.4 call budget is exceeded.
  */
 export function canonicalHash(datasetOrGraph: Dataset): Promise<string>;
 
@@ -701,14 +702,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 +737,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 +762,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 +803,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 +1192,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 +1638,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 = "ebac38a482d0";
 
 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-fa72ba5bc828-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/40439252690",
+  "gitSha": "fa72ba5bc828c1eb75572c3436e9d739f76fdd57",
+  "builtAt": "2026-10-27T03:13:16Z",
   "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": "ebac38a482d03d4a6ce1cf4a59164288628fed6957483dd55180743e7a3daf40",
+  "wasmBytes": 17071472,
   "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) {
@@ -876,9 +884,12 @@ function buildApi(driver) {
   }
 
   /**
-   * RDFC-1.0 canonical N-Quads of one graph: every quad's graph name is
-   * dropped first (op datasetGraphAsDefault with the union of the graphs).
-   * Text, not a digest.
+   * The RDFC-1.0 canonical hash of one graph: the SHA-256, as 64 lowercase
+   * hexadecimal digits, of the canonical N-Quads document (RDF Dataset
+   * Canonicalization 1.0, section 4.4 note 2). Every quad's graph name is
+   * dropped first (op datasetGraphAsDefault with the union of the graphs);
+   * then op datasetCanonicalHash computes the canonical form and the digest
+   * in Lean. canonicalize() answers the canonical text.
    * @param {Dataset} datasetOrGraph
    * @returns {Promise<string>}
    */
@@ -889,10 +900,11 @@ function buildApi(driver) {
     datasetOrGraph.size; // throws the disposed error
     const c = datasetOrGraph._ctx;
     requireEntryFn(c.e, 'datasetGraphAsDefault', 'canonicalHash');
+    requireEntryFn(c.e, 'datasetCanonicalHash', 'canonicalHash');
     const merged = c.wrap(entryResult(c.e.datasetGraphAsDefault(datasetOrGraph.handle,
       JSON.stringify({ type: 'union' })), 'canonicalHash'), {});
     try {
-      return merged.toString('rdfc');
+      return entryResult(c.e.datasetCanonicalHash(merged.handle), 'canonicalHash').hash;
     } finally {
       merged.dispose();
     }
@@ -2140,6 +2152,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 +2189,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 }
 }