@statewalker/cellb 0.0.0-stage → 0.1.0

package/dist/ltx/ltx-page-server.js

@@ -0,0 +1,309 @@
+import { scopeOf } from "../core/celld-schema.js";
+import { ltxFileName } from "./ltx.js";
+import { compactPagedCellTo, encodeLtxStream, LtxShortReadError, openPagedCell, } from "./ltx-pages.js";
+/** Bytes of page data a cell's files hold (what a compaction may write, at most). */
+const pageBytes = (c) => c.files.reduce((n, f) => n + [...f.index.values()].reduce((m, [, size]) => m + size, 0), 0);
+/** Free bytes in this origin's storage, or undefined where the estimate is not available. */
+async function room() {
+    const storage = globalThis.navigator?.storage;
+    if (!storage?.estimate)
+        return undefined;
+    const { usage = 0, quota } = await storage.estimate();
+    return quota === undefined ? undefined : quota - usage;
+}
+export function ltxCellStore(files, sab, opts = {}) {
+    const ctl = new Int32Array(sab, 0, 2);
+    const payload = new Uint8Array(sab, 8);
+    const root = (opts.root ?? "").replace(/\/$/, "");
+    const compactAfter = opts.compactAfter ?? 64;
+    // celld's cell directory: `<Class>:<idHex>` (scopeOf), as the LTX log and celld name it.
+    const dirOf = (cell) => `${root}/cells/${scopeOf(cell).replace(/[\\/]/g, "_")}/ltx/e1/0000`;
+    const cells = new Map();
+    /** Where the store's time goes (ms), for traces. */
+    const stats = {
+        commits: 0,
+        writeMs: 0,
+        appendMs: 0,
+        compactions: 0,
+        compactMs: 0,
+        reads: 0,
+        readMs: 0,
+    };
+    const list = async (dir, cleanUp = false) => {
+        const out = [];
+        if (!(await files.exists(dir)))
+            return out;
+        for await (const e of files.list(dir)) {
+            if (e.kind !== "file")
+                continue;
+            if (e.name.endsWith(".ltx"))
+                out.push(e.path);
+            // On this store's first open of the cell: a compaction or a write that did not finish
+            // (a closed tab, a full disk), its space back.
+            else if (cleanUp && /\.ltx\.(tmp|part-\w+)$/.test(e.name))
+                await files.remove(e.path).catch(() => false);
+        }
+        return out;
+    };
+    /**
+     * One writer per cell in the origin: the store holds a Web Lock per cell directory while the
+     * cell is open, so another tab's store (or worker) cannot write the same cell meanwhile; it
+     * fails instead. (Across machines, celld's epochs and ownership records do this.)
+     */
+    const owned = new Set();
+    const own = async (dir) => {
+        const locks = globalThis.navigator?.locks;
+        if (!locks || owned.has(dir))
+            return;
+        // Waits a while for it: on a reload, the previous page's store holds it until its worker
+        // goes, a moment later (failing at once broke the cell's Durable Object on every reload).
+        const got = await new Promise((resolve) => {
+            void locks
+                .request(`cellb-ltx:${opts.lockScope ?? ""}:${dir}`, { signal: AbortSignal.timeout(20_000) }, () => {
+                resolve(true);
+                return new Promise(() => { }); // held while this store lives
+            })
+                .catch(() => resolve(false));
+        });
+        if (!got)
+            throw new Error(`ltx: cell ${dir} is open in another tab or worker (waited 20 s)`);
+        owned.add(dir);
+    };
+    const cellOf = async (cell) => {
+        if (!cells.has(cell)) {
+            const dir = dirOf(cell);
+            const first = !owned.has(dir);
+            await own(dir);
+            const paths = await list(dir, first);
+            cells.set(cell, paths.length ? await openPagedCell(files, paths) : undefined);
+        }
+        return cells.get(cell);
+    };
+    const answer = (bytes, state = 1) => {
+        payload.set(bytes);
+        ctl[1] = bytes.length;
+        Atomics.store(ctl, 0, state);
+        Atomics.notify(ctl, 0);
+    };
+    const enc = new TextEncoder();
+    let queue = Promise.resolve();
+    /** The request being served and its stage: a watchdog names the one that does not end. */
+    const current = { op: "", cell: "", stage: "", since: 0 };
+    const stage = (s) => {
+        current.stage = s;
+    };
+    const watchdog = setInterval(() => {
+        if (current.op && performance.now() - current.since > 10_000)
+            console.warn(`cellb ltx-store: ${current.op} of ${current.cell} at "${current.stage}" for ${Math.round((performance.now() - current.since) / 1000)} s`);
+    }, 10_000);
+    watchdog.unref?.();
+    /**
+     * Folds a cell's files into one snapshot WITHOUT holding up its requests: the snapshot is
+     * written from a frozen view of the files as they are now (later commits add files after
+     * them), then, between two requests, the files it replaces are removed and the cell reopened
+     * (the snapshot plus the files written meanwhile). One compaction per cell at a time.
+     */
+    const compacting = new Map();
+    const compact = (cell) => {
+        const running = compacting.get(cell);
+        if (running)
+            return running;
+        const job = (async () => {
+            const c = await cellOf(cell);
+            if (!c || c.files.length < 2)
+                return c?.files.length ?? 0;
+            const dir = dirOf(cell);
+            const replaced = c.files.map((f) => f.path);
+            // The new snapshot exists beside the files it replaces until the swap: without the room
+            // for it, the compaction would only fill the disk (and fail the commits after it).
+            const needed = pageBytes(c);
+            const free = await room();
+            if (free !== undefined && free < needed * 1.25 + (64 << 20)) {
+                console.warn(`cellb ltx-store: ${cell}: no compaction, ${Math.round(free / 1e6)} MB free for a snapshot of up to ${Math.round(needed / 1e6)} MB`);
+                return c.files.length;
+            }
+            const frozen = await openPagedCell(files, replaced);
+            const final = `${dir}/${ltxFileName(1n, frozen.maxTXID)}`;
+            const tmp = `${final}.tmp`;
+            try {
+                await compactPagedCellTo(frozen, files, tmp); // page runs: memory stays at a run + index
+            }
+            catch (err) {
+                await files.remove(tmp).catch(() => false);
+                throw err;
+            }
+            await new Promise((resolve, reject) => {
+                queue = queue.then(async () => {
+                    try {
+                        for (const p of replaced)
+                            await files.remove(p);
+                        await files.move(tmp, final);
+                        cells.delete(cell);
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+            return (await cellOf(cell))?.files.length ?? 0;
+        })().finally(() => compacting.delete(cell));
+        compacting.set(cell, job);
+        return job;
+    };
+    /**
+     * When to compact: past `compactAfter` files, or once the files after the snapshot hold more
+     * bytes than half of it (a large cell is not rewritten for a few small commits).
+     */
+    const deltaBytes = new Map();
+    const wantsCompaction = (cell, c) => {
+        if (opts.autoCompact === false)
+            return false;
+        if (c.files.length >= compactAfter)
+            return true;
+        const snapshot = c.files[0];
+        const snapshotBytes = [...snapshot.index.values()].reduce((n, [, size]) => n + size, 0);
+        return c.files.length > 1 && (deltaBytes.get(cell) ?? 0) > Math.max(1 << 20, snapshotBytes / 2);
+    };
+    return {
+        /** Answers one request of a VFS (requests are served in order). */
+        handle(msg) {
+            queue = queue.then(async () => {
+                Object.assign(current, {
+                    op: msg.op,
+                    cell: msg.cell,
+                    stage: "open",
+                    since: performance.now(),
+                });
+                try {
+                    const c = await cellOf(msg.cell);
+                    stage("serve");
+                    if (msg.op === "meta")
+                        return answer(enc.encode(JSON.stringify({ pageSize: c?.pageSize ?? 0, pageCount: c?.pageCount ?? 0 })));
+                    // A read of a file that changed under the cell's view: reopen the cell, read again.
+                    const retried = async (read) => {
+                        try {
+                            return await read(c);
+                        }
+                        catch (err) {
+                            if (!(err instanceof LtxShortReadError))
+                                throw err;
+                            console.warn(`cellb ltx-store: ${msg.cell}: ${err.message}; reopening the cell`);
+                            cells.delete(msg.cell);
+                            stage("reopen");
+                            return read((await cellOf(msg.cell)));
+                        }
+                    };
+                    if (msg.op === "read")
+                        return answer(await retried((c) => c.readPage(msg.pgno)));
+                    if (msg.op === "readRun") {
+                        stats.reads++;
+                        const tr = performance.now();
+                        try {
+                            const run = await retried((c) => c.readRun(msg.pgno, msg.count));
+                            const size = c.pageSize;
+                            const out = new Uint8Array(run.size * size);
+                            const pgnos = [...run.keys()].sort((a, b) => a - b);
+                            for (const [i, p] of pgnos.entries())
+                                out.set(run.get(p), i * size);
+                            return answer(out);
+                        }
+                        finally {
+                            stats.readMs += performance.now() - tr;
+                        }
+                    }
+                    if (msg.op === "stats")
+                        return answer(enc.encode(JSON.stringify(stats)));
+                    if (msg.op === "commit") {
+                        const t0 = performance.now();
+                        const txid = (c?.maxTXID ?? 0n) + 1n;
+                        const path = `${dirOf(msg.cell)}/${ltxFileName(txid, txid)}`;
+                        const pages = msg.pages;
+                        const written = { index: new Map() };
+                        const header = {
+                            pageSize: msg.pageSize,
+                            commit: msg.pageCount,
+                            minTXID: txid,
+                            maxTXID: txid,
+                            timestamp: Date.now(),
+                            preApplyChecksum: 0n,
+                        };
+                        stage(`write ${path}`);
+                        await files.write(path, encodeLtxStream(header, (async function* () {
+                            yield* pages;
+                        })(), 0n, written));
+                        const t1 = performance.now();
+                        stage("append");
+                        // The first commit is the snapshot; later ones extend the overlay by one file.
+                        if (c)
+                            await c.append(path, { header: { flags: 2, ...header }, index: written.index });
+                        else
+                            cells.delete(msg.cell);
+                        answer(new Uint8Array());
+                        stats.commits++;
+                        stats.writeMs += t1 - t0;
+                        stats.appendMs += performance.now() - t1;
+                        // Past the threshold, fold the cell into one snapshot (after answering the commit).
+                        deltaBytes.set(msg.cell, (deltaBytes.get(msg.cell) ?? 0) +
+                            [...written.index.values()].reduce((n, [, size]) => n + size, 0));
+                        if (c && wantsCompaction(msg.cell, c) && !compacting.has(msg.cell)) {
+                            const t2 = performance.now();
+                            deltaBytes.set(msg.cell, 0);
+                            void compact(msg.cell).then(() => {
+                                stats.compactMs += performance.now() - t2;
+                            }, (err) => console.warn(`cellb ltx-store: compaction of ${msg.cell} failed:`, err));
+                            stats.compactions++;
+                        }
+                        return;
+                    }
+                    throw new Error(`unknown op ${msg.op}`);
+                }
+                catch (err) {
+                    console.warn(`cellb ltx-store: ${msg.op} of ${msg.cell} failed at "${current.stage}":`, err);
+                    answer(enc.encode(String(err?.message ?? err)), 2);
+                }
+                finally {
+                    current.op = "";
+                }
+            });
+        },
+        /** Folds a cell's files into one snapshot; answers its file count after. */
+        /** Folds a cell's files into one snapshot (not through the request queue: it takes its
+         * own turn there to swap the files); answers the cell's file count after. */
+        compact: (cell) => compact(cell),
+        stats,
+        /** The paths of a cell's current files. */
+        files: async (cell) => (await cellOf(cell))?.files.map((f) => f.path) ?? [],
+    };
+}
+/** One cell at `dir` (the earlier single-cell form): messages may omit `cell`. */
+export function ltxPageServer(files, dir, sab) {
+    const m = /^(.*)\/cells\/([^/]+)\/ltx\/e1\/0000$/.exec(dir);
+    const root = m ? m[1] : dir;
+    const name = m ? m[2] : "cell";
+    const store = ltxCellStore(files, sab, { root, autoCompact: false });
+    let count = 0;
+    const refresh = async () => {
+        count = (await store.files(name)).length;
+    };
+    return {
+        // A cell another store owns fails its requests (the VFS gets the error), not the start.
+        ready: refresh().catch(() => { }),
+        handle: (msg) => {
+            store.handle({ ...msg, cell: name });
+            void refresh();
+        },
+        compact: async () => {
+            const n = await store.compact(name);
+            count = n;
+            return n;
+        },
+        get files() {
+            return Array.from({ length: count });
+        },
+        stats: store.stats,
+        /** The cell's file count, after the requests sent so far. */
+        fileCount: async () => (await store.files(name)).length,
+    };
+}
+//# sourceMappingURL=ltx-page-server.js.map

package/dist/ltx/ltx-page-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltx-page-server.js","sourceRoot":"","sources":["../../src/ltx/ltx-page-server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The asynchronous side of the LTX VFS (src/adapters/ltx-vfs.ts): serves cells' pages from their\n * LTX files on a FilesApi and turns each commit into one LTX file there, in celld's layout\n * (`cells/<cell>/ltx/e1/0000/<min>-<max>.ltx`, a snapshot 1..N first). Runs in any thread that\n * is not one blocked on reads (a worker of its own, or a page): `handle(msg)` answers into the\n * shared buffer. A cell whose files pass `compactAfter` is folded into one snapshot (streamed).\n */\nimport type { FilesApi } from \"@statewalker/webrun-files\";\nimport { scopeOf } from \"../core/celld-schema.js\";\nimport { ltxFileName } from \"./ltx.js\";\nimport {\n  compactPagedCellTo,\n  encodeLtxStream,\n  LtxShortReadError,\n  openPagedCell,\n  type PagedCell,\n} from \"./ltx-pages.js\";\n\n/** Bytes of page data a cell's files hold (what a compaction may write, at most). */\nconst pageBytes = (c: PagedCell) =>\n  c.files.reduce((n, f) => n + [...f.index.values()].reduce((m, [, size]) => m + size, 0), 0);\n\n/** Free bytes in this origin's storage, or undefined where the estimate is not available. */\nasync function room(): Promise<number | undefined> {\n  const storage = (globalThis.navigator as { storage?: StorageManager } | undefined)?.storage;\n  if (!storage?.estimate) return undefined;\n  const { usage = 0, quota } = await storage.estimate();\n  return quota === undefined ? undefined : quota - usage;\n}\n\nexport interface LtxStoreMessage {\n  op: \"meta\" | \"read\" | \"readRun\" | \"commit\" | \"stats\";\n  cell: string;\n  pgno?: number;\n  count?: number;\n  pageSize?: number;\n  pageCount?: number;\n  pages?: [number, Uint8Array][];\n}\n\nexport function ltxCellStore(\n  files: FilesApi,\n  sab: SharedArrayBuffer,\n  opts: {\n    root?: string;\n    compactAfter?: number;\n    autoCompact?: boolean;\n    /**\n     * What the files are (the OPFS directory's name, say): part of each cell's Web Lock, so the\n     * stores of two directories (two projects in one tab) do not take each other's locks.\n     */\n    lockScope?: string;\n  } = {},\n) {\n  const ctl = new Int32Array(sab, 0, 2);\n  const payload = new Uint8Array(sab, 8);\n  const root = (opts.root ?? \"\").replace(/\\/$/, \"\");\n  const compactAfter = opts.compactAfter ?? 64;\n  // celld's cell directory: `<Class>:<idHex>` (scopeOf), as the LTX log and celld name it.\n  const dirOf = (cell: string) =>\n    `${root}/cells/${scopeOf(cell).replace(/[\\\\/]/g, \"_\")}/ltx/e1/0000`;\n  const cells = new Map<string, PagedCell | undefined>();\n  /** Where the store's time goes (ms), for traces. */\n  const stats = {\n    commits: 0,\n    writeMs: 0,\n    appendMs: 0,\n    compactions: 0,\n    compactMs: 0,\n    reads: 0,\n    readMs: 0,\n  };\n  const list = async (dir: string, cleanUp = false) => {\n    const out: string[] = [];\n    if (!(await files.exists(dir))) return out;\n    for await (const e of files.list(dir)) {\n      if (e.kind !== \"file\") continue;\n      if (e.name.endsWith(\".ltx\")) out.push(e.path);\n      // On this store's first open of the cell: a compaction or a write that did not finish\n      // (a closed tab, a full disk), its space back.\n      else if (cleanUp && /\\.ltx\\.(tmp|part-\\w+)$/.test(e.name))\n        await files.remove(e.path).catch(() => false);\n    }\n    return out;\n  };\n  /**\n   * One writer per cell in the origin: the store holds a Web Lock per cell directory while the\n   * cell is open, so another tab's store (or worker) cannot write the same cell meanwhile; it\n   * fails instead. (Across machines, celld's epochs and ownership records do this.)\n   */\n  const owned = new Set<string>();\n  const own = async (dir: string) => {\n    const locks = (globalThis.navigator as { locks?: LockManager } | undefined)?.locks;\n    if (!locks || owned.has(dir)) return;\n    // Waits a while for it: on a reload, the previous page's store holds it until its worker\n    // goes, a moment later (failing at once broke the cell's Durable Object on every reload).\n    const got = await new Promise<boolean>((resolve) => {\n      void locks\n        .request(\n          `cellb-ltx:${opts.lockScope ?? \"\"}:${dir}`,\n          { signal: AbortSignal.timeout(20_000) },\n          () => {\n            resolve(true);\n            return new Promise<void>(() => {}); // held while this store lives\n          },\n        )\n        .catch(() => resolve(false));\n    });\n    if (!got) throw new Error(`ltx: cell ${dir} is open in another tab or worker (waited 20 s)`);\n    owned.add(dir);\n  };\n  const cellOf = async (cell: string) => {\n    if (!cells.has(cell)) {\n      const dir = dirOf(cell);\n      const first = !owned.has(dir);\n      await own(dir);\n      const paths = await list(dir, first);\n      cells.set(cell, paths.length ? await openPagedCell(files, paths) : undefined);\n    }\n    return cells.get(cell);\n  };\n  const answer = (bytes: Uint8Array, state = 1) => {\n    payload.set(bytes);\n    ctl[1] = bytes.length;\n    Atomics.store(ctl, 0, state);\n    Atomics.notify(ctl, 0);\n  };\n  const enc = new TextEncoder();\n  let queue = Promise.resolve();\n  /** The request being served and its stage: a watchdog names the one that does not end. */\n  const current = { op: \"\", cell: \"\", stage: \"\", since: 0 };\n  const stage = (s: string) => {\n    current.stage = s;\n  };\n  const watchdog = setInterval(() => {\n    if (current.op && performance.now() - current.since > 10_000)\n      console.warn(\n        `cellb ltx-store: ${current.op} of ${current.cell} at \"${current.stage}\" for ${Math.round((performance.now() - current.since) / 1000)} s`,\n      );\n  }, 10_000);\n  (watchdog as { unref?: () => void }).unref?.();\n\n  /**\n   * Folds a cell's files into one snapshot WITHOUT holding up its requests: the snapshot is\n   * written from a frozen view of the files as they are now (later commits add files after\n   * them), then, between two requests, the files it replaces are removed and the cell reopened\n   * (the snapshot plus the files written meanwhile). One compaction per cell at a time.\n   */\n  const compacting = new Map<string, Promise<number>>();\n  const compact = (cell: string): Promise<number> => {\n    const running = compacting.get(cell);\n    if (running) return running;\n    const job = (async () => {\n      const c = await cellOf(cell);\n      if (!c || c.files.length < 2) return c?.files.length ?? 0;\n      const dir = dirOf(cell);\n      const replaced = c.files.map((f) => f.path);\n      // The new snapshot exists beside the files it replaces until the swap: without the room\n      // for it, the compaction would only fill the disk (and fail the commits after it).\n      const needed = pageBytes(c);\n      const free = await room();\n      if (free !== undefined && free < needed * 1.25 + (64 << 20)) {\n        console.warn(\n          `cellb ltx-store: ${cell}: no compaction, ${Math.round(free / 1e6)} MB free for a snapshot of up to ${Math.round(needed / 1e6)} MB`,\n        );\n        return c.files.length;\n      }\n      const frozen = await openPagedCell(files, replaced);\n      const final = `${dir}/${ltxFileName(1n, frozen.maxTXID)}`;\n      const tmp = `${final}.tmp`;\n      try {\n        await compactPagedCellTo(frozen, files, tmp); // page runs: memory stays at a run + index\n      } catch (err) {\n        await files.remove(tmp).catch(() => false);\n        throw err;\n      }\n      await new Promise<void>((resolve, reject) => {\n        queue = queue.then(async () => {\n          try {\n            for (const p of replaced) await files.remove(p);\n            await files.move(tmp, final);\n            cells.delete(cell);\n            resolve();\n          } catch (err) {\n            reject(err);\n          }\n        });\n      });\n      return (await cellOf(cell))?.files.length ?? 0;\n    })().finally(() => compacting.delete(cell));\n    compacting.set(cell, job);\n    return job;\n  };\n\n  /**\n   * When to compact: past `compactAfter` files, or once the files after the snapshot hold more\n   * bytes than half of it (a large cell is not rewritten for a few small commits).\n   */\n  const deltaBytes = new Map<string, number>();\n  const wantsCompaction = (cell: string, c: PagedCell) => {\n    if (opts.autoCompact === false) return false;\n    if (c.files.length >= compactAfter) return true;\n    const snapshot = c.files[0];\n    const snapshotBytes = [...snapshot.index.values()].reduce((n, [, size]) => n + size, 0);\n    return c.files.length > 1 && (deltaBytes.get(cell) ?? 0) > Math.max(1 << 20, snapshotBytes / 2);\n  };\n\n  return {\n    /** Answers one request of a VFS (requests are served in order). */\n    handle(msg: LtxStoreMessage) {\n      queue = queue.then(async () => {\n        Object.assign(current, {\n          op: msg.op,\n          cell: msg.cell,\n          stage: \"open\",\n          since: performance.now(),\n        });\n        try {\n          const c = await cellOf(msg.cell);\n          stage(\"serve\");\n          if (msg.op === \"meta\")\n            return answer(\n              enc.encode(\n                JSON.stringify({ pageSize: c?.pageSize ?? 0, pageCount: c?.pageCount ?? 0 }),\n              ),\n            );\n          // A read of a file that changed under the cell's view: reopen the cell, read again.\n          const retried = async <T>(read: (c: PagedCell) => Promise<T>): Promise<T> => {\n            try {\n              return await read(c as PagedCell);\n            } catch (err) {\n              if (!(err instanceof LtxShortReadError)) throw err;\n              console.warn(`cellb ltx-store: ${msg.cell}: ${err.message}; reopening the cell`);\n              cells.delete(msg.cell);\n              stage(\"reopen\");\n              return read((await cellOf(msg.cell)) as PagedCell);\n            }\n          };\n          if (msg.op === \"read\")\n            return answer(await retried((c) => c.readPage(msg.pgno as number)));\n          if (msg.op === \"readRun\") {\n            stats.reads++;\n            const tr = performance.now();\n            try {\n              const run = await retried((c) => c.readRun(msg.pgno as number, msg.count as number));\n              const size = (c as PagedCell).pageSize;\n              const out = new Uint8Array(run.size * size);\n              const pgnos = [...run.keys()].sort((a, b) => a - b);\n              for (const [i, p] of pgnos.entries()) out.set(run.get(p) as Uint8Array, i * size);\n              return answer(out);\n            } finally {\n              stats.readMs += performance.now() - tr;\n            }\n          }\n          if (msg.op === \"stats\") return answer(enc.encode(JSON.stringify(stats)));\n          if (msg.op === \"commit\") {\n            const t0 = performance.now();\n            const txid = (c?.maxTXID ?? 0n) + 1n;\n            const path = `${dirOf(msg.cell)}/${ltxFileName(txid, txid)}`;\n            const pages = msg.pages as [number, Uint8Array][];\n            const written = { index: new Map<number, [number, number]>() };\n            const header = {\n              pageSize: msg.pageSize as number,\n              commit: msg.pageCount as number,\n              minTXID: txid,\n              maxTXID: txid,\n              timestamp: Date.now(),\n              preApplyChecksum: 0n,\n            };\n            stage(`write ${path}`);\n            await files.write(\n              path,\n              encodeLtxStream(\n                header,\n                (async function* () {\n                  yield* pages;\n                })(),\n                0n,\n                written,\n              ),\n            );\n            const t1 = performance.now();\n            stage(\"append\");\n            // The first commit is the snapshot; later ones extend the overlay by one file.\n            if (c) await c.append(path, { header: { flags: 2, ...header }, index: written.index });\n            else cells.delete(msg.cell);\n            answer(new Uint8Array());\n            stats.commits++;\n            stats.writeMs += t1 - t0;\n            stats.appendMs += performance.now() - t1;\n            // Past the threshold, fold the cell into one snapshot (after answering the commit).\n            deltaBytes.set(\n              msg.cell,\n              (deltaBytes.get(msg.cell) ?? 0) +\n                [...written.index.values()].reduce((n, [, size]) => n + size, 0),\n            );\n            if (c && wantsCompaction(msg.cell, c) && !compacting.has(msg.cell)) {\n              const t2 = performance.now();\n              deltaBytes.set(msg.cell, 0);\n              void compact(msg.cell).then(\n                () => {\n                  stats.compactMs += performance.now() - t2;\n                },\n                (err) => console.warn(`cellb ltx-store: compaction of ${msg.cell} failed:`, err),\n              );\n              stats.compactions++;\n            }\n            return;\n          }\n          throw new Error(`unknown op ${msg.op}`);\n        } catch (err) {\n          console.warn(\n            `cellb ltx-store: ${msg.op} of ${msg.cell} failed at \"${current.stage}\":`,\n            err,\n          );\n          answer(enc.encode(String((err as Error)?.message ?? err)), 2);\n        } finally {\n          current.op = \"\";\n        }\n      });\n    },\n    /** Folds a cell's files into one snapshot; answers its file count after. */\n    /** Folds a cell's files into one snapshot (not through the request queue: it takes its\n     * own turn there to swap the files); answers the cell's file count after. */\n    compact: (cell: string) => compact(cell),\n    stats,\n    /** The paths of a cell's current files. */\n    files: async (cell: string) => (await cellOf(cell))?.files.map((f) => f.path) ?? [],\n  };\n}\n\n/** One cell at `dir` (the earlier single-cell form): messages may omit `cell`. */\nexport function ltxPageServer(files: FilesApi, dir: string, sab: SharedArrayBuffer) {\n  const m = /^(.*)\\/cells\\/([^/]+)\\/ltx\\/e1\\/0000$/.exec(dir);\n  const root = m ? m[1] : dir;\n  const name = m ? m[2] : \"cell\";\n  const store = ltxCellStore(files, sab, { root, autoCompact: false });\n  let count = 0;\n  const refresh = async () => {\n    count = (await store.files(name)).length;\n  };\n  return {\n    // A cell another store owns fails its requests (the VFS gets the error), not the start.\n    ready: refresh().catch(() => {}),\n    handle: (msg: Omit<LtxStoreMessage, \"cell\"> & { cell?: string }) => {\n      store.handle({ ...msg, cell: name } as LtxStoreMessage);\n      void refresh();\n    },\n    compact: async () => {\n      const n = await store.compact(name);\n      count = n;\n      return n;\n    },\n    get files() {\n      return Array.from({ length: count });\n    },\n    stats: store.stats,\n    /** The cell's file count, after the requests sent so far. */\n    fileCount: async () => (await store.files(name)).length,\n  };\n}\n"]}

package/dist/ltx/ltx-pages.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Page-level random access to a cell kept as celld keeps it: LTX files in a bucket
+ * (`…/ltx/e<epoch>/<level>/<min>-<max>.ltx`), a snapshot (TXID 1..N) and the incremental files
+ * after it. Nothing is read whole: an LTX file ends with a page index (pgno → offset, size), so
+ * opening a file reads its 100-byte header and its index, and a page is ONE range read plus an
+ * LZ4 decode. The newest file holding a page wins; `compact` folds them into a new snapshot.
+ *
+ * This is the read side a SQLite VFS needs to serve a database from any FilesApi (OPFS, File
+ * System Access, IndexedDB, S3…) without loading it: xRead → `readPage` (through a page cache);
+ * the write side is the existing LTX log (one incremental file per commit).
+ */
+import type { FilesApi } from "@statewalker/webrun-files";
+import { type LtxHeader } from "./ltx.js";
+/** A range read that got fewer bytes than asked: the file changed or was removed meanwhile. */
+export declare class LtxShortReadError extends Error {
+    name: string;
+}
+export interface LtxPages {
+    path: string;
+    header: LtxHeader;
+    /** pgno → [offset of the page's 6-byte header, size including it]. */
+    index: Map<number, [number, number]>;
+    /** One range read and an LZ4 decode. */
+    readPage(pgno: number): Promise<Uint8Array | undefined>;
+    /** Several pages of this file with ONE range read (they are stored in pgno order). */
+    readPages(pgnos: number[]): Promise<Map<number, Uint8Array>>;
+}
+/** Opens an LTX file for page reads: reads its header and its page index only. */
+export declare function openLtxPages(files: FilesApi, path: string, 
+/** The header and index of a file this process just wrote: nothing is read back. */
+known?: {
+    header: LtxHeader;
+    index: Map<number, [number, number]>;
+}): Promise<LtxPages>;
+export interface PagedCell {
+    pageSize: number;
+    /** Database size in pages, after the newest file. */
+    pageCount: number;
+    maxTXID: bigint;
+    /** The files, oldest first (the snapshot, then the incremental ones). */
+    files: LtxPages[];
+    /** The page as of the newest file holding it (zeros past the database end). */
+    readPage(pgno: number): Promise<Uint8Array>;
+    /** Pages `from`..`from+count-1` (within the database), one range read per file they live in. */
+    readRun(from: number, count: number): Promise<Map<number, Uint8Array>>;
+    /** Which file serves each page (for tests and traces). */
+    source(pgno: number): string | undefined;
+    /**
+     * Adds the cell's next file (the one just written after `maxTXID`): reads its header and index
+     * only, so a commit costs one file whatever the number of files before it.
+     */
+    append(path: string, known?: {
+        header: LtxHeader;
+        index: Map<number, [number, number]>;
+    }): Promise<void>;
+}
+/**
+ * A cell's pages over its LTX files: the newest snapshot (min TXID 1) and the files after it,
+ * in TXID order. Only headers and page indexes are read.
+ */
+export declare function openPagedCell(files: FilesApi, paths: string[]): Promise<PagedCell>;
+/**
+ * An LTX file produced page by page, as celld writes it (block format: size-prefixed LZ4 page
+ * blocks, page index, trailer, CRC-64/ISO over the uncompressed pages): the bytes come out as an
+ * async stream while `pages` is consumed, so a writer holds one page at a time plus the index
+ * (a few bytes per page), never the database.
+ */
+export declare function encodeLtxStream(header: LtxHeader, pages: AsyncIterable<[number, Uint8Array]>, postApplyChecksum?: bigint, 
+/** Filled while encoding: the file's page index (what `openLtxPages` would read back). */
+written?: {
+    index: Map<number, [number, number]>;
+}): AsyncGenerator<Uint8Array>;
+/**
+ * Folds a cell's files into one snapshot (TXID 1..maxTXID) written to `files` at `path`, page by
+ * page: each page is read by range from the file that holds it and streamed into the new file,
+ * so memory stays at one page (plus the index), whatever the database size. The caller removes
+ * the files it replaces once this resolves.
+ */
+export declare function compactPagedCellTo(cell: PagedCell, files: FilesApi, path: string, timestamp?: number): Promise<void>;
+/** The compacted snapshot as bytes (small cells, tests); compactPagedCellTo streams it. */
+export declare function compactPagedCell(cell: PagedCell, timestamp?: number): Promise<Uint8Array>;