@devries-cameron20 / t3code Mirror · read-only / commits / 65b4a69407
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 15:45 UTC

fix(web): thread details popover closes when the card moves inline (#25731)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 26, 2026 at 20:27 UTC 65b4a6940794b5f3b7af5d19d9ddef0957b14fe5
9 files changed +682 -244
apps/web/src/components/ChatView.tsx
+47 -21
@@ -121,6 +121,7 @@ import { BackgroundThreadContext } from "./chat/backgroundThread";
121 import { useLocation, useNavigate } from "@tanstack/react-router";
122 import { assistantCitationFromLocation } from "../lib/assistantCitationNavigation";
123 import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
124 +import { useStore } from "zustand";
125 import { useShallow } from "zustand/react/shallow";
126 import {
127 isAtomCommandInterrupted,
@@ -150,10 +151,7 @@ import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
151 import { subscribeSnapShotComposerFocus } from "../lib/desktopSnapShot";
152 import { useMediaQuery } from "../hooks/useMediaQuery";
153 import { FileMetadataThreadProvider } from "../hooks/FileMetadataThreadProvider";
153 -import {
154 - RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY,
155 - type ThreadPanelPresentation,
156 -} from "../rightPanelLayout";
154 +import { RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY } from "../rightPanelLayout";
155 import { PopoverCreateHandle } from "./ui/popover";
156 import {
157 selectActiveRightPanel,
@@ -164,7 +162,11 @@ import {
162 } from "../rightPanelStore";
163 import { isPreviewSupportedInRuntime, useThreadPreviewState } from "../previewStateStore";
164 import { previewRuntimeTabId } from "../browser/previewRuntimeTabId";
167 -import { ThreadPreviewMiniPlayer } from "./preview/ThreadPreviewMiniPlayer";
165 +import {
166 + ThreadPreviewMiniPlayer,
167 + useThreadPreviewCanvasSource,
168 +} from "./preview/ThreadPreviewMiniPlayer";
169 +import { createChatCanvasStore, resolveChatCanvasModel } from "./chat/canvasStore";
170 import { usePreviewSession } from "./preview/usePreviewSession";
171 import { getConfiguredPreviewUrls } from "./preview/previewEmptyStateLogic";
172
@@ -1004,16 +1006,8 @@ export default function ChatView(props: ChatViewProps) {
1006 const canMaximizeRightPanel = rightPanelOpen && !shouldUsePlanSidebarSheet;
1007 const rightPanelMaximized = canMaximizeRightPanel && rightPanelState.maximized === true;
1008 const inlineRightPanelOwnsTitleBar = rightPanelOpen && !shouldUsePlanSidebarSheet;
1007 - const [threadPanelPresentation, setThreadPanelPresentation] =
1008 - useState<ThreadPanelPresentation>("inline");
1009 const [threadPanelPopoverHandle] = useState(PopoverCreateHandle);
1010 - const threadPanelOpen = useRightPanelStore((state) =>
1011 - selectThreadPanelOpen(
1012 - state.threadPanelVisibilityByThreadKey,
1013 - activeThreadRef,
1014 - threadPanelPresentation,
1015 - ),
1016 - );
1010 + const [chatCanvasStore] = useState(createChatCanvasStore);
1011
1012 const latestRunSettled = isLatestRunSettled(activeLatestRun, activeRuntime);
1013 const activeThreadEnvironmentId = activeThread?.environmentId;
@@ -1856,6 +1850,39 @@ export default function ChatView(props: ChatViewProps) {
1850 activeThreadRef?.environmentId ?? null,
1851 AuthPreviewOperateScope,
1852 );
1853 + const shownPreviewMiniPlayer =
1854 + activeThreadRef &&
1855 + activePreviewMiniPlayer &&
1856 + previewMiniPlayerVisible &&
1857 + (activePreviewMiniPlayer.source.kind === "device" || canOperatePreview)
1858 + ? activePreviewMiniPlayer
1859 + : null;
1860 + const canvasPreview = useThreadPreviewCanvasSource(activeThreadRef, shownPreviewMiniPlayer);
1861 + const threadPanelInlineOpen = useRightPanelStore((state) =>
1862 + selectThreadPanelOpen(state.threadPanelVisibilityByThreadKey, activeThreadRef, "inline"),
1863 + );
1864 + const centerChatBesideDetails = useClientSettings((s) => s.redesignEnabled);
1865 + // Selects only the mode, so canvas resizes rerender the chat view only when the
1866 + // card switches presentation.
1867 + const threadPanelPresentation = useStore(
1868 + chatCanvasStore,
1869 + (state) =>
1870 + resolveChatCanvasModel({
1871 + measurements: state.measurements,
1872 + detailsCardMeasurement: state.detailsCardMeasurement,
1873 + threadRef: activeThreadRef,
1874 + preview: canvasPreview,
1875 + detailsCardInlineOpen: threadPanelInlineOpen,
1876 + centerBesideDetails: centerChatBesideDetails,
1877 + }).detailsCardMode,
1878 + );
1879 + const threadPanelOpen = useRightPanelStore((state) =>
1880 + selectThreadPanelOpen(
1881 + state.threadPanelVisibilityByThreadKey,
1882 + activeThreadRef,
1883 + threadPanelPresentation,
1884 + ),
1885 + );
1886 const supportsThreadPullRequests =
1887 serverConfig?.environment.capabilities.threadPullRequests === true;
1888 const visiblePullRequests = visibleThreadPullRequests(
@@ -3184,6 +3211,9 @@ export default function ChatView(props: ChatViewProps) {
3211 thread: activeThreadRef,
3212 enabled: threadFindEnabled,
3213 }}
3214 + store={chatCanvasStore}
3215 + threadRef={activeThreadRef}
3216 + preview={canvasPreview}
3217 detailsCardTopInset={isThreadFindActive ? THREAD_FIND_BAR_RESERVED_HEIGHT : 0}
3218 composerOverlayElement={isDraftHeroState ? null : composerOverlayElement}
3219 data-chat-workspace-drop-target="true"
@@ -3690,14 +3720,11 @@ export default function ChatView(props: ChatViewProps) {
3720 {canOperatePreview && activeThreadRef && activeEnvironmentServerBrowser ? (
3721 <PreviewSessionSync threadRef={activeThreadRef} />
3722 ) : null}
3693 - {activeThreadRef &&
3694 - activePreviewMiniPlayer &&
3695 - previewMiniPlayerVisible &&
3696 - (activePreviewMiniPlayer.source.kind === "device" || canOperatePreview) ? (
3723 + {activeThreadRef && shownPreviewMiniPlayer ? (
3724 <ThreadPreviewMiniPlayer
3698 - key={`${activeThreadKey}:${previewMiniPlayerSourceKey(activePreviewMiniPlayer.source)}`}
3725 + key={`${activeThreadKey}:${previewMiniPlayerSourceKey(shownPreviewMiniPlayer.source)}`}
3726 threadRef={activeThreadRef}
3700 - miniPlayer={activePreviewMiniPlayer}
3727 + miniPlayer={shownPreviewMiniPlayer}
3728 />
3729 ) : null}
3730
@@ -3711,7 +3738,6 @@ export default function ChatView(props: ChatViewProps) {
3738 <ThreadDetailsPanel
3739 anchor={threadPanelPopoverAnchorRef}
3740 handle={threadPanelPopoverHandle}
3714 - onPresentationChange={setThreadPanelPresentation}
3741 forceNewWorktree={multipleModelSelections !== null}
3742 environmentId={activeThread.environmentId}
3743 threadId={activeThread.id}
apps/web/src/components/chat/ChatCanvas.tsx
+47 -77
@@ -1,60 +1,35 @@
1 import { useLayoutEffect, useRef, useState, type ComponentProps, type CSSProperties } from "react";
2 +import { useStore } from "zustand";
3 import { ChatCanvasContext } from "./ChatCanvasContext";
3 -import { resolveChatCanvasLayout, type ChatCanvasPreview } from "./chatCanvasLayout";
4 -import type { PreviewMiniPlayerObstacles } from "../preview/previewMiniPlayerLayout";
4 +import type { ChatCanvasPreview } from "./chatCanvasLayout";
5 +import { resolveChatCanvasModel, type ChatCanvasStore } from "./canvasStore";
6 +import { selectThreadPanelOpen, useRightPanelStore } from "../../rightPanelStore";
7 import { observeResize } from "../../lib/observeResize";
8 +import type { ScopedThreadRef } from "@t3tools/contracts";
9 import { useClientSettings } from "~/hooks/useSettings";
10
11 export function ChatCanvas({
12 + store,
13 + threadRef,
14 + preview,
15 composerOverlayElement,
16 detailsCardTopInset = 0,
17 children,
18 ...props
19 }: Omit<ComponentProps<"div">, "className" | "style" | "ref"> & {
20 + store: ChatCanvasStore;
21 + /** The thread whose details card sits on the canvas; other threads' measurements are stale. */
22 + threadRef: ScopedThreadRef | null;
23 + /** The thread's mini player while it renders on this canvas. */
24 + preview: ChatCanvasPreview | null;
25 composerOverlayElement: HTMLElement | null;
26 detailsCardTopInset?: number;
27 }) {
28 const elementRef = useRef<HTMLDivElement | null>(null);
29 const widthProbeRef = useRef<HTMLDivElement | null>(null);
30 const [timelineElement, registerTimeline] = useState<HTMLElement | null>(null);
20 - const [preview, setPreview] = useState<ChatCanvasPreview | null>(null);
21 - const [detailsCard, setDetailsCard] = useState<PreviewMiniPlayerObstacles["detailsCard"]>(null);
22 - const reportDetailsCard = (next: PreviewMiniPlayerObstacles["detailsCard"]) => {
23 - setDetailsCard((current) =>
24 - current?.left === next?.left &&
25 - current?.right === next?.right &&
26 - current?.bottom === next?.bottom
27 - ? current
28 - : next,
29 - );
30 - };
31 - const [measurements, setMeasurements] = useState({
32 - width: 0,
33 - height: 0,
34 - padding: 48,
35 - maxChatWidth: 768,
36 - minChatWidth: 640,
37 - composerHeight: 0,
38 - timelineGutter: 0,
39 - findBarLeft: 0,
40 - findBarRight: 0,
41 - findBarBottom: 0,
42 - });
43 - const reportPreview = (next: ChatCanvasPreview) => {
44 - setPreview((current) =>
45 - current?.key === next.key &&
46 - current.width === next.width &&
47 - current.lastInteraction === next.lastInteraction &&
48 - current.position?.x === next.position?.x &&
49 - current.position?.y === next.position?.y &&
50 - current.source.width === next.source.width &&
51 - current.source.height === next.source.height
52 - ? current
53 - : next,
54 - );
55 - };
56 - const clearPreview = (key: string) =>
57 - setPreview((current) => (current?.key === key ? null : current));
31 + const measurements = useStore(store, (state) => state.measurements);
32 + const detailsCardMeasurement = useStore(store, (state) => state.detailsCardMeasurement);
33 useLayoutEffect(() => {
34 const element = elementRef.current;
35 const probe = widthProbeRef.current;
@@ -65,10 +40,15 @@ export function ChatCanvas({
40 const canvasBounds = element.getBoundingClientRect();
41 const findBarBounds = findBar?.getBoundingClientRect();
42 const styles = getComputedStyle(probe);
68 - const next = {
69 - findBarLeft: findBarBounds ? findBarBounds.left - canvasBounds.left : 0,
70 - findBarRight: findBarBounds ? findBarBounds.right - canvasBounds.left : 0,
71 - findBarBottom: findBarBounds ? findBarBounds.bottom - canvasBounds.top : 0,
43 + store.getState().setMeasurements({
44 + findBar:
45 + detailsCardTopInset > 0
46 + ? {
47 + left: findBarBounds ? findBarBounds.left - canvasBounds.left : 0,
48 + right: findBarBounds ? findBarBounds.right - canvasBounds.left : 0,
49 + bottom: findBarBounds ? findBarBounds.bottom - canvasBounds.top : 0,
50 + }
51 + : null,
52 width: element.clientWidth,
53 height: element.clientHeight,
54 padding: Number.parseFloat(styles.paddingLeft),
@@ -78,14 +58,7 @@ export function ChatCanvas({
58 timelineGutter: timelineElement
59 ? (timelineElement.offsetWidth - timelineElement.clientWidth) / 2
60 : 0,
81 - };
82 - setMeasurements((current) =>
83 - Object.keys(next).every(
84 - (key) => current[key as keyof typeof current] === next[key as keyof typeof next],
85 - )
86 - ? current
87 - : next,
88 - );
61 + });
62 };
63 measure();
64 const observed: Element[] = [element, probe];
@@ -93,34 +66,31 @@ export function ChatCanvas({
66 if (composerOverlayElement) observed.push(composerOverlayElement);
67 if (timelineElement) observed.push(timelineElement);
68 return observeResize(observed, measure);
96 - }, [composerOverlayElement, timelineElement, detailsCardTopInset]);
97 - const redesign = useClientSettings((s) => s.redesignEnabled);
98 - const container = { width: measurements.width, height: measurements.height };
99 - const findBar =
100 - detailsCardTopInset > 0
101 - ? {
102 - left: measurements.findBarLeft,
103 - right: measurements.findBarRight,
104 - bottom: measurements.findBarBottom,
105 - }
106 - : null;
69 + }, [store, composerOverlayElement, timelineElement, detailsCardTopInset]);
70 + const detailsCardInlineOpen = useRightPanelStore((state) =>
71 + threadRef === null
72 + ? false
73 + : selectThreadPanelOpen(state.threadPanelVisibilityByThreadKey, threadRef, "inline"),
74 + );
75 + const centerBesideDetails = useClientSettings((s) => s.redesignEnabled);
76 + const model = resolveChatCanvasModel({
77 + measurements,
78 + detailsCardMeasurement,
79 + threadRef,
80 + preview,
81 + detailsCardInlineOpen,
82 + centerBesideDetails,
83 + });
84 const context = {
108 - container,
109 - lane: { padding: measurements.padding, minChatWidth: measurements.minChatWidth },
110 - layout: resolveChatCanvasLayout({
111 - ...measurements,
112 - container,
113 - preview,
114 - detailsCard,
115 - findBar,
116 - centerBesideDetails: redesign,
117 - }),
85 + container: model.container,
86 + lane: model.lane,
87 + layout: model.layout,
88 previewKey: preview?.key ?? null,
119 - reportPreview,
120 - clearPreview,
89 registerTimeline,
122 - reportDetailsCard,
123 - detailsCardTopInset: findBar?.bottom ?? 0,
90 + measureDetailsCard: store.getState().measureDetailsCard,
91 + detailsCardTopInset: model.detailsCardTopInset,
92 + preferredDetailsCard: model.preferredDetailsCard,
93 + detailsCardPlacement: model.detailsCardPlacement,
94 };
95 const { layout } = context;
96 return (
apps/web/src/components/chat/ChatCanvasContext.ts
+15 -5
@@ -1,17 +1,27 @@
1 import { createContext, useContext } from "react";
2 -import type { ChatCanvasPreview, resolveChatCanvasLayout } from "./chatCanvasLayout";
3 -import type { PreviewMiniPlayerObstacles } from "../preview/previewMiniPlayerLayout";
2 +import type { resolveChatCanvasLayout } from "./chatCanvasLayout";
3 +import type { resolveThreadDetailsCardLayout } from "./threadDetailsCardLayout";
4 +import type { ScopedThreadRef } from "@t3tools/contracts";
5 +
6 +/** The inline details card's measured full-density height at a card width. */
7 +export interface DetailsCardMeasurement {
8 + readonly threadRef: ScopedThreadRef;
9 + readonly width: number;
10 + readonly fullContentHeight: number;
11 +}
12
13 export const ChatCanvasContext = createContext<{
14 container: { width: number; height: number };
15 lane: { padding: number; minChatWidth: number };
16 layout: ReturnType<typeof resolveChatCanvasLayout>;
17 previewKey: string | null;
10 - reportPreview: (preview: ChatCanvasPreview) => void;
11 - clearPreview: (key: string) => void;
18 registerTimeline: (element: HTMLElement | null) => void;
13 - reportDetailsCard: (card: PreviewMiniPlayerObstacles["detailsCard"]) => void;
19 + measureDetailsCard: (measurement: DetailsCardMeasurement) => void;
20 detailsCardTopInset: number;
21 + /** Where an inline card sits when nothing overlaps it; null when the canvas is too narrow. */
22 + preferredDetailsCard: ReturnType<typeof resolveThreadDetailsCardLayout>;
23 + /** Where the inline card sits now; null when it shows as a popover. */
24 + detailsCardPlacement: ReturnType<typeof resolveThreadDetailsCardLayout>;
25 } | null>(null);
26
27 export const useChatCanvas = () => useContext(ChatCanvasContext);
apps/web/src/components/chat/ThreadDetailsCard.browser.test.tsx new
+138
@@ -0,0 +1,138 @@
1 +import { StrictMode } from "react";
2 +import { EnvironmentId, ThreadId, type ScopedThreadRef } from "@t3tools/contracts";
3 +import { expect, it } from "vite-plus/test";
4 +import { page } from "vite-plus/test/browser";
5 +import { act, render } from "../../../test/render";
6 +import { selectThreadPanelOpen, useRightPanelStore } from "../../rightPanelStore";
7 +import { PopoverCreateHandle } from "../ui/popover";
8 +import { ChatCanvasContext } from "./ChatCanvasContext";
9 +import { resolveChatCanvasLayout } from "./chatCanvasLayout";
10 +import { ThreadDetailsCard } from "./ThreadDetailsCard";
11 +
12 +const threadA: ScopedThreadRef = {
13 + environmentId: EnvironmentId.make("environment"),
14 + threadId: ThreadId.make("thread-a"),
15 +};
16 +const threadB: ScopedThreadRef = {
17 + environmentId: EnvironmentId.make("environment"),
18 + threadId: ThreadId.make("thread-b"),
19 +};
20 +const container = { width: 1200, height: 800 };
21 +const placement = { x: 908, y: 0, right: 12, width: 280, height: 400 } as const;
22 +
23 +function setup() {
24 + useRightPanelStore.setState({ threadPanelVisibilityByThreadKey: {} });
25 + const anchor = document.createElement("div");
26 + document.body.append(anchor);
27 + return {
28 + anchor: { current: anchor },
29 + handle: PopoverCreateHandle(),
30 + [Symbol.dispose]: () => anchor.remove(),
31 + };
32 +}
33 +
34 +const popoverOpen = (threadRef: ScopedThreadRef) =>
35 + selectThreadPanelOpen(
36 + useRightPanelStore.getState().threadPanelVisibilityByThreadKey,
37 + threadRef,
38 + "popover",
39 + );
40 +
41 +function Card({
42 + threadRef,
43 + inline,
44 + fixture,
45 +}: {
46 + threadRef: ScopedThreadRef;
47 + inline: boolean;
48 + fixture: ReturnType<typeof setup>;
49 +}) {
50 + return (
51 + // The web root renders in StrictMode, which re-runs ref callbacks on every mount.
52 + <StrictMode>
53 + <ChatCanvasContext
54 + value={{
55 + container,
56 + lane: { padding: 48, minChatWidth: 640 },
57 + layout: resolveChatCanvasLayout({ container, preview: null }),
58 + previewKey: null,
59 + registerTimeline: () => {},
60 + measureDetailsCard: () => {},
61 + detailsCardTopInset: 0,
62 + preferredDetailsCard: placement,
63 + detailsCardPlacement: inline ? placement : null,
64 + }}
65 + >
66 + <ThreadDetailsCard threadRef={threadRef} anchor={fixture.anchor} handle={fixture.handle}>
67 + {() => <p>Details for {threadRef.threadId}</p>}
68 + </ThreadDetailsCard>
69 + </ChatCanvasContext>
70 + </StrictMode>
71 + );
72 +}
73 +
74 +it("stays open once opened", async () => {
75 + using fixture = setup();
76 + await using _screen = await render(<Card threadRef={threadB} inline={false} fixture={fixture} />);
77 + await act(() => useRightPanelStore.getState().setThreadPanelOpen(threadB, "popover", true));
78 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
79 + expect(popoverOpen(threadB)).toBe(true);
80 +});
81 +
82 +it("closes a popup left open when the card switches inline, and reopens from the flag", async () => {
83 + using fixture = setup();
84 + await using screen = await render(<Card threadRef={threadB} inline={false} fixture={fixture} />);
85 + const setOpen = (open: boolean) =>
86 + act(() => useRightPanelStore.getState().setThreadPanelOpen(threadB, "popover", open));
87 + await setOpen(true);
88 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
89 +
90 + useRightPanelStore.getState().setThreadPanelOpen(threadB, "inline", false);
91 + await screen.rerender(<Card threadRef={threadB} inline fixture={fixture} />);
92 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
93 + await setOpen(false);
94 +
95 + await screen.rerender(<Card threadRef={threadB} inline={false} fixture={fixture} />);
96 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
97 + await setOpen(true);
98 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
99 +});
100 +
101 +it("does not reopen the popover when the card returns from inline mode", async () => {
102 + using fixture = setup();
103 + await using screen = await render(<Card threadRef={threadB} inline={false} fixture={fixture} />);
104 + await act(() => useRightPanelStore.getState().setThreadPanelOpen(threadB, "popover", true));
105 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
106 +
107 + useRightPanelStore.getState().setThreadPanelOpen(threadB, "inline", false);
108 + await screen.rerender(<Card threadRef={threadB} inline fixture={fixture} />);
109 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
110 +
111 + await screen.rerender(<Card threadRef={threadB} inline={false} fixture={fixture} />);
112 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
113 + expect(popoverOpen(threadB)).toBe(false);
114 +});
115 +
116 +it("removes the leaving thread's popup on a thread switch", async () => {
117 + using fixture = setup();
118 + await using screen = await render(<Card threadRef={threadB} inline={false} fixture={fixture} />);
119 + await act(() => useRightPanelStore.getState().setThreadPanelOpen(threadB, "popover", true));
120 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
121 +
122 + await screen.rerender(<Card threadRef={threadA} inline={false} fixture={fixture} />);
123 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
124 + await expect.element(page.getByText("Details for thread-a")).not.toBeInTheDocument();
125 +});
126 +
127 +it("reopens after a normal close", async () => {
128 + using fixture = setup();
129 + await using _screen = await render(<Card threadRef={threadB} inline={false} fixture={fixture} />);
130 + const setOpen = (open: boolean) =>
131 + act(() => useRightPanelStore.getState().setThreadPanelOpen(threadB, "popover", open));
132 + await setOpen(true);
133 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
134 + await setOpen(false);
135 + await expect.element(page.getByText("Details for thread-b")).not.toBeInTheDocument();
136 + await setOpen(true);
137 + await expect.element(page.getByText("Details for thread-b")).toBeVisible();
138 +});
apps/web/src/components/chat/ThreadDetailsCard.tsx
+69 -92
@@ -4,12 +4,10 @@ import { ScrollArea } from "../ui/scroll-area";
4 import { cn } from "../../lib/utils";
5 import { Popover, PopoverPopup, PopoverCreateHandle } from "../ui/popover";
6 import { selectThreadPanelOpen, useRightPanelStore } from "../../rightPanelStore";
7 -import type { ThreadPanelPresentation } from "../../rightPanelLayout";
7 import { useChatCanvas } from "./ChatCanvasContext";
8 import {
9 THREAD_DETAILS_CARD_GAP,
10 resolveThreadDetailsCardDensity,
12 - resolveThreadDetailsCardLayout,
11 } from "./threadDetailsCardLayout";
12 import { observeResize } from "../../lib/observeResize";
13
@@ -17,33 +15,16 @@ export function ThreadDetailsCard({
15 threadRef,
16 anchor,
17 handle,
20 - onPresentationChange,
18 children,
19 }: {
20 threadRef: ScopedThreadRef;
21 anchor: RefObject<Element | null>;
22 handle: ReturnType<typeof PopoverCreateHandle>;
26 - onPresentationChange: (presentation: ThreadPanelPresentation) => void;
23 children: (density: "full" | "compact" | "essential") => ReactNode;
24 }) {
25 const canvas = useChatCanvas();
30 - const preferredPlacement = canvas
31 - ? resolveThreadDetailsCardLayout({
32 - container: canvas.container,
33 - lane: canvas.lane,
34 - frame: null,
35 - topInset: canvas.detailsCardTopInset,
36 - })
37 - : null;
38 - const placement = canvas
39 - ? resolveThreadDetailsCardLayout({
40 - container: canvas.container,
41 - lane: canvas.lane,
42 - frame: canvas.layout.frame,
43 - overlapsDetailsCard: canvas.layout.overlapsDetailsCard,
44 - topInset: canvas.detailsCardTopInset,
45 - })
46 - : null;
26 + const preferredPlacement = canvas?.preferredDetailsCard ?? null;
27 + const placement = canvas?.detailsCardPlacement ?? null;
28 const mode = placement ? "inline" : "popover";
29 const topInset = canvas?.detailsCardTopInset ?? 0;
30 const inlineOpen = useRightPanelStore((state) =>
@@ -52,39 +33,29 @@ export function ThreadDetailsCard({
33 const popoverOpen = useRightPanelStore((state) =>
34 selectThreadPanelOpen(state.threadPanelVisibilityByThreadKey, threadRef, "popover"),
35 );
55 - const [contentElement, setContentElement] = useState<HTMLDivElement | null>(null);
36 const measurementKey = `${threadRef.environmentId}:${threadRef.threadId}:${preferredPlacement?.width ?? "popup"}`;
37 const [measurements, setMeasurements] = useState({
38 key: measurementKey,
39 heights: { full: 0, compact: 0 },
60 - fullContentHeight: 0,
40 });
41 const contentHeights =
42 measurements.key === measurementKey ? measurements.heights : { full: 0, compact: 0 };
43 const height = placement?.height ?? Math.max(0, (canvas?.container.height ?? 0) - 52);
44 const density = resolveThreadDetailsCardDensity(height, contentHeights);
66 - const reportDetailsCard = canvas?.reportDetailsCard;
67 - const cardLeft = preferredPlacement?.x;
68 - const cardRight = preferredPlacement
69 - ? preferredPlacement.x + preferredPlacement.width
70 - : undefined;
71 - const cardBottom =
72 - preferredPlacement && measurements.key === measurementKey && measurements.fullContentHeight > 0
73 - ? preferredPlacement.y + Math.min(measurements.fullContentHeight, preferredPlacement.height)
74 - : undefined;
75 - useLayoutEffect(() => {
76 - reportDetailsCard?.(
77 - inlineOpen && cardLeft !== undefined && cardRight !== undefined && cardBottom !== undefined
78 - ? { left: cardLeft, right: cardRight, bottom: cardBottom }
79 - : null,
80 - );
81 - }, [reportDetailsCard, inlineOpen, cardLeft, cardRight, cardBottom]);
82 - useLayoutEffect(() => () => reportDetailsCard?.(null), [reportDetailsCard]);
45 + const measureDetailsCard = canvas?.measureDetailsCard;
46 + const cardWidth = preferredPlacement?.width;
47 + // The mode derives from canvas measurements, the preview frame and the
48 + // inline flag, which live in three stores, so no single write site sees the
49 + // card leave popover mode. A flag left set would reopen the popover unasked
50 + // when the card returns to popover mode.
51 useLayoutEffect(() => {
84 - onPresentationChange(mode);
52 if (mode === "inline" && popoverOpen)
53 useRightPanelStore.getState().setThreadPanelOpen(threadRef, "popover", false);
87 - }, [mode, onPresentationChange, threadRef, popoverOpen]);
54 + }, [mode, popoverOpen, threadRef]);
55 + const [contentElement, setContentElement] = useState<HTMLDivElement | null>(null);
56 + const { environmentId, threadId } = threadRef;
57 + // Re-measures when the density or measurement key changes, so each density's
58 + // height is measured once it renders.
59 useLayoutEffect(() => {
60 const element = contentElement;
61 if (!element || density === "essential") return;
@@ -100,26 +71,31 @@ export function ThreadDetailsCard({
71 next - Array.from(lists).reduce((sum, list) => sum + list.offsetHeight, 0);
72 setMeasurements((current) => {
73 const heights = current.key === measurementKey ? current.heights : { full: 0, compact: 0 };
103 - const fullContentHeight =
104 - density === "full"
105 - ? next
106 - : current.key === measurementKey
107 - ? current.fullContentHeight
108 - : 0;
109 - return current.key === measurementKey &&
110 - heights[density] === fittingHeight &&
111 - current.fullContentHeight === fullContentHeight
74 + return current.key === measurementKey && heights[density] === fittingHeight
75 ? current
113 - : {
114 - key: measurementKey,
115 - heights: { ...heights, [density]: fittingHeight },
116 - fullContentHeight,
117 - };
76 + : { key: measurementKey, heights: { ...heights, [density]: fittingHeight } };
77 });
78 + // Only the laid-out DOM knows the full card height, and the canvas keeps preview
79 + // frames clear of it, so it is reported from this measure effect.
80 + if (density === "full" && cardWidth !== undefined) {
81 + measureDetailsCard?.({
82 + threadRef: { environmentId, threadId },
83 + width: cardWidth,
84 + fullContentHeight: next,
85 + });
86 + }
87 };
88 measure();
89 return observeResize(element, measure);
122 - }, [contentElement, density, measurementKey]);
90 + }, [
91 + contentElement,
92 + density,
93 + measurementKey,
94 + cardWidth,
95 + measureDetailsCard,
96 + environmentId,
97 + threadId,
98 + ]);
99 const card = (
100 <div
101 className={cn(
@@ -153,45 +129,46 @@ export function ThreadDetailsCard({
129 useRightPanelStore.getState().setThreadPanelOpen(threadRef, "popover", open);
130 }}
131 >
156 - {placement ? (
157 - inlineOpen ? (
158 - <aside
159 - aria-label="Thread details"
160 - // Skip the return transition to avoid overlapping the rising preview.
161 - className={cn(
162 - "absolute z-20",
163 - topInset > 0 &&
164 - "transition-[top] duration-150 ease-out motion-reduce:transition-none",
165 - )}
166 - style={{
167 - right: placement.right,
168 - top: placement.y,
169 - width: placement.width,
170 - maxHeight: height,
171 - }}
172 - data-density={density}
173 - data-thread-details-panel="inline"
174 - >
175 - {card}
176 - </aside>
177 - ) : null
178 - ) : (
179 - <PopoverPopup
180 - anchor={anchor}
181 - align="end"
182 - // Account for the find panel's 8px card padding.
183 - alignOffset={THREAD_DETAILS_CARD_GAP - 8}
184 - collisionAvoidance={{ side: "shift", align: "shift", fallbackAxisSide: "none" }}
185 - side="bottom"
186 - sideOffset={topInset}
187 - variant="panel"
188 - padding="none"
132 + {placement && inlineOpen ? (
133 + <aside
134 + aria-label="Thread details"
135 + // Skip the return transition to avoid overlapping the rising preview.
136 + className={cn(
137 + "absolute z-20",
138 + topInset > 0 && "transition-[top] duration-150 ease-out motion-reduce:transition-none",
139 + )}
140 + style={{
141 + right: placement.right,
142 + top: placement.y,
143 + width: placement.width,
144 + maxHeight: height,
145 + }}
146 + data-density={density}
147 + data-thread-details-panel="inline"
148 >
149 + {card}
150 + </aside>
151 + ) : null}
152 + {/* Rendered in both modes: base-ui keeps a popup that unmounts mid-open
153 + mounted, because its exit animation never finishes. Staying in the tree
154 + lets it close cleanly when the card switches inline. */}
155 + <PopoverPopup
156 + anchor={anchor}
157 + align="end"
158 + // Account for the find panel's 8px card padding.
159 + alignOffset={THREAD_DETAILS_CARD_GAP - 8}
160 + collisionAvoidance={{ side: "shift", align: "shift", fallbackAxisSide: "none" }}
161 + side="bottom"
162 + sideOffset={topInset}
163 + variant="panel"
164 + padding="none"
165 + >
166 + {mode === "popover" ? (
167 <div data-density={density} data-thread-details-panel="popover">
168 {card}
169 </div>
193 - </PopoverPopup>
194 - )}
170 + ) : null}
171 + </PopoverPopup>
172 </Popover>
173 );
174 }
apps/web/src/components/chat/ThreadDetailsPanel.tsx
+1 -2
@@ -27,7 +27,7 @@ const GitActionsControl = memo(BaseGitActionsControl);
27
28 export interface ThreadDetailsPanelProps extends Pick<
29 ComponentProps<typeof ThreadDetailsCard>,
30 - "anchor" | "handle" | "onPresentationChange"
30 + "anchor" | "handle"
31 > {
32 forceNewWorktree?: boolean;
33 environmentId: EnvironmentId;
@@ -105,7 +105,6 @@ export function ThreadDetailsPanel(props: ThreadDetailsPanelProps) {
105 threadRef={{ environmentId: props.environmentId, threadId: props.threadId }}
106 anchor={props.anchor}
107 handle={props.handle}
108 - onPresentationChange={props.onPresentationChange}
108 >
109 {(density) => (
110 <>
apps/web/src/components/chat/canvasStore.test.ts new
+86
@@ -0,0 +1,86 @@
1 +import { EnvironmentId, ThreadId } from "@t3tools/contracts";
2 +import { describe, expect, it } from "vite-plus/test";
3 +import {
4 + createChatCanvasStore,
5 + resolveChatCanvasModel,
6 + type ChatCanvasMeasurements,
7 +} from "./canvasStore";
8 +import type { ChatCanvasPreview } from "./chatCanvasLayout";
9 +
10 +const threadRef = {
11 + environmentId: EnvironmentId.make("environment-1"),
12 + threadId: ThreadId.make("thread-1"),
13 +};
14 +const otherThreadRef = { ...threadRef, threadId: ThreadId.make("thread-2") };
15 +const measurements = (width: number, height = 900): ChatCanvasMeasurements => ({
16 + width,
17 + height,
18 + padding: 48,
19 + maxChatWidth: 768,
20 + minChatWidth: 640,
21 + composerHeight: 180,
22 + timelineGutter: 0,
23 + findBar: null,
24 +});
25 +const preview: ChatCanvasPreview = {
26 + key: "browser:one",
27 + width: 320,
28 + position: null,
29 + source: { width: 1600, height: 1000 },
30 +};
31 +
32 +describe("chat canvas model", () => {
33 + it("shows the details card inline only where the canvas fits it beside the chat", () => {
34 + const resolve = (width: number) =>
35 + resolveChatCanvasModel({
36 + measurements: measurements(width),
37 + detailsCardMeasurement: null,
38 + threadRef,
39 + preview: null,
40 + detailsCardInlineOpen: true,
41 + centerBesideDetails: false,
42 + }).detailsCardMode;
43 + expect(resolve(1400)).toBe("inline");
44 + expect(resolve(900)).toBe("popover");
45 + });
46 +
47 + it("moves the card into a popover when a preview below it leaves too little height", () => {
48 + const resolve = (fullContentHeight: number) =>
49 + resolveChatCanvasModel({
50 + measurements: measurements(1100, 300),
51 + detailsCardMeasurement: { threadRef, width: 280, fullContentHeight },
52 + threadRef,
53 + preview: { ...preview, position: { x: 760, y: 150 }, lastInteraction: "drag" },
54 + detailsCardInlineOpen: true,
55 + centerBesideDetails: false,
56 + });
57 + const model = resolve(400);
58 + expect(model.layout.overlapsDetailsCard).toBe(true);
59 + expect(model.detailsCardMode).toBe("popover");
60 + });
61 +
62 + it("ignores a details card measured for another thread", () => {
63 + const model = resolveChatCanvasModel({
64 + measurements: measurements(1100, 300),
65 + detailsCardMeasurement: { threadRef: otherThreadRef, width: 280, fullContentHeight: 400 },
66 + threadRef,
67 + preview: { ...preview, position: { x: 760, y: 150 }, lastInteraction: "drag" },
68 + detailsCardInlineOpen: true,
69 + centerBesideDetails: false,
70 + });
71 + expect(model.layout.overlapsDetailsCard).toBe(false);
72 + expect(model.detailsCardMode).toBe("inline");
73 + });
74 +
75 + it("keeps state identity when a measurement repeats", () => {
76 + const store = createChatCanvasStore();
77 + store.getState().setMeasurements(measurements(1400));
78 + const before = store.getState();
79 + store.getState().setMeasurements(measurements(1400));
80 + store.getState().measureDetailsCard({ threadRef, width: 280, fullContentHeight: 300 });
81 + const measured = store.getState();
82 + store.getState().measureDetailsCard({ threadRef, width: 280, fullContentHeight: 300 });
83 + expect(measured.measurements).toBe(before.measurements);
84 + expect(store.getState()).toBe(measured);
85 + });
86 +});
apps/web/src/components/chat/canvasStore.ts new
+160
@@ -0,0 +1,160 @@
1 +import type { ScopedThreadRef } from "@t3tools/contracts";
2 +import { createStore } from "zustand";
3 +import type { ThreadPanelPresentation } from "../../rightPanelLayout";
4 +import type { DetailsCardMeasurement } from "./ChatCanvasContext";
5 +import { resolveChatCanvasLayout, type ChatCanvasPreview } from "./chatCanvasLayout";
6 +import { resolveThreadDetailsCardLayout } from "./threadDetailsCardLayout";
7 +
8 +interface CanvasEdges {
9 + readonly left: number;
10 + readonly right: number;
11 + readonly bottom: number;
12 +}
13 +
14 +export interface ChatCanvasMeasurements {
15 + readonly width: number;
16 + readonly height: number;
17 + readonly padding: number;
18 + readonly maxChatWidth: number;
19 + readonly minChatWidth: number;
20 + readonly composerHeight: number;
21 + readonly timelineGutter: number;
22 + /** The find bar's box in canvas coordinates while it is shown. */
23 + readonly findBar: CanvasEdges | null;
24 +}
25 +
26 +interface ChatCanvasStoreState {
27 + readonly measurements: ChatCanvasMeasurements;
28 + readonly detailsCardMeasurement: DetailsCardMeasurement | null;
29 + readonly setMeasurements: (next: ChatCanvasMeasurements) => void;
30 + readonly measureDetailsCard: (next: DetailsCardMeasurement) => void;
31 +}
32 +
33 +const INITIAL_MEASUREMENTS: ChatCanvasMeasurements = {
34 + width: 0,
35 + height: 0,
36 + padding: 48,
37 + maxChatWidth: 768,
38 + minChatWidth: 640,
39 + composerHeight: 0,
40 + timelineGutter: 0,
41 + findBar: null,
42 +};
43 +
44 +const sameEdges = (a: CanvasEdges | null, b: CanvasEdges | null) =>
45 + a === b ||
46 + (a !== null && b !== null && a.left === b.left && a.right === b.right && a.bottom === b.bottom);
47 +
48 +const sameMeasurements = (a: ChatCanvasMeasurements, b: ChatCanvasMeasurements) =>
49 + a.width === b.width &&
50 + a.height === b.height &&
51 + a.padding === b.padding &&
52 + a.maxChatWidth === b.maxChatWidth &&
53 + a.minChatWidth === b.minChatWidth &&
54 + a.composerHeight === b.composerHeight &&
55 + a.timelineGutter === b.timelineGutter &&
56 + sameEdges(a.findBar, b.findBar);
57 +
58 +/**
59 + * One store per chat view: the canvas measures into it, and the chat view's
60 + * header controls derive the details card presentation from the same inputs.
61 + */
62 +export const createChatCanvasStore = () =>
63 + createStore<ChatCanvasStoreState>()((set) => ({
64 + measurements: INITIAL_MEASUREMENTS,
65 + detailsCardMeasurement: null,
66 + setMeasurements: (next) =>
67 + set((state) => (sameMeasurements(state.measurements, next) ? state : { measurements: next })),
68 + measureDetailsCard: (next) =>
69 + set((state) => {
70 + const current = state.detailsCardMeasurement;
71 + return current?.threadRef.environmentId === next.threadRef.environmentId &&
72 + current.threadRef.threadId === next.threadRef.threadId &&
73 + current.width === next.width &&
74 + current.fullContentHeight === next.fullContentHeight
75 + ? state
76 + : { detailsCardMeasurement: next };
77 + }),
78 + }));
79 +
80 +export type ChatCanvasStore = ReturnType<typeof createChatCanvasStore>;
81 +
82 +export function resolveChatCanvasModel({
83 + measurements,
84 + detailsCardMeasurement,
85 + threadRef,
86 + preview,
87 + detailsCardInlineOpen,
88 + centerBesideDetails,
89 +}: {
90 + measurements: ChatCanvasMeasurements;
91 + detailsCardMeasurement: DetailsCardMeasurement | null;
92 + /** The thread whose details card sits on the canvas; other threads' measurements are stale. */
93 + threadRef: ScopedThreadRef | null;
94 + preview: ChatCanvasPreview | null;
95 + detailsCardInlineOpen: boolean;
96 + centerBesideDetails: boolean;
97 +}) {
98 + const container = { width: measurements.width, height: measurements.height };
99 + const { findBar } = measurements;
100 + const detailsCardTopInset = findBar?.bottom ?? 0;
101 + const lane = { padding: measurements.padding, minChatWidth: measurements.minChatWidth };
102 + // The preview avoids where an open inline card would sit, whether or not a
103 + // preview overlap has pushed the card itself into popover mode.
104 + const preferredDetailsCard = resolveThreadDetailsCardLayout({
105 + container,
106 + lane,
107 + frame: null,
108 + topInset: detailsCardTopInset,
109 + });
110 + // The canvas outlives thread switches, so a measurement only counts for the
111 + // thread whose card is shown now.
112 + const detailsCardMeasured =
113 + threadRef !== null &&
114 + detailsCardMeasurement !== null &&
115 + detailsCardMeasurement.threadRef.environmentId === threadRef.environmentId &&
116 + detailsCardMeasurement.threadRef.threadId === threadRef.threadId
117 + ? detailsCardMeasurement
118 + : null;
119 + const detailsCard =
120 + detailsCardInlineOpen &&
121 + preferredDetailsCard &&
122 + detailsCardMeasured?.width === preferredDetailsCard.width &&
123 + detailsCardMeasured.fullContentHeight > 0
124 + ? {
125 + left: preferredDetailsCard.x,
126 + right: preferredDetailsCard.x + preferredDetailsCard.width,
127 + bottom:
128 + preferredDetailsCard.y +
129 + Math.min(detailsCardMeasured.fullContentHeight, preferredDetailsCard.height),
130 + }
131 + : null;
132 + const layout = resolveChatCanvasLayout({
133 + container,
134 + preview,
135 + padding: measurements.padding,
136 + maxChatWidth: measurements.maxChatWidth,
137 + minChatWidth: measurements.minChatWidth,
138 + composerHeight: measurements.composerHeight,
139 + detailsCard,
140 + findBar,
141 + centerBesideDetails,
142 + });
143 + const detailsCardPlacement = resolveThreadDetailsCardLayout({
144 + container,
145 + lane,
146 + frame: layout.frame,
147 + overlapsDetailsCard: layout.overlapsDetailsCard,
148 + topInset: detailsCardTopInset,
149 + });
150 + const detailsCardMode: ThreadPanelPresentation = detailsCardPlacement ? "inline" : "popover";
151 + return {
152 + container,
153 + lane,
154 + layout,
155 + detailsCardTopInset,
156 + preferredDetailsCard,
157 + detailsCardPlacement,
158 + detailsCardMode,
159 + };
160 +}
apps/web/src/components/preview/ThreadPreviewMiniPlayer.tsx
+119 -47
@@ -1,19 +1,20 @@
1 import { FILL_PREVIEW_VIEWPORT, type ScopedThreadRef } from "@t3tools/contracts";
2 import { previewPdfAssetUrl } from "@t3tools/shared/preview";
3 -import { useAtomValue } from "@effect/atom-react";
3 import { useEnvironmentHttpBaseUrl } from "~/state/environments";
4 import { PanelRightIcon, PictureInPicture2, XIcon } from "lucide-react";
5 import {
6 type PointerEvent as ReactPointerEvent,
7 type ReactNode,
8 useEffect,
10 - useId,
11 - useLayoutEffect,
9 useRef,
10 useState,
11 } from "react";
12 +import { create } from "zustand";
13 +import { useAtomValue } from "@effect/atom-react";
14 +import { scopedThreadKey } from "@t3tools/client-runtime/environment";
15
16 import { useChatCanvas } from "../chat/ChatCanvasContext";
17 +import type { ChatCanvasPreview } from "../chat/chatCanvasLayout";
18 import { BrowserSurfaceSlot } from "~/browser/BrowserSurfaceSlot";
19 import {
20 findActiveBrowserRecordingRuntimeTabId,
@@ -22,7 +23,8 @@ import {
23 import { useBrowserSurfaceStore } from "~/browser/browserSurfaceStore";
24 import type { BrowserViewportResizeDirection } from "~/browser/browserViewportLayout";
25 import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId";
25 -import { useRendersServerTabNatively } from "~/browser/previewRuntime";
26 +import { rendersServerTabNatively } from "~/browser/previewRuntime";
27 +import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
28 import { type ServerBrowserHandle, ServerBrowserSurface } from "~/browser/ServerBrowserSurface";
29 import {
30 closeServerPictureInPicture,
@@ -41,6 +43,7 @@ import {
43 type PreviewMiniPlayerSize,
44 type PreviewMiniPlayerSource,
45 type PreviewMiniPlayerState,
46 + browserMiniPlayerSource,
47 previewMiniPlayerSourceKey,
48 usePreviewMiniPlayerStore,
49 } from "~/previewMiniPlayerStore";
@@ -48,7 +51,9 @@ import { useRightPanelStore } from "~/rightPanelStore";
51 import { useDeviceState } from "~/state/device";
52
53 import { DeviceStreamView } from "../device/DeviceStreamView";
51 -import { deviceStreamScreenAtom } from "../device/deviceStreamSession";
54 +import type { DeviceScreenSize } from "@t3tools/client-runtime/device/stream";
55 +import { Atom } from "effect/reactivity";
56 +import { deviceScreenKey, deviceStreamScreenAtom } from "../device/deviceStreamSession";
57 import type { PreviewStreamViewport } from "@t3tools/client-runtime/preview/server-browser-stream";
58 import { previewBridge } from "./previewBridge";
59 import { showPreviewPopup } from "./showPreviewPopup";
@@ -97,6 +102,96 @@ const RESIZE_HANDLES: ReadonlyArray<{
102 { direction: "southeast", className: "-bottom-2 -right-2 size-4 cursor-nwse-resize" },
103 ];
104
105 +// What the stream reports about its source. It lives outside the player so the
106 +// chat canvas lays out the frame from the same source size the player uses. One
107 +// slot is enough, since only the shown thread renders a player, and it keeps the
108 +// store from collecting an entry for every tab a session ever streamed.
109 +const useStreamedSourceSize = create<{
110 + readonly key: string;
111 + readonly viewport: PreviewStreamViewport;
112 +} | null>(() => null);
113 +
114 +const NO_DEVICE_SCREEN_ATOM = Atom.make<DeviceScreenSize | null>(null).pipe(
115 + Atom.withLabel("device-stream-screen:none"),
116 +);
117 +
118 +const streamedSourceKey = (threadRef: ScopedThreadRef, sourceKey: string) =>
119 + `${scopedThreadKey(threadRef)}\u0000${sourceKey}`;
120 +
121 +// The mini player's device stream view, named so the canvas can read the
122 +// screen size that view reports.
123 +const miniPlayerDeviceViewId = (
124 + threadRef: ScopedThreadRef,
125 + source: Extract<PreviewMiniPlayerSource, { kind: "device" }>,
126 +) =>
127 + `preview-mini-player\u0000${scopedThreadKey(threadRef)}\u0000${deviceScreenKey(threadRef.environmentId, source.hostId, source.deviceId)}`;
128 +
129 +function useBrowserMiniPlayerSource(threadRef: ScopedThreadRef | null, tabId: string | null) {
130 + const previewState = useThreadPreviewState(threadRef);
131 + const snapshot = tabId === null ? null : (previewState.sessions[tabId] ?? null);
132 + const runtimeTabId =
133 + threadRef && tabId !== null
134 + ? previewRuntimeTabId(threadRef, previewState.serverEpoch, tabId)
135 + : null;
136 + const desktopOverlay = tabId === null ? null : (previewState.desktopByTabId[tabId] ?? null);
137 + const layoutZoomFactor = useBrowserLayoutZoomFactor(desktopOverlay?.zoomFactor ?? 1);
138 + const fittedSourceContent = useBrowserSurfaceStore((state) =>
139 + runtimeTabId === null ? null : (state.byTabId[runtimeTabId]?.fittedSourceContent ?? null),
140 + );
141 + const primaryEnvironmentId = useAtomValue(primaryEnvironmentIdAtom);
142 + const serverTab =
143 + threadRef !== null &&
144 + snapshot?.runtime === "server" &&
145 + !rendersServerTabNatively(threadRef.environmentId, primaryEnvironmentId, snapshot);
146 + const streamViewport = useStreamedSourceSize((state) =>
147 + threadRef &&
148 + tabId !== null &&
149 + state?.key ===
150 + streamedSourceKey(threadRef, previewMiniPlayerSourceKey(browserMiniPlayerSource(tabId)))
151 + ? state.viewport
152 + : null,
153 + );
154 + const sourceSize: PreviewMiniPlayerSize =
155 + serverTab && streamViewport
156 + ? streamViewport
157 + : resolvePreviewMiniPlayerSourceSize(
158 + snapshot?.viewport ?? FILL_PREVIEW_VIEWPORT,
159 + fittedSourceContent,
160 + layoutZoomFactor,
161 + );
162 + return { serverEpoch: previewState.serverEpoch, snapshot, desktopOverlay, serverTab, sourceSize };
163 +}
164 +
165 +/** The mini player as the chat canvas lays it out; null when no player renders. */
166 +export function useThreadPreviewCanvasSource(
167 + threadRef: ScopedThreadRef | null,
168 + miniPlayer: PreviewMiniPlayerState | null,
169 +): ChatCanvasPreview | null {
170 + const source = miniPlayer?.source ?? null;
171 + const browser = useBrowserMiniPlayerSource(
172 + threadRef,
173 + source?.kind === "browser" ? source.tabId : null,
174 + );
175 + const sourceKey = source ? previewMiniPlayerSourceKey(source) : null;
176 + const screen = useAtomValue(
177 + threadRef && source?.kind === "device"
178 + ? deviceStreamScreenAtom(miniPlayerDeviceViewId(threadRef, source))
179 + : NO_DEVICE_SCREEN_ATOM,
180 + );
181 + if (!miniPlayer || !source || sourceKey === null) return null;
182 + if (source.kind === "browser" && !browser.snapshot) return null;
183 + return {
184 + key: sourceKey,
185 + width: miniPlayer.width,
186 + position: miniPlayer.position,
187 + lastInteraction: miniPlayer.lastInteraction,
188 + source:
189 + source.kind === "browser"
190 + ? browser.sourceSize
191 + : resolveDeviceMiniPlayerSourceSize(source.platform, screen),
192 + };
193 +}
194 +
195 export function ThreadPreviewMiniPlayer({ threadRef, miniPlayer }: Props) {
196 const { source } = miniPlayer;
197 return source.kind === "browser" ? (
@@ -118,32 +213,20 @@ export function ThreadPreviewMiniPlayer({ threadRef, miniPlayer }: Props) {
213
214 function BrowserMiniPlayer({ threadRef, tabId, miniPlayer }: Props & { readonly tabId: string }) {
215 const httpBaseUrl = useEnvironmentHttpBaseUrl(threadRef.environmentId);
121 - const previewState = useThreadPreviewState(threadRef);
122 - const snapshot = previewState.sessions[tabId] ?? null;
123 - const runtimeTabId = previewRuntimeTabId(threadRef, previewState.serverEpoch, tabId);
216 + const { serverEpoch, snapshot, desktopOverlay, serverTab, sourceSize } =
217 + useBrowserMiniPlayerSource(threadRef, tabId);
218 + const runtimeTabId = previewRuntimeTabId(threadRef, serverEpoch, tabId);
219 const recordingTabIds = useActiveBrowserRecordingTabIds();
220 const recording =
221 recordingTabIds.has(runtimeTabId) ||
222 findActiveBrowserRecordingRuntimeTabId(threadRef, tabId) !== null;
128 - const desktopOverlay = previewState.desktopByTabId[tabId] ?? null;
129 - const layoutZoomFactor = useBrowserLayoutZoomFactor(desktopOverlay?.zoomFactor ?? 1);
130 - const fittedSourceContent = useBrowserSurfaceStore(
131 - (state) => state.byTabId[runtimeTabId]?.fittedSourceContent ?? null,
132 - );
133 - const nativeServerTab = useRendersServerTabNatively(threadRef.environmentId, snapshot);
134 - const serverTab = snapshot?.runtime === "server" && !nativeServerTab;
135 - const [streamViewport, setStreamViewport] = useState<PreviewStreamViewport | null>(null);
223 const serverSurfaceRef = useRef<ServerBrowserHandle | null>(null);
224 const serverPictureInPicture =
225 useServerPictureInPictureKey() === serverPictureInPictureKey(threadRef.threadId, tabId);
139 - const sourceSize =
140 - serverTab && streamViewport
141 - ? streamViewport
142 - : resolvePreviewMiniPlayerSourceSize(
143 - snapshot?.viewport ?? FILL_PREVIEW_VIEWPORT,
144 - fittedSourceContent,
145 - layoutZoomFactor,
146 - );
226 + const viewportKey = streamedSourceKey(
227 + threadRef,
228 + previewMiniPlayerSourceKey(browserMiniPlayerSource(tabId)),
229 + );
230
231 const openInPanel = () => {
232 usePreviewMiniPlayerStore.getState().close(threadRef);
@@ -234,7 +317,17 @@ function BrowserMiniPlayer({ threadRef, tabId, miniPlayer }: Props & { readonly
317 visible
318 followSize={false}
319 controlPosition="bottom"
237 - onViewport={setStreamViewport}
320 + onViewport={(viewport) =>
321 + useStreamedSourceSize.setState(
322 + (state) =>
323 + state?.key === viewportKey &&
324 + state.viewport.width === viewport.width &&
325 + state.viewport.height === viewport.height
326 + ? state
327 + : { key: viewportKey, viewport },
328 + true,
329 + )
330 + }
331 onPopup={(popupTabId) => showPreviewPopup(threadRef, popupTabId, "floating")}
332 className="size-full"
333 />
@@ -268,7 +361,7 @@ function DeviceMiniPlayer({
361 miniPlayer,
362 }: Props & { readonly source: Extract<PreviewMiniPlayerSource, { kind: "device" }> }) {
363 const { state: deviceState } = useDeviceState(threadRef.environmentId);
271 - const viewId = useId();
364 + const viewId = miniPlayerDeviceViewId(threadRef, source);
365 const screen = useAtomValue(deviceStreamScreenAtom(viewId));
366 const sourceSize = resolveDeviceMiniPlayerSourceSize(source.platform, screen);
367 const device = deviceState.devices.find(
@@ -360,27 +453,6 @@ function MiniPlayerShell({
453 const obstacles = NO_PREVIEW_MINI_PLAYER_OBSTACLES;
454 const sourceKey = previewMiniPlayerSourceKey(miniPlayer.source);
455 const frame = canvas?.previewKey === sourceKey ? canvas.layout.frame : null;
363 - const { width: sourceWidth, height: sourceHeight } = sourceSize;
364 - const reportPreview = canvas?.reportPreview;
365 - const clearPreview = canvas?.clearPreview;
366 - useLayoutEffect(() => {
367 - reportPreview?.({
368 - key: sourceKey,
369 - width: miniPlayer.width,
370 - position: miniPlayer.position,
371 - lastInteraction: miniPlayer.lastInteraction,
372 - source: { width: sourceWidth, height: sourceHeight },
373 - });
374 - }, [
375 - reportPreview,
376 - sourceKey,
377 - miniPlayer.width,
378 - miniPlayer.position,
379 - miniPlayer.lastInteraction,
380 - sourceWidth,
381 - sourceHeight,
382 - ]);
383 - useLayoutEffect(() => () => clearPreview?.(sourceKey), [clearPreview, sourceKey]);
456
457 const radius = frame ? cornerRadius(frame) : PREVIEW_MINI_PLAYER_CORNER_RADIUS;
458 const pillInset = Math.max(8, Math.round(radius * 0.55));