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));