@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineModel.js

@@ -0,0 +1,525 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { basename, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { MultiDiffEditorItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { getChatRequestText } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatRequestText';
+import { IChatResponseFileChangesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService.service';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import { isRequestVM, isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
+import { budgetBucketPrompts, MAX_TICKS } from './promptBucketing.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const MAX_PREVIEW_LENGTH = 80;
+function itemKind(item) {
+    if (isRequestVM(item)) {
+        return "request";
+    }
+    if (isResponseVM(item)) {
+        return "response";
+    }
+    return "other";
+}
+function isPromptTimelineRequest(item) {
+    return isRequestVM(item) && !item.isSystemInitiated;
+}
+const CHARS_PER_LINE = 48;
+const CODE_BLOCK_UNITS = 3;
+const MAX_SIGNAL = 60;
+const PRIOR_PX_PER_UNIT = {
+    request: 18,
+    response: 20,
+    other: 40
+};
+function getPromptPreview(text) {
+    const firstLine = ( text.split("\n").map(l => l.trim())).find(l => l.length > 0) ?? "";
+    return firstLine.length <= MAX_PREVIEW_LENGTH ? firstLine : `${firstLine.slice(0, MAX_PREVIEW_LENGTH)}…`;
+}
+function promptsEqual(a, b) {
+    return a.length === b.length && a.every(
+        (p, i) => p.requestId === b[i].requestId && p.text === b[i].text && p.timestamp === b[i].timestamp
+    );
+}
+let PromptTimelineModel = class PromptTimelineModel extends Disposable {
+    get ticks() {
+        return this._ticks;
+    }
+    get promptTicks() {
+        return this._promptTicks;
+    }
+    get activeRequestId() {
+        return this._activeRequestId;
+    }
+    get activePromptId() {
+        return this._activePromptId;
+    }
+    get activePinned() {
+        return this._scrollPinned;
+    }
+    get activePrompt() {
+        return this._activePrompt;
+    }
+    get onDidChangeScrollLayout() {
+        return this._scrollLayoutSignal;
+    }
+    constructor(
+        widget,
+        chatEditingService,
+        chatResponseFileChangesService,
+        editorService,
+        instantiationService,
+        fileService
+    ) {
+        super();
+        this.widget = widget;
+        this.chatEditingService = chatEditingService;
+        this.chatResponseFileChangesService = chatResponseFileChangesService;
+        this.editorService = editorService;
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this._prompts = observableValue(this, []);
+        this._editingSession = derived(this, reader => {
+            const resource = this._sessionResource.read(reader);
+            if (!resource) {
+                return undefined;
+            }
+            this.chatEditingService.editingSessionsObs.read(reader);
+            return this.chatEditingService.getEditingSession(resource);
+        });
+        this._baseTicks = derived(this, reader => {
+            const prompts = this._prompts.read(reader);
+            return (budgetBucketPrompts(prompts, Date.now(), MAX_TICKS).map(bucket => ({
+                requestId: bucket.prompt.requestId,
+                allRequestIds: ( bucket.prompts.map(p => p.requestId)),
+                text: bucket.prompt.text,
+                timestamp: bucket.prompt.timestamp,
+                count: bucket.count,
+                ariaLabel: bucket.count === 1 ? ( localize(8889, "Prompt: {0}", bucket.prompt.text)) : ( localize(8890, "{0} prompts starting with: {1}", bucket.count, bucket.prompt.text))
+            })));
+        });
+        this._ticks = derived(this, reader => {
+            const base = this._baseTicks.read(reader);
+            return ( base.map(tick => {
+                const stat = this._statForRequests(tick.allRequestIds, reader);
+                return stat ? {
+                    ...tick,
+                    stat
+                } : tick;
+            }));
+        });
+        this._promptTicks = derived(this, reader => {
+            const prompts = this._prompts.read(reader);
+            return (prompts.map(prompt => {
+                const base = {
+                    requestId: prompt.requestId,
+                    allRequestIds: [prompt.requestId],
+                    text: prompt.text,
+                    timestamp: prompt.timestamp,
+                    count: 1,
+                    ariaLabel: ( localize(8889, "Prompt: {0}", prompt.text))
+                };
+                const stat = this._statForRequests(base.allRequestIds, reader);
+                return stat ? {
+                    ...base,
+                    stat
+                } : base;
+            }));
+        });
+        this._activeRequestId = observableValue(this, undefined);
+        this._activePromptId = observableValue(this, undefined);
+        this._scrollPinned = observableValue(this, false);
+        this._activePrompt = derived(this, reader => {
+            const id = this._activePromptId.read(reader);
+            if (id === undefined) {
+                return undefined;
+            }
+            const prompts = this._prompts.read(reader);
+            const index = prompts.findIndex(p => p.requestId === id);
+            return index < 0 ? undefined : {
+                text: prompts[index].text,
+                index: index + 1,
+                total: prompts.length
+            };
+        });
+        this._scrollLayoutSignal = observableSignal(this);
+        this._viewModelListener = this._register(( new MutableDisposable()));
+        this._signalCache = ( new Map());
+        this._previewCache = ( new Map());
+        this._sessionResource = observableFromEvent(
+            this,
+            this.widget.onDidChangeViewModel,
+            () => this.widget.viewModel?.sessionResource
+        );
+        this._register(this.widget.onDidChangeViewModel(() => this._bindViewModel()));
+        this._register(this.widget.onDidScroll(() => {
+            this._updateActive();
+            this._triggerScrollLayout();
+        }));
+        this._register(this.widget.onDidChangeContentHeight(() => this._triggerScrollLayout()));
+        this._register(autorun(reader => {
+            this._baseTicks.read(reader);
+            this._updateActive();
+            this._triggerScrollLayout();
+        }));
+        this._bindViewModel();
+    }
+    _triggerScrollLayout() {
+        transaction(tx => this._scrollLayoutSignal.trigger(tx));
+    }
+    getScrollLayout() {
+        const layout = this._computeAdaptiveLayout();
+        if (!layout) {
+            return undefined;
+        }
+        const {
+            items,
+            tops,
+            total
+        } = layout;
+        const marks = [];
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (isPromptTimelineRequest(item)) {
+                marks.push({
+                    requestId: item.id,
+                    top: tops[i]
+                });
+            }
+        }
+        return {
+            marks,
+            total,
+            scrollTop: this.widget.scrollTop,
+            scrollHeight: this.widget.scrollHeight,
+            viewportHeight: this.widget.viewportHeight
+        };
+    }
+    _computeAdaptiveLayout() {
+        const items = this.widget.viewModel?.getItems();
+        if (!items) {
+            return undefined;
+        }
+        const measuredPx = {
+            request: 0,
+            response: 0,
+            other: 0
+        };
+        const measuredSignal = {
+            request: 0,
+            response: 0,
+            other: 0
+        };
+        for (const item of items) {
+            const measured = item.currentRenderedHeight;
+            if (measured !== undefined && measured > 0) {
+                const kind = itemKind(item);
+                measuredPx[kind] += measured;
+                measuredSignal[kind] += this._itemSignal(item);
+            }
+        }
+        const pxPerUnit = kind => measuredSignal[kind] > 0 ? measuredPx[kind] / measuredSignal[kind] : PRIOR_PX_PER_UNIT[kind];
+        const tops = [];
+        let acc = 0;
+        for (const item of items) {
+            tops.push(acc);
+            const measured = item.currentRenderedHeight;
+            acc += (measured !== undefined && measured > 0) ? measured : pxPerUnit(itemKind(item)) * this._itemSignal(item);
+        }
+        return {
+            items,
+            tops,
+            total: acc
+        };
+    }
+    _itemSignal(item) {
+        if (isRequestVM(item)) {
+            const cached = this._signalCache.get(item.id);
+            const version = item.messageText.length;
+            if (cached && cached.version === version) {
+                return cached.signal;
+            }
+            const signal = Math.min(MAX_SIGNAL, 1 + Math.ceil(version / CHARS_PER_LINE));
+            this._signalCache.set(item.id, {
+                version,
+                signal
+            });
+            return signal;
+        }
+        if (isResponseVM(item)) {
+            const parts = item.response.value;
+            const cached = this._signalCache.get(item.id);
+            if (cached && cached.version === parts.length) {
+                return cached.signal;
+            }
+            const text = item.response.getMarkdown();
+            const codeBlocks = Math.floor((text.match(/```/g)?.length ?? 0) / 2);
+            const lines = Math.ceil(text.length / CHARS_PER_LINE);
+            const signal = Math.min(MAX_SIGNAL, 1 + lines + codeBlocks * CODE_BLOCK_UNITS);
+            this._signalCache.set(item.id, {
+                version: parts.length,
+                signal
+            });
+            return signal;
+        }
+        return 1;
+    }
+    _requestPreview(item) {
+        const messageText = item.messageText;
+        const cached = this._previewCache.get(item.id);
+        if (cached && cached.messageText === messageText) {
+            return cached.preview;
+        }
+        const preview = getPromptPreview(getChatRequestText(item));
+        this._previewCache.set(item.id, {
+            messageText,
+            preview
+        });
+        return preview;
+    }
+    _bindViewModel() {
+        this._signalCache.clear();
+        this._previewCache.clear();
+        this._viewModelListener.value = this.widget.viewModel?.onDidChange(() => this._recompute());
+        this._recompute();
+    }
+    _recompute() {
+        const prompts = [];
+        for (const item of this.widget.viewModel?.getItems() ?? []) {
+            if (isPromptTimelineRequest(item)) {
+                prompts.push({
+                    requestId: item.id,
+                    text: this._requestPreview(item),
+                    timestamp: item.timestamp
+                });
+            }
+        }
+        if (promptsEqual(prompts, this._prompts.get())) {
+            this._updateActive();
+            return;
+        }
+        this._prompts.set(prompts, undefined);
+    }
+    _updateActive() {
+        const ticks = this._baseTicks.get();
+        const items = this.widget.viewModel?.getItems();
+        if (!items || ticks.length === 0) {
+            transaction(tx => {
+                this._activeRequestId.set(undefined, tx);
+                this._activePromptId.set(undefined, tx);
+                this._scrollPinned.set(false, tx);
+            });
+            return;
+        }
+        const scrollTop = this.widget.scrollTop;
+        const isScrolledToBottom = scrollTop + this.widget.viewportHeight >= this.widget.scrollHeight - 2;
+        let activeRequestId;
+        let activeTimestamp = 0;
+        let activeTop = -1;
+        if (isScrolledToBottom) {
+            for (let i = items.length - 1; i >= 0; i--) {
+                const item = items[i];
+                if (!isPromptTimelineRequest(item)) {
+                    continue;
+                }
+                const top = this.widget.getElementTop(item);
+                if (top === undefined || top > scrollTop) {
+                    continue;
+                }
+                activeRequestId = item.id;
+                activeTimestamp = item.timestamp;
+                activeTop = top;
+                break;
+            }
+        } else {
+            for (const item of items) {
+                if (isPromptTimelineRequest(item)) {
+                    const top = this.widget.getElementTop(item);
+                    if (top === undefined) {
+                        continue;
+                    }
+                    if (top > scrollTop) {
+                        break;
+                    }
+                    activeRequestId = item.id;
+                    activeTimestamp = item.timestamp;
+                    activeTop = top;
+                }
+            }
+        }
+        if (activeRequestId === undefined) {
+            transaction(tx => {
+                this._activeRequestId.set(ticks.at(0)?.requestId, tx);
+                this._activePromptId.set(this._prompts.get().at(0)?.requestId, tx);
+                this._scrollPinned.set(false, tx);
+            });
+            return;
+        }
+        let activeTick = ticks.find(t => t.allRequestIds.includes(activeRequestId));
+        if (!activeTick) {
+            for (const tick of ticks) {
+                if (tick.timestamp <= activeTimestamp) {
+                    activeTick = tick;
+                } else {
+                    break;
+                }
+            }
+        }
+        const pinned = activeTop < scrollTop - 2;
+        transaction(tx => {
+            this._activeRequestId.set((activeTick ?? ticks[ticks.length - 1]).requestId, tx);
+            this._activePromptId.set(activeRequestId, tx);
+            this._scrollPinned.set(pinned, tx);
+        });
+    }
+    reveal(requestId) {
+        const items = this.widget.viewModel?.getItems();
+        const index = items?.findIndex(i => isRequestVM(i) && i.id === requestId) ?? -1;
+        if (items && index >= 0) {
+            this.widget.reveal(items[index], 0);
+        }
+        const owningTick = this._baseTicks.get().find(t => t.allRequestIds.includes(requestId));
+        this._activeRequestId.set(owningTick?.requestId ?? requestId, undefined);
+    }
+    revealActivePrompt() {
+        const id = this._activePromptId.get();
+        if (id !== undefined) {
+            this.reveal(id);
+        }
+    }
+    getRequestFiles(tick) {
+        const byPath = ( new Map());
+        for (const requestId of tick.allRequestIds) {
+            for (const diff of this._diffsForRequest(requestId)) {
+                if (diff.identical) {
+                    continue;
+                }
+                const key = ( diff.modifiedURI.toString());
+                const existing = byPath.get(key);
+                if (existing) {
+                    byPath.set(key, {
+                        ...existing,
+                        diffModifiedURI: diff.modifiedSnapshotURI ?? diff.modifiedURI,
+                        added: existing.added + diff.added,
+                        removed: existing.removed + diff.removed
+                    });
+                } else {
+                    byPath.set(key, {
+                        name: basename(diff.modifiedURI),
+                        originalURI: diff.originalURI,
+                        modifiedURI: diff.modifiedURI,
+                        diffModifiedURI: diff.modifiedSnapshotURI ?? diff.modifiedURI,
+                        added: diff.added,
+                        removed: diff.removed
+                    });
+                }
+            }
+        }
+        return [...( byPath.values())];
+    }
+    async reviewChanges(tick, file) {
+        const files = this.getRequestFiles(tick);
+        if (files.length === 0) {
+            return;
+        }
+        const items = [];
+        let revealResource;
+        for (const f of files) {
+            const [originalURI, modifiedURI] = await this._readableSides(f);
+            if (!originalURI && !modifiedURI) {
+                continue;
+            }
+            items.push(( new MultiDiffEditorItem(originalURI, modifiedURI, f.modifiedURI)));
+            if (file && isEqual(f.modifiedURI, file)) {
+                revealResource = {
+                    original: originalURI,
+                    modified: modifiedURI
+                };
+            }
+        }
+        if (items.length === 0) {
+            return;
+        }
+        const source = ( URI.parse(`multi-diff-editor:prompt-timeline/${generateUuid()}`));
+        const input = this.instantiationService.createInstance(MultiDiffEditorInput, source, ( localize(8891, "Changes · {0}", tick.text)), items, false);
+        const options = revealResource ? {
+            viewState: {
+                revealData: {
+                    resource: revealResource
+                }
+            }
+        } : undefined;
+        await this.editorService.openEditor(input, options);
+    }
+    async _readableSides(file) {
+        const hasFrozenOriginal = !isEqual(file.originalURI, file.modifiedURI);
+        const hasFrozenModified = !isEqual(file.diffModifiedURI, file.modifiedURI);
+        const [frozenOriginalReadable, frozenModifiedReadable, liveModifiedReadable] = await Promise.all([
+            hasFrozenOriginal ? this._canRead(file.originalURI) : Promise.resolve(false),
+            hasFrozenModified ? this._canRead(file.diffModifiedURI) : Promise.resolve(false),
+            this._canRead(file.modifiedURI)
+        ]);
+        const modified = frozenModifiedReadable ? file.diffModifiedURI : liveModifiedReadable ? file.modifiedURI : undefined;
+        return [frozenOriginalReadable ? file.originalURI : undefined, modified];
+    }
+    async _canRead(resource) {
+        try {
+            await this.fileService.readFile(resource, {
+                length: 1
+            });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+    _diffsForRequest(requestId, reader) {
+        const resource = reader ? this._sessionResource.read(reader) : this._sessionResource.get();
+        if (resource) {
+            const provided = this.chatResponseFileChangesService.getChangesForRequest(resource, requestId);
+            if (provided) {
+                return reader ? provided.read(reader) : provided.get();
+            }
+        }
+        const session = reader ? this._editingSession.read(reader) : this._editingSession.get();
+        if (session) {
+            const obs = session.getDiffsForFilesInRequest(requestId);
+            return reader ? obs.read(reader) : obs.get();
+        }
+        return [];
+    }
+    _statForRequests(requestIds, reader) {
+        let added = 0;
+        let removed = 0;
+        const files = ( new Set());
+        for (const requestId of requestIds) {
+            for (const diff of this._diffsForRequest(requestId, reader)) {
+                if (diff.identical) {
+                    continue;
+                }
+                added += diff.added;
+                removed += diff.removed;
+                files.add(( diff.modifiedURI.toString()));
+            }
+        }
+        return files.size > 0 ? {
+            added,
+            removed,
+            fileCount: files.size
+        } : undefined;
+    }
+};
+PromptTimelineModel = ( __decorate([( __param(1, IChatEditingService)), ( __param(2, IChatResponseFileChangesService)), ( __param(3, IEditorService)), ( __param(4, IInstantiationService)), ( __param(5, IFileService))], PromptTimelineModel));
+
+export { PromptTimelineModel };

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineRail.d.ts

@@ -0,0 +1,33 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IPromptScrollLayout, PromptFileDiff, PromptTick } from "./promptTimelineModel.js";
+export interface IPromptReviewFileEvent {
+    readonly tick: PromptTick;
+    readonly file: URI;
+}
+/**
+ * A prompt timeline rail: a presentation-only vertical strip pinned beside the
+ * chat transcript's native scrollbar that renders one mark per prompt and lets the
+ * user preview, jump to, and review each prompt. Rendered as a proportional
+ * overview ruler, like the editor overview ruler; scrolling stays with the
+ * transcript's own scrollbar.
+ */
+export interface IPromptTimelineRail extends IDisposable {
+    readonly domNode: HTMLElement;
+    /** Fired when a mark is chosen (click / keyboard), with its request id. */
+    readonly onDidSelect: Event<string>;
+    /** Fired to review all of a prompt's changes. */
+    readonly onDidReview: Event<PromptTick>;
+    /** Fired to review a single changed file of a prompt. */
+    readonly onDidReviewFile: Event<IPromptReviewFileEvent>;
+    setFilesProvider(provider: (tick: PromptTick) => readonly PromptFileDiff[]): void;
+    setTicks(ticks: readonly PromptTick[]): void;
+    /** Records a hard/fast wheel flick; the fan blooms only if a real transcript scroll follows shortly after. */
+    notifyHardWheel(): void;
+    setActive(requestId: string | undefined): void;
+    focusTick(requestId: string): void;
+    setHostWidth(width: number): void;
+    /** Supplies proportional scroll positions for the marks. */
+    setScrollLayout(layout: IPromptScrollLayout | undefined): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineRulerRail.d.ts

@@ -0,0 +1,128 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IPromptScrollLayout, PromptFileDiff, PromptTick } from "./promptTimelineModel.js";
+import { IPromptReviewFileEvent, IPromptTimelineRail } from "./promptTimelineRail.js";
+/**
+ * The overview-ruler rail. The whole session is compressed into the rail height
+ * like the editor's overview ruler: each prompt is a mark at its proportional
+ * scroll position, coloured only to signal whether it changed code. The rail sits
+ * in a gutter just beside the transcript's native scrollbar (which keeps handling
+ * scroll and position); the active mark is the "you-are-here". Detail lives in the
+ * hover card.
+ */
+export declare class PromptTimelineRulerRail extends Disposable implements IPromptTimelineRail {
+    private readonly _domNode;
+    private readonly _marksContainer;
+    private readonly _card;
+    private readonly _markDisposables;
+    private readonly _marks;
+    /** Delays enabling the glide until after a structural rebuild's first layout, so freshly created marks don't slide in from the top. */
+    private readonly _glideEnabler;
+    private _activeRequestId;
+    private _layout;
+    private _resizeObserverReady;
+    private _hostWidth;
+    /** Cached rail height; only changes on resize (observed), so we avoid reading it — a forced reflow — on every scroll. */
+    private _railHeight;
+    /** Coalesces scroll-driven relayouts to one per animation frame. */
+    private readonly _relayoutScheduled;
+    /** Lane-local Y the fisheye "fan" magnifies around, or undefined when the fan is at rest. */
+    private _fanCenter;
+    /** Cached top (client px) of the marks column, captured on pointer-enter so the fan can follow the cursor without a per-move reflow. */
+    private _laneTop;
+    /** Cached client Y of the rail's top edge, refreshed on resize; used to place the hover card and derive the lane-local pointer Y without a per-hover forced reflow. */
+    private _domTop;
+    /** True while the pointer is over the lane (keeps the fan open; the linger only collapses once it leaves). */
+    private _hovering;
+    /** Timestamp (ms) of the last hard/fast wheel flick; the fan blooms only if a real scroll follows it within {@link HARD_WHEEL_REVEAL_WINDOW}. */
+    private _hardWheelAt;
+    /** Last scroll offset seen, to detect real transcript movement (vs. a wheel that hit the scroll limit and moved nothing). */
+    private _lastScrollTop;
+    /** Collapses the fan {@link FAN_LINGER}ms after the last scroll, unless the pointer is keeping it open. */
+    private readonly _fanHide;
+    /** Timestamp (ms) of the last scroll/leave that should keep the fan up; the linger timer re-checks this instead of being churned every scroll frame. */
+    private _lastFanActivityAt;
+    /** When the user prefers reduced motion the fan is disabled (marks stay their calm rest size). */
+    private _reducedMotion;
+    /** True while keyboard focus is inside the rail: the marks stay revealed (`:focus-within`) but the fisheye is suppressed. */
+    private _focused;
+    private readonly _onDidSelect;
+    readonly onDidSelect: Event<string>;
+    private readonly _onDidReview;
+    readonly onDidReview: Event<PromptTick>;
+    private readonly _onDidReviewFile;
+    readonly onDidReviewFile: Event<IPromptReviewFileEvent>;
+    get domNode(): HTMLElement;
+    constructor();
+    setFilesProvider(provider: (tick: PromptTick) => readonly PromptFileDiff[]): void;
+    setTicks(ticks: readonly PromptTick[]): void;
+    /** Roving tabindex: exactly one mark is tabbable so the toolbar is a single Tab stop. */
+    private _updateTabStops;
+    private _onMarksKeyDown;
+    private _renderMark;
+    /**
+     * Records a hard/fast wheel flick. The fan does NOT bloom here — it blooms only if the transcript
+     * actually scrolls shortly after (see {@link setScrollLayout}). This way a hard flick against the
+     * top/bottom scroll limit, which moves nothing, never reveals the fan.
+     */
+    notifyHardWheel(): void;
+    /** Lane-local Y of the active mark (the prompt currently scrolled to), or the nearest visible one. */
+    private _activeCenter;
+    /**
+     * Lane-local Y for the fisheye focus while SCROLLING: glides continuously with the viewport by
+     * interpolating between pills. Each prompt has a content position (`layout.marks[].top`) and a dock
+     * position (`baseCenter`); we find where the viewport (`scrollTop`) sits between two prompts in
+     * content space and place the focus at the matching fraction between their dock positions. So the
+     * fisheye travels smoothly through the pills as you scroll (rather than snapping at prompt
+     * boundaries), while still tracking the real scroll position. Returns `undefined` if not laid out.
+     */
+    private _scrollFanCenter;
+    setActive(requestId: string | undefined): void;
+    focusTick(requestId: string): void;
+    setHostWidth(width: number): void;
+    setScrollLayout(layout: IPromptScrollLayout | undefined): void;
+    /**
+     * Handles a real transcript scroll: blooms the fan if it followed a deliberate hard flick, and
+     * keeps it alive (re-arms the linger) while you keep scrolling. Pointer hover owns the fan on its
+     * own, so this defers to it.
+     */
+    private _onScrolled;
+    /** Coalesces relayout to at most once per animation frame. */
+    private _scheduleRelayout;
+    /** Places each mark at its proportional scroll position, spaced so hit targets never overlap. */
+    private _relayout;
+    /**
+     * Even (dock) placement: stacks the pills at a fixed spacing and centres the whole group in the
+     * lane. If the group is taller than the lane it distributes across the full height instead, so a
+     * long session still fits. Mutates each item's `center` in place.
+     */
+    private _spaceEvenCenters;
+    /**
+     * Fisheye "fan": magnify the marks near {@link _fanCenter} and gently spread their neighbours
+     * apart, so a dense cluster becomes easy to read and click. It is a pointer-only flourish layered
+     * on top of the proportional layout — the marks' `top` (owned by `_relayout`) is untouched; the
+     * fan only adds a CSS `transform`, so keyboard navigation and the base layout are unaffected.
+     * Disabled entirely under reduced-motion.
+     */
+    private _applyFan;
+    /**
+     * Opens the fan at {@link center} (lane-local Y): reveals the marks (via `.engaged`) and applies
+     * the fisheye. Reveal happens even under reduced motion (the marks just don't magnify).
+     */
+    private _engage;
+    /** Collapses the fan back to the plain scrollbar (marks hidden, no fisheye). */
+    private _collapseFan;
+    /**
+     * (Re)starts the linger countdown: {@link FAN_LINGER}ms after the last scroll the fan collapses —
+     * but only if the pointer is not keeping it open. Called on every scroll frame and when the pointer
+     * leaves, so it avoids churning the timer: it just stamps the activity time and, when the single
+     * running timer fires, it re-arms for the remaining time if more scrolling happened since.
+     */
+    private _scheduleFanHide;
+    private _armFanHide;
+    private _updateActiveClasses;
+    /** Lane-local Y (client px) of the marks column top, from the cached rail top (refreshed on resize). Reads layout lazily only if the cache is not yet primed, so hovering never forces a reflow mid-scroll. */
+    private _laneTopNow;
+    private _showCard;
+    private _ensureResizeObserver;
+}