@factoidal/core 0.11.0 → 0.12.0

package/bin/factoidal.mjs

@@ -332,7 +332,12 @@ https://www.w3.org/TR/sparql11-service-description/`,
 
 usage: factoidal lws-serve DIR (--issuer IRI | --auth-config FILE | --insecure-no-auth)
                          [--owner WEBID] [--root-acl FILE] [--audience IRI]
-                         [--port N] [--host ADDRESS] [--base IRI]
+                         [--port N] [--host ADDRESS] [--base IRI] [--page-size N]
+                         [--paginate-always] [--moves all|data|off]
+                         [--no-linkset-put] [--unstable-search-results] [--merkle]
+                         [--controller-inbox URL] [--delivery-limit N]
+                         [--delivery-window SECONDS] [--redirects-max N]
+                         [--storage snapshot|files]
 
 Starts a Node HTTP server that answers every request through the engine's
 lwsStep operation.
@@ -344,10 +349,88 @@ start. The engine decides the snapshot format and refuses a snapshot
 path with a dot segment or other traversal form
 (formal/lean4/L4Factoidal/LWS/Snapshot.lean).
 
+With --storage files (off by default) a write costs the same whatever the
+size of the storage: DIR holds one file per resource body (DIR/bodies/),
+a journal of metadata changes (DIR/lws-journal) and a metadata file
+(DIR/lws-files.json) that the journal is folded into from time to time.
+A journal record is valid only when it is complete and its SHA-256
+matches; a torn last record is ignored at start. An existing
+DIR/lws-state.json is migrated at the first start and renamed to
+lws-state.json.migrated. The engine decides every file name and every
+byte (formal/lean4/L4Factoidal/LWS/FileLayout.lean); the storage is still
+held in memory while the server runs
+(docs/designissues/2026-10-22-lws-storage-on-disk.md).
+
+Encryption at rest (off by default): when the environment variable
+FACTOIDAL_LWS_KEY holds a 32-byte key (64 hex digits, or 43 characters of
+base64url), the snapshot is sealed with ChaCha20-Poly1305 (HACL*) under a
+new random nonce for every write, and authenticated when the storage is
+opened. A wrong key, a changed or truncated file, a clear-text file with the
+variable set, or a sealed file without it stops the start with a message.
+It protects the file on disk only (formal/lean4/L4Factoidal/LWS/SnapshotSeal.lean).
+
   --port N        the port to bind; 0 takes an ephemeral one (default 3000)
   --host ADDRESS  the address to bind (default 127.0.0.1)
   --base IRI      the absolute IRI the storage root maps to
                   (default: the bound origin)
+  --page-size N   the engine's container page size (config member pageSize;
+                  default 100, 0 turns pagination off)
+  --paginate-always
+                  present every container listing as paginated, also one
+                  that fits on one page (config member paginateAlways;
+                  default off): rel="first" and rel="last", no rel="next"
+  --moves all|data|off
+                  which resources a client may move by changing their up
+                  link (config member moves; default all): data resources
+                  and containers, data resources only (the MoveResource
+                  capability's appliesTo is [DataResource]), or none (no
+                  MoveResource capability; a change of up answers 409)
+  --no-linkset-put
+                  a linkset resource does not accept PUT (config member
+                  linksetPut false): its Allow leaves PUT out and a PUT
+                  answers 405 Method Not Allowed; PATCH still applies
+  --unstable-search-results
+                  ANTICIPATORY AND UNSTABLE, off by default: a QUERY answer
+                  of the type search names a results resource with
+                  Content-Location (RFC 10008 section 2.3). lws10-index
+                  defines no such resource; this is likely to change.
+                  https://github.com/danbri/factoidal/issues/922
+  --merkle        off by default: keep a SHA-256 digest of every resource
+                  and a Merkle root of every container, and show them: an
+                  RFC 9530 Repr-Digest field on GET of a resource, a
+                  Factoidal-Merkle-Root field and listing member on a
+                  container, and the storage root's digest in the storage
+                  description (roots to the storage controller only under
+                  authorization). Entity tags do not change. The hashes are
+                  rebuilt when the storage is opened, not stored.
+                  https://github.com/danbri/factoidal/issues/919
+  --controller-inbox URL
+                  the storage controller's inbox (config member
+                  controllerInbox; default none): each new access request
+                  is announced there with a Create notification. The LWS
+                  draft names no such inbox; this is a server choice.
+                  https://github.com/danbri/factoidal/issues/920
+  --delivery-limit N
+                  the most webhook deliveries one subscription gets in one
+                  window (config member deliveryLimit; default 10, 0 turns
+                  the limit off); the changes over it wait and go in one
+                  batched notification when the window ends
+                  https://github.com/danbri/factoidal/issues/915
+  --delivery-window SECONDS
+                  the length of that window (config member deliveryWindow;
+                  default 60)
+  --redirects-max N
+                  the most previous identifiers of moved resources kept to
+                  answer 301 Moved Permanently (config member redirectsMax;
+                  default 256)
+                  https://github.com/danbri/factoidal/issues/914
+  --storage snapshot|files
+                  how DIR keeps the storage (config member storage;
+                  default the environment variable FACTOIDAL_LWS_STORAGE,
+                  else snapshot): one snapshot file written whole after
+                  each change, or one file per body with a journal, so a
+                  write costs the same whatever the storage size
+                  https://github.com/danbri/factoidal/issues/918
 
 Authorization (LWS editor's draft, section Authorization; one of the three
 is required):
@@ -365,7 +448,8 @@ is required):
                         that gives this agent Read, Write and Control
   --root-acl FILE       a Turtle root ACL for a new storage instead
   --audience IRI        the aud value tokens must carry (default: the
-                        storage root IRI)
+                        storage IRI, BASE.well-known/lws-storage, which
+                        every lws#storage link names)
 
 Requests carry an access token as "Authorization: Bearer TOKEN" (RFC 6750).
 The engine verifies its JWS signature (ES256, RS256 or EdDSA, with the
@@ -397,6 +481,14 @@ start. The engine decides the snapshot format and refuses a snapshot
 path with a dot segment or other traversal form
 (formal/lean4/L4Factoidal/LWS/Snapshot.lean).
 
+Encryption at rest (off by default): when the environment variable
+FACTOIDAL_LWS_KEY holds a 32-byte key (64 hex digits, or 43 characters of
+base64url), the snapshot is sealed with ChaCha20-Poly1305 (HACL*) under a
+new random nonce for every write, and authenticated when the storage is
+opened. A wrong key, a changed or truncated file, a clear-text file with the
+variable set, or a sealed file without it stops the start with a message.
+It protects the file on disk only (formal/lean4/L4Factoidal/LWS/SnapshotSeal.lean).
+
   --port N        the port to bind; 0 takes an ephemeral one (default 3000)
   --host ADDRESS  the address to bind (default 127.0.0.1)
   --base IRI      the absolute IRI the storage root maps to
@@ -505,7 +597,8 @@ const VALUE_OPTIONS = {
   compact: new Set([]),
   serve: new Set(['port', 'host', 'query-path', 'gsp-path', 'file', 'layout', 'tdb2']),
   'lws-serve': new Set(['port', 'host', 'base', 'issuer', 'auth-config', 'owner', 'root-acl',
-    'audience']),
+    'audience', 'page-size', 'moves', 'controller-inbox', 'delivery-limit', 'delivery-window',
+    'redirects-max', 'storage']),
   'solid-serve': new Set(['port', 'host', 'base', 'owner', 'issuer', 'auth-config']),
   'solid-client': new Set(['body', 'file', 'content-type', 'interpret'])
 }
@@ -1198,6 +1291,20 @@ function servePort (options, fallback) {
   return port
 }
 
+// --page-size N: a CLI number, passed unchanged as the engine config member
+// `pageSize`; what a page holds is decided in L4Factoidal/LWS/Pagination.lean.
+function pageSizeOption (value) {
+  return natOption('page-size', value)
+}
+
+function natOption (flag, value) {
+  const n = Number(value)
+  if (!Number.isInteger(n) || n < 0) {
+    throw new UsageError(`--${flag} must be a non-negative integer, not "${value}"`)
+  }
+  return n
+}
+
 function serveHost (options) {
   if (options.host === undefined) return '127.0.0.1'
   if (typeof options.host !== 'string' || options.host.length === 0) {
@@ -1326,6 +1433,19 @@ async function commandLwsServe (positional, options) {
       port: servePort(options, 3000),
       host: serveHost(options),
       ...(typeof options.base === 'string' ? { baseIri: options.base } : {}),
+      ...(options['page-size'] !== undefined ? { pageSize: pageSizeOption(options['page-size']) } : {}),
+      ...(options['unstable-search-results'] === true ? { searchResults: true } : {}),
+      ...(options.merkle === true ? { merkle: true } : {}),
+      // Passed unread as config members; the engine decides what they mean
+      // and refuses a value it does not know (Wasm/Ops/Lws.lean).
+      ...(options['paginate-always'] === true ? { paginateAlways: true } : {}),
+      ...(typeof options.moves === 'string' ? { moves: options.moves } : {}),
+      ...(options['no-linkset-put'] === true ? { linksetPut: false } : {}),
+      ...(typeof options['controller-inbox'] === 'string' ? { controllerInbox: options['controller-inbox'] } : {}),
+      ...(options['delivery-limit'] !== undefined ? { deliveryLimit: natOption('delivery-limit', options['delivery-limit']) } : {}),
+      ...(options['delivery-window'] !== undefined ? { deliveryWindow: natOption('delivery-window', options['delivery-window']) } : {}),
+      ...(options['redirects-max'] !== undefined ? { redirectsMax: natOption('redirects-max', options['redirects-max']) } : {}),
+      ...(typeof options.storage === 'string' ? { storage: options.storage } : {}),
       ...(insecure ? { insecureNoAuth: true } : { auth }),
       ...(typeof options.owner === 'string' ? { owner: options.owner } : {}),
       ...(typeof options['root-acl'] === 'string'
@@ -1338,6 +1458,14 @@ async function commandLwsServe (positional, options) {
     if (error instanceof LwsHostError && error.unknownOp) {
       return notWired('lws-serve', error.message)
     }
+    // The engine refused to open the storage (a bad configuration, or a
+    // snapshot it could not read or authenticate, issue 921), or the state
+    // file is not JSON: the message is the whole answer.
+    if (error !== null && typeof error === 'object' &&
+        (error.envelope !== undefined || error.stateFile === true)) {
+      err(`factoidal lws-serve: ${error.envelope !== undefined ? error.envelope.error : error.message}`)
+      return EXIT_FAILURE
+    }
     throw error
   }
   if (!quiet) {
@@ -1385,6 +1513,14 @@ async function commandSolidServe (positional, options) {
     if (error instanceof SolidServerHostError && error.unknownOp) {
       return notWired('solid-serve', error.message)
     }
+    // The engine refused to open the storage (a bad configuration, or a
+    // snapshot it could not read or authenticate, issue 921), or the state
+    // file is not JSON: the message is the whole answer.
+    if (error !== null && typeof error === 'object' &&
+        (error.envelope !== undefined || error.stateFile === true)) {
+      err(`factoidal solid-serve: ${error.envelope !== undefined ? error.envelope.error : error.message}`)
+      return EXIT_FAILURE
+    }
     throw error
   }
   if (!quiet) {

package/browser.d.ts

@@ -5,6 +5,8 @@
 // system, so a path string rejects.
 
 export type {
+  FactoidalErrorCode,
+  FactoidalErrorPosition,
   NamedNode, BlankNode, Literal, Variable, DefaultGraph, Quad, Term, DataFactory,
   DataFormat, EntailRegime, Bindings, DataInput, QueryInput, ParseOptions,
   QueryOptions, SerializeOptions, StoreReader, OpenStoreOptions,
@@ -89,9 +91,8 @@ export {
   didKeyResolve,
   capabilities,
   Dataset,
-  DatasetHandle,
   Store,
-  ParseError,
+  FactoidalError,
   dataFactory,
   version,
   engine,

package/browser.js

@@ -153,9 +153,8 @@ export const didKeyResolve = api.didKeyResolve;
 // Types, probes and metadata
 export const capabilities = api.capabilities;
 export const Dataset = api.Dataset;
-export const DatasetHandle = api.DatasetHandle;
 export const Store = api.Store;
-export const ParseError = api.ParseError;
+export const FactoidalError = api.FactoidalError;
 export const dataFactory = api.dataFactory;
 export const version = api.version;
 export const engine = api.engine;

package/fn.js

@@ -252,7 +252,7 @@ function builder() {
   let finished = false;
   return {
     addChunk(chunk) {
-      if (finished) throw new Error('builder: addChunk() called after finish()');
+      if (finished) throw new engineApi.FactoidalError('builder: addChunk() called after finish()', { code: 'op.failed' });
       if (chunk && typeof chunk.termType === 'string') {
         pending.push(chunk); // a single Quad
       } else {
@@ -260,7 +260,7 @@ function builder() {
       }
     },
     finish() {
-      if (finished) throw new Error('builder: finish() already called');
+      if (finished) throw new engineApi.FactoidalError('builder: finish() already called', { code: 'op.failed' });
       finished = true;
       const result = makeFnDataset(pending);
       pending = null; // release; no further mutation is possible anyway
@@ -354,24 +354,20 @@ async function query(ds, sparql, options) {
  * per-graph closure semantics that the underlying query() does not
  * define today.
  */
-// The regime names, their case-insensitive aliases and the x-ikl-* refusal
-// are the engine's tables (op engineTables): no host copy
+// The regime names and their case-insensitive aliases are the engine's tables
+// (op engineTables): no host copy
 // (https://github.com/danbri/factoidal/issues/894 item 5). A name with no
-// alias passes through unchanged and engineApi.query reports it.
-async function regimeOf(regime, who) {
+// alias passes through unchanged and engineApi.query refuses it with the
+// engine's code (regime.refused for x-ikl-*, option.invalid-value otherwise).
+async function regimeOf(regime) {
   const t = await engineApi.engineTables();
   const r = regime == null ? 'none' : String(regime);
-  for (const [prefix, message] of Object.entries(t.refusedRegimePrefixes)) {
-    if (r.toLowerCase().startsWith(prefix)) {
-      throw new TypeError(message.replace('WHO', who).replace('REGIME', r));
-    }
-  }
   return t.entailAliases[r.toLowerCase()] || regime;
 }
 
 async function entail(ds, regime) {
   assertFnDataset(ds, 'entail');
-  const entailRegime = await regimeOf(regime, 'entail');
+  const entailRegime = await regimeOf(regime);
   const rows = await engineApi.query((await engineOf(ds)), 'SELECT ?s ?p ?o WHERE { ?s ?p ?o }',
     { entail: entailRegime });
   return makeFnDataset(

package/index.d.ts

@@ -84,27 +84,85 @@ export interface DataFactory {
 export const dataFactory: DataFactory;
 
 /**
- * A parse failure that carries a position (issue #344): `line`/
- * `column`/`offset` are set when the failing engine call reported one
- * (Turtle, TriG, N-Triples, N-Quads); `undefined` for an RDF/XML or
- * JSON-LD failure, or any non-parse engine error, which stay a plain
- * `Error`. `name` is `'ParseError'`.
+ * The stable error codes. The engine decides the code of every refusal
+ * (formal/lean4/Wasm/Ops/ErrorModel.lean); `engineTables().errorCodes` lists
+ * each with its specification section and summary, and the README table
+ * "Errors" is generated from that list. `host.io` is a failure of
+ * the host (file system, IndexedDB), not of the engine.
  */
-export class ParseError extends Error {
-  readonly name: 'ParseError';
-  /** 1-based line of the error. */
-  readonly line?: number;
-  /** 1-based column of the error, counted in Unicode scalar values. */
-  readonly column?: number;
+export type FactoidalErrorCode =
+  | 'parse.syntax'
+  | 'parse.rdf12-required'
+  | 'term.invalid-iri'
+  | 'term.invalid-langtag'
+  | 'term.invalid'
+  | 'query.syntax'
+  | 'query.failed'
+  | 'update.syntax'
+  | 'update.failed'
+  | 'format.unknown'
+  | 'serialize.unsupported-rdf12'
+  | 'serialize.failed'
+  | 'canon.unsupported-rdf12'
+  | 'canon.failed'
+  | 'owl.unsupported-rdf12'
+  | 'reason.failed'
+  | 'regime.refused'
+  | 'validate.failed'
+  | 'xml.failed'
+  | 'crypto.failed'
+  | 'store.failed'
+  | 'registry.failed'
+  | 'handle.unknown'
+  | 'handle.disposed'
+  | 'option.unknown'
+  | 'option.invalid-value'
+  | 'option.conflict'
+  | 'capacity.exceeded'
+  | 'call.arity'
+  | 'call.arguments'
+  | 'op.unknown'
+  | 'op.failed'
+  | 'host.io';
+
+/** Where in the input a FactoidalError happened. */
+export interface FactoidalErrorPosition {
+  /** 1-based line. */
+  line: number;
+  /** 1-based column, counted in Unicode scalar values. */
+  column: number;
   /**
-   * The position of the error as a UTF-16 code-unit index into the input
-   * JavaScript string: `text.slice(err.offset)` starts at the error. A
-   * character outside the Basic Multilingual Plane (U+10000 and above)
-   * counts 2, as in every JavaScript string index. (The engine reports a
-   * count of Unicode scalar values; the wrapper converts.)
+   * A UTF-16 code-unit index into the input JavaScript string:
+   * `text.slice(err.position.offset)` starts at the error.
    */
-  readonly offset?: number;
+  offset: number;
+  /** The same position as a count of UTF-8 bytes from the start of the input. */
+  byteOffset: number;
+}
+
+/**
+ * The one error class of the package. Every function rejects (or throws)
+ * with it; a `TypeError` is thrown only when an argument has the wrong
+ * JavaScript type. The engine decides `code`, `spec` and `position`.
+ */
+export class FactoidalError extends Error {
+  constructor(message: string, info?: {
+    code?: FactoidalErrorCode; position?: FactoidalErrorPosition | null;
+    spec?: string | null; cause?: unknown; format?: string; formatInferred?: boolean;
+  });
+  readonly name: 'FactoidalError';
+  /** The stable machine code. */
+  readonly code: FactoidalErrorCode;
+  /** Where the input defines a position (a parse, a query, an update), else null. */
+  readonly position: FactoidalErrorPosition | null;
+  /** The URL of the specification section that defines the condition, else null. */
+  readonly spec: string | null;
+  /** The underlying error, when there is one (host.io). */
+  readonly cause?: unknown;
+  /** For a parse failure of text: the syntax it was read as. */
   readonly format?: string;
+  /** For a parse failure of text: true when the syntax was inferred. */
+  readonly formatInferred?: boolean;
 }
 
 /** One recoverable-parse diagnostic from a `{lenient:true}` parse() call. */
@@ -112,7 +170,7 @@ export interface ParseDiagnostic {
   message: string;
   /**
    * The position of the error as a UTF-16 code-unit index into the input
-   * JavaScript string, as ParseError.offset: `text.slice(d.offset)` starts
+   * JavaScript string, as FactoidalError.position.offset: `text.slice(d.offset)` starts
    * at the error.
    */
   offset: number;
@@ -222,8 +280,6 @@ export class Dataset implements Iterable<Quad> {
   [Symbol.dispose](): void;
 }
 
-/** @deprecated The name of Dataset before 0.10.0; removed in 0.11.0. */
-export const DatasetHandle: typeof Dataset;
 
 export type ClosureRegime = 'rdfs' | 'owl-rl' | 'rho-df' | 'rdfs-plus';
 
@@ -302,7 +358,7 @@ export interface ParseOptions {
    * entry per skipped statement. RDF/XML and JSON-LD parse strictly. A
    * document with no error gives the strict result and no diagnostics.
    * Default: false (strict; a syntax error, an undeclared prefix, or an
-   * unresolvable relative IRI rejects the whole parse with a ParseError).
+   * unresolvable relative IRI rejects the whole parse with a FactoidalError).
    */
   lenient?: boolean;
   /**
@@ -323,7 +379,7 @@ export interface QueryOptions extends DatasetQueryOptions {
  * order is sorted (canonical N-Quads order), not document order;
  * anonymous blank-node labels (`_anonN`) DO reflect document order.
  * See README.md's "Blank nodes, labels and statement order". Strict
- * by default (issue #344): a syntax error rejects with a ParseError
+ * by default (issue #344): a syntax error rejects with a FactoidalError
  * (`line`/`column`/`offset` for Turtle/TriG/N-Triples/N-Quads; a
  * message only for RDF/XML and JSON-LD). `options.lenient` recovers
  * instead; see ParseOptions.
@@ -337,7 +393,7 @@ export function parse(text: string, options?: ParseOptions | DataFormat): Promis
  * Concise Bounded Description of each resource named). A `SERVICE <iri>`
  * whose IRI no registerServiceEndpoint() call named answers no
  * solutions even without SILENT
- * (https://github.com/danbri/factoidal/issues/717). `data` may be a DatasetHandle
+ * (https://github.com/danbri/factoidal/issues/717). `data` may be a Dataset
  * from openDataset(), in which case this routes to `data.query()` and
  * `options.entail` must be 'none' or omitted (a handle carries no
  * entailment-closure step).
@@ -447,7 +503,7 @@ export function serialize(
 /**
  * RDFC-1.0 dataset canonicalization: canonical blank-node labels plus
  * sorted canonical N-Quads. Two isomorphic inputs canonicalize to the
- * same string. `data` may be a DatasetHandle, in which case this
+ * same string. `data` may be a Dataset, in which case this
  * routes to `data.canonicalize()` (options are ignored for a handle).
  */
 export function canonicalize(
@@ -1257,7 +1313,7 @@ export function capabilities(): Promise<{
   entailment: boolean;
   /** queryHdt() (op queryHdt) is served. */
   hdt: boolean;
-  /** query()'s `sparql12` and DatasetHandle.query's (queryDataset12, datasetQuery12). */
+  /** query()'s `sparql12` and Dataset.query's (queryDataset12, datasetQuery12). */
   sparql12: boolean;
   /** openStore() and the Store methods (storeOpen, storeHandleQuery). */
   store: boolean;
@@ -1267,7 +1323,7 @@ export function capabilities(): Promise<{
   profile: 'full' | string;
   /** The dispatch ABI version string of the loaded wasm module. */
   abiVersion: string;
-  /** openDataset()/DatasetHandle (datasetOpen/Query/Update/Serialize/Close) are present. */
+  /** openDataset()/Dataset (datasetOpen/Query/Update/Serialize/Close) are present. */
   datasetHandles: boolean;
   /** parse()'s `{lenient:true}` (parseDocument) is present. */
   parseDiagnostics: boolean;
@@ -1401,9 +1457,8 @@ declare const _default: {
   vcCheckRelatedResourceDigests: typeof vcCheckRelatedResourceDigests;
   capabilities: typeof capabilities;
   Dataset: typeof Dataset;
-  DatasetHandle: typeof DatasetHandle;
   Store: typeof Store;
-  ParseError: typeof ParseError;
+  FactoidalError: typeof FactoidalError;
   dataFactory: DataFactory;
   queryRaw: typeof queryRaw;
   version: string;

package/index.mjs

@@ -137,9 +137,8 @@ export const didKeyResolve = api.didKeyResolve;
 // Types, probes and metadata
 export const capabilities = api.capabilities;
 export const Dataset = api.Dataset;
-export const DatasetHandle = api.DatasetHandle;
 export const Store = api.Store;
-export const ParseError = api.ParseError;
+export const FactoidalError = api.FactoidalError;
 export const dataFactory = api.dataFactory;
 export const version = api.version;
 export const engine = api.engine;

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 = "15eb8d770829";
+const WASM_VERSION = "ec99e3524f1a";
 
 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-d83100e6ec03-web",
-  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/39574221615",
-  "gitSha": "d83100e6ec038328a71a245e9fd10fbd768a38a5",
-  "builtAt": "2026-10-21T09:44:37Z",
+  "release": "danbri/factoidal-builds build-d9cc50253669-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/39759947727",
+  "gitSha": "d9cc502536698eaf40ab74f7fb5de194c81f104f",
+  "builtAt": "2026-10-22T10:39:28Z",
   "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": "15eb8d770829f3f07dad4f8eabbbaf4503f55104a1803cb87209d05d093dc642",
-  "wasmBytes": 12362890,
+  "wasmSha256": "ec99e3524f1a78667c2b41801556a9d25d65b01cea7afa60ec14c33523da3978",
+  "wasmBytes": 13212135,
   "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"