feat(web): add zoom minimap preview overlay

Change-Id: I51d4defc2ad2b7853ec0a4944684a56f6a6a6964

e2e/src/ui/specs/asset-viewer/face-overlay.e2e-spec.ts

@@ -148,7 +148,7 @@ test.describe('zoom and face editor interaction', () => {
     await page.mouse.move(width / 2, height / 2);
     await page.mouse.wheel(0, -1);
 
-    const imgLocator = page.locator('[data-viewer-content] img[data-testid="preview"]');
+    const imgLocator = page.getByTestId('preview');
     await expect(async () => {
       const transform = await imgLocator.evaluate((element) => {
         return getComputedStyle(element.closest('[style*="transform"]') ?? element).transform;

e2e/src/ui/specs/asset-viewer/zoom-minimap.e2e-spec.ts

@@ -0,0 +1,127 @@
+import { expect, type Page, test } from '@playwright/test';
+import { assetViewerUtils } from '../timeline/utils';
+import { setupAssetViewerFixture } from './utils';
+
+test.describe.configure({ mode: 'parallel' });
+
+const zoomIn = async (page: Page) => {
+  const { width, height } = page.viewportSize()!;
+  await page.mouse.move(width / 2, height / 2);
+  await page.mouse.wheel(0, -1);
+  await page.waitForTimeout(300);
+};
+
+const getImageTransform = (page: Page) => {
+  return page.getByTestId('preview').evaluate((element) => {
+    return getComputedStyle(element.closest('[style*="transform"]') ?? element).transform;
+  });
+};
+
+test.describe('zoom minimap', () => {
+  const fixture = setupAssetViewerFixture(950);
+
+  test('minimap is not visible at 1x zoom', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await expect(page.getByTestId('zoom-minimap')).toHaveCount(0);
+  });
+
+  test('minimap appears when zoomed in', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+
+    await expect(page.getByTestId('zoom-minimap')).toBeVisible();
+  });
+
+  test('minimap contains thumbnail image', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+
+    const canvas = page.getByTestId('zoom-minimap-canvas');
+    await expect(canvas).toBeVisible();
+
+    const img = canvas.locator('img');
+    await expect(img).toBeVisible();
+    await expect(img).toHaveAttribute('src', /thumbnail/);
+  });
+
+  test('viewport rect is visible when zoomed', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+
+    const viewport = page.getByTestId('zoom-minimap-viewport');
+    await expect(viewport).toBeVisible();
+
+    const box = await viewport.boundingBox();
+    expect(box).toBeTruthy();
+    expect(box!.width).toBeGreaterThan(0);
+    expect(box!.height).toBeGreaterThan(0);
+  });
+
+  test('clicking minimap pans the image', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+
+    const transformBefore = await getImageTransform(page);
+
+    const canvas = page.getByTestId('zoom-minimap-canvas');
+    const canvasBox = await canvas.boundingBox();
+    expect(canvasBox).toBeTruthy();
+
+    // Click near the top-left corner of the minimap
+    await page.mouse.click(canvasBox!.x + 20, canvasBox!.y + 20);
+    await page.waitForTimeout(100);
+
+    const transformAfter = await getImageTransform(page);
+    expect(transformAfter).not.toBe(transformBefore);
+  });
+
+  test('zoom slider adjusts zoom level', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+
+    const slider = page.getByTestId('zoom-minimap-slider');
+    await expect(slider).toBeVisible();
+
+    const sliderBox = await slider.boundingBox();
+    expect(sliderBox).toBeTruthy();
+
+    const fillBefore = await page.getByTestId('zoom-minimap-slider-fill').evaluate((element) => {
+      return element.style.width;
+    });
+
+    // Click near the right end of the slider to increase zoom
+    await page.mouse.click(sliderBox!.x + sliderBox!.width * 0.8, sliderBox!.y + sliderBox!.height / 2);
+    await page.waitForTimeout(100);
+
+    const fillAfter = await page.getByTestId('zoom-minimap-slider-fill').evaluate((element) => {
+      return element.style.width;
+    });
+
+    expect(fillAfter).not.toBe(fillBefore);
+  });
+
+  test('minimap auto-hides after inactivity', async ({ page }) => {
+    await page.goto(`/photos/${fixture.primaryAsset.id}`);
+    await assetViewerUtils.waitForViewerLoad(page, fixture.primaryAsset);
+
+    await zoomIn(page);
+    await expect(page.getByTestId('zoom-minimap')).toBeVisible();
+
+    // Wait for the hide delay (1500ms) plus fade duration
+    await page.waitForTimeout(2000);
+
+    await expect(page.getByTestId('zoom-minimap')).toHaveCount(0);
+  });
+});

e2e/src/ui/specs/search/search-gallery.e2e-spec.ts

@@ -6,7 +6,6 @@ import {
   generateTimelineData,
   TimelineAssetConfig,
   TimelineData,
-  toAssetResponseDto,
 } from 'src/ui/generators/timeline';
 import { setupBaseMockApiRoutes } from 'src/ui/mock-network/base-network';
 import { setupTimelineMockApiRoutes, TimelineTestContext } from 'src/ui/mock-network/timeline-network';
@@ -31,10 +30,6 @@ test.describe('search gallery-viewer', () => {
   };
 
   test.beforeAll(async () => {
-    test.fail(
-      process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS !== '1',
-      'This test requires env var: PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS=1',
-    );
     adminUserId = faker.string.uuid();
     testContext.adminId = adminUserId;
     timelineRestData = generateTimelineData({ ...createDefaultTimelineConfig(), ownerId: adminUserId });
@@ -49,10 +44,7 @@ test.describe('search gallery-viewer', () => {
 
     await context.route('**/api/search/metadata', async (route, request) => {
       if (request.method() === 'POST') {
-        const searchAssets = assets
+        const searchAssets = assets.slice(0, 5).filter((asset) => !changes.assetDeletions.includes(asset.id));
-          .slice(0, 5)
-          .filter((asset) => !changes.assetDeletions.includes(asset.id))
-          .map((asset) => toAssetResponseDto(asset));
         return route.fulfill({
           status: 200,
           contentType: 'application/json',

e2e/src/ui/specs/timeline/utils.ts

@@ -143,7 +143,7 @@ export const timelineUtils = {
     return page.locator('#asset-grid');
   },
   async waitForTimelineLoad(page: Page) {
-    await page.locator('#asset-grid[data-initialized]').waitFor();
+    await expect(timelineUtils.locator(page)).toBeInViewport();
     await expect.poll(() => thumbnailUtils.locator(page).count()).toBeGreaterThan(0);
   },
   async getScrollTop(page: Page) {
@@ -163,17 +163,14 @@ export const assetViewerUtils = {
     return page.locator('#immich-asset-viewer');
   },
   async waitForViewerLoad(page: Page, asset: TimelineAssetConfig) {
-    const imgLocator = page.locator(`[data-viewer-content] img[data-testid="preview"][src*="${asset.id}"]`);
+    await page
-    const videoLocator = page.locator(`[data-viewer-content] video[poster*="${asset.id}"]`);
+      .locator(
-    await imgLocator.or(videoLocator).waitFor();
+        `img[draggable="false"][src="/api/assets/${asset.id}/thumbnail?size=preview&c=${asset.thumbhash}&edited=true"]`,
-
+      )
-    if ((await videoLocator.count()) === 0) {
+      .or(
-      await expect
+        page.locator(`video[poster="/api/assets/${asset.id}/thumbnail?size=preview&c=${asset.thumbhash}&edited=true"]`),
-        .poll(() => imgLocator.evaluate((img: HTMLImageElement) => img.complete && img.naturalWidth > 0))
+      )
-        .toBe(true);
+      .waitFor();
-    }
-
-    await expect(page.locator('#immich-asset-viewer')).not.toHaveAttribute('data-navigating');
   },
   async expectActiveAssetToBe(page: Page, assetId: string) {
     const activeElement = () =>

e2e/src/web/specs/asset-viewer/asset-viewer.ui-spec.ts

@@ -1,273 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { expect, test } from '@playwright/test';
-import {
-  Changes,
-  createDefaultTimelineConfig,
-  generateTimelineData,
-  SeededRandom,
-  selectRandom,
-  TimelineAssetConfig,
-  TimelineData,
-} from 'src/ui/generators/timeline';
-import { setupBaseMockApiRoutes } from 'src/ui/mock-network/base-network';
-import { setupTimelineMockApiRoutes, TimelineTestContext } from 'src/ui/mock-network/timeline-network';
-import { assetViewerUtils } from 'src/ui/specs/timeline/utils';
-import { utils } from 'src/utils';
-
-test.describe.configure({ mode: 'parallel' });
-test.describe('asset-viewer', () => {
-  const rng = new SeededRandom(529);
-  let adminUserId: string;
-  let timelineRestData: TimelineData;
-  const assets: TimelineAssetConfig[] = [];
-  const yearMonths: string[] = [];
-  const testContext = new TimelineTestContext();
-  const changes: Changes = {
-    albumAdditions: [],
-    assetDeletions: [],
-    assetArchivals: [],
-    assetFavorites: [],
-  };
-
-  test.beforeAll(async () => {
-    utils.initSdk();
-    adminUserId = faker.string.uuid();
-    testContext.adminId = adminUserId;
-    timelineRestData = generateTimelineData({ ...createDefaultTimelineConfig(), ownerId: adminUserId });
-    for (const timeBucket of timelineRestData.buckets.values()) {
-      assets.push(...timeBucket);
-    }
-    for (const yearMonth of timelineRestData.buckets.keys()) {
-      const [year, month] = yearMonth.split('-');
-      yearMonths.push(`${year}-${Number(month)}`);
-    }
-  });
-
-  test.beforeEach(async ({ context }) => {
-    await setupBaseMockApiRoutes(context, adminUserId);
-    await setupTimelineMockApiRoutes(context, timelineRestData, changes, testContext);
-  });
-
-  test.afterEach(() => {
-    testContext.slowBucket = false;
-    changes.albumAdditions = [];
-    changes.assetDeletions = [];
-    changes.assetArchivals = [];
-    changes.assetFavorites = [];
-  });
-
-  test.describe('/photos/:id', () => {
-    test('Navigate to next asset via button', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${asset.id}`);
-
-      await page.getByLabel('View next asset').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index + 1].id}`);
-    });
-
-    test('Navigate to previous asset via button', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${asset.id}`);
-
-      await page.getByLabel('View previous asset').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index - 1]);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index - 1].id}`);
-    });
-
-    test('Navigate to next asset via keyboard (ArrowRight)', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${asset.id}`);
-
-      await page.getByTestId('next-asset').waitFor();
-      await page.keyboard.press('ArrowRight');
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index + 1].id}`);
-    });
-
-    test('Navigate to previous asset via keyboard (ArrowLeft)', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${asset.id}`);
-
-      await page.getByTestId('previous-asset').waitFor();
-      await page.keyboard.press('ArrowLeft');
-      await assetViewerUtils.waitForViewerLoad(page, assets[index - 1]);
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index - 1].id}`);
-    });
-
-    test('Navigate forward 5 times via button', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-
-      for (let i = 1; i <= 5; i++) {
-        await page.getByLabel('View next asset').click();
-        await assetViewerUtils.waitForViewerLoad(page, assets[index + i]);
-        await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index + i].id}`);
-      }
-    });
-
-    test('Navigate backward 5 times via button', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-
-      for (let i = 1; i <= 5; i++) {
-        await page.getByLabel('View previous asset').click();
-        await assetViewerUtils.waitForViewerLoad(page, assets[index - i]);
-        await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${assets[index - i].id}`);
-      }
-    });
-
-    test('Navigate forward then backward via keyboard', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-
-      // Navigate forward 3 times
-      for (let i = 1; i <= 3; i++) {
-        await page.getByTestId('next-asset').waitFor();
-        await page.keyboard.press('ArrowRight');
-        await assetViewerUtils.waitForViewerLoad(page, assets[index + i]);
-      }
-
-      // Navigate backward 3 times to return to original
-      for (let i = 2; i >= 0; i--) {
-        await page.getByTestId('previous-asset').waitFor();
-        await page.keyboard.press('ArrowLeft');
-        await assetViewerUtils.waitForViewerLoad(page, assets[index + i]);
-      }
-
-      // Verify we're back at the original asset
-      await expect.poll(() => new URL(page.url()).pathname).toBe(`/photos/${asset.id}`);
-    });
-
-    test('Verify no next button on last asset', async ({ page }) => {
-      const lastAsset = assets.at(-1)!;
-      await page.goto(`/photos/${lastAsset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, lastAsset);
-
-      // Verify next button doesn't exist
-      await expect(page.getByLabel('View next asset')).toHaveCount(0);
-    });
-
-    test('Verify no previous button on first asset', async ({ page }) => {
-      const firstAsset = assets[0];
-      await page.goto(`/photos/${firstAsset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, firstAsset);
-
-      // Verify previous button doesn't exist
-      await expect(page.getByLabel('View previous asset')).toHaveCount(0);
-    });
-
-    test('Delete photo advances to next', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      const index = assets.indexOf(asset);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-    });
-    test('Delete photo advances to next (2x)', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      const index = assets.indexOf(asset);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-      await page.getByLabel('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 2]);
-    });
-    test('Delete last photo advances to prev', async ({ page }) => {
-      const asset = assets.at(-1)!;
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      const index = assets.indexOf(asset);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index - 1]);
-    });
-    test('Delete last photo advances to prev (2x)', async ({ page }) => {
-      const asset = assets.at(-1)!;
-      await page.goto(`/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      const index = assets.indexOf(asset);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index - 1]);
-      await page.getByLabel('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index - 2]);
-    });
-  });
-  test.describe('/trash/photos/:id', () => {
-    test('Delete trashed photo advances to next', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      const deletedAssets = assets.slice(index - 10, index + 10).map((asset) => asset.id);
-      changes.assetDeletions.push(...deletedAssets);
-      await page.goto(`/trash/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-    });
-    test('Delete trashed photo advances to next 2x', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      const deletedAssets = assets.slice(index - 10, index + 10).map((asset) => asset.id);
-      changes.assetDeletions.push(...deletedAssets);
-      await page.goto(`/trash/photos/${asset.id}`);
-      await assetViewerUtils.waitForViewerLoad(page, asset);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 1]);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 2]);
-    });
-    test('Delete trashed photo advances to prev', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      const deletedAssets = assets.slice(index - 10, index + 10).map((asset) => asset.id);
-      changes.assetDeletions.push(...deletedAssets);
-      await page.goto(`/trash/photos/${assets[index + 9].id}`);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 9]);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 8]);
-    });
-    test('Delete trashed photo advances to prev 2x', async ({ page }) => {
-      const asset = selectRandom(assets, rng);
-      const index = assets.indexOf(asset);
-      const deletedAssets = assets.slice(index - 10, index + 10).map((asset) => asset.id);
-      changes.assetDeletions.push(...deletedAssets);
-      await page.goto(`/trash/photos/${assets[index + 9].id}`);
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 9]);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 8]);
-      await page.getByLabel('Delete').click();
-      // confirm dialog
-      await page.getByRole('button').getByText('Delete').click();
-      await assetViewerUtils.waitForViewerLoad(page, assets[index + 7]);
-    });
-  });
-});

web/src/app.css

@@ -75,35 +75,6 @@
     --immich-dark-bg: 10 10 10;
     --immich-dark-fg: 229 231 235;
     --immich-dark-gray: 33 33 33;
-
-    /* transitions */
-    --immich-split-viewer-nav: enabled;
-
-    /* view transition variables */
-    /* Base animation duration for standard transitions (page fades, info panel) */
-    --vt-duration-default: 250ms;
-    /* Duration for hero transitions (thumbnail to full viewer) */
-    --vt-duration-hero: 280ms;
-    /* Duration for next/previous photo navigation */
-    --vt-duration-viewer-navigation: 270ms;
-    /* Duration for slideshow mode transitions */
-    --vt-duration-slideshow: 1s;
-    /* Easing function for slide animations (ease-out) */
-    --vt-viewer-slide-easing: cubic-bezier(0.2, 0, 0, 1);
-    /* How far images slide in/out during navigation (% of viewport) */
-    --vt-viewer-slide-distance: 15%;
-    /* Starting opacity for fly transitions (slide+fade effect) */
-    --vt-viewer-opacity-start: 0.1;
-    /* Maximum blur during fly transitions (currently disabled) */
-    --vt-viewer-blur-max: 0px;
-
-    --vt-viewer-next-in: flyInRight;
-    --vt-viewer-next-out: flyOutLeft;
-    --vt-viewer-prev-in: flyInLeft;
-    --vt-viewer-prev-out: flyOutRight;
-    --vt-viewer-old-opacity: 1;
-    /* Easing function for memory and hero morph transitions */
-    --vt-memory-easing: cubic-bezier(0.2, 0, 0, 1);
   }
 
   button:not(:disabled),
@@ -205,370 +176,3 @@
     @apply bg-subtle rounded-lg;
   }
 }
-
-@layer base {
-  ::view-transition {
-    background: var(--color-black);
-    animation-duration: var(--vt-duration-default);
-  }
-
-  ::view-transition-old(*),
-  ::view-transition-new(*) {
-    mix-blend-mode: normal;
-    animation-duration: inherit;
-  }
-
-  ::view-transition-old(*) {
-    animation-name: fadeOut;
-    animation-fill-mode: forwards;
-  }
-  ::view-transition-new(*) {
-    animation-name: fadeIn;
-    animation-fill-mode: forwards;
-  }
-
-  ::view-transition-old(root) {
-    animation: var(--vt-duration-default) 0s fadeOut forwards;
-  }
-  ::view-transition-new(root) {
-    animation: var(--vt-duration-default) 0s fadeIn forwards;
-  }
-  html:active-view-transition-type(slideshow) {
-    &::view-transition-old(*) {
-      animation: var(--vt-duration-slideshow) linear crossfadeOut forwards;
-    }
-    &::view-transition-new(*) {
-      animation: var(--vt-duration-slideshow) linear crossfadeIn forwards;
-    }
-    &::view-transition-image-pair(*) {
-      isolation: auto;
-    }
-  }
-  html:active-view-transition-type(viewer-nav) {
-    &::view-transition-old(root) {
-      animation: var(--vt-duration-hero) 0s fadeOut forwards;
-    }
-    &::view-transition-new(root) {
-      animation: var(--vt-duration-hero) 0s fadeIn forwards;
-    }
-  }
-  ::view-transition-image-pair(info) {
-    isolation: auto;
-  }
-  ::view-transition-old(info) {
-    animation: var(--vt-duration-default) 0s panelSlideOutRight forwards;
-  }
-  ::view-transition-new(info) {
-    animation: var(--vt-duration-default) 0s panelSlideInRight forwards;
-  }
-
-  ::view-transition-group(detail-panel) {
-    z-index: 1;
-  }
-  ::view-transition-old(detail-panel),
-  ::view-transition-new(detail-panel) {
-    animation: none;
-  }
-  ::view-transition-group(letterbox-left),
-  ::view-transition-group(letterbox-right),
-  ::view-transition-group(letterbox-top),
-  ::view-transition-group(letterbox-bottom) {
-    animation-duration: var(--vt-duration-viewer-navigation);
-    animation-timing-function: var(--vt-viewer-slide-easing);
-    z-index: 4;
-  }
-
-  ::view-transition-image-pair(letterbox-left),
-  ::view-transition-image-pair(letterbox-right),
-  ::view-transition-image-pair(letterbox-top),
-  ::view-transition-image-pair(letterbox-bottom) {
-    isolation: auto;
-  }
-
-  ::view-transition-old(letterbox-left),
-  ::view-transition-old(letterbox-right),
-  ::view-transition-old(letterbox-top),
-  ::view-transition-old(letterbox-bottom),
-  ::view-transition-new(letterbox-left),
-  ::view-transition-new(letterbox-right),
-  ::view-transition-new(letterbox-top),
-  ::view-transition-new(letterbox-bottom) {
-    animation: none;
-    width: 100%;
-    height: 100%;
-    object-fit: fill;
-    background-color: var(--color-black);
-  }
-
-  ::view-transition-group(exclude-leftbutton),
-  ::view-transition-group(exclude-rightbutton),
-  ::view-transition-group(exclude) {
-    animation: none;
-    z-index: 5;
-  }
-  ::view-transition-old(exclude-leftbutton),
-  ::view-transition-old(exclude-rightbutton),
-  ::view-transition-old(exclude) {
-    visibility: hidden;
-  }
-  ::view-transition-new(exclude-leftbutton),
-  ::view-transition-new(exclude-rightbutton),
-  ::view-transition-new(exclude) {
-    animation: none;
-    z-index: 5;
-  }
-
-  ::view-transition-group(hero) {
-    animation-duration: var(--vt-duration-hero);
-    animation-timing-function: var(--vt-memory-easing);
-  }
-  ::view-transition-old(hero) {
-    animation: none;
-    display: none;
-  }
-  ::view-transition-new(hero) {
-    animation: none;
-    align-content: center;
-  }
-  ::view-transition-old(next),
-  ::view-transition-old(next-old),
-  ::view-transition-new(next),
-  ::view-transition-new(next-new),
-  ::view-transition-old(previous),
-  ::view-transition-old(previous-old),
-  ::view-transition-new(previous),
-  ::view-transition-new(previous-new) {
-    animation-duration: var(--vt-duration-viewer-navigation);
-    animation-timing-function: var(--vt-viewer-slide-easing);
-    animation-fill-mode: forwards;
-  }
-
-  ::view-transition-old(next),
-  ::view-transition-old(next-old),
-  ::view-transition-old(previous),
-  ::view-transition-old(previous-old) {
-    opacity: var(--vt-viewer-old-opacity);
-  }
-
-  ::view-transition-old(next),
-  ::view-transition-old(next-old) {
-    animation-name: var(--vt-viewer-next-out);
-  }
-
-  ::view-transition-new(next),
-  ::view-transition-new(next-new) {
-    animation-name: var(--vt-viewer-next-in);
-  }
-
-  ::view-transition-old(previous),
-  ::view-transition-old(previous-old) {
-    animation-name: var(--vt-viewer-prev-out);
-  }
-
-  ::view-transition-new(previous),
-  ::view-transition-new(previous-new) {
-    animation-name: var(--vt-viewer-prev-in);
-  }
-
-  ::view-transition-old(next-old),
-  ::view-transition-new(next-new),
-  ::view-transition-old(previous-old),
-  ::view-transition-new(previous-new) {
-    overflow: hidden;
-  }
-
-  ::view-transition-old(previous-old) {
-    z-index: -1;
-  }
-
-  @keyframes flyInLeft {
-    from {
-      transform: translateX(calc(-1 * var(--vt-viewer-slide-distance)));
-      opacity: var(--vt-viewer-opacity-start);
-      filter: blur(var(--vt-viewer-blur-max));
-    }
-    to {
-      opacity: 1;
-      filter: blur(0);
-    }
-  }
-
-  @keyframes flyOutLeft {
-    from {
-      opacity: 1;
-      filter: blur(0);
-    }
-    to {
-      transform: translateX(calc(-1 * var(--vt-viewer-slide-distance)));
-      opacity: var(--vt-viewer-opacity-start);
-      filter: blur(var(--vt-viewer-blur-max));
-    }
-  }
-
-  @keyframes flyInRight {
-    from {
-      transform: translateX(var(--vt-viewer-slide-distance));
-      opacity: var(--vt-viewer-opacity-start);
-      filter: blur(var(--vt-viewer-blur-max));
-    }
-    to {
-      opacity: 1;
-      filter: blur(0);
-    }
-  }
-
-  @keyframes flyOutRight {
-    from {
-      opacity: 1;
-      filter: blur(0);
-    }
-    to {
-      transform: translateX(var(--vt-viewer-slide-distance));
-      opacity: var(--vt-viewer-opacity-start);
-      filter: blur(var(--vt-viewer-blur-max));
-    }
-  }
-
-  @keyframes panelSlideInRight {
-    from {
-      transform: translateX(100%);
-    }
-    to {
-      transform: translateX(0);
-    }
-  }
-
-  @keyframes panelSlideOutRight {
-    from {
-      transform: translateX(0);
-    }
-    to {
-      transform: translateX(100%);
-    }
-  }
-
-  /* cubic fade curves so combined opacity stays close to 1.0 during crossfade */
-  @keyframes fadeIn {
-    from {
-      opacity: 0;
-    }
-    50% {
-      opacity: 0.85;
-    }
-    to {
-      opacity: 1;
-    }
-  }
-  @keyframes fadeOut {
-    from {
-      opacity: 1;
-    }
-    50% {
-      opacity: 0.85;
-    }
-    to {
-      opacity: 0;
-    }
-  }
-
-  @keyframes crossfadeIn {
-    from {
-      opacity: 0;
-    }
-    to {
-      opacity: 1;
-    }
-  }
-  @keyframes crossfadeOut {
-    from {
-      opacity: 1;
-    }
-    to {
-      opacity: 0;
-    }
-  }
-
-  @media (prefers-reduced-motion: reduce) {
-    ::view-transition-group(hero) {
-      animation-name: none;
-    }
-
-    ::view-transition-old(hero) {
-      animation: none;
-      display: none;
-    }
-
-    ::view-transition-new(hero) {
-      animation: none;
-    }
-
-    html:active-view-transition-type(viewer) {
-      &::view-transition-old(hero) {
-        animation: none;
-        display: none;
-      }
-      &::view-transition-new(hero) {
-        animation: var(--vt-duration-default) 0s fadeIn forwards;
-      }
-    }
-
-    html:active-view-transition-type(timeline) {
-      &::view-transition-old(hero) {
-        animation: var(--vt-duration-default) 0s fadeOut forwards;
-      }
-      &::view-transition-new(hero) {
-        animation: var(--vt-duration-default) 0s fadeIn forwards;
-      }
-    }
-
-    ::view-transition-group(letterbox-left),
-    ::view-transition-group(letterbox-right),
-    ::view-transition-group(letterbox-top),
-    ::view-transition-group(letterbox-bottom) {
-      z-index: 100;
-    }
-
-    ::view-transition-old(letterbox-left),
-    ::view-transition-old(letterbox-right),
-    ::view-transition-old(letterbox-top),
-    ::view-transition-old(letterbox-bottom),
-    ::view-transition-new(letterbox-left),
-    ::view-transition-new(letterbox-right),
-    ::view-transition-new(letterbox-top),
-    ::view-transition-new(letterbox-bottom) {
-      background-color: transparent;
-    }
-
-    ::view-transition-group(previous),
-    ::view-transition-group(previous-old),
-    ::view-transition-group(next),
-    ::view-transition-group(next-old) {
-      width: 100% !important;
-      height: 100% !important;
-      transform: none !important;
-    }
-
-    ::view-transition-old(previous),
-    ::view-transition-old(previous-old),
-    ::view-transition-old(next),
-    ::view-transition-old(next-old) {
-      animation: var(--vt-duration-viewer-navigation) fadeOut forwards;
-      transform-origin: center;
-      height: 100%;
-      width: 100%;
-      object-fit: contain;
-      overflow: hidden;
-    }
-
-    ::view-transition-new(previous),
-    ::view-transition-new(previous-new),
-    ::view-transition-new(next),
-    ::view-transition-new(next-new) {
-      animation: var(--vt-duration-viewer-navigation) fadeIn forwards;
-      transform-origin: center;
-      height: 100%;
-      width: 100%;
-      object-fit: contain;
-    }
-  }
-}

web/src/lib/actions/zoom-image.ts

@@ -1,4 +1,5 @@
 import { assetViewerManager } from '$lib/managers/asset-viewer-manager.svelte';
+import type { ZoomImageWheelState } from '@zoom-image/core';
 import { createZoomImageWheel } from '@zoom-image/core';
 
 // Minimal touch shape — avoids importing DOM TouchEvent which isn't available in all TS targets.
@@ -8,22 +9,66 @@ type TouchEventLike = {
 };
 const asTouchEvent = (event: Event) => event as unknown as TouchEventLike;
 
+export const MAX_ZOOM = 10;
+
 export const zoomImageAction = (node: HTMLElement, options?: { zoomTarget?: HTMLElement }) => {
-  const zoomInstance = createZoomImageWheel(node, {
+  let zoomInstance = createZoomImageWheel(node, {
-    maxZoom: 10,
+    maxZoom: MAX_ZOOM,
     initialState: assetViewerManager.zoomState,
     zoomTarget: options?.zoomTarget,
   });
 
-  const unsubscribes = [
+  let needsResync = false;
-    assetViewerManager.on({ ZoomChange: (state) => zoomInstance.setState(state) }),
+
-    zoomInstance.subscribe(({ state }) => assetViewerManager.onZoomChange(state)),
+  const createInstance = () => {
-  ];
+    zoomInstance.cleanup();
+    zoomInstance = createZoomImageWheel(node, {
+      maxZoom: MAX_ZOOM,
+      initialState: { ...assetViewerManager.zoomState, enable: true },
+      zoomTarget: options?.zoomTarget,
+    });
+    node.style.overflow = 'visible';
+    unsubscribeStore?.();
+    unsubscribeStore = zoomInstance.subscribe(({ state }) => assetViewerManager.onZoomChange(state));
+    needsResync = false;
+  };
+
+  const applyDirectTransform = (state: ZoomImageWheelState) => {
+    const target = options?.zoomTarget ?? node.querySelector('img');
+    if (target) {
+      (target as HTMLElement).style.transformOrigin = '0 0';
+      (target as HTMLElement).style.transform =
+        `translate(${state.currentPositionX}px, ${state.currentPositionY}px) scale(${state.currentZoom})`;
+      needsResync = true;
+    }
+  };
+
+  const resyncIfNeeded = () => {
+    if (needsResync) {
+      createInstance();
+    }
+  };
+
+  let unsubscribeStore = zoomInstance.subscribe(({ state }) => assetViewerManager.onZoomChange(state));
+
+  const unsubscribeManager = assetViewerManager.on({
+    ZoomChange: (state) => zoomInstance.setState(state),
+    DirectTransform: (state) => applyDirectTransform(state),
+    ZoomEnabled: (enabled) => {
+      if (enabled && needsResync) {
+        createInstance();
+      } else {
+        zoomInstance.setState({ enable: enabled });
+      }
+    },
+  });
 
   const controller = new AbortController();
   const { signal } = controller;
 
   node.addEventListener('pointerdown', () => assetViewerManager.cancelZoomAnimation(), { capture: true, signal });
+  node.addEventListener('pointerdown', resyncIfNeeded, { signal });
+  node.addEventListener('wheel', resyncIfNeeded, { signal });
 
   // Intercept events in capture phase to prevent zoom-image from seeing interactions on
   // overlay elements (e.g. OCR text boxes), preserving browser defaults like text selection.
@@ -141,9 +186,8 @@ export const zoomImageAction = (node: HTMLElement, options?: { zoomTarget?: HTML
       if (options?.zoomTarget) {
         options.zoomTarget.style.willChange = '';
       }
-      for (const unsubscribe of unsubscribes) {
+      unsubscribeManager();
-        unsubscribe();
+      unsubscribeStore?.();
-      }
       zoomInstance.cleanup();
     },
   };

web/src/lib/components/AdaptiveImage.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">
   import { thumbhash } from '$lib/actions/thumbhash';
   import AlphaBackground from '$lib/components/AlphaBackground.svelte';
-  import Letterboxes from '$lib/components/asset-viewer/letterboxes.svelte';
   import BrokenAsset from '$lib/components/assets/broken-asset.svelte';
   import DelayedLoadingSpinner from '$lib/components/DelayedLoadingSpinner.svelte';
   import ImageLayer from '$lib/components/ImageLayer.svelte';
@@ -19,10 +18,6 @@
     sharedLink?: SharedLinkResponseDto;
     objectFit?: 'contain' | 'cover';
     container: Size;
-    showLetterboxes?: boolean;
-    transitionName?: string | null | undefined;
-    letterboxTransitionName?: string | undefined;
-    imageClass?: string;
     onUrlChange?: (url: string) => void;
     onImageReady?: () => void;
     onError?: () => void;
@@ -46,10 +41,6 @@
     sharedLink,
     objectFit = 'contain',
     container,
-    showLetterboxes = true,
-    transitionName,
-    letterboxTransitionName,
-    imageClass,
     onUrlChange,
     onImageReady,
     onError,
@@ -175,20 +166,10 @@
   });
 </script>
 
-<div class="relative h-full w-full overflow-hidden" bind:this={ref}>
+<div class="relative h-full w-full overflow-hidden will-change-transform" bind:this={ref}>
   {@render backdrop?.()}
 
-  <Letterboxes {letterboxTransitionName} show={showLetterboxes} {scaledDimensions} {container} />
+  <div class="absolute inset-0 pointer-events-none" style:left style:top style:width style:height>
-
-  <div
-    class={['absolute inset-0 pointer-events-none', imageClass]}
-    style:left
-    style:top
-    style:width
-    style:height
-    style:view-transition-name={transitionName}
-    data-transition-name={transitionName}
-  >
     {#if show.alphaBackground}
       <AlphaBackground />
     {/if}

web/src/lib/components/asset-viewer/asset-viewer-nav-bar.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import { goto } from '$app/navigation';
-  import { page } from '$app/state';
   import ActionMenuItem from '$lib/components/ActionMenuItem.svelte';
   import type { OnAction, PreAction } from '$lib/components/asset-viewer/actions/action';
   import AddToStackAction from '$lib/components/asset-viewer/actions/add-to-stack-action.svelte';
@@ -18,19 +17,15 @@
   import UnstackAction from '$lib/components/asset-viewer/actions/unstack-action.svelte';
   import ButtonContextMenu from '$lib/components/shared-components/context-menu/button-context-menu.svelte';
   import MenuOption from '$lib/components/shared-components/context-menu/menu-option.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { featureFlagsManager } from '$lib/managers/feature-flags-manager.svelte';
   import { languageManager } from '$lib/managers/language-manager.svelte';
   import { Route } from '$lib/route';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
-  import { navigateToTimeline } from '$lib/utils/transition-utils';
   import { getGlobalActions } from '$lib/services/app.service';
   import { getAssetActions } from '$lib/services/asset.service';
   import { isFaceEditMode } from '$lib/stores/face-edit.svelte';
   import { user } from '$lib/stores/user.store';
   import { getSharedLink, withoutIcons } from '$lib/utils';
   import type { OnUndoDelete } from '$lib/utils/actions';
-  import { isPhotosRoute } from '$lib/utils/navigation';
   import { toTimelineAsset } from '$lib/utils/timeline-util';
   import {
     AssetTypeEnum,
@@ -189,21 +184,7 @@
             {#if !asset.isArchived && !asset.isTrashed}
               <MenuOption
                 icon={mdiImageSearch}
-                onClick={async () => {
+                onClick={() => goto(Route.photos({ at: stack?.primaryAssetId ?? asset.id }))}
-                  const assetId = stack?.primaryAssetId ?? asset.id;
-                  if (isPhotosRoute(page.route.id) && viewTransitionManager.isSupported()) {
-                    const transitionReady = eventManager.untilNext('ViewerCloseTransitionReady');
-                    eventManager.emit('ViewerCloseTransition', { id: assetId });
-                    await transitionReady;
-                    await goto(Route.photos({ at: assetId }));
-                    return;
-                  }
-
-                  navigateToTimeline(assetId, {
-                    types: ['timeline'],
-                    prepareOldSnapshot: () => eventManager.emit('ViewerOpenTransition'),
-                  });
-                }}
                 text={$t('view_in_timeline')}
               />
             {/if}

web/src/lib/components/asset-viewer/asset-viewer.svelte

@@ -1,9 +1,3 @@
-<script module lang="ts">
-  const useSplitNavTransitions =
-    typeof document !== 'undefined' &&
-    getComputedStyle(document.documentElement).getPropertyValue('--immich-split-viewer-nav').trim() === 'enabled';
-</script>
-
 <script lang="ts">
   import { browser } from '$app/environment';
   import { focusTrap } from '$lib/actions/focus-trap';
@@ -19,7 +13,6 @@
   import { authManager } from '$lib/managers/auth-manager.svelte';
   import { editManager, EditToolType } from '$lib/managers/edit/edit-manager.svelte';
   import { eventManager } from '$lib/managers/event-manager.svelte';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
   import { getAssetActions } from '$lib/services/asset.service';
   import { assetViewingStore } from '$lib/stores/asset-viewing.store';
   import { isFaceEditMode } from '$lib/stores/face-edit.svelte';
@@ -34,7 +27,6 @@
   import { InvocationTracker } from '$lib/utils/invocationTracker';
   import { SlideshowHistory } from '$lib/utils/slideshow-history';
   import { toTimelineAsset } from '$lib/utils/timeline-util';
-  import { crossfadeViewerContent, removeCrossfadeOverlay } from '$lib/utils/transition-utils';
   import {
     AssetTypeEnum,
     getAssetInfo,
@@ -48,7 +40,7 @@
   import { onDestroy, onMount, untrack } from 'svelte';
   import type { SwipeCustomEvent } from 'svelte-gestures';
   import { t } from 'svelte-i18n';
-  import { fly, slide } from 'svelte/transition';
+  import { fly } from 'svelte/transition';
   import Thumbnail from '../assets/thumbnail/thumbnail.svelte';
   import ActivityStatus from './activity-status.svelte';
   import ActivityViewer from './activity-viewer.svelte';
@@ -97,14 +89,13 @@
     onRandom,
   }: Props = $props();
 
-  const { setAssetId, invisible } = assetViewingStore;
+  const { setAssetId } = assetViewingStore;
   const {
     restartProgress: restartSlideshowProgress,
     stopProgress: stopSlideshowProgress,
     slideshowNavigation,
     slideshowState,
     slideshowRepeat,
-    slideshowTransition,
   } = slideshowStore;
   const stackThumbnailSize = 60;
   const stackSelectedThumbnailSize = 65;
@@ -118,10 +109,6 @@
   let sharedLink = getSharedLink();
   let fullscreenElement = $state<Element>();
 
-  let slideShowPlaying = $derived($slideshowState === SlideshowState.PlaySlideshow);
-  let slideShowAscending = $derived($slideshowNavigation === SlideshowNavigation.AscendingOrder);
-  let slideShowShuffle = $derived($slideshowNavigation === SlideshowNavigation.Shuffle);
-
   let playOriginalVideo = $state($alwaysLoadOriginalVideo);
   let slideshowStartAssetId = $state<string>();
 
@@ -155,40 +142,35 @@
     }
   };
 
-  let transitionName = $state<string | undefined>('hero');
+  const onAssetUpdate = (updatedAsset: AssetResponseDto) => {
-  let letterboxTransitionName = $state<string | undefined>(undefined);
+    if (asset.id === updatedAsset.id) {
-  let detailPanelTransitionName = $state<string | undefined>(undefined);
+      cursor = { ...cursor, current: updatedAsset };
+    }
+  };
 
-  let unsubscribes: (() => void)[] = [];
   onMount(() => {
     syncAssetViewerOpenClass(true);
+    const slideshowStateUnsubscribe = slideshowState.subscribe((value) => {
+      if (value === SlideshowState.PlaySlideshow) {
+        slideshowHistory.reset();
+        slideshowHistory.queue(toTimelineAsset(asset));
+        handlePromiseError(handlePlaySlideshow());
+      } else if (value === SlideshowState.StopSlideshow) {
+        handlePromiseError(handleStopSlideshow());
+      }
+    });
 
-    const addInfoTransition = () => {
+    const slideshowNavigationUnsubscribe = slideshowNavigation.subscribe((value) => {
-      detailPanelTransitionName = 'info';
+      if (value === SlideshowNavigation.Shuffle) {
-      transitionName = 'hero';
+        slideshowHistory.reset();
+        slideshowHistory.queue(toTimelineAsset(asset));
+      }
+    });
+
+    return () => {
+      slideshowStateUnsubscribe();
+      slideshowNavigationUnsubscribe();
     };
-
-    unsubscribes.push(
-      eventManager.on({
-        ViewerOpenTransition: addInfoTransition,
-        ViewerCloseTransition: addInfoTransition,
-      }),
-      slideshowState.subscribe((value) => {
-        if (value === SlideshowState.PlaySlideshow) {
-          slideshowHistory.reset();
-          slideshowHistory.queue(toTimelineAsset(asset));
-          handlePromiseError(handlePlaySlideshow());
-        } else if (value === SlideshowState.StopSlideshow) {
-          handlePromiseError(handleStopSlideshow());
-        }
-      }),
-      slideshowNavigation.subscribe((value) => {
-        if (value === SlideshowNavigation.Shuffle) {
-          slideshowHistory.reset();
-          slideshowHistory.queue(toTimelineAsset(asset));
-        }
-      }),
-    );
   });
 
   onDestroy(() => {
@@ -197,16 +179,10 @@
     isFaceEditMode.value = false;
     syncAssetViewerOpenClass(false);
     preloadManager.destroy();
-
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
   });
 
   const closeViewer = () => {
-    transitionName = 'hero';
+    onClose?.(asset);
-    const id = stack?.primaryAssetId ?? asset.id;
-    onClose?.({ ...asset, id });
   };
 
   const closeEditor = async () => {
@@ -218,132 +194,65 @@
     assetViewerManager.closeEditor();
   };
 
-  const getTransitionName = (kind: 'old' | 'new', direction: string | null | undefined) => {
-    if (direction === 'previous' || direction === 'next') {
-      return useSplitNavTransitions ? `${direction}-${kind}` : direction;
-    }
-    return direction ?? undefined;
-  };
-
-  const clearTransitionNames = () => {
-    detailPanelTransitionName = undefined;
-    transitionName = undefined;
-    letterboxTransitionName = undefined;
-  };
-
-  const startTransition = async (
-    types: string[],
-    targetTransition: string | null,
-    navigateFn: () => Promise<boolean>,
-  ) => {
-    const oldName = getTransitionName('old', targetTransition);
-    const newName = getTransitionName('new', targetTransition);
-
-    let result = false;
-
-    await viewTransitionManager.startTransition({
-      types,
-      prepareOldSnapshot: () => {
-        transitionName = oldName;
-        letterboxTransitionName = targetTransition ? `${targetTransition}-old` : undefined;
-        detailPanelTransitionName = 'detail-panel';
-      },
-      performUpdate: async (signal) => {
-        const ready = eventManager.untilNext('ViewerOpenTransitionReady', { signal });
-        result = await navigateFn();
-        await ready;
-      },
-      prepareNewSnapshot: () => {
-        transitionName = newName;
-        letterboxTransitionName = targetTransition ? `${targetTransition}-new` : undefined;
-      },
-      onFinished: clearTransitionNames,
-    });
-
-    return result;
-  };
-
-  const completeNavigation = async (order: 'previous' | 'next', skipTransition: boolean) => {
-    preloadManager.cancelBeforeNavigation(order);
-    const skipped = viewTransitionManager.skipTransitions();
-    const canTransition = viewTransitionManager.isSupported() && !skipped && !skipTransition;
-
-    let navigate: () => Promise<boolean>;
-    let types: string[];
-    let targetTransition: string | null;
-
-    if (slideShowPlaying && slideShowShuffle) {
-      navigate = async () => {
-        let next = order === 'previous' ? slideshowHistory.previous() : slideshowHistory.next();
-        if (!next) {
-          const asset = await onRandom?.();
-          if (asset) {
-            slideshowHistory.queue(asset);
-            next = true;
-          }
-        }
-        return next;
-      };
-      types = ['slideshow'];
-      targetTransition = null;
-    } else {
-      navigate = async () => {
-        const target = order === 'previous' ? previousAsset : nextAsset;
-        return navigateToAsset(target);
-      };
-      types = slideShowPlaying ? ['slideshow'] : ['viewer-nav'];
-      targetTransition = slideShowPlaying ? null : order;
-    }
-
-    const targetAsset = order === 'previous' ? previousAsset : nextAsset;
-    const slideshowAllowsTransition = !slideShowPlaying || $slideshowTransition;
-    const useTransition = canTransition && slideshowAllowsTransition && (slideShowShuffle || !!targetAsset);
-    const hasNext = useTransition ? await startTransition(types, targetTransition, navigate) : await navigate();
-
-    if (!slideShowPlaying) {
-      return;
-    }
-
-    if (hasNext) {
-      $restartSlideshowProgress = true;
-      return;
-    }
-
-    if ($slideshowRepeat && slideshowStartAssetId) {
-      await setAssetId(slideshowStartAssetId);
-      $restartSlideshowProgress = true;
-      return;
-    }
-
-    await handleStopSlideshow();
-  };
-
   const tracker = new InvocationTracker();
-  let navigating = $state(false);
+  const navigateAsset = (order?: 'previous' | 'next') => {
-  const navigateAsset = (order?: 'previous' | 'next', skipTransition: boolean = false) => {
     if (!order) {
-      if (slideShowPlaying) {
+      if ($slideshowState === SlideshowState.PlaySlideshow) {
-        order = slideShowAscending ? 'previous' : 'next';
+        order = $slideshowNavigation === SlideshowNavigation.AscendingOrder ? 'previous' : 'next';
       } else {
         return;
       }
     }
 
+    preloadManager.cancelBeforeNavigation(order);
+
     if (tracker.isActive()) {
       return;
     }
 
-    navigating = true;
+    void tracker.invoke(async () => {
-    void tracker.invoke(
+      const isShuffle =
-      () => completeNavigation(order, skipTransition),
+        $slideshowState === SlideshowState.PlaySlideshow && $slideshowNavigation === SlideshowNavigation.Shuffle;
-      (error: unknown) => handleError(error, $t('error_while_navigating')),
+
-      () => {
+      let hasNext: boolean;
-        navigating = false;
+
-        eventManager.emit('ViewerAfterNavigate');
+      if (isShuffle) {
-      },
+        hasNext = order === 'previous' ? slideshowHistory.previous() : slideshowHistory.next();
-    );
+        if (!hasNext) {
+          const asset = await onRandom?.();
+          if (asset) {
+            slideshowHistory.queue(asset);
+            hasNext = true;
+          }
+        }
+      } else {
+        hasNext =
+          order === 'previous' ? await navigateToAsset(cursor.previousAsset) : await navigateToAsset(cursor.nextAsset);
+      }
+
+      if ($slideshowState !== SlideshowState.PlaySlideshow) {
+        return;
+      }
+
+      if (hasNext) {
+        $restartSlideshowProgress = true;
+        return;
+      }
+
+      if ($slideshowRepeat && slideshowStartAssetId) {
+        await setAssetId(slideshowStartAssetId);
+        $restartSlideshowProgress = true;
+        return;
+      }
+
+      await handleStopSlideshow();
+    }, $t('error_while_navigating'));
   };
 
+  /**
+   * Slide show mode
+   */
+
   let assetViewerHtmlElement = $state<HTMLElement>();
 
   const slideshowHistory = new SlideshowHistory((asset) => {
@@ -368,11 +277,10 @@
 
   const handleStopSlideshow = async () => {
     try {
-      if (!document.fullscreenElement) {
+      if (document.fullscreenElement) {
-        return;
+        document.body.style.cursor = '';
+        await document.exitFullscreen();
       }
-      document.body.style.cursor = '';
-      await document.exitFullscreen();
     } catch (error) {
       handleError(error, $t('errors.unable_to_exit_fullscreen'));
     } finally {
@@ -381,24 +289,11 @@
     }
   };
 
-  const handleStackedAssetMouseEnter = (stackedAsset: AssetResponseDto) => {
+  const handleStackedAssetMouseEvent = (isMouseOver: boolean, stackedAsset: AssetResponseDto) => {
-    if ((previewStackedAsset ?? cursor.current).id === stackedAsset.id) {
+    previewStackedAsset = isMouseOver ? stackedAsset : undefined;
-      return;
+    if (isMouseOver) {
+      isFaceEditMode.value = false;
     }
-
-    isFaceEditMode.value = false;
-    void crossfadeViewerContent(() => {
-      previewStackedAsset = stackedAsset;
-    });
-  };
-
-  const handleStackSlideshowMouseLeave = () => {
-    if (!previewStackedAsset) {
-      return;
-    }
-
-    removeCrossfadeOverlay();
-    previewStackedAsset = undefined;
   };
 
   const handlePreAction = (action: Action) => {
@@ -499,24 +394,15 @@
     if (cursor.current.id === lastCursor?.current.id) {
       return;
     }
-
     if (lastCursor) {
-      previewStackedAsset = undefined;
-      ocrManager.showOverlay = false;
       preloadManager.updateAfterNavigation(lastCursor, cursor, sharedLink);
-      lastCursor = cursor;
-      return;
     }
-    preloadManager.initializePreloads(cursor, sharedLink);
+    if (!lastCursor) {
+      preloadManager.initializePreloads(cursor, sharedLink);
+    }
     lastCursor = cursor;
   });
 
-  const onAssetUpdate = (update: AssetResponseDto) => {
-    if (asset.id === update.id) {
-      cursor = { ...cursor, current: update };
-    }
-  };
-
   const viewerKind = $derived.by(() => {
     if (previewStackedAsset) {
       return previewStackedAsset.type === AssetTypeEnum.Image ? 'PhotoViewer' : 'StackVideoViewer';
@@ -587,17 +473,13 @@
 
 <section
   id="immich-asset-viewer"
-  class="fixed inset-s-0 top-0 z-10 grid size-full grid-cols-4 grid-rows-[64px_1fr] overflow-hidden bg-black touch-none"
+  class="fixed start-0 top-0 grid size-full grid-cols-4 grid-rows-[64px_1fr] overflow-hidden bg-black touch-none"
-  class:invisible={$invisible}
-  data-navigating={navigating || undefined}
   use:focusTrap
   bind:this={assetViewerHtmlElement}
 >
+  <!-- Top navigation bar -->
   {#if $slideshowState === SlideshowState.None && !assetViewerManager.isShowEditor}
-    <div
+    <div class="col-span-4 col-start-1 row-span-1 row-start-1 transition-transform">
-      class="col-span-4 col-start-1 row-span-1 row-start-1 transition-transform"
-      style:view-transition-name="exclude"
-    >
       <AssetViewerNavBar
         {asset}
         {album}
@@ -608,7 +490,7 @@
         onAction={handleAction}
         {onUndoDelete}
         onPlaySlideshow={() => ($slideshowState = SlideshowState.PlaySlideshow)}
-        onClose={onClose ? closeViewer : undefined}
+        onClose={onClose ? () => onClose(asset) : undefined}
         {playOriginalVideo}
         {setPlayOriginalVideo}
       />
@@ -629,21 +511,16 @@
   {/if}
 
   {#if $slideshowState === SlideshowState.None && showNavigation && !assetViewerManager.isShowEditor && !isFaceEditMode.value && previousAsset}
-    <div
+    <div class="my-auto col-span-1 col-start-1 row-span-full row-start-1 justify-self-start">
-      data-test-id="previous-asset"
-      class="my-auto col-span-1 col-start-1 row-span-full row-start-1 justify-self-start"
-      style:view-transition-name="exclude-leftbutton"
-    >
       <PreviousAssetAction onPreviousAsset={() => navigateAsset('previous')} />
     </div>
   {/if}
 
+  <!-- Asset Viewer -->
   <div data-viewer-content class="z-[-1] relative col-start-1 col-span-4 row-start-1 row-span-full">
     {#if viewerKind === 'StackVideoViewer'}
       <VideoViewer
-        {transitionName}
         asset={previewStackedAsset!}
-        assetId={previewStackedAsset!.id}
         cacheKey={previewStackedAsset!.thumbhash}
         projectionType={previewStackedAsset!.exifInfo?.projectionType}
         loopVideo={true}
@@ -656,7 +533,6 @@
       />
     {:else if viewerKind === 'LiveVideoViewer'}
       <VideoViewer
-        {transitionName}
         {asset}
         assetId={asset.livePhotoVideoId!}
         cacheKey={asset.thumbhash}
@@ -668,20 +544,13 @@
         {playOriginalVideo}
       />
     {:else if viewerKind === 'ImagePanaramaViewer'}
-      <ImagePanoramaViewer {asset} {transitionName} {letterboxTransitionName} />
+      <ImagePanoramaViewer {asset} />
     {:else if viewerKind === 'CropArea'}
       <CropArea {asset} />
     {:else if viewerKind === 'PhotoViewer'}
-      <PhotoViewer
+      <PhotoViewer cursor={{ ...cursor, current: asset }} {sharedLink} {onSwipe} />
-        {transitionName}
-        {letterboxTransitionName}
-        cursor={{ ...cursor, current: asset }}
-        {sharedLink}
-        {onSwipe}
-      />
     {:else if viewerKind === 'VideoViewer'}
       <VideoViewer
-        {transitionName}
         {asset}
         cacheKey={asset.thumbhash}
         projectionType={asset.exifInfo?.projectionType}
@@ -715,20 +584,15 @@
   </div>
 
   {#if $slideshowState === SlideshowState.None && showNavigation && !assetViewerManager.isShowEditor && !isFaceEditMode.value && nextAsset}
-    <div
+    <div class="my-auto col-span-1 col-start-4 row-span-full row-start-1 justify-self-end">
-      data-test-id="next-asset"
-      class="my-auto col-span-1 col-start-4 row-span-full row-start-1 justify-self-end"
-      style:view-transition-name="exclude-rightbutton"
-    >
       <NextAssetAction onNextAsset={() => navigateAsset('next')} />
     </div>
   {/if}
 
   {#if showDetailPanel || assetViewerManager.isShowEditor}
     <div
-      transition:slide={{ axis: 'x', duration: 150 }}
+      transition:fly={{ duration: 150 }}
       id="detail-panel"
-      style:view-transition-name={detailPanelTransitionName}
       class="row-start-1 row-span-4 overflow-y-auto transition-all dark:border-l dark:border-s-immich-dark-gray bg-light"
       translate="yes"
     >
@@ -744,14 +608,9 @@
     </div>
   {/if}
 
-  {#if stack && withStacked && !assetViewerManager.isShowEditor && $slideshowState === SlideshowState.None}
+  {#if stack && withStacked && !assetViewerManager.isShowEditor}
     {@const stackedAssets = stack.assets}
-    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div id="stack-slideshow" class="absolute bottom-0 w-full col-span-4 col-start-1 pointer-events-none">
-    <div
-      id="stack-slideshow"
-      class="absolute bottom-0 w-full col-span-4 col-start-1 pointer-events-none"
-      onmouseleave={handleStackSlideshowMouseLeave}
-    >
       <div class="relative flex flex-row no-wrap overflow-x-auto overflow-y-hidden horizontal-scrollbar">
         {#each stackedAssets as stackedAsset (stackedAsset.id)}
           <div
@@ -764,12 +623,11 @@
               dimmed={stackedAsset.id !== asset.id}
               asset={toTimelineAsset(stackedAsset)}
               onClick={() => {
-                removeCrossfadeOverlay();
                 cursor.current = stackedAsset;
                 previewStackedAsset = undefined;
                 isFaceEditMode.value = false;
               }}
-              onMouseEvent={({ isMouseOver }) => isMouseOver && handleStackedAssetMouseEnter(stackedAsset)}
+              onMouseEvent={({ isMouseOver }) => handleStackedAssetMouseEvent(isMouseOver, stackedAsset)}
               readonly
               thumbnailSize={stackedAsset.id === asset.id ? stackSelectedThumbnailSize : stackThumbnailSize}
               showStackedIcon={false}

web/src/lib/components/asset-viewer/editor/transform-tool/crop-area.svelte

@@ -7,7 +7,6 @@
   import { Icon } from '@immich/ui';
   import { onMount } from 'svelte';
   import { t } from 'svelte-i18n';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
 
   interface Props {
     asset: AssetResponseDto;
@@ -75,8 +74,6 @@
       alt={$getAltText(toTimelineAsset(asset))}
       class="h-full select-none transition-transform motion-reduce:transition-none"
       style:transform={imageTransform}
-      onload={() => eventManager.emit('ViewerOpenTransitionReady')}
-      onerror={() => eventManager.emit('ViewerOpenTransitionReady')}
     />
     <div
       class={[

web/src/lib/components/asset-viewer/image-panorama-viewer.svelte

@@ -4,14 +4,13 @@
   import { AssetMediaSize, viewAsset, type AssetResponseDto } from '@immich/sdk';
   import { LoadingSpinner } from '@immich/ui';
   import { t } from 'svelte-i18n';
+  import { fade } from 'svelte/transition';
 
   type Props = {
-    transitionName?: string;
-    letterboxTransitionName?: string;
     asset: AssetResponseDto;
   };
 
-  let { transitionName, letterboxTransitionName, asset }: Props = $props();
+  let { asset }: Props = $props();
 
   const assetId = $derived(asset.id);
 
@@ -21,16 +20,11 @@
   };
 </script>
 
-<div class="flex h-dvh w-dvw select-none place-content-center place-items-center">
+<div transition:fade={{ duration: 150 }} class="flex h-full select-none place-content-center place-items-center">
   {#await Promise.all([loadAssetData(assetId), import('./photo-sphere-viewer-adapter.svelte')])}
     <LoadingSpinner />
   {:then [data, { default: PhotoSphereViewer }]}
-    <PhotoSphereViewer
+    <PhotoSphereViewer panorama={data} originalPanorama={getAssetUrl({ asset, forceOriginal: true })} />
-      {transitionName}
-      {letterboxTransitionName}
-      panorama={data}
-      originalPanorama={getAssetUrl({ asset, forceOriginal: true })}
-    />
   {:catch}
     {$t('errors.failed_to_load_asset')}
   {/await}

web/src/lib/components/asset-viewer/letterboxes.svelte

@@ -1,68 +0,0 @@
-<script lang="ts">
-  interface Props {
-    letterboxTransitionName?: string | undefined;
-    show?: boolean;
-    scaledDimensions: {
-      width: number;
-      height: number;
-    };
-    container: {
-      width: number;
-      height: number;
-    };
-  }
-
-  let { letterboxTransitionName, show = true, scaledDimensions, container }: Props = $props();
-
-  const shouldShowLetterboxes = $derived(show && !!letterboxTransitionName);
-
-  const letterboxes = $derived.by(() => {
-    const { width, height } = scaledDimensions;
-    const horizontalOffset = (container.width - width) / 2;
-    const verticalOffset = (container.height - height) / 2;
-
-    return [
-      {
-        name: 'letterbox-left',
-        width: horizontalOffset + 'px',
-        height: container.height + 'px',
-        left: '0px',
-        top: '0px',
-      },
-      {
-        name: 'letterbox-right',
-        width: horizontalOffset + 'px',
-        height: container.height + 'px',
-        left: container.width - horizontalOffset + 'px',
-        top: '0px',
-      },
-      {
-        name: 'letterbox-top',
-        width: width + 'px',
-        height: verticalOffset + 'px',
-        left: horizontalOffset + 'px',
-        top: '0px',
-      },
-      {
-        name: 'letterbox-bottom',
-        width: width + 'px',
-        height: verticalOffset + 'px',
-        left: horizontalOffset + 'px',
-        top: container.height - verticalOffset + 'px',
-      },
-    ];
-  });
-</script>
-
-{#if shouldShowLetterboxes}
-  {#each letterboxes as box (box.name)}
-    <div
-      class="absolute"
-      style:view-transition-name={box.name}
-      style:left={box.left}
-      style:top={box.top}
-      style:width={box.width}
-      style:height={box.height}
-    ></div>
-  {/each}
-{/if}

web/src/lib/components/asset-viewer/photo-sphere-viewer-adapter.svelte

@@ -1,9 +1,7 @@
 <script lang="ts">
   import { shortcuts } from '$lib/actions/shortcut';
   import AssetViewerEvents from '$lib/components/AssetViewerEvents.svelte';
-  import Letterboxes from '$lib/components/asset-viewer/letterboxes.svelte';
   import { assetViewerManager } from '$lib/managers/asset-viewer-manager.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { ocrManager, type OcrBoundingBox } from '$lib/stores/ocr.svelte';
   import { boundingBoxesArray, type Faces } from '$lib/stores/people.store';
   import { alwaysLoadOriginalFile } from '$lib/stores/preferences.store';
@@ -43,8 +41,6 @@
     'flex items-center justify-center text-white bg-black/50 cursor-text pointer-events-auto whitespace-pre-wrap wrap-break-word select-text';
 
   type Props = {
-    transitionName?: string;
-    letterboxTransitionName?: string;
     panorama: string | { source: string };
     originalPanorama?: string | { source: string };
     adapter?: AdapterConstructor | [AdapterConstructor, unknown];
@@ -52,21 +48,11 @@
     navbar?: boolean;
   };
 
-  let {
+  let { panorama, originalPanorama, adapter = EquirectangularAdapter, plugins = [], navbar = false }: Props = $props();
-    transitionName,
-    letterboxTransitionName,
-    panorama,
-    originalPanorama,
-    adapter = EquirectangularAdapter,
-    plugins = [],
-    navbar = false,
-  }: Props = $props();
 
   let container: HTMLDivElement | undefined = $state();
   let viewer: Viewer;
 
-  const fullscreenDimensions = { width: globalThis.innerWidth || 0, height: globalThis.innerHeight || 0 };
-
   let animationInProgress: { cancel: () => void } | undefined;
   let previousFaces: Faces[] = [];
 
@@ -224,7 +210,6 @@
       zoomSpeed: 0.5,
       fisheye: false,
     });
-    viewer.addEventListener('ready', () => eventManager.emit('ViewerOpenTransitionReady'), { once: true });
     const resolutionPlugin = viewer.getPlugin<ResolutionPlugin>(ResolutionPlugin);
     const zoomHandler = ({ zoomLevel }: events.ZoomUpdatedEvent) => {
       // zoomLevel is 0-100
@@ -269,15 +254,7 @@
 <AssetViewerEvents {onZoom} />
 
 <svelte:document use:shortcuts={[{ shortcut: { key: 'z' }, onShortcut: onZoom, preventDefault: true }]} />
-<div
+<div class="h-full w-full mb-0" bind:this={container}></div>
-  id="sphere"
-  class="h-full w-full h-dvh w-dvw mb-0"
-  bind:this={container}
-  style:view-transition-name={transitionName}
-></div>
-
-<!-- Zero-sized letterboxes for view transitions from/to regular photos -->
-<Letterboxes {letterboxTransitionName} scaledDimensions={fullscreenDimensions} container={fullscreenDimensions} />
 
 <style>
   /* Reset the default tooltip styling */

web/src/lib/components/asset-viewer/photo-viewer.svelte

@@ -5,10 +5,10 @@
   import AdaptiveImage from '$lib/components/AdaptiveImage.svelte';
   import FaceEditor from '$lib/components/asset-viewer/face-editor/face-editor.svelte';
   import OcrBoundingBox from '$lib/components/asset-viewer/ocr-bounding-box.svelte';
+  import ZoomMinimap from '$lib/components/asset-viewer/zoom-minimap.svelte';
   import AssetViewerEvents from '$lib/components/AssetViewerEvents.svelte';
   import { assetViewerManager } from '$lib/managers/asset-viewer-manager.svelte';
   import { castManager } from '$lib/managers/cast-manager.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { isEditFacesPanelOpen, isFaceEditMode } from '$lib/stores/face-edit.svelte';
   import { ocrManager } from '$lib/stores/ocr.svelte';
   import { boundingBoxesArray, type Faces } from '$lib/stores/people.store';
@@ -30,26 +30,14 @@
     cursor: AssetCursor;
     element?: HTMLDivElement;
     sharedLink?: SharedLinkResponseDto;
-    transitionName?: string;
+    onReady?: () => void;
-    letterboxTransitionName?: string;
     onError?: () => void;
     onSwipe?: (event: SwipeCustomEvent) => void;
   };
 
-  let {
+  let { cursor, element = $bindable(), sharedLink, onReady, onError, onSwipe }: Props = $props();
-    cursor,
-    element = $bindable(),
-    sharedLink,
-    transitionName,
-    letterboxTransitionName,
-    onError,
-    onSwipe,
-  }: Props = $props();
 
   const { slideshowState, slideshowLook } = slideshowStore;
-  const objectFit = $derived(
-    $slideshowState !== SlideshowState.None && $slideshowLook === SlideshowLook.Cover ? 'cover' : 'contain',
-  );
   const asset = $derived(cursor.current);
 
   let visibleImageReady: boolean = $state(false);
@@ -194,23 +182,20 @@
     {asset}
     {sharedLink}
     {container}
-    {objectFit}
+    objectFit={$slideshowState !== SlideshowState.None && $slideshowLook === SlideshowLook.Cover ? 'cover' : 'contain'}
     {onUrlChange}
     onImageReady={() => {
       visibleImageReady = true;
-      eventManager.emit('ViewerOpenTransitionReady');
+      onReady?.();
     }}
     onError={() => {
       onError?.();
-      eventManager.emit('ViewerOpenTransitionReady');
+      onReady?.();
     }}
     bind:imgRef={assetViewerManager.imgRef}
     bind:imgNaturalSize={imageDimensions}
     bind:imgScaledSize={scaledDimensions}
     bind:ref={adaptiveImage}
-    {transitionName}
-    {letterboxTransitionName}
-    showLetterboxes={!blurredSlideshow}
   >
     {#snippet backdrop()}
       {#if blurredSlideshow}
@@ -263,6 +248,8 @@
     {/snippet}
   </AdaptiveImage>
 
+  <ZoomMinimap {containerWidth} {containerHeight} {asset} {sharedLink} />
+
   {#if isFaceEditMode.value && assetViewerManager.imgRef}
     <FaceEditor imageSize={imageDimensions} {containerWidth} {containerHeight} assetId={asset.id} />
   {/if}

web/src/lib/components/asset-viewer/video-native-viewer.svelte

@@ -3,7 +3,6 @@
   import VideoRemoteViewer from '$lib/components/asset-viewer/video-remote-viewer.svelte';
   import { assetViewerFadeDuration } from '$lib/constants';
   import { castManager } from '$lib/managers/cast-manager.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { isFaceEditMode } from '$lib/stores/face-edit.svelte';
   import {
     autoPlayVideo,
@@ -20,7 +19,6 @@
   import { fade } from 'svelte/transition';
 
   type Props = {
-    transitionName?: string;
     assetId: string;
     imageSize: Size;
     loopVideo: boolean;
@@ -34,7 +32,6 @@
   };
 
   let {
-    transitionName,
     assetId,
     imageSize,
     loopVideo,
@@ -64,6 +61,7 @@
   });
 
   $effect(() => {
+    // reactive on `assetFileUrl` changes
     if (assetFileUrl) {
       hasFocused = false;
       videoPlayer?.load();
@@ -144,7 +142,6 @@
       </div>
     {:else}
       <video
-        style:view-transition-name={transitionName}
         bind:this={videoPlayer}
         loop={$loopVideoPreference && loopVideo}
         autoplay={$autoPlayVideo}
@@ -153,7 +150,6 @@
         disablePictureInPicture
         class="h-full object-contain"
         {...useSwipe(onSwipe)}
-        onloadedmetadata={() => eventManager.emit('ViewerOpenTransitionReady')}
         oncanplay={(e) => handleCanPlay(e.currentTarget)}
         onended={onVideoEnded}
         onvolumechange={(e) => ($videoViewerMuted = e.currentTarget.muted)}

web/src/lib/components/asset-viewer/video-panorama-viewer.svelte

@@ -3,13 +3,13 @@
   import type { AssetResponseDto } from '@immich/sdk';
   import { LoadingSpinner } from '@immich/ui';
   import { t } from 'svelte-i18n';
+  import { fade } from 'svelte/transition';
 
   interface Props {
-    transitionName?: string;
     asset: AssetResponseDto;
   }
 
-  const { asset, transitionName }: Props = $props();
+  const { asset }: Props = $props();
 
   const modules = Promise.all([
     import('./photo-sphere-viewer-adapter.svelte').then((module) => module.default),
@@ -19,12 +19,11 @@
   ]);
 </script>
 
-<div class="flex h-full select-none place-content-center place-items-center">
+<div transition:fade={{ duration: 150 }} class="flex h-full select-none place-content-center place-items-center">
   {#await modules}
     <LoadingSpinner />
   {:then [PhotoSphereViewer, adapter, videoPlugin]}
     <PhotoSphereViewer
-      {transitionName}
       panorama={{ source: getAssetPlaybackUrl({ id: asset.id }) }}
       originalPanorama={{ source: getAssetUrl({ asset, forceOriginal: true })! }}
       plugins={[videoPlugin]}

web/src/lib/components/asset-viewer/video-wrapper-viewer.svelte

@@ -5,7 +5,6 @@
   import type { AssetResponseDto } from '@immich/sdk';
 
   type Props = {
-    transitionName?: string;
     asset: AssetResponseDto;
     assetId?: string;
     projectionType: string | null | undefined;
@@ -20,7 +19,6 @@
   };
 
   let {
-    transitionName,
     asset,
     assetId,
     projectionType,
@@ -38,10 +36,9 @@
 </script>
 
 {#if projectionType === ProjectionType.EQUIRECTANGULAR}
-  <VideoPanoramaViewer {transitionName} {asset} />
+  <VideoPanoramaViewer {asset} />
 {:else}
   <VideoNativeViewer
-    {transitionName}
     {loopVideo}
     {cacheKey}
     assetId={effectiveAssetId}

web/src/lib/components/asset-viewer/zoom-minimap.svelte

@@ -0,0 +1,272 @@
+<script lang="ts">
+  import { MAX_ZOOM } from '$lib/actions/zoom-image';
+  import { assetViewerManager } from '$lib/managers/asset-viewer-manager.svelte';
+  import { getAssetUrls } from '$lib/utils';
+  import { scaleToFit, type ContentMetrics } from '$lib/utils/container-utils';
+  import type { AssetResponseDto, SharedLinkResponseDto } from '@immich/sdk';
+  import { TUNABLES } from '$lib/utils/tunables';
+  import { clamp } from 'lodash-es';
+  import { fade } from 'svelte/transition';
+
+  interface Props {
+    containerWidth: number;
+    containerHeight: number;
+    asset: AssetResponseDto;
+    sharedLink?: SharedLinkResponseDto;
+  }
+
+  let { containerWidth, containerHeight, asset, sharedLink }: Props = $props();
+
+  const MINIMAP_MAX = 192;
+  const MINIMAP_MIN = 100;
+  const minimapSize = $derived(clamp(Math.min(containerWidth, containerHeight) * 0.25, MINIMAP_MIN, MINIMAP_MAX));
+
+  const thumbnailUrl = $derived(getAssetUrls(asset, sharedLink).thumbnail);
+
+  const imageDimensions = $derived({
+    width: asset.width && asset.width > 0 ? asset.width : 1,
+    height: asset.height && asset.height > 0 ? asset.height : 1,
+  });
+
+  const container = $derived({ width: containerWidth, height: containerHeight });
+
+  // Scale the full container into the minimap square
+  const containerInMinimap = $derived(scaleToFit(container, { width: minimapSize, height: minimapSize }));
+  const minimapContainerScale = $derived(containerInMinimap.width / containerWidth);
+  const containerOffsetX = $derived((minimapSize - containerInMinimap.width) / 2);
+  const containerOffsetY = $derived((minimapSize - containerInMinimap.height) / 2);
+
+  // Position the image within the minimap's container representation
+  const imageInMinimap: ContentMetrics = $derived.by(() => {
+    const fitted = scaleToFit(imageDimensions, containerInMinimap);
+    return {
+      contentWidth: fitted.width,
+      contentHeight: fitted.height,
+      offsetX: containerOffsetX + (containerInMinimap.width - fitted.width) / 2,
+      offsetY: containerOffsetY + (containerInMinimap.height - fitted.height) / 2,
+    };
+  });
+
+  const { FADE_DURATION, HIDE_DELAY } = TUNABLES.MINIMAP;
+
+  let isDragging = $state(false);
+  let isDraggingZoom = $state(false);
+  let isRecentActivity = $state(false);
+  let hideTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const resetHideTimer = () => {
+    isRecentActivity = true;
+    if (hideTimer !== null) {
+      clearTimeout(hideTimer);
+    }
+    hideTimer = setTimeout(() => {
+      isRecentActivity = false;
+      hideTimer = null;
+    }, HIDE_DELAY);
+  };
+
+  const isZoomed = $derived(assetViewerManager.zoom > 1);
+  const isVisible = $derived((isZoomed && isRecentActivity) || isDragging || isDraggingZoom);
+
+  $effect(() => {
+    // Track zoom state changes to reset the hide timer
+    const _state = assetViewerManager.zoomState;
+    void _state;
+    if (isZoomed) {
+      resetHideTimer();
+    }
+    return () => {
+      if (hideTimer !== null) {
+        clearTimeout(hideTimer);
+        hideTimer = null;
+      }
+    };
+  });
+
+  const zoomPercent = $derived(((assetViewerManager.zoom - 1) / (MAX_ZOOM - 1)) * 100);
+  const zoomLabel = $derived(assetViewerManager.zoom.toFixed(1) + 'x');
+
+  const clampPanPosition = (positionX: number, positionY: number, zoom: number) => ({
+    positionX: clamp(positionX, -(containerWidth * (zoom - 1)), 0),
+    positionY: clamp(positionY, -(containerHeight * (zoom - 1)), 0),
+  });
+
+  const minimapToContainerPosition = (minimapX: number, minimapY: number) => {
+    const containerX = (minimapX - containerOffsetX) / minimapContainerScale;
+    const containerY = (minimapY - containerOffsetY) / minimapContainerScale;
+    const { currentZoom } = assetViewerManager.zoomState;
+    const rawPositionX = containerWidth / 2 - containerX * currentZoom;
+    const rawPositionY = containerHeight / 2 - containerY * currentZoom;
+    return clampPanPosition(rawPositionX, rawPositionY, currentZoom);
+  };
+
+  const panToMinimapPosition = (event: PointerEvent) => {
+    const target = event.currentTarget as HTMLElement;
+    const rect = target.getBoundingClientRect();
+    const minimapX = event.clientX - rect.left;
+    const minimapY = event.clientY - rect.top;
+    const { positionX, positionY } = minimapToContainerPosition(minimapX, minimapY);
+    assetViewerManager.directTransform({ currentPositionX: positionX, currentPositionY: positionY });
+  };
+
+  const onPointerDown = (event: PointerEvent) => {
+    if (event.button !== 0) {
+      return;
+    }
+    isDragging = true;
+    assetViewerManager.setZoomEnabled(false);
+    (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
+    panToMinimapPosition(event);
+    event.preventDefault();
+    event.stopPropagation();
+  };
+
+  const onPointerMove = (event: PointerEvent) => {
+    if (!isDragging) {
+      return;
+    }
+    panToMinimapPosition(event);
+  };
+
+  const onPointerUp = () => {
+    isDragging = false;
+    assetViewerManager.setZoomEnabled(true);
+  };
+
+  const zoomAroundCenter = (newZoom: number) => {
+    const { currentZoom, currentPositionX, currentPositionY } = assetViewerManager.zoomState;
+    const centerX = containerWidth / 2;
+    const centerY = containerHeight / 2;
+    const zoomTargetX = (centerX - currentPositionX) / currentZoom;
+    const zoomTargetY = (centerY - currentPositionY) / currentZoom;
+    const newPositionX = -zoomTargetX * newZoom + centerX;
+    const newPositionY = -zoomTargetY * newZoom + centerY;
+
+    assetViewerManager.directTransform({
+      currentZoom: newZoom,
+      currentPositionX: clamp(newPositionX, -(containerWidth * (newZoom - 1)), 0),
+      currentPositionY: clamp(newPositionY, -(containerHeight * (newZoom - 1)), 0),
+    });
+  };
+
+  const setZoomFromSlider = (event: PointerEvent) => {
+    const target = event.currentTarget as HTMLElement;
+    const rect = target.getBoundingClientRect();
+    const percent = clamp((event.clientX - rect.left) / rect.width, 0, 1);
+    zoomAroundCenter(1 + percent * (MAX_ZOOM - 1));
+  };
+
+  const WHEEL_ZOOM_RATIO = 0.1;
+
+  const onWheel = (event: WheelEvent) => {
+    event.preventDefault();
+    const { currentZoom } = assetViewerManager.zoomState;
+    const delta = -clamp(event.deltaY, -0.5, 0.5);
+    const newZoom = clamp(currentZoom + delta * WHEEL_ZOOM_RATIO * currentZoom, 1, MAX_ZOOM);
+    zoomAroundCenter(newZoom);
+  };
+
+  const onZoomSliderPointerDown = (event: PointerEvent) => {
+    if (event.button !== 0) {
+      return;
+    }
+    isDraggingZoom = true;
+    assetViewerManager.setZoomEnabled(false);
+    (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
+    setZoomFromSlider(event);
+    event.preventDefault();
+    event.stopPropagation();
+  };
+
+  const onZoomSliderPointerMove = (event: PointerEvent) => {
+    if (!isDraggingZoom) {
+      return;
+    }
+    setZoomFromSlider(event);
+  };
+
+  const onZoomSliderPointerUp = () => {
+    isDraggingZoom = false;
+    assetViewerManager.setZoomEnabled(true);
+  };
+
+  const viewportRect = $derived.by(() => {
+    const { currentZoom, currentPositionX, currentPositionY } = assetViewerManager.zoomState;
+
+    // Visible area in container coordinates
+    const visibleLeft = -currentPositionX / currentZoom;
+    const visibleTop = -currentPositionY / currentZoom;
+    const visibleWidth = containerWidth / currentZoom;
+    const visibleHeight = containerHeight / currentZoom;
+
+    // Map to minimap coordinates
+    return {
+      left: visibleLeft * minimapContainerScale + containerOffsetX,
+      top: visibleTop * minimapContainerScale + containerOffsetY,
+      width: visibleWidth * minimapContainerScale,
+      height: visibleHeight * minimapContainerScale,
+    };
+  });
+</script>
+
+{#if isVisible}
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div
+    class="absolute top-[68px] right-14 md:right-4 z-10 rounded-lg border border-white/30 bg-black/60 p-1 backdrop-blur-sm"
+    data-testid="zoom-minimap"
+    transition:fade={{ duration: FADE_DURATION }}
+  >
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div
+      class="relative overflow-hidden rounded bg-black"
+      class:cursor-grabbing={isDragging}
+      class:cursor-pointer={!isDragging}
+      data-testid="zoom-minimap-canvas"
+      style="width: {minimapSize}px; height: {minimapSize}px;"
+      onpointerdown={onPointerDown}
+      onpointermove={onPointerMove}
+      onpointerup={onPointerUp}
+      onpointercancel={onPointerUp}
+      onwheel={onWheel}
+    >
+      <img
+        src={thumbnailUrl}
+        alt=""
+        class="absolute pointer-events-none"
+        draggable="false"
+        style="left: {imageInMinimap.offsetX}px; top: {imageInMinimap.offsetY}px; width: {imageInMinimap.contentWidth}px; height: {imageInMinimap.contentHeight}px;"
+      />
+      <div
+        class={[
+          'absolute border-2 border-white bg-white/20 pointer-events-none rounded-sm',
+          isDragging && 'border-white/80',
+        ]}
+        data-testid="zoom-minimap-viewport"
+        style="left: {viewportRect.left}px; top: {viewportRect.top}px; width: {viewportRect.width}px; height: {viewportRect.height}px;"
+      ></div>
+    </div>
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div
+      class="relative mt-1 h-3 rounded-full bg-white/20 cursor-pointer"
+      class:cursor-grabbing={isDraggingZoom}
+      data-testid="zoom-minimap-slider"
+      style="width: {minimapSize}px;"
+      onpointerdown={onZoomSliderPointerDown}
+      onpointermove={onZoomSliderPointerMove}
+      onpointerup={onZoomSliderPointerUp}
+      onpointercancel={onZoomSliderPointerUp}
+    >
+      <div
+        class="absolute top-0 left-0 h-full rounded-full bg-white/80 pointer-events-none"
+        data-testid="zoom-minimap-slider-fill"
+        style="width: {zoomPercent}%;"
+      ></div>
+      <span
+        class="absolute inset-0 flex items-center justify-center text-[9px] font-semibold pointer-events-none select-none leading-none"
+        style="color: #000; text-shadow: 0 0 3px rgba(255,255,255,0.8);"
+      >
+        {zoomLabel}
+      </span>
+    </div>
+  </div>
+{/if}

web/src/lib/components/layouts/user-page-layout.svelte

@@ -6,11 +6,10 @@
   import { useActions, type ActionArray } from '$lib/actions/use-actions';
   import NavigationBar from '$lib/components/shared-components/navigation-bar/navigation-bar.svelte';
   import UserSidebar from '$lib/components/shared-components/side-bar/user-sidebar.svelte';
-  import { appManager } from '$lib/managers/app-manager.svelte';
   import type { HeaderButtonActionItem } from '$lib/types';
   import { openFileUploadDialog } from '$lib/utils/file-uploader';
   import { Button, ContextMenuButton, HStack, isMenuItemType, type MenuItemType } from '@immich/ui';
-  import { type Snippet } from 'svelte';
+  import type { Snippet } from 'svelte';
   import { t } from 'svelte-i18n';
 
   interface Props {
@@ -45,17 +44,12 @@
 
   let scrollbarClass = $derived(scrollbar ? 'immich-scrollbar' : 'scrollbar-hidden');
   let hasTitleClass = $derived(title ? 'top-16 h-[calc(100%-(--spacing(16)))]' : 'top-0 h-full');
-  let isAssetViewer = $derived(appManager.isAssetViewer);
 </script>
 
 <header>
-  {#if !hideNavbar && !isAssetViewer}
+  {#if !hideNavbar}
     <NavigationBar onUploadClick={() => openFileUploadDialog()} />
   {/if}
-
-  {#if isAssetViewer}
-    <div class="max-md:h-(--navbar-height-md) h-(--navbar-height)"></div>
-  {/if}
 </header>
 <div
   tabindex="-1"
@@ -64,15 +58,13 @@
     {hideNavbar ? 'pt-(--navbar-height)' : ''}
     {hideNavbar ? 'max-md:pt-(--navbar-height-md)' : ''}"
 >
-  {#if isAssetViewer}
+  {#if sidebar}
-    <div></div>
-  {:else if sidebar}
     {@render sidebar()}
   {:else}
     <UserSidebar />
   {/if}
 
-  <main class="relative w-full">
+  <main class="relative">
     <div class="{scrollbarClass} absolute {hasTitleClass} w-full overflow-y-auto p-2" use:useActions={use}>
       {@render children?.()}
     </div>

web/src/lib/components/memory-page/memory-photo-viewer.svelte

@@ -11,10 +11,9 @@
   interface Props {
     asset: TimelineAsset;
     onImageLoad: () => void;
-    transitionName?: string;
   }
 
-  const { asset, onImageLoad, transitionName }: Props = $props();
+  const { asset, onImageLoad }: Props = $props();
 
   let assetFileUrl: string = $state('');
   let imageLoaded: boolean = $state(false);
@@ -53,7 +52,6 @@
       src={assetFileUrl}
       alt={$getAltText(asset)}
       draggable="false"
-      style:view-transition-name={transitionName}
     />
   </div>
 {/if}

web/src/lib/components/memory-page/memory-viewer.svelte

@@ -30,7 +30,6 @@
   import { preferences } from '$lib/stores/user.store';
   import { getAssetMediaUrl, handlePromiseError, memoryLaneTitle } from '$lib/utils';
   import { cancelMultiselect } from '$lib/utils/asset-utils';
-  import { navigateToTimeline } from '$lib/utils/transition-utils';
   import { fromISODateTimeUTC, toTimelineAsset } from '$lib/utils/timeline-util';
   import { AssetMediaSize, AssetTypeEnum, getAssetInfo } from '@immich/sdk';
   import { ActionButton, IconButton, toastManager } from '@immich/ui';
@@ -227,20 +226,6 @@
     handlePromiseError(handleAction('galleryInView', 'pause'));
   };
 
-  let memoryTransitionName = $state<string | undefined>(undefined);
-
-  const viewInTimeline = (assetId: string) => {
-    navigateToTimeline(assetId, {
-      types: ['memory-enter'],
-      prepareOldSnapshot: () => {
-        memoryTransitionName = 'hero';
-      },
-      onFinished: () => {
-        memoryTransitionName = undefined;
-      },
-    });
-  };
-
   const handleGalleryScrollsOutOfView = () => {
     galleryInView = false;
     // only call play after the first page load. When page first loads the gallery will not be visible
@@ -520,11 +505,7 @@
                   videoViewerVolume={$videoViewerVolume}
                 />
               {:else}
-                <MemoryPhotoViewer
+                <MemoryPhotoViewer asset={current.asset} onImageLoad={resetAndPlay} />
-                  asset={current.asset}
-                  onImageLoad={resetAndPlay}
-                  transitionName={memoryTransitionName}
-                />
               {/if}
             {/key}
 
@@ -579,10 +560,6 @@
                       color="secondary"
                       variant="ghost"
                       shape="round"
-                      onclick={(event: MouseEvent) => {
-                        event.preventDefault();
-                        viewInTimeline(asset.stack?.primaryAssetId ?? asset.id);
-                      }}
                     />
                   {/if}
                 {/await}

web/src/lib/components/shared-components/gallery-viewer/gallery-viewer.svelte

@@ -3,13 +3,10 @@
   import { shortcuts, type ShortcutOptions } from '$lib/actions/shortcut';
   import type { Action } from '$lib/components/asset-viewer/actions/action';
   import Thumbnail from '$lib/components/assets/thumbnail/thumbnail.svelte';
-  import { focusAsset } from '$lib/components/timeline/actions/focus-actions';
   import { AssetAction } from '$lib/constants';
   import Portal from '$lib/elements/Portal.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { featureFlagsManager } from '$lib/managers/feature-flags-manager.svelte';
   import type { TimelineAsset, Viewport } from '$lib/managers/timeline-manager/types';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
   import AssetDeleteConfirmModal from '$lib/modals/AssetDeleteConfirmModal.svelte';
   import ShortcutsModal from '$lib/modals/ShortcutsModal.svelte';
   import { Route } from '$lib/route';
@@ -30,11 +27,9 @@
   import { getJustifiedLayoutFromAssets } from '$lib/utils/layout-utils';
   import { navigate } from '$lib/utils/navigation';
   import { isTimelineAsset, toTimelineAsset } from '$lib/utils/timeline-util';
-  import { startViewerTransition } from '$lib/utils/transition-utils';
   import { AssetVisibility, type AssetResponseDto } from '@immich/sdk';
   import { modalManager } from '@immich/ui';
   import { debounce } from 'lodash-es';
-  import { onMount, tick } from 'svelte';
   import { t } from 'svelte-i18n';
 
   type Props = {
@@ -70,16 +65,6 @@
   }: Props = $props();
 
   let { isViewing: isViewerOpen, asset: viewingAsset } = assetViewingStore;
-
-  $effect(() => {
-    if ($isViewerOpen) {
-      document.documentElement.style.overflow = 'hidden';
-    }
-    return () => {
-      document.documentElement.style.overflow = '';
-    };
-  });
-
   const navigationAssets = $derived(viewerAssets ?? assets);
 
   const geometry = $derived(
@@ -122,36 +107,6 @@
 
   const updateSlidingWindow = () => (scrollTop = document.scrollingElement?.scrollTop ?? 0);
 
-  const scrollGalleryToAsset = async (assetId: string) => {
-    const index = assets.findIndex((asset) => asset.id === assetId);
-    if (index === -1) {
-      return;
-    }
-    const assetTopPage = geometry.getTop(index) + slidingWindowOffset;
-    const assetBottomPage = assetTopPage + geometry.getHeight(index);
-    const currentScrollTop = document.scrollingElement?.scrollTop ?? 0;
-    const visibleTop = currentScrollTop + pageHeaderOffset;
-    const visibleBottom = currentScrollTop + viewport.height;
-
-    if (assetTopPage >= visibleTop && assetBottomPage <= visibleBottom) {
-      return;
-    }
-    const distanceToAlignTop = Math.abs(assetTopPage - pageHeaderOffset - currentScrollTop);
-    const distanceToAlignBottom = Math.abs(assetBottomPage - viewport.height - currentScrollTop);
-    const newScrollTop =
-      distanceToAlignTop < distanceToAlignBottom ? assetTopPage - pageHeaderOffset : assetBottomPage - viewport.height;
-    if (document.scrollingElement) {
-      document.scrollingElement.scrollTop = newScrollTop;
-    }
-    updateSlidingWindow();
-    await tick();
-  };
-
-  const scrollToAndFocusAsset = async (assetId: string) => {
-    await scrollGalleryToAsset(assetId);
-    focusAsset(assetId);
-  };
-
   const debouncedOnIntersected = debounce(() => onIntersected?.(), 750, { maxWait: 100, leading: true });
 
   let lastIntersectedHeight = 0;
@@ -401,63 +356,6 @@
     nextAsset: getNextAsset(navigationAssets, $viewingAsset),
     previousAsset: getPreviousAsset(navigationAssets, $viewingAsset),
   });
-
-  let toViewerTransitionId = $state<string | null>(null);
-  let toGalleryTransitionId = $state<string | null>(null);
-  const transitionTargetId = $derived(toViewerTransitionId ?? toGalleryTransitionId);
-
-  const handleThumbnailClick = (asset: AssetResponseDto, currentAsset: TimelineAsset) => {
-    if (assetInteraction.selectionActive) {
-      handleSelectAssets(currentAsset);
-      return;
-    }
-
-    const doNavigate = () => void navigateToAsset(asset);
-
-    if (!viewTransitionManager.isSupported()) {
-      doNavigate();
-      return;
-    }
-
-    startViewerTransition(asset.id, doNavigate, (id) => (toViewerTransitionId = id));
-  };
-
-  const transitionToGalleryCallback = ({ id }: { id: string }) => {
-    void viewTransitionManager.startTransition({
-      types: ['timeline'],
-      prepareOldSnapshot: () => {
-        void scrollGalleryToAsset(id);
-      },
-      performUpdate: async () => {
-        eventManager.emit('ViewerCloseTransitionReady');
-        toGalleryTransitionId = id;
-        await tick();
-      },
-      onFinished: () => {
-        toGalleryTransitionId = null;
-        focusAsset(id);
-      },
-    });
-  };
-
-  if (viewTransitionManager.isSupported()) {
-    onMount(() => eventManager.on({ ViewerCloseTransition: transitionToGalleryCallback }));
-  }
-
-  const handleClose = async (asset: { id: string }) => {
-    const useTransition = viewTransitionManager.isSupported();
-    if (useTransition) {
-      const transitionReady = eventManager.untilNext('ViewerCloseTransitionReady');
-      eventManager.emit('ViewerCloseTransition', { id: asset.id });
-      await transitionReady;
-    }
-    assetViewingStore.showAssetViewer(false);
-    if (!useTransition) {
-      await tick();
-      await scrollToAndFocusAsset(asset.id);
-    }
-    handlePromiseError(navigate({ targetRoute: 'current', assetId: null }, { noScroll: true }));
-  };
 </script>
 
 <svelte:document
@@ -477,17 +375,16 @@
     {#each assets as asset, i (asset.id + '-' + i)}
       {#if isIntersecting(i)}
         {@const currentAsset = toTimelineAsset(asset)}
-        {@const transitionName = transitionTargetId === asset.id ? 'hero' : undefined}
+        <div class="absolute" style:overflow="clip" style={getStyle(i)}>
-        <div
-          class="absolute"
-          style:overflow="clip"
-          style={getStyle(i)}
-          style:view-transition-name={transitionName}
-          data-transition-name={transitionName}
-        >
           <Thumbnail
             readonly={disableAssetSelect}
-            onClick={() => handleThumbnailClick(asset, currentAsset)}
+            onClick={() => {
+              if (assetInteraction.selectionActive) {
+                handleSelectAssets(currentAsset);
+                return;
+              }
+              void navigateToAsset(asset);
+            }}
             onSelect={() => handleSelectAssets(currentAsset)}
             onMouseEvent={() => assetMouseEventHandler(currentAsset)}
             {showArchiveIcon}
@@ -519,7 +416,10 @@
         onAction={handleAction}
         onRandom={handleRandom}
         onAssetChange={updateCurrentAsset}
-        onClose={(asset) => handleClose(asset)}
+        onClose={() => {
+          assetViewingStore.showAssetViewer(false);
+          handlePromiseError(navigate({ targetRoute: 'current', assetId: null }));
+        }}
       />
     {/await}
   </Portal>

web/src/lib/components/shared-components/navigation-bar/navigation-bar.svelte

@@ -50,11 +50,7 @@
 
 <svelte:window bind:innerWidth />
 
-<nav
+<nav id="dashboard-navbar" class="max-md:h-(--navbar-height-md) h-(--navbar-height) w-dvw text-sm">
-  id="dashboard-navbar"
-  class="max-md:h-(--navbar-height-md) h-(--navbar-height) w-dvw text-sm relative z-10"
-  style:view-transition-name="exclude"
->
   <SkipLink text={$t('skip_to_content')} />
   <div
     class="grid h-full grid-cols-[--spacing(32)_auto] items-center py-2 sidebar:grid-cols-[--spacing(64)_auto] {noBorder

web/src/lib/components/timeline/AssetLayout.svelte

@@ -1,19 +1,20 @@
 <script lang="ts">
   import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
-  import { filterIntersecting } from '$lib/managers/timeline-manager/utils.svelte';
   import type { ViewerAsset } from '$lib/managers/timeline-manager/viewer-asset.svelte';
+  import type { VirtualScrollManager } from '$lib/managers/VirtualScrollManager/VirtualScrollManager.svelte';
   import { uploadAssetsStore } from '$lib/stores/upload';
   import type { CommonPosition } from '$lib/utils/layout-utils';
   import type { Snippet } from 'svelte';
   import { flip } from 'svelte/animate';
   import { scale } from 'svelte/transition';
 
+  let { isUploading } = uploadAssetsStore;
+
   type Props = {
-    animationTargetAssetId?: string | null;
-    suspendTransitions?: boolean;
     viewerAssets: ViewerAsset[];
     width: number;
     height: number;
+    manager: VirtualScrollManager;
     thumbnail: Snippet<
       [
         {
@@ -25,20 +26,14 @@
     customThumbnailLayout?: Snippet<[asset: TimelineAsset]>;
   };
 
-  let { isUploading } = uploadAssetsStore;
+  const { viewerAssets, width, height, manager, thumbnail, customThumbnailLayout }: Props = $props();
 
-  const {
+  const transitionDuration = $derived(manager.suspendTransitions && !$isUploading ? 0 : 150);
-    animationTargetAssetId,
-    suspendTransitions = false,
-    viewerAssets,
-    width,
-    height,
-    thumbnail,
-    customThumbnailLayout,
-  }: Props = $props();
-
-  const transitionDuration = $derived(suspendTransitions && !$isUploading ? 0 : 150);
   const scaleDuration = $derived(transitionDuration === 0 ? 0 : transitionDuration + 100);
+
+  const filterIntersecting = <T extends { intersecting: boolean }>(intersectables: T[]) => {
+    return intersectables.filter(({ intersecting }) => intersecting);
+  };
 </script>
 
 <!-- Image grid -->
@@ -46,14 +41,11 @@
   {#each filterIntersecting(viewerAssets) as viewerAsset (viewerAsset.id)}
     {@const position = viewerAsset.position!}
     {@const asset = viewerAsset.asset!}
-    {@const transitionName = animationTargetAssetId === asset.id ? 'hero' : undefined}
 
     <!-- note: don't remove data-asset-id - its used by web e2e tests -->
     <div
       data-asset-id={asset.id}
       class="absolute"
-      data-transition-name={transitionName}
-      style:view-transition-name={transitionName}
       style:top={position.top + 'px'}
       style:inset-inline-start={position.left + 'px'}
       style:width={position.width + 'px'}

web/src/lib/components/timeline/Month.svelte

@@ -1,37 +1,34 @@
 <script lang="ts">
-  import { focusAsset } from '$lib/components/timeline/actions/focus-actions';
   import AssetLayout from '$lib/components/timeline/AssetLayout.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import { DayGroup } from '$lib/managers/timeline-manager/day-group.svelte';
   import type { MonthGroup } from '$lib/managers/timeline-manager/month-group.svelte';
   import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
-  import { assetsSnapshot, filterIntersecting } from '$lib/managers/timeline-manager/utils.svelte';
+  import { assetsSnapshot } from '$lib/managers/timeline-manager/utils.svelte';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
+  import type { VirtualScrollManager } from '$lib/managers/VirtualScrollManager/VirtualScrollManager.svelte';
   import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
   import { uploadAssetsStore } from '$lib/stores/upload';
   import type { CommonPosition } from '$lib/utils/layout-utils';
   import { fromTimelinePlainDate, getDateLocaleString } from '$lib/utils/timeline-util';
   import { Icon } from '@immich/ui';
   import { mdiCheckCircle, mdiCircleOutline } from '@mdi/js';
-  import { onMount, tick, type Snippet } from 'svelte';
+  import type { Snippet } from 'svelte';
 
   type Props = {
-    toAssetViewerTransitionId?: string | null;
     thumbnail: Snippet<[{ asset: TimelineAsset; position: CommonPosition; dayGroup: DayGroup; groupIndex: number }]>;
     customThumbnailLayout?: Snippet<[TimelineAsset]>;
     singleSelect: boolean;
     assetInteraction: AssetInteraction;
     monthGroup: MonthGroup;
+    manager: VirtualScrollManager;
     onDayGroupSelect: (dayGroup: DayGroup, assets: TimelineAsset[]) => void;
   };
-
   let {
-    toAssetViewerTransitionId,
     thumbnail: thumbnailWithGroup,
     customThumbnailLayout,
     singleSelect,
     assetInteraction,
     monthGroup,
+    manager,
     onDayGroupSelect,
   }: Props = $props();
 
@@ -40,6 +37,10 @@
 
   const transitionDuration = $derived(monthGroup.timelineManager.suspendTransitions && !$isUploading ? 0 : 150);
 
+  const filterIntersecting = <T extends { intersecting: boolean }>(intersectables: T[]) => {
+    return intersectables.filter(({ intersecting }) => intersecting);
+  };
+
   const getDayGroupFullDate = (dayGroup: DayGroup): string => {
     const { month, year } = dayGroup.monthGroup.yearMonth;
     const date = fromTimelinePlainDate({
@@ -49,32 +50,6 @@
     });
     return getDateLocaleString(date);
   };
-
-  let toTimelineTransitionAssetId = $state<string | null>(null);
-  let animationTargetAssetId = $derived(toTimelineTransitionAssetId ?? toAssetViewerTransitionId ?? null);
-
-  const transitionToTimelineCallback = ({ id }: { id: string }) => {
-    const asset = monthGroup.findAssetById({ id });
-    if (!asset) {
-      return;
-    }
-    void viewTransitionManager.startTransition({
-      types: ['timeline'],
-      performUpdate: async () => {
-        eventManager.emit('ViewerCloseTransitionReady');
-        const event = await eventManager.untilNext('TimelineLoaded');
-        toTimelineTransitionAssetId = event.id;
-        await tick();
-      },
-      onFinished: () => {
-        toTimelineTransitionAssetId = null;
-        focusAsset(asset.id);
-      },
-    });
-  };
-  if (viewTransitionManager.isSupported()) {
-    onMount(() => eventManager.on({ ViewerCloseTransition: transitionToTimelineCallback }));
-  }
 </script>
 
 {#each filterIntersecting(monthGroup.dayGroups) as dayGroup, groupIndex (dayGroup.day)}
@@ -118,8 +93,7 @@
     </div>
 
     <AssetLayout
-      {animationTargetAssetId}
+      {manager}
-      suspendTransitions={monthGroup.timelineManager.suspendTransitions}
       viewerAssets={dayGroup.viewerAssets}
       height={dayGroup.height}
       width={dayGroup.width}

web/src/lib/components/timeline/Scrubber.svelte

@@ -11,7 +11,6 @@
   import { fade, fly } from 'svelte/transition';
 
   interface Props {
-    invisible: boolean;
     /** Offset from the top of the timeline (e.g., for headers) */
     timelineTopOffset?: number;
     /** Offset from the bottom of the timeline (e.g., for footers) */
@@ -40,7 +39,6 @@
   }
 
   let {
-    invisible = false,
     timelineTopOffset = 0,
     timelineBottomOffset = 0,
     height = 0,
@@ -440,7 +438,7 @@
           next = forward
             ? (focusable[(index + 1) % focusable.length] as HTMLElement)
             : (focusable[(index - 1) % focusable.length] as HTMLElement);
-          next?.focus();
+          next.focus();
         }
       }
     }
@@ -511,7 +509,6 @@
   aria-valuemin={toScrollY(0)}
   data-id="scrubber"
   class="absolute end-0 z-1 select-none hover:cursor-row-resize"
-  class:invisible
   style:padding-top={PADDING_TOP + 'px'}
   style:padding-bottom={PADDING_BOTTOM + 'px'}
   style:width

web/src/lib/components/timeline/Timeline.svelte

@@ -11,8 +11,6 @@
   import HotModuleReload from '$lib/elements/HotModuleReload.svelte';
   import Portal from '$lib/elements/Portal.svelte';
   import Skeleton from '$lib/elements/Skeleton.svelte';
-  import { startViewerTransition } from '$lib/utils/transition-utils';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
   import type { DayGroup } from '$lib/managers/timeline-manager/day-group.svelte';
   import { isIntersecting } from '$lib/managers/timeline-manager/internal/intersection-support.svelte';
   import type { MonthGroup } from '$lib/managers/timeline-manager/month-group.svelte';
@@ -104,7 +102,6 @@
   // Overall scroll percentage through the entire timeline (0-1)
   let timelineScrollPercent: number = $state(0);
   let scrubberWidth = $state(0);
-  let toAssetViewerTransitionId = $state<string | null>(null);
 
   const isEmpty = $derived(timelineManager.isInitialized && timelineManager.months.length === 0);
   const maxMd = $derived(mediaQueryManager.maxMd);
@@ -212,22 +209,19 @@
         timelineManager.viewportWidth = rect.width;
       }
     }
-    const scrollTarget = getScrollTarget();
+    const scrollTarget = $gridScrollTarget?.at;
     let scrolled = false;
     if (scrollTarget) {
       scrolled = await scrollAndLoadAsset(scrollTarget);
     }
     if (!scrolled) {
+      // if the asset is not found, scroll to the top
       timelineManager.scrollTo(0);
-      if (scrollTarget) {
-        eventManager.emit('TimelineScrolledToAsset', { id: scrollTarget });
-      }
     } else if (scrollTarget) {
       await tick();
       focusAsset(scrollTarget);
-      eventManager.emit('TimelineScrolledToAsset', { id: scrollTarget });
     }
-    invisible = isAssetViewerRoute(page) ? true : false;
+    invisible = false;
   };
 
   // note: only modified once in afterNavigate()
@@ -245,13 +239,10 @@
     hasNavigatedToOrFromAssetViewer = isNavigatingToAssetViewer !== isNavigatingFromAssetViewer;
   });
 
-  const getScrollTarget = () => {
-    return $gridScrollTarget?.at ?? page.params.assetId ?? null;
-  };
   // afterNavigate is only called after navigation to a new URL, {complete} will resolve
   // after successful navigation.
   afterNavigate(({ complete }) => {
-    void complete.finally(async () => {
+    void complete.finally(() => {
       const isAssetViewerPage = isAssetViewerRoute(page);
 
       // Set initial load state only once - if initialLoadWasAssetViewer is null, then
@@ -260,13 +251,8 @@
       if (isDirectNavigation) {
         initialLoadWasAssetViewer = isAssetViewerPage && !hasNavigatedToOrFromAssetViewer;
       }
-      void scrollAfterNavigate();
-      if (!isAssetViewerPage) {
-        const scrollTarget = getScrollTarget();
-        await tick();
 
-        eventManager.emit('TimelineLoaded', { id: scrollTarget });
+      void scrollAfterNavigate();
-      }
     });
   });
 
@@ -274,7 +260,7 @@
   // note: don't throttle, debounch, or otherwise do this function async - it causes flicker
 
   onMount(() => {
-    if (!enableRouting && !isAssetViewerRoute(page)) {
+    if (!enableRouting) {
       invisible = false;
     }
   });
@@ -538,33 +524,6 @@
     }
   });
 
-  const defaultThumbnailClick = (
-    timelineManager: TimelineManager,
-    assets: TimelineAsset[],
-    groupTitle: string,
-    asset: TimelineAsset,
-  ) => {
-    if (isSelectionMode || assetInteraction.selectionActive) {
-      assetSelectHandler(timelineManager, asset, assets, groupTitle);
-      return;
-    }
-    void navigate({ targetRoute: 'current', assetId: asset.id });
-  };
-
-  const handleThumbnailClick = (asset: TimelineAsset, dayGroup: DayGroup) => {
-    if (typeof onThumbnailClick === 'function' || isSelectionMode || assetInteraction.selectionActive) {
-      if (typeof onThumbnailClick === 'function') {
-        onThumbnailClick(asset, timelineManager, dayGroup, defaultThumbnailClick);
-      } else {
-        defaultThumbnailClick(timelineManager, dayGroup.getAssets(), dayGroup.groupTitle, asset);
-      }
-      return;
-    }
-
-    const openViewer = () => void navigate({ targetRoute: 'current', assetId: asset.id });
-    startViewerTransition(asset.id, openViewer, (id) => (toAssetViewerTransitionId = id));
-  };
-
   const assetSelectHandler = (
     timelineManager: TimelineManager,
     asset: TimelineAsset,
@@ -585,6 +544,19 @@
 
     assetInteraction.selectAll = timelineManager.assetCount === assetInteraction.selectedAssets.length;
   };
+
+  const _onClick = (
+    timelineManager: TimelineManager,
+    assets: TimelineAsset[],
+    groupTitle: string,
+    asset: TimelineAsset,
+  ) => {
+    if (isSelectionMode || assetInteraction.selectionActive) {
+      assetSelectHandler(timelineManager, asset, assets, groupTitle);
+      return;
+    }
+    void navigate({ targetRoute: 'current', assetId: asset.id });
+  };
 </script>
 
 <svelte:document onkeydown={onKeyDown} onkeyup={onKeyUp} />
@@ -615,7 +587,6 @@
 {#if timelineManager.months.length > 0}
   <Scrubber
     {timelineManager}
-    {invisible}
     height={timelineManager.viewportHeight}
     timelineTopOffset={timelineManager.topSectionHeight}
     timelineBottomOffset={timelineManager.bottomSectionHeight}
@@ -647,7 +618,6 @@
   id="asset-grid"
   class={['scrollbar-hidden h-full overflow-y-auto outline-none', { 'm-0': isEmpty }, { 'ms-0': !isEmpty }]}
   style:margin-inline-end={(usingMobileDevice ? 0 : scrubberWidth) + 'px'}
-  data-initialized={timelineManager.isInitialized || undefined}
   tabindex="-1"
   bind:clientHeight={timelineManager.viewportHeight}
   bind:clientWidth={timelineManager.viewportWidth}
@@ -696,11 +666,11 @@
           style:width="100%"
         >
           <Month
-            {toAssetViewerTransitionId}
             {assetInteraction}
             {customThumbnailLayout}
             {singleSelect}
             {monthGroup}
+            manager={timelineManager}
             onDayGroupSelect={handleGroupSelect}
           >
             {#snippet thumbnail({ asset, position, dayGroup, groupIndex })}
@@ -714,7 +684,13 @@
                 {asset}
                 {albumUsers}
                 {groupIndex}
-                onClick={(asset) => handleThumbnailClick(asset, dayGroup)}
+                onClick={(asset) => {
+                  if (typeof onThumbnailClick === 'function') {
+                    onThumbnailClick(asset, timelineManager, dayGroup, _onClick);
+                  } else {
+                    _onClick(timelineManager, dayGroup.getAssets(), dayGroup.groupTitle, asset);
+                  }
+                }}
                 onSelect={() => {
                   if (isSelectionMode || assetInteraction.selectionActive) {
                     assetSelectHandler(timelineManager, asset, dayGroup.getAssets(), dayGroup.groupTitle);

web/src/lib/components/timeline/TimelineAssetViewer.svelte

@@ -4,8 +4,6 @@
   import { AssetAction } from '$lib/constants';
   import { assetCacheManager } from '$lib/managers/AssetCacheManager.svelte';
   import { authManager } from '$lib/managers/auth-manager.svelte';
-  import { eventManager } from '$lib/managers/event-manager.svelte';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
   import { TimelineManager } from '$lib/managers/timeline-manager/timeline-manager.svelte';
   import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
   import { assetViewingStore } from '$lib/stores/asset-viewing.store';
@@ -100,12 +98,6 @@
   };
 
   const handleClose = async (asset: { id: string }) => {
-    if (viewTransitionManager.isSupported()) {
-      const transitionReady = eventManager.untilNext('ViewerCloseTransitionReady');
-      eventManager.emit('ViewerCloseTransition', { id: asset.id });
-      await transitionReady;
-    }
-
     invisible = true;
     $gridScrollTarget = { at: asset.id };
     await navigate({ targetRoute: 'current', assetId: null, assetGridRouteSearchParams: $gridScrollTarget });

web/src/lib/managers/ViewTransitionManager.svelte.spec.ts

@@ -1,363 +0,0 @@
-import { ViewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
-
-describe('ViewTransitionManager', () => {
-  let manager: ViewTransitionManager;
-
-  beforeEach(() => {
-    manager = new ViewTransitionManager();
-  });
-
-  afterEach(() => {
-    delete (document as Partial<typeof document> & { startViewTransition?: unknown }).startViewTransition;
-  });
-
-  describe('when View Transition API is not supported', () => {
-    it('should still call performUpdate', async () => {
-      const performUpdate = vi.fn().mockResolvedValue(undefined);
-
-      await manager.startTransition({ performUpdate });
-
-      expect(performUpdate).toHaveBeenCalledOnce();
-    });
-
-    it('should call onFinished after performUpdate', async () => {
-      const callOrder: string[] = [];
-      const performUpdate = vi.fn().mockImplementation(() => {
-        callOrder.push('performUpdate');
-      });
-      const onFinished = vi.fn().mockImplementation(() => {
-        callOrder.push('onFinished');
-      });
-
-      await manager.startTransition({ performUpdate, onFinished });
-
-      expect(onFinished).toHaveBeenCalledOnce();
-      expect(callOrder).toEqual(['performUpdate', 'onFinished']);
-    });
-
-    it('should not call prepareOldSnapshot or prepareNewSnapshot', async () => {
-      const prepareOldSnapshot = vi.fn();
-      const prepareNewSnapshot = vi.fn();
-      const performUpdate = vi.fn().mockResolvedValue(undefined);
-
-      await manager.startTransition({ performUpdate, prepareOldSnapshot, prepareNewSnapshot });
-
-      expect(prepareOldSnapshot).not.toHaveBeenCalled();
-      expect(prepareNewSnapshot).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('when a transition is already active', () => {
-    it('should skip the second transition', async () => {
-      let resolveFinished!: () => void;
-      const finished = new Promise<void>((resolve) => {
-        resolveFinished = resolve;
-      });
-      let resolveUpdate!: () => void;
-      const updateCallbackDone = new Promise<void>((resolve) => {
-        resolveUpdate = resolve;
-      });
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return { updateCallbackDone, finished, ready: Promise.resolve(), skipTransition: vi.fn() };
-      });
-
-      const secondPerformUpdate = vi.fn().mockResolvedValue(undefined);
-
-      // Start first — it will be blocked on updateCallbackDone
-      const firstPromise = manager.startTransition({
-        performUpdate: async () => {},
-      });
-
-      // Flush microtasks so the first transition reaches the startViewTransition call
-      await new Promise<void>((r) => queueMicrotask(r));
-
-      // While first is active, try a second — should be skipped
-      await manager.startTransition({ performUpdate: secondPerformUpdate });
-      expect(secondPerformUpdate).not.toHaveBeenCalled();
-
-      // Clean up
-      resolveUpdate();
-      resolveFinished();
-      await firstPromise;
-    });
-  });
-
-  describe('skipTransitions', () => {
-    it('should return false when no transition is active', () => {
-      expect(manager.skipTransitions()).toBe(false);
-    });
-
-    it('should call skipTransition on the active transition and return true', async () => {
-      let resolveFinished!: () => void;
-      const finished = new Promise<void>((resolve) => {
-        resolveFinished = resolve;
-      });
-      let resolveUpdate!: () => void;
-      const updateCallbackDone = new Promise<void>((resolve) => {
-        resolveUpdate = resolve;
-      });
-      const skipTransition = vi.fn();
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return { updateCallbackDone, finished, ready: Promise.resolve(), skipTransition };
-      });
-
-      const promise = manager.startTransition({ performUpdate: async () => {} });
-      await new Promise<void>((r) => queueMicrotask(r));
-
-      const skipped = manager.skipTransitions();
-      expect(skipped).toBe(true);
-      expect(skipTransition).toHaveBeenCalledOnce();
-
-      resolveUpdate();
-      resolveFinished();
-      await promise;
-    });
-
-    it('should allow a new transition after skipping', async () => {
-      let resolveFinished!: () => void;
-      const finished = new Promise<void>((resolve) => {
-        resolveFinished = resolve;
-      });
-      let resolveUpdate!: () => void;
-      const updateCallbackDone = new Promise<void>((resolve) => {
-        resolveUpdate = resolve;
-      });
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return { updateCallbackDone, finished, ready: Promise.resolve(), skipTransition: vi.fn() };
-      });
-
-      const promise = manager.startTransition({ performUpdate: async () => {} });
-      await new Promise<void>((r) => queueMicrotask(r));
-
-      manager.skipTransitions();
-      resolveUpdate();
-      resolveFinished();
-      await promise;
-
-      // Now start a second transition — it should NOT be skipped
-      const secondUpdate = vi.fn().mockResolvedValue(undefined);
-      const secondFinished = Promise.resolve();
-      const secondUpdateDone = Promise.resolve();
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return {
-          updateCallbackDone: secondUpdateDone,
-          finished: secondFinished,
-          ready: Promise.resolve(),
-          skipTransition: vi.fn(),
-        };
-      });
-
-      await manager.startTransition({ performUpdate: secondUpdate });
-      expect(secondUpdate).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should propagate error from performUpdate when API is not supported', async () => {
-      const error = new Error('update failed');
-      const performUpdate = vi.fn().mockRejectedValue(error);
-
-      await expect(manager.startTransition({ performUpdate })).rejects.toThrow('update failed');
-    });
-
-    it('should clean up activeViewTransition when performUpdate throws (API supported)', async () => {
-      const error = new Error('update failed');
-      let resolveFinished!: () => void;
-      const finished = new Promise<void>((resolve) => {
-        resolveFinished = resolve;
-      });
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        const updateCallbackDone = updateFn();
-        return { updateCallbackDone, finished, ready: Promise.resolve(), skipTransition: vi.fn() };
-      });
-
-      await expect(manager.startTransition({ performUpdate: () => Promise.reject(error) })).rejects.toThrow(
-        'update failed',
-      );
-
-      // Simulate transition finishing after error
-      resolveFinished();
-      await new Promise<void>((r) => queueMicrotask(r));
-
-      // Manager should accept new transitions after cleanup
-      const secondUpdate = vi.fn().mockResolvedValue(undefined);
-      const secondFinished = Promise.resolve();
-      const secondUpdateDone = Promise.resolve();
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return {
-          updateCallbackDone: secondUpdateDone,
-          finished: secondFinished,
-          ready: Promise.resolve(),
-          skipTransition: vi.fn(),
-        };
-      });
-
-      await manager.startTransition({ performUpdate: secondUpdate });
-      expect(secondUpdate).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('fallback path', () => {
-    it('should fall back to function argument when object argument throws', async () => {
-      const performUpdate = vi.fn().mockResolvedValue(undefined);
-      const prepareNewSnapshot = vi.fn();
-      const finished = Promise.resolve();
-      const updateCallbackDone = Promise.resolve();
-
-      let callCount = 0;
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        callCount++;
-        if (callCount === 1 && typeof arg !== 'function') {
-          throw new TypeError('object form not supported');
-        }
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return { updateCallbackDone, finished, ready: Promise.resolve(), skipTransition: vi.fn() };
-      });
-
-      await manager.startTransition({ performUpdate, prepareNewSnapshot, types: ['test'] });
-
-      expect(performUpdate).toHaveBeenCalledOnce();
-      expect(prepareNewSnapshot).toHaveBeenCalledOnce();
-      // eslint-disable-next-line tscompat/tscompat
-      expect(document.startViewTransition).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('abort signal', () => {
-    it('should pass an AbortSignal to performUpdate', async () => {
-      const performUpdate = vi.fn().mockResolvedValue(undefined);
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return {
-          updateCallbackDone: Promise.resolve(),
-          finished: Promise.resolve(),
-          ready: Promise.resolve(),
-          skipTransition: vi.fn(),
-        };
-      });
-
-      await manager.startTransition({ performUpdate });
-
-      expect(performUpdate).toHaveBeenCalledWith(expect.any(AbortSignal));
-    });
-
-    it('should abort the signal when transition.ready rejects', async () => {
-      let capturedSignal: AbortSignal | undefined;
-      let resolveUpdate!: () => void;
-      const updateCallbackDone = new Promise<void>((resolve) => {
-        resolveUpdate = resolve;
-      });
-
-      const readyError = new Error('Transition was aborted because of timeout in DOM update');
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return {
-          updateCallbackDone,
-          finished: Promise.reject(readyError),
-          ready: Promise.reject(readyError),
-          skipTransition: vi.fn(),
-        };
-      });
-
-      const performUpdate = vi.fn().mockImplementation((signal: AbortSignal) => {
-        capturedSignal = signal;
-        return new Promise<void>((resolve) => {
-          signal.addEventListener('abort', () => resolve(), { once: true });
-        });
-      });
-
-      const promise = manager.startTransition({ performUpdate });
-
-      // Flush microtasks so ready rejection fires and aborts the signal
-      await new Promise<void>((r) => queueMicrotask(r));
-      await new Promise<void>((r) => queueMicrotask(r));
-
-      expect(capturedSignal?.aborted).toBe(true);
-
-      resolveUpdate();
-      await promise;
-    });
-
-    it('should not abort the signal when transition completes normally', async () => {
-      let capturedSignal: AbortSignal | undefined;
-
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn().mockImplementation((arg: unknown) => {
-        const updateFn = typeof arg === 'function' ? arg : (arg as { update: () => Promise<void> }).update;
-        void updateFn();
-        return {
-          updateCallbackDone: Promise.resolve(),
-          finished: Promise.resolve(),
-          ready: Promise.resolve(),
-          skipTransition: vi.fn(),
-        };
-      });
-
-      await manager.startTransition({
-        performUpdate: (signal) => {
-          capturedSignal = signal;
-          return Promise.resolve();
-        },
-      });
-
-      expect(capturedSignal?.aborted).toBe(false);
-    });
-
-    it('should pass a non-aborted signal in the unsupported fallback path', async () => {
-      let capturedSignal: AbortSignal | undefined;
-
-      await manager.startTransition({
-        performUpdate: (signal) => {
-          capturedSignal = signal;
-          return Promise.resolve();
-        },
-      });
-
-      expect(capturedSignal).toBeInstanceOf(AbortSignal);
-      expect(capturedSignal?.aborted).toBe(false);
-    });
-  });
-
-  describe('isSupported', () => {
-    it('should return false when startViewTransition is not in document', () => {
-      expect(manager.isSupported()).toBe(false);
-    });
-
-    it('should return true when startViewTransition is in document', () => {
-      // eslint-disable-next-line tscompat/tscompat
-      document.startViewTransition = vi.fn();
-
-      expect(manager.isSupported()).toBe(true);
-    });
-  });
-});

web/src/lib/managers/ViewTransitionManager.svelte.ts

@@ -1,94 +0,0 @@
-import { tick } from 'svelte';
-
-interface TransitionRequest {
-  types?: string[];
-  prepareOldSnapshot?: () => void;
-  performUpdate: (signal: AbortSignal) => Promise<void>;
-  prepareNewSnapshot?: () => void;
-  onFinished?: () => void;
-}
-
-export class ViewTransitionManager {
-  #activeViewTransition = $state<ViewTransition | null>(null);
-
-  get activeViewTransition() {
-    return this.#activeViewTransition;
-  }
-
-  isSupported() {
-    return 'startViewTransition' in document;
-  }
-
-  skipTransitions() {
-    const skipped = !!this.#activeViewTransition;
-    this.#activeViewTransition?.skipTransition();
-    this.#activeViewTransition = null;
-    return skipped;
-  }
-
-  async startTransition({
-    types,
-    prepareOldSnapshot,
-    performUpdate,
-    prepareNewSnapshot,
-    onFinished,
-  }: TransitionRequest) {
-    if (this.#activeViewTransition) {
-      return;
-    }
-
-    if (!this.isSupported()) {
-      await performUpdate(AbortSignal.timeout(10_000));
-      onFinished?.();
-      return;
-    }
-
-    prepareOldSnapshot?.();
-    await tick();
-
-    const abortController = new AbortController();
-    let transition: ViewTransition;
-    try {
-      // eslint-disable-next-line tscompat/tscompat
-      transition = document.startViewTransition({
-        update: async () => {
-          await performUpdate(abortController.signal);
-          prepareNewSnapshot?.();
-          await tick();
-        },
-        types,
-      });
-    } catch {
-      // eslint-disable-next-line tscompat/tscompat
-      transition = document.startViewTransition(async () => {
-        await performUpdate(abortController.signal);
-        prepareNewSnapshot?.();
-        await tick();
-      });
-    }
-
-    this.#activeViewTransition = transition;
-
-    // eslint-disable-next-line tscompat/tscompat
-    void transition.ready.catch((error: unknown) => {
-      abortController.abort(error);
-    });
-
-    // Let animation run in the background — don't block the caller.
-    // This allows skipTransitions() to abort mid-animation for rapid navigation.
-    // eslint-disable-next-line tscompat/tscompat
-    void transition.finished
-      .catch(() => {})
-      .finally(() => {
-        this.#activeViewTransition = null;
-        onFinished?.();
-      });
-
-    // Wait only until the DOM update completes (both snapshots captured),
-    // not for the animation to finish.
-    // eslint-disable-next-line tscompat/tscompat
-    await transition.updateCallbackDone;
-  }
-}
-
-export const viewTransitionManager = new ViewTransitionManager();

web/src/lib/managers/app-manager.svelte.ts

@@ -1,5 +0,0 @@
-class AppManager {
-  isAssetViewer = $state(false);
-}
-
-export const appManager = new AppManager();

web/src/lib/managers/asset-viewer-manager.svelte.ts

@@ -18,6 +18,8 @@ const createDefaultZoomState = (): ZoomImageWheelState => ({
 export type Events = {
   Zoom: [];
   ZoomChange: [ZoomImageWheelState];
+  DirectTransform: [ZoomImageWheelState];
+  ZoomEnabled: [boolean];
   Copy: [];
 };
 
@@ -87,6 +89,15 @@ export class AssetViewerManager extends BaseEventManager<Events> {
     this.#zoomState = state;
   }
 
+  directTransform(state: Partial<ZoomImageWheelState>) {
+    this.#zoomState = { ...this.#zoomState, ...state };
+    this.emit('DirectTransform', this.#zoomState);
+  }
+
+  setZoomEnabled(enabled: boolean) {
+    this.emit('ZoomEnabled', enabled);
+  }
+
   cancelZoomAnimation() {
     if (this.#animationFrameId !== null) {
       cancelAnimationFrame(this.#animationFrameId);

web/src/lib/managers/event-manager.svelte.ts

@@ -89,15 +89,6 @@ export type Events = {
   ReleaseEvent: [ReleaseEvent];
 
   WebsocketConnect: [];
-
-  TimelineLoaded: [{ id: string | null }];
-  TimelineScrolledToAsset: [{ id: string }];
-
-  ViewerAfterNavigate: [];
-  ViewerCloseTransition: [{ id: string }];
-  ViewerCloseTransitionReady: [];
-  ViewerOpenTransition: [];
-  ViewerOpenTransitionReady: [];
 };
 
 export const eventManager = new BaseEventManager<Events>();

web/src/lib/managers/timeline-manager/utils.svelte.ts

@@ -2,11 +2,3 @@ import type { TimelineAsset } from './types';
 
 export const assetSnapshot = (asset: TimelineAsset): TimelineAsset => $state.snapshot(asset);
 export const assetsSnapshot = (assets: TimelineAsset[]) => assets.map((asset) => $state.snapshot(asset));
-
-export function* filterIntersecting<T extends { intersecting: boolean }>(items: T[]) {
-  for (const item of items) {
-    if (item.intersecting) {
-      yield item;
-    }
-  }
-}

web/src/lib/stores/asset-viewing.store.ts

@@ -5,7 +5,6 @@ import { readonly, writable } from 'svelte/store';
 
 function createAssetViewingStore() {
   const viewingAssetStoreState = writable<AssetResponseDto>();
-  const invisible = writable<boolean>(false);
   const viewState = writable<boolean>(false);
   const gridScrollTarget = writable<AssetGridRouteSearchParams | null | undefined>();
 
@@ -31,7 +30,6 @@ function createAssetViewingStore() {
     setAsset,
     setAssetId,
     showAssetViewer,
-    invisible,
   };
 }
 

web/src/lib/utils/base-event-manager.svelte.ts

@@ -43,50 +43,6 @@ export class BaseEventManager<Events extends EventsBase> {
     };
   }
 
-  once<T extends keyof Events>(event: T, callback: EventCallback<Events, T>) {
-    const unsubscribe = this.#onEvent(event, (...args: Events[T]) => {
-      unsubscribe();
-      return callback(...args);
-    });
-    return unsubscribe;
-  }
-
-  untilNext<T extends keyof Events>(
-    event: T,
-    { timeoutMs = 10_000, signal }: { timeoutMs?: number; signal?: AbortSignal } = {},
-  ): Promise<Events[T] extends [] ? void : Events[T][0]> {
-    type Result = Events[T] extends [] ? void : Events[T][0];
-    return new Promise<Result>((resolve, reject) => {
-      let settled = false;
-      const settle = () => {
-        if (settled) {
-          return false;
-        }
-        settled = true;
-        unsubscribe();
-        clearTimeout(timer);
-        signal?.removeEventListener('abort', onAbort);
-        return true;
-      };
-      const unsubscribe = this.once(event, (...args: Events[T]) => {
-        if (settle()) {
-          resolve(args[0] as Result);
-        }
-      });
-      const timer = setTimeout(() => {
-        if (settle()) {
-          reject(new Error(`untilNext('${String(event)}') timed out after ${timeoutMs}ms`));
-        }
-      }, timeoutMs);
-      const onAbort = () => {
-        if (settle()) {
-          resolve(undefined as Result);
-        }
-      };
-      signal?.addEventListener('abort', onAbort, { once: true });
-    });
-  }
-
   emit<T extends keyof Events>(event: T, ...params: Events[T]) {
     const listeners = this.getListeners(event);
     for (const listener of listeners) {

web/src/lib/utils/invocationTracker.ts

@@ -1,36 +1,66 @@
+import { handleError } from '$lib/utils/handle-error';
+
+/**
+ * Tracks the state of asynchronous invocations to handle race conditions and stale operations.
+ * This class helps manage concurrent operations by tracking which invocations are active
+ * and allowing operations to check if they're still valid.
+ */
 export class InvocationTracker {
+  /** Counter for the number of invocations that have been started */
   invocationsStarted = 0;
+  /** Counter for the number of invocations that have been completed */
   invocationsEnded = 0;
 
+  constructor() {}
+
+  /**
+   * Starts a new invocation and returns an object with utilities to manage the invocation lifecycle.
+   * @returns  An object containing methods to manage the invocation:
+   *   - isInvalidInvocationError: Checks if an error is an invalid invocation error
+   *   - checkStillValid: Throws an error if the invocation is no longer valid
+   *   - endInvocation: Marks the invocation as complete
+   */
   startInvocation() {
     this.invocationsStarted++;
     const invocation = this.invocationsStarted;
 
     return {
-      isStillValid: () => invocation === this.invocationsStarted,
+      /**
+       * Throws an error if this invocation is no longer valid
+       * @throws {Error} If the invocation is no longer valid
+       */
+      isStillValid: () => {
+        if (invocation !== this.invocationsStarted) {
+          return false;
+        }
+        return true;
+      },
+
+      /**
+       * Marks this invocation as complete
+       */
       endInvocation: () => {
-        this.invocationsEnded = Math.max(this.invocationsEnded, invocation);
+        this.invocationsEnded = invocation;
       },
     };
   }
 
+  /**
+   * Checks if there are any active invocations
+   * @returns True if there are active invocations, false otherwise
+   */
   isActive() {
     return this.invocationsStarted !== this.invocationsEnded;
   }
 
-  async invoke<T>(invocable: () => Promise<T>, catchCallback?: (error: unknown) => void, finallyCallback?: () => void) {
+  async invoke<T>(invocable: () => Promise<T>, localizedMessage: string) {
     const invocation = this.startInvocation();
     try {
       return await invocable();
     } catch (error: unknown) {
-      if (catchCallback) {
+      handleError(error, localizedMessage);
-        catchCallback(error);
-      } else {
-        console.error(error);
-      }
     } finally {
       invocation.endInvocation();
-      finallyCallback?.();
     }
   }
 }

web/src/lib/utils/transition-utils.ts

@@ -1,144 +0,0 @@
-import { goto } from '$app/navigation';
-import { eventManager } from '$lib/managers/event-manager.svelte';
-import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
-import { Route } from '$lib/route';
-import { tick } from 'svelte';
-
-export function startViewerTransition(
-  assetId: string,
-  navigate: () => void,
-  setTransitionId: (id: string | null) => void,
-) {
-  void viewTransitionManager.startTransition({
-    types: ['viewer'],
-    prepareOldSnapshot: () => {
-      setTransitionId(assetId);
-    },
-    performUpdate: async (signal) => {
-      setTransitionId(null);
-      const ready = eventManager.untilNext('ViewerOpenTransitionReady', { signal });
-      navigate();
-      await ready;
-      eventManager.emit('ViewerOpenTransition');
-      await tick();
-    },
-  });
-}
-
-let activeOverlay: HTMLElement | undefined;
-
-export function removeCrossfadeOverlay() {
-  if (activeOverlay) {
-    activeOverlay.remove();
-    activeOverlay = undefined;
-  }
-}
-
-export function navigateToTimeline(
-  assetId: string,
-  options: { types: string[]; prepareOldSnapshot?: () => void; onFinished?: () => void },
-) {
-  let heroOverlay: HTMLElement | null = null;
-  let hiddenElement: HTMLElement | null = null;
-
-  void viewTransitionManager.startTransition({
-    types: options.types,
-    prepareOldSnapshot: options.prepareOldSnapshot,
-    performUpdate: async () => {
-      const scrolled = eventManager.untilNext('TimelineScrolledToAsset');
-      await goto(Route.photos({ at: assetId }));
-      await scrolled;
-      await tick();
-
-      const element = document.querySelector<HTMLElement>(`[data-asset-id="${CSS.escape(assetId)}"]`);
-      if (!element) {
-        return;
-      }
-
-      const rect = element.getBoundingClientRect();
-      const img = element.querySelector('img');
-
-      hiddenElement = element;
-      element.style.visibility = 'hidden';
-
-      heroOverlay = document.createElement('div');
-      heroOverlay.style.cssText = `
-        position: fixed;
-        top: ${rect.top}px;
-        left: ${rect.left}px;
-        width: ${rect.width}px;
-        height: ${rect.height}px;
-        view-transition-name: hero;
-        pointer-events: none;
-        z-index: -1;
-        overflow: hidden;
-      `;
-      if (img?.src) {
-        heroOverlay.style.backgroundImage = `url("${CSS.escape(img.src)}")`;
-        heroOverlay.style.backgroundSize = 'cover';
-        heroOverlay.style.backgroundPosition = 'center';
-      }
-      document.body.append(heroOverlay);
-    },
-    onFinished: () => {
-      heroOverlay?.remove();
-      heroOverlay = null;
-      if (hiddenElement) {
-        hiddenElement.style.visibility = '';
-        hiddenElement = null;
-      }
-      options.onFinished?.();
-    },
-  });
-}
-
-export async function crossfadeViewerContent(updateFn: () => void | Promise<void>, duration = 200) {
-  const viewerContent = document.querySelector<HTMLElement>('[data-viewer-content]');
-  if (!viewerContent) {
-    await updateFn();
-    return;
-  }
-
-  removeCrossfadeOverlay();
-
-  const clone = viewerContent.cloneNode(true) as HTMLElement;
-  Object.assign(clone.style, {
-    position: 'absolute',
-    inset: '0',
-    zIndex: '1',
-    pointerEvents: 'none',
-  });
-  delete clone.dataset.viewerContent;
-  if (!viewerContent.parentElement) {
-    await updateFn();
-    return;
-  }
-  viewerContent.parentElement.append(clone);
-  activeOverlay = clone;
-
-  const ready = eventManager.untilNext('ViewerOpenTransitionReady');
-  await updateFn();
-
-  try {
-    await ready;
-  } catch {
-    clone.remove();
-    if (activeOverlay === clone) {
-      activeOverlay = undefined;
-    }
-    return;
-  }
-
-  const fadeOut = clone.animate([{ opacity: 1 }, { opacity: 0 }], {
-    duration,
-    easing: 'cubic-bezier(0.4, 0, 1, 1)',
-    fill: 'forwards',
-  });
-
-  void fadeOut.finished.then(() => {
-    clone.remove();
-    if (activeOverlay === clone) {
-      activeOverlay = undefined;
-    }
-  });
-}

web/src/lib/utils/tunables.ts

@@ -31,4 +31,8 @@ export const TUNABLES = {
   IMAGE_THUMBNAIL: {
     THUMBHASH_FADE_DURATION: getNumber(storage.getItem('THUMBHASH_FADE_DURATION'), 100),
   },
+  MINIMAP: {
+    FADE_DURATION: getNumber(storage.getItem('MINIMAP.FADE_DURATION'), 150),
+    HIDE_DELAY: getNumber(storage.getItem('MINIMAP.HIDE_DELAY'), 1500),
+  },
 };

web/src/routes/(user)/+layout.svelte

@@ -24,7 +24,7 @@
   });
 </script>
 
-<div class:invisible={$showAssetViewer}>
+<div class:display-none={$showAssetViewer}>
   {@render children?.()}
 </div>
 <UploadCover />
@@ -33,4 +33,7 @@
   :root {
     overscroll-behavior: none;
   }
+  .display-none {
+    display: none;
+  }
 </style>

web/src/routes/(user)/map/[[photos=photos]]/[[assetId=id]]/+page.svelte

@@ -6,16 +6,13 @@
   import { timeToLoadTheMap } from '$lib/constants';
   import Portal from '$lib/elements/Portal.svelte';
   import { featureFlagsManager } from '$lib/managers/feature-flags-manager.svelte';
-  import { viewTransitionManager } from '$lib/managers/ViewTransitionManager.svelte';
   import { Route } from '$lib/route';
   import { assetViewingStore } from '$lib/stores/asset-viewing.store';
   import { handlePromiseError } from '$lib/utils';
   import { delay } from '$lib/utils/asset-utils';
   import { navigate } from '$lib/utils/navigation';
   import { LoadingSpinner } from '@immich/ui';
-  import { linear } from 'svelte/easing';
   import { onDestroy } from 'svelte';
-  import { fly } from 'svelte/transition';
   import type { PageData } from './$types';
 
   interface Props {
@@ -44,14 +41,9 @@
     handlePromiseError(goto(Route.photos()));
   }
 
-  function onViewAssets(assetIds: string[]) {
+  async function onViewAssets(assetIds: string[]) {
-    void viewTransitionManager.startTransition({
+    await setAssetId(assetIds[0]);
-      types: ['viewer'],
+    closeTimelinePanel();
-      performUpdate: async () => {
-        await setAssetId(assetIds[0]);
-        closeTimelinePanel();
-      },
-    });
   }
 
   function onClusterSelect(assetIds: string[], bbox: SelectionBBox) {
@@ -85,10 +77,7 @@
       </div>
 
       {#if isTimelinePanelVisible && selectedClusterBBox}
-        <div
+        <div class="h-1/2 min-h-0 w-full pt-2 sm:h-full sm:w-1/3 sm:ps-2 sm:pt-0">
-          transition:fly={{ x: 400, duration: 150, easing: linear }}
-          class="h-1/2 min-h-0 w-full pt-2 sm:h-full sm:w-1/3 sm:ps-2 sm:pt-0"
-        >
           <MapTimelinePanel
             bbox={selectedClusterBBox}
             {selectedClusterIds}
@@ -100,7 +89,7 @@
     </div>
   </UserPageLayout>
   <Portal target="body">
-    {#if $showAssetViewer && !isTimelinePanelVisible}
+    {#if $showAssetViewer}
       {#await import('$lib/components/asset-viewer/asset-viewer.svelte') then { default: AssetViewer }}
         <AssetViewer
           cursor={{ current: $viewingAsset }}

web/src/routes/+layout.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { afterNavigate, beforeNavigate, goto, onNavigate } from '$app/navigation';
+  import { afterNavigate, beforeNavigate, goto } from '$app/navigation';
   import { page } from '$app/state';
   import { shortcut } from '$lib/actions/shortcut';
   import DownloadPanel from '$lib/components/asset-viewer/download-panel.svelte';
@@ -8,7 +8,6 @@
   import NavigationLoadingBar from '$lib/components/shared-components/navigation-loading-bar.svelte';
   import UploadPanel from '$lib/components/shared-components/upload-panel.svelte';
   import VersionAnnouncement from '$lib/components/VersionAnnouncement.svelte';
-  import { appManager } from '$lib/managers/app-manager.svelte';
   import { eventManager } from '$lib/managers/event-manager.svelte';
   import { serverConfigManager } from '$lib/managers/server-config-manager.svelte';
   import { themeManager } from '$lib/managers/theme-manager.svelte';
@@ -78,8 +77,6 @@
 
   let showNavigationLoadingBar = $state(false);
 
-  appManager.isAssetViewer = isAssetViewerRoute(page);
-
   const getMyImmichLink = () => {
     return new URL(page.url.pathname + page.url.search, 'https://my.immich.app');
   };
@@ -105,15 +102,8 @@
     showNavigationLoadingBar = true;
   });
 
-  onNavigate(({ to }) => {
+  afterNavigate(() => {
-    appManager.isAssetViewer = isAssetViewerRoute(to);
+    showNavigationLoadingBar = false;
-  });
-
-  afterNavigate(({ to, complete }) => {
-    appManager.isAssetViewer = isAssetViewerRoute(to);
-    void complete.finally(() => {
-      showNavigationLoadingBar = false;
-    });
   });
 
   const { serverRestarting } = websocketStore;