@factoidal/core 0.14.0 → 0.16.0

package/lib/nodes.mjs

@@ -14,15 +14,34 @@
 // on a wire is `{ graph, evidence }`, and each node appends one evidence
 // record `{ stage, status, contract, assumptions, checked, artefact }` (plus
 // `unchecked` and `reason` for a step run under run()'s `unchecked` opt-in;
-// the record logic is in evidence.mjs). The result of
-// a run also reports the union of the named assumptions of the nodes it
-// passed: the premise list of the pipeline's soundness statement
-// (Dataflow/EndToEnd.lean) as the user sees it.
+// the record logic is in evidence.mjs).
+//
+// The type check and the assumption union are the engine's (op
+// pipelineCheck, formal/lean4/Wasm/Ops/StageList.lean, computed by
+// pipelineReport of formal/lean4/L4Factoidal/Dataflow/Pipeline.lean): a
+// pipeline is well typed when each stage's output wire is the next stage's
+// input wire or converts to it, and its `assumptions` are the premises of
+// Pipeline.guarantee_sound, the guarantee of any pipeline of components with
+// these signatures. This file does not compute the union. With an engine
+// 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';
-import { refusalFor, makeRecord, summarize, unionAssumptions } from './evidence.mjs';
+import { refusalFor, makeRecord, summarize, unionAssumptions, unionLists } from './evidence.mjs';
 
 /**
  * @param {object} deps the package functions and the engine entry
@@ -30,7 +49,7 @@ import { refusalFor, makeRecord, summarize, unionAssumptions } from './evidence.
  */
 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') {
@@ -81,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) {
@@ -91,6 +118,7 @@ export function buildNodes(deps) {
   };
 
   let stageCache = null;
+  let engine = null; // the entry stages() loaded; node() calls stages(), so pipe() has it
 
   /**
    * The engine's stage list (op stageList), one element per registry entry.
@@ -101,13 +129,17 @@ export function buildNodes(deps) {
       stageCache = (async () => {
         const e = await entry();
         requireEntryFn(e, 'stageList', 'stages');
+        engine = e;
         const r = entryResult(e.stageList(), 'stages');
         return Object.freeze(r.stages.map((s) => Object.freeze({
           ...s,
           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; });
@@ -117,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}`,
@@ -135,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,
     });
   }
 
@@ -161,14 +229,49 @@ export function buildNodes(deps) {
   }
 
   /**
-   * A pipeline: the nodes in order (pipelines are flattened).
-   * `assumptions` is the union of the nodes' named assumptions.
-   * @returns {{nodes: object[], assumptions: string[]}}
+   * The engine's check of the stages of `nodes` in order (op pipelineCheck),
+   * or null when the loaded engine has no such op.
+   */
+  function check(nodes) {
+    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,
+      wireOut: r.wireOut,
+      mismatch: r.mismatch === null ? null : Object.freeze({ ...r.mismatch }),
+      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]),
+        ...(s.outside ? { outside: Object.freeze(s.outside.map((o) => Object.freeze({ ...o }))) } : {}),
+      }))),
+    });
+  }
+
+  /**
+   * A pipeline: the nodes in order (pipelines are flattened). `check` is
+   * the engine's op pipelineCheck on the nodes' stages; `wellTyped` and
+   * `assumptions` (the union of the nodes' named assumptions) are its
+   * fields. Without the op: `check` and `wellTyped` are null and
+   * `assumptions` is the union of the nodes' fields.
+   * @returns {{nodes: object[], assumptions: string[], wellTyped: boolean|null, check: object|null}}
    */
   function pipe(...items) {
     const nodes = nodesOf(items, 'pipe');
     if (nodes.length === 0) throw new TypeError('pipe: no nodes');
-    return Object.freeze({ nodes: Object.freeze(nodes), assumptions: Object.freeze(unionAssumptions(nodes)) });
+    const c = check(nodes);
+    return Object.freeze({
+      nodes: Object.freeze(nodes),
+      assumptions: c ? c.assumptions : Object.freeze(unionAssumptions(nodes)),
+      wellTyped: c ? c.wellTyped : null,
+      check: c,
+    });
   }
 
   const isWire = (v) => v !== null && typeof v === 'object' && !(v instanceof Dataset) &&
@@ -180,9 +283,13 @@ export function buildNodes(deps) {
    * `options.unchecked: true` lets stages that are not `proved` run,
    * `missing` ones too when the package has a runner for them; each such
    * step's record says so (evidence.mjs). Without it, a `missing` stage
-   * refuses before any node runs.
+   * refuses before any node runs, and so does a pipeline that the engine's
+   * check finds not well typed (op pipelineCheck); with it such a pipeline
+   * runs and `proved` is false.
+   * `assumptions`: the assumptions of the records on the input wire, then
+   * the engine's union for this pipeline (op pipelineCheck), no duplicate.
    * @returns {Promise<{graph: any, evidence: object[], assumptions: string[],
-   *   proved: boolean, uncheckedSteps: string[]}>}
+   *   proved: boolean, uncheckedSteps: string[], wellTyped: boolean|null}>}
    */
   async function run(pipeline, input, options) {
     if (options !== undefined && (options === null || typeof options !== 'object')) {
@@ -194,6 +301,14 @@ export function buildNodes(deps) {
       const why = refusalFor(n, unchecked, Object.prototype.hasOwnProperty.call(RUNNERS, n.stage));
       if (why) throw why;
     }
+    const c = check(nodes);
+    if (c && !c.wellTyped && !unchecked) {
+      const m = c.mismatch;
+      throw new FactoidalError(`run: the pipeline is not well typed: stage ${m.at} ` +
+        `(${nodes[m.at].stage}) writes ${m.out}, stage ${m.at + 1} (${nodes[m.at + 1].stage}) ` +
+        `reads ${m.in} (pass { unchecked: true } to run it without a guarantee)`, { code: 'op.failed' });
+    }
+    const prior = isWire(input) ? input.evidence : [];
     let wire = isWire(input) ? { graph: input.graph, evidence: [...input.evidence] }
       : { graph: input, evidence: [] };
     let owned = null; // a Dataset an earlier node of this run made
@@ -208,7 +323,17 @@ export function buildNodes(deps) {
       }
       wire = { graph, evidence: [...wire.evidence, record] };
     }
-    return { graph: wire.graph, evidence: wire.evidence, ...summarize(wire.evidence) };
+    const s = summarize(wire.evidence);
+    if (!c) return { graph: wire.graph, evidence: wire.evidence, ...s, wellTyped: null };
+    return {
+      graph: wire.graph,
+      evidence: wire.evidence,
+      assumptions: prior.length === 0 ? [...c.assumptions]
+        : unionLists([unionAssumptions(prior), c.assumptions]),
+      proved: s.proved && c.wellTyped,
+      uncheckedSteps: s.uncheckedSteps,
+      wellTyped: c.wellTyped,
+    };
   }
 
   return { stages, node, pipe, run };

package/lib/sbm11-lws.mjs

@@ -0,0 +1,200 @@
+// The LWS reader of an SBM11 generation for lib/sbm11.mjs: the files of a
+// generation (or of a collection root with its CURRENT pointer) stored as
+// Linked Web Storage resources, one resource per file, under one container
+// URL (https://github.com/danbri/factoidal/issues/1010 KR3, read part;
+// LWS 1.0: https://w3c.github.io/lws-protocol/lws10-core/).
+//
+// WHAT THIS FILE IS ALLOWED TO DO
+// Move bytes. The engine names every file and checks every length against
+// the manifest (formal/lean4/L4Factoidal/Storage/Sbm11/HostSession.lean,
+// through the storage medium of formal/lean4/L4Factoidal/Storage/Medium.lean).
+// This file maps a file name to a resource URL, makes HTTP GETs, and hands
+// the bytes over. It reads no manifest and no byte of a file.
+//
+// HTTP (RFC 9110 section 14): each read asks for `Range: bytes=a-b`. A
+// partial answer is used only when it is status 206 and its Content-Range is
+// exactly `bytes a-b/N`. Any other successful answer is the whole
+// representation: it is kept in memory and every later read of that file is
+// cut from it, with no further request. A changed entity tag between two
+// reads of one file refuses the read (the bytes of two versions are never
+// mixed). Limits: no Merkle check here (the engine's Verify.none path), no
+// eviction of the in-memory copies, no retry.
+//
+// EVIDENCE
+// `evidence()` lists each resource read: { resource, etag, lastModified,
+// requests, partial, bytes } -- `partial` the number of 206 answers. The
+// store from openSbm11 answers it as `store.evidence`.
+//
+// SYNCHRONOUS TRANSPORT
+// The engine is inside WebAssembly and asks for bytes synchronously, so the
+// reader needs a synchronous GET: `transport(url, headers) -> { status,
+// header(name) -> string | null, bytes: Uint8Array }`. In Node the default
+// is lib/sync-http-node.mjs (fetch in a worker thread, Atomics.wait); in a
+// browser worker it is a synchronous XMLHttpRequest. A browser window
+// thread has neither: pass `transport` or run the engine in a worker.
+
+function containerUrl (url) {
+  const s = String(url)
+  return s.endsWith('/') ? s : s + '/'
+}
+
+function resourceUrl (base, file) {
+  return new URL(String(file).split('/').map(encodeURIComponent).join('/'), base).href
+}
+
+/** A synchronous GET with XMLHttpRequest (a browser worker). */
+export function xhrSyncTransport (url, headers) {
+  const x = new XMLHttpRequest()
+  x.open('GET', url, false)
+  x.responseType = 'arraybuffer'
+  for (const [k, v] of Object.entries(headers)) x.setRequestHeader(k, v)
+  x.send()
+  return {
+    status: x.status,
+    header: (name) => x.getResponseHeader(name),
+    bytes: new Uint8Array(x.response || new ArrayBuffer(0))
+  }
+}
+
+function parseContentRange (value) {
+  const m = /^bytes\s+(\d+)-(\d+)\/(\d+|\*)$/.exec(String(value || '').trim())
+  if (!m) return null
+  return { first: Number(m[1]), last: Number(m[2]), total: m[3] === '*' ? null : Number(m[3]) }
+}
+
+function unsatisfiedTotal (value) {
+  const m = /^bytes\s+\*\/(\d+)$/.exec(String(value || '').trim())
+  return m ? Number(m[1]) : null
+}
+
+/**
+ * A reader ({ readAt, size, evidence, close }) of the SBM11 files held as
+ * LWS resources under the container `url`.
+ *
+ * @param {string} url the container that holds CURRENT and the generation
+ *   (or the generation container itself)
+ * @param {object} [opts]
+ * @param {Function} [opts.transport] the synchronous GET (see above)
+ * @param {string} [opts.auth] a value for the Authorization header, such as
+ *   `Bearer <access token>` (an LWS access token)
+ * @param {object} [opts.headers] further request headers
+ */
+export function lwsSbm11Reader (url, opts = {}) {
+  const base = containerUrl(url)
+  let transport = opts.transport
+  if (typeof transport !== 'function') {
+    if (typeof XMLHttpRequest === 'function' && typeof document === 'undefined') {
+      transport = xhrSyncTransport
+    } else {
+      throw new TypeError('lwsSbm11Reader: no synchronous transport here; pass opts.transport (Node: @factoidal/core gives one)')
+    }
+  }
+  const extra = { ...(opts.headers || {}) }
+  if (opts.auth) extra.authorization = String(opts.auth)
+  // file -> { url, etag, lastModified, total, whole, requests, partial, bytes }
+  const files = new Map()
+  const errors = []
+
+  function entry (file) {
+    let e = files.get(file)
+    if (!e) {
+      e = { url: resourceUrl(base, file), etag: null, lastModified: null, total: undefined, whole: null, requests: 0, partial: 0, bytes: 0 }
+      files.set(file, e)
+    }
+    return e
+  }
+
+  function fail (file, message) {
+    errors.push(`${file}: ${message}`)
+    return null
+  }
+
+  function get (e, file, first, last) {
+    const headers = { ...extra, range: `bytes=${first}-${last}` }
+    let r
+    try {
+      r = transport(e.url, headers)
+    } catch (error) {
+      fail(file, `GET ${e.url}: ${error && error.message ? error.message : error}`)
+      return null
+    }
+    e.requests += 1
+    const tag = r.header('etag')
+    if (r.status >= 200 && r.status < 300) {
+      if (e.etag !== null && tag !== e.etag) {
+        fail(file, `the entity tag changed from ${e.etag} to ${tag}`)
+        return null
+      }
+      e.etag = tag
+      e.lastModified = r.header('last-modified')
+      e.bytes += r.bytes.length
+    }
+    return r
+  }
+
+  function sizeOf (file) {
+    const e = entry(file)
+    if (e.total !== undefined) return e.total
+    const r = get(e, file, 0, 0)
+    if (r === null) return null
+    const cr = parseContentRange(r.header('content-range'))
+    if (r.status === 206 && cr && cr.first === 0 && cr.last === 0 && cr.total !== null && r.bytes.length === 1) {
+      e.partial += 1
+      e.total = cr.total
+    } else if (r.status === 416 && unsatisfiedTotal(r.header('content-range')) !== null) {
+      e.total = unsatisfiedTotal(r.header('content-range'))
+      e.whole = new Uint8Array(0)
+    } else if (r.status === 200) {
+      e.whole = r.bytes
+      e.total = r.bytes.length
+    } else if (r.status === 404 || r.status === 410) {
+      e.total = null
+    } else {
+      fail(file, `GET ${e.url}: status ${r.status}`)
+      return null
+    }
+    return e.total
+  }
+
+  return {
+    readAt (file, offset, length) {
+      const e = entry(file)
+      if (length === 0) return new Uint8Array(0)
+      if (e.whole !== null) {
+        return offset + length <= e.whole.length ? e.whole.subarray(offset, offset + length) : null
+      }
+      const last = offset + length - 1
+      const r = get(e, file, offset, last)
+      if (r === null) return null
+      const cr = parseContentRange(r.header('content-range'))
+      if (r.status === 206 && cr && cr.first === offset && cr.last === last && r.bytes.length === length) {
+        e.partial += 1
+        return r.bytes
+      }
+      if (r.status === 200) {
+        e.whole = r.bytes
+        e.total = r.bytes.length
+        return offset + length <= r.bytes.length ? r.bytes.subarray(offset, offset + length) : null
+      }
+      return fail(file, `GET ${e.url} bytes ${offset}-${last}: status ${r.status}`)
+    },
+    size (file) {
+      return sizeOf(file)
+    },
+    /** Each resource read: { resource, etag, lastModified, requests, partial, bytes }. */
+    evidence () {
+      const out = []
+      for (const e of files.values()) {
+        if (e.requests === 0 || e.etag === null) continue
+        out.push({ resource: e.url, etag: e.etag, lastModified: e.lastModified, requests: e.requests, partial: e.partial, bytes: e.bytes })
+      }
+      return out
+    },
+    /** The transport failures, as text (a failed read reaches the engine as no bytes). */
+    errors () { return errors.slice() },
+    close () {
+      files.clear()
+      if (typeof opts.onClose === 'function') opts.onClose()
+    }
+  }
+}

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) {
@@ -98,8 +124,15 @@ export function sbm11Api (loadEngine) {
     const opened = envelope(eng.call('sbm11Open', [String(source)]))
     const handle = opened.handle
     let open = true
+    const reader = options.reader || readers.get(String(source))
     return {
       handle,
+      /** The resources the reader read (`lwsSbm11Reader`): `[{ resource,
+       *  etag, lastModified, requests, partial, bytes }]`; undefined for a
+       *  reader that records none. */
+      get evidence () {
+        return reader && typeof reader.evidence === 'function' ? reader.evidence() : undefined
+      },
       generation: opened.generation,
       terms: Number(opened.terms),
       query (sparql, qopts = {}) {
@@ -144,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/sync-http-node.mjs

@@ -0,0 +1,71 @@
+// A synchronous HTTP GET for Node, for the readers of lib/sbm11.mjs that read
+// over HTTP (lib/sbm11-lws.mjs; https://github.com/danbri/factoidal/issues/1010).
+// The engine is inside WebAssembly and asks for bytes synchronously; Node's
+// fetch is asynchronous. A worker thread makes the fetch; this thread waits
+// on a shared Int32Array (Atomics.wait) and takes the answer with
+// receiveMessageOnPort. Pure I/O: no header is read here, no status judged.
+//
+// The thread that calls the transport is blocked until the answer comes, so
+// the server must not run on that thread (start it in another process or
+// worker).
+
+import { Worker, MessageChannel, receiveMessageOnPort } from 'node:worker_threads'
+
+const WORKER = `
+const { workerData } = require('node:worker_threads')
+const { port, signal } = workerData
+const flag = new Int32Array(signal)
+port.on('message', async (req) => {
+  let out
+  try {
+    const r = await fetch(req.url, { headers: req.headers, redirect: 'follow' })
+    const headers = {}
+    r.headers.forEach((v, k) => { headers[k] = v })
+    out = { status: r.status, headers, bytes: new Uint8Array(await r.arrayBuffer()) }
+  } catch (e) {
+    out = { error: String(e && e.message ? e.message : e) }
+  }
+  port.postMessage(out)
+  Atomics.store(flag, 0, 1)
+  Atomics.notify(flag, 0)
+})
+`
+
+/**
+ * A synchronous transport `(url, headers) -> { status, header(name), bytes }`
+ * with a `close()` that stops its worker.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.timeoutMs] the most one request may take (default 60000)
+ */
+export function nodeSyncTransport (opts = {}) {
+  const timeoutMs = typeof opts.timeoutMs === 'number' ? opts.timeoutMs : 60000
+  const signal = new SharedArrayBuffer(4)
+  const flag = new Int32Array(signal)
+  const { port1, port2 } = new MessageChannel()
+  const worker = new Worker(WORKER, { eval: true, workerData: { port: port2, signal }, transferList: [port2] })
+  worker.unref()
+  port1.unref()
+  let closed = false
+  function transport (url, headers) {
+    if (closed) throw new Error('the transport is closed')
+    Atomics.store(flag, 0, 0)
+    port1.postMessage({ url: String(url), headers: { ...headers } })
+    if (Atomics.wait(flag, 0, 0, timeoutMs) === 'timed-out') {
+      throw new Error(`GET ${url}: no answer in ${timeoutMs} ms`)
+    }
+    const got = receiveMessageOnPort(port1)
+    if (!got) throw new Error(`GET ${url}: no answer from the transport worker`)
+    const m = got.message
+    if (m.error) throw new Error(m.error)
+    const h = m.headers
+    return { status: m.status, header: (name) => (Object.hasOwn(h, name.toLowerCase()) ? h[name.toLowerCase()] : null), bytes: m.bytes }
+  }
+  transport.close = () => {
+    if (closed) return
+    closed = true
+    port1.close()
+    worker.terminate()
+  }
+  return transport
+}

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.14.0';
+export const version = '0.16.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factoidal/core",
-  "version": "0.14.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",