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

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

@@ -0,0 +1,460 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { $, append, addDisposableListener, EventType, getWindow, getActiveElement, clearNode, scheduleAtNextAnimationFrame } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { PromptTimelineCard } from './promptTimelineCard.js';
+import { MIN_HOST_WIDTH } from './promptTimelineLayout.js';
+import * as promptTimeline from './media/promptTimeline.css';
+
+registerCss(promptTimeline);
+const MIN_TARGET = 24;
+const RELAYOUT_MIN_DELTA = 0.5;
+const FAN_SIGMA = 40;
+const FAN_SPREAD = 14;
+const FAN_LINGER = 2000;
+const HARD_WHEEL_REVEAL_WINDOW = 200;
+const EVEN_PILL_SPACING = 26;
+class PromptTimelineRulerRail extends Disposable {
+    get domNode() {
+        return this._domNode;
+    }
+    constructor() {
+        super();
+        this._markDisposables = this._register(( new DisposableStore()));
+        this._marks = [];
+        this._glideEnabler = this._register(( new MutableDisposable()));
+        this._resizeObserverReady = false;
+        this._hostWidth = Number.POSITIVE_INFINITY;
+        this._railHeight = 0;
+        this._relayoutScheduled = this._register(( new MutableDisposable()));
+        this._laneTop = 0;
+        this._hovering = false;
+        this._hardWheelAt = 0;
+        this._fanHide = this._register(( new MutableDisposable()));
+        this._lastFanActivityAt = 0;
+        this._reducedMotion = false;
+        this._focused = false;
+        this._onDidSelect = this._register(( new Emitter()));
+        this.onDidSelect = this._onDidSelect.event;
+        this._onDidReview = this._register(( new Emitter()));
+        this.onDidReview = this._onDidReview.event;
+        this._onDidReviewFile = this._register(( new Emitter()));
+        this.onDidReviewFile = this._onDidReviewFile.event;
+        this._domNode = $("nav.prompt-timeline-rail.prompt-timeline-rail-ruler");
+        this._domNode.setAttribute("aria-label", ( localize(8892, "Prompt timeline")));
+        this._domNode.setAttribute("role", "toolbar");
+        this._domNode.setAttribute("aria-orientation", "vertical");
+        this._marksContainer = append(this._domNode, $(".prompt-timeline-ruler-marks"));
+        this._card = this._register(( new PromptTimelineCard(this._domNode)));
+        this._register(this._card.onDidReview(tick => this._onDidReview.fire(tick)));
+        this._register(this._card.onDidReviewFile(e => this._onDidReviewFile.fire(e)));
+        this._register(
+            addDisposableListener(this._marksContainer, EventType.KEY_DOWN, e => this._onMarksKeyDown(e))
+        );
+        this._register(addDisposableListener(this._marksContainer, EventType.MOUSE_ENTER, e => {
+            this._laneTop = this._laneTopNow();
+            this._hovering = true;
+            this._fanHide.clear();
+            this._engage(e.clientY - this._laneTop);
+        }));
+        this._register(addDisposableListener(this._marksContainer, EventType.MOUSE_MOVE, e => {
+            this._hovering = true;
+            this._engage(e.clientY - this._laneTop);
+        }));
+        this._register(addDisposableListener(this._marksContainer, EventType.MOUSE_LEAVE, () => {
+            this._hovering = false;
+            this._scheduleFanHide();
+        }));
+        const win = getWindow(this._domNode);
+        const reducedMotionQuery = win.matchMedia?.("(prefers-reduced-motion: reduce)");
+        if (reducedMotionQuery) {
+            this._reducedMotion = reducedMotionQuery.matches;
+            this._register(addDisposableListener(reducedMotionQuery, "change", () => {
+                this._reducedMotion = reducedMotionQuery.matches;
+                this._applyFan();
+            }));
+        }
+        this._register(addDisposableListener(this._domNode, EventType.FOCUS_IN, () => {
+            this._focused = true;
+            this._collapseFan();
+        }));
+        this._register(addDisposableListener(this._domNode, EventType.FOCUS_OUT, () => {
+            if (!this._domNode.contains(getActiveElement(this._domNode.ownerDocument))) {
+                this._focused = false;
+                this._card.scheduleHide();
+            }
+        }));
+    }
+    setFilesProvider(provider) {
+        this._card.setFilesProvider(provider);
+    }
+    setTicks(ticks) {
+        const sameStructure = ticks.length === this._marks.length && ticks.every((t, i) => this._marks[i]?.tick.requestId === t.requestId);
+        if (sameStructure) {
+            for (let i = 0; i < ticks.length; i++) {
+                this._renderMark(this._marks[i], ticks[i]);
+            }
+            this._updateActiveClasses();
+            this._relayout();
+            return;
+        }
+        this._markDisposables.clear();
+        this._marks.length = 0;
+        clearNode(this._marksContainer);
+        this._card.hide();
+        this._marksContainer.classList.remove("glide");
+        this._glideEnabler.clear();
+        for (const tick of ticks) {
+            const button = append(this._marksContainer, $("button.prompt-timeline-ruler-mark"));
+            button.tabIndex = -1;
+            const bar = append(button, $("span.prompt-timeline-ruler-bar"));
+            const entry = {
+                tick,
+                button,
+                bar
+            };
+            this._renderMark(entry, tick);
+            const requestId = tick.requestId;
+            this._markDisposables.add(
+                addDisposableListener(button, EventType.CLICK, () => this._onDidSelect.fire(requestId))
+            );
+            this._markDisposables.add(
+                addDisposableListener(button, EventType.MOUSE_ENTER, () => this._showCard(entry))
+            );
+            this._markDisposables.add(addDisposableListener(button, EventType.FOCUS, () => {
+                this._showCard(entry);
+                this._updateTabStops(this._marks.indexOf(entry));
+            }));
+            this._markDisposables.add(
+                addDisposableListener(button, EventType.MOUSE_LEAVE, () => this._card.scheduleHide())
+            );
+            this._marks.push(entry);
+        }
+        this._ensureResizeObserver();
+        const activeIndex = this._marks.findIndex(m => m.tick.requestId === this._activeRequestId);
+        this._updateTabStops(activeIndex >= 0 ? activeIndex : 0);
+        this._updateActiveClasses();
+        this._relayout();
+        this._glideEnabler.value = scheduleAtNextAnimationFrame(
+            getWindow(this._domNode),
+            () => this._marksContainer.classList.add("glide")
+        );
+    }
+    _updateTabStops(focusIndex) {
+        for (let i = 0; i < this._marks.length; i++) {
+            this._marks[i].button.tabIndex = i === focusIndex ? 0 : -1;
+        }
+    }
+    _onMarksKeyDown(e) {
+        if (this._marks.length === 0) {
+            return;
+        }
+        const event = ( new StandardKeyboardEvent(e));
+        const currentIndex = this._marks.findIndex(m => m.button === getActiveElement(this._domNode.ownerDocument));
+        let nextIndex;
+        switch (event.keyCode) {
+        case KeyCode.DownArrow:
+            nextIndex = Math.min(this._marks.length - 1, currentIndex + 1);
+            break;
+        case KeyCode.UpArrow:
+            nextIndex = Math.max(0, currentIndex - 1);
+            break;
+        case KeyCode.Home:
+            nextIndex = 0;
+            break;
+        case KeyCode.End:
+            nextIndex = this._marks.length - 1;
+            break;
+        default:
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        this._updateTabStops(nextIndex);
+        this._marks[nextIndex]?.button.focus();
+    }
+    _renderMark(entry, tick) {
+        entry.tick = tick;
+        entry.button.setAttribute("aria-label", tick.ariaLabel);
+        clearNode(entry.bar);
+        const stat = tick.stat;
+        const edited = !!stat && stat.added + stat.removed > 0;
+        entry.bar.classList.toggle("edited", edited);
+        if (edited) {
+            if (stat.added > 0) {
+                append(entry.bar, $("span.seg-add")).style.flexGrow = String(stat.added);
+            }
+            if (stat.removed > 0) {
+                append(entry.bar, $("span.seg-del")).style.flexGrow = String(stat.removed);
+            }
+        }
+    }
+    notifyHardWheel() {
+        this._hardWheelAt = Date.now();
+    }
+    _activeCenter() {
+        const active = this._marks.find(
+            m => m.tick.requestId === this._activeRequestId && m.baseCenter !== undefined
+        );
+        if (active?.baseCenter !== undefined) {
+            return active.baseCenter;
+        }
+        const laidOut = this._marks.filter(m => m.baseCenter !== undefined);
+        return laidOut.at(-1)?.baseCenter;
+    }
+    _scrollFanCenter() {
+        const layout = this._layout;
+        if (!layout) {
+            return undefined;
+        }
+        const topById = ( new Map(( layout.marks.map(m => [m.requestId, m.top]))));
+        const pts = [];
+        for (const entry of this._marks) {
+            const contentTop = topById.get(entry.tick.requestId);
+            if (contentTop !== undefined && entry.baseCenter !== undefined) {
+                pts.push({
+                    contentTop,
+                    center: entry.baseCenter
+                });
+            }
+        }
+        if (pts.length === 0) {
+            return undefined;
+        }
+        pts.sort((a, b) => a.contentTop - b.contentTop);
+        const scrollTop = layout.scrollHeight > 0 ? (layout.scrollTop / layout.scrollHeight) * layout.total : layout.scrollTop;
+        if (scrollTop <= pts[0].contentTop) {
+            return pts[0].center;
+        }
+        const last = pts[pts.length - 1];
+        if (scrollTop >= last.contentTop) {
+            return last.center;
+        }
+        for (let i = 0; i < pts.length - 1; i++) {
+            const a = pts[i];
+            const b = pts[i + 1];
+            if (scrollTop >= a.contentTop && scrollTop <= b.contentTop) {
+                const span = b.contentTop - a.contentTop;
+                const frac = span > 0 ? (scrollTop - a.contentTop) / span : 0;
+                return a.center + frac * (b.center - a.center);
+            }
+        }
+        return last.center;
+    }
+    setActive(requestId) {
+        this._activeRequestId = requestId;
+        this._updateActiveClasses();
+    }
+    focusTick(requestId) {
+        this._marks.find(
+            m => m.tick.requestId === requestId || m.tick.allRequestIds.includes(requestId)
+        )?.button.focus();
+    }
+    setHostWidth(width) {
+        if (width > 0 && width !== this._hostWidth) {
+            this._hostWidth = width;
+            this._relayout();
+        }
+    }
+    setScrollLayout(layout) {
+        const prevScrollTop = this._lastScrollTop;
+        this._layout = layout;
+        if (layout) {
+            this._lastScrollTop = layout.scrollTop;
+            if (prevScrollTop !== undefined && Math.abs(layout.scrollTop - prevScrollTop) > 0.5) {
+                this._onScrolled();
+            }
+        }
+        this._scheduleRelayout();
+    }
+    _onScrolled() {
+        if (this._hovering || this._focused) {
+            return;
+        }
+        if (this._domNode.classList.contains("engaged")) {
+            this._scheduleFanHide();
+            return;
+        }
+        if (Date.now() - this._hardWheelAt <= HARD_WHEEL_REVEAL_WINDOW) {
+            const center = this._scrollFanCenter() ?? this._activeCenter();
+            if (center !== undefined) {
+                this._engage(center);
+                this._scheduleFanHide();
+            }
+        }
+    }
+    _scheduleRelayout() {
+        if (this._relayoutScheduled.value) {
+            return;
+        }
+        this._relayoutScheduled.value = scheduleAtNextAnimationFrame(getWindow(this._domNode), () => {
+            this._relayoutScheduled.clear();
+            this._relayout();
+        });
+    }
+    _relayout() {
+        const height = this._railHeight > 0 ? this._railHeight : (this._railHeight = this._domNode.clientHeight);
+        const layout = this._layout;
+        const overflowing = this._hostWidth < MIN_HOST_WIDTH;
+        this._domNode.classList.toggle("overflowing", overflowing);
+        if (overflowing || height <= 0 || !layout || layout.total <= 0) {
+            return;
+        }
+        const scale = height / layout.total;
+        const topById = ( new Map(( layout.marks.map(m => [m.requestId, m.top]))));
+        const visible = [];
+        for (const entry of this._marks) {
+            const top = topById.get(entry.tick.requestId);
+            if (top === undefined) {
+                entry.button.classList.add("hidden");
+                entry.lastTop = undefined;
+                entry.baseCenter = undefined;
+                entry.button.style.transform = "";
+                entry.bar.style.transform = "";
+                continue;
+            }
+            entry.button.classList.remove("hidden");
+            visible.push({
+                entry,
+                center: top * scale
+            });
+        }
+        {
+            this._spaceEvenCenters(visible, height);
+        }
+        for (const {
+            entry,
+            center
+        } of visible) {
+            entry.baseCenter = center;
+            const y = center - MIN_TARGET / 2;
+            if (entry.lastTop !== undefined && Math.abs(y - entry.lastTop) < RELAYOUT_MIN_DELTA) {
+                continue;
+            }
+            entry.lastTop = y;
+            entry.button.style.top = `${y}px`;
+        }
+        if (this._domNode.classList.contains("engaged") && !this._hovering && !this._focused) {
+            const scrollCenter = this._scrollFanCenter();
+            if (scrollCenter !== undefined) {
+                this._fanCenter = scrollCenter;
+            }
+        }
+        this._applyFan();
+    }
+    _spaceEvenCenters(visible, height) {
+        const n = visible.length;
+        if (n === 0) {
+            return;
+        }
+        const groupHeight = n * EVEN_PILL_SPACING;
+        let start;
+        let step;
+        if (groupHeight <= height) {
+            step = EVEN_PILL_SPACING;
+            start = (height - groupHeight) / 2 + step / 2;
+        } else {
+            step = (height - EVEN_PILL_SPACING) / (n - 1);
+            start = EVEN_PILL_SPACING / 2;
+        }
+        for (let i = 0; i < n; i++) {
+            visible[i].center = start + i * step;
+        }
+    }
+    _applyFan() {
+        const center = this._fanCenter;
+        const fanning = center !== undefined && !this._reducedMotion;
+        for (const entry of this._marks) {
+            if (entry.baseCenter === undefined) {
+                continue;
+            }
+            if (!fanning) {
+                entry.button.style.transform = "";
+                entry.bar.style.transform = "";
+                continue;
+            }
+            const d = entry.baseCenter - center;
+            const m = Math.exp(-(d * d) / (2 * FAN_SIGMA * FAN_SIGMA));
+            entry.button.style.transform = `translateY(${FAN_SPREAD * Math.tanh(d / FAN_SIGMA)}px)`;
+            entry.bar.style.transform = `scale(${1 + m * 0.9}, ${1 + m * 0.6})`;
+        }
+    }
+    _engage(center) {
+        this._domNode.classList.add("engaged");
+        this._fanCenter = center;
+        this._applyFan();
+    }
+    _collapseFan() {
+        if (!this._domNode.classList.contains("engaged")) {
+            return;
+        }
+        this._domNode.classList.remove("engaged");
+        this._fanCenter = undefined;
+        this._applyFan();
+    }
+    _scheduleFanHide() {
+        this._lastFanActivityAt = Date.now();
+        if (!this._fanHide.value) {
+            this._armFanHide(FAN_LINGER);
+        }
+    }
+    _armFanHide(delay) {
+        this._fanHide.value = disposableTimeout(() => {
+            this._fanHide.clear();
+            if (this._hovering) {
+                return;
+            }
+            const remaining = FAN_LINGER - (Date.now() - this._lastFanActivityAt);
+            if (remaining > 0) {
+                this._armFanHide(remaining);
+            } else {
+                this._collapseFan();
+            }
+        }, delay);
+    }
+    _updateActiveClasses() {
+        for (const entry of this._marks) {
+            const isActive = entry.tick.requestId === this._activeRequestId;
+            entry.button.classList.toggle("active", isActive);
+            if (isActive) {
+                entry.button.setAttribute("aria-current", "location");
+            } else {
+                entry.button.removeAttribute("aria-current");
+            }
+        }
+    }
+    _laneTopNow() {
+        if (this._domTop === undefined) {
+            this._domTop = this._domNode.getBoundingClientRect().top;
+        }
+        return this._domTop;
+    }
+    _showCard(entry) {
+        const centerY = entry.baseCenter ?? (entry.button.getBoundingClientRect().top - this._domNode.getBoundingClientRect().top + MIN_TARGET / 2);
+        this._card.show(entry.tick, centerY);
+    }
+    _ensureResizeObserver() {
+        if (this._resizeObserverReady) {
+            return;
+        }
+        const ResizeObserverCtor = getWindow(this._domNode).ResizeObserver;
+        if (!ResizeObserverCtor) {
+            return;
+        }
+        this._resizeObserverReady = true;
+        const observer = ( new ResizeObserverCtor(() => {
+            this._railHeight = this._domNode.clientHeight;
+            this._domTop = this._domNode.getBoundingClientRect().top;
+            this._relayout();
+        }));
+        observer.observe(this._domNode);
+        this._register(toDisposable(() => observer.disconnect()));
+    }
+}
+
+export { PromptTimelineRulerRail };

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

@@ -0,0 +1,38 @@
+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 { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+/**
+ * A flat, opaque header pinned to the top of the chat transcript, modelled on the editor's sticky
+ * scroll: it names the prompt currently scrolled off the top. Activating the label reveals the
+ * prompt it names. Purely presentational — the owner drives its content and visibility.
+ */
+export declare class PromptTimelineStickyHeader extends Disposable {
+    private readonly accessibilityService;
+    private readonly _domNode;
+    private readonly _labelButton;
+    private readonly _label;
+    private readonly _count;
+    /** The line element currently naming the pinned prompt (siblings are transient roll animations). */
+    private _labelLine;
+    private _currentLabel;
+    private _lastIndex;
+    private _visible;
+    private _rollInAnim;
+    private _rollOutAnim;
+    private _rollOutgoing;
+    private readonly _onDidActivate;
+    /** Fired when the label is clicked or activated by keyboard. */
+    readonly onDidActivate: Event<void>;
+    get domNode(): HTMLElement;
+    constructor(container: HTMLElement, accessibilityService: IAccessibilityService);
+    /** Names the pinned prompt (1-based index within all prompts). */
+    update(text: string, index: number, total: number): void;
+    private _createLine;
+    /** Rolls the outgoing label out and the incoming label in, following the scroll direction. */
+    private _roll;
+    /** Commits any in-flight roll immediately so a new one can start from a settled state. */
+    private _finalizeRoll;
+    setVisible(visible: boolean): void;
+    private _setVisible;
+    dispose(): void;
+}

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

@@ -0,0 +1,120 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import * as promptTimeline from './media/promptTimeline.css';
+
+registerCss(promptTimeline);
+let PromptTimelineStickyHeader = class PromptTimelineStickyHeader extends Disposable {
+    get domNode() {
+        return this._domNode;
+    }
+    constructor(container, accessibilityService) {
+        super();
+        this.accessibilityService = accessibilityService;
+        this._currentLabel = "";
+        this._visible = false;
+        this._onDidActivate = this._register(( new Emitter()));
+        this.onDidActivate = this._onDidActivate.event;
+        this._domNode = append(container, $(".prompt-timeline-sticky"));
+        const content = append(this._domNode, $(".prompt-timeline-sticky-content"));
+        const band = append(content, $(".prompt-timeline-sticky-band"));
+        this._labelButton = append(band, $("button.prompt-timeline-sticky-label-button"));
+        this._label = append(this._labelButton, $("span.prompt-timeline-sticky-label"));
+        this._labelLine = this._createLine("");
+        this._label.appendChild(this._labelLine);
+        this._count = append(this._labelButton, $("span.prompt-timeline-sticky-count"));
+        this._register(
+            addDisposableListener(this._labelButton, EventType.CLICK, () => this._onDidActivate.fire())
+        );
+        this._setVisible(false);
+    }
+    update(text, index, total) {
+        const label = text || ( localize(8893, "(empty prompt)"));
+        this._count.textContent = ( localize(8894, "{0}/{1}", index, total));
+        this._labelButton.title = label;
+        this._labelButton.setAttribute("aria-label", ( localize(8895, "Go to prompt {0} of {1}: {2}", index, total, label)));
+        if (label !== this._currentLabel || index !== this._lastIndex) {
+            const direction = this._lastIndex !== undefined && index !== this._lastIndex ? Math.sign(index - this._lastIndex) : 0;
+            const newLine = this._createLine(label);
+            this._label.appendChild(newLine);
+            const oldLine = this._labelLine;
+            this._labelLine = newLine;
+            if (this._visible && direction !== 0 && !this.accessibilityService.isMotionReduced()) {
+                this._roll(oldLine, newLine, direction);
+            } else {
+                this._finalizeRoll();
+                oldLine.remove();
+            }
+            this._currentLabel = label;
+        }
+        this._lastIndex = index;
+    }
+    _createLine(text) {
+        const line = $(".prompt-timeline-sticky-label-line");
+        append(line, $("span.prompt-timeline-sticky-label-text")).textContent = text;
+        return line;
+    }
+    _roll(oldLine, newLine, direction) {
+        this._finalizeRoll();
+        const timing = {
+            duration: 140,
+            easing: "ease"
+        };
+        const outTo = direction > 0 ? -100 : 100;
+        const inFrom = direction > 0 ? 100 : -100;
+        const outAnim = oldLine.animate([{
+            transform: "translateY(0)",
+            opacity: 1
+        }, {
+            transform: `translateY(${outTo}%)`,
+            opacity: 0
+        }], timing);
+        const inAnim = newLine.animate([{
+            transform: `translateY(${inFrom}%)`,
+            opacity: 0
+        }, {
+            transform: "translateY(0)",
+            opacity: 1
+        }], timing);
+        this._rollOutgoing = oldLine;
+        this._rollOutAnim = outAnim;
+        this._rollInAnim = inAnim;
+        outAnim.finished.then(() => oldLine.remove(), () => {});
+        inAnim.finished.then(() => {
+            if (this._rollInAnim === inAnim) {
+                this._rollInAnim = this._rollOutAnim = this._rollOutgoing = undefined;
+            }
+        }, () => {});
+    }
+    _finalizeRoll() {
+        this._rollInAnim?.finish();
+        this._rollOutAnim?.finish();
+        this._rollOutgoing?.remove();
+        this._rollInAnim = this._rollOutAnim = this._rollOutgoing = undefined;
+    }
+    setVisible(visible) {
+        this._setVisible(visible);
+    }
+    _setVisible(visible) {
+        this._visible = visible;
+        this._domNode.classList.toggle("hidden", !visible);
+        this._domNode.toggleAttribute("inert", !visible);
+        if (!visible) {
+            this._finalizeRoll();
+        }
+    }
+    dispose() {
+        this._rollInAnim?.cancel();
+        this._rollOutAnim?.cancel();
+        this._domNode.remove();
+        super.dispose();
+    }
+};
+PromptTimelineStickyHeader = ( __decorate([( __param(1, IAccessibilityService))], PromptTimelineStickyHeader));
+
+export { PromptTimelineStickyHeader };

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

@@ -0,0 +1,53 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetContrib, ChatWidget } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
+import { IPromptTimelineRail } from "./promptTimelineRail.js";
+export declare function observePromptTimelineHostWidth(widget: Pick<ChatWidget, "onDidLayout">, host: HTMLElement, rail: Pick<IPromptTimelineRail, "setHostWidth">): IDisposable;
+/**
+ * Whether the sticky prompt header is mounted for a widget. Shared with the accessibility help so it
+ * only describes the header on widgets that actually get one.
+ */
+export declare function isStickyPromptHeaderShown(widget: IChatWidget, configurationService: IConfigurationService): boolean;
+/**
+ * Per-widget contribution that overlays the prompt timeline on the chat transcript. It shows the sticky
+ * header (`chat.stickyScroll.enabled`, both windows) and/or the rail
+ * (`sessions.chatTimeline.display`, Agents window only), and is torn down and re-created when a relevant
+ * setting changes.
+ */
+export declare class PromptTimelineWidgetContrib extends Disposable implements IChatWidgetContrib {
+    private readonly widget;
+    private readonly instantiationService;
+    private readonly configurationService;
+    private readonly environmentService;
+    static readonly ID = "chat.promptTimeline";
+    readonly id = "chat.promptTimeline";
+    /** Holds the model and every surface's wiring while at least one surface is enabled. */
+    private readonly _enablement;
+    constructor(widget: IChatWidget, instantiationService: IInstantiationService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService);
+    /** (Re)builds the timeline to match the current settings, or tears it down if no surface is enabled. */
+    private _update;
+    /**
+     * Builds the model shared by both surfaces, mounts the host anchor, then creates whichever surfaces
+     * are enabled: the rail beside the transcript and/or the sticky header at the top. Each is
+     * independently toggleable, so header-only and rail-only configurations both work.
+     */
+    private _createFeature;
+    private _createRail;
+    /**
+     * Mounts the flat sticky header that pins the current prompt to the top of the transcript. It shows
+     * only once that prompt's row has scrolled above the viewport (via {@link PromptTimelineModel.activePinned}).
+     * Activating the label jumps straight to the prompt it names (scrolling it to the top of the transcript).
+     */
+    private _createStickyHeader;
+    /**
+     * Detects a deliberate hard/fast scroll from wheel velocity and tells the rail (it only blooms if a
+     * real scroll movement follows, so flicking against a scroll limit never opens it). Deltas are
+     * normalized via {@link StandardWheelEvent} so line-mode devices are not stuck below the threshold,
+     * and the listener is on the capture phase so it is seen before the transcript's ScrollableElement
+     * consumes the wheel mid-content.
+     */
+    private _registerHardWheelDetector;
+}