@toddzheng024/dscode-bundle 0.7.11 → 0.7.13

package/vendor/tui/types/render/projection.d.ts

@@ -1,587 +0,0 @@
-/**
- * Pure session-event-to-view projection for the TUI transcript: one reducer
- * over {@link SessionEvent}s producing the ordered entries the renderer draws.
- * Rendering never reads the session directly — this module owns the view
- * model, so tests drive it with plain event arrays.
- *
- * @module @deepseek-ai/dsh-tui/render/projection
- */
-import { type ImageBlock, type MessageId, type StreamChunk } from '@deepseek-ai/dsh-llm';
-import type { FileAttachmentRef } from '@deepseek-ai/dsh-attachment';
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
-import type { TodoItem } from '@deepseek-ai/dsh-tool-todo';
-import { type ToolDetail } from './tool-detail.ts';
-/** One user prompt line. */
-export interface UserEntry {
-    kind: 'user';
-    /** Joined text blocks of the user message. */
-    text: string;
-    /** True for collapsed injected context (plugin/continuation notices), which
-     * the renderer marks with a dim ↳ instead of the user ❯ prompt. */
-    notice: boolean;
-    /** Durable image references carried by this prompt. */
-    images?: readonly ImageBlock['attachment'][];
-    /** Durable file references carried by this prompt (0.1.5 file blocks). */
-    files?: readonly FileAttachmentRef[];
-    /**
-     * How the prompt reached the agent, when it did not arrive as an ordinary
-     * submission: `queued` waited for this turn, `steered` joined it mid-flight.
-     * Absent for a prompt typed straight into an idle composer.
-     */
-    delivery?: 'queued' | 'steered';
-}
-/** One user message waiting in the agent inbox (the web's queued-message row). */
-export interface PendingEntry {
-    kind: 'pending';
-    /** Stable message identity shared with the durable `user/message` that retires it. */
-    messageId: MessageId;
-    /** Which inbox list holds the message: steering is consumed at the next step boundary. */
-    target: 'next-turn' | 'next-step';
-    /** Full message text — Codex PendingSteer renders queued prompts exactly like user rows. */
-    text: string;
-    /** Durable image references queued with this prompt. */
-    images?: readonly ImageBlock['attachment'][];
-    /** Durable file references queued with this prompt (0.1.5 file blocks). */
-    files?: readonly FileAttachmentRef[];
-}
-/** One authoritative assembled assistant reply. */
-export interface AssistantEntry {
-    kind: 'assistant';
-    /** Joined text blocks of the assistant message. */
-    text: string;
-    /** Joined reasoning blocks from the same assembled message. */
-    reasoning: string;
-    /** True when a cancelled stream's delivered prefix was finalized as this
-     * entry (rc.8 `assistant/message.interrupted`) — rendered with a marker. */
-    interrupted?: true;
-}
-/** One model-requested tool invocation and its settled state. */
-export interface ToolEntry {
-    kind: 'tool';
-    /** Correlation id shared with the matching `tool/result`. */
-    callId: string;
-    /**
-     * Global tool-call ordinal across the whole transcript (1, 2, 3…, never
-     * reset between turns). The tool-card badge and every error line that
-     * references the failed call share this number, so "call N" in an error
-     * always names the exact card the badge shows.
-     */
-    ordinal: number;
-    /** Tool name as the model addressed it. */
-    name: string;
-    /** Raw arguments JSON string exactly as the model produced it. */
-    arguments: string;
-    /** Bounded human-meaningful arguments preview for the tool card. */
-    preview: string;
-    /** Bounded delegation prompt (subagent cards' second row), '' when none. */
-    prompt: string;
-    /** Execution state; `running` until the paired result lands. */
-    state: 'running' | 'done' | 'error';
-    /** Bounded first text block of the result, empty until it lands. */
-    summary: string;
-    /**
-     * Bounded expansion payload for the verbose transcript (Ctrl+O), derived
-     * from the tool's persisted presentation metadata; undefined until the
-     * result lands and only when something renderable exists.
-     */
-    detail: ToolDetail | undefined;
-    /**
-     * Nested PTC sub-dispatches (`run_code`) in start order, bounded to the
-     * newest {@link MAX_TOOL_SUB_DISPATCHES} rows.
-     */
-    subs: readonly ToolSubDispatch[];
-    /** Sub-dispatches evicted from the bounded window. */
-    subsDropped: number;
-}
-/**
- * One nested PTC sub-dispatch under a `run_code` parent call: the durable
- * `tool/ptc-dispatch-start`/`tool/ptc-dispatch` pair folded to one bounded
- * row (upstream contract: pair by `subCallId`, every start settles, and the
- * settle carries `tool/result`'s own vocabulary).
- */
-export interface ToolSubDispatch {
-    /** Opaque sub-call id pairing the start with its settle. */
-    subCallId: string;
-    /** Sub-call tool name. */
-    name: string;
-    /** Bounded arguments preview. */
-    preview: string;
-    /** Lifecycle; `running` until the paired settle lands. */
-    state: 'running' | 'done' | 'error';
-    /** Bounded first text block of the settle content, '' until it lands. */
-    summary: string;
-    /** Wall-clock duration (settle − start), 0 while running. */
-    durationMs: number;
-}
-/** Bounded sub-dispatch window per tool card (display budget only). */
-export declare const MAX_TOOL_SUB_DISPATCHES = 12;
-/** Bounded member window per workflow run card (display budget only). */
-export declare const MAX_WORKFLOW_MEMBERS = 12;
-/** One workflow member (an `agent()` call inside a `workflow` script). */
-export interface WorkflowMember {
-    /** Member sequence within the run (the agent-start/agent-end pairing key). */
-    seq: number;
-    /** Display label. */
-    label: string;
-    /** Declared phase title, '' when none. */
-    phase: string;
-    /** Child session id (cross-links the subagent feed's rows). */
-    childId: string;
-    /** Settlement; `running` until the paired `tool-workflow/agent-end`. */
-    outcome: 'running' | 'completed' | 'failed' | 'cancelled';
-}
-/**
- * One durable workflow run (the `tool-workflow/*` record a `workflow` or
- * `ralph` tool appends to the parent session): run identity plus its
- * bounded member list, live until `tool-workflow/run-end` settles.
- */
-export interface WorkflowEntry {
-    kind: 'workflow';
-    /** Stable run identity shared by every event of the run. */
-    runId: string;
-    /** Display name of the run. */
-    name: string;
-    /** Members in sequence order, bounded to the newest window. */
-    members: readonly WorkflowMember[];
-    /** Members evicted from the bounded window. */
-    membersDropped: number;
-    /** Run settlement; `running` until `tool-workflow/run-end`. */
-    state: 'running' | 'completed' | 'cancelled' | 'error';
-}
-/** One slash-command execution dispatched through `ctx.commands`. */
-export interface CommandEntry {
-    kind: 'command';
-    /** Pairing id shared with the matching `command/done`. */
-    commandId: string;
-    /** Lowercase command name without the leading slash. */
-    name: string;
-    /** Verbatim text following the command name. */
-    args: string;
-    /** Execution state; `running` until the paired lifecycle event lands. */
-    state: 'running' | 'done' | 'error';
-    /** Handler outcome text, empty until it lands. */
-    summary: string;
-}
-/** One turn-level failure surfaced from `turn/end`. */
-export interface ErrorEntry {
-    kind: 'error';
-    /** `code: message` of the failure. */
-    text: string;
-}
-/** One non-error turn outcome surfaced from `turn/end`. */
-export interface TurnMarkerEntry {
-    kind: 'turn-marker';
-    /** Human-readable outcome line, dim-rendered. */
-    text: string;
-}
-/** One completed compaction lifecycle surfaced from `compaction/end`. */
-export interface CompactionEntry {
-    kind: 'compaction';
-    /** True when the compaction completed, false when it failed. */
-    ok: boolean;
-    /** Heuristic tokens shadowed by the compaction (summary or prune price). */
-    tokens: number;
-    /** Failure text when `ok` is false, empty otherwise. */
-    error: string;
-}
-/** One provider-routed model-request retry (the `llm/retry` pair). */
-export interface RetryEntry {
-    kind: 'retry';
-    /** Correlation id shared with the matching `llm/retry-started`. */
-    retryId: string;
-    /** Retry policy mode from the event: `always` has no attempt cap. */
-    mode: 'normal' | 'always';
-    /** Attempt ordinal and its cap. */
-    attempt: number;
-    max: number;
-    /** Failure code that triggered the retry. */
-    code: string;
-    /** Backoff wait before the next attempt, in ms. */
-    delayMs: number;
-    /**
-     * `running` while the backoff waits, `done` once the attempt started — or
-     * when the turn ended first (the turn-end sweep finalizes orphans so they
-     * never pin the settled boundary).
-     */
-    state: 'running' | 'done';
-}
-/** Turn-tail deliverables: files mutated by the turn's diff-bearing tools. */
-export interface FilesEntry {
-    kind: 'files';
-    /** Unique mutated paths in call order, bounded. */
-    paths: readonly string[];
-}
-/** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | PendingEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry | WorkflowEntry;
-/** The live goal the status line badges, folded from `goal/change`. */
-export interface GoalFold {
-    /** Human-requested completion objective. */
-    objective: string;
-    /** Durable lifecycle phase. */
-    phase: 'active' | 'paused' | 'blocked' | 'complete';
-    /** Highest admitted continuation round and its cap. */
-    rounds: number;
-    max: number;
-    /** Blocked explanation, empty outside the blocked phase. */
-    blocked: string;
-}
-/**
- * Cumulative token accounting folded from `assistant/message` usage reports.
- * The buckets are disjoint and mirror the provider's report, so the prompt
- * side is never double counted: reasoning tokens are already inside
- * `outputTokens`, and cache reads are never folded into the uncached input.
- */
-export interface UsageTotals {
-    /** Prompt-side tokens billed outside the cache. */
-    uncachedInputTokens: number;
-    /** Completion-side tokens over the whole log. */
-    outputTokens: number;
-    /** Cache-read tokens over the whole log (0 when the adapter reports none). */
-    cacheReadTokens: number;
-    /** Cache-write tokens over the whole log (0 when the adapter reports none). */
-    cacheWriteTokens: number;
-}
-/**
- * Estimated used tokens per context content type, folded from transcript
- * events via {@link estimateTokens}. The segmented context bar's composition
- * source: proportions across types are meaningful, absolute values are not
- * (they never touch billing or the reported `lastPromptTokens`).
- */
-export interface ContextSegments {
-    /** Rendered system-prompt text (latest `request/header`) plus injected-context notices. */
-    system: number;
-    /** Direct human prompts (durable `user/message` rows). */
-    prompt: number;
-    /** Assistant text blocks (visible replies). */
-    assistant: number;
-    /** Assistant reasoning blocks (hidden thinking). */
-    thinking: number;
-    /** Tool call arguments plus result text. */
-    tools: number;
-}
-/** Window-scoped figures the status line shows; timing uses event timestamps. */
-export interface TranscriptStats {
-    /** Durable turns opened (`turn/start` events). */
-    turns: number;
-    /** Model requests made (`step/start` events). */
-    steps: number;
-    /** Summed model wall time: `step/start` → `assistant/message`, in ms. */
-    llmMs: number;
-    /** Summed tool wall time: `tool/call` → `tool/result`, in ms. */
-    toolMs: number;
-    /** Cumulative token accounting; input stays 0 until a report lands. */
-    usage: UsageTotals;
-    /** Prompt-side size of the most recent reported request (context pressure). */
-    lastPromptTokens: number;
-    /** Newest advertised route capacity, 0 when no adapter ever advertised one. */
-    contextWindow: number;
-    /** Estimated used tokens per content type (the segmented bar's composition). */
-    contextSegments: ContextSegments;
-    /** Summed first-token waits: `step/start` → first non-empty chunk, in ms. */
-    ttftMs: number;
-    /** Steps that produced a first chunk (the TTFT average's denominator). */
-    ttftSteps: number;
-    /** Summed decode spans: first chunk → `assistant/message`, in ms. */
-    decodeMs: number;
-    /** Completion tokens over timed decode spans (the tok/s numerator). */
-    decodeTokens: number;
-    /**
-     * Adapter-owned reasoning effort of the latest `request/header` config —
-     * the EFFECTIVE effort the session actually uses (a materialized model
-     * default is included, exactly as the adapter resolved it). Empty when the
-     * header carried none (provider-default behavior). The status line appends
-     * it to the model segment as `provider/model@effort`.
-     */
-    reasoningEffort: string;
-}
-/** One active reminder folded from durable `schedule/change` events. */
-export interface ScheduleRow {
-    readonly id: string;
-    readonly kind: 'after' | 'at' | 'every';
-    readonly prompt: string;
-    /** Next due time (epoch ms); the /schedule panel derives overdue/relative labels. */
-    readonly targetAt: number;
-    /** Recurrence seconds for 'every' rows, undefined otherwise. */
-    readonly everySeconds?: number;
-}
-/**
- * The durable `schedule/change` payload shape this fold consumes. Upstream
- * strict-decodes the whole transition stream before appending, so unknown
- * ids here are corrupt-input edges that degrade to a no-op.
- */
-export interface ScheduleChangeLike {
-    readonly operation: 'create' | 'delete' | 'dispatch';
-    readonly schedule?: {
-        readonly id: string;
-        readonly kind: 'after' | 'at' | 'every';
-        readonly prompt: string;
-        readonly afterSeconds?: number;
-        readonly everySeconds?: number;
-        readonly scheduledAt: string;
-    };
-    readonly id?: string;
-    readonly acceptedAt?: string;
-}
-/** Fold one `schedule/change` into the active-reminder list (create/delete/dispatch). */
-export declare function applyScheduleChange(rows: readonly ScheduleRow[], data: ScheduleChangeLike): readonly ScheduleRow[];
-/** First anchor-aligned target after `acceptedAt`, stepping from the previous aligned target. */
-export declare function nextEveryTarget(previousTarget: number, acceptedAt: number, everySeconds: number): number;
-/** The complete TUI transcript view for one session. */
-export interface TranscriptView {
-    /** Settled entries in log order. */
-    entries: readonly TranscriptEntry[];
-    /** Bounded text tail accumulated from live stream frames since the last settlement. */
-    streaming: string;
-    /** Bounded thinking tail accumulated from reasoning deltas since the last flush. */
-    streamingReasoning: string;
-    /** Latest whole-list todo snapshot from `todo/write`, empty when none. */
-    todos: readonly TodoItem[];
-    /**
-     * Global tool-call ordinal counter: the number the NEXT `tool/call` lands
-     * with (1-based). Never reset, so the counter and the badges/error lines
-     * stay consistent across turns and resumed sessions.
-     */
-    toolCallOrdinal: number;
-    /** True while a durable turn is open (`turn/start` … `turn/end`). */
-    busy: boolean;
-    /** `turn/start` time of the open turn (0 while idle) — the web TurnStatus clock anchor. */
-    busySince: number;
-    /** Figures the status line renders. */
-    stats: TranscriptStats;
-    /**
-     * The `provider/model` pair of the last `request/header` snapshot — the
-     * session's own model record, which a resumed TUI prefers over the
-     * deployment default (mirrors the web host's resume selection order).
-     * Empty before the session's first request.
-     */
-    model: string;
-    /** Plan mode state folded from the last `plan/mode` event. */
-    plan: boolean;
-    /** Active permission preset folded from the last `permission/preset` event, empty before one. */
-    permission: string;
-    /** Latest session title folded from the last `session/title` event, empty before one. */
-    title: string;
-    /**
-     * Effective system prompt assembled from `system/message` surface nodes
-     * (v3): the head node's text joined with every later non-empty node, blank
-     * lines between. Empty before the first system node or when every node is
-     * empty ("no system prompt").
-     */
-    systemPrompt: string;
-    /** Sandbox-mode override folded from the last `sandbox/mode` event, empty when never switched. */
-    sandbox: string;
-    /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
-    goal: GoalFold | undefined;
-    /** Active reminders folded from `schedule/change` events, oldest target first at render. */
-    schedules: readonly ScheduleRow[];
-    /**
-     * Ordered live message ids per inbox target, mirrored from
-     * `agent/inbox/spliced` exactly like the upstream Inbox projection — the
-     * coordinates later removals resolve against.
-     */
-    pending: {
-        'next-turn': readonly string[];
-        'next-step': readonly string[];
-    };
-    /**
-     * In-flight inbox messages by the list they were inserted into, kept until
-     * the durable user message that claims them lands. The claim itself is a
-     * plain splice that empties the pending row first, so this map — not
-     * {@link pending} — is what lets a settled prompt say it was queued or
-     * steered rather than typed into an idle composer.
-     */
-    claimOrigin: ReadonlyMap<string, 'next-turn' | 'next-step'>;
-    /**
-     * Fold-internal timing anchors, never rendered: open step and tool-call
-     * start timestamps the next `assistant/message` / `tool/result` resolves
-     * against. Keyed `turn:step` and by call id. `turnSteps`/`turnTools`
-     * track which step/tool anchors still belong to the open turn so
-     * `turn/end` (and a superseding `step/start`) can sweep anchors an
-     * interruption left behind; `turnFiles` keys mutated paths by turn.
-     */
-    readonly anchors: {
-        stepStart: Map<string, number>;
-        toolStart: Map<string, number>;
-        /** Open PTC sub-dispatch starts by `subCallId` (duration anchors). */
-        subStart: Map<string, number>;
-        firstChunkAt: Map<string, number>;
-        compactionTokens: Map<string, number>;
-        lastPruneTokens: number;
-        turnFiles: Map<number, Set<string>>;
-        turnSteps: Map<number, string>;
-        turnTools: Map<number, Set<string>>;
-        /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
-        systemNodes: Map<number, string>;
-    };
-}
-/** Human-readable bounded image labels for transcript, inspector, and export surfaces. */
-export declare function imageLabels(images: readonly ImageBlock['attachment'][] | undefined): string;
-/** Human-readable bounded file labels for the same surfaces (0.1.5 file blocks). */
-export declare function fileLabels(files: readonly FileAttachmentRef[] | undefined): string;
-/** Prompt text with its durable image and file labels, without exposing local paths or bytes. */
-export declare function promptDisplayText(entry: Pick<UserEntry | PendingEntry, 'text' | 'images' | 'files'>): string;
-/** A fresh, empty transcript view. */
-export declare function createTranscriptView(): TranscriptView;
-/**
- * Fold one session event into an updated view (copy-on-write).
- * @param view - the view before the event.
- * @param event - one durable session event from `session/event` or the log.
- * @returns the view after the event; the input view is never mutated.
- */
-export declare function projectEvent(view: TranscriptView, event: SessionEvent): TranscriptView;
-/**
- * Mutable replay accumulator: folds a persisted log into the identical view
- * `projectEvent` would produce, but in near-linear time. Where `projectEvent`
- * is copy-on-write — every append/scan rebuilds the whole `entries` array, so
- * folding a full log costs O(N²) — the accumulator appends by push, resolves
- * id-keyed updates (tool/result, command/done, retry-started) through index
- * maps, and tombstones retired pending rows, so the whole log folds in O(N)
- * plus one compaction pass when tombstones exist.
- *
- * Index maps never delete: every appended row registers its index, so an id
- * lookup miss provably means no matching row exists and the update is an O(1)
- * no-op (a malicious/orphan-heavy log cannot force per-orphan full-array
- * scans). Each id maps to ALL of its indices, so a duplicate id updates every
- * matching row exactly like the copy-on-write reducer.
- *
- * @internal Exported only so tests can (a) prove replay ≡ sequential
- * `projectEvent` folds and (b) assert the linear complexity deterministically
- * via {@link ReplayAccumulator.ops}, which counts entry-level container work
- * instead of relying on wall-clock thresholds. No public consumer.
- */
-export interface ReplayAccumulator {
-    /** Working entry list; `undefined` marks a retired pending row (tombstone). */
-    entries: (TranscriptEntry | undefined)[];
-    /** callId → every index into `entries` holding a `tool` row with that id. */
-    toolIndex: Map<string, number[]>;
-    /** commandId → every index into `entries` holding a `command` row with that id. */
-    commandIndex: Map<string, number[]>;
-    /** retryId → every index into `entries` holding a `retry` row with that id. */
-    retryIndex: Map<string, number[]>;
-    /** messageId → every index into `entries` holding a `pending` row with that id. */
-    pendingIndex: Map<string, number[]>;
-    /** runId → every index into `entries` holding a `workflow` row with that id. */
-    workflowIndex: Map<string, number[]>;
-    /** Tombstone count; zero means `entries` is already the final array. */
-    removedCount: number;
-    /** Mutable inbox id lists, mirroring `view.pending` order per target. */
-    pendingTurn: string[];
-    pendingStep: string[];
-    /** Mutable mirror of `view.claimOrigin` (see the reducer's field doc). */
-    claimOrigin: Map<string, 'next-turn' | 'next-step'>;
-    streaming: string;
-    streamingReasoning: string;
-    todos: readonly TodoItem[];
-    /** Global tool-call ordinal counter (see `TranscriptView.toolCallOrdinal`). */
-    toolCallOrdinal: number;
-    busy: boolean;
-    busySince: number;
-    model: string;
-    plan: boolean;
-    permission: string;
-    title: string;
-    systemPrompt: string;
-    sandbox: string;
-    goal: GoalFold | undefined;
-    schedules: readonly ScheduleRow[];
-    stats: TranscriptStats;
-    stepStart: Map<string, number>;
-    toolStart: Map<string, number>;
-    /** Open PTC sub-dispatch starts by `subCallId` (duration anchors). */
-    subStart: Map<string, number>;
-    firstChunkAt: Map<string, number>;
-    compactionTokens: Map<string, number>;
-    lastPruneTokens: number;
-    turnFiles: Map<number, Set<string>>;
-    turnSteps: Map<number, string>;
-    turnTools: Map<number, Set<string>>;
-    /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
-    systemNodes: Map<number, string>;
-    /** Entry-level container operations performed so far (test instrumentation). */
-    ops: number;
-}
-/** @internal A fresh replay accumulator whose state mirrors `createTranscriptView()`. */
-export declare function createReplayAccumulator(): ReplayAccumulator;
-/**
- * Fold one session event into a replay accumulator. This mirrors
- * {@link projectEvent} case for case — same stats arithmetic, same anchor
- * set/delete behavior, same entry shapes — so the finished view is identical
- * to a sequential fold; only the `entries` container operations are mutable.
- *
- * @internal Test-instrumentation path; `projectEvents` is the public entry.
- * @returns whether the event changed the accumulated state — the live store
- * stays silent and keeps its snapshot identity for ignored events, exactly
- * like the copy-on-write reducer returning its input view unchanged.
- */
-export declare function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): boolean;
-/**
- * Materialize the accumulated fold as a `TranscriptView`, compacting any
- * retired tombstones. The anchors maps are handed through as-is (their
- * content is identical to a sequential fold's).
- *
- * @internal Test-instrumentation path; `projectEvents` is the public entry.
- */
-export declare function finishReplay(acc: ReplayAccumulator): TranscriptView;
-/**
- * Materialize the accumulated fold as a fresh immutable snapshot for the
- * live store. Unlike {@link finishReplay} — the one-shot replay entry, which
- * hands the accumulator's own arrays through because the accumulator is
- * discarded — every array a renderer can hold is copied here, so later
- * folds never mutate a snapshot already handed out. Same fields, same
- * tombstone compaction.
- *
- * @internal Live-store path; `projectEvents` is the public entry.
- */
-export declare function snapshotReplayView(acc: ReplayAccumulator): TranscriptView;
-/**
- * Fold a replayed event history into one view.
- *
- * Folding is near-linear in the log size: the mutable replay accumulator
- * appends in place and resolves id-keyed updates through index maps, so a
- * long persisted session replays without the O(N²) copy-on-write rebuilds a
- * naive sequential fold would incur. The result is identical to folding
- * {@link projectEvent} per event in order.
- * @param events - events in `seq` order.
- * @returns the folded view.
- */
-export declare function projectEvents(events: readonly SessionEvent[]): TranscriptView;
-/**
- * Fold one process-local assistant-stream chunk frame (session-log v2+ keeps
- * durable logs settlement-only; live typing rides the `agent/assistant-stream`
- * agent event). Same first-token anchoring the durable `assistant/chunk` event
- * used to carry: the first non-empty delta anchors the TTFT and empty
- * keep-alive deltas do not count. The caller maps the frame's attempt to the
- * `turn:step` key (the start frame owns turn/step; chunk frames do not).
- * @param acc - the live replay accumulator.
- * @param key - the `turn:step` key the attempt's start frame declared.
- * @param time - the frame's safe-integer timestamp.
- * @param chunk - the model chunk the frame carries.
- * @returns whether the accumulator changed (the store stays silent otherwise).
- */
-export declare function applyAssistantStreamChunk(acc: ReplayAccumulator, key: string, time: number, chunk: StreamChunk): boolean;
-/**
- * Drop the live streaming tails without a settlement (an `agent/assistant-stream`
- * end frame with an `abandoned` outcome, or a session switch). The next start
- * frame rebuilds from scratch.
- * @param acc - the live replay accumulator.
- * @returns whether any tail text was discarded.
- */
-export declare function clearAssistantStream(acc: ReplayAccumulator): boolean;
-/**
- * The append-only flush boundary for a transcript view: the count of entries
- * no later event can remove. Entries at or beyond this index are mutable and
- * must stay in the live tree.
- *
- * `pending` rows are excluded even though they are not a running tool/retry:
- * the inbox claims or cancels them durably (`agent/inbox/spliced` removals,
- * `user/message` retirement), and an append-only `<Static>` flush cannot
- * erase a row that vanishes from the view — the retired row would ghost on
- * screen until the next source-backed replay. Running commands join the
- * mutable boundary for the same reason in reverse: `command/done` mutates the
- * row's state/summary, so a flushed row would keep its stale running mark
- * until a resize-triggered replay. Everything else (including a completed
- * tail) is final: later events only APPEND new rows.
- * @param entries - the view's transcript entries in order.
- * @returns the count of entries safe to flush (0 for an empty transcript).
- */
-export declare function settledEntryCount(entries: readonly TranscriptEntry[]): number;