@factoidal/core 0.11.0 → 0.12.0

package/lib/dataset.mjs

@@ -13,9 +13,10 @@
 // Lifetime: dispose() (or `using ds = ...`, Symbol.dispose) releases the
 // engine copy. A Dataset that is garbage collected without dispose() is
 // released by a FinalizationRegistry callback. Every method of a disposed
-// Dataset throws a TypeError that names the method.
+// Dataset throws the engine's FactoidalError, code handle.disposed.
 
 import { dataFactory, quadFromJson, quadToJson, termToJson, termFromSrj, Literal, NamedNode } from '../rdfjs.mjs';
+import { FactoidalError, envelopeResult } from './errors.mjs';
 
 const INTERNAL = Symbol('factoidal.Dataset.internal');
 
@@ -28,30 +29,38 @@ const WRITER_TAGS = {};
 
 const VERSIONS = { '1.1': '11', '1.2': '12' };
 
-/** Throw a TypeError when `options` has a key outside `allowed`. */
-function checkOptions(who, options, allowed) {
+/**
+ * The options object of public function `who`, checked by the engine (op
+ * apiCheck, formal/lean4/Wasm/Ops/Handles.lean): every key one the function
+ * takes, every format, regime, output and version in the engine's tables, and
+ * no two options that cannot be combined. A value that is not an object is a
+ * TypeError (a wrong JavaScript type); every other refusal is the engine's
+ * FactoidalError.
+ */
+function checkOptions(e, who, options) {
   if (options == null) return {};
   if (typeof options !== 'object' || Array.isArray(options)) {
     throw new TypeError(`${who}: options must be an object, got ${Array.isArray(options) ? 'array' : typeof options}`);
   }
+  // Each value as the engine reads it: a primitive as its String form, an
+  // object, array or function as {}, undefined as null.
+  const wire = {};
   for (const key of Object.keys(options)) {
-    if (!allowed.includes(key)) {
-      throw new TypeError(
-        `${who}: unknown option '${key}'. Known options: ${allowed.join(', ') || '(none)'}`);
-    }
+    const v = options[key];
+    wire[key] = v === undefined || v === null ? null
+      : (typeof v === 'object' || typeof v === 'function') ? {} : String(v);
   }
+  // An engine with no apiCheck op (the F* entry of tests/engine-compare, a
+  // private comparison build) has no option tables: its ops refuse instead.
+  if (typeof e.apiCheck !== 'function') return options;
+  envelopeResult(e.apiCheck(who, JSON.stringify(wire)));
   return options;
 }
 
-function envelope(jsonText, what) {
-  const r = JSON.parse(jsonText);
-  if (!r.ok) throw new Error(`${what}: ${r.error}`);
-  return r;
+function envelope(jsonText, _what, text) {
+  return envelopeResult(jsonText, text);
 }
 
-const SERIALIZE_OPTIONS = ['format', 'version', 'prefixes', 'literalShorthand',
-  'useNativeTypes', 'useRdfType', 'rdfDirection'];
-
 // The quads of the compact answer of datasetQuadsJson: each distinct term is
 // built once and shared (TermJson.compactCertified).
 function quadsFromCompact(terms, ixs) {
@@ -74,7 +83,7 @@ const DIRECTION = ['', 'ltr', 'rtl'];
 function quadsFromRegion(bytes, out) {
   const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   if (bytes.length < 12 || v.getUint32(0, true) !== 0x31425146) {
-    throw new Error('iterate: the engine answered no datasetQuadsBin region');
+    throw new FactoidalError('iterate: the engine answered no datasetQuadsBin region', { code: 'op.failed' });
   }
   const nTerms = v.getUint32(4, true);
   const nQuads = v.getUint32(8, true);
@@ -112,7 +121,7 @@ function quadsFromRegion(bytes, out) {
         const pr = term();
         return dataFactory.quad(s, pr, term());
       }
-      default: throw new Error('iterate: a term tag outside the DLOG version 2 codec');
+      default: throw new FactoidalError('iterate: a term tag outside the DLOG version 2 codec', { code: 'op.failed' });
     }
   };
   const ts = new Array(nTerms);
@@ -172,9 +181,11 @@ class Dataset {
    */
   get info() { return this._info; }
 
+  // A disposed Dataset: the engine answers handle.disposed for its handle.
   _open(who) {
     if (this._disposed) {
-      throw new TypeError(`Dataset.${who}: the Dataset was disposed (handle '${this._handle}')`);
+      envelopeResult(this._ctx.e.datasetClose(this._handle));
+      throw new FactoidalError(`Dataset.${who}: the Dataset was disposed`, { code: 'handle.disposed' });
     }
   }
 
@@ -196,7 +207,7 @@ class Dataset {
   async query(sparql, options) {
     this._open('query');
     return this._ctx.queryHandle(this, sparql,
-      checkOptions('Dataset.query', options, ['sparql12', 'version', 'entail', 'output']));
+      checkOptions(this._ctx.e, 'Dataset.query', options));
   }
 
   /**
@@ -207,11 +218,11 @@ class Dataset {
    */
   async update(updateText, options) {
     this._open('update');
-    checkOptions('Dataset.update', options, []);
+    checkOptions(this._ctx.e, 'Dataset.update', options);
     if (typeof updateText !== 'string') {
       throw new TypeError('Dataset.update: updateText must be a string');
     }
-    const r = envelope(this._ctx.e.datasetUpdate(this._handle, updateText), 'update');
+    const r = envelope(this._ctx.e.datasetUpdate(this._handle, updateText), 'update', updateText);
     this._changed(r.count);
     return this;
   }
@@ -225,7 +236,7 @@ class Dataset {
   async validateShacl(shapes, options) {
     this._open('validateShacl');
     return this._ctx.shacl(this, shapes,
-      checkOptions('Dataset.validateShacl', options, ['format', 'baseIRI']));
+      checkOptions(this._ctx.e, 'Dataset.validateShacl', options));
   }
 
   /**
@@ -237,7 +248,7 @@ class Dataset {
   async validateShex(schema, options) {
     this._open('validateShex');
     return this._ctx.shex(this, schema,
-      checkOptions('Dataset.validateShex', options, ['focus', 'shape']));
+      checkOptions(this._ctx.e, 'Dataset.validateShex', options));
   }
 
   /**
@@ -267,8 +278,8 @@ class Dataset {
    */
   async serialize(options) {
     this._open('serialize');
-    if (typeof options === 'string') return this._write({ format: options });
-    return this._write(checkOptions('Dataset.serialize', options, SERIALIZE_OPTIONS));
+    const opts = typeof options === 'string' ? { format: options } : options;
+    return this._write(checkOptions(this._ctx.e, 'Dataset.serialize', opts));
   }
 
   /**
@@ -278,34 +289,18 @@ class Dataset {
    */
   toString(formatOrOptions) {
     this._open('toString');
-    const opts = typeof formatOrOptions === 'string'
-      ? { format: formatOrOptions }
-      : checkOptions('Dataset.toString', formatOrOptions, SERIALIZE_OPTIONS);
-    return this._write(opts);
+    const opts = typeof formatOrOptions === 'string' ? { format: formatOrOptions } : formatOrOptions;
+    return this._write(checkOptions(this._ctx.e, 'Dataset.toString', opts));
   }
 
   _write(opts) {
     const e = this._ctx.e;
     const name = String(opts.format || 'nquads').toLowerCase();
     const writerTags = this._ctx.tables().writerFormats;
+    // The engine checked the format, the version and the option
+    // combination (op apiCheck) before this.
     const tag = writerTags[name];
-    if (!tag) {
-      throw new TypeError(
-        `Dataset.serialize: unknown format '${opts.format}'. Known formats: ` +
-        [...new Set(Object.values(writerTags))].join(', '));
-    }
-    let suffix = '';
-    if (opts.version !== undefined) {
-      suffix = VERSIONS[String(opts.version)];
-      if (!suffix) throw new TypeError("Dataset.serialize: version must be '1.1' or '1.2'");
-    }
-    if (tag !== 'turtle' && (opts.prefixes !== undefined || opts.literalShorthand !== undefined)) {
-      throw new TypeError("Dataset.serialize: 'prefixes' and 'literalShorthand' apply to format 'turtle' only");
-    }
-    const jsonldKeys = ['useNativeTypes', 'useRdfType', 'rdfDirection'];
-    if (tag !== 'jsonld' && jsonldKeys.some((k) => opts[k] !== undefined)) {
-      throw new TypeError(`Dataset.serialize: ${jsonldKeys.join(', ')} apply to format 'jsonld' only`);
-    }
+    const suffix = opts.version !== undefined ? VERSIONS[String(opts.version)] : '';
     if (tag === 'jsonld') {
       if (typeof e.datasetToJsonLd !== 'function') throw this._ctx.missing('serialize {format:jsonld}', 'datasetToJsonLd');
       const r = envelope(e.datasetToJsonLd(this._handle, JSON.stringify({

package/lib/delta-log-hosts.mjs

@@ -20,6 +20,7 @@
 //                              would; false when the log is empty
 //
 // No Node built-ins: the browser imports this file as it is.
+import { hostError } from './errors.mjs';
 
 const DELTA_STORE = 'deltaBatches';
 
@@ -65,7 +66,7 @@ export function memoryDeltaLogStore() {
 function indexedDbFactory() {
   const factory = globalThis.indexedDB;
   if (!factory) {
-    throw new Error('deltaLog: this runtime has no indexedDB; the browser entry keeps the log in IndexedDB');
+    throw hostError('deltaLog: this runtime has no indexedDB; the browser entry keeps the log in IndexedDB');
   }
   return factory;
 }
@@ -80,23 +81,23 @@ function idbOpen(dbName) {
       }
     };
     req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error || new Error('indexedDB.open failed'));
-    req.onblocked = () => reject(new Error('indexedDB.open blocked (another tab holds an open connection at an older version)'));
+    req.onerror = () => reject(hostError('indexedDB.open failed', req.error));
+    req.onblocked = () => reject(hostError('indexedDB.open blocked (another tab holds an open connection at an older version)'));
   });
 }
 
 function requestDone(req) {
   return new Promise((resolve, reject) => {
     req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error || new Error('IndexedDB request failed'));
+    req.onerror = () => reject(hostError('IndexedDB request failed', req.error));
   });
 }
 
 function transactionDone(tx) {
   return new Promise((resolve, reject) => {
     tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error || new Error('IndexedDB transaction failed'));
-    tx.onabort = () => reject(tx.error || new Error('IndexedDB transaction aborted'));
+    tx.onerror = () => reject(hostError('IndexedDB transaction failed', tx.error));
+    tx.onabort = () => reject(hostError('IndexedDB transaction aborted', tx.error));
   });
 }
 
@@ -164,8 +165,8 @@ export function indexedDbDeltaLogStore() {
       await new Promise((resolve, reject) => {
         const req = indexedDbFactory().deleteDatabase(name);
         req.onsuccess = () => resolve();
-        req.onerror = () => reject(req.error || new Error('indexedDB.deleteDatabase failed'));
-        req.onblocked = () => reject(new Error('indexedDB.deleteDatabase blocked (another open connection)'));
+        req.onerror = () => reject(hostError('indexedDB.deleteDatabase failed', req.error));
+        req.onblocked = () => reject(hostError('indexedDB.deleteDatabase blocked (another open connection)'));
       });
     },
     async corruptLast(name) {

package/lib/errors.mjs

@@ -0,0 +1,97 @@
+// factoidal — the one error class of the package
+// (https://github.com/danbri/factoidal/issues/882 item 4).
+//
+// Every function of the package rejects (or throws) with a FactoidalError.
+// The engine decides its `code`, its `spec` section and its `position`
+// (formal/lean4/Wasm/Ops/ErrorModel.lean); this file only copies them out
+// of the error envelope. A TypeError is thrown only when an argument has the
+// wrong JavaScript type (a number where a string is needed, and the like).
+//
+// ES module, no Node built-ins: the browser loads this file as it is.
+
+/**
+ * An engine refusal, or a host failure (`host.io`).
+ *
+ * - `code`: a stable machine code, one of the engine's `errorCodes` table
+ *   (op engineTables; README "Errors").
+ * - `position`: `{line, column, offset, byteOffset}` where the input defines
+ *   one, else `null`. `line` and `column` are 1-based (`column` counts
+ *   Unicode scalar values); `offset` is a UTF-16 index into the JavaScript
+ *   string, so `text.slice(err.position.offset)` starts at the error;
+ *   `byteOffset` counts UTF-8 bytes.
+ * - `spec`: the URL of the specification section that defines the
+ *   condition, or `null`.
+ * - `cause`: the underlying error, when there is one.
+ * - `format`, `formatInferred`: for a parse failure of text, the syntax it
+ *   was read as and whether that syntax was inferred.
+ */
+export class FactoidalError extends Error {
+  constructor(message, info) {
+    const i = info || {};
+    super(message, i.cause !== undefined ? { cause: i.cause } : undefined);
+    this.name = 'FactoidalError';
+    this.code = i.code || 'op.failed';
+    this.position = i.position || null;
+    this.spec = i.spec || null;
+    if (i.format !== undefined) this.format = i.format;
+    if (i.formatInferred !== undefined) this.formatInferred = i.formatInferred;
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, FactoidalError);
+    }
+  }
+}
+
+// The engine counts `offset` in Unicode scalar values from the start of the
+// input; a JavaScript string is indexed in UTF-16 code units, where a
+// character at U+10000 or above takes two. This converts the count to the
+// UTF-16 index of the same position (a unit conversion of the host string;
+// a count past the end gives text.length).
+export function utf16OffsetOf(text, scalarOffset) {
+  if (typeof text !== 'string' || !Number.isInteger(scalarOffset) || scalarOffset < 0) {
+    return scalarOffset;
+  }
+  let units = 0;
+  let scalars = 0;
+  for (const ch of text) {
+    if (scalars >= scalarOffset) break;
+    units += ch.length;
+    scalars += 1;
+  }
+  return units;
+}
+
+/**
+ * The FactoidalError of an error envelope ({"ok":false,"error",...}).
+ * `text` is the input string the envelope's position counts into, when the
+ * caller has it.
+ */
+export function errorFromEnvelope(env, text) {
+  const p = env && env.position;
+  let position = null;
+  if (p && typeof p === 'object') {
+    position = {
+      line: p.line,
+      column: p.column,
+      offset: typeof text === 'string' ? utf16OffsetOf(text, p.offset) : p.offset,
+      byteOffset: p.byteOffset,
+    };
+  }
+  return new FactoidalError(String((env && env.error) || 'engine refusal'), {
+    code: env && env.code,
+    spec: env && env.spec,
+    position,
+    format: env && env.format,
+  });
+}
+
+/** Unwrap one op envelope: the envelope object, or throw its FactoidalError. */
+export function envelopeResult(jsonText, text) {
+  const r = typeof jsonText === 'string' ? JSON.parse(jsonText) : jsonText;
+  if (!r.ok) throw errorFromEnvelope(r, text);
+  return r;
+}
+
+/** A host failure (file system, IndexedDB): code `host.io`, with its cause. */
+export function hostError(message, cause) {
+  return new FactoidalError(message, { code: 'host.io', cause });
+}

package/lib/lean-entry.mjs

@@ -28,6 +28,7 @@
 // (`fullOnlyOps`, `fullOnlyFormats`); a call to one of those names the
 // entry that has it.
 import { appTermToJson, termToJson } from '../rdfjs.mjs';
+import { errorFromEnvelope } from './errors.mjs';
 export const FULL_ENTRY = '@factoidal/core';
 // The core profile is built for the hub pages only; the package ships the
 // full engine (owner, 2026-10-20).
@@ -53,15 +54,13 @@ function okEnvelope(extra) {
 }
 
 // An engine refusal arrives as an Error whose `.envelope` is the whole
-// {"ok":false,...} document (the loader keeps it, so a parse failure's
-// line, column, offset and format reach lib/api.mjs's ParseError). The
-// message stays the loader's own, "l4factoidal: <error>".
+// {"ok":false,...} document: the engine's message, code, spec section and
+// position pass to lib/errors.mjs unchanged. Any other throw (the wasm
+// trapped, the loader failed) is code op.failed.
 function failEnvelope(err) {
   const env = err && err.envelope;
-  if (env && typeof env === 'object' && env.ok === false) {
-    return JSON.stringify({ ...env, error: String(err.message) });
-  }
-  return JSON.stringify({ ok: false, error: String((err && err.message) || err) });
+  if (env && typeof env === 'object' && env.ok === false) return JSON.stringify(env);
+  return JSON.stringify({ ok: false, code: 'op.failed', error: String((err && err.message) || err) });
 }
 
 // One answer for Wasm/Ops/ExtFns.lean: the JavaScript value tagged with its
@@ -158,7 +157,7 @@ export function entryFromEngine(eng) {
     entry[op] = (...args) => {
       if (formatChecked && entry.fullOnlyFormats.includes(String(args[1] ?? '').toLowerCase())) {
         return JSON.stringify({
-          ok: false, servedBy: 'full',
+          ok: false, servedBy: 'full', code: 'op.unknown',
           error: fullEngineMessage(`the format '${args[1]}'`),
         });
       }
@@ -204,8 +203,14 @@ export function entryFromEngine(eng) {
   // this method answers {envelope, bytes} and throws on a refusal.
   const blobIoOps = Array.isArray(reflection.blobIoOps) ? reflection.blobIoOps : [];
   if (typeof eng.callBlobIO === 'function' && blobIoOps.includes('datasetQuadsBin')) {
-    entry.datasetQuadsBin = (handle, optsJson) =>
-      eng.callBlobIO('datasetQuadsBin', [String(handle), String(optsJson ?? '')], new Uint8Array(0));
+    entry.datasetQuadsBin = (handle, optsJson) => {
+      try {
+        return eng.callBlobIO('datasetQuadsBin', [String(handle), String(optsJson ?? '')], new Uint8Array(0));
+      } catch (err) {
+        if (err && err.envelope) throw errorFromEnvelope(err.envelope);
+        throw err;
+      }
+    };
   } else {
     delete entry.datasetQuadsBin;
   }

package/lib/store.mjs

@@ -17,6 +17,7 @@
 // `factoidal` command.
 
 import { requireChildName } from '../store-host/paths.mjs';
+import { hostError } from './errors.mjs';
 
 /** The manifest file names a generation directory can carry, in the order
  *  the native tools try them. */
@@ -44,10 +45,8 @@ export async function openGeneration(reader, generation) {
     try {
       pointer = await readBytes(reader, 'CURRENT');
     } catch (cause) {
-      const err = new Error(
-        `openStore: the collection root has no readable CURRENT pointer (${cause && cause.message})`);
-      err.cause = cause;
-      throw err;
+      throw hostError(
+        `openStore: the collection root has no readable CURRENT pointer (${cause && cause.message})`, cause);
     }
     // CURRENT holds a UTF-8 generation name (docs/shardborough-storage-spec.md
     // section 6.4); trailing ASCII whitespace is tolerated, as in
@@ -67,7 +66,7 @@ export async function openGeneration(reader, generation) {
     }
     return { generation: name, manifestName, manifest, activated: generation == null };
   }
-  throw new Error(`openStore: generation '${name}' has none of ${MANIFEST_NAMES.join(', ')}`);
+  throw hostError(`openStore: generation '${name}' has none of ${MANIFEST_NAMES.join(', ')}`);
 }
 
 /** Read the named artifacts of one generation into one region, with a

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

package/lws/README.md

@@ -27,10 +27,12 @@ host or the engine failed rather than answered.
 | op | arguments | answer |
 | --- | --- | --- |
 | `lwsOpen` | `[configJson]` | `{ ok, handle, root }` |
-| `lwsStep` | `[handle, requestJson]` | `{ ok, response }` |
+| `lwsStep` | `[handle, requestJson]` | `{ ok, response, changed, deliveries?, wake? }`, or `{ ok, resolve: { host } }` |
 | `lwsClose` | `[handle]` | `{ ok }` |
 | `lwsSnapshot` | `[handle]` | `{ ok, snapshot }` |
 | `lwsFetched` | `[handle, documentJson]` | `{ ok, fetch? , installed?, refused? }` |
+| `lwsDelivered` | `[handle, reportJson]` | `{ ok, changed, retry? }` |
+| `lwsFlush` | `[handle, { now? }]` | `{ ok, changed, deliveries?, wake? }` |
 
 ```
 request  { method, target, headers: [[name, value]] } + the content as bytes
@@ -46,8 +48,11 @@ unchanged and this host composes no IRI.
 `configJson` members, all optional: `baseIri` (the absolute IRI the
 storage root maps to), `now` (the engine clock in seconds, which advances
 by one second per mutation so a write sequence has increasing
-`Last-Modified` values with no real clock), `owner`, `agent`, `rootAcl`,
-`auth` and `insecureNoAuth` (below). A request
+`Last-Modified` values with no real clock), `owner`, `agent`, `pageSize`
+(the container pagination threshold and page size, default 100, 0 for no
+pagination), `rootAcl`, `auth` and `insecureNoAuth` (below),
+`notifications` (default true) and `entropy` (random bytes, base64, which
+this host makes for every open). A request
 may carry `now` and `agent` of its own to override the handle's for one
 step; `listen({realClock: true})` is how a server with a real clock feeds
 one in, and a test leaves it off to keep the engine's deterministic
@@ -87,6 +92,68 @@ const running = await listen({
 * `insecureNoAuth: true` serves every request with no authorization. It is
   for development only, and must be asked for.
 
+## Pagination and client links
+
+Both are decided in Lean; this host passes the fields through.
+
+* A container with more than `pageSize` members (default 100) is listed in
+  pages (LWS §LWS Media Type, Pagination;
+  https://github.com/danbri/factoidal/issues/887). Each page answers 200
+  with the `Link` relations `first` and `last`, `next` on every page but the
+  last, and `prev` on every page but the first; the page URIs are
+  `CONTAINER?page=N`. `totalItems` counts the full membership. The members
+  are in increasing path order, each once; the theorem `pageItems_concat` in
+  `L4Factoidal/LWS/Operations.lean` states that the pages of an unchanged
+  container concatenate to the full listing. Each page has its own `ETag`,
+  which starts with the container's clock; the clock changes when the
+  membership changes.
+* A client sets its own links (`license`, `author`, any extension relation)
+  with `Link` and `Prefer: set-linkset` on PUT (replace) or PATCH (add),
+  with `Link` on POST, or through the linkset resource `PATH?linkset` with
+  JSON Patch or a PUT of `application/linkset+json` (LWS §Metadata, §Update
+  Resource; https://github.com/danbri/factoidal/issues/888). The relations
+  `linkset`, `type`, `format`, `size`, `modified`, `up`, `items` and
+  `lws#storage` are server-managed: a request that sets or changes one gets
+  409. A malformed link gets 400. Without `Prefer: set-linkset`, a `Link`
+  field on PUT and PATCH is not stored.
+
+## Notifications
+
+LWS notifications and the webhook notification suite
+(https://github.com/danbri/factoidal/issues/890) are decided by
+`formal/lean4/L4Factoidal/LWS/Notifications.lean`. They are on unless
+`notifications: false` is passed.
+
+* The storage description at `/.well-known/lws-storage` names the
+  `NotificationService`: endpoint `/.well-known/lws-subscriptions/`, type
+  `WebhookSubscription`, and the Ed25519 key that signs deliveries.
+* A client POSTs `{"type":"WebhookSubscription","topic":[IRI…],"inbox":URL}`
+  (`application/lws+json`, with a token when authorization is on) and gets
+  201 with the subscription URL. GET on the endpoint lists the agent's
+  subscriptions; GET and DELETE manage one.
+* After a write, `lwsStep` names the deliveries: `{ id, url, headers, body }`.
+  This host POSTs each one exactly as given, after the response, and reports
+  the status to `lwsDelivered`; when the engine answers `retry`, it waits
+  `after` seconds and sends the delivery it names. `storage().settled()`
+  resolves when no delivery is in flight.
+* Rate limit (https://github.com/danbri/factoidal/issues/915): at most
+  `deliveryLimit` deliveries (default 10) per subscription in a window of
+  `deliveryWindow` seconds (default 60; `deliveryLimit: 0` turns it off).
+  The rest wait; an answer then carries `wake: SECONDS`, and this host calls
+  `lwsFlush` after that many seconds and sends the one batched delivery it
+  names.
+* Inbox check (issue 915): when an inbox host is a name, `lwsStep` answers
+  `resolve: { host }`; this host resolves it (`dns.lookup`, every address)
+  and steps the request again with `resolved: [{ host, addresses }]`.
+  `listen()` passes `listen: { address, port, addresses }` to `lwsOpen`. The
+  engine refuses a container of this storage under another name of this
+  server.
+* `controllerInbox: URL` (https://github.com/danbri/factoidal/issues/920):
+  each new access request is announced there with a `Create` notification.
+* After a move, a request to a previous path answers 301 with `Location`
+  (https://github.com/danbri/factoidal/issues/914); `redirectsMax` (default
+  256) bounds the table.
+
 ## Use
 
 ```js