@factoidal/core 0.7.1 → 0.10.0

package/lib/browser-engine.mjs

@@ -0,0 +1,69 @@
+// Loading a Lean engine in the browser: one of the two modules of
+// l4-assets/ (issue 713 stage 4), named by its basename:
+//
+//   'l4factoidal'       the full engine (browser.js)
+//   'l4factoidal-core'  the core engine (core-browser.js)
+//
+// Each engine is three files that keep their names together: the loader
+// <name>.js, Emscripten's glue <name>.mjs and the module <name>.wasm. The
+// loader is imported from the assets directory; the wasm is fetched and
+// compiled with WebAssembly.instantiateStreaming (a server that does not
+// send `Content-Type: application/wasm` gets WebAssembly.instantiate over
+// the fetched bytes instead).
+//
+// No Node built-ins: the browser imports this file as it is.
+
+async function instantiate(url, imports) {
+  try {
+    return await WebAssembly.instantiateStreaming(fetch(url), imports);
+  } catch (err) {
+    // instantiateStreaming refuses a response without the application/wasm
+    // media type with a TypeError; compile from the bytes then. Any other
+    // failure (network, a corrupt module) is the caller's.
+    if (!(err instanceof TypeError)) throw err;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`factoidal: fetching ${url} failed: ${response.status} ${response.statusText}`);
+    }
+    return WebAssembly.instantiate(await response.arrayBuffer(), imports);
+  }
+}
+
+/**
+ * The asset-directory setters and the engine loader of one engine.
+ * @param {string} name 'l4factoidal' or 'l4factoidal-core'
+ * @param {string} defaultAssetsUrl the directory URL to load from until
+ *        setAssetsUrl() names another
+ */
+export function browserEngine(name, defaultAssetsUrl) {
+  let assetsUrl = defaultAssetsUrl;
+  let enginePromise = null;
+
+  function setAssetsUrl(url) {
+    if (enginePromise) {
+      throw new Error('setAssetsUrl: the engine is already loaded from ' + assetsUrl);
+    }
+    const text = String(url);
+    assetsUrl = new URL(text.endsWith('/') ? text : text + '/', globalThis.location?.href).href;
+  }
+
+  function getAssetsUrl() {
+    return assetsUrl;
+  }
+
+  function loadEngine() {
+    if (enginePromise) return enginePromise;
+    enginePromise = (async () => {
+      const loader = await import(new URL(`${name}.js`, assetsUrl).href);
+      // The content-hash version keeps a cached wasm from pairing with a
+      // newer loader (the loader's own locateFile does the same).
+      const version = loader.wasmVersion ? `?v=${loader.wasmVersion}` : '';
+      const wasmUrl = new URL(`${name}.wasm`, assetsUrl).href + version;
+      return loader.loadL4({ instantiateWasm: (imports) => instantiate(wasmUrl, imports) });
+    })();
+    enginePromise.catch(() => { enginePromise = null; });
+    return enginePromise;
+  }
+
+  return { setAssetsUrl, getAssetsUrl, loadEngine };
+}

package/lib/dataset.mjs

@@ -0,0 +1,377 @@
+// factoidal — Dataset: an RDF dataset held inside the Lean engine.
+//
+// https://github.com/danbri/factoidal/issues/882 item 1. A Dataset is a
+// handle into the engine's dataset store (formal/lean4/Wasm/Ops/Handles.lean
+// and Wasm/Ops/DatasetFull.lean). The parsed, indexed dataset stays in the
+// wasm memory; a query, an update, a validation, a closure or a
+// serialisation sends the handle id and the query text, not the data. An op
+// that makes a dataset (parse, CSVW, RML, JSON-LD, closures, RIF) answers a
+// new handle, so a pipeline of steps moves no N-Quads text between them.
+//
+// This file only marshals: every decision about RDF is the engine's.
+//
+// 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.
+
+import { nquadsLineToQuad, quadToNQuads, termToNQuads, termFromSrj } from '../rdfjs.mjs';
+
+const INTERNAL = Symbol('factoidal.Dataset.internal');
+
+// Writer names (lower case) -> the engine's writer tag. JSON-LD is served
+// by the op datasetToJsonLd; the SPARQL results formats are query outputs.
+const WRITER_TAGS = {
+  nquads: 'nquads', nq: 'nquads', 'n-quads': 'nquads',
+  ntriples: 'ntriples', nt: 'ntriples', 'n-triples': 'ntriples',
+  turtle: 'turtle', ttl: 'turtle',
+  trig: 'trig',
+  rdfxml: 'rdfxml', 'rdf-xml': 'rdfxml', rdf: 'rdfxml',
+  jsonld: 'jsonld', 'json-ld': 'jsonld',
+  rdfc: 'rdfc', canonical: 'rdfc', 'rdfc-1.0': 'rdfc',
+};
+
+const VERSIONS = { '1.1': '11', '1.2': '12' };
+
+/** Throw a TypeError when `options` has a key outside `allowed`. */
+function checkOptions(who, options, allowed) {
+  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}`);
+  }
+  for (const key of Object.keys(options)) {
+    if (!allowed.includes(key)) {
+      throw new TypeError(
+        `${who}: unknown option '${key}'. Known options: ${allowed.join(', ') || '(none)'}`);
+    }
+  }
+  return options;
+}
+
+function envelope(jsonText, what) {
+  const r = JSON.parse(jsonText);
+  if (!r.ok) throw new Error(`${what}: ${r.error}`);
+  return r;
+}
+
+const SERIALIZE_OPTIONS = ['format', 'version', 'prefixes', 'literalShorthand',
+  'useNativeTypes', 'useRdfType', 'rdfDirection'];
+
+class Dataset {
+  /** @private Datasets come from parse(), csvwToRdf() and the other producers. */
+  constructor(token, ctx, handle, size, prefixes, extra) {
+    if (token !== INTERNAL) {
+      throw new TypeError(
+        'Dataset: use parse(), openDataset() or another producer; the constructor is internal');
+    }
+    this._ctx = ctx;
+    this._handle = handle;
+    this._size = size;
+    this._prefixes = Object.freeze({ ...(prefixes || {}) });
+    const x = extra || {};
+    this._diagnostics = Object.freeze((x.diagnostics || []).slice());
+    this._format = x.format;
+    this._formatInferred = !!x.formatInferred;
+    this._info = Object.freeze({ ...(x.info || {}) });
+    this._disposed = false;
+    this._nquads = null;   // cached N-Quads text, dropped on update
+    this._quads = null;    // cached quad array, dropped on update
+    if (ctx.registry) ctx.registry.register(this, { e: ctx.e, handle }, this);
+  }
+
+  /** The engine's handle id (opaque, e.g. "h7"). */
+  get handle() { return this._handle; }
+  /** Number of quads. */
+  get size() { this._open('size'); return this._size; }
+  /** Prefixes the source document declared (label -> namespace IRI). */
+  get prefixes() { return this._prefixes; }
+  /** Diagnostics of a lenient parse ({lenient:true}); else empty. */
+  get diagnostics() { return this._diagnostics; }
+  /** The syntax the data was read from, when it was read from text. */
+  get format() { return this._format; }
+  /** True when `format` was inferred because the caller gave none. */
+  get formatInferred() { return this._formatInferred; }
+  /** True after dispose(). */
+  get disposed() { return this._disposed; }
+  /**
+   * What the producing op reported beside the data: `rounds` for the rho-df
+   * and RDFS-Plus closures; `inputCount`, `derivedCount`, `fuel` for rifEval.
+   */
+  get info() { return this._info; }
+
+  _open(who) {
+    if (this._disposed) {
+      throw new TypeError(`Dataset.${who}: the Dataset was disposed (handle '${this._handle}')`);
+    }
+  }
+
+  _changed(size) {
+    this._size = size;
+    this._nquads = null;
+    this._quads = null;
+  }
+
+  /**
+   * SPARQL 1.1 (or 1.2) query.
+   * @param {string} sparql
+   * @param {{sparql12?: boolean, version?: '1.1'|'1.2', entail?: string,
+   *   output?: 'json'|'xml'|'csv'|'tsv'|'table'|'ntriples'}} [options]
+   *   With `output` (or an `entail` regime other than 'none') the answer
+   *   is text (`output` 'json': the parsed results JSON object).
+   * @returns {Promise<Array<Map<string, object>>|boolean|Dataset|string|object>}
+   */
+  async query(sparql, options) {
+    this._open('query');
+    return this._ctx.queryHandle(this, sparql,
+      checkOptions('Dataset.query', options, ['sparql12', 'version', 'entail', 'output']));
+  }
+
+  /**
+   * SPARQL 1.1 Update, applied to this Dataset in place.
+   * @param {string} updateText
+   * @param {{}} [options] none today
+   * @returns {Promise<Dataset>} this Dataset
+   */
+  async update(updateText, options) {
+    this._open('update');
+    checkOptions('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');
+    this._changed(r.count);
+    return this;
+  }
+
+  /**
+   * SHACL validation with this Dataset as the data graph.
+   * @param {Dataset|string} shapes a Dataset or text
+   * @param {{format?: string, baseIRI?: string}} [options] read `shapes` text
+   * @returns {Promise<{conforms: boolean, report: Dataset}>}
+   */
+  async validateShacl(shapes, options) {
+    this._open('validateShacl');
+    return this._ctx.shacl(this, shapes,
+      checkOptions('Dataset.validateShacl', options, ['format', 'baseIRI']));
+  }
+
+  /**
+   * ShEx validation of one focus node with this Dataset as the data graph.
+   * @param {string} schema ShExC or ShExJ text
+   * @param {{focus: string|object, shape?: string|object}} options
+   * @returns {Promise<boolean>}
+   */
+  async validateShex(schema, options) {
+    this._open('validateShex');
+    return this._ctx.shex(this, schema,
+      checkOptions('Dataset.validateShex', options, ['focus', 'shape']));
+  }
+
+  /**
+   * Closure of the default graph under a regime, as a new Dataset.
+   * @param {'rdfs'|'owl-rl'|'rho-df'|'rdfs-plus'} regime
+   * @returns {Promise<Dataset>}
+   */
+  async closure(regime) {
+    this._open('closure');
+    return this._ctx.closure(this, regime);
+  }
+
+  /** RDFC-1.0 canonical N-Quads. @returns {Promise<string>} */
+  async canonicalize() {
+    this._open('canonicalize');
+    return this.toString('rdfc');
+  }
+
+  /**
+   * The dataset as a document.
+   * @param {{format?: string, version?: '1.1'|'1.2', prefixes?: object,
+   *   literalShorthand?: boolean, useNativeTypes?: boolean,
+   *   useRdfType?: boolean, rdfDirection?: string}} [options]
+   *   format: nquads (default), ntriples, turtle, trig, rdfxml, jsonld,
+   *   rdfc (RDFC-1.0 canonical N-Quads).
+   * @returns {Promise<string>}
+   */
+  async serialize(options) {
+    this._open('serialize');
+    if (typeof options === 'string') return this._write({ format: options });
+    return this._write(checkOptions('Dataset.serialize', options, SERIALIZE_OPTIONS));
+  }
+
+  /**
+   * Synchronous serialize(): `toString('turtle')` or `toString({format})`.
+   * @param {string|object} [formatOrOptions]
+   * @returns {string}
+   */
+  toString(formatOrOptions) {
+    this._open('toString');
+    const opts = typeof formatOrOptions === 'string'
+      ? { format: formatOrOptions }
+      : checkOptions('Dataset.toString', formatOrOptions, SERIALIZE_OPTIONS);
+    return this._write(opts);
+  }
+
+  _write(opts) {
+    const e = this._ctx.e;
+    const name = String(opts.format || 'nquads').toLowerCase();
+    const tag = WRITER_TAGS[name];
+    if (!tag) {
+      throw new TypeError(
+        `Dataset.serialize: unknown format '${opts.format}'. Known formats: ` +
+        [...new Set(Object.values(WRITER_TAGS))].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`);
+    }
+    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({
+        ...(opts.useNativeTypes ? { useNativeTypes: true } : {}),
+        ...(opts.useRdfType ? { useRdfType: true } : {}),
+        ...(opts.rdfDirection ? { rdfDirection: String(opts.rdfDirection) } : {}),
+        ...(suffix ? { version: String(opts.version) } : {}),
+      })), 'serialize');
+      return r.jsonld;
+    }
+    if (tag === 'nquads' && !suffix && this._nquads !== null) return this._nquads;
+    const fullTag = tag + suffix;
+    let r;
+    if (tag === 'turtle' && (opts.prefixes !== undefined || opts.literalShorthand !== undefined ||
+        Object.keys(this._prefixes).length > 0)) {
+      r = envelope(e.datasetSerializeWith(this._handle, fullTag, JSON.stringify({
+        prefixes: { ...this._prefixes, ...(opts.prefixes || {}) },
+        ...(opts.literalShorthand !== undefined ? { literalShorthand: !!opts.literalShorthand } : {}),
+      })), 'serialize');
+    } else {
+      r = envelope(e.datasetSerialize(this._handle, fullTag), 'serialize');
+    }
+    const text = r.text !== undefined ? r.text : (tag === 'turtle' ? r.turtle : r.nquads);
+    if (tag === 'nquads' && !suffix) this._nquads = text;
+    return text;
+  }
+
+  /** N-Quads text (sorted, the engine's canonical line order). */
+  toNQuads() {
+    this._open('toNQuads');
+    return this._write({ format: 'nquads' });
+  }
+
+  /** A new Dataset with the same quads; updates of one leave the other unchanged. */
+  clone() {
+    this._open('clone');
+    const r = envelope(this._ctx.e.datasetClone(this._handle), 'clone');
+    return this._ctx.wrap(r, this._prefixes);
+  }
+
+  /**
+   * RDF/JS quads, read from the engine's N-Quads text one line at a time.
+   * @returns {Iterator<object>}
+   */
+  *[Symbol.iterator]() {
+    this._open('iterate');
+    if (this._quads) { yield* this._quads; return; }
+    const text = this.toNQuads();
+    let start = 0;
+    let lineNo = 0;
+    while (start < text.length) {
+      let end = text.indexOf('\n', start);
+      if (end < 0) end = text.length;
+      lineNo += 1;
+      const line = text.slice(start, end);
+      start = end + 1;
+      const q = nquadsLineToQuad(line, lineNo);
+      if (q) yield q;
+    }
+  }
+
+  /** Every quad as an array. */
+  toArray() {
+    this._open('toArray');
+    if (!this._quads) this._quads = Object.freeze([...this]);
+    return this._quads.slice();
+  }
+
+  // A quad pattern for the ops datasetMatch and datasetMatchCount: four
+  // N-Triples term tokens, '' for an unbound position, 'DEFAULT' for the
+  // default graph.
+  _pattern(subject, predicate, object, graph) {
+    const tok = (t) => (t == null ? '' : termToNQuads(t));
+    const g = graph == null ? '' : (graph.termType === 'DefaultGraph' ? 'DEFAULT' : termToNQuads(graph));
+    return JSON.stringify([tok(subject), tok(predicate), tok(object), g]);
+  }
+
+  /** RDF/JS DatasetCore.has: one indexed lookup in the engine. */
+  has(quad) {
+    this._open('has');
+    const r = envelope(this._ctx.e.datasetMatchCount(this._handle,
+      this._pattern(quad.subject, quad.predicate, quad.object, quad.graph || { termType: 'DefaultGraph' })), 'has');
+    return r.count > 0;
+  }
+
+  /**
+   * RDF/JS DatasetCore.match: the matching quads as a new Dataset, found
+   * through the engine's indexes. `null`/`undefined` matches any term.
+   */
+  match(subject, predicate, object, graph) {
+    this._open('match');
+    const r = envelope(this._ctx.e.datasetMatch(this._handle,
+      this._pattern(subject, predicate, object, graph)), 'match');
+    return this._ctx.wrap(r, this._prefixes);
+  }
+
+  /**
+   * RDF/JS DatasetCore.add: add one quad (set semantics). A blank node is
+   * the node of that label in this Dataset. Each call changes the engine
+   * copy and costs time in the dataset size; for many quads use update()
+   * or parse().
+   */
+  add(quad) {
+    this._open('add');
+    const r = envelope(this._ctx.e.datasetAddQuads(this._handle, quadToNQuads(quad)), 'add');
+    this._changed(r.count);
+    return this;
+  }
+
+  /** RDF/JS DatasetCore.delete: remove one quad. */
+  delete(quad) {
+    this._open('delete');
+    const r = envelope(this._ctx.e.datasetDeleteQuads(this._handle, quadToNQuads(quad)), 'delete');
+    this._changed(r.count);
+    return this;
+  }
+
+  /** Release the engine copy. Idempotent. */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._nquads = null;
+    this._quads = null;
+    if (this._ctx.registry) this._ctx.registry.unregister(this);
+    try { this._ctx.e.datasetClose(this._handle); } catch (_err) { /* engine gone */ }
+  }
+
+  /** `using ds = await parse(...)` disposes at the end of the block. */
+  [Symbol.dispose]() { this.dispose(); }
+}
+
+/**
+ * A FinalizationRegistry that closes the engine handle of a Dataset that is
+ * collected without dispose(). Null where the platform has none.
+ */
+function makeRegistry() {
+  if (typeof FinalizationRegistry !== 'function') return null;
+  return new FinalizationRegistry(({ e, handle }) => {
+    try { e.datasetClose(handle); } catch (_err) { /* engine gone */ }
+  });
+}
+
+export { Dataset, INTERNAL, checkOptions, makeRegistry, WRITER_TAGS, termFromSrj };

package/lib/delta-log-hosts.mjs

@@ -0,0 +1,191 @@
+// Host stores for the durable update log (deltaLog* in lib/api.mjs; hub
+// post 18; https://github.com/danbri/factoidal/issues/728).
+//
+// A host store keeps, for each log name, the records in commit order. A
+// record is { seq, epoch, hex }: `hex` is the hexadecimal text of one DLB1
+// record as the engine wrote it (op deltaLogEncode,
+// formal/lean4/Wasm/Ops/DeltaLog.lean). The store does not read the hex.
+// The byte format, the checksums, the torn-record rule and the merge are in
+// Lean (formal/lean4/L4Factoidal/Storage/BrowserLog.lean); a host store
+// only stores and loads text.
+//
+//   open(name)                 create the log if it is absent
+//   append(name, makeRecord)   seq := the number of records; makeRecord(seq)
+//                              (synchronous) gives {hex, epoch}; the record
+//                              is committed with that seq, atomically
+//   readAll(name)              the hex texts, in seq order
+//   destroy(name)              remove the log
+//   corruptLast(name)          TEST HOOK: cut the last 8 hex digits (4
+//                              bytes) of the last record, as a torn write
+//                              would; false when the log is empty
+//
+// No Node built-ins: the browser imports this file as it is.
+
+const DELTA_STORE = 'deltaBatches';
+
+/**
+ * The records in the memory of this process. The default store of the Node
+ * entry: the records live as long as the process. Pass another store to
+ * buildApi() (driver.deltaLogStore) to keep them elsewhere.
+ */
+export function memoryDeltaLogStore() {
+  const logs = new Map();
+  const recordsOf = (name) => {
+    if (!logs.has(name)) logs.set(name, []);
+    return logs.get(name);
+  };
+  return {
+    kind: 'memory',
+    async open(name) {
+      recordsOf(name);
+    },
+    async append(name, makeRecord) {
+      const records = recordsOf(name);
+      const seq = records.length;
+      const rec = makeRecord(seq);
+      records.push({ seq, epoch: rec.epoch, hex: rec.hex });
+      return { seq };
+    },
+    async readAll(name) {
+      return (logs.get(name) || []).map((r) => r.hex);
+    },
+    async destroy(name) {
+      logs.delete(name);
+    },
+    async corruptLast(name) {
+      const records = logs.get(name);
+      if (!records || records.length === 0) return false;
+      const last = records[records.length - 1];
+      last.hex = last.hex.slice(0, Math.max(0, last.hex.length - 8));
+      return true;
+    },
+  };
+}
+
+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');
+  }
+  return factory;
+}
+
+function idbOpen(dbName) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDbFactory().open(dbName, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(DELTA_STORE)) {
+        db.createObjectStore(DELTA_STORE, { keyPath: 'seq' });
+      }
+    };
+    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)'));
+  });
+}
+
+function requestDone(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error || new Error('IndexedDB request failed'));
+  });
+}
+
+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'));
+  });
+}
+
+/**
+ * The records in IndexedDB: one database for each log name, one object
+ * store 'deltaBatches' keyed by seq, one object { seq, epoch, hex } for each
+ * committed update. The default store of the browser entries.
+ *
+ * append() counts the records, calls makeRecord and adds the record in ONE
+ * readwrite transaction. IndexedDB runs the readwrite transactions of one
+ * object store one after another, so two tabs that append at the same time
+ * get different seq values; `add` (not `put`) refuses a seq that exists. The
+ * transaction asks for `durability: 'strict'`: Chrome 121 and later default
+ * to 'relaxed', where `complete` can fire before the data is on disk.
+ */
+export function indexedDbDeltaLogStore() {
+  return {
+    kind: 'indexedDB',
+    async open(name) {
+      const db = await idbOpen(name);
+      db.close();
+    },
+    async append(name, makeRecord) {
+      const db = await idbOpen(name);
+      try {
+        const tx = db.transaction(DELTA_STORE, 'readwrite', { durability: 'strict' });
+        const done = transactionDone(tx);
+        const store = tx.objectStore(DELTA_STORE);
+        let seq;
+        let failure = null;
+        const countReq = store.count();
+        countReq.onsuccess = () => {
+          seq = countReq.result;
+          try {
+            // Synchronous: the transaction stays active inside this callback.
+            const rec = makeRecord(seq);
+            store.add({ seq, epoch: rec.epoch, hex: rec.hex });
+          } catch (err) {
+            failure = err;
+            tx.abort();
+          }
+        };
+        try {
+          await done;
+        } catch (err) {
+          throw failure || err;
+        }
+        return { seq };
+      } finally {
+        db.close();
+      }
+    },
+    async readAll(name) {
+      const db = await idbOpen(name);
+      try {
+        const all = await requestDone(
+          db.transaction(DELTA_STORE, 'readonly').objectStore(DELTA_STORE).getAll());
+        all.sort((a, b) => a.seq - b.seq);
+        return all.map((r) => r.hex);
+      } finally {
+        db.close();
+      }
+    },
+    async destroy(name) {
+      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)'));
+      });
+    },
+    async corruptLast(name) {
+      const db = await idbOpen(name);
+      try {
+        const all = await requestDone(
+          db.transaction(DELTA_STORE, 'readonly').objectStore(DELTA_STORE).getAll());
+        if (all.length === 0) return false;
+        all.sort((a, b) => a.seq - b.seq);
+        const last = all[all.length - 1];
+        const tx = db.transaction(DELTA_STORE, 'readwrite');
+        const done = transactionDone(tx);
+        tx.objectStore(DELTA_STORE).put({
+          seq: last.seq, epoch: last.epoch, hex: last.hex.slice(0, Math.max(0, last.hex.length - 8)),
+        });
+        await done;
+        return true;
+      } finally {
+        db.close();
+      }
+    },
+  };
+}