@factoidal/core 0.27.0 → 0.28.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.28.0 (2026-10-31)
+
+- The public LWS SBM11 reader rejects resource paths that escape its configured container before calling transport. Default Node HTTP reads refuse redirects. Browser default XHR now rejects caller-supplied headers, including authorization; authenticated browser use requires an explicit trusted, redirect-safe transport. Custom transports remain responsible for redirect and credential policy. WebDAV read-only behavior is unchanged.
+- The Lean HTML parser improvements merged in PR269 now reach the package, including processing instructions, namespace/template handling and public parse-html regressions. This is parser support, not a browser layout engine or a claim of complete HTML conformance.
+- Valid zero-second IETF dates no longer emit panic diagnostics. The targeted native fn-parse-ietf-date set passes 105 cases.
+- Bounded slice and positional consumers of fn:generate evaluate finite prefixes without increasing the generation cap. Native fn-generate improves from 13 pass / 3 fail to 15 pass / 1 fail; the constructed-node identity failure remains visible. All 104 fn-slice cases pass. These targeted native results are not whole-catalog WASM conformance claims.
+
+Native server executables and the SVG graphics experiment have separate release gates; this package version does not claim new executable or SVG compatibility coverage.
+
 ## 0.27.0 (2026-10-30)
 
 - New CLI commands `factoidal xpath4`, `factoidal xquery` and `factoidal xslt4` expose the existing Lean XML operations. They accept explicit local input files, display JSON or the engine's serialized result, and preserve QT4 error codes such as `XPST0003`. See the README for arguments and examples.

package/index.d.ts

@@ -1556,14 +1556,21 @@ export interface Sbm11ReadEvidence {
   bytes: number;
 }
 
-/** A synchronous HTTP GET: `(url, headers) -> answer`. */
+/** A trusted synchronous HTTP GET: `(url, headers) -> answer`.
+ * It must refuse redirects before forwarding scoped headers. */
 export type Sbm11Transport = (url: string, headers: Record<string, string>) =>
   { status: number; header(name: string): string | null; bytes: Uint8Array };
 
 /** A reader of the SBM11 files held as LWS resources under the container
  * `url` (one resource per file, CURRENT a resource too), by HTTP Range GETs
  * when the server answers 206, else by whole GETs kept in memory. Node: the
- * default transport is a fetch in a worker thread; close() stops it. */
+ * default transport is a fetch in a worker thread that refuses redirects;
+ * close() stops it. `url` must be absolute HTTP(S), without userinfo, query
+ * or fragment. File arguments are raw relative paths; invalid paths return
+ * null before transport and appear in errors().
+ * Browser worker default XHR accepts no caller auth/headers; provide an explicit
+ * trusted transport for those. Its final-URL check cannot prevent an already
+ * sent anonymous request or ambient same-origin browser cookies. */
 export function lwsSbm11Reader(url: string, opts?: {
   auth?: string; headers?: Record<string, string>; transport?: Sbm11Transport; timeoutMs?: number
 }): Sbm11Reader & { evidence(): Sbm11ReadEvidence[]; errors(): string[]; close(): void };

package/index.mjs

@@ -107,7 +107,12 @@ export { registerSbm11Source, mapReader };
 export function lwsSbm11Reader(url, opts = {}) {
   if (typeof opts.transport === 'function') return lwsSbm11ReaderWith(url, opts);
   const transport = nodeSyncTransport({ timeoutMs: opts.timeoutMs });
-  return lwsSbm11ReaderWith(url, { ...opts, transport, onClose: () => transport.close() });
+  try {
+    return lwsSbm11ReaderWith(url, { ...opts, transport, onClose: () => transport.close() });
+  } catch (error) {
+    transport.close();
+    throw error;
+  }
 }
 
 // The persisted store

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 = "b2be461959a2";
+const WASM_VERSION = "5ca09ab0343e";
 
 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-a9bd50c3b28b-web",
-  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/41040584515",
-  "gitSha": "a9bd50c3b28b3d42c5071cc8c3e74a5ede8706db",
-  "builtAt": "2026-10-30T11:09:24Z",
+  "release": "danbri/factoidal-builds build-e5057984e388-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/41154673265",
+  "gitSha": "e5057984e388be6534fef19cdbb869b5b5652a17",
+  "builtAt": "2026-10-31T02:40:08Z",
   "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": "b2be461959a2ac90ffe8c010b61e70fa4b12f894c2973365904096f41fa6f6ee",
-  "wasmBytes": 30524277,
+  "wasmSha256": "5ca09ab0343eac5cfea0295461af8c4ea963a8bf083afc6f3aeadf1f92ef4804",
+  "wasmBytes": 30629431,
   "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/sbm11-lws.mjs

@@ -20,7 +20,11 @@
 // mixed). The engine checks every byte it decodes against the manifest's
 // Merkle roots (openSbm11's default `verify: 'merkle'`), so it asks for whole
 // 65,536-byte chunks and the `.merkle` sidecars; this file does no check.
-// Limits: no eviction of the in-memory copies, no retry.
+// Limits: no eviction of the in-memory copies, no retry. Resource paths are
+// confined to the configured container. A custom transport must independently
+// refuse redirects before forwarding headers. Default Node fetch refuses them;
+// default worker XHR accepts no caller headers and checks the final response URL
+// only after sending. XHR may still use ambient same-origin browser cookies.
 //
 // EVIDENCE
 // `evidence()` lists each resource read: { resource, etag, lastModified,
@@ -35,13 +39,41 @@
 // browser worker it is a synchronous XMLHttpRequest. A browser window
 // thread has neither: pass `transport` or run the engine in a worker.
 
+// This reader grants its transport authority only within one HTTP container.
+// A file is a raw relative filename/path, never a URL reference. Reject both
+// literal traversal and encoded structural characters before attaching headers.
 function containerUrl (url) {
-  const s = String(url)
-  return s.endsWith('/') ? s : s + '/'
+  let base
+  try { base = new URL(String(url)) } catch { throw new TypeError('lwsSbm11Reader: expected an absolute HTTP(S) container URL') }
+  if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || /[?#]/.test(base.href)) {
+    throw new TypeError('lwsSbm11Reader: container must be HTTP(S), without userinfo, query or fragment; use opts.auth/headers')
+  }
+  if (!base.pathname.endsWith('/')) base.pathname += '/'
+  return base
 }
 
 function resourceUrl (base, file) {
-  return new URL(String(file).split('/').map(encodeURIComponent).join('/'), base).href
+  if (typeof file !== 'string' || file.length === 0 || file.length > 4096) {
+    throw new TypeError('invalid relative resource path')
+  }
+  let probe = file
+  for (;;) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(probe) || /[\\?#\x00-\x1f\x7f]/.test(probe) ||
+        probe.split('/').some(part => part === '' || part === '.' || part === '..') ||
+        /%(?:2f|5c|3f|23)/i.test(probe)) {
+      throw new TypeError('resource path must remain inside the configured container')
+    }
+    // Decode only for rejection, never for the requested filename. Each changed
+    // pass shortens the string, so nested percent encodings are also bounded.
+    const next = probe.replace(/%([a-f0-9]{2})/gi, (_match, hex) => String.fromCharCode(parseInt(hex, 16)))
+    if (next === probe) break
+    probe = next
+  }
+  const resource = new URL(file.split('/').map(encodeURIComponent).join('/'), base)
+  if (resource.origin !== base.origin || !resource.pathname.startsWith(base.pathname)) {
+    throw new TypeError('resource URL escaped the configured container')
+  }
+  return resource.href
 }
 
 /** A synchronous GET with XMLHttpRequest (a browser worker). */
@@ -51,6 +83,9 @@ export function xhrSyncTransport (url, headers) {
   x.responseType = 'arraybuffer'
   for (const [k, v] of Object.entries(headers)) x.setRequestHeader(k, v)
   x.send()
+  // XHR follows redirects internally. This rejects returned bytes, not the
+  // already-sent request. Caller headers require an explicit trusted transport.
+  if (x.responseURL !== new URL(url).href) throw new Error('LWS reader: redirected XHR resource refused')
   return {
     status: x.status,
     header: (name) => x.getResponseHeader(name),
@@ -73,26 +108,27 @@ function unsatisfiedTotal (value) {
  * 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
+ * @param {string} url absolute HTTP(S), no userinfo/query/fragment; 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 {Function} [opts.transport] trusted synchronous GET; must constrain redirect/header forwarding
  * @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
+ * @param {object} [opts.headers] further request headers; browser use requires explicit trusted transport
  */
 export function lwsSbm11Reader (url, opts = {}) {
   const base = containerUrl(url)
+  const extra = { ...(opts.headers || {}) }
+  if (opts.auth) extra.authorization = String(opts.auth)
   let transport = opts.transport
   if (typeof transport !== 'function') {
     if (typeof XMLHttpRequest === 'function' && typeof document === 'undefined') {
+      if (Object.keys(extra).length > 0) throw new TypeError('lwsSbm11Reader: caller headers require an explicit redirect-safe transport; default XHR cannot constrain forwarding')
       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 = []
@@ -100,7 +136,12 @@ export function lwsSbm11Reader (url, opts = {}) {
   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 }
+      let url
+      try { url = resourceUrl(base, file) } catch (error) {
+        fail(file, error.message)
+        return null
+      }
+      e = { url, etag: null, lastModified: null, total: undefined, whole: null, requests: 0, partial: 0, bytes: 0 }
       files.set(file, e)
     }
     return e
@@ -136,6 +177,7 @@ export function lwsSbm11Reader (url, opts = {}) {
 
   function sizeOf (file) {
     const e = entry(file)
+    if (e === null) return null
     if (e.total !== undefined) return e.total
     const r = get(e, file, 0, 0)
     if (r === null) return null
@@ -161,6 +203,7 @@ export function lwsSbm11Reader (url, opts = {}) {
   return {
     readAt (file, offset, length) {
       const e = entry(file)
+      if (e === null) return null
       if (length === 0) return new Uint8Array(0)
       if (e.whole !== null) {
         return offset + length <= e.whole.length ? e.whole.subarray(offset, offset + length) : null

package/lib/sync-http-node.mjs

@@ -3,7 +3,8 @@
 // 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.
+// receiveMessageOnPort. Redirects are refused before forwarding scoped headers.
+// No RDF or response-header decision is made here.
 //
 // 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
@@ -18,7 +19,7 @@ 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 r = await fetch(req.url, { headers: req.headers, redirect: 'error' })
     const headers = {}
     r.headers.forEach((v, k) => { headers[k] = v })
     out = { status: r.status, headers, bytes: new Uint8Array(await r.arrayBuffer()) }

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factoidal/core",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "EXPERIMENTAL UNREVIEWED CODE: do not run public services on it without careful independent expert review. 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",