From 2f1a2ea693062085ef39a111f109733a62ef22f0 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 14:53:51 +0000 Subject: [PATCH 1/7] fix(web): horizontal mouse wheel no longer switches threads The history swipe treated any mostly horizontal pixel-mode wheel stream as a trackpad swipe, so one horizontal wheel notch (such as the MX Master thumb wheel) navigated to the previous or next thread. Electron gives no device signal, so ignore a gesture whose first event carries Chromium's notched legacy wheelDelta (a multiple of 120 that is not the macOS trackpad's -3x pixel delta). Fixes pingdotgg/t3code#33888 AI-assisted; verified with the tests and tools listed above. --- .../HistorySwipeNavigation.browser.test.tsx | 14 ++++++++++++++ .../src/components/HistorySwipeNavigation.tsx | 19 ++++++++++++++++++- 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index b2e6fcaaaf402..ba93b80aad0fa 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -58,4 +58,18 @@ describe("HistorySwipeNavigation", () => { expect(navigateHistory).toHaveBeenCalledTimes(navigates ? 1 : 0); }); + + it.each([ + ["a macOS trackpad swipe navigates", -120, 360, true], + ["a macOS horizontal mouse wheel notch keeps the thread", -200, 240, false], + ["a Linux horizontal mouse wheel notch keeps the thread", -120, 120, false], + ])("%s", async (_name, deltaX, wheelDeltaX, navigates) => { + navigateHistory.mockReset(); + await using screen = await render(); + const target = screen.container.appendChild(document.createElement("div")); + for (const init of [{ deltaX, wheelDeltaX }, { deltaX: 0 }]) { + target.dispatchEvent(new WheelEvent("wheel", { ...init, bubbles: true })); + } + expect(navigateHistory).toHaveBeenCalledTimes(navigates ? 1 : 0); + }); }); diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx index 767b4285c696f..dc477284536fe 100644 --- a/apps/web/src/components/HistorySwipeNavigation.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.tsx @@ -8,6 +8,7 @@ const SWIPE_TRIGGER_DISTANCE = 120; // Movement needed before the gesture picks an axis; first events are often diagonal. const SWIPE_AXIS_LOCK_DISTANCE = 8; const MOMENTUM_SAMPLE_SIZE = 5; +const WHEEL_NOTCH_DELTA = 120; type SwipeBounds = { left: number; top: number; width: number; height: number }; type SwipeGesture = @@ -37,6 +38,20 @@ function readMainContentBounds(): SwipeBounds { return { left, top, width, height }; } +// Electron cannot tell a wheel from a trackpad, but Chromium's legacy wheelDelta counts wheel +// notches in multiples of 120, while macOS trackpads report it as -3x the pixel delta. +function isMouseWheelNotch(event: WheelEvent): boolean { + const { wheelDeltaX = 0, wheelDeltaY = 0 } = event as WheelEvent & { + wheelDeltaX?: number; + wheelDeltaY?: number; + }; + if (wheelDeltaX === 0 && wheelDeltaY === 0) return false; + if (wheelDeltaX % WHEEL_NOTCH_DELTA !== 0 || wheelDeltaY % WHEEL_NOTCH_DELTA !== 0) return false; + return ( + Math.abs(wheelDeltaX + 3 * event.deltaX) >= 1 || Math.abs(wheelDeltaY + 3 * event.deltaY) >= 1 + ); +} + // `event.target` stops at a shadow host; the composed path also reaches scrollers inside it. function canScrollHorizontally(path: readonly EventTarget[], deltaX: number): boolean { for (const element of path) { @@ -116,7 +131,9 @@ export function HistorySwipeNavigation() { const onWheel = (event: WheelEvent) => { if (gesture === null) { gesture = - event.ctrlKey || event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL + event.ctrlKey || + event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL || + isMouseWheelNotch(event) ? { kind: "ignored" } : { kind: "pending", path: event.composedPath(), y: event.clientY, sumX: 0, sumY: 0 }; } From 15e7c39c9fd2ef4c8616393099072fa98fa8557b Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 15:06:16 +0000 Subject: [PATCH 2/7] fix(web): mouse wheel notches at any zoom or speed keep the thread Treat any wheelDelta that is a whole number of 120-unit notches, after undoing page zoom and its integer rounding, as a mouse wheel. Drop the -3x pixel exception, which also matched slow macOS notches (-40/120). AI-assisted; verified with the tests and tools listed above. --- .../HistorySwipeNavigation.browser.test.tsx | 41 +++++++++++++++---- .../src/components/HistorySwipeNavigation.tsx | 12 +++--- 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index ba93b80aad0fa..44435483fd821 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -1,6 +1,6 @@ import { describe, expect, it, vi } from "vite-plus/test"; -import { render } from "../../test/render"; +import { render, stubGlobal } from "../../test/render"; import { HistorySwipeNavigation } from "./HistorySwipeNavigation"; const navigateHistory = vi.hoisted(() => vi.fn()); @@ -60,15 +60,42 @@ describe("HistorySwipeNavigation", () => { }); it.each([ - ["a macOS trackpad swipe navigates", -120, 360, true], - ["a macOS horizontal mouse wheel notch keeps the thread", -200, 240, false], - ["a Linux horizontal mouse wheel notch keeps the thread", -120, 120, false], - ])("%s", async (_name, deltaX, wheelDeltaX, navigates) => { + [ + "a macOS trackpad swipe navigates", + 1, + [ + [-4, 12], + [-60, 180], + [-60, 180], + ], + true, + ], + ["an accelerated macOS mouse wheel notch keeps the thread", 1, [[-200, 240]], false], + [ + "slow macOS mouse wheel notches keep the thread", + 1, + [ + [-40, 120], + [-40, 120], + [-40, 120], + ], + false, + ], + ["a macOS mouse wheel notch at 120% zoom keeps the thread", 1.2, [[-166.67, 200]], false], + ["a macOS mouse wheel notch at 110% zoom keeps the thread", 1.1, [[-181.82, 218]], false], + ["a Linux horizontal mouse wheel notch keeps the thread", 1, [[-120, 120]], false], + ] as const)("%s", async (_name, zoomFactor, events, navigates) => { navigateHistory.mockReset(); + using _bridge = stubGlobal("desktopBridge", { + getWindowZoomFactor: () => zoomFactor, + onTrackpadScrollBegin: () => () => {}, + onTrackpadScrollEnd: () => () => {}, + }); await using screen = await render(); const target = screen.container.appendChild(document.createElement("div")); - for (const init of [{ deltaX, wheelDeltaX }, { deltaX: 0 }]) { - target.dispatchEvent(new WheelEvent("wheel", { ...init, bubbles: true })); + for (const [deltaX, wheelDeltaX] of [...events, [0, 0]]) { + const init = { deltaX, wheelDeltaX, bubbles: true }; + target.dispatchEvent(new WheelEvent("wheel", init)); } expect(navigateHistory).toHaveBeenCalledTimes(navigates ? 1 : 0); }); diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx index dc477284536fe..a8fdde430c920 100644 --- a/apps/web/src/components/HistorySwipeNavigation.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.tsx @@ -39,17 +39,19 @@ function readMainContentBounds(): SwipeBounds { } // Electron cannot tell a wheel from a trackpad, but Chromium's legacy wheelDelta counts wheel -// notches in multiples of 120, while macOS trackpads report it as -3x the pixel delta. +// notches in multiples of 120, divided by page zoom and rounded to an integer. A trackpad +// swipe's first event is a few pixels, so it rarely lands on a multiple. function isMouseWheelNotch(event: WheelEvent): boolean { const { wheelDeltaX = 0, wheelDeltaY = 0 } = event as WheelEvent & { wheelDeltaX?: number; wheelDeltaY?: number; }; if (wheelDeltaX === 0 && wheelDeltaY === 0) return false; - if (wheelDeltaX % WHEEL_NOTCH_DELTA !== 0 || wheelDeltaY % WHEEL_NOTCH_DELTA !== 0) return false; - return ( - Math.abs(wheelDeltaX + 3 * event.deltaX) >= 1 || Math.abs(wheelDeltaY + 3 * event.deltaY) >= 1 - ); + const zoom = window.desktopBridge?.getWindowZoomFactor() ?? 1; + return [wheelDeltaX, wheelDeltaY].every((wheelDelta) => { + const notches = (wheelDelta * zoom) / WHEEL_NOTCH_DELTA; + return Math.abs(notches - Math.round(notches)) * WHEEL_NOTCH_DELTA <= zoom; + }); } // `event.target` stops at a shadow host; the composed path also reaches scrollers inside it. From 7321dcd655b8a29e45618feefc2f28c3301b83ac Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 15:28:14 +0000 Subject: [PATCH 3/7] fix(web): a trackpad swipe opening below one wheel notch still navigates The wheel-notch check accepted zero notches, so a trackpad swipe whose first event was a pixel at high zoom latched as ignored. Require a nonzero notch. AI-assisted; verified with the tests and tools listed above. --- .../components/HistorySwipeNavigation.browser.test.tsx | 6 ++++++ apps/web/src/components/HistorySwipeNavigation.tsx | 10 +++++----- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index 44435483fd821..37e101735f5ce 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -70,6 +70,12 @@ describe("HistorySwipeNavigation", () => { ], true, ], + [ + "a macOS trackpad swipe opening with one native pixel at 299% zoom navigates", + 1.2 ** 6, + [[-1 / 1.2 ** 6, 1], ...Array.from({ length: 6 }, () => [-60 / 1.2 ** 6, 60] as const)], + true, + ], ["an accelerated macOS mouse wheel notch keeps the thread", 1, [[-200, 240]], false], [ "slow macOS mouse wheel notches keep the thread", diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx index a8fdde430c920..81feb8302b4a0 100644 --- a/apps/web/src/components/HistorySwipeNavigation.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.tsx @@ -46,12 +46,12 @@ function isMouseWheelNotch(event: WheelEvent): boolean { wheelDeltaX?: number; wheelDeltaY?: number; }; - if (wheelDeltaX === 0 && wheelDeltaY === 0) return false; const zoom = window.desktopBridge?.getWindowZoomFactor() ?? 1; - return [wheelDeltaX, wheelDeltaY].every((wheelDelta) => { - const notches = (wheelDelta * zoom) / WHEEL_NOTCH_DELTA; - return Math.abs(notches - Math.round(notches)) * WHEEL_NOTCH_DELTA <= zoom; - }); + const notches = [wheelDeltaX, wheelDeltaY].map((delta) => (delta * zoom) / WHEEL_NOTCH_DELTA); + return ( + notches.some((count) => Math.round(count) !== 0) && + notches.every((count) => Math.abs(count - Math.round(count)) * WHEEL_NOTCH_DELTA <= zoom) + ); } // `event.target` stops at a shadow host; the composed path also reaches scrollers inside it. From ee7c872f50829039e49a423973b0bb29026fb567 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 15:37:19 +0000 Subject: [PATCH 4/7] fix(web): a trackpad swipe opening on a wheel-notch multiple still navigates Classify the whole stream instead of its first event: the swipe is ignored only when every moving event is a wheel notch. AI-assisted; verified with the tests and tools listed above. --- .../HistorySwipeNavigation.browser.test.tsx | 10 +++++ .../src/components/HistorySwipeNavigation.tsx | 41 ++++++++++++++----- 2 files changed, 41 insertions(+), 10 deletions(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index 37e101735f5ce..def994ff7f64d 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -76,6 +76,16 @@ describe("HistorySwipeNavigation", () => { [[-1 / 1.2 ** 6, 1], ...Array.from({ length: 6 }, () => [-60 / 1.2 ** 6, 60] as const)], true, ], + [ + "a macOS trackpad swipe opening on a wheel-notch multiple navigates", + 1, + [ + [-40, 120], + [-60, 180], + [-60, 180], + ], + true, + ], ["an accelerated macOS mouse wheel notch keeps the thread", 1, [[-200, 240]], false], [ "slow macOS mouse wheel notches keep the thread", diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx index 81feb8302b4a0..0ad3c78ea8b04 100644 --- a/apps/web/src/components/HistorySwipeNavigation.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.tsx @@ -12,9 +12,17 @@ const WHEEL_NOTCH_DELTA = 120; type SwipeBounds = { left: number; top: number; width: number; height: number }; type SwipeGesture = - | { kind: "pending"; path: EventTarget[]; y: number; sumX: number; sumY: number } + | { + kind: "pending"; + path: EventTarget[]; + y: number; + sumX: number; + sumY: number; + notchesOnly: boolean; + } | { kind: "tracking"; + notchesOnly: boolean; direction: HistoryDirection; distance: number; deltas: number[]; @@ -39,8 +47,8 @@ function readMainContentBounds(): SwipeBounds { } // Electron cannot tell a wheel from a trackpad, but Chromium's legacy wheelDelta counts wheel -// notches in multiples of 120, divided by page zoom and rounded to an integer. A trackpad -// swipe's first event is a few pixels, so it rarely lands on a multiple. +// notches in multiples of 120, divided by page zoom and rounded to an integer. A trackpad's +// pixel deltas can land on a multiple too, but a whole swipe rarely stays on them. function isMouseWheelNotch(event: WheelEvent): boolean { const { wheelDeltaX = 0, wheelDeltaY = 0 } = event as WheelEvent & { wheelDeltaX?: number; @@ -72,7 +80,7 @@ function canScrollHorizontally(path: readonly EventTarget[], deltaX: number): bo function lockSwipeAxis( pending: Extract, ): Exclude { - const { path, sumX, sumY } = pending; + const { path, sumX, sumY, notchesOnly } = pending; if (Math.abs(sumX) <= Math.abs(sumY)) return { kind: "ignored" }; if (path.some((node) => node instanceof Element && node.matches('[role="dialog"]'))) { return { kind: "ignored" }; @@ -82,6 +90,7 @@ function lockSwipeAxis( if (!canNavigateHistory(direction)) return { kind: "ignored" }; return { kind: "tracking", + notchesOnly, direction, distance: Math.abs(sumX), deltas: [], @@ -116,7 +125,11 @@ export function HistorySwipeNavigation() { setSwipe((current) => (current === null ? null : { ...current, tracking: false })); // The fingers lifted: navigate if the swipe went far enough, then ignore its momentum. const release = () => { - if (gesture?.kind === "tracking" && gesture.distance >= SWIPE_TRIGGER_DISTANCE) { + if ( + gesture?.kind === "tracking" && + !gesture.notchesOnly && + gesture.distance >= SWIPE_TRIGGER_DISTANCE + ) { navigateHistory(gesture.direction); } gesture = { kind: "ignored" }; @@ -133,13 +146,20 @@ export function HistorySwipeNavigation() { const onWheel = (event: WheelEvent) => { if (gesture === null) { gesture = - event.ctrlKey || - event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL || - isMouseWheelNotch(event) + event.ctrlKey || event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL ? { kind: "ignored" } - : { kind: "pending", path: event.composedPath(), y: event.clientY, sumX: 0, sumY: 0 }; + : { + kind: "pending", + path: event.composedPath(), + y: event.clientY, + sumX: 0, + sumY: 0, + notchesOnly: true, + }; } if (gesture.kind === "ignored") return; + const moved = event.deltaX !== 0 || event.deltaY !== 0; + if (moved && !isMouseWheelNotch(event)) gesture.notchesOnly = false; if (gesture.kind === "pending") { gesture.sumX += event.deltaX; gesture.sumY += event.deltaY; @@ -148,11 +168,12 @@ export function HistorySwipeNavigation() { if (gesture.kind === "ignored") return; } else { const delta = gesture.direction === "back" ? -event.deltaX : event.deltaX; - if (event.deltaX === 0 && event.deltaY === 0) return release(); + if (!moved) return release(); gesture.deltas = [...gesture.deltas.slice(1 - MOMENTUM_SAMPLE_SIZE), delta]; if (isMomentumTail(gesture.deltas)) return release(); gesture.distance = Math.max(0, gesture.distance + delta); } + if (gesture.notchesOnly) return; setSwipe({ direction: gesture.direction, progress: Math.min(1, gesture.distance / SWIPE_TRIGGER_DISTANCE), From 59391014313b83838ce9e0a1424f54125dbf39a9 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 17:21:12 +0000 Subject: [PATCH 5/7] fix(web): mouse wheel notches at 120% zoom keep the thread Chromium truncates wheelDelta after dividing by page zoom, so one notch at 120% arrives as 99 rather than 100. The notch check allowed exactly one zoom unit of error and float rounding pushed 99 * 1.2 just past it, so two notches read as a trackpad swipe and navigated. Compare in wheelDelta units with room for the truncation. AI-assisted; verified with the tests and tools listed above. --- .../HistorySwipeNavigation.browser.test.tsx | 10 +++++++++- apps/web/src/components/HistorySwipeNavigation.tsx | 14 ++++++++------ 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index def994ff7f64d..1afb729e75d2f 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -97,7 +97,15 @@ describe("HistorySwipeNavigation", () => { ], false, ], - ["a macOS mouse wheel notch at 120% zoom keeps the thread", 1.2, [[-166.67, 200]], false], + [ + "two mouse wheel notches at 120% zoom keep the thread", + 1.2, + [ + [-100, 99], + [-100, 99], + ], + false, + ], ["a macOS mouse wheel notch at 110% zoom keeps the thread", 1.1, [[-181.82, 218]], false], ["a Linux horizontal mouse wheel notch keeps the thread", 1, [[-120, 120]], false], ] as const)("%s", async (_name, zoomFactor, events, navigates) => { diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx index 0ad3c78ea8b04..10f2171e07519 100644 --- a/apps/web/src/components/HistorySwipeNavigation.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.tsx @@ -47,18 +47,20 @@ function readMainContentBounds(): SwipeBounds { } // Electron cannot tell a wheel from a trackpad, but Chromium's legacy wheelDelta counts wheel -// notches in multiples of 120, divided by page zoom and rounded to an integer. A trackpad's -// pixel deltas can land on a multiple too, but a whole swipe rarely stays on them. +// notches in multiples of 120, divided by page zoom and truncated (99 for one notch at 120%). +// A trackpad's pixel deltas can land on a multiple too, but a whole swipe rarely stays on them. function isMouseWheelNotch(event: WheelEvent): boolean { const { wheelDeltaX = 0, wheelDeltaY = 0 } = event as WheelEvent & { wheelDeltaX?: number; wheelDeltaY?: number; }; - const zoom = window.desktopBridge?.getWindowZoomFactor() ?? 1; - const notches = [wheelDeltaX, wheelDeltaY].map((delta) => (delta * zoom) / WHEEL_NOTCH_DELTA); + const notchDelta = WHEEL_NOTCH_DELTA / (window.desktopBridge?.getWindowZoomFactor() ?? 1); + const notches = [wheelDeltaX, wheelDeltaY].map((delta) => Math.round(delta / notchDelta)); return ( - notches.some((count) => Math.round(count) !== 0) && - notches.every((count) => Math.abs(count - Math.round(count)) * WHEEL_NOTCH_DELTA <= zoom) + notches.some((count) => count !== 0) && + [wheelDeltaX, wheelDeltaY].every( + (delta, index) => Math.abs(delta - notches[index]! * notchDelta) < 1.5, + ) ); } From 3e8b5933d1b94479904d844b01533bb891db7237 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 20:51:58 +0000 Subject: [PATCH 6/7] test(web): drop overlapping wheel-notch cases AI-assisted; verified with the tests and tools listed above. --- .../HistorySwipeNavigation.browser.test.tsx | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx index 1afb729e75d2f..ae4d927d34c41 100644 --- a/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx +++ b/apps/web/src/components/HistorySwipeNavigation.browser.test.tsx @@ -60,16 +60,6 @@ describe("HistorySwipeNavigation", () => { }); it.each([ - [ - "a macOS trackpad swipe navigates", - 1, - [ - [-4, 12], - [-60, 180], - [-60, 180], - ], - true, - ], [ "a macOS trackpad swipe opening with one native pixel at 299% zoom navigates", 1.2 ** 6, @@ -86,7 +76,6 @@ describe("HistorySwipeNavigation", () => { ], true, ], - ["an accelerated macOS mouse wheel notch keeps the thread", 1, [[-200, 240]], false], [ "slow macOS mouse wheel notches keep the thread", 1, @@ -106,7 +95,6 @@ describe("HistorySwipeNavigation", () => { ], false, ], - ["a macOS mouse wheel notch at 110% zoom keeps the thread", 1.1, [[-181.82, 218]], false], ["a Linux horizontal mouse wheel notch keeps the thread", 1, [[-120, 120]], false], ] as const)("%s", async (_name, zoomFactor, events, navigates) => { navigateHistory.mockReset(); From 4455ab2b34842052366a6a3352aa571cdf7b5406 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 13 Nov 2026 07:00:48 +0000 Subject: [PATCH 7/7] test(web): right panel tabs bridge stub reports a window zoom factor Co-Authored-By: Claude Opus 5.5 --- apps/web/src/components/RightPanelTabs.browser.test.tsx | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/apps/web/src/components/RightPanelTabs.browser.test.tsx b/apps/web/src/components/RightPanelTabs.browser.test.tsx index f803cb41520bc..2d38910b7045e 100644 --- a/apps/web/src/components/RightPanelTabs.browser.test.tsx +++ b/apps/web/src/components/RightPanelTabs.browser.test.tsx @@ -25,7 +25,11 @@ function trackpad() { }; let scrolling = false; return { - bridge: { onTrackpadScrollBegin: subscribe(begin), onTrackpadScrollEnd: subscribe(end) }, + bridge: { + getWindowZoomFactor: () => 1, + onTrackpadScrollBegin: subscribe(begin), + onTrackpadScrollEnd: subscribe(end), + }, scroll(target: Element, deltas: readonly number[]) { let scroller: Element | null = target; while (