@code-yeongyu/senpi 2026.10.26-1 → 2026.10.27-1

package/dist/modes/rpc/compact-content-index.js

@@ -0,0 +1,243 @@
+import { CompactCommitDependencies } from "./compact-commit-dependencies.js";
+import { isSmallPage, packPages } from "./compact-index-pages.js";
+import { CompactReadError } from "./compact-read-lease.js";
+export class CompactContentIndex {
+    constructor(store, leavesOf, compactAboveRows) {
+        this.base = { pages: [], pageOf: new Map() };
+        this.overrides = new Map();
+        this.compacting = false;
+        this.tombstones = 0;
+        this.tombstoneKeyUnits = 0;
+        this.frozen = new WeakSet();
+        this.store = store;
+        this.leavesOf = leavesOf;
+        this.compactAboveRows = compactAboveRows;
+        this.unsettledLeaves = new CompactCommitDependencies(store, () => this.maybeCompact());
+    }
+    has(key) {
+        const override = this.overrides.get(key);
+        return override ? override.kind !== "tombstone" : this.base.pageOf.has(key);
+    }
+    set(key, row) {
+        this.put(key, { kind: "row", row });
+    }
+    patch(key, fields) {
+        const current = this.overrides.get(key);
+        if (current?.kind === "row")
+            this.put(key, { kind: "row", row: { ...current.row, ...fields } });
+        else if (current?.kind === "patch")
+            this.put(key, { kind: "patch", patch: { ...current.patch, ...fields } });
+        else
+            this.put(key, { kind: "patch", patch: fields });
+    }
+    /** A key only the overlay ever held leaves no tombstone; a committed one is masked until compaction. */
+    delete(key) {
+        if (this.base.pageOf.has(key))
+            this.put(key, { kind: "tombstone" });
+        else
+            this.drop(key);
+    }
+    freeze() {
+        for (const page of this.base.pages)
+            page.pins++;
+        for (const override of this.overrides.values())
+            this.pinRow(override, 1);
+        const frozen = { base: this.base, overrides: new Map(this.overrides) };
+        this.frozen.add(frozen);
+        return frozen;
+    }
+    release(frozen) {
+        if (!this.frozen.delete(frozen))
+            return;
+        for (const override of frozen.overrides.values())
+            this.pinRow(override, -1);
+        for (const page of frozen.base.pages) {
+            page.pins--;
+            if (!page.inBase && page.pins === 0)
+                this.reclaimPage(page, 0, -1);
+        }
+    }
+    /** Every row visible at a frozen root, reading only that root's own pages. */
+    async entries(frozen) {
+        if (!this.frozen.has(frozen))
+            throw new CompactReadError("released");
+        const rows = new Map();
+        for (const page of frozen.base.pages)
+            for (const [key, row] of await this.readPage(page))
+                rows.set(key, row);
+        applyOverrides(rows, frozen.overrides);
+        return rows;
+    }
+    status() {
+        return {
+            overrideSlots: this.overrides.size,
+            deletionMasks: this.tombstones,
+            deletionMaskBytes: this.tombstoneKeyUnits * 2,
+            basePages: this.base.pages.length,
+            baseRows: this.base.pageOf.size,
+        };
+    }
+    /** The acceptance path checks counts only: an override is eligible once none of its leaves is uncommitted. */
+    maybeCompact() {
+        if (this.compacting || !this.store.spillAllowed)
+            return;
+        if (this.overrides.size - this.unsettledLeaves.size < this.compactAboveRows)
+            return;
+        this.compacting = true;
+        this.store.enqueue("page_write", async () => {
+            let progressed = false;
+            try {
+                progressed = await this.compact();
+            }
+            finally {
+                this.compacting = false;
+            }
+            if (progressed)
+                this.maybeCompact();
+        });
+    }
+    /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
+    async compact() {
+        const base = this.base;
+        const selected = [...this.overrides].filter(([key]) => !this.unsettledLeaves.has(key));
+        if (selected.length < this.compactAboveRows)
+            return false;
+        const touched = new Set(base.pages.filter(isSmallPage));
+        for (const [key] of selected) {
+            const page = base.pageOf.get(key);
+            if (page)
+                touched.add(page);
+        }
+        const rows = new Map();
+        try {
+            for (const page of touched)
+                for (const [key, row] of await this.readPage(page))
+                    rows.set(key, row);
+        }
+        catch {
+            return false;
+        }
+        applyOverrides(rows, new Map(selected));
+        const written = [];
+        for (const chunk of packPages([...rows])) {
+            const data = Buffer.from(JSON.stringify(chunk));
+            const path = await this.store.writeFile(data, "page_write", data.byteLength);
+            if (path === undefined || !this.store.spillAllowed) {
+                for (const page of written)
+                    this.store.discard(page.path, page.bytes);
+                if (path !== undefined)
+                    this.store.discard(path, data.byteLength);
+                return false;
+            }
+            written.push({ path, bytes: data.byteLength, rows: chunk });
+        }
+        this.swap(base, touched, written, new Map(selected));
+        return true;
+    }
+    /**
+     * The publication point: one synchronous step, so no acceptance observes a half-swapped index. A folded
+     * row is published only while its value is still observable (its override is the folded one, or a newer
+     * patch over it); a row removed or wholly replaced meanwhile is skipped, so every published leaf is still
+     * owned by the folded override or a touched page when its reference is added.
+     */
+    swap(base, touched, written, selected) {
+        const pageOf = new Map(base.pageOf);
+        for (const page of touched)
+            for (const key of page.keys)
+                pageOf.delete(key);
+        const published = [];
+        for (const { path, bytes, rows } of written) {
+            const kept = rows.filter(([key]) => {
+                const folded = selected.get(key);
+                const current = this.overrides.get(key);
+                return folded === undefined || current === folded || current?.kind === "patch";
+            });
+            if (kept.length === 0) {
+                this.store.discard(path, bytes);
+                continue;
+            }
+            const leaves = kept.flatMap(([, row]) => this.leavesOf(row));
+            const page = { path, bytes, keys: kept.map(([key]) => key), leaves, inBase: true, pins: 0 };
+            for (const key of page.keys)
+                pageOf.set(key, page);
+            for (const id of leaves)
+                this.store.adjust(id, 1, 0);
+            published.push(page);
+        }
+        this.base = { pages: [...base.pages.filter((page) => !touched.has(page)), ...published], pageOf };
+        for (const [key, override] of selected) {
+            const current = this.overrides.get(key);
+            if (current === override || (current?.kind === "tombstone" && !pageOf.has(key)))
+                this.drop(key);
+        }
+        for (const page of touched) {
+            page.inBase = false;
+            if (page.pins === 0)
+                this.reclaimPage(page, -1, 0);
+            else
+                for (const id of page.leaves)
+                    this.store.adjust(id, -1, 1);
+        }
+    }
+    async readPage(page) {
+        const data = await this.store.readFile(page.path, page.bytes, "page_read");
+        const entries = JSON.parse(data.toString("utf8"));
+        if (entries.length === page.keys.length)
+            return entries;
+        const keys = new Set(page.keys);
+        return entries.filter(([key]) => keys.has(key));
+    }
+    reclaimPage(page, live, pins) {
+        for (const id of page.leaves)
+            this.store.adjust(id, live, pins);
+        this.store.discard(page.path, page.bytes);
+    }
+    put(key, override) {
+        const leaves = override.kind === "row" ? this.leavesOf(override.row) : [];
+        for (const id of leaves)
+            this.store.adjust(id, 1, 0);
+        this.drop(key);
+        this.overrides.set(key, override);
+        this.unsettledLeaves.set(key, leaves);
+        if (override.kind === "tombstone")
+            this.countTombstone(key, 1);
+        this.maybeCompact();
+    }
+    drop(key) {
+        const old = this.overrides.get(key);
+        if (!old)
+            return;
+        this.overrides.delete(key);
+        this.unsettledLeaves.delete(key);
+        if (old.kind === "row") {
+            for (const id of this.leavesOf(old.row)) {
+                this.store.adjust(id, -1, 0);
+            }
+        }
+        if (old.kind === "tombstone")
+            this.countTombstone(key, -1);
+    }
+    countTombstone(key, delta) {
+        this.tombstones += delta;
+        this.tombstoneKeyUnits += delta * key.length;
+    }
+    pinRow(override, delta) {
+        if (override.kind === "row")
+            for (const id of this.leavesOf(override.row))
+                this.store.adjust(id, 0, delta);
+    }
+}
+function applyOverrides(rows, overrides) {
+    for (const [key, override] of overrides) {
+        if (override.kind === "tombstone")
+            rows.delete(key);
+        else if (override.kind === "row")
+            rows.set(key, override.row);
+        else {
+            const row = rows.get(key);
+            if (row)
+                rows.set(key, { ...row, ...override.patch });
+        }
+    }
+}
+//# sourceMappingURL=compact-content-index.js.map

package/dist/modes/rpc/compact-content-store.d.ts

@@ -1,4 +1,6 @@
+import { CompactSpoolStorage } from "./compact-spool-storage.ts";
 import { type CompactStorageFailure, type CompactStorageIo } from "./compact-storage-io.ts";
+import { CompactTextRoots } from "./compact-text-roots.ts";
 /**
  * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
  *
@@ -30,67 +32,32 @@ export interface CompactContentStoreOptions {
     readonly spillAboveBytes?: number;
     readonly spillTargetBytes?: number;
 }
-export declare class CompactContentStore {
-    readonly dir: string;
-    private readonly io;
+export declare class CompactContentStore extends CompactSpoolStorage {
     private readonly spillAboveBytes;
     private readonly spillTargetBytes;
     private readonly leaves;
     /** Resident leaves in creation order, so each spill takes the oldest without rescanning committed ones. */
     private readonly ramLeaves;
-    private readonly failures;
     private nextLeafId;
-    private nextFile;
-    private dirReady;
-    private spoolToken;
-    private chain;
-    private queued;
-    private spillQueued;
-    private halted;
-    private retired;
     private residentPayloadBytes;
-    private pendingIoCopyBytes;
     private pinnedOnlyBytes;
     private spilledLiveBytes;
-    private spillBytesWritten;
-    private reclaimDebtBytes;
+    private readonly subscribers;
+    readonly text: CompactTextRoots;
+    subscribeCommitted(listener: (id: LeafId) => void): void;
+    committed(id: LeafId): void;
+    leafUnits(id: LeafId): number;
     constructor(options: CompactContentStoreOptions);
     /** Takes ownership of an immutable value with one live reference. */
     createLeaf(text: string): LeafId;
     /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
     adjust(id: LeafId, live: number, pins: number): void;
+    isCommitted(id: LeafId): boolean;
     /** Reads a leaf the caller still references, from RAM or its committed file. */
     readLeaf(id: LeafId): Promise<string>;
-    /** Resolves once every queued storage job, including the ones they queued, has completed. */
-    idle(): Promise<void>;
-    /**
-     * Invalidates spilling, joins owned I/O, then removes the epoch directory only when this store
-     * created it and it still passes the ownership checks; otherwise rejects with `CompactSpoolRefusedError`.
-     */
-    retire(): Promise<void>;
     status(): CompactStorageStatus;
-    /** Reads a committed file and rejects a missing, unreadable or short one. */
-    private readFile;
-    /** Writes one new spool file; undefined means the write failed, was reported, and spilling halted. */
-    private writeFile;
-    /**
-     * An unreferenced (or partially written) spool file: reclamation debt until its unlink completes or
-     * finds it gone. Files dropped after retirement started belong to the directory retirement removes.
-     */
-    private discard;
-    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
-    private reclaim;
-    private get spillAllowed();
-    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
-    private get spillStopped();
-    private enqueue;
-    private scheduleSpill;
+    protected scheduleSpill(): void;
     /** Spills one oldest resident leaf per job, so other storage work interleaves fairly. */
     private spillNext;
-    /** Creates the private epoch directory once; a refusal or failure halts spilling and is reported. */
-    private ensureDir;
-    private readFailure;
-    private fail;
-    private record;
 }
 //# sourceMappingURL=compact-content-store.d.ts.map

package/dist/modes/rpc/compact-content-store.js

@@ -1,6 +1,7 @@
-import { join } from "node:path";
-import { createSpoolDir, removeSpoolDir } from "./compact-spool-dir.js";
-import { CompactStorageReadError, describeCause, nodeCompactStorageIo, } from "./compact-storage-io.js";
+import { CompactSpoolStorage, RECLAIM_WORK_ALLOWANCE_BYTES } from "./compact-spool-storage.js";
+import { nodeCompactStorageIo } from "./compact-storage-io.js";
+import { CompactReadError } from "./compact-read-lease.js";
+import { CompactTextRoots } from "./compact-text-roots.js";
 /**
  * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
  *
@@ -11,35 +12,39 @@ import { CompactStorageReadError, describeCause, nodeCompactStorageIo, } from ".
  */
 /** 32,768 UTF-16 code units (64 KiB as UTF-16LE), so a split surrogate survives a leaf boundary exactly. */
 export const COMPACT_LEAF_CODE_UNITS = 32_768;
-const RECLAIM_WORK_ALLOWANCE_BYTES = 1024 * 1024;
-const RECLAIM_RETRY_DELAYS_MS = [100, 400, 1_600, 6_400, 25_600];
-const FAILURE_HISTORY = 32;
-export class CompactContentStore {
+export class CompactContentStore extends CompactSpoolStorage {
+    subscribeCommitted(listener) {
+        this.subscribers.add(listener);
+    }
+    committed(id) {
+        for (const listener of this.subscribers)
+            listener(id);
+    }
+    leafUnits(id) {
+        const leaf = this.leaves.get(id);
+        if (!leaf)
+            throw new CompactReadError("ownership");
+        return leaf.units;
+    }
     constructor(options) {
+        super(options.dir, options.io ?? nodeCompactStorageIo);
         this.leaves = new Map();
         /** Resident leaves in creation order, so each spill takes the oldest without rescanning committed ones. */
         this.ramLeaves = new Set();
-        this.failures = [];
         this.nextLeafId = 1;
-        this.nextFile = 1;
-        this.chain = Promise.resolve();
-        this.queued = 0;
-        this.spillQueued = false;
-        this.halted = false;
-        this.retired = false;
         this.residentPayloadBytes = 0;
-        this.pendingIoCopyBytes = 0;
         this.pinnedOnlyBytes = 0;
         this.spilledLiveBytes = 0;
-        this.spillBytesWritten = 0;
-        this.reclaimDebtBytes = 0;
-        this.dir = options.dir;
-        this.io = options.io ?? nodeCompactStorageIo;
+        this.subscribers = new Set();
+        this.text = new CompactTextRoots(this);
         this.spillAboveBytes = options.spillAboveBytes ?? 4 * 1024 * 1024;
         this.spillTargetBytes = options.spillTargetBytes ?? 2 * 1024 * 1024;
     }
     /** Takes ownership of an immutable value with one live reference. */
     createLeaf(text) {
+        this.assertReadable();
+        if (text.length > COMPACT_LEAF_CODE_UNITS)
+            throw new CompactReadError("size_limit");
         const id = this.nextLeafId++;
         this.leaves.set(id, { text, units: text.length, live: 1, pins: 0, state: "ram" });
         this.ramLeaves.add(id);
@@ -49,9 +54,13 @@ export class CompactContentStore {
     }
     /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
     adjust(id, live, pins) {
+        if (id === 0)
+            return;
+        if (id < 0)
+            return this.text.adjust(id, live, pins);
         const leaf = this.leaves.get(id);
-        if (!leaf)
-            throw new Error(`compact leaf ${id} is not owned`);
+        if (!leaf || leaf.live + live < 0 || leaf.pins + pins < 0)
+            throw new CompactReadError("ownership");
         const pinnedOnly = leaf.live === 0 && leaf.pins > 0;
         leaf.live += live;
         leaf.pins += pins;
@@ -68,31 +77,26 @@ export class CompactContentStore {
         }
         this.residentPayloadBytes -= leaf.units * 2;
     }
+    isCommitted(id) {
+        if (id <= 0)
+            return id === 0 || this.text.isCommitted(id);
+        return this.leaves.get(id)?.state === "committed";
+    }
     /** Reads a leaf the caller still references, from RAM or its committed file. */
     async readLeaf(id) {
+        this.assertReadable();
         const leaf = this.leaves.get(id);
         if (!leaf)
-            throw new Error(`compact leaf ${id} is not owned`);
-        if (leaf.text !== undefined)
-            return leaf.text;
-        return (await this.readFile(leaf.path ?? "", leaf.units * 2, "leaf_read")).toString("utf16le");
-    }
-    /** Resolves once every queued storage job, including the ones they queued, has completed. */
-    async idle() {
-        while (this.queued > 0)
-            await this.chain;
-    }
-    /**
-     * Invalidates spilling, joins owned I/O, then removes the epoch directory only when this store
-     * created it and it still passes the ownership checks; otherwise rejects with `CompactSpoolRefusedError`.
-     */
-    async retire() {
-        this.retired = true;
-        await this.idle();
-        const token = this.spoolToken;
-        this.spoolToken = undefined;
-        if (token !== undefined)
-            await removeSpoolDir(this.dir, token);
+            throw new CompactReadError("ownership");
+        this.adjust(id, 0, 1);
+        try {
+            if (leaf.text !== undefined)
+                return leaf.text;
+            return (await this.readFile(leaf.path ?? "", leaf.units * 2, "leaf_read")).toString("utf16le");
+        }
+        finally {
+            this.adjust(id, 0, -1);
+        }
     }
     status() {
         return {
@@ -109,94 +113,6 @@ export class CompactContentStore {
             failures: [...this.failures],
         };
     }
-    /** Reads a committed file and rejects a missing, unreadable or short one. */
-    async readFile(path, bytes, operation) {
-        let data;
-        try {
-            data = await this.io.readFile(path);
-        }
-        catch (cause) {
-            throw this.readFailure(operation, path, cause);
-        }
-        if (data.byteLength !== bytes) {
-            throw this.readFailure(operation, path, new Error(`expected ${bytes} bytes, found ${data.byteLength}`));
-        }
-        return data;
-    }
-    /** Writes one new spool file; undefined means the write failed, was reported, and spilling halted. */
-    async writeFile(data, operation, retainedInMemoryBytes) {
-        const path = await this.ensureDir(retainedInMemoryBytes);
-        if (path === undefined)
-            return undefined;
-        const file = join(path, `leaf-${this.nextFile++}.bin`);
-        this.pendingIoCopyBytes += data.byteLength;
-        try {
-            await this.io.writeFile(file, data);
-            this.spillBytesWritten += data.byteLength;
-            return file;
-        }
-        catch (cause) {
-            this.fail(operation, file, cause, retainedInMemoryBytes);
-            this.discard(file, data.byteLength);
-            return undefined;
-        }
-        finally {
-            this.pendingIoCopyBytes -= data.byteLength;
-        }
-    }
-    /**
-     * An unreferenced (or partially written) spool file: reclamation debt until its unlink completes or
-     * finds it gone. Files dropped after retirement started belong to the directory retirement removes.
-     */
-    discard(path, bytes) {
-        if (this.retired)
-            return;
-        this.reclaimDebtBytes += bytes;
-        this.enqueue("reclaim", () => this.reclaim(path, bytes, 0));
-    }
-    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
-    async reclaim(path, bytes, attempt) {
-        try {
-            await this.io.unlink(path);
-        }
-        catch (cause) {
-            if (cause.code !== "ENOENT") {
-                this.fail("reclaim", path, cause, 0);
-                const delay = RECLAIM_RETRY_DELAYS_MS[attempt];
-                if (delay !== undefined) {
-                    setTimeout(() => {
-                        if (this.retired)
-                            this.reclaimDebtBytes -= bytes;
-                        else
-                            this.enqueue("reclaim", () => this.reclaim(path, bytes, attempt + 1));
-                    }, delay).unref?.();
-                }
-                return;
-            }
-        }
-        this.reclaimDebtBytes -= bytes;
-        this.scheduleSpill();
-    }
-    get spillAllowed() {
-        return !this.halted && !this.retired;
-    }
-    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
-    get spillStopped() {
-        return this.halted || this.reclaimDebtBytes > RECLAIM_WORK_ALLOWANCE_BYTES;
-    }
-    enqueue(operation, job) {
-        this.queued++;
-        this.chain = this.chain
-            .then(job)
-            .catch((cause) => {
-            if (operation === "spill_write")
-                this.spillQueued = false;
-            this.fail(operation, this.dir, cause, 0);
-        })
-            .finally(() => {
-            this.queued--;
-        });
-    }
     scheduleSpill() {
         if (this.spillQueued || !this.spillAllowed || this.residentPayloadBytes <= this.spillAboveBytes)
             return;
@@ -216,22 +132,29 @@ export class CompactContentStore {
         const bytes = leaf.units * 2;
         leaf.state = "pending";
         this.ramLeaves.delete(id);
-        const path = await this.writeFile(Buffer.from(leaf.text, "utf16le"), "spill_write", bytes);
-        const owned = this.leaves.get(id) === leaf;
-        if (path === undefined) {
-            leaf.state = "ram";
-            if (owned)
-                this.ramLeaves.add(id);
+        let path;
+        try {
+            path = await this.writeFile(Buffer.from(leaf.text, "utf16le"), "spill_write", bytes);
+        }
+        finally {
+            // A failed write, or a failure report that threw, keeps the leaf resident and spillable.
+            if (path === undefined) {
+                leaf.state = "ram";
+                if (this.leaves.get(id) === leaf)
+                    this.ramLeaves.add(id);
+            }
         }
-        else if (!owned || this.retired) {
+        const owned = this.leaves.get(id) === leaf;
+        if (path !== undefined && (!owned || this.retired)) {
             this.discard(path, bytes);
         }
-        else {
+        else if (path !== undefined) {
             leaf.state = "committed";
             leaf.path = path;
             leaf.text = undefined;
             this.residentPayloadBytes -= bytes;
             this.spilledLiveBytes += bytes;
+            this.committed(id);
         }
         this.spillQueued = false;
         if (this.residentPayloadBytes > this.spillTargetBytes) {
@@ -240,30 +163,5 @@ export class CompactContentStore {
                 this.enqueue("spill_write", () => this.spillNext());
         }
     }
-    /** Creates the private epoch directory once; a refusal or failure halts spilling and is reported. */
-    ensureDir(retained) {
-        this.dirReady ??= createSpoolDir(this.dir).then((token) => {
-            this.spoolToken = token;
-            return this.dir;
-        }, (cause) => {
-            this.fail("spool_create", this.dir, cause, retained);
-            return undefined;
-        });
-        return this.dirReady;
-    }
-    readFailure(operation, path, cause) {
-        this.fail(operation, path, cause, 0);
-        return new CompactStorageReadError(operation, path, cause);
-    }
-    fail(operation, path, cause, retained) {
-        if (operation === "spill_write" || operation === "spool_create")
-            this.halted = true;
-        this.record({ operation, path, cause: describeCause(cause), retainedInMemoryBytes: retained });
-    }
-    record(failure) {
-        this.failures.push(failure);
-        if (this.failures.length > FAILURE_HISTORY)
-            this.failures.shift();
-    }
 }
 //# sourceMappingURL=compact-content-store.js.map

package/dist/modes/rpc/compact-index-pages.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Page layout of the compact settled-row index (senpi#4272): how folded rows are packed into
+ * copy-on-write page files, and which base pages are small enough to merge on the next compaction.
+ */
+/** A page under half full in both rows and bytes is rewritten by the next compaction, so pages merge. */
+export declare function isSmallPage(page: {
+    readonly keys: readonly string[];
+    readonly bytes: number;
+}): boolean;
+/** Packs entries into pages of at most `PAGE_ROWS` rows and `PAGE_BYTES` UTF-8 bytes (one oversized row stands alone). */
+export declare function packPages<Row>(rows: readonly [string, Row][]): [string, Row][][];
+//# sourceMappingURL=compact-index-pages.d.ts.map

package/dist/modes/rpc/compact-index-pages.js

@@ -0,0 +1,31 @@
+/**
+ * Page layout of the compact settled-row index (senpi#4272): how folded rows are packed into
+ * copy-on-write page files, and which base pages are small enough to merge on the next compaction.
+ */
+const PAGE_ROWS = 128;
+const PAGE_BYTES = 64 * 1024;
+/** A page under half full in both rows and bytes is rewritten by the next compaction, so pages merge. */
+export function isSmallPage(page) {
+    return page.keys.length < PAGE_ROWS / 2 && page.bytes < PAGE_BYTES / 2;
+}
+/** Packs entries into pages of at most `PAGE_ROWS` rows and `PAGE_BYTES` UTF-8 bytes (one oversized row stands alone). */
+export function packPages(rows) {
+    const pages = [];
+    let page = [];
+    // UTF-8 bytes of the serialized page: the brackets, plus each entry and its separator.
+    let bytes = 1;
+    for (const entry of rows) {
+        const size = Buffer.byteLength(JSON.stringify(entry)) + 1;
+        if (page.length > 0 && (page.length === PAGE_ROWS || bytes + size > PAGE_BYTES)) {
+            pages.push(page);
+            page = [];
+            bytes = 1;
+        }
+        page.push(entry);
+        bytes += size;
+    }
+    if (page.length > 0)
+        pages.push(page);
+    return pages;
+}
+//# sourceMappingURL=compact-index-pages.js.map

package/dist/modes/rpc/compact-read-lease.d.ts

@@ -0,0 +1,15 @@
+export declare class CompactReadError extends Error {
+    readonly reason: "released" | "retired" | "range" | "size_limit" | "count_limit" | "ownership";
+    constructor(reason: CompactReadError["reason"]);
+}
+/** Invalidates immediately, but holds the owner's references until its last operation unwinds. */
+export declare class CompactReadLease {
+    private released;
+    private operations;
+    private readonly dispose;
+    constructor(dispose: () => void);
+    assert(): void;
+    run<T>(read: () => Promise<T>): Promise<T>;
+    release(): void;
+}
+//# sourceMappingURL=compact-read-lease.d.ts.map