diff --git a/web/src/lib/components/photos-page/asset-grid-without-scrubber.svelte b/web/src/lib/components/photos-page/asset-grid-without-scrubber.svelte
new file mode 100644
index 0000000000..6633b0f27c
--- /dev/null
+++ b/web/src/lib/components/photos-page/asset-grid-without-scrubber.svelte
@@ -0,0 +1,375 @@
+<script lang="ts">
+  import { afterNavigate, beforeNavigate } from '$app/navigation';
+  import { page } from '$app/stores';
+  import { resizeObserver, type OnResizeCallback } from '$lib/actions/resize-observer';
+  import AssetDateGroupActions from '$lib/components/photos-page/asset-date-group-actions.svelte';
+  import AssetGridActions from '$lib/components/photos-page/asset-grid-actions.svelte';
+  import AssetViewerAndActions from '$lib/components/photos-page/asset-viewer-and-actions.svelte';
+  import Skeleton from '$lib/components/photos-page/skeleton.svelte';
+  import { AssetAction } from '$lib/constants';
+  import type { MonthGroup } from '$lib/managers/timeline-manager/month-group.svelte';
+  import { TimelineManager } from '$lib/managers/timeline-manager/timeline-manager.svelte';
+  import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+  import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
+  import { assetViewingStore } from '$lib/stores/asset-viewing.store';
+  import { mobileDevice } from '$lib/stores/mobile-device.svelte';
+  import { navigate } from '$lib/utils/navigation';
+  import { type AlbumResponseDto, type PersonResponseDto } from '@immich/sdk';
+  import { onMount, type Snippet } from 'svelte';
+  import type { UpdatePayload } from 'vite';
+  import Portal from '../shared-components/portal/portal.svelte';
+  import AssetDateGroup from './asset-date-group.svelte';
+
+  interface Props {
+    isSelectionMode?: boolean;
+    singleSelect?: boolean;
+    /** `true` if this asset grid is responds to navigation events; if `true`, then look at the
+     `AssetViewingStore.gridScrollTarget` and load and scroll to the asset specified, and
+     additionally, update the page location/url with the asset as the asset-grid is scrolled */
+    enableRouting: boolean;
+    timelineManager: TimelineManager;
+    assetInteraction: AssetInteraction;
+    removeAction?:
+      | AssetAction.UNARCHIVE
+      | AssetAction.ARCHIVE
+      | AssetAction.FAVORITE
+      | AssetAction.UNFAVORITE
+      | AssetAction.SET_VISIBILITY_TIMELINE;
+    withStacked?: boolean;
+    showArchiveIcon?: boolean;
+    isShared?: boolean;
+    album?: AlbumResponseDto | null;
+    person?: PersonResponseDto | null;
+    isShowDeleteConfirmation?: boolean;
+    onSelect?: (asset: TimelineAsset) => void;
+    onEscape?: () => void;
+    header?: Snippet<[handleScrollTop: (top: number) => void]>;
+    children?: Snippet;
+    empty?: Snippet;
+    handleTimelineScroll?: () => void;
+  }
+
+  let {
+    isSelectionMode = false,
+    singleSelect = false,
+    enableRouting,
+    timelineManager = $bindable(),
+    assetInteraction,
+    removeAction,
+    withStacked = false,
+    showArchiveIcon = false,
+    isShared = false,
+    album = null,
+    person = null,
+    isShowDeleteConfirmation = $bindable(false),
+    onSelect = () => {},
+    onEscape = () => {},
+    children,
+    empty,
+    header,
+    handleTimelineScroll = () => {},
+  }: Props = $props();
+
+  let { isViewing: showAssetViewer, gridScrollTarget } = assetViewingStore;
+
+  let element: HTMLElement | undefined = $state();
+
+  let timelineElement: HTMLElement | undefined = $state();
+  let showSkeleton = $state(true);
+
+  let scrubberWidth = $state(0);
+
+  // 60 is the bottom spacer element at 60px
+  let bottomSectionHeight = 60;
+  let leadout = $state(false);
+
+  const maxMd = $derived(mobileDevice.maxMd);
+  const usingMobileDevice = $derived(mobileDevice.pointerCoarse);
+  const isEmpty = $derived(timelineManager.isInitialized && timelineManager.months.length === 0);
+
+  $effect(() => {
+    const layoutOptions = maxMd
+      ? {
+          rowHeight: 100,
+          headerHeight: 32,
+        }
+      : {
+          rowHeight: 235,
+          headerHeight: 48,
+        };
+    timelineManager.setLayoutOptions(layoutOptions);
+  });
+
+  const scrollTo = (top: number) => {
+    if (element) {
+      element.scrollTo({ top });
+    }
+  };
+  const scrollTop = (top: number) => {
+    if (element) {
+      element.scrollTop = top;
+    }
+  };
+  const scrollBy = (y: number) => {
+    if (element) {
+      element.scrollBy(0, y);
+    }
+  };
+  const scrollToTop = () => {
+    scrollTo(0);
+  };
+
+  const getAssetHeight = (assetId: string, monthGroup: MonthGroup) => {
+    // the following method may trigger any layouts, so need to
+    // handle any scroll compensation that may have been set
+    const height = monthGroup!.findAssetAbsolutePosition(assetId);
+
+    while (timelineManager.scrollCompensation.monthGroup) {
+      handleScrollCompensation(timelineManager.scrollCompensation);
+      timelineManager.clearScrollCompensation();
+    }
+    return height;
+  };
+
+  const scrollToAssetId = async (assetId: string) => {
+    const monthGroup = await timelineManager.findMonthGroupForAsset(assetId);
+    if (!monthGroup) {
+      return false;
+    }
+    const height = getAssetHeight(assetId, monthGroup);
+    scrollTo(height);
+    updateSlidingWindow();
+    return true;
+  };
+
+  const scrollToAsset = (asset: TimelineAsset) => {
+    const monthGroup = timelineManager.getMonthGroupByAssetId(asset.id);
+    if (!monthGroup) {
+      return false;
+    }
+    const height = getAssetHeight(asset.id, monthGroup);
+    scrollTo(height);
+    updateSlidingWindow();
+    return true;
+  };
+
+  const completeNav = async () => {
+    const scrollTarget = $gridScrollTarget?.at;
+    let scrolled = false;
+    if (scrollTarget) {
+      scrolled = await scrollToAssetId(scrollTarget);
+    }
+    if (!scrolled) {
+      // if the asset is not found, scroll to the top
+      scrollToTop();
+    }
+    showSkeleton = false;
+  };
+
+  beforeNavigate(() => (timelineManager.suspendTransitions = true));
+
+  afterNavigate((nav) => {
+    const { complete } = nav;
+    complete.then(completeNav, completeNav);
+  });
+
+  const hmrSupport = () => {
+    // when hmr happens, skeleton is initialized to true by default
+    // normally, loading asset-grid is part of a navigation event, and the completion of
+    // that event triggers a scroll-to-asset, if necessary, when then clears the skeleton.
+    // this handler will run the navigation/scroll-to-asset handler when hmr is performed,
+    // preventing skeleton from showing after hmr
+    if (import.meta && import.meta.hot) {
+      const afterApdate = (payload: UpdatePayload) => {
+        const assetGridUpdate = payload.updates.some(
+          (update) => update.path.endsWith('asset-grid.svelte') || update.path.endsWith('assets-store.ts'),
+        );
+
+        if (assetGridUpdate) {
+          setTimeout(() => {
+            const asset = $page.url.searchParams.get('at');
+            if (asset) {
+              $gridScrollTarget = { at: asset };
+              void navigate(
+                { targetRoute: 'current', assetId: null, assetGridRouteSearchParams: $gridScrollTarget },
+                { replaceState: true, forceNavigate: true },
+              );
+            } else {
+              scrollToTop();
+            }
+            showSkeleton = false;
+          }, 500);
+        }
+      };
+      import.meta.hot?.on('vite:afterUpdate', afterApdate);
+      import.meta.hot?.on('vite:beforeUpdate', (payload) => {
+        const assetGridUpdate = payload.updates.some((update) => update.path.endsWith('asset-grid.svelte'));
+        if (assetGridUpdate) {
+          timelineManager.destroy();
+        }
+      });
+
+      return () => import.meta.hot?.off('vite:afterUpdate', afterApdate);
+    }
+    return () => void 0;
+  };
+
+  const updateIsScrolling = () => (timelineManager.scrolling = true);
+  // note: don't throttle, debounch, or otherwise do this function async - it causes flicker
+  const updateSlidingWindow = () => timelineManager.updateSlidingWindow(element?.scrollTop || 0);
+
+  const handleScrollCompensation = ({ heightDelta, scrollTop }: { heightDelta?: number; scrollTop?: number }) => {
+    if (heightDelta !== undefined) {
+      scrollBy(heightDelta);
+    } else if (scrollTop !== undefined) {
+      scrollTo(scrollTop);
+    }
+    // Yes, updateSlideWindow() is called by the onScroll event triggered as a result of
+    // the above calls. However, this delay is enough time to set the intersecting property
+    // of the monthGroup to false, then true, which causes the DOM nodes to be recreated,
+    // causing bad perf, and also, disrupting focus of those elements.
+    updateSlidingWindow();
+  };
+
+  const topSectionResizeObserver: OnResizeCallback = ({ height }) => (timelineManager.topSectionHeight = height);
+
+  onMount(() => {
+    if (!enableRouting) {
+      showSkeleton = false;
+    }
+    const disposeHmr = hmrSupport();
+    return () => {
+      disposeHmr();
+    };
+  });
+
+  let onDateGroupSelect = <({ title, assets }: { title: string; assets: TimelineAsset[] }) => void>$state();
+  let onSelectAssets = <(asset: TimelineAsset) => Promise<void>>$state();
+  let onSelectAssetCandidates = <(asset: TimelineAsset | null) => void>$state();
+</script>
+
+<AssetDateGroupActions
+  {timelineManager}
+  {assetInteraction}
+  handleScrollTop={scrollTop}
+  {onSelect}
+  bind:onDateGroupSelect
+  bind:onSelectAssets
+  bind:onSelectAssetCandidates
+></AssetDateGroupActions>
+
+<AssetGridActions {scrollToAsset} {timelineManager} {assetInteraction} bind:isShowDeleteConfirmation {onEscape}
+></AssetGridActions>
+
+{@render header?.(scrollTop)}
+
+<!-- Right margin MUST be equal to the width of scrubber -->
+<section
+  id="asset-grid"
+  class={['scrollbar-hidden h-full overflow-y-auto outline-none', { 'm-0': isEmpty }, { 'ms-0': !isEmpty }]}
+  style:margin-right={(usingMobileDevice ? 0 : scrubberWidth) + 'px'}
+  tabindex="-1"
+  bind:clientHeight={timelineManager.viewportHeight}
+  bind:clientWidth={null, (v) => ((timelineManager.viewportWidth = v), updateSlidingWindow())}
+  bind:this={element}
+  onscroll={() => (handleTimelineScroll(), updateSlidingWindow(), updateIsScrolling())}
+>
+  <section
+    bind:this={timelineElement}
+    id="virtual-timeline"
+    class:invisible={showSkeleton}
+    style:height={timelineManager.timelineHeight + 'px'}
+  >
+    <section
+      use:resizeObserver={topSectionResizeObserver}
+      class:invisible={showSkeleton}
+      style:position="absolute"
+      style:left="0"
+      style:right="0"
+    >
+      {@render children?.()}
+      {#if isEmpty}
+        <!-- (optional) empty placeholder -->
+        {@render empty?.()}
+      {/if}
+    </section>
+
+    {#each timelineManager.months as monthGroup (monthGroup.viewId)}
+      {@const display = monthGroup.intersecting}
+      {@const absoluteHeight = monthGroup.top}
+
+      {#if !monthGroup.isLoaded}
+        <div
+          style:height={monthGroup.height + 'px'}
+          style:position="absolute"
+          style:transform={`translate3d(0,${absoluteHeight}px,0)`}
+          style:width="100%"
+        >
+          <Skeleton
+            height={monthGroup.height - monthGroup.timelineManager.headerHeight}
+            title={monthGroup.monthGroupTitle}
+          />
+        </div>
+      {:else if display}
+        <div
+          class="month-group"
+          style:height={monthGroup.height + 'px'}
+          style:position="absolute"
+          style:transform={`translate3d(0,${absoluteHeight}px,0)`}
+          style:width="100%"
+        >
+          <AssetDateGroup
+            {withStacked}
+            {showArchiveIcon}
+            {assetInteraction}
+            {timelineManager}
+            {isSelectionMode}
+            {singleSelect}
+            {monthGroup}
+            onSelect={onDateGroupSelect}
+            {onSelectAssetCandidates}
+            {onSelectAssets}
+            onScrollCompensation={handleScrollCompensation}
+          />
+        </div>
+      {/if}
+    {/each}
+    <!-- spacer for leadout -->
+    <div
+      class="h-[60px]"
+      style:position="absolute"
+      style:left="0"
+      style:right="0"
+      style:transform={`translate3d(0,${timelineManager.timelineHeight}px,0)`}
+    ></div>
+  </section>
+</section>
+
+<Portal target="body">
+  {#if $showAssetViewer}
+    <AssetViewerAndActions
+      bind:showSkeleton
+      {timelineManager}
+      {removeAction}
+      {withStacked}
+      {isShared}
+      {album}
+      {person}
+      {isShowDeleteConfirmation}
+    ></AssetViewerAndActions>
+  {/if}
+</Portal>
+
+<style>
+  #asset-grid {
+    contain: strict;
+    scrollbar-width: none;
+  }
+
+  .month-group {
+    contain: layout size paint;
+    transform-style: flat;
+    backface-visibility: hidden;
+    transform-origin: center center;
+  }
+</style>
diff --git a/web/src/lib/components/photos-page/asset-grid.svelte b/web/src/lib/components/photos-page/asset-grid.svelte
index fcb655ee6b..caec698491 100644
--- a/web/src/lib/components/photos-page/asset-grid.svelte
+++ b/web/src/lib/components/photos-page/asset-grid.svelte
@@ -1,26 +1,14 @@
 <script lang="ts">
-  import { afterNavigate, beforeNavigate } from '$app/navigation';
-  import { page } from '$app/stores';
-  import { resizeObserver, type OnResizeCallback } from '$lib/actions/resize-observer';
-  import AssetDateGroupActions from '$lib/components/photos-page/asset-date-group-actions.svelte';
-  import AssetGridActions from '$lib/components/photos-page/asset-grid-actions.svelte';
-  import AssetViewerAndActions from '$lib/components/photos-page/asset-viewer-and-actions.svelte';
-  import Skeleton from '$lib/components/photos-page/skeleton.svelte';
-  import Scrubber from '$lib/components/shared-components/scrubber/scrubber.svelte';
+  import AssetGridWithoutScrubber from '$lib/components/photos-page/asset-grid-without-scrubber.svelte';
   import { AssetAction } from '$lib/constants';
   import type { MonthGroup } from '$lib/managers/timeline-manager/month-group.svelte';
-  import { TimelineManager } from '$lib/managers/timeline-manager/timeline-manager.svelte';
+  import type { TimelineManager } from '$lib/managers/timeline-manager/timeline-manager.svelte';
   import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
   import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
-  import { assetViewingStore } from '$lib/stores/asset-viewing.store';
-  import { mobileDevice } from '$lib/stores/mobile-device.svelte';
-  import { navigate } from '$lib/utils/navigation';
-  import { type ScrubberListener, type TimelinePlainYearMonth } from '$lib/utils/timeline-util';
-  import { type AlbumResponseDto, type PersonResponseDto } from '@immich/sdk';
-  import { onMount, type Snippet } from 'svelte';
-  import type { UpdatePayload } from 'vite';
-  import Portal from '../shared-components/portal/portal.svelte';
-  import AssetDateGroup from './asset-date-group.svelte';
+  import type { ScrubberListener, TimelinePlainYearMonth } from '$lib/utils/timeline-util';
+  import type { AlbumResponseDto, PersonResponseDto } from '@immich/sdk';
+  import type { Snippet } from 'svelte';
+  import Scrubber from '../shared-components/scrubber/scrubber.svelte';
 
   interface Props {
     isSelectionMode?: boolean;
@@ -68,254 +56,37 @@
     empty,
   }: Props = $props();
 
-  let { isViewing: showAssetViewer, gridScrollTarget } = assetViewingStore;
-
-  let element: HTMLElement | undefined = $state();
-
-  let timelineElement: HTMLElement | undefined = $state();
-  let showSkeleton = $state(true);
+  let leadout = $state(false);
   let scrubberMonthPercent = $state(0);
   let scrubberMonth: { year: number; month: number } | undefined = $state(undefined);
   let scrubOverallPercent: number = $state(0);
-  let scrubberWidth = $state(0);
-
-  // 60 is the bottom spacer element at 60px
-  let bottomSectionHeight = 60;
-  let leadout = $state(false);
-
-  const maxMd = $derived(mobileDevice.maxMd);
-  const usingMobileDevice = $derived(mobileDevice.pointerCoarse);
-  const isEmpty = $derived(timelineManager.isInitialized && timelineManager.months.length === 0);
-
-  $effect(() => {
-    const layoutOptions = maxMd
-      ? {
-          rowHeight: 100,
-          headerHeight: 32,
-        }
-      : {
-          rowHeight: 235,
-          headerHeight: 48,
-        };
-    timelineManager.setLayoutOptions(layoutOptions);
-  });
-
-  const scrollTo = (top: number) => {
-    if (element) {
-      element.scrollTo({ top });
-    }
-  };
-  const scrollTop = (top: number) => {
-    if (element) {
-      element.scrollTop = top;
-    }
-  };
-  const scrollBy = (y: number) => {
-    if (element) {
-      element.scrollBy(0, y);
-    }
-  };
-  const scrollToTop = () => {
-    scrollTo(0);
-  };
-
-  const getAssetHeight = (assetId: string, monthGroup: MonthGroup) => {
-    // the following method may trigger any layouts, so need to
-    // handle any scroll compensation that may have been set
-    const height = monthGroup!.findAssetAbsolutePosition(assetId);
-
-    while (timelineManager.scrollCompensation.monthGroup) {
-      handleScrollCompensation(timelineManager.scrollCompensation);
-      timelineManager.clearScrollCompensation();
-    }
-    return height;
-  };
-
-  const scrollToAssetId = async (assetId: string) => {
-    const monthGroup = await timelineManager.findMonthGroupForAsset(assetId);
-    if (!monthGroup) {
-      return false;
-    }
-    const height = getAssetHeight(assetId, monthGroup);
-    scrollTo(height);
-    updateSlidingWindow();
-    return true;
-  };
-
-  const scrollToAsset = (asset: TimelineAsset) => {
-    const monthGroup = timelineManager.getMonthGroupByAssetId(asset.id);
-    if (!monthGroup) {
-      return false;
-    }
-    const height = getAssetHeight(asset.id, monthGroup);
-    scrollTo(height);
-    updateSlidingWindow();
-    return true;
-  };
-
-  const completeNav = async () => {
-    const scrollTarget = $gridScrollTarget?.at;
-    let scrolled = false;
-    if (scrollTarget) {
-      scrolled = await scrollToAssetId(scrollTarget);
-    }
-    if (!scrolled) {
-      // if the asset is not found, scroll to the top
-      scrollToTop();
-    }
-    showSkeleton = false;
-  };
-
-  beforeNavigate(() => (timelineManager.suspendTransitions = true));
-
-  afterNavigate((nav) => {
-    const { complete } = nav;
-    complete.then(completeNav, completeNav);
-  });
-
-  const hmrSupport = () => {
-    // when hmr happens, skeleton is initialized to true by default
-    // normally, loading asset-grid is part of a navigation event, and the completion of
-    // that event triggers a scroll-to-asset, if necessary, when then clears the skeleton.
-    // this handler will run the navigation/scroll-to-asset handler when hmr is performed,
-    // preventing skeleton from showing after hmr
-    if (import.meta && import.meta.hot) {
-      const afterApdate = (payload: UpdatePayload) => {
-        const assetGridUpdate = payload.updates.some(
-          (update) => update.path.endsWith('asset-grid.svelte') || update.path.endsWith('assets-store.ts'),
-        );
-
-        if (assetGridUpdate) {
-          setTimeout(() => {
-            const asset = $page.url.searchParams.get('at');
-            if (asset) {
-              $gridScrollTarget = { at: asset };
-              void navigate(
-                { targetRoute: 'current', assetId: null, assetGridRouteSearchParams: $gridScrollTarget },
-                { replaceState: true, forceNavigate: true },
-              );
-            } else {
-              scrollToTop();
-            }
-            showSkeleton = false;
-          }, 500);
-        }
-      };
-      import.meta.hot?.on('vite:afterUpdate', afterApdate);
-      import.meta.hot?.on('vite:beforeUpdate', (payload) => {
-        const assetGridUpdate = payload.updates.some((update) => update.path.endsWith('asset-grid.svelte'));
-        if (assetGridUpdate) {
-          timelineManager.destroy();
-        }
-      });
-
-      return () => import.meta.hot?.off('vite:afterUpdate', afterApdate);
-    }
-    return () => void 0;
-  };
-
-  const updateIsScrolling = () => (timelineManager.scrolling = true);
-  // note: don't throttle, debounch, or otherwise do this function async - it causes flicker
-  const updateSlidingWindow = () => timelineManager.updateSlidingWindow(element?.scrollTop || 0);
-
-  const handleScrollCompensation = ({ heightDelta, scrollTop }: { heightDelta?: number; scrollTop?: number }) => {
-    if (heightDelta !== undefined) {
-      scrollBy(heightDelta);
-    } else if (scrollTop !== undefined) {
-      scrollTo(scrollTop);
-    }
-    // Yes, updateSlideWindow() is called by the onScroll event triggered as a result of
-    // the above calls. However, this delay is enough time to set the intersecting property
-    // of the monthGroup to false, then true, which causes the DOM nodes to be recreated,
-    // causing bad perf, and also, disrupting focus of those elements.
-    updateSlidingWindow();
-  };
-
-  const topSectionResizeObserver: OnResizeCallback = ({ height }) => (timelineManager.topSectionHeight = height);
-
-  onMount(() => {
-    if (!enableRouting) {
-      showSkeleton = false;
-    }
-    const disposeHmr = hmrSupport();
-    return () => {
-      disposeHmr();
-    };
-  });
-
-  const getMaxScrollPercent = () => {
-    const totalHeight = timelineManager.timelineHeight + bottomSectionHeight + timelineManager.topSectionHeight;
-    return (totalHeight - timelineManager.viewportHeight) / totalHeight;
-  };
-
-  const getMaxScroll = () => {
-    if (!element || !timelineElement) {
-      return 0;
-    }
-    return (
-      timelineManager.topSectionHeight + bottomSectionHeight + (timelineElement.clientHeight - element.clientHeight)
-    );
-  };
-
-  const scrollToMonthGroupAndOffset = (monthGroup: MonthGroup, monthGroupScrollPercent: number) => {
-    const topOffset = monthGroup.top;
-    const maxScrollPercent = getMaxScrollPercent();
-    const delta = monthGroup.height * monthGroupScrollPercent;
-    const scrollToTop = (topOffset + delta) * maxScrollPercent;
-
-    scrollTop(scrollToTop);
-  };
-
-  // note: don't throttle, debounch, or otherwise make this function async - it causes flicker
-  const onScrub: ScrubberListener = (
-    scrubMonth: { year: number; month: number },
-    overallScrollPercent: number,
-    scrubberMonthScrollPercent: number,
-  ) => {
-    if (!scrubMonth || timelineManager.timelineHeight < timelineManager.viewportHeight * 2) {
-      // edge case - scroll limited due to size of content, must adjust - use use the overall percent instead
-      const maxScroll = getMaxScroll();
-      const offset = maxScroll * overallScrollPercent;
-      scrollTop(offset);
-    } else {
-      const monthGroup = timelineManager.months.find(
-        ({ yearMonth: { year, month } }) => year === scrubMonth.year && month === scrubMonth.month,
-      );
-      if (!monthGroup) {
-        return;
-      }
-      scrollToMonthGroupAndOffset(monthGroup, scrubberMonthScrollPercent);
-    }
-  };
+  let scrubberWidth: number = $state(0);
 
   // note: don't throttle, debounch, or otherwise make this function async - it causes flicker
+  // this function updates the scrubber position based on the current scroll position in the timeline
   const handleTimelineScroll = () => {
     leadout = false;
 
-    if (!element) {
-      return;
-    }
-
     if (timelineManager.timelineHeight < timelineManager.viewportHeight * 2) {
       // edge case - scroll limited due to size of content, must adjust -  use the overall percent instead
-      const maxScroll = getMaxScroll();
-      scrubOverallPercent = Math.min(1, element.scrollTop / maxScroll);
+      const maxScroll = timelineManager.getMaxScroll();
+      scrubOverallPercent = Math.min(1, timelineManager.visibleWindow.top / maxScroll);
 
       scrubberMonth = undefined;
       scrubberMonthPercent = 0;
     } else {
-      let top = element.scrollTop;
+      let top = timelineManager.visibleWindow.top;
       if (top < timelineManager.topSectionHeight) {
         // in the lead-in area
         scrubberMonth = undefined;
         scrubberMonthPercent = 0;
-        const maxScroll = getMaxScroll();
+        const maxScroll = timelineManager.getMaxScroll();
 
-        scrubOverallPercent = Math.min(1, element.scrollTop / maxScroll);
+        scrubOverallPercent = Math.min(1, top / maxScroll);
         return;
       }
 
-      let maxScrollPercent = getMaxScrollPercent();
+      let maxScrollPercent = timelineManager.getMaxScrollPercent();
       let found = false;
 
       const monthsLength = timelineManager.months.length;
@@ -327,7 +98,7 @@
           monthGroupHeight = timelineManager.topSectionHeight;
         } else if (i === monthsLength) {
           // lead-out
-          monthGroupHeight = bottomSectionHeight;
+          monthGroupHeight = timelineManager.bottomSectionHeight;
         } else {
           monthGroup = timelineManager.months[i].yearMonth;
           monthGroupHeight = timelineManager.months[i].height;
@@ -361,146 +132,77 @@
     }
   };
 
-  let onDateGroupSelect = <({ title, assets }: { title: string; assets: TimelineAsset[] }) => void>$state();
-  let onSelectAssets = <(asset: TimelineAsset) => Promise<void>>$state();
-  let onSelectAssetCandidates = <(asset: TimelineAsset | null) => void>$state();
+  // note: don't throttle, debounch, or otherwise make this function async - it causes flicker
+  // this function scrolls the timeline to the specified month group and offset, based on scrubber interaction
+  const onScrub: ScrubberListener = ({
+    scrubberMonth,
+    overallScrollPercent,
+    scrubberMonthScrollPercent,
+    handleScrollTop,
+  }) => {
+    if (!scrubberMonth || timelineManager.timelineHeight < timelineManager.viewportHeight * 2) {
+      // edge case - scroll limited due to size of content, must adjust - use use the overall percent instead
+      const maxScroll = timelineManager.getMaxScroll();
+      const offset = maxScroll * overallScrollPercent;
+      handleScrollTop?.(offset);
+    } else {
+      const monthGroup = timelineManager.months.find(
+        ({ yearMonth: { year, month } }) => year === scrubberMonth.year && month === scrubberMonth.month,
+      );
+      if (!monthGroup) {
+        return;
+      }
+      scrollToMonthGroupAndOffset(monthGroup, scrubberMonthScrollPercent, handleScrollTop);
+    }
+  };
+
+  const scrollToMonthGroupAndOffset = (
+    monthGroup: MonthGroup,
+    monthGroupScrollPercent: number,
+    handleScrollTop?: (top: number) => void,
+  ) => {
+    const topOffset = monthGroup.top;
+    const maxScrollPercent = timelineManager.getMaxScrollPercent();
+    const delta = monthGroup.height * monthGroupScrollPercent;
+    const scrollToTop = (topOffset + delta) * maxScrollPercent;
+
+    handleScrollTop?.(scrollToTop);
+  };
 </script>
 
-<AssetDateGroupActions
+<AssetGridWithoutScrubber
+  {isSelectionMode}
+  {singleSelect}
+  {enableRouting}
   {timelineManager}
   {assetInteraction}
-  handleScrollTop={scrollTop}
+  {removeAction}
+  {withStacked}
+  {showArchiveIcon}
+  {isShared}
+  {album}
+  {person}
+  {isShowDeleteConfirmation}
   {onSelect}
-  bind:onDateGroupSelect
-  bind:onSelectAssets
-  bind:onSelectAssetCandidates
-></AssetDateGroupActions>
-
-<AssetGridActions {scrollToAsset} {timelineManager} {assetInteraction} bind:isShowDeleteConfirmation {onEscape}
-></AssetGridActions>
-
-{#if timelineManager.months.length > 0}
-  <Scrubber
-    {timelineManager}
-    height={timelineManager.viewportHeight}
-    timelineTopOffset={timelineManager.topSectionHeight}
-    timelineBottomOffset={bottomSectionHeight}
-    {leadout}
-    {scrubOverallPercent}
-    {scrubberMonthPercent}
-    {scrubberMonth}
-    {onScrub}
-    bind:scrubberWidth
-  />
-{/if}
-
-<!-- Right margin MUST be equal to the width of scrubber -->
-<section
-  id="asset-grid"
-  class={['scrollbar-hidden h-full overflow-y-auto outline-none', { 'm-0': isEmpty }, { 'ms-0': !isEmpty }]}
-  style:margin-right={(usingMobileDevice ? 0 : scrubberWidth) + 'px'}
-  tabindex="-1"
-  bind:clientHeight={timelineManager.viewportHeight}
-  bind:clientWidth={null, (v) => ((timelineManager.viewportWidth = v), updateSlidingWindow())}
-  bind:this={element}
-  onscroll={() => (handleTimelineScroll(), updateSlidingWindow(), updateIsScrolling())}
+  {onEscape}
+  {children}
+  {empty}
+  {handleTimelineScroll}
 >
-  <section
-    bind:this={timelineElement}
-    id="virtual-timeline"
-    class:invisible={showSkeleton}
-    style:height={timelineManager.timelineHeight + 'px'}
-  >
-    <section
-      use:resizeObserver={topSectionResizeObserver}
-      class:invisible={showSkeleton}
-      style:position="absolute"
-      style:left="0"
-      style:right="0"
-    >
-      {@render children?.()}
-      {#if isEmpty}
-        <!-- (optional) empty placeholder -->
-        {@render empty?.()}
-      {/if}
-    </section>
-
-    {#each timelineManager.months as monthGroup (monthGroup.viewId)}
-      {@const display = monthGroup.intersecting}
-      {@const absoluteHeight = monthGroup.top}
-
-      {#if !monthGroup.isLoaded}
-        <div
-          style:height={monthGroup.height + 'px'}
-          style:position="absolute"
-          style:transform={`translate3d(0,${absoluteHeight}px,0)`}
-          style:width="100%"
-        >
-          <Skeleton
-            height={monthGroup.height - monthGroup.timelineManager.headerHeight}
-            title={monthGroup.monthGroupTitle}
-          />
-        </div>
-      {:else if display}
-        <div
-          class="month-group"
-          style:height={monthGroup.height + 'px'}
-          style:position="absolute"
-          style:transform={`translate3d(0,${absoluteHeight}px,0)`}
-          style:width="100%"
-        >
-          <AssetDateGroup
-            {withStacked}
-            {showArchiveIcon}
-            {assetInteraction}
-            {timelineManager}
-            {isSelectionMode}
-            {singleSelect}
-            {monthGroup}
-            onSelect={onDateGroupSelect}
-            {onSelectAssetCandidates}
-            {onSelectAssets}
-            onScrollCompensation={handleScrollCompensation}
-          />
-        </div>
-      {/if}
-    {/each}
-    <!-- spacer for leadout -->
-    <div
-      class="h-[60px]"
-      style:position="absolute"
-      style:left="0"
-      style:right="0"
-      style:transform={`translate3d(0,${timelineManager.timelineHeight}px,0)`}
-    ></div>
-  </section>
-</section>
-
-<Portal target="body">
-  {#if $showAssetViewer}
-    <AssetViewerAndActions
-      bind:showSkeleton
-      {timelineManager}
-      {removeAction}
-      {withStacked}
-      {isShared}
-      {album}
-      {person}
-      {isShowDeleteConfirmation}
-    ></AssetViewerAndActions>
-  {/if}
-</Portal>
-
-<style>
-  #asset-grid {
-    contain: strict;
-    scrollbar-width: none;
-  }
-
-  .month-group {
-    contain: layout size paint;
-    transform-style: flat;
-    backface-visibility: hidden;
-    transform-origin: center center;
-  }
-</style>
+  {#snippet header(handleScrollTop)}
+    {#if timelineManager.months.length > 0}
+      <Scrubber
+        {timelineManager}
+        height={timelineManager.viewportHeight}
+        timelineTopOffset={timelineManager.topSectionHeight}
+        timelineBottomOffset={timelineManager.bottomSectionHeight}
+        {leadout}
+        {scrubOverallPercent}
+        {scrubberMonthPercent}
+        {scrubberMonth}
+        onScrub={(args) => onScrub({ ...args, handleScrollTop })}
+        bind:scrubberWidth
+      />
+    {/if}
+  {/snippet}
+</AssetGridWithoutScrubber>
diff --git a/web/src/lib/components/shared-components/scrubber/scrubber.svelte b/web/src/lib/components/shared-components/scrubber/scrubber.svelte
index 4e49f9a012..83f9919279 100644
--- a/web/src/lib/components/shared-components/scrubber/scrubber.svelte
+++ b/web/src/lib/components/shared-components/scrubber/scrubber.svelte
@@ -295,12 +295,24 @@
 
     const scrollPercent = toTimelineY(hoverY);
     if (wasDragging === false && isDragging) {
-      void startScrub?.(segmentDate!, scrollPercent, monthGroupPercentY);
-      void onScrub?.(segmentDate!, scrollPercent, monthGroupPercentY);
+      void startScrub?.({
+        scrubberMonth: segmentDate!,
+        overallScrollPercent: scrollPercent,
+        scrubberMonthScrollPercent: monthGroupPercentY,
+      });
+      void onScrub?.({
+        scrubberMonth: segmentDate!,
+        overallScrollPercent: scrollPercent,
+        scrubberMonthScrollPercent: monthGroupPercentY,
+      });
     }
 
     if (wasDragging && !isDragging) {
-      void stopScrub?.(segmentDate!, scrollPercent, monthGroupPercentY);
+      void stopScrub?.({
+        scrubberMonth: segmentDate!,
+        overallScrollPercent: scrollPercent,
+        scrubberMonthScrollPercent: monthGroupPercentY,
+      });
       return;
     }
 
@@ -308,7 +320,11 @@
       return;
     }
 
-    void onScrub?.(segmentDate!, scrollPercent, monthGroupPercentY);
+    void onScrub?.({
+      scrubberMonth: segmentDate!,
+      overallScrollPercent: scrollPercent,
+      scrubberMonthScrollPercent: monthGroupPercentY,
+    });
   };
   /* eslint-disable tscompat/tscompat */
   const getTouch = (event: TouchEvent) => {
@@ -412,7 +428,11 @@
       }
       if (next) {
         event.preventDefault();
-        void onScrub?.({ year: next.year, month: next.month }, -1, 0);
+        void onScrub?.({
+          scrubberMonth: { year: next.year, month: next.month },
+          overallScrollPercent: -1,
+          scrubberMonthScrollPercent: 0,
+        });
         return true;
       }
     }
@@ -422,7 +442,11 @@
         const next = segments[idx + 1];
         if (next) {
           event.preventDefault();
-          void onScrub?.({ year: next.year, month: next.month }, -1, 0);
+          void onScrub?.({
+            scrubberMonth: { year: next.year, month: next.month },
+            overallScrollPercent: -1,
+            scrubberMonthScrollPercent: 0,
+          });
           return true;
         }
       }
diff --git a/web/src/lib/managers/timeline-manager/timeline-manager.svelte.ts b/web/src/lib/managers/timeline-manager/timeline-manager.svelte.ts
index 8aacd0a90a..803b6c3dd4 100644
--- a/web/src/lib/managers/timeline-manager/timeline-manager.svelte.ts
+++ b/web/src/lib/managers/timeline-manager/timeline-manager.svelte.ts
@@ -41,6 +41,7 @@ export class TimelineManager {
   isInitialized = $state(false);
   months: MonthGroup[] = $state([]);
   topSectionHeight = $state(0);
+  bottomSectionHeight = $state(60);
   timelineHeight = $derived(this.months.reduce((accumulator, b) => accumulator + b.height, 0) + this.topSectionHeight);
   assetCount = $derived(this.months.reduce((accumulator, b) => accumulator + b.assetsCount, 0));
 
@@ -540,4 +541,13 @@ export class TimelineManager {
       isMismatched(this.#options.isTrashed, asset.isTrashed)
     );
   }
+
+  getMaxScrollPercent() {
+    const totalHeight = this.timelineHeight + this.bottomSectionHeight + this.topSectionHeight;
+    return (totalHeight - this.viewportHeight) / totalHeight;
+  }
+
+  getMaxScroll() {
+    return this.topSectionHeight + this.bottomSectionHeight + (this.timelineHeight - this.viewportHeight);
+  }
 }
diff --git a/web/src/lib/utils/timeline-util.ts b/web/src/lib/utils/timeline-util.ts
index c3e41c01be..cfe9454d26 100644
--- a/web/src/lib/utils/timeline-util.ts
+++ b/web/src/lib/utils/timeline-util.ts
@@ -22,11 +22,12 @@ export type TimelinePlainDateTime = TimelinePlainDate & {
   millisecond: number;
 };
 
-export type ScrubberListener = (
-  scrubberMonth: { year: number; month: number },
-  overallScrollPercent: number,
-  scrubberMonthScrollPercent: number,
-) => void | Promise<void>;
+export type ScrubberListener = (args: {
+  scrubberMonth: { year: number; month: number };
+  overallScrollPercent: number;
+  scrubberMonthScrollPercent: number;
+  handleScrollTop?: (top: number) => void;
+}) => void | Promise<void>;
 
 // used for AssetResponseDto.dateTimeOriginal, amongst others
 export const fromISODateTime = (isoDateTime: string, timeZone: string): DateTime<true> =>