@factoidal/core 0.31.1 → 0.33.0

package/index.d.ts

@@ -240,7 +240,7 @@ export type WriteFormat =
   | 'rdfxml' | 'rdf-xml' | 'rdf' | 'jsonld' | 'json-ld' | 'rdfc' | 'canonical';
 
 /** Results formats of query() with `output`. */
-export type ResultsFormat = 'json' | 'xml' | 'csv' | 'tsv' | 'table' | 'ntriples';
+export type ResultsFormat = 'json' | 'xml' | 'xml-report' | 'csv' | 'tsv' | 'table' | 'ntriples';
 
 /** One row of formats(). */
 export interface FormatCapability {
@@ -1570,10 +1570,14 @@ export type Sbm11Transport = (url: string, headers: Record<string, string>) =>
  * 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. */
+ * sent anonymous request or ambient same-origin browser cookies.
+ * Asynchronous: the engine's op containerPath (Lean, L4Factoidal.LWS.ContainerPath)
+ * decides the container URL and every resource URL. */
 export function lwsSbm11Reader(url: string, opts?: {
-  auth?: string; headers?: Record<string, string>; transport?: Sbm11Transport; timeoutMs?: number
-}): Sbm11Reader & { evidence(): Sbm11ReadEvidence[]; errors(): string[]; close(): void };
+  auth?: string; headers?: Record<string, string>; transport?: Sbm11Transport; timeoutMs?: number;
+  /** a loaded engine handle (default: loadEngine()); its op containerPath decides every URL */
+  engine?: object
+}): Promise<Sbm11Reader & { evidence(): Sbm11ReadEvidence[]; errors(): string[]; close(): void }>;
 
 /** One query against a store: open with the query's plan, query, close. */
 export function queryStore(
@@ -2260,13 +2264,22 @@ export interface SparqlResultsJson {
   boolean?: boolean;
 }
 
+/** The exact serialized result is checked by the Lean XML parser. This is
+ * parser admission, not a proof of SPARQL serialization fidelity or XSLT success.
+ * Invalid RDF/XML characters are refused, never removed or replaced.
+ */
+export type SparqlXmlReport =
+  | { kind: 'xml'; xml: string }
+  | { kind: 'diagnostic'; code: 'XML_ADMISSION_REFUSED'; message: string };
+
 export type OutputFormat =
-  | 'json' | 'csv' | 'tsv' | 'xml' | 'table' | 'ntriples';
+  | 'json' | 'csv' | 'tsv' | 'xml' | 'xml-report' | 'table' | 'ntriples';
 
 /**
  * One call, serialised answer: parse `dataString`, close the default
  * graph under `entail`, run the query. Resolves to parsed SPARQL Results
- * JSON when output is 'json' (default), the text otherwise. 'csv', 'tsv'
+ * JSON when output is 'json' (default), an XML/diagnostic object for
+ * 'xml-report', and text otherwise. 'csv', 'tsv'
  * and 'xml' are the W3C SPARQL results formats (CSV and TSV have no ASK
  * encoding, so an ASK with those rejects); 'table' and 'ntriples' are
  * display formats. A CONSTRUCT or DESCRIBE answer is a graph and takes
@@ -2280,7 +2293,7 @@ export function queryRaw(
     entail?: EntailRegime;
     output?: OutputFormat;
   }
-): Promise<SparqlResultsJson | string>;
+): Promise<SparqlResultsJson | SparqlXmlReport | string>;
 
 /** Package version string, e.g. '0.9.0'. */
 export const version: string;

package/index.mjs

@@ -103,12 +103,15 @@ 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
 // synchronous transport is a fetch in a worker thread (lib/sync-http-node.mjs),
-// stopped by the reader's close().
-export function lwsSbm11Reader(url, opts = {}) {
-  if (typeof opts.transport === 'function') return lwsSbm11ReaderWith(url, opts);
+// stopped by the reader's close(). Asynchronous: it loads the engine, whose
+// op containerPath decides the container URL and every resource URL
+// (formal/lean4/L4Factoidal/LWS/ContainerPath.lean).
+export async function lwsSbm11Reader(url, opts = {}) {
+  const engine = opts.engine ?? await loadEngine();
+  if (typeof opts.transport === 'function') return lwsSbm11ReaderWith(url, { ...opts, engine });
   const transport = nodeSyncTransport({ timeoutMs: opts.timeoutMs });
   try {
-    return lwsSbm11ReaderWith(url, { ...opts, transport, onClose: () => transport.close() });
+    return lwsSbm11ReaderWith(url, { ...opts, engine, transport, onClose: () => transport.close() });
   } catch (error) {
     transport.close();
     throw error;

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 = "745308558206";
+const WASM_VERSION = "7f617da4ecbe";
 
 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-72a8fcf2e2a4-web",
-  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/42071487615",
-  "gitSha": "72a8fcf2e2a4bd88ce730f2420fcbc8a094ee0ce",
-  "builtAt": "2026-11-05T18:45:52Z",
+  "release": "danbri/factoidal-builds build-31be9833264a-web",
+  "releaseRun": "https://github.com/danbri/factoidal-builds/actions/runs/42304532396",
+  "gitSha": "31be9833264a2289526a8c9fcc1d6b67610cf746",
+  "builtAt": "2026-11-06T23:08:01Z",
   "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": "7453085582064ea77fd61dedcaeab0bc9cb94a234aa2484a1cddd7beb9ac3342",
-  "wasmBytes": 31370655,
+  "wasmSha256": "7f617da4ecbe7352b94f361802e12bb785f401aafbf78f92b6031c8e920011f2",
+  "wasmBytes": 32611669,
   "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

@@ -693,7 +693,7 @@ function buildApi(driver) {
       }
       const r = await withExtensionRounds(() => entryResult(e.datasetQueryRaw(ds.handle, sparql,
         JSON.stringify({ entail, output })), 'query', sparql));
-      return output === 'json' && !graphForm ? JSON.parse(r.text) : r.text;
+      return (output === 'json' || output === 'xml-report') && !graphForm ? JSON.parse(r.text) : r.text;
     }
     const fn = sparql12 ? e.datasetQuery12 : e.datasetQuery;
     if (typeof fn !== 'function') {
@@ -2487,7 +2487,9 @@ function buildApi(driver) {
    * One call, serialised answer (op queryRaw): parse `dataString`, close
    * the default graph under `entail`, run the query, and write the answer
    * in `output`: 'json' (default; parsed SPARQL results JSON), or 'csv',
-   * 'tsv', 'xml', 'table', 'ntriples' (text). A CONSTRUCT or DESCRIBE
+   * 'tsv', 'xml', 'table', 'ntriples' (text), or 'xml-report' (a checked
+   * XML/diagnostic object from Lean). Ordinary 'xml' rejects an XML
+   * admission failure; 'xml-report' returns it as data. A CONSTRUCT or DESCRIBE
    * answer is a graph: 'ntriples' or 'table' only.
    * @param {string} dataString
    * @param {string} queryString
@@ -2511,7 +2513,7 @@ function buildApi(driver) {
     const r = entryResult(e.queryRaw(dataString, queryString,
       JSON.stringify({ dataFormat: tables.rawDataFormats[dataFormat], entail, output })),
     'queryRaw', queryString);
-    return output === 'json' ? JSON.parse(r.text) : r.text;
+    return output === 'json' || output === 'xml-report' ? JSON.parse(r.text) : r.text;
   }
 
   // ---------------------------------------------------------------

package/lib/sbm11-lws.mjs

@@ -40,40 +40,23 @@
 // 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) {
-  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')
+// A file is a raw relative filename/path, never a URL reference. The engine
+// decides the container URL and every resource URL (op containerPath,
+// formal/lean4/L4Factoidal/LWS/ContainerPath.lean: containerOf, resourceIn,
+// theorem resourceIn_under) before any header is attached; this file only
+// turns a refusal into a TypeError.
+function containerUrl (engine, url) {
+  const r = engine.call('containerPath', [JSON.stringify({ kind: 'container', url: String(url) })])
+  if (!r.allowed) {
+    throw new TypeError(`lwsSbm11Reader: ${r.reason}; the container must be an absolute HTTP(S) URL without userinfo, query or fragment (use opts.auth/headers)`)
   }
-  if (!base.pathname.endsWith('/')) base.pathname += '/'
-  return base
+  return r.url
 }
 
-function resourceUrl (base, file) {
-  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
+function resourceUrl (engine, base, file) {
+  const r = engine.call('containerPath', [JSON.stringify({ kind: 'resource', container: base, path: file })])
+  if (!r.allowed) throw new TypeError(`resource path must remain inside the configured container: ${r.reason}`)
+  return r.url
 }
 
 /** A synchronous GET with XMLHttpRequest (a browser worker). */
@@ -85,7 +68,8 @@ export function xhrSyncTransport (url, headers) {
   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')
+  // `url` is the engine's serialization, so any other response URL is a redirect.
+  if (x.responseURL !== url) throw new Error('LWS reader: redirected XHR resource refused')
   return {
     status: x.status,
     header: (name) => x.getResponseHeader(name),
@@ -110,14 +94,20 @@ function unsatisfiedTotal (value) {
  *
  * @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 {object} opts
+ * @param {object} opts.engine a loaded engine handle (`call(op, args)`); its op
+ *   containerPath decides the container URL and every resource URL
  * @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; browser use requires explicit trusted transport
  */
 export function lwsSbm11Reader (url, opts = {}) {
-  const base = containerUrl(url)
+  const engine = opts.engine
+  if (!engine || typeof engine.call !== 'function') {
+    throw new TypeError('lwsSbm11Reader: opts.engine (a loaded engine handle) decides the resource URLs')
+  }
+  const base = containerUrl(engine, url)
   const extra = { ...(opts.headers || {}) }
   if (opts.auth) extra.authorization = String(opts.auth)
   let transport = opts.transport
@@ -137,7 +127,7 @@ export function lwsSbm11Reader (url, opts = {}) {
     let e = files.get(file)
     if (!e) {
       let url
-      try { url = resourceUrl(base, file) } catch (error) {
+      try { url = resourceUrl(engine, base, file) } catch (error) {
         fail(file, error.message)
         return null
       }

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

package/lws/server.mjs

@@ -24,6 +24,16 @@
 //   lwsFetched [handle, documentJson] -> { ok, fetch? | installed? | refused? }
 //   lwsDelivered [handle, reportJson] -> { ok, changed, retry? }
 //   lwsFlush [handle, { now? }]       -> { ok, changed, deliveries?, wake? }
+//   lwsEgress [handle, { url, addresses }] -> { ok, host, address } | { ok, refused }
+//
+// REQUESTS TO PRIVATE ADDRESSES (https://github.com/danbri/factoidal/issues/1126)
+// Just before each delivery this host resolves the name the delivery names
+// (`resolve`, every address), passes the addresses to `lwsEgress`, and
+// connects to the address the answer names, with no second resolution
+// (`postTo`). A refused delivery is not made; it is reported to
+// `lwsDelivered` with `refused: true`. Which addresses are refused (the
+// IANA special-purpose ranges) and the opt-in `allowPrivateFetch` are
+// decided by `L4Factoidal/Net/Egress.lean` and `Notifications.egressOf`.
 //
 // RATE LIMIT AND INBOX CHECK (https://github.com/danbri/factoidal/issues/915)
 // An answer may carry `wake: SECONDS`: deliveries wait for a rate-limit
@@ -87,7 +97,7 @@ import { loadEngine } from '../bin/engine.mjs'
 import { readSnapshot, persistIfChanged, storageKeyText, storageModeText, loadFiles, persistFilesIfChanged, readStepBodies, acquireDirLock, atRestNotice } from './persist.mjs'
 
 /** The ops this host needs from the engine. */
-export const LWS_OPS = ['lwsOpen', 'lwsStep', 'lwsClose', 'lwsSnapshot', 'lwsFetched', 'lwsDelivered',
+export const LWS_OPS = ['lwsOpen', 'lwsStep', 'lwsClose', 'lwsSnapshot', 'lwsFetched', 'lwsDelivered', 'lwsEgress',
   'lwsLoad', 'lwsPersist', 'lwsRead', 'lwsDirLock', 'lwsAtRestNotice']
 
 /** How long this host waits for the answer to one delivery request before
@@ -128,6 +138,59 @@ async function resolveHost (host) {
   }
 }
 
+/** The most response bytes this host reads from an inbox; the rest is
+ *  dropped (the engine reads only the status). */
+const MAX_DELIVERY_ANSWER_BYTES = 65536
+
+/**
+ * POST one delivery to the address the engine chose (`lwsEgress`). Pure
+ * I/O: the connection goes to `address` only (the lookup answers it, so the
+ * name is not resolved again), TLS still checks the certificate against the
+ * URL's host name, redirects are not followed. The status, or 0 when no
+ * answer came in time.
+ */
+async function postTo (url, address, headers, body) {
+  let target
+  try {
+    target = new URL(url)
+  } catch (_error) {
+    return 0
+  }
+  const module = target.protocol === 'https:' ? await import('node:https') : await import('node:http')
+  const family = address.indexOf(':') >= 0 ? 6 : 4
+  const fields = {}
+  for (const pair of Array.isArray(headers) ? headers : []) {
+    if (Array.isArray(pair) && pair.length === 2) fields[String(pair[0])] = String(pair[1])
+  }
+  const bytes = Buffer.from(typeof body === 'string' ? body : '', 'utf8')
+  fields['content-length'] = String(bytes.length)
+  return new Promise((done) => {
+    let finished = false
+    const finish = (status) => { if (!finished) { finished = true; done(status) } }
+    const request = module.request(target, {
+      method: 'POST',
+      headers: fields,
+      lookup: (_host, options, callback) => {
+        if (options && options.all) callback(null, [{ address, family }])
+        else callback(null, address, family)
+      },
+      timeout: DELIVERY_TIMEOUT_MS
+    }, (response) => {
+      let size = 0
+      response.on('data', (chunk) => {
+        size += chunk.length
+        if (size > MAX_DELIVERY_ANSWER_BYTES) response.destroy()
+      })
+      response.on('end', () => finish(response.statusCode))
+      response.on('close', () => finish(response.statusCode))
+      response.on('error', () => finish(response.statusCode))
+    })
+    request.on('timeout', () => request.destroy(new Error('timeout')))
+    request.on('error', () => finish(0))
+    request.end(bytes)
+  })
+}
+
 /** The addresses of this machine's network interfaces. Pure I/O. */
 async function interfaceAddresses () {
   try {
@@ -323,6 +386,11 @@ export async function openLwsStorage (options = {}) {
   // engine checks and decides.
   if (typeof options.deliveryLimit === 'number') config.deliveryLimit = options.deliveryLimit
   if (typeof options.deliveryWindow === 'number') config.deliveryWindow = options.deliveryWindow
+  // The limit per destination and the opt-in for private and other
+  // special-purpose delivery targets (issue 1126): passed unread; the
+  // engine decides (L4Factoidal/Net/Egress.lean, Notifications.admitDest).
+  if (typeof options.deliveryDestLimit === 'number') config.deliveryDestLimit = options.deliveryDestLimit
+  if (options.allowPrivateFetch === true) config.allowPrivateFetch = true
   if (typeof options.redirectsMax === 'number') config.redirectsMax = options.redirectsMax
   if (typeof options.controllerInbox === 'string') config.controllerInbox = options.controllerInbox
   // CORS (https://github.com/danbri/factoidal/issues/923): `cors` is false or
@@ -440,22 +508,22 @@ export async function openLwsStorage (options = {}) {
   function deliver (delivery) {
     const job = (async () => {
       let status = 0
-      try {
-        const answer = await fetch(delivery.url, {
-          method: 'POST',
-          headers: Array.isArray(delivery.headers) ? delivery.headers : [],
-          body: delivery.body,
-          redirect: 'manual',
-          signal: AbortSignal.timeout(DELIVERY_TIMEOUT_MS)
-        })
-        status = answer.status
-        await answer.arrayBuffer()
-      } catch (_error) {
-        status = 0
+      // Resolve now, let the engine choose the address (issue 1126), and
+      // connect to that address only.
+      const addresses = typeof delivery.resolve === 'string' ? await resolveHost(delivery.resolve) : []
+      if (closed) return
+      const decided = engine.call('lwsEgress', [handle, JSON.stringify({ url: delivery.url, addresses })])
+      const refused = decided !== null && typeof decided === 'object' && typeof decided.refused === 'string'
+        ? decided.refused
+        : null
+      if (refused !== null) {
+        console.error(`lws-serve: delivery to ${delivery.url} not made: ${refused}`)
+      } else {
+        status = await postTo(delivery.url, String(decided.address), delivery.headers, delivery.body)
       }
       if (closed) return
       const told = engine.call('lwsDelivered', [handle, JSON.stringify({
-        id: delivery.id, status, ...clockNow()
+        id: delivery.id, status, ...(refused !== null ? { refused: true } : {}), ...clockNow()
       })])
       persist(told)
       const retry = told !== null && typeof told === 'object' ? told.retry : null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factoidal/core",
-  "version": "0.31.1",
+  "version": "0.33.0",
   "description": "EXPERIMENTAL UNDER-REVIEWED 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",
@@ -35,7 +35,10 @@
   "browser": "./browser.js",
   "types": "./index.d.ts",
   "bin": {
-    "factoidal": "./bin/factoidal.mjs"
+    "factoidal": "./bin/factoidal.mjs",
+    "foafnaut": "./bin/foafnaut.mjs",
+    "foafnaut-latest": "./bin/foafnaut-latest.mjs",
+    "foafnaut-bleedingedge": "./bin/foafnaut-bleedingedge.mjs"
   },
   "exports": {
     ".": {

package/webdav/server.mjs

@@ -186,6 +186,13 @@ export async function openWebdav (options = {}) {
   }
   // The guest user (issue 1147), passed unread; the engine checks it.
   if (typeof options.guest === 'string') login.guest = options.guest
+  // HTTP over XMPP (issue 1125): the transport, the account and, when the
+  // operator gave one, the XMPP server's address; the engine decides.
+  if (options.transport === 'xmpp') {
+    login.transport = 'xmpp'
+    if (typeof options.jid === 'string') login.jid = options.jid
+    if (typeof options.host !== 'string') delete login.host
+  }
   const config = { listing, entropy: randomBase64(32), now: nowSeconds(), login }
   // The Host and Origin guard of the HTTP listener (issue 1124): the bound
   // address and the operator's names and origins, passed unread
@@ -257,6 +264,9 @@ export async function openWebdav (options = {}) {
       randomBase64: randomBase64(16),
       remoteAddress: typeof request.remoteAddress === 'string' ? request.remoteAddress : ''
     }
+    // Over XMPP: the requester the XMPP client handle named (the sender's
+    // bare JID), passed unread (https://github.com/danbri/factoidal/issues/1128).
+    if (request.requester !== undefined && request.requester !== null) record.requester = request.requester
     let got = blobCall(engine, 'webdavStep', [handle, JSON.stringify(record)], request.body || new Uint8Array(0))
     for (let hop = 0; hop < MAX_HOPS; hop += 1) {
       const env = got.envelope
@@ -294,6 +304,8 @@ export async function openWebdav (options = {}) {
     engine,
     mounts: ready.mounts || [],
     warnings: ready.warnings || [],
+    /** The engine's `ready.login`: a users file is loaded. */
+    login: ready.login === true,
     /** The start notices of the local mounts (a stale lock taken over,
      *  encryption at rest on or off), for standard error. */
     storageNotices,

package/xmpp/README.md

@@ -66,6 +66,7 @@ mkdir -p state && printf 'juliet:r0m30\nromeo:juli3t\n' > state/accounts
 npx factoidal xmpp-serve state --domain localhost            # plaintext on 5222
 npx factoidal xmpp-serve state --cert fullchain.pem --key privkey.pem   # XEP-0368 direct TLS on 5223
 npx factoidal xmpp-serve state --cert fullchain.pem --key privkey.pem --starttls   # STARTTLS required on 5222
+npx factoidal xmpp-serve state --cert fullchain.pem --key privkey.pem --starttls --tls-port 5223   # both, one server
 ```
 
 Without `--cert` and `--key` the listener has no TLS and offers PLAIN, so
@@ -99,7 +100,8 @@ process per connection behind socat) serves; the wasm session ops are
 | `xmppClose` | `[server]` | `{ ok, sessions }` |
 
 The state directory is laid out as the native carrier's, so the two
-hosts can share one: `DIR/accounts` (one `user:password` per line),
+hosts can share one: `DIR/accounts` (one `user:password` per line, or a line with no
+password from `factoidal xmpp-serve --verifier NAME`, for SCRAM only),
 `DIR/roster/<bare jid>.tsv` (persisted on every `rostersSaved`, loaded
 on start), and `DIR/spool/<bare jid>/<file>` — a stanza written there
 by any process is delivered to that account's bound session and
@@ -129,8 +131,9 @@ RFC 6120 section 5 STARTTLS with `startTls: true` (op `xmppSessionTlsUp`;
 the engine decides, the host does the handshake; see the theorems in
 `formal/lean4/L4Factoidal/XMPP/Server.lean`).
 Not: server-to-server federation, MUC/MIX/GC3 rooms, PRECIS.
-Known limitation shared with the native harness: one SCRAM salt per
-server (`saltB64` in the config), not one per account.
+Each name has its own SCRAM salt, from a seed the host gives the engine
+(`saltSeed`; derived from the state key when there is one). The native
+harness and a fixed `saltB64` keep one salt for all.
 
 The shared engine currently reduces routed destinations to bare JIDs and
 the Node host delivers to every bound resource. It does not implement full
@@ -191,3 +194,27 @@ node --test test/xmpp.test.mjs
 Skips wholesale when the Lean wasm assets aren't resolvable, and skips
 per-op when the resolved bundle predates a given op (see
 `xmppOpsAvailable`) — the same pattern `test/l4-core.test.js` uses.
+
+## Transport limits
+
+The host closes a socket when a limit is reached. These are limits on bytes and time; every protocol decision stays in Lean.
+
+| Option | CLI | Default | Limit |
+|---|---|---|---|
+| `maxConnections` | `--max-connections N` | 1024 | Open connections of all kinds |
+| `loginTimeoutMs` | `--login-timeout SECONDS` | 30 s | Time to bind a resource |
+| `maxQueuedBytes` | | 8 MiB | Bytes waiting for a client that is not reading |
+| `maxBuffered` | | 1 MiB | Bytes of an unfinished unit |
+
+There is no connection limit per address: behind a proxy, every client has the same one.
+
+## Limits the engine applies
+
+| Option | CLI | Default | Limit |
+|---|---|---|---|
+| `heldLimits.perAccount`, `.perAccountBytes` | | 256 stanzas, 4 MiB | Held for one offline account |
+| `heldLimits.total`, `.totalBytes` | | 10,000 stanzas, 64 MiB | Held on the server |
+| `heldLimits.senderPerWindow`, `.senderWindow` | | 60 in 60 s | Stanzas one account may have held; roster writes of one account |
+| `addressLimit: false` | `--no-address-limit` | on | Failed logins per client address (5 in 60 s, 20 in an hour). Turn it off behind a proxy, where every client has one address |
+
+Fixed in the engine: 5 failed logins in 60 s per account name, 3 failed attempts on a stream, 1,000 items in a roster, 64 levels and 8,192 elements in a stanza, and room nicks of at most 64 bytes.

package/xmpp/client.mjs

@@ -196,7 +196,9 @@ async function openStream (engine, config, options, onFeed, onClosed) {
  * @param {string} [options.resource]
  * @param {object[]} [options.mounts] the WebDAV handle's mounts, passed unread (the engine refuses writable local mounts without the opt-in)
  * @param {boolean} [options.dangerouslyAllowWritableWithoutLogin]
- * @param {Function} options.step `async ({method, target, headers, body}) => ({status, headers, body})`
+ * @param {boolean} [options.login] the WebDAV handle has a users file (its `ready.login`, passed unread)
+ * @param {number} [options.tickMs] how often the clock is given to the engine (default 1000)
+ * @param {Function} options.step `async ({method, target, headers, body, requester}) => ({status, headers, body})`
  * @param {object} [options.engine]
  * @param {Function} [options.onError]
  * @param {number} [options.maxBuffered] residual bytes the engine may hold before the socket is closed (default 16 MiB)
@@ -211,6 +213,7 @@ export async function connectHttpTarget (options = {}) {
   config.allow = Array.isArray(options.allow) ? options.allow : []
   if (Array.isArray(options.mounts)) config.mounts = options.mounts
   if (options.dangerouslyAllowWritableWithoutLogin === true) config.dangerouslyAllowWritableWithoutLogin = true
+  if (options.login === true) config.login = true
 
   let stream = null
   /** One request the engine named: carried to `step`, answered. */
@@ -221,7 +224,10 @@ export async function connectHttpTarget (options = {}) {
         method: request.method,
         target: request.target,
         headers: request.headers || [],
-        body: new Uint8Array(Buffer.from(request.bodyBase64 || '', 'base64'))
+        body: new Uint8Array(Buffer.from(request.bodyBase64 || '', 'base64')),
+        // The sender's bare JID as the engine named it (issue 1128),
+        // passed unread to the WebDAV handle's login.
+        requester: request.requester
       })
       answer = {
         status: response.status,
@@ -243,11 +249,20 @@ export async function connectHttpTarget (options = {}) {
     for (const r of answer.requests || []) carry(r)
   })
   const jid = await stream.bound
+  // The clock for the time limit of requests that wait for chunks
+  // (https://github.com/danbri/factoidal/issues/1128); the engine decides.
+  const timer = setInterval(() => {
+    if (!stream.isOpen()) return
+    try {
+      stream.write(call(engine, 'xmppClientTick', [stream.handle, String(Date.now())]).send)
+    } catch (_error) { /* handle gone */ }
+  }, typeof options.tickMs === 'number' ? options.tickMs : 1000)
+  stream.closed.then(() => clearInterval(timer))
   return {
     jid,
     writableWithoutLogin: stream.opened.writableWithoutLogin || [],
     closed: stream.closed,
-    close: () => stream.close()
+    close: () => { clearInterval(timer); return stream.close() }
   }
 }
 

package/xmpp/inpage.mjs

@@ -53,6 +53,8 @@ export async function openInPageXmppServer (options = {}) {
   for (const k of ['domain', 'mucDomain', 'mixDomain', 'gc3Domain', 'saltB64']) {
     if (typeof options[k] === 'string') config[k] = options[k]
   }
+  if (typeof config.saltB64 !== 'string') config.saltSeed = randomToken()
+  config.occupantSeed = randomToken()
   if (Array.isArray(options.accounts)) config.accounts = options.accounts
   if (typeof options.iterationCount === 'number') config.iterationCount = options.iterationCount
   const opened = engine.call('xmppOpen', [JSON.stringify(config)])
@@ -106,7 +108,11 @@ export async function openInPageXmppServer (options = {}) {
       send (message) {
         if (!open) throw new Error('the in-page XMPP connection is closed')
         let answer
-        try { answer = engine.call('xmppMsgFeed', [session, String(message)]) } catch (error) { onError(error); end(); return }
+        try {
+          // The rate limits read the host's clock.
+          engine.call('xmppClock', [handle, String(Math.floor(Date.now() / 1000))])
+          answer = engine.call('xmppMsgFeed', [session, String(message)])
+        } catch (error) { onError(error); end(); return }
         emit(answer.send || [])
         router.apply(c, answer)
         if (answer.close === true) end()