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

package/dist/modes/rpc/compact-session-state.js

@@ -0,0 +1,197 @@
+import { CompactContentIndex } from "./compact-content-index.js";
+import { COMPACT_LEAF_CODE_UNITS, CompactContentStore, } from "./compact-content-store.js";
+import { CompactTransitionError, } from "./compact-transition.js";
+const byContentIndex = ([a], [b]) => a - b;
+export class CompactSessionState {
+    constructor(options) {
+        this.active = new Map();
+        this.sequence = 0;
+        this.frozenTailBytes = 0;
+        this.store = new CompactContentStore(options);
+        const leavesOf = (row) => row.blocks.flatMap((block) => block.leaves);
+        this.settled = new CompactContentIndex(this.store, leavesOf, options.compactAboveRows ?? 128);
+    }
+    get acceptedSequence() {
+        return this.sequence;
+    }
+    accept(transition) {
+        switch (transition.type) {
+            case "block_start":
+                this.start(transition);
+                break;
+            case "block_delta":
+                this.delta(this.block(transition), transition.offset, transition.text);
+                break;
+            case "block_replace":
+                this.replace(this.block(transition), transition.text);
+                break;
+            case "message_status":
+                this.setPersistence(transition.messageId, transition.persistence);
+                break;
+            case "message_remove":
+                this.remove(transition.messageId);
+                break;
+        }
+        return ++this.sequence;
+    }
+    freeze() {
+        const active = new Map();
+        for (const [messageId, blocks] of this.active)
+            active.set(messageId, this.seal(blocks, false));
+        for (const blocks of active.values())
+            this.pin(blocks, 1);
+        return { sequence: this.sequence, active, settled: this.settled.freeze() };
+    }
+    release(frozen) {
+        for (const blocks of frozen.active.values())
+            this.pin(blocks, -1);
+        this.settled.release(frozen.settled);
+    }
+    /** Rejects with the storage error when committed content is gone; never returns empty content for it. */
+    async read(frozen) {
+        const messages = [];
+        for (const [messageId, row] of await this.settled.entries(frozen.settled)) {
+            messages.push({ messageId, persistence: row.persistence, blocks: await this.texts(row.blocks) });
+        }
+        for (const [messageId, blocks] of frozen.active) {
+            messages.push({ messageId, persistence: undefined, blocks: await this.texts(blocks) });
+        }
+        return { sequence: frozen.sequence, messages };
+    }
+    storageStatus() {
+        let residentTailBytes = 0;
+        let hotWitnessBytes = 0;
+        for (const blocks of this.active.values()) {
+            for (const block of blocks.values()) {
+                residentTailBytes += block.tail.length * 2;
+                hotWitnessBytes += block.witness.length * 2;
+            }
+        }
+        return {
+            ...this.store.status(),
+            ...this.settled.status(),
+            residentTailBytes,
+            frozenTailBytes: this.frozenTailBytes,
+            hotWitnessBytes,
+        };
+    }
+    idle() {
+        return this.store.idle();
+    }
+    retire() {
+        return this.store.retire();
+    }
+    start(t) {
+        if (this.active.get(t.messageId)?.has(t.contentIndex) || this.settled.has(t.messageId)) {
+            throw new CompactTransitionError("duplicate_block", `${t.messageId}#${t.contentIndex}`);
+        }
+        const covered = t.coveredCodeUnits;
+        if (!Number.isInteger(covered) || (covered !== 0 && covered !== t.seed.length)) {
+            throw new CompactTransitionError("invalid_coverage", `${covered} of ${t.seed.length} seed code units`);
+        }
+        const emitted = covered > 0 ? 0 : t.seed.length;
+        const block = { kind: t.kind, leaves: [], tail: "", units: 0, emitted, covered, witness: "" };
+        block.witness = t.seed.slice(0, covered);
+        this.append(block, t.seed);
+        const blocks = this.active.get(t.messageId) ?? new Map();
+        blocks.set(t.contentIndex, block);
+        this.active.set(t.messageId, blocks);
+    }
+    /**
+     * 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.
+     */
+    delta(block, offset, text) {
+        if (offset !== block.emitted) {
+            throw new CompactTransitionError("non_contiguous", `offset ${offset}, expected ${block.emitted}`);
+        }
+        const overlapEnd = Math.min(offset + text.length, block.units);
+        const overlap = Math.max(0, overlapEnd - offset);
+        if (overlap > 0 && text.slice(0, overlap) !== block.witness.slice(offset, overlapEnd)) {
+            throw new CompactTransitionError("conflicting_overlap", `[${offset}, ${overlapEnd})`);
+        }
+        this.append(block, text.slice(overlap));
+        block.emitted = offset + text.length;
+        if (block.emitted >= block.covered)
+            block.witness = "";
+    }
+    replace(block, text) {
+        for (const id of block.leaves.splice(0))
+            this.store.adjust(id, -1, 0);
+        block.tail = "";
+        block.units = 0;
+        block.covered = 0;
+        block.witness = "";
+        this.append(block, text);
+        block.emitted = block.units;
+    }
+    setPersistence(messageId, persistence) {
+        const blocks = this.active.get(messageId);
+        if (blocks) {
+            this.settled.set(messageId, { persistence, blocks: this.seal(blocks, true) });
+            for (const block of blocks.values())
+                for (const id of block.leaves)
+                    this.store.adjust(id, -1, 0);
+            this.active.delete(messageId);
+        }
+        else if (this.settled.has(messageId)) {
+            this.settled.patch(messageId, { persistence });
+        }
+        else {
+            throw new CompactTransitionError("unknown_message", messageId);
+        }
+    }
+    remove(messageId) {
+        const blocks = this.active.get(messageId);
+        const settled = this.settled.has(messageId);
+        if (!blocks && !settled)
+            throw new CompactTransitionError("unknown_message", messageId);
+        for (const block of blocks?.values() ?? [])
+            for (const id of block.leaves)
+                this.store.adjust(id, -1, 0);
+        this.active.delete(messageId);
+        if (settled)
+            this.settled.delete(messageId);
+    }
+    block(address) {
+        const block = this.active.get(address.messageId)?.get(address.contentIndex);
+        if (!block)
+            throw new CompactTransitionError("unknown_block", `${address.messageId}#${address.contentIndex}`);
+        return block;
+    }
+    append(block, text) {
+        block.units += text.length;
+        let rest = text;
+        while (block.tail.length + rest.length >= COMPACT_LEAF_CODE_UNITS) {
+            const take = COMPACT_LEAF_CODE_UNITS - block.tail.length;
+            block.leaves.push(this.store.createLeaf(block.tail + rest.slice(0, take)));
+            block.tail = "";
+            rest = rest.slice(take);
+        }
+        block.tail += rest;
+    }
+    /** Settling mints the final tail into a spillable leaf; a freeze of an active block shares the tail. */
+    seal(blocks, settle) {
+        return [...blocks].sort(byContentIndex).map(([contentIndex, block]) => {
+            if (settle && block.tail.length > 0) {
+                block.leaves.push(this.store.createLeaf(block.tail));
+                block.tail = "";
+            }
+            return { contentIndex, kind: block.kind, leaves: [...block.leaves], tail: block.tail };
+        });
+    }
+    pin(blocks, delta) {
+        for (const block of blocks) {
+            this.frozenTailBytes += delta * block.tail.length * 2;
+            for (const id of block.leaves)
+                this.store.adjust(id, 0, delta);
+        }
+    }
+    async texts(blocks) {
+        return Promise.all(blocks.map(async ({ contentIndex, kind, leaves, tail }) => {
+            const parts = await Promise.all(leaves.map((id) => this.store.readLeaf(id)));
+            return { contentIndex, kind, text: parts.join("") + tail };
+        }));
+    }
+}
+//# sourceMappingURL=compact-session-state.js.map

package/dist/modes/rpc/compact-spool-dir.d.ts

@@ -0,0 +1,8 @@
+/** Creates a fresh private epoch directory and returns the token its ownership marker holds. */
+export declare function createSpoolDir(dir: string): Promise<string>;
+/**
+ * Removes `dir` only while it is still the private, marked directory `createSpoolDir` made. A
+ * directory that is already gone leaves nothing to remove, so retirement settles as a no-op.
+ */
+export declare function removeSpoolDir(dir: string, token: string): Promise<void>;
+//# sourceMappingURL=compact-spool-dir.d.ts.map

package/dist/modes/rpc/compact-spool-dir.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { describeCause } from "./compact-storage-io.js";
+/**
+ * Ownership of the compact spool's epoch directory (senpi#4272). The store creates the directory
+ * itself (0700, never adopting an existing one) and writes a private marker into it; removal
+ * re-checks the directory and that marker without following symlinks, so retirement never deletes
+ * a directory this store did not create and still own.
+ */
+const MARKER = ".compact-spool-owner";
+class CompactSpoolRefusedError extends Error {
+    constructor(reason, path, cause, cleanupFailure) {
+        const detail = cause === undefined ? "" : `: ${describeCause(cause)}`;
+        const kept = cleanupFailure === undefined ? "" : `; removing the directory failed: ${describeCause(cleanupFailure)}`;
+        super(`compact spool directory refused (${reason}): ${path}${detail}${kept}`, { cause });
+        this.name = "CompactSpoolRefusedError";
+        this.reason = reason;
+        this.path = path;
+    }
+}
+/** Creates a fresh private epoch directory and returns the token its ownership marker holds. */
+export async function createSpoolDir(dir) {
+    await mkdir(dirname(dir), { recursive: true, mode: 0o700 });
+    try {
+        await mkdir(dir, { mode: 0o700 });
+    }
+    catch (cause) {
+        if (cause.code === "EEXIST")
+            throw new CompactSpoolRefusedError("pre_existing", dir);
+        throw cause;
+    }
+    const token = randomUUID();
+    try {
+        await writeFile(join(dir, MARKER), token, { flag: "wx", mode: 0o600 });
+    }
+    catch (cause) {
+        throw await abandonSpoolDir(dir, cause);
+    }
+    return token;
+}
+/**
+ * Removes a directory `createSpoolDir` just made but could not mark, so a later store creates it
+ * fresh instead of refusing it as pre-existing. Only a marker this call's exclusive create made (any
+ * failure but EEXIST) is unlinked, then the directory itself, which `rmdir` removes only while empty.
+ */
+async function abandonSpoolDir(dir, cause) {
+    try {
+        if (cause.code !== "EEXIST")
+            await rm(join(dir, MARKER), { force: true });
+        await rmdir(dir);
+        return new CompactSpoolRefusedError("marker_write_failed", dir, cause);
+    }
+    catch (cleanupFailure) {
+        return new CompactSpoolRefusedError("marker_write_failed", dir, cause, cleanupFailure);
+    }
+}
+/**
+ * Removes `dir` only while it is still the private, marked directory `createSpoolDir` made. A
+ * directory that is already gone leaves nothing to remove, so retirement settles as a no-op.
+ */
+export async function removeSpoolDir(dir, token) {
+    const owned = await lstat(dir).catch((cause) => {
+        if (cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    });
+    if (owned === undefined)
+        return;
+    const refusal = await refusalFor(dir, owned, token);
+    if (refusal)
+        throw new CompactSpoolRefusedError(refusal, dir);
+    await rm(dir, { recursive: true, force: true });
+}
+async function refusalFor(dir, owned, token) {
+    if (owned.isSymbolicLink())
+        return "symlink";
+    if (!owned.isDirectory())
+        return "not_directory";
+    const markerPath = join(dir, MARKER);
+    const marker = await lstat(markerPath).catch(() => undefined);
+    if (!marker?.isFile() || (await readFile(markerPath, "utf8")) !== token)
+        return "marker_missing";
+    // Windows has no POSIX owner or mode bits; the marker token and the no-follow checks still apply.
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        return undefined;
+    if (owned.uid !== uid || marker.uid !== uid)
+        return "foreign_owner";
+    if (((owned.mode | marker.mode) & 0o077) !== 0)
+        return "wide_mode";
+    return undefined;
+}
+//# sourceMappingURL=compact-spool-dir.js.map

package/dist/modes/rpc/compact-spool-storage.d.ts

@@ -0,0 +1,53 @@
+import { type CompactStorageFailure, type CompactStorageIo, type CompactStorageOperation } from "./compact-storage-io.ts";
+/**
+ * The spool file path of compact current-state storage (senpi#4272, R3.C6.4): one serial
+ * asynchronous job chain, the private epoch directory, spool file writes, reads and reclamation,
+ * and the failure ledger. `CompactContentStore` adds leaf ownership and spilling on top.
+ */
+export declare const RECLAIM_WORK_ALLOWANCE_BYTES: number;
+export declare abstract class CompactSpoolStorage {
+    readonly dir: string;
+    private readonly io;
+    protected readonly failures: CompactStorageFailure[];
+    private nextFile;
+    private dirReady;
+    private spoolToken;
+    private chain;
+    private queued;
+    protected spillQueued: boolean;
+    private halted;
+    protected retired: boolean;
+    protected pendingIoCopyBytes: number;
+    protected spillBytesWritten: number;
+    protected reclaimDebtBytes: number;
+    constructor(dir: string, io: CompactStorageIo);
+    /** 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>;
+    /** Reads a committed file and rejects a missing, unreadable or short one. */
+    readFile(path: string, bytes: number, operation: CompactStorageOperation): Promise<Buffer>;
+    /** Writes one new spool file; undefined means the write failed and was reported (a spill write also halts spilling). */
+    writeFile(data: Buffer, operation: CompactStorageOperation, retainedInMemoryBytes: number): Promise<string | undefined>;
+    /**
+     * 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: string, bytes: number): void;
+    /** A failed unlink keeps its debt and is retried with bounded backoff outside the job chain. */
+    private reclaim;
+    get spillAllowed(): boolean;
+    /** True while a storage failure or unreclaimed debt above the work allowance holds spilling back. */
+    protected get spillStopped(): boolean;
+    enqueue(operation: CompactStorageOperation, job: () => Promise<void>): void;
+    protected abstract scheduleSpill(): void;
+    /** 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-spool-storage.d.ts.map

package/dist/modes/rpc/compact-spool-storage.js

@@ -0,0 +1,162 @@
+import { join } from "node:path";
+import { createSpoolDir, removeSpoolDir } from "./compact-spool-dir.js";
+import { CompactStorageReadError, describeCause, } from "./compact-storage-io.js";
+/**
+ * The spool file path of compact current-state storage (senpi#4272, R3.C6.4): one serial
+ * asynchronous job chain, the private epoch directory, spool file writes, reads and reclamation,
+ * and the failure ledger. `CompactContentStore` adds leaf ownership and spilling on top.
+ */
+export 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 CompactSpoolStorage {
+    constructor(dir, io) {
+        this.failures = [];
+        this.nextFile = 1;
+        this.chain = Promise.resolve();
+        this.queued = 0;
+        this.spillQueued = false;
+        this.halted = false;
+        this.retired = false;
+        this.pendingIoCopyBytes = 0;
+        this.spillBytesWritten = 0;
+        this.reclaimDebtBytes = 0;
+        this.dir = dir;
+        this.io = io;
+    }
+    /** 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);
+    }
+    /** 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 and was reported (a spill write also halts spilling). */
+    async writeFile(data, operation, retainedInMemoryBytes) {
+        const path = await this.ensureDir(retainedInMemoryBytes);
+        if (path === undefined)
+            return undefined;
+        const file = join(path, `${operation === "spill_write" ? "leaf" : "page"}-${this.nextFile++}.bin`);
+        this.pendingIoCopyBytes += data.byteLength;
+        try {
+            await this.io.writeFile(file, data);
+            this.spillBytesWritten += data.byteLength;
+            return file;
+        }
+        catch (cause) {
+            try {
+                this.fail(operation, file, cause, retainedInMemoryBytes);
+            }
+            finally {
+                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--;
+        });
+    }
+    /** 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-spool-storage.js.map

package/dist/modes/rpc/compact-storage-io.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The asynchronous file seam of compact current-state storage (senpi#4272) and the failures it
+ * reports. Every spool access goes through `CompactStorageIo`; nothing here blocks the host loop.
+ */
+export type CompactStorageOperation = "spool_create" | "spill_write" | "page_write" | "leaf_read" | "page_read" | "reclaim";
+export interface CompactStorageFailure {
+    readonly operation: CompactStorageOperation;
+    readonly path: string;
+    readonly cause: string;
+    /** Accepted bytes this failure leaves resident in memory instead of on disk. */
+    readonly retainedInMemoryBytes: number;
+}
+/** Asynchronous file access the host supplies; the default is node's promise filesystem. */
+export interface CompactStorageIo {
+    writeFile(path: string, data: Buffer): Promise<void>;
+    readFile(path: string): Promise<Buffer>;
+    unlink(path: string): Promise<void>;
+}
+export declare const nodeCompactStorageIo: CompactStorageIo;
+/** Never throws: a host-supplied cause that cannot be described must not abort the failure report. */
+export declare function describeCause(cause: unknown): string;
+/** Committed storage that can no longer be read: a real error, never empty content. */
+export declare class CompactStorageReadError extends Error {
+    readonly operation: CompactStorageOperation;
+    readonly path: string;
+    constructor(operation: CompactStorageOperation, path: string, cause: unknown);
+}
+//# sourceMappingURL=compact-storage-io.d.ts.map

package/dist/modes/rpc/compact-storage-io.js

@@ -0,0 +1,25 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+export const nodeCompactStorageIo = {
+    writeFile: (path, data) => writeFile(path, data, { flag: "wx", mode: 0o600 }),
+    readFile: (path) => readFile(path),
+    unlink: (path) => unlink(path),
+};
+/** Never throws: a host-supplied cause that cannot be described must not abort the failure report. */
+export function describeCause(cause) {
+    try {
+        return cause instanceof Error ? cause.message : String(cause);
+    }
+    catch {
+        return "unprintable failure cause";
+    }
+}
+/** Committed storage that can no longer be read: a real error, never empty content. */
+export class CompactStorageReadError extends Error {
+    constructor(operation, path, cause) {
+        super(`compact storage ${operation} failed for ${path}: ${describeCause(cause)}`, { cause });
+        this.name = "CompactStorageReadError";
+        this.operation = operation;
+        this.path = path;
+    }
+}
+//# sourceMappingURL=compact-storage-io.js.map

package/dist/modes/rpc/compact-transition.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The typed transitions compact current state accepts (senpi#4272, R3.C6.4) and the typed
+ * rejection `CompactSessionState.accept` throws when one fails validation.
+ */
+export type CompactBlockKind = "text" | "thinking" | "tool_arguments";
+export type CompactPersistence = "pending" | "appended" | "failed";
+export interface BlockAddress {
+    readonly messageId: string;
+    readonly contentIndex: number;
+}
+export type CompactTransition = (BlockAddress & {
+    readonly type: "block_start";
+    readonly kind: CompactBlockKind;
+    readonly seed: string;
+    /**
+     * The whole seed when later deltas replay it from offset 0, or 0 when they continue after it. Partial
+     * coverage is refused: the uncovered seed tail would make every later delta overlap or leave a gap.
+     */
+    readonly coveredCodeUnits: number;
+}) | (BlockAddress & {
+    readonly type: "block_delta";
+    readonly offset: number;
+    readonly text: string;
+}) | (BlockAddress & {
+    readonly type: "block_replace";
+    readonly text: string;
+}) | {
+    readonly type: "message_status";
+    readonly messageId: string;
+    readonly persistence: CompactPersistence;
+} | {
+    readonly type: "message_remove";
+    readonly messageId: string;
+};
+type CompactRejection = "unknown_block" | "duplicate_block" | "invalid_coverage" | "non_contiguous" | "conflicting_overlap" | "unknown_message";
+export declare class CompactTransitionError extends Error {
+    readonly reason: CompactRejection;
+    constructor(reason: CompactRejection, detail: string);
+}
+export {};
+//# sourceMappingURL=compact-transition.d.ts.map

package/dist/modes/rpc/compact-transition.js

@@ -0,0 +1,12 @@
+/**
+ * The typed transitions compact current state accepts (senpi#4272, R3.C6.4) and the typed
+ * rejection `CompactSessionState.accept` throws when one fails validation.
+ */
+export class CompactTransitionError extends Error {
+    constructor(reason, detail) {
+        super(`compact transition rejected (${reason}): ${detail}`);
+        this.name = "CompactTransitionError";
+        this.reason = reason;
+    }
+}
+//# sourceMappingURL=compact-transition.js.map

package/dist/modes/rpc/connection-handler.d.ts

@@ -48,6 +48,10 @@ export interface RpcConnectionOptions {
  */
 export interface RpcConnectionSink {
     writeRaw(chunk: string): void;
+    /** Shared bindings accept correlated records synchronously, before JSONL buffering. */
+    writeRecord?(record: object): void;
+    /** The internal structured lane (senpi#4272): seeded records and block controls, never a legacy destination. */
+    writeStructured?(record: object): void;
     waitForBackpressure(): Promise<void>;
     /** Tears the transport down once its event queue can no longer deliver (overflow, write failure). */
     close?(): void;