From 1e4ad07511ac6f1161b1c589aedf00aadade1a98 Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Wed, 4 Nov 2026 20:31:56 -0600 Subject: [PATCH] fix(app): drive the active message cursor with an explicit state machine (#61848) --- .../e2e/regression/timeline-history.spec.ts | 28 ++ .../session/timeline/cursor-machine.test.ts | 201 +++++++++++++ .../src/session/timeline/cursor-machine.ts | 269 ++++++++++++++++++ packages/app/src/session/timeline/cursor.ts | 202 +++++++++++++ .../app/src/session/timeline/interaction.ts | 116 +++----- .../src/session/use-session-hash-scroll.ts | 234 --------------- packages/app/src/shell/state/layout.test.ts | 10 +- packages/app/src/shell/state/layout.tsx | 50 ---- 8 files changed, 749 insertions(+), 361 deletions(-) create mode 100644 packages/app/src/session/timeline/cursor-machine.test.ts create mode 100644 packages/app/src/session/timeline/cursor-machine.ts create mode 100644 packages/app/src/session/timeline/cursor.ts delete mode 100644 packages/app/src/session/use-session-hash-scroll.ts diff --git a/packages/app/e2e/regression/timeline-history.spec.ts b/packages/app/e2e/regression/timeline-history.spec.ts index 472d84c7833..a26461b6f52 100644 --- a/packages/app/e2e/regression/timeline-history.spec.ts +++ b/packages/app/e2e/regression/timeline-history.spec.ts @@ -502,6 +502,34 @@ test.describe("timeline history", () => { await expect(editor).toBeFocused() await expect(editor).toHaveText("keep this draft") }) + + test("a message hash and message navigation keep the prompt in view and the hash in step", async ({ page }) => { + const messages = validateTimelineMessages([ + ...historyMessages(20), + userMessage(), + assistantMessage([textPart("prt_cursor_tail", "Latest answer")]), + ]) + + const prompt = (index: number) => messages.filter((message) => message.type === "user")[index]!.id + const row = (index: number) => page.locator(`[data-timeline-row="UserMessage"][data-message-id="${prompt(index)}"]`) + const hash = () => page.evaluate(() => location.hash) + + await setupTimeline(page, { sessionMessages: messages }) + await expect(page.getByText("Latest answer", { exact: true })).toBeInViewport() + await page.evaluate((id) => (location.hash = `#message-${id}`), prompt(10)) + await expect(row(10)).toBeInViewport() + + await page.keyboard.press("Control+Alt+BracketLeft") + await expect.poll(hash).toBe(`#message-${prompt(9)}`) + await expect(row(9)).toBeInViewport() + await page.keyboard.press("Control+Alt+BracketRight") + await expect.poll(hash).toBe(`#message-${prompt(10)}`) + await expect(row(10)).toBeInViewport() + + await page.getByRole("button", { name: "Jump to latest" }).click() + await expect.poll(hash).toBe("") + await expect(page.getByText("Latest answer", { exact: true })).toBeInViewport() + }) }) declare global { diff --git a/packages/app/src/session/timeline/cursor-machine.test.ts b/packages/app/src/session/timeline/cursor-machine.test.ts new file mode 100644 index 00000000000..f74bbe1125d --- /dev/null +++ b/packages/app/src/session/timeline/cursor-machine.test.ts @@ -0,0 +1,201 @@ +import { describe, expect, test } from "bun:test" +import { messageIdFromHash } from "../message-id-from-hash" +import { + CLEAR_CURSOR_EVENT, + createTimelineCursorState, + CURSOR_SEEK_LIMIT, + cursorMessageID, + DISPOSED_CURSOR_EVENT, + freshCursorMessageID, + hasFreshCursorOrSeek, + LATEST_ADVANCED_EVENT, + pendingCursorMessageID, + SCROLL_MOVED_EVENT, + SESSION_CHANGED_EVENT, + transitionTimelineCursor, + type TimelineCursorEvent, + type TimelineCursorState, +} from "./cursor-machine" + +const jump = (messageID: string): TimelineCursorEvent => ({ type: "message.jump", messageID, behavior: "auto" }) + +// Built the way the driver builds it from `location.hash`. +const hash = (value: string, initial = false, reveal = false): TimelineCursorEvent => ({ + type: "hash.applied", + hash: value.slice(1), + messageID: messageIdFromHash(value.slice(1)), + initial, + reveal, +}) + +function replay(events: TimelineCursorEvent[], from = createTimelineCursorState()) { + return events.reduce((state, event) => transitionTimelineCursor(state, event).state, from) +} + +function expectIgnored(state: TimelineCursorState, event: TimelineCursorEvent) { + const next = transitionTimelineCursor(state, event) + + expect(next.state).toBe(state) + expect(next.effects).toEqual([]) +} + +const landed = (state: TimelineCursorState) => replay([{ type: "seek.landed", attempt: state.attempt }], state) + +describe("cursor machine", () => { + test("jumping back to the same prompt after scrolling away makes it fresh again", () => { + const scrolled = replay([jump("msg_5"), SCROLL_MOVED_EVENT]) + expect(freshCursorMessageID(scrolled)).toBeUndefined() + expect(cursorMessageID(scrolled)).toBe("msg_5") + + const again = transitionTimelineCursor(scrolled, jump("msg_5")) + expect(freshCursorMessageID(again.state)).toBe("msg_5") + expect(again.effects).toEqual([ + { type: "follow.detach" }, + { type: "hash.set", messageID: "msg_5" }, + { type: "seek.start", attempt: again.state.attempt, messageID: "msg_5", behavior: "auto" }, + ]) + }) + + test("a Find or tool reveal makes the cursor stale and cancels its seek", () => { + const seeking = replay([jump("msg_10")]) + const moved = transitionTimelineCursor(seeking, SCROLL_MOVED_EVENT) + + expect(moved.state).toEqual({ + status: "selected", + messageID: "msg_10", + fresh: false, + attempt: seeking.attempt + 1, + echo: true, + }) + expect(moved.effects).toEqual([{ type: "seek.cancel" }]) + expectIgnored(moved.state, { type: "seek.missing", attempt: seeking.attempt }) + expectIgnored(moved.state, { type: "seek.landed", attempt: seeking.attempt }) + }) + + test("undo or redo while pinned does not leave a cursor behind", () => { + expectIgnored(createTimelineCursorState(), { type: "message.select", messageID: "msg_2", following: true }) + + const selected = replay([{ type: "message.select", messageID: "msg_2", following: false }]) + expect(freshCursorMessageID(selected)).toBe("msg_2") + expect(replay([{ type: "message.select", messageID: "msg_3", following: true }], selected).status).toBe("none") + }) + + test("clearing its own hash does not scroll again, while Browser Back off a prompt returns to the end", () => { + const selected = landed(replay([jump("msg_5")])) + const cleared = transitionTimelineCursor(selected, CLEAR_CURSOR_EVENT) + + expect(cleared.state.status).toBe("none") + expect(cleared.effects).toEqual([{ type: "hash.clear" }]) + // The router echoes the cleared hash; a smooth return to the end must keep its course. + expectIgnored(cleared.state, hash("")) + + const back = transitionTimelineCursor(selected, hash("")) + expect(back.state.status).toBe("none") + expect(back.effects).toEqual([{ type: "follow.end" }]) + }) + + test("the router's echo of the cursor's own hash does not seek again, once", () => { + const seeking = replay([jump("msg_5")]) + + for (const state of [seeking, replay([SCROLL_MOVED_EVENT], seeking)]) { + const echoed = transitionTimelineCursor(state, hash("#message-msg_5")) + + expect(echoed.state).toMatchObject({ status: "selected", messageID: "msg_5", echo: false }) + expect(echoed.state.attempt).toBe(state.attempt) + expect(echoed.effects).toEqual([]) + // Only the write echoes; the same hash applied again is a real navigation. + expect(transitionTimelineCursor(echoed.state, hash("#message-msg_5")).state.status).toBe("pending") + } + }) + + test("a link to the prompt undo, redo or rewind selected still navigates to it", () => { + const undone = replay([{ type: "message.select", messageID: "msg_3", following: false }]) + const linked = transitionTimelineCursor(undone, hash("#message-msg_3")) + + expect(pendingCursorMessageID(linked.state)).toBe("msg_3") + expect(linked.effects).toEqual([{ type: "follow.detach" }]) + + const loaded = transitionTimelineCursor(linked.state, { type: "target.loaded", messageID: "msg_3" }) + expect(loaded.effects).toEqual([ + { type: "follow.detach" }, + { type: "seek.schedule", attempt: loaded.state.attempt, messageID: "msg_3", behavior: "auto" }, + ]) + }) + + test("a hash target waits until its prompt loads, then seeks to it", () => { + const pending = transitionTimelineCursor(createTimelineCursorState(), hash("#message-msg_1", true)) + + expect(pendingCursorMessageID(pending.state)).toBe("msg_1") + expect(pending.effects).toEqual([{ type: "follow.detach" }]) + expectIgnored(pending.state, { type: "target.loaded", messageID: "msg_2" }) + + const loaded = transitionTimelineCursor(pending.state, { type: "target.loaded", messageID: "msg_1" }) + expect(freshCursorMessageID(loaded.state)).toBe("msg_1") + expect(loaded.effects).toEqual([ + { type: "follow.detach" }, + { type: "seek.schedule", attempt: loaded.state.attempt, messageID: "msg_1", behavior: "auto" }, + ]) + }) + + test("a session switch drops the previous session's target and seek", () => { + const pending = replay([hash("#message-msg_a", true)]) + expect(replay([SESSION_CHANGED_EVENT], pending)).toEqual({ status: "none", attempt: pending.attempt + 1 }) + + const seeking = replay([jump("msg_a")]) + const switched = transitionTimelineCursor(seeking, SESSION_CHANGED_EVENT) + expect(switched.effects).toEqual([{ type: "seek.cancel" }]) + expectIgnored(switched.state, { type: "seek.missing", attempt: seeking.attempt }) + }) + + test("a seek retries for a bounded number of frames", () => { + const seeking = replay([jump("msg_5")]) + const missing: TimelineCursorEvent = { type: "seek.missing", attempt: seeking.attempt } + + const retried = Array.from({ length: CURSOR_SEEK_LIMIT }).reduce((state) => { + const next = transitionTimelineCursor(state, missing) + expect(next.effects).toEqual([ + { type: "seek.schedule", attempt: seeking.attempt, messageID: "msg_5", behavior: "auto" }, + ]) + + return next.state + }, seeking) + + const settled = transitionTimelineCursor(retried, missing) + expect(settled.state).toEqual({ + status: "selected", + messageID: "msg_5", + fresh: true, + attempt: seeking.attempt, + echo: true, + }) + expect(settled.effects).toEqual([]) + expect(hasFreshCursorOrSeek(settled.state)).toBe(true) + expect(landed(seeking)).toEqual(settled.state) + }) + + test("the first apply of an empty hash goes to the end unless the route reveals a tool", () => { + expect(transitionTimelineCursor(createTimelineCursorState(), hash("", true)).effects).toEqual([ + { type: "follow.end" }, + ]) + expectIgnored(createTimelineCursorState(), hash("", true, true)) + expect(transitionTimelineCursor(createTimelineCursorState(), hash("#section")).effects).toEqual([ + { type: "anchor.scroll", id: "section" }, + ]) + }) + + test("a newer prompt clears the selection but keeps a pending target", () => { + expect(replay([jump("msg_1"), LATEST_ADVANCED_EVENT]).status).toBe("none") + expectIgnored(replay([hash("#message-msg_1")]), LATEST_ADVANCED_EVENT) + }) + + test("steady scrolling and disposal of an idle cursor keep the same state", () => { + const stale = replay([jump("msg_1"), SCROLL_MOVED_EVENT]) + + expectIgnored(createTimelineCursorState(), SCROLL_MOVED_EVENT) + expectIgnored(stale, SCROLL_MOVED_EVENT) + expectIgnored(createTimelineCursorState(), DISPOSED_CURSOR_EVENT) + expect(transitionTimelineCursor(replay([jump("msg_1")]), DISPOSED_CURSOR_EVENT).effects).toEqual([ + { type: "seek.cancel" }, + ]) + }) +}) diff --git a/packages/app/src/session/timeline/cursor-machine.ts b/packages/app/src/session/timeline/cursor-machine.ts new file mode 100644 index 00000000000..4a30fe20e62 --- /dev/null +++ b/packages/app/src/session/timeline/cursor-machine.ts @@ -0,0 +1,269 @@ +// Frames a seek waits for the target prompt's virtualized row to mount. +export const CURSOR_SEEK_LIMIT = 4 + +export type CursorSeek = { + readonly behavior: ScrollBehavior + readonly retries: number +} + +// `attempt` advances on every change of target or seek, so a seek result from an earlier one is ignored. +export type TimelineCursorState = + | { readonly status: "none"; readonly attempt: number } + /** A `#message-` target that is not loaded yet; history pages toward it. */ + | { readonly status: "pending"; readonly messageID: string; readonly attempt: number } + /** + * The active prompt. `fresh` until the reader scrolls, after which navigation steps from the prompt in view instead. + * `seek` while the view is still bringing the prompt in. `echo` after a jump wrote the prompt's hash, until the router + * repeats it once; any other `#message-` for the prompt is a real navigation. + */ + | { + readonly status: "selected" + readonly messageID: string + readonly fresh: boolean + readonly attempt: number + readonly seek?: CursorSeek + readonly echo?: boolean + } + +export type TimelineCursorEvent = + | { readonly type: "session.changed" } + /** + * The route hash, applied once the session's messages are ready (`initial`) and on every later change. `messageID` is + * the `#message-` target. `reveal`: the route opens the session on a tool call instead. + */ + | { + readonly type: "hash.applied" + readonly hash: string + readonly messageID: string | undefined + readonly initial: boolean + readonly reveal: boolean + } + | { readonly type: "target.loaded"; readonly messageID: string } + /** Previous or next message. */ + | { readonly type: "message.jump"; readonly messageID: string; readonly behavior: ScrollBehavior } + /** Undo, redo and rewind name the prompt navigation continues from. */ + | { readonly type: "message.select"; readonly messageID: string | undefined; readonly following: boolean } + /** The reader scrolled the timeline, or Find or a tool reveal moved it. */ + | { readonly type: "scroll.moved" } + /** Following resumed, or the reader jumped to the latest message. */ + | { readonly type: "clear" } + | { readonly type: "latest.advanced" } + | { readonly type: "seek.landed"; readonly attempt: number } + | { readonly type: "seek.missing"; readonly attempt: number } + | { readonly type: "disposed" } + +export type TimelineCursorEffect = + | { readonly type: "follow.detach" } + /** Follow the newest content again and scroll to it. */ + | { readonly type: "follow.end" } + | { readonly type: "hash.set"; readonly messageID: string } + | { readonly type: "hash.clear" } + /** Scroll to the element a non-message hash names, or to the end when there is none. */ + | { readonly type: "anchor.scroll"; readonly id: string } + /** Scroll now: a smooth jump glides to a mounted prompt, any other first asks the virtualizer to reveal it. */ + | { + readonly type: "seek.start" + readonly attempt: number + readonly messageID: string + readonly behavior: ScrollBehavior + } + | { + readonly type: "seek.schedule" + readonly attempt: number + readonly messageID: string + readonly behavior: ScrollBehavior + } + | { readonly type: "seek.cancel" } + +export type TimelineCursorTransition = { + readonly state: TimelineCursorState + readonly effects: readonly TimelineCursorEffect[] +} + +type Selected = Extract + +// Shared events for the frequent dispatches, so scrolling allocates nothing. +export const SCROLL_MOVED_EVENT: TimelineCursorEvent = Object.freeze({ type: "scroll.moved" }) + +export const CLEAR_CURSOR_EVENT: TimelineCursorEvent = Object.freeze({ type: "clear" }) + +export const LATEST_ADVANCED_EVENT: TimelineCursorEvent = Object.freeze({ type: "latest.advanced" }) + +export const SESSION_CHANGED_EVENT: TimelineCursorEvent = Object.freeze({ type: "session.changed" }) + +export const DISPOSED_CURSOR_EVENT: TimelineCursorEvent = Object.freeze({ type: "disposed" }) + +const NO_EFFECTS: readonly TimelineCursorEffect[] = Object.freeze([]) + +const SEEK_CANCEL: readonly TimelineCursorEffect[] = Object.freeze([{ type: "seek.cancel" }]) + +const FOLLOW_END: TimelineCursorEffect = Object.freeze({ type: "follow.end" }) + +const FOLLOW_DETACH: TimelineCursorEffect = Object.freeze({ type: "follow.detach" }) + +const HASH_CLEAR: TimelineCursorEffect = Object.freeze({ type: "hash.clear" }) + +export function createTimelineCursorState(): TimelineCursorState { + return { status: "none", attempt: 0 } +} + +export function transitionTimelineCursor( + state: TimelineCursorState, + event: TimelineCursorEvent, +): TimelineCursorTransition { + if (event.type === "session.changed" || event.type === "disposed") return clear(state) + + if (event.type === "hash.applied") return hashApplied(state, event) + + if (event.type === "target.loaded") { + if (state.status !== "pending" || state.messageID !== event.messageID) return unchanged(state) + + // The route already carries this hash, so nothing echoes. + return seek(state, event.messageID, "auto", [FOLLOW_DETACH], { now: false, echo: false }) + } + + if (event.type === "message.jump") + return seek( + state, + event.messageID, + event.behavior, + [...cancelSeek(state), FOLLOW_DETACH, { type: "hash.set", messageID: event.messageID }], + { now: true, echo: true }, + ) + + if (event.type === "message.select") { + // A pinned view shows the newest prompt; a remembered one would only send navigation elsewhere. + if (!event.messageID || event.following) return clear(state) + + if (state.status === "selected" && state.messageID === event.messageID && state.fresh && !state.seek) + return unchanged(state) + + return changed( + { status: "selected", messageID: event.messageID, fresh: true, attempt: state.attempt + 1 }, + cancelSeek(state), + ) + } + + if (event.type === "scroll.moved") { + if (state.status !== "selected" || !hasFreshCursorOrSeek(state)) return unchanged(state) + + return changed( + { status: "selected", messageID: state.messageID, fresh: false, attempt: state.attempt + 1, echo: state.echo }, + cancelSeek(state), + ) + } + + if (event.type === "clear") { + const next = clear(state) + + return changed(next.state, [...next.effects, HASH_CLEAR]) + } + + if (event.type === "latest.advanced") return state.status === "selected" ? clear(state) : unchanged(state) + + if (state.status !== "selected" || !state.seek || state.attempt !== event.attempt) return unchanged(state) + + if (event.type === "seek.landed" || state.seek.retries >= CURSOR_SEEK_LIMIT) return changed(settled(state)) + + return changed({ ...state, seek: { behavior: state.seek.behavior, retries: state.seek.retries + 1 } }, [ + { type: "seek.schedule", attempt: state.attempt, messageID: state.messageID, behavior: state.seek.behavior }, + ]) +} + +/** The prompt navigation steps from, while the reader has not scrolled since choosing it. */ +export function freshCursorMessageID(state: TimelineCursorState) { + return state.status === "selected" && state.fresh ? state.messageID : undefined +} + +/** The last chosen prompt, for when no prompt header is mounted in view. */ +export function cursorMessageID(state: TimelineCursorState) { + return state.status === "selected" ? state.messageID : undefined +} + +/** A target history pages toward until it loads. */ +export function pendingCursorMessageID(state: TimelineCursorState) { + return state.status === "pending" ? state.messageID : undefined +} + +/** Only a fresh cursor or a running seek cares about the reader's scroll, so steady scrolling skips the rest. */ +export function hasFreshCursorOrSeek(state: TimelineCursorState) { + return state.status === "selected" && (state.fresh || !!state.seek) +} + +function hashApplied( + state: TimelineCursorState, + event: Extract, +): TimelineCursorTransition { + if (event.messageID) { + // The hash this cursor wrote, repeated by the router: consumed once, so a later link to the prompt still navigates. + if (state.status === "selected" && state.echo && state.messageID === event.messageID) + return changed({ ...state, echo: false }) + + if (state.status === "pending" && state.messageID === event.messageID) return unchanged(state) + + return changed({ status: "pending", messageID: event.messageID, attempt: state.attempt + 1 }, [ + ...cancelSeek(state), + FOLLOW_DETACH, + ]) + } + + if (event.hash) { + const next = clear(state) + + return changed(next.state, [...next.effects, { type: "anchor.scroll", id: event.hash }]) + } + + // A hash this cursor cleared itself leaves it at `none`, so the echo does not undo a smooth return to the end. + if (state.status === "none" && !event.initial) return unchanged(state) + const next = clear(state) + + if (event.reveal) return next + + return changed(next.state, [...next.effects, FOLLOW_END]) +} + +function seek( + state: TimelineCursorState, + messageID: string, + behavior: ScrollBehavior, + effects: readonly TimelineCursorEffect[], + options: { now: boolean; echo: boolean }, +): TimelineCursorTransition { + const attempt = state.attempt + 1 + + return changed( + { status: "selected", messageID, fresh: true, attempt, seek: { behavior, retries: 0 }, echo: options.echo }, + [...effects, { type: options.now ? "seek.start" : "seek.schedule", attempt, messageID, behavior }], + ) +} + +function settled(state: Selected): TimelineCursorState { + return { + status: "selected", + messageID: state.messageID, + fresh: state.fresh, + attempt: state.attempt, + echo: state.echo, + } +} + +function clear(state: TimelineCursorState): TimelineCursorTransition { + if (state.status === "none") return unchanged(state) + + return changed({ status: "none", attempt: state.attempt + 1 }, cancelSeek(state)) +} + +function cancelSeek(state: TimelineCursorState) { + return state.status === "selected" && state.seek ? SEEK_CANCEL : NO_EFFECTS +} + +function changed( + state: TimelineCursorState, + effects: readonly TimelineCursorEffect[] = NO_EFFECTS, +): TimelineCursorTransition { + return { state, effects } +} + +function unchanged(state: TimelineCursorState): TimelineCursorTransition { + return { state, effects: NO_EFFECTS } +} diff --git a/packages/app/src/session/timeline/cursor.ts b/packages/app/src/session/timeline/cursor.ts new file mode 100644 index 00000000000..3fa0bce3117 --- /dev/null +++ b/packages/app/src/session/timeline/cursor.ts @@ -0,0 +1,202 @@ +import type { SessionMessageUser } from "@opencode/client/promise" +import { useLocation, useNavigate } from "@solidjs/router" +import { createEffect, createSignal, on, onCleanup, onMount, untrack, type Accessor } from "solid-js" +import { messageIdFromHash } from "../message-id-from-hash" +import { + CLEAR_CURSOR_EVENT, + createTimelineCursorState, + DISPOSED_CURSOR_EVENT, + LATEST_ADVANCED_EVENT, + pendingCursorMessageID, + SESSION_CHANGED_EVENT, + transitionTimelineCursor, + type TimelineCursorEffect, + type TimelineCursorEvent, +} from "./cursor-machine" + +/** The active prompt, the route's `#message-` target, and the scroll that brings either into view. */ +export function createTimelineCursor(input: { + sessionKey: Accessor + sessionID: Accessor + ready: Accessor + following: Accessor + visibleUserMessages: Accessor + scroller: () => HTMLDivElement | undefined + anchor: (id: string) => string + revealMessage: (id: string) => void + detach: () => void + toEnd: () => void + /** Whether history can page toward a pending target now; read tracked, so paging resumes after each page. */ + historySeekable: Accessor + seekHistory: () => void +}) { + const location = useLocation<{ reveal?: string }>() + const navigate = useNavigate() + const [cursorState, setCursorState] = createSignal(createTimelineCursorState()) + let seekFrame: number | undefined + let applyFrame: { id: number; initial: boolean } | undefined + + function dispatch(event: TimelineCursorEvent) { + untrack(() => { + const current = cursorState() + const next = transitionTimelineCursor(current, event) + + if (next.state !== current) setCursorState(next.state) + next.effects.forEach(run) + }) + } + + function run(effect: TimelineCursorEffect) { + if (effect.type === "follow.detach") return input.detach() + + if (effect.type === "follow.end") return input.toEnd() + + if (effect.type === "hash.set") { + const hash = `#${input.anchor(effect.messageID)}` + + if (location.hash !== hash) navigate(location.pathname + location.search + hash, { replace: true }) + + return + } + + if (effect.type === "hash.clear") { + if (location.hash) navigate(location.pathname + location.search, { replace: true }) + + return + } + + if (effect.type === "anchor.scroll") { + const target = document.getElementById(effect.id) + + if (!target) return input.toEnd() + input.detach() + scrollToElement(target, "auto") + + return + } + + cancelSeek() + + if (effect.type === "seek.cancel") return + + if (effect.type === "seek.start") return dispatch(probe(effect, effect.behavior === "smooth")) + seekFrame = requestAnimationFrame(() => { + seekFrame = undefined + dispatch(probe(effect, false)) + }) + } + + // A mounted prompt is close enough to glide to; any other is first brought in by the virtualizer. + function probe( + effect: { attempt: number; messageID: string; behavior: ScrollBehavior }, + glide: boolean, + ): TimelineCursorEvent { + const mounted = glide ? document.getElementById(input.anchor(effect.messageID)) : null + + if (!mounted) input.revealMessage(effect.messageID) + const element = mounted ?? document.getElementById(input.anchor(effect.messageID)) + + if (!element || !scrollToElement(element, effect.behavior)) return { type: "seek.missing", attempt: effect.attempt } + + return { type: "seek.landed", attempt: effect.attempt } + } + + function scrollToElement(element: HTMLElement, behavior: ScrollBehavior) { + const root = input.scroller() + + if (!root) return false + const sticky = root.querySelector("[data-session-title]") + const inset = sticky instanceof HTMLElement ? sticky.offsetHeight : 0 + const top = element.getBoundingClientRect().top - root.getBoundingClientRect().top + root.scrollTop - inset + root.scrollTo({ top: Math.max(0, top), behavior }) + + return true + } + + function cancelSeek() { + if (seekFrame !== undefined) cancelAnimationFrame(seekFrame) + seekFrame = undefined + } + + // Applies the hash a frame later, once the virtualizer has registered its navigation. A session switch that also + // changes the hash stays an initial apply. + function scheduleApply(initial: boolean) { + const merged = initial || (applyFrame?.initial ?? false) + + if (applyFrame) cancelAnimationFrame(applyFrame.id) + applyFrame = { + initial: merged, + id: requestAnimationFrame(() => { + applyFrame = undefined + const hash = location.hash.slice(1) + + dispatch({ + type: "hash.applied", + hash, + messageID: messageIdFromHash(hash), + initial: merged, + reveal: !!location.state?.reveal, + }) + }), + } + } + + // Runs first on a session switch, so nothing below sees the previous session's cursor. + createEffect(on(input.sessionKey, () => dispatch(SESSION_CHANGED_EVENT), { defer: true })) + createEffect( + on( + () => (input.sessionID() && input.ready() ? input.sessionKey() : undefined), + (key) => { + if (key) scheduleApply(true) + }, + ), + ) + createEffect( + on( + () => location.hash, + () => { + if (untrack(input.sessionID) && untrack(input.ready)) scheduleApply(false) + }, + { defer: true }, + ), + ) + createEffect(() => { + const id = pendingCursorMessageID(cursorState()) + + if (!id || !input.sessionID() || !input.ready()) return + + if (input.visibleUserMessages().some((message) => message.id === id)) + return dispatch({ type: "target.loaded", messageID: id }) + + if (input.historySeekable()) input.seekHistory() + }) + createEffect( + on( + () => input.visibleUserMessages().at(-1)?.id, + (lastID, previousID) => { + if (lastID && previousID && lastID > previousID) dispatch(LATEST_ADVANCED_EVENT) + }, + { defer: true }, + ), + ) + createEffect( + on( + input.following, + (following) => { + if (following) dispatch(CLEAR_CURSOR_EVENT) + }, + { defer: true }, + ), + ) + + onMount(() => { + if ("scrollRestoration" in window.history) window.history.scrollRestoration = "manual" + }) + + onCleanup(() => { + if (applyFrame) cancelAnimationFrame(applyFrame.id) + dispatch(DISPOSED_CURSOR_EVENT) + }) + + return { state: cursorState, dispatch } +} diff --git a/packages/app/src/session/timeline/interaction.ts b/packages/app/src/session/timeline/interaction.ts index 5646db17cdb..7170ffdbee4 100644 --- a/packages/app/src/session/timeline/interaction.ts +++ b/packages/app/src/session/timeline/interaction.ts @@ -4,9 +4,15 @@ import { useLocation } from "@solidjs/router" import { createEffect, createMemo, createSignal, on, onCleanup, untrack } from "solid-js" import { createStore } from "solid-js/store" import { frameLoop } from "@opencode/ui/motion" -import { useLayout } from "@/shell/state/layout" import type { SessionModel } from "../model" -import { useSessionHashScroll } from "../use-session-hash-scroll" +import { createTimelineCursor } from "./cursor" +import { + CLEAR_CURSOR_EVENT, + cursorMessageID, + freshCursorMessageID, + hasFreshCursorOrSeek, + SCROLL_MOVED_EVENT, +} from "./cursor-machine" import { createTimelineFollow } from "./follow" import { canRequestFillProbe, @@ -27,13 +33,10 @@ import { import { createTimelineModel } from "./model" export function createSessionTimelineInteraction(session: SessionModel) { - const layout = useLayout() const location = useLocation<{ reveal?: string }>() const timeline = createTimelineModel({ session }) const [state, setState] = createStore<{ - messageID: string | undefined - pendingMessage: string | undefined scroll: { overflow: boolean; jump: boolean } /** The composer region's height; the timeline scrolls on underneath it and fades out at its top. */ inset: number @@ -43,8 +46,6 @@ export function createSessionTimelineInteraction(session: SessionModel) { visible: HTMLDivElement | undefined } }>({ - messageID: undefined, - pendingMessage: undefined, scroll: { overflow: false, jump: false, @@ -75,8 +76,6 @@ export function createSessionTimelineInteraction(session: SessionModel) { let page = (_direction: 1 | -1) => {} - let scrollMark = 0 - let messageMark = 0 let scrollStateFrame: (() => void) | undefined let scrollStateTarget: HTMLDivElement | undefined const [historyState, setHistoryState] = createSignal(createTimelineHistoryState()) @@ -88,8 +87,9 @@ export function createSessionTimelineInteraction(session: SessionModel) { const visibleUserMessages = timeline.visibleUserMessages const anchor = (id: string) => `message-${id}` - const cursor = () => { - if (!scroller) return state.messageID + // The prompt at the top of the view, or the last chosen one when no prompt header is mounted there. + const promptInView = () => { + if (!scroller) return cursorMessageID(untrack(cursor.state)) const box = scroller.getBoundingClientRect() const line = box.top + 100 @@ -118,13 +118,11 @@ export function createSessionTimelineInteraction(session: SessionModel) { if (near) return near.id - return list.filter((item) => item.top <= line).at(-1)?.id ?? list[0]?.id ?? state.messageID + return list.filter((item) => item.top <= line).at(-1)?.id ?? list[0]?.id ?? cursorMessageID(untrack(cursor.state)) } - const setActiveMessage = (message: SessionMessageUser | undefined) => { - messageMark = scrollMark - setState("messageID", message?.id) - } + const setActiveMessage = (message: SessionMessageUser | undefined) => + cursor.dispatch({ type: "message.select", messageID: message?.id, following: untrack(follow.following) }) const jumpThreshold = (element: HTMLDivElement) => Math.max(400, element.clientHeight) @@ -160,35 +158,30 @@ export function createSessionTimelineInteraction(session: SessionModel) { ) } - const { clearMessageHash, scrollToMessage } = useSessionHashScroll({ + const cursor = createTimelineCursor({ sessionKey: session.identity.sessionKey, sessionID: () => session.identity.params.id, - messagesReady: timeline.ready, + ready: timeline.ready, + following: follow.following, visibleUserMessages, - historySeekable: () => canSeekHistory(historyState()), - seekHistory: () => dispatchHistory(SEEK_REQUESTED_EVENT), - currentMessageId: () => state.messageID, - pendingMessage: () => state.pendingMessage, - setPendingMessage: (value) => setState("pendingMessage", value), - setActiveMessage, - follow: { - detach, - toBottom: () => { - follow.dispatch({ type: "follow" }) - scrollToEnd() - }, - }, scroller: () => scroller, anchor, revealMessage: (id) => revealMessage(id), - scheduleScrollState, - consumePendingMessage: (key) => layout.pendingMessage.consume(key), + detach, + toEnd: () => { + follow.dispatch({ type: "follow" }) + scrollToEnd() + + if (scroller) scheduleScrollState(scroller) + }, + historySeekable: () => canSeekHistory(historyState()), + seekHistory: () => dispatchHistory(SEEK_REQUESTED_EVENT), }) let resumeFrame: (() => void) | undefined const resume = (behavior?: ScrollBehavior) => { - setState("messageID", undefined) + cursor.dispatch(CLEAR_CURSOR_EVENT) const attempt = follow.beginReturn() // Scrolls on the next frame, before it paints. A submit resumes from its key handler right after changing the // DOM, where reading the scroll range would force a layout that the frame then repeats. Input that stops @@ -203,7 +196,6 @@ export function createSessionTimelineInteraction(session: SessionModel) { return false }) - clearMessageHash() if (scroller) scheduleScrollState(scroller) } @@ -212,7 +204,7 @@ export function createSessionTimelineInteraction(session: SessionModel) { const messages = visibleUserMessages() if (messages.length === 0) return - const current = state.messageID && messageMark === scrollMark ? state.messageID : cursor() + const current = freshCursorMessageID(untrack(cursor.state)) ?? promptInView() const base = current ? messages.findIndex((message) => message.id === current) : messages.length const target = (base === -1 ? messages.length : base) + offset @@ -224,18 +216,17 @@ export function createSessionTimelineInteraction(session: SessionModel) { return } - detach() - scrollToMessage(messages[target], "auto") + cursor.dispatch({ type: "message.jump", messageID: messages[target].id, behavior: "auto" }) } // A gesture inside a nested scrollable region scrolls that region, not the timeline. const markUserScroll = (target?: EventTarget | null) => { - if (!scroller) return + if (!scroller || !hasFreshCursorOrSeek(untrack(cursor.state))) return const element = target instanceof Element ? target : undefined const nested = element?.closest("[data-scrollable]") if (nested && nested !== scroller) return - scrollMark += 1 + cursor.dispatch(SCROLL_MOVED_EVENT) } const setScrollRef = (element: HTMLDivElement | undefined) => { @@ -366,46 +357,19 @@ export function createSessionTimelineInteraction(session: SessionModel) { } createEffect( - on( - () => visibleUserMessages().at(-1)?.id, - (lastID, previousID) => { - if (lastID && previousID && lastID > previousID) setState("messageID", undefined) - }, - { defer: true }, - ), - ) - createEffect( - on( - session.identity.sessionKey, - () => { - setState("messageID", undefined) - setState("pendingMessage", undefined) - setState("scroll", { overflow: false, jump: false }) - }, - { defer: true }, - ), + on(session.identity.sessionKey, () => setState("scroll", { overflow: false, jump: false }), { defer: true }), ) createEffect( on( () => session.identity.params.id, (id, previous) => { - if (!id || !previous || id === previous || state.messageID || state.pendingMessage || location.hash) return + // A switch resets the cursor, so only a `#message-` or other hash can hold the new session elsewhere. + if (!id || !previous || id === previous || location.hash) return follow.dispatch({ type: "follow" }) scrollToEnd() }, ), ) - createEffect( - on( - follow.following, - (value) => { - if (!value) return - setState("messageID", undefined) - clearMessageHash() - }, - { defer: true }, - ), - ) createEffect(() => { const id = session.identity.params.id @@ -454,8 +418,16 @@ export function createSessionTimelineInteraction(session: SessionModel) { actions: { navigateMessage, page: (direction: 1 | -1) => page(direction), - revealMessage: (id: string, partID?: string) => revealMessage(id, partID), - revealPart: (target: string) => revealPart(target), + // Find and tool reveals move the view like a scroll, so the chosen prompt is no longer where navigation starts. + revealMessage: (id: string, partID?: string) => { + cursor.dispatch(SCROLL_MOVED_EVENT) + revealMessage(id, partID) + }, + revealPart: (target: string) => { + cursor.dispatch(SCROLL_MOVED_EVENT) + + return revealPart(target) + }, resume, setActiveMessage, }, diff --git a/packages/app/src/session/use-session-hash-scroll.ts b/packages/app/src/session/use-session-hash-scroll.ts deleted file mode 100644 index 9e773153e1f..00000000000 --- a/packages/app/src/session/use-session-hash-scroll.ts +++ /dev/null @@ -1,234 +0,0 @@ -import type { SessionMessageUser } from "@opencode/client/promise" -import { useLocation, useNavigate } from "@solidjs/router" -import { createEffect, createMemo, onCleanup, onMount } from "solid-js" -import { messageIdFromHash } from "./message-id-from-hash" - -export const useSessionHashScroll = (input: { - sessionKey: () => string - sessionID: () => string | undefined - messagesReady: () => boolean - visibleUserMessages: () => SessionMessageUser[] - historySeekable: () => boolean - seekHistory: () => void - currentMessageId: () => string | undefined - pendingMessage: () => string | undefined - setPendingMessage: (value: string | undefined) => void - setActiveMessage: (message: SessionMessageUser | undefined) => void - follow: { detach: () => void; toBottom: () => void } - scroller: () => HTMLDivElement | undefined - anchor: (id: string) => string - revealMessage?: (id: string) => void - scheduleScrollState: (el: HTMLDivElement) => void - consumePendingMessage: (key: string) => string | undefined -}) => { - const visibleUserMessages = createMemo(() => input.visibleUserMessages()) - const messageById = createMemo(() => new Map(visibleUserMessages().map((m) => [m.id, m]))) - let pendingKey = "" - let clearing = false - - const location = useLocation<{ reveal?: string }>() - const navigate = useNavigate() - - const frames = new Set() - - const queue = (fn: () => void) => { - const id = requestAnimationFrame(() => { - frames.delete(id) - fn() - }) - - frames.add(id) - } - - const cancel = () => { - for (const id of frames) cancelAnimationFrame(id) - frames.clear() - } - - const clearMessageHash = () => { - cancel() - input.consumePendingMessage(input.sessionKey()) - - if (input.pendingMessage()) input.setPendingMessage(undefined) - - if (!location.hash) return - clearing = true - navigate(location.pathname + location.search, { replace: true }) - } - - const updateHash = (id: string) => { - const hash = `#${input.anchor(id)}` - - if (location.hash === hash) return - clearing = false - navigate(location.pathname + location.search + hash, { - replace: true, - }) - } - - const scrollToElement = (el: HTMLElement, behavior: ScrollBehavior) => { - const root = input.scroller() - - if (!root) return false - - const a = el.getBoundingClientRect() - const b = root.getBoundingClientRect() - const sticky = root.querySelector("[data-session-title]") - const inset = sticky instanceof HTMLElement ? sticky.offsetHeight : 0 - const top = Math.max(0, a.top - b.top + root.scrollTop - inset) - root.scrollTo({ top, behavior }) - - return true - } - - const seek = (id: string, behavior: ScrollBehavior, left = 4): boolean => { - input.revealMessage?.(id) - const el = document.getElementById(input.anchor(id)) - - if (el) return scrollToElement(el, behavior) - - if (left <= 0) return false - queue(() => { - seek(id, behavior, left - 1) - }) - - return false - } - - const scrollToMessage = (message: SessionMessageUser, behavior: ScrollBehavior = "smooth") => { - cancel() - - if (input.currentMessageId() !== message.id) input.setActiveMessage(message) - // A mounted prompt is close enough to glide to; any other is first brought in by the virtualizer. - const mounted = behavior === "smooth" ? document.getElementById(input.anchor(message.id)) : null - - if (mounted) scrollToElement(mounted, behavior) - - if (!mounted) { - input.revealMessage?.(message.id) - seek(message.id, behavior) - } - - updateHash(message.id) - } - - const applyHash = (behavior: ScrollBehavior) => { - const hash = location.hash.slice(1) - - if (!hash) { - // A route that opens the session on a tool call leaves the scroll to the timeline, which reveals the call. - if (location.state?.reveal) return - - input.follow.toBottom() - const el = input.scroller() - - if (el) input.scheduleScrollState(el) - - return - } - - const messageId = messageIdFromHash(hash) - - if (messageId) { - input.follow.detach() - const msg = messageById().get(messageId) - - if (msg) { - scrollToMessage(msg, behavior) - - return - } - - return - } - - const target = document.getElementById(hash) - - if (target) { - input.follow.detach() - scrollToElement(target, behavior) - - return - } - - input.follow.toBottom() - const el = input.scroller() - - if (el) input.scheduleScrollState(el) - } - - createEffect(() => { - const hash = location.hash - - if (!hash) clearing = false - - if (!input.sessionID() || !input.messagesReady()) return - cancel() - queue(() => applyHash("auto")) - }) - - createEffect(() => { - if (!input.sessionID() || !input.messagesReady()) return - - visibleUserMessages() - - let targetId = input.pendingMessage() - - if (!targetId) { - const key = input.sessionKey() - - if (pendingKey !== key) { - pendingKey = key - const next = input.consumePendingMessage(key) - - if (next) { - input.setPendingMessage(next) - targetId = next - } - } - } - - if (!targetId && !clearing) targetId = messageIdFromHash(location.hash) - - if (!targetId) return - - const pending = input.pendingMessage() === targetId - const msg = messageById().get(targetId) - - if (!msg) return - - if (pending) input.setPendingMessage(undefined) - - if (input.currentMessageId() === targetId && !pending) return - - input.follow.detach() - cancel() - queue(() => scrollToMessage(msg, "auto")) - }) - - // Pages toward a target that is not loaded yet. History paging stops it once a page fails or history runs out. - createEffect(() => { - if (!input.sessionID() || !input.messagesReady()) return - - let targetId = input.pendingMessage() - - if (!targetId && !clearing) targetId = messageIdFromHash(location.hash) - - if (!targetId || messageById().has(targetId) || !input.historySeekable()) return - input.seekHistory() - }) - - onMount(() => { - if (typeof window !== "undefined" && "scrollRestoration" in window.history) { - window.history.scrollRestoration = "manual" - } - }) - - onCleanup(cancel) - - return { - clearMessageHash, - scrollToMessage, - applyHash, - } -} diff --git a/packages/app/src/shell/state/layout.test.ts b/packages/app/src/shell/state/layout.test.ts index 6eb19263fc7..faab6c6926a 100644 --- a/packages/app/src/shell/state/layout.test.ts +++ b/packages/app/src/shell/state/layout.test.ts @@ -76,15 +76,15 @@ describe("layout persistence", () => { expect( decode({ sidebar: { workspaces: { good: true, bad: "bad" } }, - sessionView: { [key]: { scroll, pendingMessage: "message" } }, + sessionView: { [key]: { scroll, reviewFile: "src/app.ts" } }, }), ).toMatchObject({ sidebar: { workspaces: {} }, - sessionView: { [key]: { scroll: {}, pendingMessage: "message" } }, + sessionView: { [key]: { scroll: {}, reviewFile: "src/app.ts" } }, }) - expect( - decode({ sessionView: { [key]: { scroll: { good: { x: 1, y: 2 } }, pendingMessage: 5 } } }).sessionView, - ).toEqual({ [key]: { scroll: {} } }) + expect(decode({ sessionView: { [key]: { scroll: { good: { x: 1, y: 2 } }, reviewFile: 5 } } }).sessionView).toEqual( + { [key]: { scroll: {} } }, + ) }) test("keeps scoped state and salvages valid tab entries", () => { diff --git a/packages/app/src/shell/state/layout.tsx b/packages/app/src/shell/state/layout.tsx index 4ae69504e6b..5d1748cc8bb 100644 --- a/packages/app/src/shell/state/layout.tsx +++ b/packages/app/src/shell/state/layout.tsx @@ -129,8 +129,6 @@ const sessionViewSchema = Persistence.struct({ reviewOpen: Schema.optional(Persistence.array(Schema.String)), reviewMode: Schema.optional(Schema.Literals(["git", "branch", "turn"])), reviewFile: Schema.optional(Schema.String), - pendingMessage: Schema.optional(Schema.String), - pendingMessageAt: Schema.optional(Schema.Finite), }) export const layoutSchema = Persistence.struct({ @@ -313,7 +311,6 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext( ) const MAX_SESSION_KEYS = 50 - const PENDING_MESSAGE_TTL_MS = 2 * 60 * 1000 const usage: SessionKeyUsage = { active: undefined, @@ -519,53 +516,6 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext( setStore("mobileSidebar", "opened", (x) => !x) }, }, - pendingMessage: { - set(sessionKey: string, messageID: string) { - const at = Date.now() - touch(sessionKey) - const current = store.sessionView[sessionKey] - - if (!current) { - setStore("sessionView", sessionKey, { - scroll: {}, - pendingMessage: messageID, - pendingMessageAt: at, - }) - prune(usage.active ?? sessionKey) - - return - } - - setStore( - "sessionView", - sessionKey, - produce((draft) => { - draft.pendingMessage = messageID - draft.pendingMessageAt = at - }), - ) - }, - consume(sessionKey: string) { - const current = store.sessionView[sessionKey] - const message = current?.pendingMessage - const at = current?.pendingMessageAt - - if (!message || !at) return - - setStore( - "sessionView", - sessionKey, - produce((draft) => { - delete draft.pendingMessage - delete draft.pendingMessageAt - }), - ) - - if (Date.now() - at > PENDING_MESSAGE_TTL_MS) return - - return message - }, - }, /** The side region of a shell tab, and the session panel width beside it. */ view(sessionKey: string | Accessor, regions: TabRegions) { const key = createSessionKeyReader(sessionKey, ensureKey)