diff --git a/__tests__/components/brain/left-sidebar/waves/BrainLeftSidebarWave.test.tsx b/__tests__/components/brain/left-sidebar/waves/BrainLeftSidebarWave.test.tsx
index 03c60b8acb..1418f29ac5 100644
--- a/__tests__/components/brain/left-sidebar/waves/BrainLeftSidebarWave.test.tsx
+++ b/__tests__/components/brain/left-sidebar/waves/BrainLeftSidebarWave.test.tsx
@@ -89,7 +89,7 @@ describe('BrainLeftSidebarWave', () => {
     render(<BrainLeftSidebarWave wave={baseWave} onHover={onHover} />);
     const link = screen.getByRole('link');
     await userEvent.click(link);
-    expect(setActiveWave).toHaveBeenCalledWith('1', { isDirectMessage: false, serialNo: null, divider: null });
+    expect(setActiveWave).toHaveBeenCalledWith('1', { isDirectMessage: false, divider: null });
   });
 
   it('shows drop indicators for non-chat waves', () => {
@@ -101,7 +101,7 @@ describe('BrainLeftSidebarWave', () => {
   it('includes firstUnreadDropSerialNo in href when present', () => {
     const waveWithUnread = { ...baseWave, id: '3', firstUnreadDropSerialNo: 42 };
     render(<BrainLeftSidebarWave wave={waveWithUnread} onHover={onHover} />);
-    expect(screen.getByRole('link')).toHaveAttribute('href', '/waves?divider=42&wave=3&serialNo=42');
+    expect(screen.getByRole('link')).toHaveAttribute('href', '/waves?divider=42&wave=3');
   });
 
   it('does not include serialNo in href when firstUnreadDropSerialNo is null', () => {
diff --git a/__tests__/components/brain/my-stream/MyStreamWaveChat.test.tsx b/__tests__/components/brain/my-stream/MyStreamWaveChat.test.tsx
index 9a9026fc74..6171bfc2d4 100644
--- a/__tests__/components/brain/my-stream/MyStreamWaveChat.test.tsx
+++ b/__tests__/components/brain/my-stream/MyStreamWaveChat.test.tsx
@@ -1,9 +1,9 @@
-import { render, screen, act } from "@testing-library/react";
+import MyStreamWaveChat from "@/components/brain/my-stream/MyStreamWaveChat";
+import { editSlice } from "@/store/editSlice";
+import { configureStore } from "@reduxjs/toolkit";
+import { act, render, screen } from "@testing-library/react";
 import React from "react";
 import { Provider } from "react-redux";
-import { configureStore } from "@reduxjs/toolkit";
-import { editSlice } from "@/store/editSlice";
-import MyStreamWaveChat from "@/components/brain/my-stream/MyStreamWaveChat";
 
 const replaceMock = jest.fn();
 const searchParamsMock = { get: jest.fn() };
@@ -23,11 +23,15 @@ jest.mock("@/components/brain/my-stream/layout/LayoutContext", () => ({
   useLayout: () => ({ waveViewStyle: { height: "1px" } }),
 }));
 
-let capturedProps: any = {};
+const capturedPropsHolder = { current: {} as any };
 jest.mock("@/components/waves/drops/wave-drops-all", () => ({
   __esModule: true,
   default: (props: any) => {
-    capturedProps = props;
+    capturedPropsHolder.current = props;
+    return <div data-testid="drops" />;
+  },
+  WaveDropsAllWithoutProvider: (props: any) => {
+    capturedPropsHolder.current = props;
     return <div data-testid="drops" />;
   },
 }));
@@ -55,21 +59,26 @@ jest.mock("@/hooks/useDeviceInfo", () => ({
   default: () => ({ isApp: false }),
 }));
 
+jest.mock("@/contexts/wave/UnreadDividerContext", () => ({
+  UnreadDividerProvider: ({ children }: any) => <>{children}</>,
+}));
+
 jest.mock("@/components/waves/gallery", () => ({
   WaveGallery: () => <div data-testid="gallery" />,
 }));
 
-const wave = { id: "10" } as any;
+const wave = { id: "10", metrics: { muted: false } } as any;
 const mockOnDropClick = jest.fn();
 
 describe("MyStreamWaveChat", () => {
   let store: any;
 
   beforeEach(() => {
-    capturedProps = {};
+    capturedPropsHolder.current = {};
     replaceMock.mockClear();
     searchParamsMock.get.mockReset();
     mockIsMemesWave = false;
+    mockOnDropClick.mockClear();
     store = configureStore({
       reducer: { edit: editSlice.reducer },
     });
@@ -93,7 +102,7 @@ describe("MyStreamWaveChat", () => {
       );
     });
     expect(replaceMock).toHaveBeenCalled();
-    expect(capturedProps.initialDrop).toBe(5);
+    expect(capturedPropsHolder.current.initialDrop).toBe(5);
     expect(screen.getByTestId("memes-btn")).toBeInTheDocument();
   });
 
@@ -110,7 +119,7 @@ describe("MyStreamWaveChat", () => {
       );
     });
     expect(replaceMock).not.toHaveBeenCalled();
-    expect(capturedProps.initialDrop).toBeNull();
+    expect(capturedPropsHolder.current.initialDrop).toBeNull();
     expect(screen.queryByTestId("memes-btn")).toBeNull();
   });
 });
diff --git a/__tests__/components/waves/drops/DropMobileMenuHandler.test.tsx b/__tests__/components/waves/drops/DropMobileMenuHandler.test.tsx
index 001ca0181e..9df8813a1d 100644
--- a/__tests__/components/waves/drops/DropMobileMenuHandler.test.tsx
+++ b/__tests__/components/waves/drops/DropMobileMenuHandler.test.tsx
@@ -4,6 +4,7 @@ import DropMobileMenuHandler from '@/components/waves/drops/DropMobileMenuHandle
 import { DropSize } from '@/helpers/waves/drop.helpers';
 
 jest.mock('@/hooks/isMobileDevice', () => () => true);
+jest.mock('@/hooks/useIsTouchDevice', () => ({ __esModule: true, default: () => true }));
 
 jest.mock('@/components/waves/drops/WaveDropMobileMenu', () => ({
   __esModule: true,
diff --git a/__tests__/components/waves/drops/WaveDrop.test.tsx b/__tests__/components/waves/drops/WaveDrop.test.tsx
index b3fa061868..4eb6c77335 100644
--- a/__tests__/components/waves/drops/WaveDrop.test.tsx
+++ b/__tests__/components/waves/drops/WaveDrop.test.tsx
@@ -16,6 +16,7 @@ jest.mock('@/components/waves/drops/WaveDropRatings', () => () => <div data-test
 jest.mock('@/components/waves/drops/WaveDropMobileMenu', () => () => <div data-testid="mobile" />);
 
 jest.mock('@/hooks/isMobileDevice');
+jest.mock('@/hooks/useIsTouchDevice', () => ({ __esModule: true, default: jest.fn(() => false) }));
 
 jest.mock('next/navigation', () => ({
   useRouter: jest.fn(() => ({ push: jest.fn() })),
diff --git a/__tests__/components/waves/drops/WaveDropsAll.test.tsx b/__tests__/components/waves/drops/WaveDropsAll.test.tsx
index eb812650e2..6b6f41361e 100644
--- a/__tests__/components/waves/drops/WaveDropsAll.test.tsx
+++ b/__tests__/components/waves/drops/WaveDropsAll.test.tsx
@@ -85,6 +85,11 @@ jest.mock('@/components/waves/drops/WaveDropsScrollBottomButton', () => ({
   }
 }));
 
+jest.mock('@/components/waves/drops/WaveDropsScrollToUnreadButton', () => ({
+  __esModule: true,
+  WaveDropsScrollToUnreadButton: () => <button data-testid="scroll-unread-btn" />
+}));
+
 jest.mock('@/components/waves/drops/WaveDropsEmptyPlaceholder', () => ({
   __esModule: true,
   default: () => <div data-testid="empty-placeholder" />
diff --git a/__tests__/hooks/useDeviceInfo.test.ts b/__tests__/hooks/useDeviceInfo.test.ts
index 7434651cfd..82d0c58350 100644
--- a/__tests__/hooks/useDeviceInfo.test.ts
+++ b/__tests__/hooks/useDeviceInfo.test.ts
@@ -1,50 +1,100 @@
-import { renderHook } from '@testing-library/react';
 import useDeviceInfo from '@/hooks/useDeviceInfo';
+import { act, renderHook } from '@testing-library/react';
 
 jest.mock('@/hooks/useCapacitor', () => ({ __esModule: true, default: jest.fn(() => ({ isCapacitor: false })) }));
 const capacitorMock = require('@/hooks/useCapacitor').default as jest.Mock;
 
-defineMatchMedia();
+let touchStartHandler: EventListener | null = null;
 
-function defineMatchMedia(pointer = false, width = false) {
-  Object.defineProperty(window, 'matchMedia', {
+function defineMatchMedia(pointerFine = true, width = false) {
+  Object.defineProperty(globalThis, 'matchMedia', {
     writable: true,
-    value: jest.fn((query) => ({
-      matches: query.includes('pointer') ? pointer : width,
-      addEventListener: jest.fn(),
-      removeEventListener: jest.fn(),
-    })),
+    value: jest.fn((query: string) => {
+      if (query === '(pointer: fine)') {
+        return { matches: pointerFine, addEventListener: jest.fn(), removeEventListener: jest.fn() };
+      }
+      if (query === '(max-width: 768px)') {
+        return { matches: width, addEventListener: jest.fn(), removeEventListener: jest.fn() };
+      }
+      return { matches: false, addEventListener: jest.fn(), removeEventListener: jest.fn() };
+    }),
   });
 }
 
 describe('useDeviceInfo', () => {
+  beforeEach(() => {
+    jest.spyOn(globalThis, 'addEventListener').mockImplementation((event, handler) => {
+      if (event === 'touchstart') {
+        touchStartHandler = handler as EventListener;
+      }
+    });
+    jest.spyOn(globalThis, 'removeEventListener');
+  });
+
+  afterEach(() => {
+    touchStartHandler = null;
+    jest.restoreAllMocks();
+    capacitorMock.mockReturnValue({ isCapacitor: false });
+  });
+
   it('detects classic mobile user agent', () => {
-    Object.defineProperty(window.navigator, 'userAgent', { value: 'iPhone', configurable: true });
-    defineMatchMedia(true, false);
+    Object.defineProperty(globalThis.navigator, 'userAgent', { value: 'iPhone', configurable: true });
+    Object.defineProperty(globalThis.navigator, 'maxTouchPoints', { value: 5, configurable: true });
+    defineMatchMedia(false, false);
     const { result } = renderHook(() => useDeviceInfo());
     expect(result.current.isMobileDevice).toBe(true);
     expect(result.current.isAppleMobile).toBe(true);
-    expect(result.current.hasTouchScreen).toBe(true);
     expect(result.current.isApp).toBe(false);
+    expect(result.current.hasTouchScreen).toBe(true);
   });
 
   it('detects capacitor mobile with desktop UA', () => {
     capacitorMock.mockReturnValue({ isCapacitor: true });
-    Object.defineProperty(window.navigator, 'userAgent', { value: 'Macintosh', configurable: true });
-    defineMatchMedia(true, true);
+    Object.defineProperty(globalThis.navigator, 'userAgent', { value: 'Macintosh', configurable: true });
+    Object.defineProperty(globalThis.navigator, 'maxTouchPoints', { value: 5, configurable: true });
+    defineMatchMedia(false, true);
     const { result } = renderHook(() => useDeviceInfo());
     expect(result.current.isMobileDevice).toBe(true);
     expect(result.current.isApp).toBe(true);
     expect(result.current.isAppleMobile).toBe(true);
+    expect(result.current.hasTouchScreen).toBe(true);
   });
 
   it('returns false for desktop without touch', () => {
     capacitorMock.mockReturnValue({ isCapacitor: false });
-    Object.defineProperty(window.navigator, 'userAgent', { value: 'Mozilla/5.0', configurable: true });
-    defineMatchMedia(false, false);
+    Object.defineProperty(globalThis.navigator, 'userAgent', { value: 'Mozilla/5.0', configurable: true });
+    Object.defineProperty(globalThis.navigator, 'maxTouchPoints', { value: 0, configurable: true });
+    defineMatchMedia(true, false);
     const { result } = renderHook(() => useDeviceInfo());
     expect(result.current.isMobileDevice).toBe(false);
     expect(result.current.hasTouchScreen).toBe(false);
     expect(result.current.isAppleMobile).toBe(false);
   });
+
+  it('hasTouchScreen becomes true on hybrid device after touch even with fine pointer', () => {
+    capacitorMock.mockReturnValue({ isCapacitor: false });
+    Object.defineProperty(globalThis.navigator, 'userAgent', { value: 'Mozilla/5.0', configurable: true });
+    Object.defineProperty(globalThis.navigator, 'maxTouchPoints', { value: 0, configurable: true });
+    defineMatchMedia(true, false);
+    const { result } = renderHook(() => useDeviceInfo());
+
+    expect(result.current.hasTouchScreen).toBe(false);
+
+    act(() => {
+      if (touchStartHandler) {
+        touchStartHandler(new Event('touchstart'));
+      }
+    });
+
+    expect(result.current.hasTouchScreen).toBe(true);
+  });
+
+  it('hasTouchScreen is true when maxTouchPoints > 0 even without touch event', () => {
+    capacitorMock.mockReturnValue({ isCapacitor: false });
+    Object.defineProperty(globalThis.navigator, 'userAgent', { value: 'Mozilla/5.0', configurable: true });
+    Object.defineProperty(globalThis.navigator, 'maxTouchPoints', { value: 5, configurable: true });
+    defineMatchMedia(true, false);
+    const { result } = renderHook(() => useDeviceInfo());
+    expect(result.current.hasTouchScreen).toBe(true);
+  });
 });
diff --git a/__tests__/hooks/useIsTouchDevice.test.ts b/__tests__/hooks/useIsTouchDevice.test.ts
index 0540ca98aa..3dffe50545 100644
--- a/__tests__/hooks/useIsTouchDevice.test.ts
+++ b/__tests__/hooks/useIsTouchDevice.test.ts
@@ -2,114 +2,94 @@ import { renderHook, act } from "@testing-library/react";
 import useIsTouchDevice from "@/hooks/useIsTouchDevice";
 
 describe("useIsTouchDevice", () => {
-  const originalWindow = globalThis.window;
-  const originalNavigator = globalThis.navigator;
+  let addEventListenerSpy: jest.SpyInstance;
+  let removeEventListenerSpy: jest.SpyInstance;
+  let touchStartHandler: EventListener | null = null;
+
+  beforeEach(() => {
+    addEventListenerSpy = jest.spyOn(globalThis, "addEventListener").mockImplementation((event, handler) => {
+      if (event === "touchstart") {
+        touchStartHandler = handler as EventListener;
+      }
+    });
+    removeEventListenerSpy = jest.spyOn(globalThis, "removeEventListener");
+  });
 
   afterEach(() => {
-    Object.defineProperty(globalThis, "window", {
-      value: originalWindow,
-      writable: true,
-    });
-    Object.defineProperty(globalThis, "navigator", {
-      value: originalNavigator,
-      writable: true,
-    });
+    addEventListenerSpy.mockRestore();
+    removeEventListenerSpy.mockRestore();
+    touchStartHandler = null;
+    jest.restoreAllMocks();
   });
 
-  it("returns false when window is undefined", () => {
-    Object.defineProperty(globalThis, "window", {
-      value: undefined,
+  it("returns false initially when fine pointer is detected", () => {
+    Object.defineProperty(globalThis, "matchMedia", {
       writable: true,
+      value: jest.fn((query: string) => ({
+        matches: query === "(pointer: fine)",
+      })),
     });
 
     const { result } = renderHook(() => useIsTouchDevice());
     expect(result.current).toBe(false);
   });
 
-  it("returns true when ontouchstart is in window", () => {
-    const mockWindow = {
-      ...originalWindow,
-      ontouchstart: null,
-      matchMedia: jest.fn(() => ({ matches: false })),
-    };
-    Object.defineProperty(globalThis, "window", {
-      value: mockWindow,
+  it("returns false initially and does not listen for touch when fine pointer exists", () => {
+    Object.defineProperty(globalThis, "matchMedia", {
       writable: true,
+      value: jest.fn((query: string) => ({
+        matches: query === "(pointer: fine)",
+      })),
     });
 
-    const { result } = renderHook(() => useIsTouchDevice());
-
-    act(() => {
-      jest.runAllTimers?.();
-    });
-
-    expect(result.current).toBe(true);
+    renderHook(() => useIsTouchDevice());
+    expect(addEventListenerSpy).not.toHaveBeenCalledWith("touchstart", expect.any(Function), expect.any(Object));
   });
 
-  it("returns true when navigator.maxTouchPoints > 0", () => {
-    const mockWindow = {
-      ...originalWindow,
-      matchMedia: jest.fn(() => ({ matches: false })),
-    };
-    Object.defineProperty(globalThis, "window", {
-      value: mockWindow,
-      writable: true,
-    });
-    Object.defineProperty(globalThis, "navigator", {
-      value: { maxTouchPoints: 5 },
+  it("returns false initially but switches to true after touchstart when no fine pointer", () => {
+    Object.defineProperty(globalThis, "matchMedia", {
       writable: true,
+      value: jest.fn(() => ({ matches: false })),
     });
 
     const { result } = renderHook(() => useIsTouchDevice());
+    expect(result.current).toBe(false);
 
     act(() => {
-      jest.runAllTimers?.();
+      if (touchStartHandler) {
+        touchStartHandler(new Event("touchstart"));
+      }
     });
 
     expect(result.current).toBe(true);
   });
 
-  it("returns true when matchMedia pointer:coarse matches", () => {
-    const mockWindow = {
-      ...originalWindow,
-      matchMedia: jest.fn((query: string) => ({
-        matches: query === "(pointer: coarse)",
-      })),
-    };
-    Object.defineProperty(globalThis, "window", {
-      value: mockWindow,
-      writable: true,
-    });
-    Object.defineProperty(globalThis, "navigator", {
-      value: { maxTouchPoints: 0 },
+  it("removes touchstart listener after first touch", () => {
+    Object.defineProperty(globalThis, "matchMedia", {
       writable: true,
+      value: jest.fn(() => ({ matches: false })),
     });
 
-    const { result } = renderHook(() => useIsTouchDevice());
+    renderHook(() => useIsTouchDevice());
 
     act(() => {
-      jest.runAllTimers?.();
+      if (touchStartHandler) {
+        touchStartHandler(new Event("touchstart"));
+      }
     });
 
-    expect(result.current).toBe(true);
+    expect(removeEventListenerSpy).toHaveBeenCalledWith("touchstart", expect.any(Function));
   });
 
-  it("returns false when no touch indicators present", () => {
-    const mockWindow = {
-      ...originalWindow,
-      matchMedia: jest.fn(() => ({ matches: false })),
-    };
-    Object.defineProperty(globalThis, "window", {
-      value: mockWindow,
-      writable: true,
-    });
-    Object.defineProperty(globalThis, "navigator", {
-      value: { maxTouchPoints: 0 },
+  it("cleans up event listener on unmount", () => {
+    Object.defineProperty(globalThis, "matchMedia", {
       writable: true,
+      value: jest.fn(() => ({ matches: false })),
     });
 
-    const { result } = renderHook(() => useIsTouchDevice());
+    const { unmount } = renderHook(() => useIsTouchDevice());
+    unmount();
 
-    expect(result.current).toBe(false);
+    expect(removeEventListenerSpy).toHaveBeenCalledWith("touchstart", expect.any(Function));
   });
 });
diff --git a/components/brain/left-sidebar/waves/BrainLeftSidebarWave.tsx b/components/brain/left-sidebar/waves/BrainLeftSidebarWave.tsx
index 24deb946a6..ead841fa78 100644
--- a/components/brain/left-sidebar/waves/BrainLeftSidebarWave.tsx
+++ b/components/brain/left-sidebar/waves/BrainLeftSidebarWave.tsx
@@ -68,7 +68,6 @@ const BrainLeftSidebarWave: React.FC<BrainLeftSidebarWaveProps> = ({
     }
     return getWaveRoute({
       waveId: wave.id,
-      serialNo: wave.firstUnreadDropSerialNo ?? undefined,
       extraParams: wave.firstUnreadDropSerialNo
         ? { divider: String(wave.firstUnreadDropSerialNo) }
         : undefined,
@@ -112,7 +111,6 @@ const BrainLeftSidebarWave: React.FC<BrainLeftSidebarWaveProps> = ({
       const nextWaveId = wave.id === activeWaveId ? null : wave.id;
       setActiveWave(nextWaveId, {
         isDirectMessage,
-        serialNo: nextWaveId ? wave.firstUnreadDropSerialNo : null,
         divider: nextWaveId ? wave.firstUnreadDropSerialNo : null,
       });
     },
diff --git a/components/brain/left-sidebar/web/WebBrainLeftSidebarWave/hooks/useWaveNavigation.ts b/components/brain/left-sidebar/web/WebBrainLeftSidebarWave/hooks/useWaveNavigation.ts
index d558683484..c610c48728 100644
--- a/components/brain/left-sidebar/web/WebBrainLeftSidebarWave/hooks/useWaveNavigation.ts
+++ b/components/brain/left-sidebar/web/WebBrainLeftSidebarWave/hooks/useWaveNavigation.ts
@@ -50,7 +50,6 @@ export const useWaveNavigation = ({
     const params = new URLSearchParams();
     params.set("wave", waveId);
     if (firstUnreadDropSerialNo) {
-      params.set("serialNo", String(firstUnreadDropSerialNo));
       params.set("divider", String(firstUnreadDropSerialNo));
     }
     return `${basePath}?${params.toString()}`;
@@ -85,7 +84,6 @@ export const useWaveNavigation = ({
       const nextWaveId = waveId === currentWaveId ? null : waveId;
       setActiveWave(nextWaveId, {
         isDirectMessage,
-        serialNo: nextWaveId ? firstUnreadDropSerialNo : null,
         divider: nextWaveId ? firstUnreadDropSerialNo : null,
       });
     },
diff --git a/components/brain/my-stream/MyStreamWaveChat.tsx b/components/brain/my-stream/MyStreamWaveChat.tsx
index 6bb4b99add..f391170fa8 100644
--- a/components/brain/my-stream/MyStreamWaveChat.tsx
+++ b/components/brain/my-stream/MyStreamWaveChat.tsx
@@ -1,16 +1,20 @@
 "use client";
 
 import { CreateDropWaveWrapper } from "@/components/waves/CreateDropWaveWrapper";
-import WaveDropsAll from "@/components/waves/drops/wave-drops-all";
+import { WaveDropsAllWithoutProvider } from "@/components/waves/drops/wave-drops-all";
+import { WaveGallery } from "@/components/waves/gallery";
 import MobileMemesArtSubmissionBtn from "@/components/waves/memes/submission/MobileMemesArtSubmissionBtn";
 import PrivilegedDropCreator, {
-  DropMode,
+    DropMode,
 } from "@/components/waves/PrivilegedDropCreator";
+import { UnreadDividerProvider } from "@/contexts/wave/UnreadDividerContext";
 import type { ApiDrop } from "@/generated/models/ApiDrop";
 import type { ApiWave } from "@/generated/models/ApiWave";
 import { getHomeFeedRoute } from "@/helpers/navigation.helpers";
+import type { ExtendedDrop } from "@/helpers/waves/drop.helpers";
 import useDeviceInfo from "@/hooks/useDeviceInfo";
 import { useWave } from "@/hooks/useWave";
+import type { WaveViewMode } from "@/hooks/useWaveViewMode";
 import { selectEditingDropId } from "@/store/editSlice";
 import type { ActiveDropState } from "@/types/dropInteractionTypes";
 import { ActiveDropAction } from "@/types/dropInteractionTypes";
@@ -18,9 +22,6 @@ import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import React, { useEffect, useMemo, useRef, useState } from "react";
 import { useSelector } from "react-redux";
 import { useLayout } from "./layout/LayoutContext";
-import { WaveGallery } from "@/components/waves/gallery";
-import type { WaveViewMode } from "@/hooks/useWaveViewMode";
-import type { ExtendedDrop } from "@/helpers/waves/drop.helpers";
 
 interface InitialDropState {
   readonly waveId: string;
@@ -48,6 +49,7 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({
   const { isMemesWave } = useWave(wave);
   const editingDropId = useSelector(selectEditingDropId);
   const { isApp } = useDeviceInfo();
+
   const [activeDropState, setActiveDropState] = useState<{
     readonly waveId: string;
     readonly activeDrop: ActiveDropState | null;
@@ -63,6 +65,12 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({
     setActiveDropState({ waveId: wave.id, activeDrop: nextActiveDrop });
   };
 
+  const capturedDividerRef = useRef<{ waveId: string; serialNo: number | null } | null>(null);
+
+  if (!capturedDividerRef.current || capturedDividerRef.current.waveId !== wave.id) {
+    capturedDividerRef.current = { waveId: wave.id, serialNo: firstUnreadSerialNo };
+  }
+
   const initialDropState = useMemo<InitialDropState | null>(() => {
     const dropParam = searchParams.get("serialNo");
     if (!dropParam) {
@@ -90,13 +98,33 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({
     };
   }, [searchParams, wave.id, firstUnreadSerialNo]);
 
+  useEffect(() => {
+    if (
+      initialDropState?.waveId === wave.id &&
+      initialDropState.dividerSerialNo !== null
+    ) {
+      capturedDividerRef.current = {
+        waveId: wave.id,
+        serialNo: initialDropState.dividerSerialNo,
+      };
+    } else if (
+      !capturedDividerRef.current ||
+      capturedDividerRef.current.waveId !== wave.id
+    ) {
+      capturedDividerRef.current = {
+        waveId: wave.id,
+        serialNo: firstUnreadSerialNo,
+      };
+    }
+  }, [initialDropState, wave.id, firstUnreadSerialNo]);
+
   const scrollTarget =
     initialDropState?.waveId === wave.id ? initialDropState.serialNo : null;
 
   const dividerTarget =
     initialDropState?.waveId === wave.id
       ? initialDropState.dividerSerialNo
-      : firstUnreadSerialNo;
+      : capturedDividerRef.current?.serialNo ?? null;
 
   useEffect(() => {
     if (!initialDropState) {
@@ -117,12 +145,10 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({
 
   const { waveViewStyle } = useLayout();
 
-  // Create container class based on wave type
   const containerClassName = useMemo(() => {
     const baseStyles =
       "tw-w-full tw-flex tw-flex-col tw-overflow-y-auto tw-overflow-x-hidden lg:tw-scrollbar-thin tw-scrollbar-thumb-iron-500 tw-scrollbar-track-iron-800 desktop-hover:hover:tw-scrollbar-thumb-iron-300 scroll-shadow";
 
-    // Always use flex-grow for consistent height handling
     const heightClass = "tw-flex-grow";
 
     return `${baseStyles} ${heightClass}`;
@@ -169,38 +195,43 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({
   }
 
   return (
-    <div
-      ref={containerRef}
-      className={`${containerClassName}`}
-      style={waveViewStyle}
+    <UnreadDividerProvider
+      initialSerialNo={dividerTarget ?? null}
+      key={`unread-divider-${wave.id}`}
     >
-      <WaveDropsAll
-        key={wave.id}
-        waveId={wave.id}
-        onReply={handleReply}
-        onQuote={handleQuote}
-        activeDrop={activeDrop}
-        initialDrop={scrollTarget}
-        dividerSerialNo={dividerTarget}
-        dropId={null}
-        isMuted={wave.metrics.muted}
-      />
-      {!(isApp && editingDropId) && (
-        <div className="tw-mt-auto">
-          <CreateDropWaveWrapper>
-            <PrivilegedDropCreator
-              activeDrop={activeDrop}
-              onCancelReplyQuote={onCancelReplyQuote}
-              onDropAddedToQueue={onCancelReplyQuote}
-              wave={wave}
-              dropId={null}
-              fixedDropMode={DropMode.BOTH}
-            />
-          </CreateDropWaveWrapper>
-        </div>
-      )}
-      {isMemesWave && <MobileMemesArtSubmissionBtn wave={wave} />}
-    </div>
+      <div
+        ref={containerRef}
+        className={`${containerClassName}`}
+        style={waveViewStyle}
+      >
+        <WaveDropsAllWithoutProvider
+          key={wave.id}
+          waveId={wave.id}
+          onReply={handleReply}
+          onQuote={handleQuote}
+          activeDrop={activeDrop}
+          initialDrop={scrollTarget}
+          dividerSerialNo={dividerTarget}
+          dropId={null}
+          isMuted={wave.metrics.muted}
+        />
+        {!(isApp && editingDropId) && (
+          <div className="tw-mt-auto">
+            <CreateDropWaveWrapper>
+              <PrivilegedDropCreator
+                activeDrop={activeDrop}
+                onCancelReplyQuote={onCancelReplyQuote}
+                onDropAddedToQueue={onCancelReplyQuote}
+                wave={wave}
+                dropId={null}
+                fixedDropMode={DropMode.BOTH}
+              />
+            </CreateDropWaveWrapper>
+          </div>
+        )}
+        {isMemesWave && <MobileMemesArtSubmissionBtn wave={wave} />}
+      </div>
+    </UnreadDividerProvider>
   );
 };
 
diff --git a/components/nextGen/collections/collectionParts/mint/NextGenMintWidget.tsx b/components/nextGen/collections/collectionParts/mint/NextGenMintWidget.tsx
index b595afcf41..688e69f122 100644
--- a/components/nextGen/collections/collectionParts/mint/NextGenMintWidget.tsx
+++ b/components/nextGen/collections/collectionParts/mint/NextGenMintWidget.tsx
@@ -331,11 +331,13 @@ export default function NextGenMintWidget(props: Readonly<Props>) {
   }, [props.mint_counts]);
 
   useEffect(() => {
-    const currentProof = findActiveProof(originalProofs);
-    setCurrentProof({
-      ...currentProof!,
-      proof: currentProof!.proof!,
-    });
+    const activeProof = findActiveProof(originalProofs);
+    if (activeProof?.proof) {
+      setCurrentProof({
+        ...activeProof,
+        proof: activeProof.proof,
+      });
+    }
   }, [props.fetchingMintCounts]);
 
   function renderAllowlistStatus() {
diff --git a/components/waves/CreateDrop.tsx b/components/waves/CreateDrop.tsx
index ea073e166e..a3a7aa113c 100644
--- a/components/waves/CreateDrop.tsx
+++ b/components/waves/CreateDrop.tsx
@@ -26,6 +26,7 @@ import { DropMode } from "./PrivilegedDropCreator";
 import type { DropPrivileges } from "@/hooks/useDropPriviledges";
 import { useMyStream } from "@/contexts/wave/MyStreamContext";
 import { ProcessIncomingDropType } from "@/contexts/wave/hooks/useWaveRealtimeUpdater";
+import { useUnreadDividerOptional } from "@/contexts/wave/UnreadDividerContext";
 
 interface CreateDropProps {
   readonly activeDrop: ActiveDropState | null;
@@ -57,6 +58,7 @@ export default function CreateDrop({
 }: CreateDropProps) {
   const { setToast } = useContext(AuthContext);
   const { waitAndInvalidateDrops } = useContext(ReactQueryWrapperContext);
+  const unreadDividerContext = useUnreadDividerOptional();
   useKeyPressEvent("Escape", () => onCancelReplyQuote());
   const [isStormMode, setIsStormMode] = useState(false);
   const [drop, setDrop] = useState<CreateDropConfig | null>(null);
@@ -225,13 +227,18 @@ export default function CreateDrop({
       // Process immediately - avoids state update timing issues
       processNextDrop();
 
+      // Clear unread divider when user sends a message
+      if (unreadDividerContext) {
+        unreadDividerContext.setUnreadDividerSerialNo(null);
+      }
+
       // Trigger UI updates
       onDropAddedToQueue();
 
       // Explicitly blur any focused input to close keyboard
       (document.activeElement as HTMLElement)?.blur();
     },
-    [onDropAddedToQueue, processNextDrop]
+    [onDropAddedToQueue, processNextDrop, unreadDividerContext]
   );
 
   const createDropContentProps = useMemo(
diff --git a/components/waves/drops/WaveDropsScrollToUnreadButton.tsx b/components/waves/drops/WaveDropsScrollToUnreadButton.tsx
new file mode 100644
index 0000000000..27cfca9980
--- /dev/null
+++ b/components/waves/drops/WaveDropsScrollToUnreadButton.tsx
@@ -0,0 +1,115 @@
+"use client";
+
+import type { FC, RefObject } from "react";
+import { useEffect, useState, useCallback } from "react";
+
+type UnreadPosition = "hidden" | "above" | "below";
+
+interface WaveDropsScrollToUnreadButtonProps {
+  readonly unreadDividerSerialNo: number | null;
+  readonly scrollContainerRef: RefObject<HTMLDivElement | null>;
+  readonly onScrollToUnread: (serialNo: number) => void;
+}
+
+export const WaveDropsScrollToUnreadButton: FC<
+  WaveDropsScrollToUnreadButtonProps
+> = ({ unreadDividerSerialNo, scrollContainerRef, onScrollToUnread }) => {
+  const [unreadPosition, setUnreadPosition] = useState<UnreadPosition>("hidden");
+
+  const checkUnreadVisibility = useCallback(() => {
+    if (unreadDividerSerialNo === null) {
+      setUnreadPosition("hidden");
+      return;
+    }
+
+    const scrollContainer = scrollContainerRef.current;
+    if (!scrollContainer) {
+      setUnreadPosition("hidden");
+      return;
+    }
+
+    const unreadElement = scrollContainer.querySelector(
+      `#drop-${unreadDividerSerialNo}`
+    );
+
+    if (!unreadElement) {
+      setUnreadPosition("above");
+      return;
+    }
+
+    const containerRect = scrollContainer.getBoundingClientRect();
+    const elementRect = unreadElement.getBoundingClientRect();
+
+    const isAboveViewport = elementRect.bottom < containerRect.top;
+    const isBelowViewport = elementRect.top > containerRect.bottom;
+
+    if (isAboveViewport) {
+      setUnreadPosition("above");
+    } else if (isBelowViewport) {
+      setUnreadPosition("below");
+    } else {
+      setUnreadPosition("hidden");
+    }
+  }, [unreadDividerSerialNo, scrollContainerRef]);
+
+  useEffect(() => {
+    checkUnreadVisibility();
+
+    const scrollContainer = scrollContainerRef.current;
+    if (!scrollContainer) return;
+
+    const handleScroll = () => {
+      checkUnreadVisibility();
+    };
+
+    scrollContainer.addEventListener("scroll", handleScroll, { passive: true });
+
+    const observer = new MutationObserver(() => {
+      checkUnreadVisibility();
+    });
+    observer.observe(scrollContainer, { childList: true, subtree: true });
+
+    return () => {
+      scrollContainer.removeEventListener("scroll", handleScroll);
+      observer.disconnect();
+    };
+  }, [checkUnreadVisibility, scrollContainerRef]);
+
+  useEffect(() => {
+    checkUnreadVisibility();
+  }, [unreadDividerSerialNo, checkUnreadVisibility]);
+
+  if (unreadPosition === "hidden" || unreadDividerSerialNo === null) {
+    return null;
+  }
+
+  const handleClick = () => {
+    onScrollToUnread(unreadDividerSerialNo);
+  };
+
+  const isPointingUp = unreadPosition === "above";
+
+  return (
+    <button
+      onClick={handleClick}
+      className="tw-flex-shrink-0 tw-absolute tw-z-[49] tw-bottom-14 lg:tw-bottom-12 tw-right-2 lg:tw-right-6 tw-rounded-full tw-border-0 tw-bg-rose-500 tw-text-white tw-min-w-[2.75rem] tw-h-10 lg:tw-h-8 tw-px-4 tw-flex tw-items-center tw-justify-center tw-gap-2 tw-opacity-75 hover:tw-opacity-100 tw-transition-all tw-duration-300"
+      aria-label="Scroll to first unread message"
+    >
+      <svg
+        className="tw-flex-shrink-0 tw-size-4"
+        fill="none"
+        stroke="currentColor"
+        viewBox="0 0 24 24"
+        xmlns="http://www.w3.org/2000/svg"
+      >
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          strokeWidth="2"
+          d={isPointingUp ? "M5 10l7-7m0 0l7 7m-7-7v18" : "M19 14l-7 7m0 0l-7-7m7 7V3"}
+        />
+      </svg>
+      <span className="tw-hidden lg:tw-inline tw-text-sm tw-font-medium">New messages</span>
+    </button>
+  );
+};
diff --git a/components/waves/drops/wave-drops-all/index.tsx b/components/waves/drops/wave-drops-all/index.tsx
index ff890b6032..13322708cd 100644
--- a/components/waves/drops/wave-drops-all/index.tsx
+++ b/components/waves/drops/wave-drops-all/index.tsx
@@ -113,8 +113,13 @@ const WaveDropsAllInner: React.FC<WaveDropsAllProps> = ({
   );
 
   const prevLatestSerialNoRef = useRef<number | null>(null);
+  const initializedWaveRef = useRef<string | null>(null);
 
   useEffect(() => {
+    if (initializedWaveRef.current === waveId) {
+      return;
+    }
+    initializedWaveRef.current = waveId;
     setVisibleLatestSerial(null);
     prevLatestSerialNoRef.current = null;
     setUnreadDividerSerialNo(dividerSerialNo ?? null);
@@ -127,18 +132,8 @@ const WaveDropsAllInner: React.FC<WaveDropsAllProps> = ({
       return;
     }
 
-    const prevSerial = prevLatestSerialNoRef.current;
     prevLatestSerialNoRef.current = latestSerialNo;
-
-    if (prevSerial !== null && latestSerialNo > prevSerial && !isAtBottom) {
-      setUnreadDividerSerialNo((current) => {
-        if (current === null) {
-          return prevSerial + 1;
-        }
-        return current;
-      });
-    }
-  }, [latestSerialNo, isAtBottom, setUnreadDividerSerialNo]);
+  }, [latestSerialNo]);
 
   useEffect(() => {
     if (latestSerialNo === null) {
@@ -319,12 +314,15 @@ const WaveDropsAllInner: React.FC<WaveDropsAllProps> = ({
         bottomPaddingClassName={bottomPaddingClassName}
         boostedDrops={boostedDrops}
         onBoostedDropClick={queueSerialTarget}
+        onScrollToUnread={queueSerialTarget}
       />
       <WaveDropsScrollingOverlay isVisible={isScrolling} />
     </div>
   );
 };
 
+export const WaveDropsAllWithoutProvider: React.FC<WaveDropsAllProps> = WaveDropsAllInner;
+
 const WaveDropsAll: React.FC<WaveDropsAllProps> = ({
   waveId,
   dropId,
diff --git a/components/waves/drops/wave-drops-all/subcomponents/WaveDropsContent.tsx b/components/waves/drops/wave-drops-all/subcomponents/WaveDropsContent.tsx
index 3b60eb0261..44afa5336b 100644
--- a/components/waves/drops/wave-drops-all/subcomponents/WaveDropsContent.tsx
+++ b/components/waves/drops/wave-drops-all/subcomponents/WaveDropsContent.tsx
@@ -49,6 +49,7 @@ interface WaveDropsContentProps {
   readonly bottomPaddingClassName?: string | undefined;
   readonly boostedDrops?: ApiDrop[] | undefined;
   readonly onBoostedDropClick?: ((serialNo: number) => void) | undefined;
+  readonly onScrollToUnread?: ((serialNo: number) => void) | undefined;
 }
 
 export const WaveDropsContent: React.FC<WaveDropsContentProps> = ({
@@ -73,6 +74,7 @@ export const WaveDropsContent: React.FC<WaveDropsContentProps> = ({
   bottomPaddingClassName,
   boostedDrops,
   onBoostedDropClick,
+  onScrollToUnread,
 }) => {
   const { unreadDividerSerialNo } = useUnreadDivider();
   const dropsCount = waveMessages?.drops.length ?? 0;
@@ -119,6 +121,7 @@ export const WaveDropsContent: React.FC<WaveDropsContentProps> = ({
         unreadDividerSerialNo={unreadDividerSerialNo}
         boostedDrops={boostedDrops}
         onBoostedDropClick={onBoostedDropClick}
+        onScrollToUnread={onScrollToUnread}
       />
       <WaveDropsTypingIndicator typingMessage={typingMessage} />
     </>
diff --git a/components/waves/drops/wave-drops-all/subcomponents/WaveDropsMessageListSection.tsx b/components/waves/drops/wave-drops-all/subcomponents/WaveDropsMessageListSection.tsx
index 42ff8c759b..ab726d2a44 100644
--- a/components/waves/drops/wave-drops-all/subcomponents/WaveDropsMessageListSection.tsx
+++ b/components/waves/drops/wave-drops-all/subcomponents/WaveDropsMessageListSection.tsx
@@ -1,6 +1,7 @@
 import DropsList from "@/components/drops/view/DropsList";
 import { WaveDropsReverseContainer } from "@/components/waves/drops/WaveDropsReverseContainer";
 import { WaveDropsScrollBottomButton } from "@/components/waves/drops/WaveDropsScrollBottomButton";
+import { WaveDropsScrollToUnreadButton } from "@/components/waves/drops/WaveDropsScrollToUnreadButton";
 import type { ApiDrop } from "@/generated/models/ApiDrop";
 import type { ExtendedDrop } from "@/helpers/waves/drop.helpers";
 import type { useVirtualizedWaveDrops } from "@/hooks/useVirtualizedWaveDrops";
@@ -45,6 +46,7 @@ interface WaveDropsMessageListSectionProps {
   readonly unreadDividerSerialNo?: number | null | undefined;
   readonly boostedDrops?: ApiDrop[] | undefined;
   readonly onBoostedDropClick?: ((serialNo: number) => void) | undefined;
+  readonly onScrollToUnread?: ((serialNo: number) => void) | undefined;
 }
 
 const MIN_DROPS_FOR_PAGINATION = 25;
@@ -73,6 +75,7 @@ export const WaveDropsMessageListSection: React.FC<
   unreadDividerSerialNo,
   boostedDrops,
   onBoostedDropClick,
+  onScrollToUnread,
 }) => {
   const hasNextPage =
     !!waveMessages?.hasNextPage &&
@@ -109,6 +112,13 @@ export const WaveDropsMessageListSection: React.FC<
         />
         <div ref={bottomAnchorRef} style={{ height: "1px" }} />
       </WaveDropsReverseContainer>
+      {onScrollToUnread && (
+        <WaveDropsScrollToUnreadButton
+          unreadDividerSerialNo={unreadDividerSerialNo ?? null}
+          scrollContainerRef={scrollContainerRef}
+          onScrollToUnread={onScrollToUnread}
+        />
+      )}
       <WaveDropsScrollBottomButton
         isAtBottom={isAtBottom}
         scrollToBottom={scrollToBottom}
diff --git a/hooks/useDeviceInfo.ts b/hooks/useDeviceInfo.ts
index a4cf6e49fd..447effdddb 100644
--- a/hooks/useDeviceInfo.ts
+++ b/hooks/useDeviceInfo.ts
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useCallback, useEffect } from "react";
+import { useState, useCallback, useEffect, useRef } from "react";
 import useCapacitor from "./useCapacitor";
 
 interface DeviceInfo {
@@ -10,70 +10,65 @@ interface DeviceInfo {
   readonly isAppleMobile: boolean;
 }
 
-/**
- * Hook that provides comprehensive device and screen information.
- * Combines functionality of useIsMobileDevice and useHasTouchScreen.
- *
- * @returns Object containing device information:
- * - isMobileDevice: Whether the device is a mobile device (based on user agent)
- * - hasTouchScreen: Whether the device has a touch screen
- * - isApp: Whether the device is an app
- */
-
 export default function useDeviceInfo(): DeviceInfo {
   const { isCapacitor } = useCapacitor();
-
-  const getInfo = useCallback((): DeviceInfo => {
-    if (typeof window === "undefined" || typeof navigator === "undefined") {
-      const info: DeviceInfo = {
-        isMobileDevice: false,
-        hasTouchScreen: false,
-        isApp: false,
-        isAppleMobile: false,
+  const touchDetectedRef = useRef(false);
+
+  const getInfo = useCallback(
+    (touchDetected: boolean): DeviceInfo => {
+      if (typeof globalThis === "undefined" || typeof navigator === "undefined") {
+        return {
+          isMobileDevice: false,
+          hasTouchScreen: false,
+          isApp: false,
+          isAppleMobile: false,
+        };
+      }
+
+      const win = globalThis as typeof globalThis & {
+        matchMedia: (query: string) => MediaQueryList;
+      };
+      const nav = navigator as Navigator & {
+        msMaxTouchPoints?: number | undefined;
+        userAgentData?: { mobile?: boolean | undefined } | undefined;
+        standalone?: boolean | undefined;
       };
-      return info;
-    }
-
-    const win = window as any;
-    const nav = navigator as Navigator & {
-      msMaxTouchPoints?: number | undefined;
-      userAgentData?: { mobile?: boolean | undefined } | undefined;
-      standalone?: boolean | undefined;
-    };
 
-    const hasTouchScreen =
-      (nav.maxTouchPoints ?? nav.msMaxTouchPoints ?? 0) > 0 ||
-      "ontouchstart" in win ||
-      win.matchMedia("(pointer: coarse)").matches;
-
-    const ua = nav.userAgent;
-    const uaDataMobile = nav.userAgentData?.mobile;
-    const classicMobile =
-      /Android|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua);
-    const iPadDesktopUA = ua.includes("Macintosh") && hasTouchScreen;
-    const appleMobile = /(iPhone|iPad|iPod)/i.test(ua) || iPadDesktopUA;
-    const widthMobile = win.matchMedia("(max-width: 768px)").matches;
-
-    const isMobileDevice =
-      uaDataMobile ??
-      (classicMobile || (isCapacitor && (iPadDesktopUA || widthMobile)));
-
-    const info: DeviceInfo = {
-      isMobileDevice,
-      hasTouchScreen,
-      isApp: isCapacitor,
-      isAppleMobile: appleMobile,
-    };
-    return info;
-  }, [isCapacitor]);
+      const maxTouchPoints = nav.maxTouchPoints ?? nav.msMaxTouchPoints ?? 0;
+      const hasTouchScreen = touchDetected || maxTouchPoints > 0;
+
+      const ua = nav.userAgent;
+      const uaDataMobile = nav.userAgentData?.mobile;
+      const classicMobile =
+        /Android|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua);
+      const iPadDesktopUA = ua.includes("Macintosh") && hasTouchScreen;
+      const appleMobile = /(iPhone|iPad|iPod)/i.test(ua) || iPadDesktopUA;
+      const widthMobile = win.matchMedia?.("(max-width: 768px)")?.matches ?? false;
+
+      const isMobileDevice =
+        uaDataMobile ??
+        (classicMobile || (isCapacitor && (iPadDesktopUA || widthMobile)));
+
+      return {
+        isMobileDevice,
+        hasTouchScreen,
+        isApp: isCapacitor,
+        isAppleMobile: appleMobile,
+      };
+    },
+    [isCapacitor]
+  );
 
-  const [info, setInfo] = useState<DeviceInfo>(() => getInfo());
+  const [info, setInfo] = useState<DeviceInfo>(() => getInfo(false));
 
   useEffect(() => {
-    const mq = window.matchMedia("(pointer: coarse)");
+    const hasEventListenerApi =
+      typeof globalThis.addEventListener === "function" &&
+      typeof globalThis.removeEventListener === "function";
+
     const update = () =>
       setInfo((prev) => {
-        const next = getInfo();
+        const next = getInfo(touchDetectedRef.current);
         if (
           prev.isMobileDevice === next.isMobileDevice &&
           prev.hasTouchScreen === next.hasTouchScreen &&
@@ -85,19 +80,24 @@ export default function useDeviceInfo(): DeviceInfo {
         return next;
       });
 
-    mq.addEventListener("change", update);
-    window.addEventListener("resize", update);
-
     const onceTouch = () => {
+      touchDetectedRef.current = true;
       update();
-      window.removeEventListener("touchstart", onceTouch);
+      if (hasEventListenerApi) {
+        globalThis.removeEventListener("touchstart", onceTouch);
+      }
     };
-    window.addEventListener("touchstart", onceTouch, { passive: true });
+
+    if (hasEventListenerApi) {
+      globalThis.addEventListener("resize", update);
+      globalThis.addEventListener("touchstart", onceTouch, { passive: true });
+    }
 
     return () => {
-      mq.removeEventListener("change", update);
-      window.removeEventListener("resize", update);
-      window.removeEventListener("touchstart", onceTouch);
+      if (hasEventListenerApi) {
+        globalThis.removeEventListener("resize", update);
+        globalThis.removeEventListener("touchstart", onceTouch);
+      }
     };
   }, [getInfo]);
 
diff --git a/hooks/useIsTouchDevice.ts b/hooks/useIsTouchDevice.ts
index 3b58700ce2..f875bc757f 100644
--- a/hooks/useIsTouchDevice.ts
+++ b/hooks/useIsTouchDevice.ts
@@ -1,25 +1,35 @@
 "use client";
 
-import { useState, useEffect } from "react";
+import { useEffect, useState } from "react";
 
 export default function useIsTouchDevice(): boolean {
   const [isTouchDevice, setIsTouchDevice] = useState(false);
 
   useEffect(() => {
-    const globalScope = globalThis as typeof globalThis & {
-      window?: Window | undefined;
-      navigator?: Navigator | undefined;
+    if (typeof globalThis === "undefined") {
+      return;
+    }
+
+    const win = globalThis as typeof globalThis & {
+      matchMedia?: (query: string) => MediaQueryList;
     };
-    const browserWindow = globalScope.window;
-    const browserNavigator = globalScope.navigator;
 
-    const isTouch =
-      !!browserWindow &&
-      ("ontouchstart" in browserWindow ||
-        (browserNavigator?.maxTouchPoints ?? 0) > 0 ||
-        browserWindow.matchMedia?.("(pointer: coarse)")?.matches);
+    const hasFinePointer = win.matchMedia?.("(pointer: fine)")?.matches;
+    if (hasFinePointer) {
+      setIsTouchDevice(false);
+      return;
+    }
+
+    const onTouchStart = () => {
+      setIsTouchDevice(true);
+      globalThis.removeEventListener("touchstart", onTouchStart);
+    };
 
-    setIsTouchDevice(isTouch);
+    globalThis.addEventListener("touchstart", onTouchStart, { passive: true });
+
+    return () => {
+      globalThis.removeEventListener("touchstart", onTouchStart);
+    };
   }, []);
 
   return isTouchDevice;