@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-2

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

@@ -0,0 +1,85 @@
+import type { CompactContentStore, LeafId } from "./compact-content-store.ts";
+/**
+ * A spillable keyed collection: an immutable paged disk base plus one resident override slot per key
+ * (senpi#4272). Updates coalesce into that slot, so N updates to one key hold one slot, and a cold row
+ * changes without reading its page. Background compaction folds eligible overrides into new pages and
+ * publishes them in one synchronous swap that never removes an override newer than the one it read.
+ * A failed compaction leaves the previous base in place and the next one free to run.
+ * Pages are internal storage only; nothing here is a wire record.
+ */
+type Override<Row> = {
+    readonly kind: "row";
+    readonly row: Row;
+} | {
+    readonly kind: "patch";
+    readonly patch: Partial<Row>;
+} | {
+    readonly kind: "tombstone";
+};
+interface Page {
+    readonly path: string;
+    readonly bytes: number;
+    /** Published keys; a row skipped at publication stays in the file but is never read back. */
+    readonly keys: readonly string[];
+    readonly leaves: readonly LeafId[];
+    inBase: boolean;
+    pins: number;
+}
+interface IndexBase {
+    readonly pages: readonly Page[];
+    readonly pageOf: ReadonlyMap<string, Page>;
+}
+export interface FrozenIndex<Row> {
+    readonly base: IndexBase;
+    readonly overrides: ReadonlyMap<string, Override<Row>>;
+}
+export declare class CompactContentIndex<Row extends object> {
+    private readonly store;
+    private readonly leavesOf;
+    private readonly compactAboveRows;
+    private base;
+    private readonly overrides;
+    /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
+    private readonly unsettledLeaves;
+    private readonly leafKey;
+    private compacting;
+    private tombstones;
+    private tombstoneKeyUnits;
+    constructor(store: CompactContentStore, leavesOf: (row: Row) => readonly LeafId[], compactAboveRows: number);
+    has(key: string): boolean;
+    set(key: string, row: Row): void;
+    patch(key: string, fields: Partial<Row>): void;
+    /** A key only the overlay ever held leaves no tombstone; a committed one is masked until compaction. */
+    delete(key: string): void;
+    freeze(): FrozenIndex<Row>;
+    release(frozen: FrozenIndex<Row>): void;
+    /** Every row visible at a frozen root, reading only that root's own pages. */
+    entries(frozen: FrozenIndex<Row>): Promise<Map<string, Row>>;
+    status(): {
+        overrideSlots: number;
+        deletionMasks: number;
+        deletionMaskBytes: number;
+        basePages: number;
+        baseRows: number;
+    };
+    /** The acceptance path checks counts only: an override is eligible once none of its leaves is uncommitted. */
+    maybeCompact(): void;
+    private committed;
+    /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
+    private compact;
+    /**
+     * 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.
+     */
+    private swap;
+    private readPage;
+    private reclaimPage;
+    private put;
+    private drop;
+    private countTombstone;
+    private pinRow;
+}
+export {};
+//# sourceMappingURL=compact-content-index.d.ts.map

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

@@ -0,0 +1,254 @@
+import { isSmallPage, packPages } from "./compact-index-pages.js";
+export class CompactContentIndex {
+    constructor(store, leavesOf, compactAboveRows) {
+        this.base = { pages: [], pageOf: new Map() };
+        this.overrides = new Map();
+        /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
+        this.unsettledLeaves = new Map();
+        this.leafKey = new Map();
+        this.compacting = false;
+        this.tombstones = 0;
+        this.tombstoneKeyUnits = 0;
+        this.store = store;
+        this.leavesOf = leavesOf;
+        this.compactAboveRows = compactAboveRows;
+        store.onCommitted = (id) => this.committed(id);
+    }
+    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);
+        return { base: this.base, overrides: new Map(this.overrides) };
+    }
+    release(frozen) {
+        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) {
+        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();
+        });
+    }
+    committed(id) {
+        const key = this.leafKey.get(id);
+        if (key === undefined)
+            return;
+        this.leafKey.delete(id);
+        const left = (this.unsettledLeaves.get(key) ?? 0) - 1;
+        if (left > 0)
+            this.unsettledLeaves.set(key, left);
+        else
+            this.unsettledLeaves.delete(key);
+        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);
+        const unsettled = leaves.filter((id) => !this.store.isCommitted(id));
+        for (const id of unsettled)
+            this.leafKey.set(id, key);
+        if (unsettled.length > 0)
+            this.unsettledLeaves.set(key, unsettled.length);
+        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.leafKey.delete(id);
+                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

@@ -0,0 +1,59 @@
+import { CompactSpoolStorage } from "./compact-spool-storage.ts";
+import { type CompactStorageFailure, type CompactStorageIo } from "./compact-storage-io.ts";
+/**
+ * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
+ *
+ * Acceptance never waits here: a leaf is created synchronously in RAM, and a spill only relocates
+ * that immutable value. Its RAM copy is released only after the whole file was written and closed;
+ * a failed write keeps the bytes resident, halts further spilling and is reported through
+ * `status()`, never dropped. All storage work runs as one serial asynchronous job chain.
+ */
+/** 32,768 UTF-16 code units (64 KiB as UTF-16LE), so a split surrogate survives a leaf boundary exactly. */
+export declare const COMPACT_LEAF_CODE_UNITS = 32768;
+export type LeafId = number;
+export interface CompactStorageStatus {
+    readonly residentPayloadBytes: number;
+    readonly pendingIoCopyBytes: number;
+    readonly pinnedOnlyBytes: number;
+    readonly spilledLiveBytes: number;
+    readonly spillBytesWritten: number;
+    readonly reclaimDebtBytes: number;
+    /** Resident bytes above the spill target that a halted spool keeps in RAM (ruling 08 condition 1). */
+    readonly spillFailureRetainedBytes: number;
+    readonly spillHalted: boolean;
+    readonly failures: readonly CompactStorageFailure[];
+}
+export interface CompactContentStoreOptions {
+    /** Private epoch spool directory the store creates itself (0700, never an existing one; files 0600). Not a transcript. */
+    readonly dir: string;
+    readonly io?: CompactStorageIo;
+    /** Spilling starts above this many resident leaf bytes and stops at the target. */
+    readonly spillAboveBytes?: number;
+    readonly spillTargetBytes?: number;
+}
+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 nextLeafId;
+    private residentPayloadBytes;
+    private pinnedOnlyBytes;
+    private spilledLiveBytes;
+    /** Called after a leaf commits, so index compaction can include rows that now reference only disk. */
+    onCommitted: ((id: LeafId) => void) | undefined;
+    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>;
+    status(): CompactStorageStatus;
+    protected scheduleSpill(): void;
+    /** Spills one oldest resident leaf per job, so other storage work interleaves fairly. */
+    private spillNext;
+}
+//# sourceMappingURL=compact-content-store.d.ts.map

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

@@ -0,0 +1,134 @@
+import { CompactSpoolStorage, RECLAIM_WORK_ALLOWANCE_BYTES } from "./compact-spool-storage.js";
+import { nodeCompactStorageIo } from "./compact-storage-io.js";
+/**
+ * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
+ *
+ * Acceptance never waits here: a leaf is created synchronously in RAM, and a spill only relocates
+ * that immutable value. Its RAM copy is released only after the whole file was written and closed;
+ * a failed write keeps the bytes resident, halts further spilling and is reported through
+ * `status()`, never dropped. All storage work runs as one serial asynchronous job chain.
+ */
+/** 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;
+export class CompactContentStore extends CompactSpoolStorage {
+    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.nextLeafId = 1;
+        this.residentPayloadBytes = 0;
+        this.pinnedOnlyBytes = 0;
+        this.spilledLiveBytes = 0;
+        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) {
+        const id = this.nextLeafId++;
+        this.leaves.set(id, { text, units: text.length, live: 1, pins: 0, state: "ram" });
+        this.ramLeaves.add(id);
+        this.residentPayloadBytes += text.length * 2;
+        this.scheduleSpill();
+        return id;
+    }
+    /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
+    adjust(id, live, pins) {
+        const leaf = this.leaves.get(id);
+        if (!leaf)
+            throw new Error(`compact leaf ${id} is not owned`);
+        const pinnedOnly = leaf.live === 0 && leaf.pins > 0;
+        leaf.live += live;
+        leaf.pins += pins;
+        if (pinnedOnly !== (leaf.live === 0 && leaf.pins > 0))
+            this.pinnedOnlyBytes += (pinnedOnly ? -2 : 2) * leaf.units;
+        if (leaf.live > 0 || leaf.pins > 0)
+            return;
+        this.leaves.delete(id);
+        this.ramLeaves.delete(id);
+        if (leaf.state === "committed" && leaf.path) {
+            this.spilledLiveBytes -= leaf.units * 2;
+            this.discard(leaf.path, leaf.units * 2);
+            return;
+        }
+        this.residentPayloadBytes -= leaf.units * 2;
+    }
+    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) {
+        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");
+    }
+    status() {
+        return {
+            residentPayloadBytes: this.residentPayloadBytes,
+            pendingIoCopyBytes: this.pendingIoCopyBytes,
+            pinnedOnlyBytes: this.pinnedOnlyBytes,
+            spilledLiveBytes: this.spilledLiveBytes,
+            spillBytesWritten: this.spillBytesWritten,
+            reclaimDebtBytes: this.reclaimDebtBytes,
+            spillFailureRetainedBytes: this.spillStopped
+                ? Math.max(0, this.residentPayloadBytes - this.spillTargetBytes)
+                : 0,
+            spillHalted: this.spillStopped,
+            failures: [...this.failures],
+        };
+    }
+    scheduleSpill() {
+        if (this.spillQueued || !this.spillAllowed || this.residentPayloadBytes <= this.spillAboveBytes)
+            return;
+        if (this.reclaimDebtBytes > RECLAIM_WORK_ALLOWANCE_BYTES)
+            return;
+        this.spillQueued = true;
+        this.enqueue("spill_write", () => this.spillNext());
+    }
+    /** Spills one oldest resident leaf per job, so other storage work interleaves fairly. */
+    async spillNext() {
+        const [id] = this.ramLeaves;
+        const leaf = id === undefined ? undefined : this.leaves.get(id);
+        if (id === undefined || !leaf || leaf.text === undefined || !this.spillAllowed) {
+            this.spillQueued = false;
+            return;
+        }
+        const bytes = leaf.units * 2;
+        leaf.state = "pending";
+        this.ramLeaves.delete(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);
+            }
+        }
+        const owned = this.leaves.get(id) === leaf;
+        if (path !== undefined && (!owned || this.retired)) {
+            this.discard(path, bytes);
+        }
+        else if (path !== undefined) {
+            leaf.state = "committed";
+            leaf.path = path;
+            leaf.text = undefined;
+            this.residentPayloadBytes -= bytes;
+            this.spilledLiveBytes += bytes;
+            this.onCommitted?.(id);
+        }
+        this.spillQueued = false;
+        if (this.residentPayloadBytes > this.spillTargetBytes) {
+            this.spillQueued = this.spillAllowed;
+            if (this.spillQueued)
+                this.enqueue("spill_write", () => this.spillNext());
+        }
+    }
+}
+//# 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-session-state.d.ts

@@ -0,0 +1,83 @@
+import { CompactContentIndex, type FrozenIndex } from "./compact-content-index.ts";
+import { type CompactContentStoreOptions, type CompactStorageStatus, type LeafId } from "./compact-content-store.ts";
+import { type CompactBlockKind, type CompactPersistence, type CompactTransition } from "./compact-transition.ts";
+/**
+ * The in-memory current-state owner over compact storage (senpi#4272, R3.C6.4 first half).
+ *
+ * `accept` is synchronous: it validates a typed transition completely, then publishes the next
+ * sequence, or throws and leaves the prior root untouched. Block text lives in owned bounded leaves
+ * that spill asynchronously; settled messages live in a spillable index whose persistence status
+ * changes only through `message_status`, never through storage success or failure. `freeze` pins
+ * an immutable cut synchronously, and `read` materializes it asynchronously from RAM or disk.
+ */
+interface FrozenBlock {
+    readonly contentIndex: number;
+    readonly kind: CompactBlockKind;
+    readonly leaves: readonly LeafId[];
+    /** A cut shares the immutable active tail string (under one leaf) instead of minting a leaf per freeze. */
+    readonly tail: string;
+}
+interface SettledRow {
+    readonly persistence: CompactPersistence;
+    readonly blocks: readonly FrozenBlock[];
+}
+interface FrozenCompactState {
+    readonly sequence: number;
+    readonly active: ReadonlyMap<string, readonly FrozenBlock[]>;
+    readonly settled: FrozenIndex<SettledRow>;
+}
+interface CompactMessageView {
+    readonly messageId: string;
+    readonly persistence: CompactPersistence | undefined;
+    readonly blocks: readonly {
+        readonly contentIndex: number;
+        readonly kind: CompactBlockKind;
+        readonly text: string;
+    }[];
+}
+export interface CompactSessionStateOptions extends CompactContentStoreOptions {
+    /** Index compaction is considered once this many override slots exist (one page by default). */
+    readonly compactAboveRows?: number;
+}
+export declare class CompactSessionState {
+    private readonly store;
+    private readonly settled;
+    private readonly active;
+    private sequence;
+    private frozenTailBytes;
+    constructor(options: CompactSessionStateOptions);
+    get acceptedSequence(): number;
+    accept(transition: CompactTransition): number;
+    freeze(): FrozenCompactState;
+    release(frozen: FrozenCompactState): void;
+    /** Rejects with the storage error when committed content is gone; never returns empty content for it. */
+    read(frozen: FrozenCompactState): Promise<{
+        sequence: number;
+        messages: CompactMessageView[];
+    }>;
+    storageStatus(): CompactStorageStatus & ReturnType<CompactContentIndex<SettledRow>["status"]> & {
+        readonly residentTailBytes: number;
+        /** Active tails held by unreleased cuts; may share storage with `residentTailBytes`. */
+        readonly frozenTailBytes: number;
+        readonly hotWitnessBytes: number;
+    };
+    idle(): Promise<void>;
+    retire(): Promise<void>;
+    private start;
+    /**
+     * Appends only the new suffix. Overlap exists only while a fully covered seed is being replayed
+     * (`emitted < covered == units`), so it always lies inside the producer-declared coverage.
+     */
+    private delta;
+    private replace;
+    private setPersistence;
+    private remove;
+    private block;
+    private append;
+    /** Settling mints the final tail into a spillable leaf; a freeze of an active block shares the tail. */
+    private seal;
+    private pin;
+    private texts;
+}
+export {};
+//# sourceMappingURL=compact-session-state.d.ts.map