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

package/dist/core/session-activity.js

@@ -16,6 +16,7 @@
  * `AgentSession.isSessionBusy` instead of testing individual flags, so a source
  * added later cannot be silently missed by one call site.
  */
+import { normalizeWaitItems, wakeSourceItems } from "./lifecycle-wait-items.js";
 /** Live counts of extension-published wake sources, keyed by source name. */
 export class WakeSourceTracker {
     constructor() {
@@ -39,6 +40,7 @@ export class WakeSourceTracker {
             this.counts.set(source, {
                 activeCount,
                 kind: "kind" in data && data.kind === "children" ? "children" : "background",
+                ...normalizeWaitItems(wakeSourceItems(data)),
             });
         else
             this.counts.delete(source);

package/dist/core/session-lifecycle-types.d.ts

@@ -9,13 +9,26 @@ export interface HumanWait {
     readonly childLabel?: string;
     readonly since: string;
 }
+export interface LifecycleWaitItem {
+    readonly id: string;
+    readonly label?: string;
+    readonly startedAt?: string;
+}
+export interface LifecycleWaitSource {
+    readonly source: string;
+    readonly activeCount: number;
+    readonly items?: readonly LifecycleWaitItem[];
+    readonly omittedItems?: number;
+}
 export interface LifecycleWaits {
     readonly children: number;
-    readonly background: readonly {
-        readonly source: string;
-        readonly activeCount: number;
+    /** Named detail can be incomplete even without truncation: custody need not have a named report. */
+    readonly childSources?: readonly LifecycleWaitSource[];
+    readonly childReports?: readonly Pick<ChildLifecycleReport, "taskId" | "childSessionId" | "runEpoch" | "state" | "label" | "since">[];
+    readonly childReportsOmitted?: number;
+    readonly background: readonly (LifecycleWaitSource & {
         readonly retryAtMs?: number;
-    }[];
+    })[];
     readonly human: readonly HumanWait[];
 }
 export interface LifecycleHold {
@@ -83,6 +96,9 @@ export interface ChildLifecycleReport {
     readonly runEpoch: number;
     readonly generation: number;
     readonly state: SessionLifecycleState;
+    readonly label?: string;
+    /** The child's own state-entry time, not the parent's evaluation time. */
+    readonly since?: string;
     readonly waitingOn?: LifecycleWaits;
     readonly terminal?: "completed" | "error" | "lost" | "interrupted" | "cancelled";
 }

package/dist/core/session-lifecycle.js

@@ -1,6 +1,7 @@
 import { effectiveWakes } from "./extensions/builtin/goal/turn-end-liveness.js";
 import { LifecycleChildren } from "./lifecycle-children.js";
 import { LifecycleLedger } from "./lifecycle-ledger.js";
+import { projectWaitItems } from "./lifecycle-wait-items.js";
 import { sameStop, stopDetail } from "./lifecycle-stop.js";
 import { lifecycleState, lifecycleTerminal } from "./session-lifecycle-reducer.js";
 import { SessionWorkObligations } from "./work-obligations.js";
@@ -189,11 +190,34 @@ export class SessionLifecycleController {
     evaluate() {
         const runtime = this.options.readRuntime();
         const active = this.obligations.active;
-        const childRecords = this.children.reports.filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined).length;
+        const childRecords = this.children.reports
+            .filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined)
+            .sort((a, b) => (a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0));
+        const childReports = childRecords
+            .slice(0, 32)
+            .map(({ taskId, childSessionId, runEpoch, state, label, since }) => ({
+            taskId,
+            childSessionId,
+            runEpoch,
+            state,
+            ...(label === undefined ? {} : { label }),
+            ...(since === undefined ? {} : { since }),
+        }));
+        const childSources = active
+            .filter((record) => record.kind === "children")
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
         const background = active
             .filter((record) => record.kind === "background")
-            .map((record) => ({ source: record.source ?? record.key, activeCount: record.activeCount ?? 1 }));
-        const children = Math.max(childRecords, active
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
+        const children = Math.max(childRecords.length, active
             .filter((record) => record.kind === "children")
             .reduce((sum, record) => sum + (record.activeCount ?? 1), 0));
         const input = this.liveness;
@@ -297,7 +321,14 @@ export class SessionLifecycleController {
                     runEpoch: this.ownTask.runEpoch,
                 }
                 : undefined;
-        const waits = { children, background, human };
+        const waits = {
+            children,
+            background,
+            human,
+            ...(childSources.length ? { childSources } : {}),
+            ...(childReports.length ? { childReports } : {}),
+            ...(childRecords.length > 32 ? { childReportsOmitted: childRecords.length - 32 } : {}),
+        };
         const lastStop = this.lastStop(input, synthetic.some((wait) => wait.kind === "stalled"));
         const state = lifecycleState({
             role: this.ledger.snapshot.role,

package/dist/core/structured-session-lane.d.ts

@@ -0,0 +1,33 @@
+import type { InternalAgentChannel } from "@earendil-works/pi-agent-core";
+import { type AssistantProgress } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "./agent-session.ts";
+/** One record of a session's internal structured lane: a session event or a block control, in session order. */
+export type AgentSessionStructuredRecord = AgentSessionEvent | AssistantProgress;
+type StructuredListener = (record: AgentSessionStructuredRecord) => void;
+export declare class StructuredLaneUnavailableError extends Error {
+    constructor();
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export declare class StructuredSessionLane {
+    #private;
+    private readonly listeners;
+    private releaseChannel;
+    constructor(channel: InternalAgentChannel | undefined, enqueue: (deliver: () => void) => void);
+    get active(): boolean;
+    subscribe(listener: StructuredListener): () => void;
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event: AgentSessionEvent, source: object): void;
+    dispose(): void;
+    private emit;
+}
+export {};
+//# sourceMappingURL=structured-session-lane.d.ts.map

package/dist/core/structured-session-lane.js

@@ -0,0 +1,62 @@
+import { carryAssistantCapture } from "@earendil-works/pi-ai";
+export class StructuredLaneUnavailableError extends Error {
+    constructor() {
+        super("Structured lane unavailable: Agent was constructed outside the session layer");
+        this.name = "StructuredLaneUnavailableError";
+    }
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export class StructuredSessionLane {
+    #channel;
+    #enqueue;
+    constructor(channel, enqueue) {
+        this.listeners = new Set();
+        this.#channel = channel;
+        this.#enqueue = enqueue;
+    }
+    get active() {
+        return this.listeners.size > 0;
+    }
+    subscribe(listener) {
+        if (!this.#channel)
+            throw new StructuredLaneUnavailableError();
+        this.listeners.add(listener);
+        this.releaseChannel ??= this.#channel.subscribe((record) => {
+            if ("progress" in record)
+                this.#enqueue(() => this.emit(record.progress));
+        });
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0)
+                this.dispose();
+        };
+    }
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event, source) {
+        const message = (event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant"
+            ? event.message
+            : undefined;
+        // A user-facing description replaced the engine message, so the capture's frozen message must follow it.
+        const described = message && "message" in source && source.message !== message ? message : undefined;
+        this.emit(carryAssistantCapture(source, event, described));
+    }
+    dispose() {
+        this.listeners.clear();
+        this.releaseChannel?.();
+        this.releaseChannel = undefined;
+    }
+    emit(record) {
+        for (const listener of [...this.listeners])
+            listener(record);
+    }
+}
+//# sourceMappingURL=structured-session-lane.js.map

package/dist/core/work-custody-record.d.ts

@@ -1,4 +1,5 @@
 import type { CustomMessage } from "./messages.ts";
+import { type WaitSourceItems } from "./lifecycle-wait-items.ts";
 import type { ObligationKind } from "./session-lifecycle-types.ts";
 export interface CustodyPayload {
     readonly message: Pick<CustomMessage, "customType" | "content" | "display" | "details">;
@@ -7,7 +8,7 @@ export interface CustodyPayload {
     readonly itemIds?: readonly string[];
 }
 /** Mutable only by the registry; every replacement is appended before installation. */
-export interface WorkCustodyRecord {
+export interface WorkCustodyRecord extends WaitSourceItems {
     readonly id: string;
     readonly key: string;
     readonly kind: ObligationKind;

package/dist/core/work-custody-record.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems } from "./lifecycle-wait-items.js";
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25,6 +26,7 @@ export function readWorkCustody(value) {
         key: value.key,
         kind: value.kind,
         state: value.state,
+        ...normalizeWaitItems(value.items, value.omittedItems),
         ...(typeof value.source === "string" ? { source: value.source } : {}),
         ...(typeof value.activeCount === "number" ? { activeCount: value.activeCount } : {}),
         ...(typeof value.detail === "string" ? { detail: value.detail } : {}),

package/dist/core/work-obligations.d.ts

@@ -36,7 +36,7 @@ export declare class SessionWorkObligations implements WorkObligations {
     get activeCount(): number;
     get persisted(): boolean;
     open(key: string, kind: ObligationKind, detail?: string): ObligationToken;
-    syncSource(source: string, kind: ObligationKind, activeCount: number): void;
+    syncSource(source: string, kind: ObligationKind, activeCount: number, items?: unknown): void;
     /** After a restart, a restored wake source stays open only if its producer published again. */
     retireRestoredSources(): void;
     /**

package/dist/core/work-obligations.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems, waitItemSignature } from "./lifecycle-wait-items.js";
 import { custodyIsOpen, readWorkCustody } from "./work-custody-record.js";
 /** Custody keys the engine opens itself (senpi#3986): queued deliveries and published wake sources. */
 export const ENGINE_DELIVERY_KEY_PREFIX = "delivery:";
@@ -59,7 +60,7 @@ export class SessionWorkObligations {
         this.store.changed();
         return this.token(record.id);
     }
-    syncSource(source, kind, activeCount) {
+    syncSource(source, kind, activeCount, items) {
         const key = `${WAKE_SOURCE_KEY_PREFIX}${source}`;
         this.publishedSources.add(key);
         const current = this.active.find((record) => record.key === key);
@@ -68,7 +69,10 @@ export class SessionWorkObligations {
                 this.close(current.id, "passive");
             return;
         }
-        if (current?.activeCount === activeCount && current.kind === kind)
+        const detail = normalizeWaitItems(items);
+        if (current?.activeCount === activeCount &&
+            current.kind === kind &&
+            waitItemSignature(current) === waitItemSignature(detail))
             return;
         this.install({
             ...current,
@@ -77,6 +81,8 @@ export class SessionWorkObligations {
             source,
             kind,
             activeCount,
+            items: detail.items,
+            omittedItems: detail.omittedItems,
             state: current?.state ?? "open",
         });
         this.store.changed();

package/dist/modes/interactive/interactive-mode.d.ts

@@ -329,7 +329,8 @@ export declare class InteractiveMode {
      */
     private unsubscribeSecurityNotices?;
     private detachMcpGrantPresentation?;
-    private mcpMrtrPresentationLifetime;
+    /** A presentation is optional until extension UI is created; shutdown may precede it. */
+    private mcpMrtrPresentationLifetime?;
     private mcpLocalPresenter?;
     private bindCurrentSessionExtensions;
     private applyFullscreenScrollbarSetting;

package/dist/modes/interactive/interactive-mode.js

@@ -691,7 +691,6 @@ export class InteractiveMode {
         this.onRightClickPaste = () => {
             void this.handleRightClickPaste();
         };
-        this.mcpMrtrPresentationLifetime = new AbortController();
         /**
          * Gracefully shutdown the agent.
          * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
@@ -2859,6 +2858,8 @@ export class InteractiveMode {
     }
     createExtensionUIContext() {
         this.mcpMrtrPresentationLifetime ??= new AbortController();
+        if (this.isShuttingDown)
+            this.mcpMrtrPresentationLifetime.abort();
         const context = {
             select: (title, options, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionSelector(title, options, opts), opts),
             confirm: async (title, message, opts) => (await this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionConfirm(title, message, opts), opts)) ?? false,

package/dist/modes/json-event.d.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "@earendil-works/pi-ai";
+import { type AssistantMessage, getAssistantCapture, type TextContent, type ThinkingContent, type ToolCall, type Usage } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent } from "../core/agent-session.ts";
 type WithoutPartial<T> = T extends {
     partial: unknown;
@@ -13,6 +13,7 @@ type ToJsonAssistantMessageEvent<T> = T extends {
 type MessageUpdateEvent = Extract<AgentSessionEvent, {
     type: "message_update";
 }>;
+type AssistantCapture = NonNullable<ReturnType<typeof getAssistantCapture>>;
 type JsonMessageUpdateEvent = {
     type: "message_update";
     usage: Usage;
@@ -23,6 +24,82 @@ type JsonMessageUpdateEvent = {
 export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
     type: "message_update";
 }> | JsonMessageUpdateEvent;
+/** The engine-staged block-seed projection (senpi#4272, R3.C6.2); no public destination selects it before S17. */
+export interface BlockSeedOptions {
+    readonly blockSeeds: 1;
+}
+type SeededAssistantEvent = {
+    type: "start";
+    seed: {
+        message: AssistantMessage;
+    };
+} | {
+    type: "text_start";
+    contentIndex: number;
+    seed: {
+        block: TextContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+    seed: {
+        block: ThinkingContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    id: string;
+    toolName: string;
+    seed: {
+        block: ToolCall;
+        rawArgumentPrefix: string;
+        parsedThrough: number;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "text_delta" | "thinking_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+    parsedThrough: number;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    block: TextContent;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    block: ThinkingContent;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    reason: string;
+    message: AssistantMessage;
+} | {
+    type: "error";
+    reason: string;
+    error: AssistantMessage;
+};
+export type SeededJsonMessageUpdateEvent = Omit<MessageUpdateEvent, "message" | "assistantMessageEvent"> & {
+    usage: Usage;
+    messageMetadata?: AssistantCapture["metadata"];
+    assistantMessageEvent: SeededAssistantEvent;
+};
+export type SeededJsonAgentSessionEvent = Exclude<AgentSessionEvent, {
+    type: "message_update";
+}> | SeededJsonMessageUpdateEvent;
 /**
  * Remove cumulative assistant snapshots from streaming wire events.
  * `message_start` provides the initial message, deltas build it, and
@@ -31,5 +108,6 @@ export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
  */
 export declare function toJsonEvent(event: MessageUpdateEvent): JsonMessageUpdateEvent;
 export declare function toJsonEvent(event: AgentSessionEvent): JsonAgentSessionEvent;
+export declare function toJsonEvent(event: AgentSessionEvent, options: BlockSeedOptions): SeededJsonAgentSessionEvent | undefined;
 export {};
 //# sourceMappingURL=json-event.d.ts.map

package/dist/modes/json-event.js

@@ -1,3 +1,4 @@
+import { getAssistantCapture, } from "@earendil-works/pi-ai";
 function toJsonAssistantMessageEvent(event) {
     if (event.type === "toolcall_start") {
         const toolCall = event.partial.content[event.contentIndex];
@@ -13,7 +14,84 @@ function toJsonAssistantMessageEvent(event) {
     const { partial: _partial, ...deltaEvent } = event;
     return deltaEvent;
 }
-export function toJsonEvent(event) {
+/**
+ * Builds a seeded assistant event from the producer-time capture only: an ordinary delta reads its index, its
+ * delta string and the capture, never the shared partial, the block or the parsed arguments.
+ */
+function toSeededAssistantEvent(event, capture) {
+    if (event.type === "start")
+        return capture.message && { type: "start", seed: { message: capture.message } };
+    if (event.type === "done")
+        return { type: "done", reason: event.reason, message: event.message };
+    if (event.type === "error")
+        return { type: "error", reason: event.reason, error: event.error };
+    const contentIndex = capture.contentIndex ?? event.contentIndex;
+    if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
+        const { offset, parsedThrough } = capture;
+        if (offset === undefined)
+            return undefined;
+        if (event.type !== "toolcall_delta")
+            return { type: event.type, contentIndex, delta: event.delta, offset };
+        if (parsedThrough === undefined)
+            return undefined;
+        return { type: event.type, contentIndex, delta: event.delta, offset, parsedThrough };
+    }
+    const { block, coveredCodeUnits } = capture;
+    if (event.type === "toolcall_end")
+        return block?.type === "toolCall" ? { type: event.type, contentIndex, toolCall: block } : undefined;
+    if (event.type === "text_end")
+        return block?.type === "text" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (event.type === "thinking_end")
+        return block?.type === "thinking" ? { type: event.type, contentIndex, content: event.content, block } : undefined;
+    if (coveredCodeUnits === undefined)
+        return undefined;
+    if (event.type === "text_start")
+        return block?.type === "text" ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } } : undefined;
+    if (event.type === "thinking_start")
+        return block?.type === "thinking"
+            ? { type: event.type, contentIndex, seed: { block, coveredCodeUnits } }
+            : undefined;
+    const { rawArgumentPrefix, parsedThrough } = capture;
+    if (block?.type !== "toolCall" || rawArgumentPrefix === undefined || parsedThrough === undefined)
+        return undefined;
+    return {
+        type: event.type,
+        contentIndex,
+        id: block.id,
+        toolName: block.name,
+        seed: { block, rawArgumentPrefix, parsedThrough, coveredCodeUnits },
+    };
+}
+/**
+ * An assistant record with no capture has no seeded form (`undefined`): its producer captured nothing, so any
+ * seed would be read from the live partial and could already hold later bytes. Identity is never invented.
+ */
+function toSeededJsonEvent(event) {
+    if ((event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant") {
+        const message = getAssistantCapture(event)?.message;
+        if (message)
+            return { ...event, message };
+        // The terminal message is complete when emitted; only an uncaptured start may already hold later bytes.
+        return event.type === "message_end" ? event : undefined;
+    }
+    if (event.type !== "message_update")
+        return event;
+    const capture = getAssistantCapture(event);
+    const assistantMessageEvent = capture && toSeededAssistantEvent(event.assistantMessageEvent, capture);
+    if (!capture || !assistantMessageEvent)
+        return undefined;
+    const { message: _message, assistantMessageEvent: _event, ...outer } = event;
+    const changed = capture.metadata !== undefined && Object.keys(capture.metadata).length > 0;
+    return {
+        ...outer,
+        usage: capture.usage,
+        ...(changed ? { messageMetadata: capture.metadata } : {}),
+        assistantMessageEvent,
+    };
+}
+export function toJsonEvent(event, options) {
+    if (options)
+        return toSeededJsonEvent(event);
     if (event.type !== "message_update") {
         return event;
     }

package/dist/modes/rpc/compact-commit-dependencies.d.ts

@@ -0,0 +1,13 @@
+import type { CompactContentStore, LeafId } from "./compact-content-store.ts";
+/** Per-owner readiness, independent of counted references: one leaf can unblock many rows/trees. */
+export declare class CompactCommitDependencies<Key> {
+    private readonly pending;
+    private readonly dependants;
+    private readonly store;
+    constructor(store: CompactContentStore, ready: (key: Key) => void);
+    get size(): number;
+    has(key: Key): boolean;
+    set(key: Key, refs: readonly LeafId[]): void;
+    delete(key: Key): void;
+}
+//# sourceMappingURL=compact-commit-dependencies.d.ts.map

package/dist/modes/rpc/compact-commit-dependencies.js

@@ -0,0 +1,48 @@
+/** Per-owner readiness, independent of counted references: one leaf can unblock many rows/trees. */
+export class CompactCommitDependencies {
+    constructor(store, ready) {
+        this.pending = new Map();
+        this.dependants = new Map();
+        this.store = store;
+        store.subscribeCommitted((id) => {
+            const keys = this.dependants.get(id);
+            this.dependants.delete(id);
+            for (const key of keys ?? []) {
+                const pending = this.pending.get(key);
+                pending?.delete(id);
+                if (pending?.size === 0) {
+                    this.pending.delete(key);
+                    ready(key);
+                }
+            }
+        });
+    }
+    get size() {
+        return this.pending.size;
+    }
+    has(key) {
+        return this.pending.has(key);
+    }
+    set(key, refs) {
+        this.delete(key);
+        const pending = new Set(refs.filter((id) => !this.store.isCommitted(id)));
+        if (pending.size === 0)
+            return;
+        this.pending.set(key, pending);
+        for (const id of pending) {
+            const keys = this.dependants.get(id) ?? new Set();
+            keys.add(key);
+            this.dependants.set(id, keys);
+        }
+    }
+    delete(key) {
+        for (const id of this.pending.get(key) ?? []) {
+            const keys = this.dependants.get(id);
+            keys?.delete(key);
+            if (keys?.size === 0)
+                this.dependants.delete(id);
+        }
+        this.pending.delete(key);
+    }
+}
+//# sourceMappingURL=compact-commit-dependencies.js.map

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

@@ -0,0 +1,84 @@
+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 compacting;
+    private tombstones;
+    private tombstoneKeyUnits;
+    private readonly frozen;
+    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;
+    /** 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