diff --git a/.changes/dashboard-hero-light-legibility.md b/.changes/dashboard-hero-light-legibility.md
new file mode 100644
index 000000000..f0dd60918
--- /dev/null
+++ b/.changes/dashboard-hero-light-legibility.md
@@ -0,0 +1,10 @@
+---
+type: fix
+area: dashboard
+---
+
+The dashboard hero stays readable in the light theme: titles without artwork
+get a light tinted backdrop instead of a dark slab, text keeps a solid backing
+over busy artwork (also in narrow windows), and the star rating is darker.
+Screen readers now find one stable "Dashboard" page heading and hear slide
+changes they make.
diff --git a/.changes/playback-embedded-mpv-slow-shell-selection.md b/.changes/playback-embedded-mpv-slow-shell-selection.md
new file mode 100644
index 000000000..61d0b1f1f
--- /dev/null
+++ b/.changes/playback-embedded-mpv-slow-shell-selection.md
@@ -0,0 +1,8 @@
+---
+type: fix
+area: playback
+---
+
+On Linux, the app no longer switches a saved Embedded MPV player back to the
+default player when your login shell is slow to start. It now keeps your
+choice until it knows for certain whether mpv is installed.
diff --git a/.changes/workspace-header-back-everywhere.md b/.changes/workspace-header-back-everywhere.md
new file mode 100644
index 000000000..f3994462f
--- /dev/null
+++ b/.changes/workspace-header-back-everywhere.md
@@ -0,0 +1,6 @@
+---
+type: feature
+area: workspace
+---
+
+Back is now always in the same place: Settings, search, Discover and actor pages use the Back button at the start of the top bar instead of their own. Any page you reached from another one also shows it, and it takes you to the previous page.
diff --git a/.changes/workspace-rail-traffic-light-gap.md b/.changes/workspace-rail-traffic-light-gap.md
new file mode 100644
index 000000000..dcb03ea74
--- /dev/null
+++ b/.changes/workspace-rail-traffic-light-gap.md
@@ -0,0 +1,6 @@
+---
+type: fix
+area: workspace
+---
+
+On macOS the side rail now starts level with the page content and the dashboard banner, so its first button no longer crowds the window's close, minimize and zoom buttons.
diff --git a/apps/electron-backend-e2e/src/dashboard-activation.e2e.ts b/apps/electron-backend-e2e/src/dashboard-activation.e2e.ts
index 51eb37830..745b78058 100644
--- a/apps/electron-backend-e2e/src/dashboard-activation.e2e.ts
+++ b/apps/electron-backend-e2e/src/dashboard-activation.e2e.ts
@@ -29,6 +29,11 @@ import {
     routePlayableStreams,
     startAndConfirmPlayback,
 } from './playable-stream-fixture';
+import {
+    addCurrentDetailToFavorites,
+    goBackFromDetail,
+    toggleFavoriteForChannel,
+} from './dashboard-e2e-flows';
 
 test.describe('Dashboard Activation', () => {
     test('opens live favorites in the collection route and movies/series in global collection detail views from the dashboard', async ({
@@ -305,38 +310,6 @@ function dashboardRailCardByTitle(
         .first();
 }
 
-async function goBackFromDetail(page: Page): Promise<void> {
-    // Return to the list: the header's Back is route-level in browse and
-    // watch alike (closing the player is the bar's own Close button).
-    const backButton = page.getByTestId('workspace-header-back');
-
-    await expect(backButton).toBeVisible({ timeout: 20000 });
-    try {
-        await backButton.click({ timeout: 5000 });
-    } catch {
-        await backButton.evaluate((button: HTMLButtonElement) =>
-            button.click()
-        );
-    }
-}
-
-// By accessible name, not class: the Xtream movie detail's favorite control is
-// an icon-only button that carries its label in aria-label, while series and
-// Stalker details still use the labeled variant. This matches both.
-async function addCurrentDetailToFavorites(page: Page): Promise<void> {
-    const addButton = page
-        .getByRole('button', { name: /add to favorites/i })
-        .first();
-
-    await expect(addButton).toBeVisible({ timeout: 20000 });
-    await addButton.click();
-    await expect(
-        page.getByRole('button', { name: /remove from favorites/i }).first()
-    ).toBeVisible({
-        timeout: 20000,
-    });
-}
-
 async function expectInlineCollectionDetail(
     page: Page,
     params: {
@@ -383,20 +356,3 @@ async function playFirstSeriesEpisode(page: Page): Promise<void> {
     await expect(episodeCard).toBeVisible({ timeout: 20000 });
     await episodeCard.click();
 }
-
-async function toggleFavoriteForChannel(
-    page: Page,
-    title: string
-): Promise<void> {
-    const item = page
-        .locator('[data-test-id="channel-item"]')
-        .filter({ hasText: title })
-        .first();
-
-    await expect(item).toBeVisible({ timeout: 20000 });
-    await item.hover();
-    await item.locator('.favorite-button').first().click();
-    await expect(item.locator('.favorite-button mat-icon').first()).toHaveText(
-        /star/
-    );
-}
diff --git a/apps/electron-backend-e2e/src/dashboard-e2e-flows.ts b/apps/electron-backend-e2e/src/dashboard-e2e-flows.ts
new file mode 100644
index 000000000..208900940
--- /dev/null
+++ b/apps/electron-backend-e2e/src/dashboard-e2e-flows.ts
@@ -0,0 +1,54 @@
+import type { Page } from '@playwright/test';
+import { expect } from './electron-test-fixtures';
+
+// Steps that put content on the dashboard: favourites from the Live TV list
+// and from a detail page, and the way back from that detail page.
+
+export async function goBackFromDetail(page: Page): Promise<void> {
+    // Return to the list: the header's Back is route-level in browse and
+    // watch alike (closing the player is the bar's own Close button).
+    const backButton = page.getByTestId('workspace-header-back');
+
+    await expect(backButton).toBeVisible({ timeout: 20000 });
+    try {
+        await backButton.click({ timeout: 5000 });
+    } catch {
+        await backButton.evaluate((button: HTMLButtonElement) =>
+            button.click()
+        );
+    }
+}
+
+// By accessible name, not class: the Xtream movie detail's favorite control is
+// an icon-only button that carries its label in aria-label, while series and
+// Stalker details still use the labeled variant. This matches both.
+export async function addCurrentDetailToFavorites(page: Page): Promise<void> {
+    const addButton = page
+        .getByRole('button', { name: /add to favorites/i })
+        .first();
+
+    await expect(addButton).toBeVisible({ timeout: 20000 });
+    await addButton.click();
+    await expect(
+        page.getByRole('button', { name: /remove from favorites/i }).first()
+    ).toBeVisible({
+        timeout: 20000,
+    });
+}
+
+export async function toggleFavoriteForChannel(
+    page: Page,
+    title: string
+): Promise<void> {
+    const item = page
+        .locator('[data-test-id="channel-item"]')
+        .filter({ hasText: title })
+        .first();
+
+    await expect(item).toBeVisible({ timeout: 20000 });
+    await item.hover();
+    await item.locator('.favorite-button').first().click();
+    await expect(item.locator('.favorite-button mat-icon').first()).toHaveText(
+        /star/
+    );
+}
diff --git a/apps/electron-backend-e2e/src/dashboard-hero-legibility.e2e.ts b/apps/electron-backend-e2e/src/dashboard-hero-legibility.e2e.ts
new file mode 100644
index 000000000..7accbb72e
--- /dev/null
+++ b/apps/electron-backend-e2e/src/dashboard-hero-legibility.e2e.ts
@@ -0,0 +1,355 @@
+import type { Locator, Page } from '@playwright/test';
+import { writeFileSync } from 'node:fs';
+import sharp = require('sharp');
+import {
+    addXtreamPortal,
+    clickCategoryByNameExact,
+    clickFirstGridListCard,
+    closeElectronApp,
+    defaultXtreamPassword,
+    defaultXtreamUsername,
+    expect,
+    goToDashboard,
+    launchElectronApp,
+    openWorkspaceSection,
+    resetMockServers,
+    test,
+    waitForXtreamWorkspaceReady,
+} from './electron-test-fixtures';
+import {
+    fetchXtreamLiveFixture,
+    fetchXtreamSeriesFixture,
+    fetchXtreamVodFixture,
+    getXtreamTitle,
+} from './portal-mock-fixtures';
+import { applyTheme, measureBackdropTextContrast } from './theme-contrast';
+import {
+    addCurrentDetailToFavorites,
+    goBackFromDetail,
+    toggleFavoriteForChannel,
+} from './dashboard-e2e-flows';
+
+// ---------------------------------------------------------------------------
+// The dashboard hero's text must stay legible over any artwork, in both
+// themes and in the narrow layout where the slide spans the whole width.
+// Every mock image is replaced by a black-and-white checkerboard, the worst
+// case for either theme's scrim; series images fail, so the favourited
+// series falls back to the generated gradient. Each slide kind (16:9
+// backdrop, blurred poster, no artwork, live channel) is measured from the
+// screen at a wide and a narrow content width.
+// ---------------------------------------------------------------------------
+
+type SlideKind = 'backdrop' | 'poster' | 'fallback' | 'live';
+
+const widths = { wide: 1280, narrow: 760 } as const;
+const minimumContrast = 4.5;
+const xtreamCredentials = {
+    username: defaultXtreamUsername,
+    password: defaultXtreamPassword,
+};
+/** A full TMDB slide has a rating and a two-line overview; the mock has no
+ * TMDB, so the measurement adds both, styled by the hero's own rules. */
+const sampleOverview =
+    'A long synopsis that wraps onto a second line, so the body text of a ' +
+    'fully enriched slide is measured where it really sits over the artwork.';
+
+async function busyArtwork(): Promise<Buffer> {
+    const width = 1280;
+    const height = 720;
+    const square = 40;
+    const pixels = Buffer.alloc(width * height * 3);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const white =
+                (Math.floor(x / square) + Math.floor(y / square)) % 2 === 0;
+            pixels.fill(
+                white ? 255 : 0,
+                (y * width + x) * 3,
+                (y * width + x) * 3 + 3
+            );
+        }
+    }
+    return sharp(pixels, { raw: { width, height, channels: 3 } })
+        .png()
+        .toBuffer();
+}
+
+/** Serves the checkerboard for every mock image except series artwork,
+ * which fails: an image the page has already shown is reused from memory,
+ * so the failure has to be in place before the series is first opened. */
+async function routeArtwork(page: Page): Promise<void> {
+    const image = await busyArtwork();
+    await page.route(
+        (url) => url.hostname === 'picsum.photos',
+        (route) =>
+            /\/seed\/series-/.test(route.request().url())
+                ? route.fulfill({ status: 404, body: '' })
+                : route.fulfill({
+                      status: 200,
+                      contentType: 'image/png',
+                      body: image,
+                  })
+    );
+}
+
+async function slideKinds(page: Page): Promise<SlideKind[]> {
+    return page.locator('.hero__backdrop').evaluateAll((backdrops) =>
+        backdrops.map((backdrop): SlideKind => {
+            if (backdrop.classList.contains('hero__backdrop--live')) {
+                return 'live';
+            }
+            if (!backdrop.querySelector('.hero__backdrop-image')) {
+                return 'fallback';
+            }
+            return backdrop.classList.contains('hero__backdrop--poster')
+                ? 'poster'
+                : 'backdrop';
+        })
+    );
+}
+
+async function showSlide(page: Page, index: number): Promise<Locator> {
+    const dot = page.getByTestId('dashboard-hero-dot').nth(index);
+    await dot.click();
+    await expect(dot).toHaveAttribute('aria-current', 'true');
+    // The backdrop crossfade and the slide's entrance have finished (not the
+    // image's slow zoom, which never changes what is under the text).
+    await expect
+        .poll(() =>
+            page.evaluate(() =>
+                [
+                    document.querySelector('.hero__backdrop--active'),
+                    document.querySelector('.hero__content'),
+                ].every(
+                    (element) =>
+                        element &&
+                        element
+                            .getAnimations()
+                            .every(
+                                (animation) => animation.playState !== 'running'
+                            )
+                )
+            )
+        )
+        .toBe(true);
+    return page.getByTestId('dashboard-hero-slide');
+}
+
+/** Sum of non-input layout shifts while the hero runs through every slide
+ * on its own, at a shortened interval. */
+async function rotationLayoutShift(page: Page): Promise<number> {
+    const hero = page.getByTestId('dashboard-hero');
+    const dots = page.getByTestId('dashboard-hero-dot');
+    const count = await dots.count();
+    await page.mouse.move(1, 1);
+    await hero.evaluate((element) => {
+        (element as HTMLElement).style.setProperty(
+            '--hero-rotation-ms',
+            '600ms'
+        );
+        const shifts: number[] = [];
+        new PerformanceObserver((list) => {
+            for (const entry of list.getEntries() as (PerformanceEntry & {
+                value: number;
+                hadRecentInput: boolean;
+            })[]) {
+                if (!entry.hadRecentInput) {
+                    shifts.push(entry.value);
+                }
+            }
+        }).observe({ type: 'layout-shift' });
+        (window as unknown as { __heroShifts: number[] }).__heroShifts = shifts;
+    });
+    // Back to the first slide after one full cycle, then a quiet moment.
+    const first = await dots.evaluateAll((all) =>
+        all.findIndex((dot) => dot.getAttribute('aria-current') === 'true')
+    );
+    for (let step = 1; step <= count; step++) {
+        await expect(dots.nth((first + step) % count)).toHaveAttribute(
+            'aria-current',
+            'true',
+            { timeout: 5_000 }
+        );
+    }
+    await page.waitForTimeout(500);
+    return page.evaluate(() =>
+        (window as unknown as { __heroShifts: number[] }).__heroShifts.reduce(
+            (sum, value) => sum + value,
+            0
+        )
+    );
+}
+
+/** Adds what a TMDB-enriched slide shows: a rating chip and an overview. */
+async function enrichSlide(slide: Locator): Promise<void> {
+    await slide.evaluate((content, overview) => {
+        const chip = content.querySelector('.hero__pill');
+        if (chip) {
+            const rating = chip.cloneNode() as HTMLElement;
+            rating.classList.add('meta-chip--rating');
+            rating.textContent = '★ 7.4';
+            chip.before(rating);
+        }
+        // The overview takes the title's view encapsulation attribute, so the
+        // hero's `.hero__description` rule styles it.
+        const title = content.querySelector('.hero__title');
+        const scope = Array.from(title?.attributes ?? []).find((attribute) =>
+            attribute.name.startsWith('_ngcontent')
+        );
+        const actions = content.querySelector('.hero__actions');
+        if (scope && actions && !content.querySelector('.hero__description')) {
+            const description = document.createElement('p');
+            description.setAttribute(scope.name, '');
+            description.className = 'hero__description';
+            description.textContent = overview;
+            actions.before(description);
+        }
+    }, sampleOverview);
+    await expect(slide.locator('.hero__description')).toHaveCount(1);
+}
+
+/** Every piece of slide text a viewer reads, one element per colour. */
+function slideTexts(slide: Locator): Record<string, Locator> {
+    return {
+        eyebrow: slide.locator('.hero__eyebrow > span:not(.hero__eyebrow-sep)'),
+        title: slide.locator('.hero__title'),
+        pill: slide.locator('.hero__pill'),
+        programme: slide.locator('.hero__programme'),
+        description: slide.locator('.hero__description'),
+        button: slide.locator('.hero__button > span'),
+    };
+}
+
+test.describe('Dashboard hero legibility', () => {
+    test('keeps slide text at 4.5:1 over any artwork in both themes and widths', async ({
+        dataDir,
+        request,
+    }, testInfo) => {
+        test.setTimeout(240_000);
+        await resetMockServers(request, ['xtream']);
+        const live = await fetchXtreamLiveFixture(request, xtreamCredentials);
+        const vod = await fetchXtreamVodFixture(request, xtreamCredentials);
+        const series = await fetchXtreamSeriesFixture(
+            request,
+            xtreamCredentials
+        );
+        const app = await launchElectronApp(dataDir);
+        const page = app.mainWindow;
+        const results: string[] = [];
+
+        try {
+            await routeArtwork(page);
+            await page.setViewportSize({ width: widths.wide, height: 800 });
+            await addXtreamPortal(page);
+            await waitForXtreamWorkspaceReady(page);
+
+            // Live slide: a favourite channel with a programme on air.
+            await openWorkspaceSection(page, 'Live TV');
+            await clickCategoryByNameExact(page, live.categoryName);
+            await toggleFavoriteForChannel(page, getXtreamTitle(live.items[0]));
+            // Backdrop slide: favouriting from the detail page stores the
+            // movie's 16:9 backdrop.
+            await page
+                .getByRole('link', { name: 'Movies', exact: true })
+                .click();
+            await clickCategoryByNameExact(page, vod.categoryName);
+            await clickFirstGridListCard(page);
+            await addCurrentDetailToFavorites(page);
+            await goBackFromDetail(page);
+            // No-artwork slide: series images fail, poster and backdrop.
+            await page
+                .getByRole('link', { name: 'Series', exact: true })
+                .click();
+            await clickCategoryByNameExact(page, series.categoryName);
+            await clickFirstGridListCard(page);
+            await addCurrentDetailToFavorites(page);
+
+            await goToDashboard(page);
+            await expect(page.getByTestId('dashboard-hero')).toBeVisible({
+                timeout: 20_000,
+            });
+            // Poster-only slides come from the Xtream "recently added" list.
+            await expect
+                .poll(async () => [...new Set(await slideKinds(page))].sort(), {
+                    timeout: 20_000,
+                })
+                .toEqual(['backdrop', 'fallback', 'live', 'poster']);
+
+            // One stable page heading; the rotating slide title is an h2.
+            await expect(page.locator('h1')).toHaveCount(1);
+            await expect(page.getByTestId('dashboard-page-heading')).toHaveText(
+                'Dashboard'
+            );
+            await expect(
+                page
+                    .getByTestId('dashboard-hero-slide')
+                    .locator('h2.hero__title')
+            ).toHaveCount(1);
+
+            // An unattended rotation, counted like the launch journey's
+            // settled layout-shift counter (non-input shifts only). Slides of
+            // different heights still resize the hero by a few pixels and
+            // move the rails below (0.005 here, 0.013 before this change);
+            // a scrim or heading that reflowed the slide would add lines.
+            const shift = await rotationLayoutShift(page);
+            results.push(`rotation layout shift ${shift.toFixed(3)}`);
+            expect(shift).toBeLessThan(0.02);
+
+            await page.getByTestId('dashboard-hero-pause').click();
+            const kinds = await slideKinds(page);
+            for (const theme of ['light', 'dark'] as const) {
+                await applyTheme(page, theme);
+                for (const [layout, width] of Object.entries(widths)) {
+                    await page.setViewportSize({ width, height: 800 });
+                    // The narrow layout is the dashboard container's
+                    // ≤720px query, not the window width.
+                    const narrow = await page
+                        .locator('.hero__content')
+                        .evaluate(
+                            (content) =>
+                                getComputedStyle(content).maxWidth === 'none'
+                        );
+                    expect(narrow).toBe(layout === 'narrow');
+                    for (const [index, kind] of kinds.entries()) {
+                        const slide = await showSlide(page, index);
+                        await enrichSlide(slide);
+                        await page.mouse.move(1, 1);
+                        const name = `${theme}-${layout}-${kind}`;
+                        const shot = testInfo.outputPath(`hero-${name}.png`);
+                        await page
+                            .getByTestId('dashboard-hero')
+                            .screenshot({ path: shot });
+                        await testInfo.attach(name, {
+                            path: shot,
+                            contentType: 'image/png',
+                        });
+                        for (const [part, texts] of Object.entries(
+                            slideTexts(slide)
+                        )) {
+                            for (const text of await texts.all()) {
+                                const ratio = await measureBackdropTextContrast(
+                                    page,
+                                    text
+                                );
+                                results.push(
+                                    `${name} ${part} ${ratio.toFixed(2)}`
+                                );
+                                expect
+                                    .soft(ratio, `${name} ${part}`)
+                                    .toBeGreaterThanOrEqual(minimumContrast);
+                            }
+                        }
+                    }
+                }
+            }
+        } finally {
+            const report = testInfo.outputPath('contrast.txt');
+            writeFileSync(report, results.join('\n'));
+            await testInfo.attach('contrast', {
+                path: report,
+                contentType: 'text/plain',
+            });
+            await closeElectronApp(app);
+        }
+    });
+});
diff --git a/apps/electron-backend-e2e/src/detail-header-back.e2e.ts b/apps/electron-backend-e2e/src/detail-header-back.e2e.ts
index 2f8a4ec57..7be2f2e85 100644
--- a/apps/electron-backend-e2e/src/detail-header-back.e2e.ts
+++ b/apps/electron-backend-e2e/src/detail-header-back.e2e.ts
@@ -24,6 +24,11 @@ import {
 // The "Episodes" heading must also stay on one line: the detail pane is far
 // narrower than the window beside the rail and category panel, and the
 // heading used to wrap beside its actions.
+//
+// Pages without a Back of their own (the list a detail returns to) get the
+// header's history fallback while an in-app previous page exists; on a
+// phone it yields to the drawer toggle, and with nowhere to go the slot is
+// empty rather than a disabled arrow.
 // ---------------------------------------------------------------------------
 
 const widths = [1280, 780, 375];
@@ -45,6 +50,16 @@ function headerBack(page: Page): Locator {
     return page.getByTestId('workspace-header-back');
 }
 
+/**
+ * The generic history Back. A detail's own Back advertises Escape in browse;
+ * the fallback runs no page handler, so it advertises none.
+ */
+async function expectHistoryBack(page: Page): Promise<void> {
+    await expect(headerBack(page)).toBeVisible();
+    await expect(headerBack(page)).toHaveAccessibleName('Back');
+    await expect(headerBack(page)).not.toHaveAttribute('aria-keyshortcuts');
+}
+
 /** Line boxes of the heading's text; 1 means it did not wrap. */
 function headingLineCount(page: Page): Promise<number> {
     return page
@@ -228,12 +243,15 @@ async function startFirstEpisode(page: Page): Promise<void> {
     ).toBeVisible({ timeout: 20_000 });
 }
 
-/** The header Back leaves the detail and is gone from the list it opens. */
+/**
+ * The header Back leaves the detail; the list it opens keeps only the
+ * history fallback (it was itself reached by navigation).
+ */
 async function expectHeaderBackReturnsToList(page: Page): Promise<void> {
     await headerBack(page).click();
     await expect(page).not.toHaveURL(detailUrlPattern);
     await expect(page.locator('app-portal-detail-shell')).toHaveCount(0);
-    await expect(headerBack(page)).toHaveCount(0);
+    await expectHistoryBack(page);
 }
 
 test.describe('Portal detail header Back', () => {
@@ -248,7 +266,7 @@ test.describe('Portal detail header Back', () => {
             const page = app.mainWindow;
             await addXtreamPortal(page);
             await waitForXtreamWorkspaceReady(page);
-            await expect(headerBack(page)).toHaveCount(0);
+            await expectHistoryBack(page);
 
             const detailUrl = await openFirstSeries(page);
             await expectBackInHeader(page, 'browse');
@@ -287,4 +305,45 @@ test.describe('Portal detail header Back', () => {
             await closeElectronApp(app);
         }
     });
+
+    test('@xtream @electron falls back to history where no page offers Back', async ({
+        dataDir,
+        request,
+    }) => {
+        await resetMockServers(request, ['xtream']);
+        const app = await launchElectronApp(dataDir);
+
+        try {
+            const page = app.mainWindow;
+            await page.waitForURL(/\/workspace\//);
+            const startUrl = page.url();
+            // The first page of the session has nowhere to go back to: the
+            // slot is empty, not a disabled arrow.
+            await expect(headerBack(page)).toHaveCount(0);
+
+            await addXtreamPortal(page);
+            await waitForXtreamWorkspaceReady(page);
+            const listUrl = page.url();
+            await expectHistoryBack(page);
+
+            // On a phone the list's drawer toggle keeps the slot: it is the
+            // only way into the categories.
+            await page.setViewportSize({ width: 375, height: 800 });
+            await expect(page.getByTestId('context-drawer-toggle')).toBeVisible();
+            await expect(headerBack(page)).toBeHidden();
+
+            await page.setViewportSize({ width: widths[0], height: 800 });
+            await headerBack(page).click();
+            await expect(page).toHaveURL(startUrl);
+            await expect(headerBack(page)).toHaveCount(0);
+
+            // Forward history is not offered; browser Forward still works and
+            // brings the fallback back.
+            await page.goForward();
+            await expect(page).toHaveURL(listUrl);
+            await expectHistoryBack(page);
+        } finally {
+            await closeElectronApp(app);
+        }
+    });
 });
diff --git a/apps/electron-backend-e2e/src/performance/zoneless-migration.spec.ts b/apps/electron-backend-e2e/src/performance/zoneless-migration.spec.ts
new file mode 100644
index 000000000..f9a67c9d7
--- /dev/null
+++ b/apps/electron-backend-e2e/src/performance/zoneless-migration.spec.ts
@@ -0,0 +1,119 @@
+/* eslint-disable playwright/expect-expect -- These are Node assertion-based repository contract tests. */
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+// docs/architecture/zoneless-migration.md lists every component that still
+// opts out of OnPush. This keeps the checklist and the code in step: a new
+// Eager component fails here, and so does a converted one left unticked.
+
+const workspaceRoot = fileURLToPath(new URL('../../../../', import.meta.url));
+const checklistPath = 'docs/architecture/zoneless-migration.md';
+const sourceRoots = ['apps', 'libs'];
+const skippedDirectories = new Set([
+    'node_modules',
+    'dist',
+    'coverage',
+    'test-stubs',
+]);
+// Test-only files follow the repository's `.spec` / `.test` naming, with an
+// optional suffix of one or more segments (`.spec-stubs.ts`,
+// `.test-helpers.ts`, `.test-data-stubs.ts`).
+const testOnlyFile = /(\.(spec|test)(-\w+)*|^test-setup)\.ts$/;
+
+function listProductionSources(directory: string): string[] {
+    const files: string[] = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (skippedDirectories.has(entry.name)) continue;
+            if (entry.name.endsWith('-e2e')) continue;
+            files.push(...listProductionSources(path));
+        } else if (
+            entry.name.endsWith('.ts') &&
+            !entry.name.endsWith('.d.ts') &&
+            !testOnlyFile.test(entry.name)
+        ) {
+            files.push(relative(workspaceRoot, path).split(sep).join('/'));
+        }
+    }
+    return files;
+}
+
+function readSources(): Map<string, string> {
+    const sources = new Map<string, string>();
+    for (const root of sourceRoots) {
+        for (const file of listProductionSources(join(workspaceRoot, root))) {
+            sources.set(file, readFileSync(join(workspaceRoot, file), 'utf8'));
+        }
+    }
+    return sources;
+}
+
+function readEagerChecklist(): { open: string[]; done: string[] } {
+    const markdown = readFileSync(join(workspaceRoot, checklistPath), 'utf8');
+    const section = markdown.split(/^## Eager components$/m)[1];
+    assert.ok(
+        section,
+        `${checklistPath} must have an "Eager components" section`
+    );
+    const body = section.split(/^## /m)[0];
+    const open: string[] = [];
+    const done: string[] = [];
+    for (const match of body.matchAll(/^- \[( |x)\] `([^`]+\.ts)`/gm)) {
+        (match[1] === 'x' ? done : open).push(match[2]);
+    }
+    return { open: open.sort(), done: done.sort() };
+}
+
+const sources = readSources();
+
+test('the zoneless checklist lists exactly the components that are still Eager', () => {
+    const eager = [...sources]
+        .filter(([, text]) => text.includes('ChangeDetectionStrategy.Eager'))
+        .map(([file]) => file)
+        .sort();
+    const { open } = readEagerChecklist();
+
+    assert.deepEqual(
+        eager,
+        open,
+        `Production files with ChangeDetectionStrategy.Eager must match the unticked entries in ${checklistPath}. ` +
+            'Do not add Eager components; tick an entry when its component is converted.'
+    );
+});
+
+test('the guard skips test-only file names and keeps production ones', () => {
+    for (const name of [
+        'player.component.spec.ts',
+        'serial-details.test-stubs.ts',
+        'dashboard.spec-stubs.ts',
+        'rail.test-data-stubs.ts',
+        'test-setup.ts',
+    ]) {
+        assert.ok(testOnlyFile.test(name), `${name} is test-only`);
+    }
+    for (const name of [
+        'player.component.ts',
+        'spec-utils.ts',
+        'contest.ts',
+        'latest-setup.ts',
+        'testing.service.ts',
+    ]) {
+        assert.ok(!testOnlyFile.test(name), `${name} ships`);
+    }
+});
+
+test('ticked checklist entries name files that exist', () => {
+    for (const file of readEagerChecklist().done) {
+        assert.ok(sources.has(file), `${file} is ticked but does not exist`);
+    }
+});
+
+test('no production component uses the deprecated Default strategy alias', () => {
+    for (const [file, text] of sources) {
+        assert.doesNotMatch(text, /ChangeDetectionStrategy\.Default\b/, file);
+    }
+});
diff --git a/apps/electron-backend-e2e/src/search.e2e.ts b/apps/electron-backend-e2e/src/search.e2e.ts
index 257c903f3..e3a97d7a3 100644
--- a/apps/electron-backend-e2e/src/search.e2e.ts
+++ b/apps/electron-backend-e2e/src/search.e2e.ts
@@ -638,6 +638,18 @@ test.describe('Electron Workspace Search', () => {
             await expect(
                 xtreamSearchResultCards(app.mainWindow).first()
             ).toBeVisible({ timeout: 20000 });
+
+            // The search page's Back is the header's leading button, not an
+            // arrow beside its title, and it returns to the dashboard.
+            const headerBack = app.mainWindow.getByTestId(
+                'workspace-header-back'
+            );
+            await expect(headerBack).toBeVisible();
+            await expect(
+                app.mainWindow.getByRole('button', { name: 'Back', exact: true })
+            ).toHaveCount(1);
+            await headerBack.click();
+            await expectPathname(app.mainWindow, /\/workspace\/dashboard$/);
         } finally {
             await closeElectronApp(app);
         }
diff --git a/apps/electron-backend-e2e/src/theme-contrast.ts b/apps/electron-backend-e2e/src/theme-contrast.ts
index ab8ac2cf0..895698d31 100644
--- a/apps/electron-backend-e2e/src/theme-contrast.ts
+++ b/apps/electron-backend-e2e/src/theme-contrast.ts
@@ -198,3 +198,98 @@ export async function expectSkeletonContrast(
         ).toBeGreaterThanOrEqual(1.3);
     }
 }
+
+/** Contrast of an element's own text against whatever is painted behind it
+ * (images, gradient scrims, translucent chips), read back from the screen.
+ * The text is made transparent for the capture, so its `text-shadow` stays
+ * in the backdrop it is meant to support; its CSS colour (with alpha and
+ * ancestor opacity) is then composited over every pixel under its line
+ * boxes. Returns the worst ratio, so one dark patch of artwork under one
+ * letter fails it. */
+export async function measureBackdropTextContrast(
+    page: Page,
+    text: Locator
+): Promise<number> {
+    await expect(text).toBeVisible();
+    const probe = await text.evaluate((element) => {
+        const canvas = document.createElement('canvas');
+        canvas.width = canvas.height = 1;
+        const ctx = canvas.getContext('2d')!;
+        ctx.fillStyle = getComputedStyle(element).color;
+        ctx.fillRect(0, 0, 1, 1);
+        const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
+        let alpha = a / 255;
+        for (
+            let node: Element | null = element;
+            node;
+            node = node.parentElement
+        ) {
+            alpha *= Number(getComputedStyle(node).opacity);
+        }
+        const range = document.createRange();
+        range.selectNodeContents(element);
+        const box = range.getBoundingClientRect();
+        const style = (element as HTMLElement).style;
+        const previous = style.getPropertyValue('color');
+        style.setProperty('color', 'transparent', 'important');
+        (element as HTMLElement).dataset['contrastPrevious'] = previous;
+        return {
+            color: [r, g, b, alpha],
+            // Whole pixels inside the line boxes, clear of glyph edges that
+            // spill past them.
+            clip: {
+                x: Math.ceil(box.left),
+                y: Math.ceil(box.top),
+                width: Math.max(1, Math.floor(box.width) - 1),
+                height: Math.max(1, Math.floor(box.height) - 1),
+            },
+        };
+    });
+    try {
+        const { data, info } = await sharp(
+            await page.screenshot({ clip: probe.clip })
+        )
+            .removeAlpha()
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        const [fr, fg, fb, fa] = probe.color;
+        const luminance = (r: number, g: number, b: number) =>
+            [r, g, b]
+                .map((value) => {
+                    const s = value / 255;
+                    return s <= 0.04045
+                        ? s / 12.92
+                        : ((s + 0.055) / 1.055) ** 2.4;
+                })
+                .reduce(
+                    (sum, value, index) =>
+                        sum + value * [0.2126, 0.7152, 0.0722][index],
+                    0
+                );
+        let worst = Infinity;
+        for (let i = 0; i < data.length; i += info.channels) {
+            const [br, bg, bb] = [data[i], data[i + 1], data[i + 2]];
+            const front = luminance(
+                fr * fa + br * (1 - fa),
+                fg * fa + bg * (1 - fa),
+                fb * fa + bb * (1 - fa)
+            );
+            const back = luminance(br, bg, bb);
+            worst = Math.min(
+                worst,
+                (Math.max(front, back) + 0.05) / (Math.min(front, back) + 0.05)
+            );
+        }
+        return worst;
+    } finally {
+        await text.evaluate((element) => {
+            const style = (element as HTMLElement).style;
+            const previous = (element as HTMLElement).dataset[
+                'contrastPrevious'
+            ];
+            style.removeProperty('color');
+            if (previous) style.setProperty('color', previous);
+            delete (element as HTMLElement).dataset['contrastPrevious'];
+        });
+    }
+}
diff --git a/apps/electron-backend-e2e/src/window-controls.e2e.ts b/apps/electron-backend-e2e/src/window-controls.e2e.ts
index d65b463bd..da90fec62 100644
--- a/apps/electron-backend-e2e/src/window-controls.e2e.ts
+++ b/apps/electron-backend-e2e/src/window-controls.e2e.ts
@@ -187,3 +187,69 @@ test.describe('Custom window controls', () => {
         }
     });
 });
+
+test.describe('macOS traffic lights', () => {
+    test.skip(
+        process.platform !== 'darwin',
+        'Only macOS draws the native traffic lights over the rail'
+    );
+
+    test('@electron the first rail link starts with the content area, clear of the lights', async ({
+        dataDir,
+    }) => {
+        const app = await launchElectronApp(dataDir);
+
+        try {
+            const page = app.mainWindow;
+            await expect(page.locator('.app-rail')).toHaveClass(/is-macos/);
+            const firstLink = page.locator('.app-rail a').first();
+            await expect(firstLink).toBeVisible();
+
+            const [linkBox, contentBox] = await Promise.all([
+                firstLink.boundingBox(),
+                page.locator('.workspace-content').boundingBox(),
+            ]);
+            // Aligned with the content area, where the dashboard hero starts.
+            expect(
+                Math.abs((linkBox?.y ?? 0) - (contentBox?.y ?? -100))
+            ).toBeLessThanOrEqual(1);
+
+            const lights = await app.electronApp.evaluate(({ BrowserWindow }) =>
+                BrowserWindow.getAllWindows()[0]?.getWindowButtonPosition()
+            );
+            expect(lights, 'native window button position').toBeTruthy();
+            const lightsY = lights?.y ?? Number.NaN;
+            // The buttons are about 14pt tall; keep a visible gap below them,
+            // measured in window pixels (CSS pixels times the zoom factor).
+            const linkTopInWindowPixels = async (): Promise<number> => {
+                const [box, zoom] = await Promise.all([
+                    firstLink.boundingBox(),
+                    page.evaluate(() => window.outerWidth / window.innerWidth),
+                ]);
+                return (box?.y ?? Number.NaN) * zoom;
+            };
+            expect(await linkTopInWindowPixels()).toBeGreaterThanOrEqual(
+                lightsY + 14 + 16
+            );
+
+            // App zoom scales CSS pixels but not the native buttons: at the
+            // smallest zoom the inset must still clear them.
+            for (let step = 0; step < 8; step++) {
+                await page.evaluate(() =>
+                    window.electron.adjustZoomLevel('out')
+                );
+            }
+            await expect
+                .poll(() =>
+                    page.evaluate(() => window.outerWidth / window.innerWidth)
+                )
+                .toBeLessThan(0.6);
+            await expect
+                .poll(linkTopInWindowPixels)
+                .toBeGreaterThanOrEqual(lightsY + 14 + 8);
+            await page.evaluate(() => window.electron.adjustZoomLevel('reset'));
+        } finally {
+            await closeElectronApp(app);
+        }
+    });
+});
diff --git a/apps/electron-backend/src/app/events/embedded-mpv.events.login-shell.spec.ts b/apps/electron-backend/src/app/events/embedded-mpv.events.login-shell.spec.ts
new file mode 100644
index 000000000..8fab35178
--- /dev/null
+++ b/apps/electron-backend/src/app/events/embedded-mpv.events.login-shell.spec.ts
@@ -0,0 +1,198 @@
+/**
+ * The Linux native-view support check end to end in the main process: the
+ * real IPC handlers, native service and login shell PATH lookup. Only the
+ * process boundary is faked: the shell (`readPath`), `mpv --version`
+ * (`spawnSync`) and Electron. `process.platform` is forced here, so the
+ * Linux branch runs on every host.
+ */
+import {
+    EMBEDDED_MPV_PREPARE,
+    EMBEDDED_MPV_SUPPORT,
+    type EmbeddedMpvSupport,
+} from '@iptvnator/shared/interfaces';
+
+const mockSpawnSync = jest.fn();
+const mockIpcHandle = jest.fn();
+
+jest.mock('child_process', () => ({ spawnSync: mockSpawnSync }));
+jest.mock('electron', () => ({
+    app: {
+        isPackaged: true,
+        getAppPath: () => '/mock/app.asar',
+        commandLine: { getSwitchValue: () => '' },
+    },
+    ipcMain: { handle: mockIpcHandle },
+    powerSaveBlocker: {
+        start: jest.fn(),
+        stop: jest.fn(),
+        isStarted: jest.fn(),
+    },
+    screen: { getDisplayMatching: jest.fn() },
+}));
+jest.mock('../app', () => ({
+    __esModule: true,
+    default: { mainWindow: null },
+}));
+jest.mock('../services/embedded-mpv-session-options', () => ({
+    readEmbeddedMpvSessionOptions: () => ({
+        extraOptions: [],
+        autoReconnect: true,
+    }),
+}));
+jest.mock('../services/embedded-mpv-frame-copy-platform.util', () => ({
+    ...jest.requireActual('../services/embedded-mpv-frame-copy-platform.util'),
+    getFrameCopyRuntimeAvailability: () => ({
+        usable: false,
+        reason: 'helper-probe-failed',
+    }),
+    isFrameCopyRuntimeUsable: () => false,
+}));
+
+const INHERITED_PATH = '/usr/bin:/bin';
+const LOGIN_SHELL_ONLY_DIR = '/home/user/.local/bin';
+const LOGIN_SHELL_PATH = `${LOGIN_SHELL_ONLY_DIR}:${INHERITED_PATH}`;
+/** Budget of the lookup; the shell in these tests never answers within it. */
+const LOOKUP_BUDGET_MS = 5;
+
+type SupportHandler = (event: unknown) => Promise<EmbeddedMpvSupport>;
+
+async function flushLookup(): Promise<void> {
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+}
+
+describe('Embedded MPV support and a slow login shell (Linux native-view)', () => {
+    const originalPlatform = process.platform;
+    const originalEnv = {
+        PATH: process.env.PATH,
+        DISPLAY: process.env.DISPLAY,
+        WAYLAND_DISPLAY: process.env.WAYLAND_DISPLAY,
+        IPTVNATOR_ENABLE_EMBEDDED_MPV_FRAME_COPY:
+            process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_FRAME_COPY,
+    };
+    let answerShell: (path: string) => void;
+
+    function handlerFor(channel: string): SupportHandler {
+        const registration = mockIpcHandle.mock.calls.find(
+            ([registered]) => registered === channel
+        );
+        if (!registration) {
+            throw new Error(`Missing ipcMain handler for ${channel}`);
+        }
+        return registration[1] as SupportHandler;
+    }
+
+    beforeEach(async () => {
+        jest.resetModules();
+        mockIpcHandle.mockReset();
+        mockSpawnSync.mockReset();
+        // mpv is installed where only the login shell PATH reaches it.
+        mockSpawnSync.mockImplementation(() => ({
+            status: (process.env.PATH ?? '')
+                .split(':')
+                .includes(LOGIN_SHELL_ONLY_DIR)
+                ? 0
+                : 1,
+        }));
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        process.env.PATH = INHERITED_PATH;
+        process.env.DISPLAY = ':0';
+        delete process.env.WAYLAND_DISPLAY;
+        delete process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_FRAME_COPY;
+
+        const { scheduleDeferredFixPath } =
+            await import('../startup/login-shell-path');
+        const { embeddedMpvNativeService } =
+            await import('../services/embedded-mpv-native.service');
+        await import('./embedded-mpv.events');
+        // The addon is normally a vendored .node file; with it in place,
+        // mpv on PATH is the only thing support depends on.
+        (
+            embeddedMpvNativeService as unknown as {
+                addon: { isSupported(): boolean };
+            }
+        ).addon = { isSupported: () => true };
+
+        scheduleDeferredFixPath(
+            () =>
+                new Promise((resolve) => {
+                    answerShell = resolve;
+                }),
+            LOOKUP_BUDGET_MS
+        );
+        // The lookup starts on the next tick; only then can it be answered.
+        await flushLookup();
+    });
+
+    afterEach(async () => {
+        // Let the lookup finish, so no test leaves a pending shell behind.
+        answerShell(INHERITED_PATH);
+        await flushLookup();
+    });
+
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+        });
+        for (const [key, value] of Object.entries(originalEnv)) {
+            if (value === undefined) {
+                delete process.env[key];
+            } else {
+                process.env[key] = value;
+            }
+        }
+    });
+
+    it.each([EMBEDDED_MPV_SUPPORT, EMBEDDED_MPV_PREPARE])(
+        '%s reports a missing mpv as inconclusive until the shell answers',
+        async (channel) => {
+            const check = handlerFor(channel);
+
+            // The lookup runs out of budget: this probe sees the inherited
+            // PATH, where mpv is missing.
+            await expect(check({})).resolves.toMatchObject({
+                supported: false,
+                inconclusive: true,
+            });
+            // Asked again meanwhile: the cached answer is still not final.
+            await expect(check({})).resolves.toMatchObject({
+                supported: false,
+                inconclusive: true,
+            });
+            expect(mockSpawnSync).toHaveBeenCalledTimes(1);
+
+            answerShell(LOGIN_SHELL_PATH);
+            await flushLookup();
+
+            const settled = await check({});
+            expect(settled.supported).toBe(true);
+            expect(settled.inconclusive).toBeUndefined();
+            expect(mockSpawnSync).toHaveBeenCalledTimes(2);
+        }
+    );
+
+    it('reports a missing mpv as final once the shell answered without it', async () => {
+        const support = handlerFor(EMBEDDED_MPV_SUPPORT);
+        await expect(support({})).resolves.toMatchObject({
+            supported: false,
+            inconclusive: true,
+        });
+
+        answerShell(INHERITED_PATH);
+        await flushLookup();
+
+        const settled = await support({});
+        expect(settled.supported).toBe(false);
+        expect(settled.reason).toContain('mpv executable');
+        expect(settled.inconclusive).toBeUndefined();
+    });
+
+    it('reports a missing mpv as final when the shell answered in time', async () => {
+        answerShell(INHERITED_PATH);
+        await flushLookup();
+
+        const answer = await handlerFor(EMBEDDED_MPV_SUPPORT)({});
+        expect(answer.supported).toBe(false);
+        expect(answer.inconclusive).toBeUndefined();
+    });
+});
diff --git a/apps/electron-backend/src/app/events/embedded-mpv.events.spec.ts b/apps/electron-backend/src/app/events/embedded-mpv.events.spec.ts
index b496fc0c2..1c34a63c1 100644
--- a/apps/electron-backend/src/app/events/embedded-mpv.events.spec.ts
+++ b/apps/electron-backend/src/app/events/embedded-mpv.events.spec.ts
@@ -10,6 +10,7 @@ const mockEmbeddedMpvService = {
     getSupport: jest.fn(),
     willProbeLinuxMpvExecutable: jest.fn(() => false),
     forgetLinuxMpvExecutableProbe: jest.fn(),
+    markLinuxMpvExecutableProbeProvisional: jest.fn(),
     setPaused: jest.fn(),
 };
 const mockSessionOptions = {
@@ -26,9 +27,7 @@ jest.mock('../services/embedded-mpv-session-options', () => ({
 }));
 const mockWaitForLoginShellPath = jest.fn(() => Promise.resolve(true));
 let settleLookup: () => void = () => undefined;
-const mockLookupSettled = new Promise<void>((resolve) => {
-    settleLookup = resolve;
-});
+let mockLookupSettled = Promise.resolve();
 jest.mock('../startup/login-shell-path', () => ({
     waitForLoginShellPath: () => mockWaitForLoginShellPath(),
     whenLoginShellPathSettled: () => mockLookupSettled,
@@ -69,6 +68,16 @@ describe('EmbeddedMpvEvents IPC handlers', () => {
     });
 
     describe('support checks and the login shell PATH', () => {
+        beforeEach(() => {
+            // A lookup of its own per test: the pending re-probe of one test
+            // must not answer for the next.
+            mockLookupSettled = new Promise<void>((resolve) => {
+                settleLookup = resolve;
+            });
+            mockEmbeddedMpvService.forgetLinuxMpvExecutableProbe.mockClear();
+            mockEmbeddedMpvService.markLinuxMpvExecutableProbeProvisional.mockClear();
+        });
+
         afterEach(() => {
             mockWaitForLoginShellPath.mockClear();
             mockEmbeddedMpvService.willProbeLinuxMpvExecutable.mockReset();
@@ -110,6 +119,10 @@ describe('EmbeddedMpvEvents IPC handlers', () => {
                 expect(
                     mockEmbeddedMpvService.forgetLinuxMpvExecutableProbe
                 ).not.toHaveBeenCalled();
+                // The probe saw the login shell PATH: its answer is final.
+                expect(
+                    mockEmbeddedMpvService.markLinuxMpvExecutableProbeProvisional
+                ).not.toHaveBeenCalled();
             }
         );
 
@@ -125,6 +138,17 @@ describe('EmbeddedMpvEvents IPC handlers', () => {
             await expect(
                 getIpcMainHandler(EMBEDDED_MPV_SUPPORT)({})
             ).resolves.toEqual({ supported: false });
+            // The service is told before it probes, so the answer of this
+            // very check is already marked as not final.
+            const { markLinuxMpvExecutableProbeProvisional, getSupport } =
+                mockEmbeddedMpvService;
+            expect(
+                markLinuxMpvExecutableProbeProvisional
+            ).toHaveBeenCalledTimes(1);
+            expect(
+                markLinuxMpvExecutableProbeProvisional.mock
+                    .invocationCallOrder[0]
+            ).toBeLessThan(getSupport.mock.invocationCallOrder[0]);
             expect(
                 mockEmbeddedMpvService.forgetLinuxMpvExecutableProbe
             ).not.toHaveBeenCalled();
@@ -136,6 +160,33 @@ describe('EmbeddedMpvEvents IPC handlers', () => {
             ).toHaveBeenCalledTimes(1);
         });
 
+        it('still re-probes when the check on the inherited PATH throws', async () => {
+            const consoleErrorSpy = jest
+                .spyOn(console, 'error')
+                .mockImplementation();
+            mockEmbeddedMpvService.willProbeLinuxMpvExecutable.mockReturnValue(
+                true
+            );
+            mockWaitForLoginShellPath.mockResolvedValueOnce(false);
+            mockEmbeddedMpvService.getSupport.mockImplementation(() => {
+                throw new Error('probe failed');
+            });
+
+            try {
+                await expect(
+                    getIpcMainHandler(EMBEDDED_MPV_SUPPORT)({})
+                ).rejects.toThrow('probe failed');
+                // Otherwise the provisional state would outlive the lookup.
+                settleLookup();
+                await new Promise<void>((resolve) => setImmediate(resolve));
+                expect(
+                    mockEmbeddedMpvService.forgetLinuxMpvExecutableProbe
+                ).toHaveBeenCalledTimes(1);
+            } finally {
+                consoleErrorSpy.mockRestore();
+            }
+        });
+
         it('does not wait when no probe runs, nor for session calls', async () => {
             mockEmbeddedMpvService.getSupport.mockReturnValue({
                 supported: true,
diff --git a/apps/electron-backend/src/app/events/embedded-mpv.events.ts b/apps/electron-backend/src/app/events/embedded-mpv.events.ts
index 904bd9bb2..cd49c6c58 100644
--- a/apps/electron-backend/src/app/events/embedded-mpv.events.ts
+++ b/apps/electron-backend/src/app/events/embedded-mpv.events.ts
@@ -80,13 +80,14 @@ async function afterLoginShellPathIfProbing<T>(check: () => T): Promise<T> {
     ) {
         return check();
     }
-    // The lookup ran out of budget, so this probe sees the inherited PATH.
-    // Once the shell does answer, the result is probed again.
-    const result = check();
+    // The lookup ran out of budget, so this probe sees the inherited PATH: a
+    // missing mpv is answered as inconclusive, never as a verdict the
+    // renderer may persist. Once the shell does answer, it is probed again.
+    getService().markLinuxMpvExecutableProbeProvisional();
     void whenLoginShellPathSettled().then(() =>
         getService().forgetLinuxMpvExecutableProbe()
     );
-    return result;
+    return check();
 }
 
 handleEmbeddedMpv(EMBEDDED_MPV_SUPPORT, () =>
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-native.service.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-native.service.spec.ts
index 728af5580..9991436e8 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-native.service.spec.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-native.service.spec.ts
@@ -414,6 +414,56 @@ describe('EmbeddedMpvNativeService power blocker', () => {
             expect(service.willProbeLinuxMpvExecutable()).toBe(true);
         });
 
+        it('reports a missing mpv as inconclusive only while its probe is provisional', () => {
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            process.env.DISPLAY = ':0';
+            delete process.env.WAYLAND_DISPLAY;
+            mockSpawnSync.mockReturnValue({ status: 1 });
+            mockRuntimeUsable();
+
+            // The login shell has not answered: mpv is looked up on the
+            // inherited PATH.
+            service.markLinuxMpvExecutableProbeProvisional();
+            expect(service.getSupport()).toEqual(
+                expect.objectContaining({
+                    supported: false,
+                    inconclusive: true,
+                })
+            );
+            expect(service.prepareAddon()).toEqual(
+                expect.objectContaining({
+                    supported: false,
+                    inconclusive: true,
+                })
+            );
+
+            // It answered: the next probe is a verdict again.
+            service.forgetLinuxMpvExecutableProbe();
+            const settled = service.getSupport();
+            expect(settled.supported).toBe(false);
+            expect(settled.reason).toContain('mpv executable');
+            expect(settled.inconclusive).toBeUndefined();
+        });
+
+        it('keeps every other answer final while the mpv probe is provisional', () => {
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            process.env.DISPLAY = ':0';
+            delete process.env.WAYLAND_DISPLAY;
+            mockSpawnSync.mockReturnValue({ status: 0 });
+            mockRuntimeUsable();
+            service.markLinuxMpvExecutableProbeProvisional();
+
+            const found = service.getSupport();
+            expect(found.supported).toBe(true);
+            expect(found.inconclusive).toBeUndefined();
+
+            // mpv is there, the addon is not: the PATH cannot change that.
+            addon.isSupported.mockReturnValue(false);
+            const unsupported = service.getSupport();
+            expect(unsupported.supported).toBe(false);
+            expect(unsupported.inconclusive).toBeUndefined();
+        });
+
         it('predicts no probe for the frame-copy engine or native Wayland', () => {
             Object.defineProperty(process, 'platform', { value: 'linux' });
             process.env.DISPLAY = ':0';
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-native.service.ts b/apps/electron-backend/src/app/services/embedded-mpv-native.service.ts
index 10f30a806..e929d240f 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-native.service.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-native.service.ts
@@ -174,6 +174,12 @@ export class EmbeddedMpvNativeService {
     private powerBlockerId: number | null = null;
     private readonly loadAddonModule = createRequire(__filename);
     private cachedLinuxMpvExecutableReason: string | null | undefined;
+    /**
+     * True while `mpv --version` runs, or was cached, on the inherited PATH
+     * because the login shell had not answered: a missing mpv is then no
+     * verdict yet.
+     */
+    private linuxMpvExecutableProbeIsProvisional = false;
     private frameCopyAdapter: EmbeddedMpvFrameCopyAdapter | null = null;
     private sessionOptionsDirectory: string | null = null;
     /**
@@ -401,6 +407,16 @@ export class EmbeddedMpvNativeService {
      */
     forgetLinuxMpvExecutableProbe(): void {
         this.cachedLinuxMpvExecutableReason = undefined;
+        this.linuxMpvExecutableProbeIsProvisional = false;
+    }
+
+    /**
+     * Declares that the probe sees the inherited PATH, the login shell one
+     * not having arrived. Until `forgetLinuxMpvExecutableProbe()`, a missing
+     * mpv is reported as `inconclusive`, so no caller settles on it.
+     */
+    markLinuxMpvExecutableProbeProvisional(): void {
+        this.linuxMpvExecutableProbeIsProvisional = true;
     }
 
     getSupport(): EmbeddedMpvSupport {
@@ -458,6 +474,9 @@ export class EmbeddedMpvNativeService {
                 supported: false,
                 platform: process.platform,
                 reason: missingLinuxMpvExecutableReason,
+                ...(this.linuxMpvExecutableProbeIsProvisional
+                    ? { inconclusive: true }
+                    : {}),
                 ...this.getFrameCopySupportDetails(),
             };
         }
diff --git a/apps/web-e2e/src/m3u-movie-details.e2e.ts b/apps/web-e2e/src/m3u-movie-details.e2e.ts
index 2f2a49a41..b28e80cae 100644
--- a/apps/web-e2e/src/m3u-movie-details.e2e.ts
+++ b/apps/web-e2e/src/m3u-movie-details.e2e.ts
@@ -406,17 +406,21 @@ test('@web @m3u @tmdb browse and watch keep the adjusted volume', async ({
             )
         )
         .toBe(0.25);
-    // M3U has no browse Back target, so the header shows no arrow in either
-    // state; the now-playing bar's own Close button returns to browse.
+    // M3U registers no Back target in either state: the header's only arrow
+    // is the history fallback to the dashboard the import started from,
+    // which claims no Escape. The now-playing bar's own Close button
+    // returns to browse.
     const shell = detail(page).locator('app-portal-detail-shell');
     const headerBack = page.locator('[data-test-id="workspace-header-back"]');
-    await expect(headerBack).toHaveCount(0);
+    await expect(headerBack).toHaveCount(1);
+    await expect(headerBack).not.toHaveAttribute('aria-keyshortcuts');
     await shell
         .locator('app-portal-inline-player')
         .getByRole('button', { name: 'Close player', exact: true })
         .click();
     await expect(inlineVideo(page)).toHaveCount(0);
-    await expect(headerBack).toHaveCount(0);
+    await expect(headerBack).toHaveCount(1);
+    await expect(headerBack).not.toHaveAttribute('aria-keyshortcuts');
     // The hero keeps its own inset (32px, or 20px in a pane narrower than
     // 760px) in both states.
     expect(
diff --git a/apps/web-e2e/src/mobile-layout.e2e.ts b/apps/web-e2e/src/mobile-layout.e2e.ts
index c0535cdad..e58f9cb9e 100644
--- a/apps/web-e2e/src/mobile-layout.e2e.ts
+++ b/apps/web-e2e/src/mobile-layout.e2e.ts
@@ -21,8 +21,9 @@ import {
  *      by default so the content keeps the full viewport width, opened from
  *      the header toggle (winning over the persisted desktop inline width),
  *      and closed again by picking a category or tapping the backdrop.
- *   4. The settings section list scrolls instead of painting over the
- *      Back footer — now inside the open drawer.
+ *   4. Settings keeps its drawer toggle beside the header Back (the drawer
+ *      holds the sections), and the section list scrolls inside the drawer.
+ *      On a portal list, the header's history Back yields to the toggle.
  *   5. On a 640x360 landscape phone the live route keeps the channel
  *      sidebar at least 72px tall and the player container inside the
  *      viewport.
@@ -107,17 +108,25 @@ test.describe('portrait phone 375x812', () => {
         await expectRailLinksInsideTopBar(page);
     });
 
-    test('@mobile settings drawer opens from the header toggle and keeps the section list clear of the Back footer', async ({
+    test('@mobile settings keeps the drawer toggle beside the header Back and the section list inside the drawer', async ({
         page,
     }) => {
         await page.goto('/workspace/settings');
 
+        // Back is the header's leading button. The drawer holds the section
+        // list, so its toggle stays beside Back instead of giving way.
+        const back = page.locator('[data-test-id="workspace-header-back"]');
+        const toggle = page.locator('[data-test-id="context-drawer-toggle"]');
+        await expect(back).toBeVisible();
+        await expect(toggle).toBeVisible();
+        expect((await boxOf(back)).x).toBeLessThan((await boxOf(toggle)).x);
+
         // The phone context panel is an off-canvas drawer: hidden until the
         // header toggle opens it, so the settings content owns the pane.
         const panel = page.locator('.context-panel--settings');
         await expect(panel).toBeHidden();
 
-        await page.locator('[data-test-id="context-drawer-toggle"]').click();
+        await toggle.click();
         await expect(panel).toBeVisible();
 
         // Narrower than the viewport so the backdrop stays tappable, and
@@ -126,15 +135,13 @@ test.describe('portrait phone 375x812', () => {
         expect(panelBox.width).toBeGreaterThanOrEqual(300);
         expect(panelBox.width).toBeLessThanOrEqual(PHONE.width - 20);
 
-        const footer = panel.locator('.settings-panel-footer');
-        await expect(footer.locator('.settings-back-button')).toBeVisible();
-
-        // Before #1326 the section list kept its full content height and
-        // painted over the footer whenever the panel was shorter than its
-        // sections; now the list scrolls and ends above the footer.
+        // No footer Back any more; the list scrolls and ends inside the
+        // panel instead of painting past it (#1326).
+        await expect(panel.locator('button:has-text("Back")')).toHaveCount(0);
         const listBox = await boxOf(panel.locator('.settings-sections-list'));
-        const footerBox = await boxOf(footer);
-        expect(listBox.y + listBox.height).toBeLessThanOrEqual(footerBox.y + 1);
+        expect(listBox.y + listBox.height).toBeLessThanOrEqual(
+            panelBox.y + panelBox.height + 1
+        );
 
         // Tapping the backdrop (right of the drawer) closes it.
         await page
@@ -163,7 +170,18 @@ test.describe('xtream portal routes on a phone', () => {
     test('@mobile @xtream vod route keeps the context panel in a drawer behind the header toggle', async ({
         page,
     }) => {
+        // The import navigated here from the dashboard, so the header offers
+        // the history Back on wide screens...
+        const back = page.locator('[data-test-id="workspace-header-back"]');
+        await expect(back).toBeVisible();
+
         await page.setViewportSize(PHONE);
+        // ...and on a phone it yields to the drawer toggle, the list's only
+        // way into its categories.
+        await expect(back).toBeHidden();
+        await expect(
+            page.locator('[data-test-id="context-drawer-toggle"]')
+        ).toBeVisible();
 
         // Hidden by default — the content owns the full pane. This is the
         // successor to the #1326 stacked layout, which left the content
diff --git a/apps/web-e2e/src/settings.e2e.ts b/apps/web-e2e/src/settings.e2e.ts
index e12bb9d7b..b40e6fb61 100644
--- a/apps/web-e2e/src/settings.e2e.ts
+++ b/apps/web-e2e/src/settings.e2e.ts
@@ -7,7 +7,12 @@ async function openSettings(page: Page) {
     // The bare settings URL redirects to the default section page.
     await page.waitForURL(/\/workspace\/settings\/general$/);
     await expect(page.locator('.settings-container')).toBeVisible();
-    await expect(page.locator('.settings-back-button')).toBeVisible();
+    await expect(settingsBack(page)).toBeVisible();
+}
+
+/** Settings' Back is the workspace header's leading button. */
+function settingsBack(page: Page) {
+    return page.locator('[data-test-id="workspace-header-back"]');
 }
 
 /** Settings render one section page at a time — open it via the rail. */
@@ -36,7 +41,12 @@ test.describe('Settings', () => {
 
     test('@settings @web Check settings page', async ({ page }) => {
         await openSettings(page);
-        await page.locator('.settings-back-button').click();
+        // The context panel no longer carries a Back of its own.
+        await expect(
+            page.locator('app-workspace-settings-context-panel button')
+        ).toHaveCount(0);
+        await settingsBack(page).click();
+        await page.waitForURL(/\/workspace\/dashboard$/);
     });
 
     test('@settings @web Change video player', async ({ page }) => {
diff --git a/apps/web-e2e/src/stalker-embedded-series.fixture.ts b/apps/web-e2e/src/stalker-embedded-series.fixture.ts
new file mode 100644
index 000000000..67096aef6
--- /dev/null
+++ b/apps/web-e2e/src/stalker-embedded-series.fixture.ts
@@ -0,0 +1,104 @@
+import type { APIRequestContext, Locator, Page } from '@playwright/test';
+import { expect } from './fixtures';
+import {
+    BACKEND_PROXY,
+    EMBEDDED_SERIES_MAC,
+    MOCK_SERVER,
+} from './stalker-portal.fixture';
+
+/** A VOD row of the embedded-series scenario carrying a `series[]` array. */
+interface EmbeddedSeriesItem {
+    name: string;
+    series: unknown[];
+}
+
+/**
+ * Finds a VOD item carrying an embedded series[] array in the mock catalog
+ * and reports how many episodes it currently has.
+ */
+export async function findEmbeddedSeriesItem(
+    request: APIRequestContext
+): Promise<{ embeddedItem: EmbeddedSeriesItem; episodeCount: number }> {
+    const listResponse = await request.get(
+        `${MOCK_SERVER}/stalker?action=get_ordered_list&type=vod&category=2001&p=1&macAddress=${EMBEDDED_SERIES_MAC}&JsHttpRequest=1-xml`
+    );
+    const listBody = await listResponse.json();
+    const embeddedItem = listBody.payload.js.data.find(
+        (item: { series?: unknown[] }) =>
+            Array.isArray(item.series) && item.series.length > 0
+    );
+    expect(embeddedItem).toBeDefined();
+    const episodeCount: number = embeddedItem.series.length;
+
+    return { embeddedItem, episodeCount };
+}
+
+/**
+ * Opens the embedded-series item from its category (the first row is "All")
+ * and waits until the series detail lists its last episode. Returns the
+ * item's card in the category grid.
+ */
+export async function openEmbeddedSeriesItem(
+    page: Page,
+    itemName: string,
+    episodeCount: number
+): Promise<Locator> {
+    const categories = page.locator('.category-item');
+    await expect(categories.first()).toBeVisible({ timeout: 10_000 });
+    await categories.nth(1).click();
+    const card = page.getByText(itemName).first();
+    await expect(card).toBeVisible({ timeout: 10_000 });
+    await card.click();
+
+    await expect(
+        page.getByRole('heading', {
+            name: `${episodeCount}. Episode ${episodeCount}`,
+            exact: true,
+        })
+    ).toBeVisible({ timeout: 10_000 });
+
+    return card;
+}
+
+/**
+ * From now on the portal has "released" one more episode: extend series[] in
+ * every search response (the background snapshot refresh re-fetches the item
+ * via a title search).
+ */
+export async function releaseExtraEpisodeInSearchResponses(
+    page: Page
+): Promise<void> {
+    await page.route('**/localhost:3000/stalker**', async (route) => {
+        const originalUrl = new URL(route.request().url());
+        if (!originalUrl.searchParams.get('search')) {
+            await route.fallback();
+            return;
+        }
+
+        const mockUrl = new URL(BACKEND_PROXY);
+        const targetId = originalUrl.searchParams.get('targetId');
+        const providerUrl = targetId
+            ? Buffer.from(targetId, 'base64url').toString()
+            : originalUrl.searchParams.get('url');
+        if (providerUrl) {
+            mockUrl.searchParams.set('url', providerUrl);
+        }
+        originalUrl.searchParams.forEach((value, key) => {
+            if (key === 'targetId') {
+                return;
+            }
+            mockUrl.searchParams.set(key, value);
+        });
+
+        const response = await route.fetch({ url: mockUrl.toString() });
+        const body = await response.json();
+        const rows: { series?: string[] }[] =
+            body?.payload?.js?.data ?? body?.js?.data ?? [];
+        for (const row of rows) {
+            if (Array.isArray(row.series) && row.series.length > 0) {
+                row.series = [...row.series, String(row.series.length + 1)];
+            }
+        }
+        await route.fulfill({ response, body: JSON.stringify(body) });
+    });
+}
diff --git a/apps/web-e2e/src/stalker-portal.fixture.ts b/apps/web-e2e/src/stalker-portal.fixture.ts
new file mode 100644
index 000000000..08d0f0985
--- /dev/null
+++ b/apps/web-e2e/src/stalker-portal.fixture.ts
@@ -0,0 +1,238 @@
+import type { Page } from '@playwright/test';
+import { setInputValue } from './e2e-helpers';
+import { expect } from './fixtures';
+import {
+    getRegisteredProviderUrl,
+    interceptProviderTargetRegistration,
+} from './provider-target-route';
+
+/**
+ * Mock-portal endpoints, scenario MACs and page helpers of `stalker.e2e.ts`.
+ *
+ * The scenario MACs declared here belong to that spec alone: it lists them in
+ * its `OWNED_MACS` and resets them before every test, so a sibling spec that
+ * reused one would have its mock state cleared mid-run. See the isolation
+ * notes at the top of `stalker.e2e.ts`.
+ */
+
+const MOCK_PORT = process.env['MOCK_PORT'] ?? '3210';
+export const MOCK_SERVER = `http://localhost:${MOCK_PORT}`;
+const PORTAL_URL = `${MOCK_SERVER}/portal.php`;
+/**
+ * Canonical Ministra path. `PORTAL_URL` above is classified by the app as a
+ * "simple" portal (no handshake, no token, no watchdog); this shape is the
+ * authenticated branch, which the mock guards like the real middleware.
+ */
+export const FULL_PORTAL_URL = `${MOCK_SERVER}/stalker_portal/server/load.php`;
+export const BACKEND_PROXY = `${MOCK_SERVER}/stalker`;
+
+/** Default scenario MAC — balanced catalog, 8 categories, 40 items */
+export const DEFAULT_MAC = '00:1A:79:00:00:01';
+
+/** Minimal scenario MAC — 2 categories, 5 items (edge case testing) */
+export const MINIMAL_MAC = '00:1A:79:00:00:03';
+
+/** Embedded-series MAC — 50% of VOD items carry an embedded series[] array */
+export const EMBEDDED_SERIES_MAC = '00:1A:79:00:00:05';
+
+/** Legacy pagination MAC — portal without get_all_channels support */
+export const LEGACY_PAGINATION_MAC = '00:1A:79:00:00:06';
+
+/**
+ * Static-cmd MAC — ITV rows carrying a directly playable `cmd` with
+ * `use_http_tmp_link` and `use_load_balancing` both `'0'`, i.e. a portal that
+ * expects no `create_link` call at all.
+ */
+export const STATIC_CMD_MAC = '00:1A:79:00:00:0A';
+
+/**
+ * The full-portal authentication tests assert state transitions within one
+ * portal session, so a reset from a concurrent browser project or repeat
+ * worker would invalidate the assertion itself. Giving every concurrent
+ * worker slot its own MAC range preserves browser parallelism and also keeps
+ * `--repeat-each` runs isolated.
+ */
+export interface StatefulAuthMacs {
+    authenticatedFlow: string;
+    loginRequired: string;
+    tokenReuse: string;
+    deviceConflict: string;
+    reauthentication: string;
+}
+
+export function getStatefulAuthMacs({
+    parallelIndex,
+}: {
+    parallelIndex: number;
+}): StatefulAuthMacs {
+    if (
+        !Number.isSafeInteger(parallelIndex) ||
+        parallelIndex < 0 ||
+        parallelIndex > 255
+    ) {
+        throw new Error(
+            `Unsupported Playwright parallel index: ${parallelIndex}`
+        );
+    }
+
+    const workerOctet = parallelIndex
+        .toString(16)
+        .padStart(2, '0')
+        .toUpperCase();
+    const workerPrefix = `00:1A:79:AE:${workerOctet}`;
+
+    return {
+        authenticatedFlow: `${workerPrefix}:01`,
+        loginRequired: `${workerPrefix}:02`,
+        tokenReuse: `${workerPrefix}:03`,
+        deviceConflict: `${workerPrefix}:04`,
+        reauthentication: `${workerPrefix}:05`,
+    };
+}
+
+/**
+ * Deliberately NOT an Infomir MAC: the strict endpoint rejects get_profile for
+ * it, so no token is ever adopted and content requests fail permanently.
+ */
+export const AUTH_REJECTED_MAC = 'AA:BB:CC:DD:EE:01';
+
+/**
+ * Intercept calls to the Angular dev backend (/stalker proxy) and redirect
+ * them to the mock server. This avoids needing a real backend or changing
+ * any app environment configuration.
+ */
+export async function interceptStalkerRequests(page: Page): Promise<void> {
+    const providerTargets = await interceptProviderTargetRegistration(page);
+
+    await page.route('**/localhost:3000/stalker**', async (route) => {
+        const originalUrl = new URL(route.request().url());
+        const mockUrl = new URL(BACKEND_PROXY);
+        const providerUrl = getRegisteredProviderUrl(
+            originalUrl,
+            providerTargets
+        );
+
+        if (providerUrl) {
+            mockUrl.searchParams.set('url', providerUrl);
+        }
+
+        originalUrl.searchParams.forEach((value, key) => {
+            if (key === 'targetId') {
+                return;
+            }
+
+            mockUrl.searchParams.set(key, value);
+        });
+        await route.continue({ url: mockUrl.toString() });
+    });
+}
+
+/**
+ * Add a Stalker portal via the UI:
+ * 1. Click the "add playlist" button to open the unified dialog
+ * 2. Select "Stalker" toggle
+ * 3. Fill in the form and submit
+ */
+export async function addStalkerPortal(
+    page: Page,
+    options: { name?: string; mac?: string } = {}
+): Promise<void> {
+    const { name = 'Mock Stalker Portal', mac = DEFAULT_MAC } = options;
+
+    await page.getByRole('button', { name: 'Add playlist' }).click();
+    const dialog = page.locator('mat-dialog-container');
+    await expect(dialog).toBeVisible();
+    // v0.22 redesign: tabs were replaced with a flat 5-card radio picker.
+    await dialog.getByRole('radio', { name: /Stalker portal/i }).click();
+
+    await setInputValue(dialog.locator('input#title'), name);
+    await setInputValue(dialog.locator('input#portalUrl'), PORTAL_URL);
+    await setInputValue(dialog.locator('input#macAddress'), mac);
+
+    const addButton = dialog.getByRole('button', {
+        name: 'Add playlist',
+        exact: true,
+    });
+    await expect(addButton).toBeEnabled({ timeout: 10_000 });
+    await addButton.click();
+    await expect(dialog).toBeHidden();
+    await page.waitForURL(/stalker.*vod/);
+}
+
+/**
+ * Add a Stalker portal through the canonical Ministra URL, which the app
+ * imports as a FULL portal: handshake, Bearer token and watchdog.
+ */
+export async function addFullStalkerPortal(
+    page: Page,
+    options: {
+        name?: string;
+        mac: string;
+        expectContent?: boolean;
+        username?: string;
+        password?: string;
+    }
+): Promise<void> {
+    const {
+        name = 'Full Stalker Portal',
+        mac,
+        expectContent = true,
+        username,
+        password,
+    } = options;
+
+    await page.getByRole('button', { name: 'Add playlist' }).click();
+    const dialog = page.locator('mat-dialog-container');
+    await expect(dialog).toBeVisible();
+    await dialog.getByRole('radio', { name: /Stalker portal/i }).click();
+
+    await setInputValue(dialog.locator('input#title'), name);
+    await setInputValue(dialog.locator('input#portalUrl'), FULL_PORTAL_URL);
+    await setInputValue(dialog.locator('input#macAddress'), mac);
+    if (username !== undefined) {
+        await setInputValue(dialog.locator('input#username'), username);
+    }
+    if (password !== undefined) {
+        await setInputValue(dialog.locator('input#password'), password);
+    }
+
+    const addButton = dialog.getByRole('button', {
+        name: 'Add playlist',
+        exact: true,
+    });
+    await expect(addButton).toBeEnabled({ timeout: 10_000 });
+    await addButton.click();
+    await expect(dialog).toBeHidden();
+
+    if (expectContent) {
+        await page.waitForURL(/stalker.*vod/, { timeout: 30_000 });
+    }
+}
+
+export const CONTENT_ACTIONS = [
+    'get_categories',
+    'get_genres',
+    'get_ordered_list',
+    'get_all_channels',
+];
+
+/** Every portal request in order, with the token it carried. */
+export function recordPortalRequests(
+    page: Page
+): Array<{ action: string; token: string | null }> {
+    const requests: Array<{ action: string; token: string | null }> = [];
+
+    page.on('request', (request) => {
+        const url = new URL(request.url());
+        if (!url.pathname.endsWith('/stalker')) {
+            return;
+        }
+        const action = url.searchParams.get('action');
+        if (!action) {
+            return;
+        }
+        requests.push({ action, token: url.searchParams.get('token') });
+    });
+
+    return requests;
+}
diff --git a/apps/web-e2e/src/stalker.e2e.ts b/apps/web-e2e/src/stalker.e2e.ts
index 99bd00708..051acc8af 100644
--- a/apps/web-e2e/src/stalker.e2e.ts
+++ b/apps/web-e2e/src/stalker.e2e.ts
@@ -1,4 +1,4 @@
-import { type APIRequestContext, type Page } from '@playwright/test';
+import { type APIRequestContext } from '@playwright/test';
 import {
     closeSeriesMenu,
     expectSeriesSurfacesInBothThemes,
@@ -10,14 +10,33 @@ import {
     verifyStalkerPlaybackCategoryReturn,
     verifyUncachedStalkerSearch,
 } from './stalker-category-search.fixture';
+import {
+    findEmbeddedSeriesItem,
+    openEmbeddedSeriesItem,
+    releaseExtraEpisodeInSearchResponses,
+} from './stalker-embedded-series.fixture';
 import { verifyStalkerSeasonMarkers } from './stalker-season-markers.fixture';
 import { verifyStalkerOpenInPlaylist } from './stalker-open-in-playlist.fixture';
 import { playFirstItvChannel } from './stalker-itv-playback.fixture';
-import { expect, test } from './fixtures';
 import {
-    getRegisteredProviderUrl,
-    interceptProviderTargetRegistration,
-} from './provider-target-route';
+    AUTH_REJECTED_MAC,
+    BACKEND_PROXY,
+    CONTENT_ACTIONS,
+    DEFAULT_MAC,
+    EMBEDDED_SERIES_MAC,
+    FULL_PORTAL_URL,
+    LEGACY_PAGINATION_MAC,
+    MINIMAL_MAC,
+    MOCK_SERVER,
+    STATIC_CMD_MAC,
+    type StatefulAuthMacs,
+    addFullStalkerPortal,
+    addStalkerPortal,
+    getStatefulAuthMacs,
+    interceptStalkerRequests,
+    recordPortalRequests,
+} from './stalker-portal.fixture';
+import { expect, test } from './fixtures';
 
 /**
  * Stalker Portal E2E Tests
@@ -58,121 +77,10 @@ import {
 
 test.describe.configure({ mode: 'serial' });
 
-const MOCK_PORT = process.env['MOCK_PORT'] ?? '3210';
-const MOCK_SERVER = `http://localhost:${MOCK_PORT}`;
-const PORTAL_URL = `${MOCK_SERVER}/portal.php`;
-/**
- * Canonical Ministra path. `PORTAL_URL` above is classified by the app as a
- * "simple" portal (no handshake, no token, no watchdog); this shape is the
- * authenticated branch, which the mock guards like the real middleware.
- */
-const FULL_PORTAL_URL = `${MOCK_SERVER}/stalker_portal/server/load.php`;
-const BACKEND_PROXY = `${MOCK_SERVER}/stalker`;
-
-/** Default scenario MAC — balanced catalog, 8 categories, 40 items */
-const DEFAULT_MAC = '00:1A:79:00:00:01';
-
-/** Minimal scenario MAC — 2 categories, 5 items (edge case testing) */
-const MINIMAL_MAC = '00:1A:79:00:00:03';
-
-/** Embedded-series MAC — 50% of VOD items carry an embedded series[] array */
-const EMBEDDED_SERIES_MAC = '00:1A:79:00:00:05';
-
-/** Legacy pagination MAC — portal without get_all_channels support */
-const LEGACY_PAGINATION_MAC = '00:1A:79:00:00:06';
-
-/**
- * Static-cmd MAC — ITV rows carrying a directly playable `cmd` with
- * `use_http_tmp_link` and `use_load_balancing` both `'0'`, i.e. a portal that
- * expects no `create_link` call at all.
- */
-const STATIC_CMD_MAC = '00:1A:79:00:00:0A';
-
-/**
- * These tests assert state transitions within one portal session, so a reset
- * from a concurrent browser project or repeat worker would invalidate the
- * assertion itself. Giving every concurrent worker slot its own MAC range
- * preserves browser parallelism and also keeps `--repeat-each` runs isolated.
- */
-interface StatefulAuthMacs {
-    authenticatedFlow: string;
-    loginRequired: string;
-    tokenReuse: string;
-    deviceConflict: string;
-    reauthentication: string;
-}
-
-function getStatefulAuthMacs({
-    parallelIndex,
-}: {
-    parallelIndex: number;
-}): StatefulAuthMacs {
-    if (
-        !Number.isSafeInteger(parallelIndex) ||
-        parallelIndex < 0 ||
-        parallelIndex > 255
-    ) {
-        throw new Error(
-            `Unsupported Playwright parallel index: ${parallelIndex}`
-        );
-    }
-
-    const workerOctet = parallelIndex
-        .toString(16)
-        .padStart(2, '0')
-        .toUpperCase();
-    const workerPrefix = `00:1A:79:AE:${workerOctet}`;
-
-    return {
-        authenticatedFlow: `${workerPrefix}:01`,
-        loginRequired: `${workerPrefix}:02`,
-        tokenReuse: `${workerPrefix}:03`,
-        deviceConflict: `${workerPrefix}:04`,
-        reauthentication: `${workerPrefix}:05`,
-    };
-}
-
-/**
- * Deliberately NOT an Infomir MAC: the strict endpoint rejects get_profile for
- * it, so no token is ever adopted and content requests fail permanently.
- */
-const AUTH_REJECTED_MAC = 'AA:BB:CC:DD:EE:01';
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Intercept calls to the Angular dev backend (/stalker proxy) and redirect
- * them to the mock server. This avoids needing a real backend or changing
- * any app environment configuration.
- */
-async function interceptStalkerRequests(page: Page): Promise<void> {
-    const providerTargets = await interceptProviderTargetRegistration(page);
-
-    await page.route('**/localhost:3000/stalker**', async (route) => {
-        const originalUrl = new URL(route.request().url());
-        const mockUrl = new URL(BACKEND_PROXY);
-        const providerUrl = getRegisteredProviderUrl(
-            originalUrl,
-            providerTargets
-        );
-
-        if (providerUrl) {
-            mockUrl.searchParams.set('url', providerUrl);
-        }
-
-        originalUrl.searchParams.forEach((value, key) => {
-            if (key === 'targetId') {
-                return;
-            }
-
-            mockUrl.searchParams.set(key, value);
-        });
-        await route.continue({ url: mockUrl.toString() });
-    });
-}
-
 /** Every MAC this file owns; all are cleared in one batched reset request. */
 const OWNED_MACS = [
     DEFAULT_MAC,
@@ -223,116 +131,6 @@ async function resetMockServer(
     throw lastError;
 }
 
-/**
- * Add a Stalker portal via the UI:
- * 1. Click the "add playlist" button to open the unified dialog
- * 2. Select "Stalker" toggle
- * 3. Fill in the form and submit
- */
-async function addStalkerPortal(
-    page: Page,
-    options: { name?: string; mac?: string } = {}
-): Promise<void> {
-    const { name = 'Mock Stalker Portal', mac = DEFAULT_MAC } = options;
-
-    await page.getByRole('button', { name: 'Add playlist' }).click();
-    const dialog = page.locator('mat-dialog-container');
-    await expect(dialog).toBeVisible();
-    // v0.22 redesign: tabs were replaced with a flat 5-card radio picker.
-    await dialog.getByRole('radio', { name: /Stalker portal/i }).click();
-
-    await setInputValue(dialog.locator('input#title'), name);
-    await setInputValue(dialog.locator('input#portalUrl'), PORTAL_URL);
-    await setInputValue(dialog.locator('input#macAddress'), mac);
-
-    const addButton = dialog.getByRole('button', {
-        name: 'Add playlist',
-        exact: true,
-    });
-    await expect(addButton).toBeEnabled({ timeout: 10_000 });
-    await addButton.click();
-    await expect(dialog).toBeHidden();
-    await page.waitForURL(/stalker.*vod/);
-}
-
-/**
- * Add a Stalker portal through the canonical Ministra URL, which the app
- * imports as a FULL portal: handshake, Bearer token and watchdog.
- */
-async function addFullStalkerPortal(
-    page: Page,
-    options: {
-        name?: string;
-        mac: string;
-        expectContent?: boolean;
-        username?: string;
-        password?: string;
-    }
-): Promise<void> {
-    const {
-        name = 'Full Stalker Portal',
-        mac,
-        expectContent = true,
-        username,
-        password,
-    } = options;
-
-    await page.getByRole('button', { name: 'Add playlist' }).click();
-    const dialog = page.locator('mat-dialog-container');
-    await expect(dialog).toBeVisible();
-    await dialog.getByRole('radio', { name: /Stalker portal/i }).click();
-
-    await setInputValue(dialog.locator('input#title'), name);
-    await setInputValue(dialog.locator('input#portalUrl'), FULL_PORTAL_URL);
-    await setInputValue(dialog.locator('input#macAddress'), mac);
-    if (username !== undefined) {
-        await setInputValue(dialog.locator('input#username'), username);
-    }
-    if (password !== undefined) {
-        await setInputValue(dialog.locator('input#password'), password);
-    }
-
-    const addButton = dialog.getByRole('button', {
-        name: 'Add playlist',
-        exact: true,
-    });
-    await expect(addButton).toBeEnabled({ timeout: 10_000 });
-    await addButton.click();
-    await expect(dialog).toBeHidden();
-
-    if (expectContent) {
-        await page.waitForURL(/stalker.*vod/, { timeout: 30_000 });
-    }
-}
-
-const CONTENT_ACTIONS = [
-    'get_categories',
-    'get_genres',
-    'get_ordered_list',
-    'get_all_channels',
-];
-
-/** Every portal request in order, with the token it carried. */
-function recordPortalRequests(
-    page: Page
-): Array<{ action: string; token: string | null }> {
-    const requests: Array<{ action: string; token: string | null }> = [];
-
-    page.on('request', (request) => {
-        const url = new URL(request.url());
-        if (!url.pathname.endsWith('/stalker')) {
-            return;
-        }
-        const action = url.searchParams.get('action');
-        if (!action) {
-            return;
-        }
-        requests.push({ action, token: url.searchParams.get('token') });
-    });
-
-    return requests;
-}
-
 // ---------------------------------------------------------------------------
 // Test setup
 // ---------------------------------------------------------------------------
@@ -967,16 +765,8 @@ test('@stalker favorites — embedded-series favorite refreshes newly released e
     request,
 }) => {
     // Find an embedded-series VOD item in the mock catalog first
-    const listResponse = await request.get(
-        `${MOCK_SERVER}/stalker?action=get_ordered_list&type=vod&category=2001&p=1&macAddress=${EMBEDDED_SERIES_MAC}&JsHttpRequest=1-xml`
-    );
-    const listBody = await listResponse.json();
-    const embeddedItem = listBody.payload.js.data.find(
-        (item: { series?: unknown[] }) =>
-            Array.isArray(item.series) && item.series.length > 0
-    );
-    expect(embeddedItem).toBeDefined();
-    const episodeCount: number = embeddedItem.series.length;
+    const { embeddedItem, episodeCount } =
+        await findEmbeddedSeriesItem(request);
 
     await addStalkerPortal(page, {
         name: 'Embedded Series Portal',
@@ -985,19 +775,7 @@ test('@stalker favorites — embedded-series favorite refreshes newly released e
 
     // Open the embedded-series item from its category and favorite it —
     // this persists a snapshot with the current episode list
-    const categories = page.locator('.category-item');
-    await expect(categories.first()).toBeVisible({ timeout: 10_000 });
-    await categories.nth(1).click();
-    const card = page.getByText(embeddedItem.name).first();
-    await expect(card).toBeVisible({ timeout: 10_000 });
-    await card.click();
-
-    await expect(
-        page.getByRole('heading', {
-            name: `${episodeCount}. Episode ${episodeCount}`,
-            exact: true,
-        })
-    ).toBeVisible({ timeout: 10_000 });
+    await openEmbeddedSeriesItem(page, embeddedItem.name, episodeCount);
     await page.getByRole('button', { name: 'Add to favorites' }).click();
     // Wait for the async favorite persistence before navigating away
     await expect(
@@ -1007,39 +785,7 @@ test('@stalker favorites — embedded-series favorite refreshes newly released e
     // From now on the portal has "released" one more episode: extend
     // series[] in every search response (the background snapshot refresh
     // re-fetches the item via a title search)
-    await page.route('**/localhost:3000/stalker**', async (route) => {
-        const originalUrl = new URL(route.request().url());
-        if (!originalUrl.searchParams.get('search')) {
-            await route.fallback();
-            return;
-        }
-
-        const mockUrl = new URL(BACKEND_PROXY);
-        const targetId = originalUrl.searchParams.get('targetId');
-        const providerUrl = targetId
-            ? Buffer.from(targetId, 'base64url').toString()
-            : originalUrl.searchParams.get('url');
-        if (providerUrl) {
-            mockUrl.searchParams.set('url', providerUrl);
-        }
-        originalUrl.searchParams.forEach((value, key) => {
-            if (key === 'targetId') {
-                return;
-            }
-            mockUrl.searchParams.set(key, value);
-        });
-
-        const response = await route.fetch({ url: mockUrl.toString() });
-        const body = await response.json();
-        const rows: { series?: string[] }[] =
-            body?.payload?.js?.data ?? body?.js?.data ?? [];
-        for (const row of rows) {
-            if (Array.isArray(row.series) && row.series.length > 0) {
-                row.series = [...row.series, String(row.series.length + 1)];
-            }
-        }
-        await route.fulfill({ response, body: JSON.stringify(body) });
-    });
+    await releaseExtraEpisodeInSearchResponses(page);
 
     // Open the item from the Favorites view: the stored snapshot renders
     // first, then the background refresh patches in the new episode
@@ -1083,35 +829,15 @@ test('@stalker season watched toggle — embedded series marks and clears every
     // Reuse the modeled embedded-series flow: find a VOD item carrying an
     // embedded series[] array, open it from its category, and land on the
     // series detail with its episode list.
-    const listResponse = await request.get(
-        `${MOCK_SERVER}/stalker?action=get_ordered_list&type=vod&category=2001&p=1&macAddress=${EMBEDDED_SERIES_MAC}&JsHttpRequest=1-xml`
-    );
-    const listBody = await listResponse.json();
-    const embeddedItem = listBody.payload.js.data.find(
-        (item: { series?: unknown[] }) =>
-            Array.isArray(item.series) && item.series.length > 0
-    );
-    expect(embeddedItem).toBeDefined();
-    const episodeCount: number = embeddedItem.series.length;
+    const { embeddedItem, episodeCount } =
+        await findEmbeddedSeriesItem(request);
 
     await addStalkerPortal(page, {
         name: 'Embedded Series Watch Portal',
         mac: EMBEDDED_SERIES_MAC,
     });
 
-    const categories = page.locator('.category-item');
-    await expect(categories.first()).toBeVisible({ timeout: 10_000 });
-    await categories.nth(1).click();
-    const card = page.getByText(embeddedItem.name).first();
-    await expect(card).toBeVisible({ timeout: 10_000 });
-    await card.click();
-
-    await expect(
-        page.getByRole('heading', {
-            name: `${episodeCount}. Episode ${episodeCount}`,
-            exact: true,
-        })
-    ).toBeVisible({ timeout: 10_000 });
+    await openEmbeddedSeriesItem(page, embeddedItem.name, episodeCount);
 
     await expectSeriesSurfacesInBothThemes(page, testInfo);
 
@@ -1153,35 +879,19 @@ test('@stalker series watched toggle — embedded series marks and clears from t
 }) => {
     // Same modeled embedded-series flow as the season test above, driven
     // through the series-level ⋮ menu instead of the season button.
-    const listResponse = await request.get(
-        `${MOCK_SERVER}/stalker?action=get_ordered_list&type=vod&category=2001&p=1&macAddress=${EMBEDDED_SERIES_MAC}&JsHttpRequest=1-xml`
-    );
-    const listBody = await listResponse.json();
-    const embeddedItem = listBody.payload.js.data.find(
-        (item: { series?: unknown[] }) =>
-            Array.isArray(item.series) && item.series.length > 0
-    );
-    expect(embeddedItem).toBeDefined();
-    const episodeCount: number = embeddedItem.series.length;
+    const { embeddedItem, episodeCount } =
+        await findEmbeddedSeriesItem(request);
 
     await addStalkerPortal(page, {
         name: 'Embedded Series Watch Menu Portal',
         mac: EMBEDDED_SERIES_MAC,
     });
 
-    const categories = page.locator('.category-item');
-    await expect(categories.first()).toBeVisible({ timeout: 10_000 });
-    await categories.nth(1).click();
-    const card = page.getByText(embeddedItem.name).first();
-    await expect(card).toBeVisible({ timeout: 10_000 });
-    await card.click();
-
-    await expect(
-        page.getByRole('heading', {
-            name: `${episodeCount}. Episode ${episodeCount}`,
-            exact: true,
-        })
-    ).toBeVisible({ timeout: 10_000 });
+    const card = await openEmbeddedSeriesItem(
+        page,
+        embeddedItem.name,
+        episodeCount
+    );
 
     // The series row sits in the hero's "…" menu (data-test-id with a dash —
     // getByTestId only matches data-testid in this suite; the row renders
diff --git a/apps/web-e2e/src/workspace-header-back.e2e.ts b/apps/web-e2e/src/workspace-header-back.e2e.ts
new file mode 100644
index 000000000..6bdb5f175
--- /dev/null
+++ b/apps/web-e2e/src/workspace-header-back.e2e.ts
@@ -0,0 +1,86 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from './fixtures';
+import {
+    addXtreamPortal,
+    interceptXtreamRequests,
+    MOCK_SERVER,
+} from './xtream-series-playback.fixture';
+
+/**
+ * Pages reached from a detail or the header search draw no Back arrow of
+ * their own: they register the workspace header's leading Back, which keeps
+ * their previous return behaviour (history Back).
+ * Contract: docs/architecture/workspace-shell.md, "Header Back".
+ */
+
+const headerBack = (page: Page) =>
+    page.locator(
+        'app-workspace-shell-header [data-test-id="workspace-header-back"]'
+    );
+
+/** The one Back button on the page, wherever it lives. */
+const anyBack = (page: Page) =>
+    page.getByRole('button', { name: 'Back', exact: true });
+
+async function expectOnlyHeaderBack(page: Page): Promise<void> {
+    await expect(headerBack(page)).toBeVisible();
+    await expect(anyBack(page)).toHaveCount(1);
+    // None of these pages handles Escape.
+    await expect(headerBack(page)).not.toHaveAttribute('aria-keyshortcuts');
+}
+
+test.beforeEach(async ({ page, request }) => {
+    await request.post(`${MOCK_SERVER}/reset`);
+    await page.goto('/');
+    await interceptXtreamRequests(page);
+    await addXtreamPortal(page);
+});
+
+test('@web @xtream the in-portal search page returns through the header Back', async ({
+    page,
+}) => {
+    await page
+        .locator('app-workspace-shell-rail a[href$="/workspace/dashboard"]')
+        .first()
+        .click();
+    await page.waitForURL(/\/workspace\/dashboard$/);
+    // The rail link's tooltip would otherwise sit over the header's leading
+    // button for as long as the pointer rests on the link.
+    await page.mouse.move(640, 400);
+
+    // Enter on the dashboard opens the active portal's search page.
+    const search = page.locator(
+        'app-workspace-shell-header .search-field input[type="search"]'
+    );
+    await search.fill('Movie');
+    await search.press('Enter');
+    await page.waitForURL(/\/workspace\/xtreams\/[^/]+\/search\?q=Movie$/);
+    await expect(page.locator('app-search-layout')).toBeVisible();
+
+    await expectOnlyHeaderBack(page);
+    await headerBack(page).click();
+    await page.waitForURL(/\/workspace\/dashboard$/);
+});
+
+for (const { name, path, selector } of [
+    {
+        name: 'Discover',
+        path: 'discover?type=movie&genre=18&genreLabel=Drama',
+        selector: 'app-discover-view',
+    },
+    { name: 'actor', path: 'actor/287', selector: 'app-actor-view' },
+]) {
+    test(`@web @xtream the ${name} page returns through the header Back`, async ({
+        page,
+    }) => {
+        const listUrl = page.url();
+        const portalUrl = listUrl.replace(/\/vod.*$/, '');
+
+        await page.goto(`${portalUrl}/${path}`);
+        await expect(page.locator(selector)).toBeAttached();
+
+        await expectOnlyHeaderBack(page);
+        await headerBack(page).click();
+        await page.waitForURL(listUrl);
+    });
+}
diff --git a/apps/web/src/app/settings/settings-embedded-mpv.facade.spec.ts b/apps/web/src/app/settings/settings-embedded-mpv.facade.spec.ts
new file mode 100644
index 000000000..069b409c6
--- /dev/null
+++ b/apps/web/src/app/settings/settings-embedded-mpv.facade.spec.ts
@@ -0,0 +1,89 @@
+import { TestBed } from '@angular/core/testing';
+import { RuntimeCapabilitiesService } from '@iptvnator/services';
+import {
+    EMBEDDED_MPV_SUPPORT_RECHECK_MS,
+    EmbeddedMpvSupport,
+} from '@iptvnator/shared/interfaces';
+import { SettingsEmbeddedMpvFacade } from './settings-embedded-mpv.facade';
+
+const SUPPORTED: EmbeddedMpvSupport = { supported: true, platform: 'linux' };
+/** A slow login shell: mpv was looked up before its PATH arrived. */
+const INCONCLUSIVE: EmbeddedMpvSupport = {
+    supported: false,
+    platform: 'linux',
+    reason: 'mpv executable missing',
+    inconclusive: true,
+};
+
+describe('SettingsEmbeddedMpvFacade', () => {
+    const originalElectron = window.electron;
+    let getEmbeddedMpvSupport: jest.Mock;
+    let facade: SettingsEmbeddedMpvFacade;
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        getEmbeddedMpvSupport = jest.fn();
+        window.electron = {
+            platform: 'linux',
+            getEmbeddedMpvSupport,
+        } as unknown as typeof window.electron;
+        TestBed.configureTestingModule({
+            providers: [
+                SettingsEmbeddedMpvFacade,
+                {
+                    provide: RuntimeCapabilitiesService,
+                    useValue: { isElectron: true },
+                },
+            ],
+        });
+        facade = TestBed.inject(SettingsEmbeddedMpvFacade);
+    });
+
+    afterEach(() => {
+        TestBed.resetTestingModule();
+        window.electron = originalElectron;
+        jest.useRealTimers();
+    });
+
+    it('offers Embedded MPV once an inconclusive answer turns into supported', async () => {
+        getEmbeddedMpvSupport
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValue(SUPPORTED);
+
+        await facade.load();
+        expect(facade.supported()).toBe(false);
+
+        // The page stays open; nobody calls load() again.
+        await jest.advanceTimersByTimeAsync(EMBEDDED_MPV_SUPPORT_RECHECK_MS);
+        expect(facade.supported()).toBe(true);
+
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+        );
+        expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+    });
+
+    it('stops asking once the settings page is closed', async () => {
+        getEmbeddedMpvSupport.mockResolvedValue(INCONCLUSIVE);
+        await facade.load();
+
+        TestBed.resetTestingModule();
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+        );
+
+        expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(1);
+    });
+
+    it('reports a failed probe as unsupported', async () => {
+        getEmbeddedMpvSupport.mockRejectedValue(new Error('addon load failed'));
+
+        await facade.load();
+
+        expect(facade.support()).toEqual({
+            supported: false,
+            platform: 'linux',
+            reason: 'addon load failed',
+        });
+    });
+});
diff --git a/apps/web/src/app/settings/settings-embedded-mpv.facade.ts b/apps/web/src/app/settings/settings-embedded-mpv.facade.ts
index cfe738c72..59c2cb632 100644
--- a/apps/web/src/app/settings/settings-embedded-mpv.facade.ts
+++ b/apps/web/src/app/settings/settings-embedded-mpv.facade.ts
@@ -1,6 +1,15 @@
-import { computed, inject, Injectable, signal } from '@angular/core';
+import {
+    computed,
+    DestroyRef,
+    inject,
+    Injectable,
+    signal,
+} from '@angular/core';
 import { RuntimeCapabilitiesService } from '@iptvnator/services';
-import { EmbeddedMpvSupport } from '@iptvnator/shared/interfaces';
+import {
+    EmbeddedMpvSupport,
+    watchEmbeddedMpvSupport,
+} from '@iptvnator/shared/interfaces';
 
 /**
  * Probes the desktop backend for embedded MPV support so the playback
@@ -9,6 +18,7 @@ import { EmbeddedMpvSupport } from '@iptvnator/shared/interfaces';
 @Injectable()
 export class SettingsEmbeddedMpvFacade {
     private readonly runtime = inject(RuntimeCapabilitiesService);
+    private stopSupportWatch: (() => void) | undefined;
 
     readonly support = signal<EmbeddedMpvSupport | null>(null);
 
@@ -24,6 +34,14 @@ export class SettingsEmbeddedMpvFacade {
         () => this.support()?.engine === 'frame-copy'
     );
 
+    constructor() {
+        inject(DestroyRef).onDestroy(() => this.stopSupportWatch?.());
+    }
+
+    /**
+     * Resolves with the first answer. An inconclusive one keeps being asked
+     * for while the page is open, so the option appears without reopening it.
+     */
     async load(): Promise<void> {
         if (!this.runtime.isElectron) {
             this.support.set({
@@ -43,15 +61,27 @@ export class SettingsEmbeddedMpvFacade {
             return;
         }
 
-        try {
-            this.support.set(await window.electron.getEmbeddedMpvSupport());
-        } catch (error) {
-            this.support.set({
-                supported: false,
-                platform: window.electron.platform,
-                reason: error instanceof Error ? error.message : String(error),
-            });
-        }
+        this.stopSupportWatch?.();
+        await new Promise<void>((answered) => {
+            this.stopSupportWatch = watchEmbeddedMpvSupport(
+                () => window.electron.getEmbeddedMpvSupport(),
+                (support) => {
+                    this.support.set(support);
+                    answered();
+                },
+                (error) => {
+                    this.support.set({
+                        supported: false,
+                        platform: window.electron.platform,
+                        reason:
+                            error instanceof Error
+                                ? error.message
+                                : String(error),
+                    });
+                    answered();
+                }
+            );
+        });
     }
 
     /**
diff --git a/apps/web/src/app/settings/settings-search.facade.ts b/apps/web/src/app/settings/settings-search.facade.ts
index 036c80b73..5893c85e0 100644
--- a/apps/web/src/app/settings/settings-search.facade.ts
+++ b/apps/web/src/app/settings/settings-search.facade.ts
@@ -66,7 +66,9 @@ export class SettingsSearchFacade {
     });
 
     constructor() {
-        void this.settingsSearch.ensureEmbeddedMpvSupportLoaded();
+        inject(DestroyRef).onDestroy(
+            this.settingsSearch.followEmbeddedMpvSupport()
+        );
 
         effect(() => {
             if (!this.isSearching()) {
diff --git a/apps/web/src/app/settings/settings.component.search.spec.ts b/apps/web/src/app/settings/settings.component.search.spec.ts
index 075357c25..540761a1d 100644
--- a/apps/web/src/app/settings/settings.component.search.spec.ts
+++ b/apps/web/src/app/settings/settings.component.search.spec.ts
@@ -95,6 +95,21 @@ describe('SettingsComponent search', () => {
         expect(query('app-settings-general-section')).not.toBeNull();
     });
 
+    it('follows Embedded MPV support only while the page is open', () => {
+        const stopFollowing = jest.fn();
+        const follow = jest
+            .spyOn(settingsSearch, 'followEmbeddedMpvSupport')
+            .mockReturnValue(stopFollowing);
+
+        const page = TestBed.createComponent(SettingsComponent);
+        expect(follow).toHaveBeenCalledTimes(1);
+        expect(stopFollowing).not.toHaveBeenCalled();
+
+        // Closing the page ends it: nothing shows these rows any more.
+        page.destroy();
+        expect(stopFollowing).toHaveBeenCalledTimes(1);
+    });
+
     it('shows an empty state when nothing matches', () => {
         setSettingsSearchQuery('zzzz-no-such-setting');
         fixture.detectChanges();
diff --git a/apps/web/src/m3-theme.scss b/apps/web/src/m3-theme.scss
index 439ccfd9e..f37d6d652 100644
--- a/apps/web/src/m3-theme.scss
+++ b/apps/web/src/m3-theme.scss
@@ -157,8 +157,9 @@ html {
     --app-cta-fg: #f5f6f8;
     --app-cta-hover-bg: #2a2f3a;
     --app-cta-meta-fg: rgba(245, 246, 248, 0.68);
-    // Star rating chip: amber on white needs a deeper tone than gold on dark.
-    --app-rating-color: #a16207;
+    // Star rating chip: a deep amber, since the chip's 12px text needs
+    // 4.5:1 over hero artwork under the light scrim (#a16207 measured 3.4:1).
+    --app-rating-color: #7a4a00;
 
     .dark-theme {
         @include mat.all-component-colors($dark-theme);
diff --git a/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-dark.png b/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-dark.png
index f8d61d7ed..713e5c640 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-dark.png and b/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-light.png b/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-light.png
index af070aab1..6112f46d5 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-light.png and b/apps/website/public/blog/guides/screenshots/guide-m3u-add-playlist-light.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-dark.png b/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-dark.png
index 99c16e3d3..c75af50d2 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-dark.png and b/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-light.png b/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-light.png
index 2f6935e15..63d40b8b0 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-light.png and b/apps/website/public/blog/guides/screenshots/guide-stalker-add-playlist-light.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-dark.png b/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-dark.png
index 8883662e4..916c16e53 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-dark.png and b/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-light.png b/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-light.png
index d17c79e59..de6d4919e 100644
Binary files a/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-light.png and b/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-light.png differ
diff --git a/apps/website/src/content/blog/m3u-playlist-epg-setup-guide.mdx b/apps/website/src/content/blog/m3u-playlist-epg-setup-guide.mdx
index 14e0c9829..27b4ff631 100644
--- a/apps/website/src/content/blog/m3u-playlist-epg-setup-guide.mdx
+++ b/apps/website/src/content/blog/m3u-playlist-epg-setup-guide.mdx
@@ -52,7 +52,7 @@ to the self-hosted browser version.
   steps={[
     'Open the Add playlist dialog from the dashboard, the header playlist switcher, or the command palette entry "Add M3U playlist".',
     'Choose "M3U URL" and paste the link your provider gave you, or choose "M3U file" and pick the file, or choose "Raw m3u text" and paste the playlist itself.',
-    'Give the playlist a title. For a URL the title is optional; IPTVnator falls back to the file name.',
+    'For a URL, optionally fill in a playlist title; without one, IPTVnator falls back to the file name. A file keeps its file name and pasted text is titled "Imported as text"; you can rename either later.',
     'Click "Add playlist". The channels are parsed, grouped by their group-title attribute, and the playlist opens.',
   ]}
 />
diff --git a/apps/website/src/content/blog/playlist-backup-restore-guide.mdx b/apps/website/src/content/blog/playlist-backup-restore-guide.mdx
index b731366a1..f16b9250f 100644
--- a/apps/website/src/content/blog/playlist-backup-restore-guide.mdx
+++ b/apps/website/src/content/blog/playlist-backup-restore-guide.mdx
@@ -1,13 +1,13 @@
 ---
 title: Back Up Your Playlists and Move to a New Computer
 description: Export and restore an IPTVnator playlist backup, understand which favorites and playback state it carries, and check what needs to be moved separately when changing computers.
-pubDate: 2026-09-27
+pubDate: 2026-10-04
 author: 4gray
 heroImage: /iptvnator/blog/feature-guides/screenshots/guide-backup-dark.png
 tags:
     - guide
     - troubleshooting
-draft: true
+draft: false
 faq:
     - q: Is a playlist backup a complete copy of the app?
       a: No. It contains playlist definitions, supported playlist-specific user state and global EPG source addresses. It does not include the full settings profile, cached catalog and EPG data, or downloaded media.
@@ -38,7 +38,7 @@ by source type, so check the table below before relying on it as your only copy
 1. On the computer with the library you want to keep, open **Settings → Backup**.
 2. Under **Import/export playlist backups**, choose **Export**.
 3. Save the JSON file. The suggested name includes the export date, for example
-   `iptvnator-playlist-backup-2026-09-27.json`.
+   `iptvnator-playlist-backup-2026-10-04.json`.
 4. Keep a copy outside the app's own data folder. If you are moving computers, transfer
    it through a location you control.
 
@@ -46,9 +46,9 @@ Export the receiving computer's library too if it already has sources and favori
 care about. Restoring a snapshot can replace saved state for a matching source; preserving
 both backups gives you a record of each library before the import.
 
-![Settings Backup with Import data and Export data actions](/iptvnator/blog/feature-guides/screenshots/guide-backup-dark.png)
+![Settings Backup with Import and Export actions](/iptvnator/blog/feature-guides/screenshots/guide-backup-dark.png)
 
-*Settings → Backup contains both actions: Export data creates the backup; Import data restores it.*
+*Settings → Backup contains both actions: Export creates the backup; Import restores it.*
 
 ## What travels in the file
 
@@ -108,6 +108,7 @@ importing snapshots can make it harder to tell which state you are examining.
 
 ## Related
 
+- [Choose between Stable and Nightly updates](/iptvnator/blog/stable-nightly-updates-guide/)
 - [Add an M3U playlist and EPG](/iptvnator/blog/m3u-playlist-epg-setup-guide/)
 - [Connect an Xtream account](/iptvnator/blog/xtream-codes-setup-guide/)
 - [Connect a Stalker portal](/iptvnator/blog/stalker-portal-setup-guide/)
diff --git a/apps/website/src/content/blog/stable-nightly-updates-guide.mdx b/apps/website/src/content/blog/stable-nightly-updates-guide.mdx
index 37e8d4d8a..784d540da 100644
--- a/apps/website/src/content/blog/stable-nightly-updates-guide.mdx
+++ b/apps/website/src/content/blog/stable-nightly-updates-guide.mdx
@@ -1,12 +1,12 @@
 ---
 title: Stable or Nightly? How IPTVnator Updates Work
 description: Choose an update channel in the desktop app, understand what happens when you switch back to Stable, and find the build details that make a nightly bug report useful.
-pubDate: 2026-09-27
+pubDate: 2026-10-04
 author: 4gray
 heroImage: /iptvnator/blog/feature-guides/screenshots/guide-update-channel-dark.png
 tags:
     - guide
-draft: true
+draft: false
 faq:
     - q: Which update channel should I use?
       a: Stable is the default and suits everyday viewing. Nightly is for trying changes before the next stable release and helping test them. Nightly builds can introduce regressions.
@@ -103,6 +103,7 @@ the update or only after refreshing a playlist.
 
 ## Related
 
+- [Back up your playlists before updating](/iptvnator/blog/playlist-backup-restore-guide/)
 - [Stable releases](https://github.com/4gray/iptvnator/releases)
 - [Nightly builds](https://github.com/4gray/iptvnator-nightly/releases)
 - [Desktop installation options](/iptvnator/download/)
diff --git a/apps/website/src/content/blog/stalker-portal-setup-guide.mdx b/apps/website/src/content/blog/stalker-portal-setup-guide.mdx
index ebd74b90c..ed194a65b 100644
--- a/apps/website/src/content/blog/stalker-portal-setup-guide.mdx
+++ b/apps/website/src/content/blog/stalker-portal-setup-guide.mdx
@@ -14,11 +14,11 @@ faq:
 - q: Which portal URL should I enter?
   a: Whatever your provider gave you, as long as it starts with http or https. A bare host, an address ending in /c, portal.php, or server/load.php all work. IPTVnator probes the usual endpoints behind that address and keeps the one that answers, so you rarely need to guess the exact path.
 - q: The provider's MAC address is written with dashes or in lowercase. Does it matter?
-  a: No. IPTVnator normalizes hyphens, dots, spaces and lowercase letters into the canonical 00:1A:79:XX:XX:XX form when you leave the field, and again when you click Add. The bytes stay the same, so the portal sees the address it registered.
+  a: No. IPTVnator normalizes hyphens, dots, spaces and lowercase letters into the canonical 00:1A:79:XX:XX:XX form when you leave the field, and again when you click Add playlist. The bytes stay the same, so the portal sees the address it registered.
 - q: Should I turn on "Generate device IDs from the MAC address"?
   a: Only for a MAC the portal has never seen, or one you already use in StbEmu with generated IDs. A portal pins the first device ID it receives to the MAC and refuses any other one afterwards, so enabling it for an existing box with a different ID locks the account out. If your provider did not mention device IDs, leave the option off.
 - q: Why does IPTVnator ask for a username and password on some portals?
-  a: A few Ministra portals require a login on top of the MAC address. IPTVnator reports "This portal requires a login and password" when it sees that; fill in the two optional fields and click Add again. Portals that never ask for it ignore the fields.
+  a: A few Ministra portals require a login on top of the MAC address. IPTVnator reports "This portal requires a login and password" under the portal URL when it sees that; fill in the two optional fields and click Add playlist again. Portals that never ask for it ignore the fields.
 - q: Does IPTVnator show a program guide and catch-up for portal channels?
   a: Yes. It loads the portal's seven-day schedule once per session and shows the current program in the channel list and a timeline under the player. Channels the portal marks as archived can be played from the timeline. On the desktop app, XMLTV sources configured in the settings act as a fallback.
 - q: Where can I see when my portal subscription expires?
@@ -65,8 +65,8 @@ it, because some reseller panels are configured differently.
   steps={[
     'Open the Add playlist dialog from the dashboard, the header playlist switcher, or the command palette entry "Add Stalker portal".',
     'Choose the "Stalker portal" method.',
-    'Fill in a title of your choice, the portal URL and the MAC address. Leave the optional fields empty unless your provider gave you values for them.',
-    'Click "Add". IPTVnator probes the portal, authenticates with your MAC address, and opens the new source. "Validating portal..." can take a few seconds on slow servers.',
+    'Fill in a playlist title of your choice, the portal URL in the "Server URL" field and the MAC address. Leave the optional fields empty unless your provider gave you values for them.',
+    'Click "Add playlist". IPTVnator probes the portal, authenticates with your MAC address, and opens the new source. "Validating portal…" can take a few seconds on slow servers.',
   ]}
 />
 
@@ -75,10 +75,10 @@ it, because some reseller panels are configured differently.
 <Alert type="success" title="Paste the provider message instead">
   The Auto-detect method in the same dialog reads a pasted email or chat message. A MAC
   address is its strongest signal, so a message with a portal link and a MAC address
-  pre-fills the Stalker form for you. You still click Add yourself.
+  pre-fills the Stalker form for you. You still click Add playlist yourself.
 </Alert>
 
-## What happens when you click Add
+## What happens when you click Add playlist
 
 Providers write portal addresses in a dozen shapes, and the same host can run a strict
 Ministra middleware or a tolerant reseller panel. Guessing from the URL used to break real
@@ -94,10 +94,11 @@ setups, so IPTVnator no longer guesses:
    that address, and if a provider migrates the portal, IPTVnator re-probes once on the
    first failure and repairs the stored connection.
 
-On a full portal the profile also carries your subscription facts, and the dialog confirms
-the import with the expiry date. A portal that cannot be reached during the import is still
-added when the address looks like a panel, so a temporarily offline provider does not block
-you; the next successful request completes the setup.
+On a full portal the profile also carries your subscription facts, and IPTVnator confirms
+the import with "Portal validated" and the expiry date. A portal that cannot be reached
+during the import is still added when the address looks like a panel, with a notice that it
+was added without validation, so a temporarily offline provider does not block you; the next
+successful request completes the setup.
 
 ## After the import
 
@@ -146,7 +147,8 @@ behind your back, and that matters because of how portals treat device IDs:
   later one. A later empty value locks the MAC out for good.
 - **Generate device IDs from the MAC address** produces the same pair StbEmu generates, so a
   MAC you already use there keeps working. It is offered at import only, writes the values
-  into the visible fields, and re-derives them if you correct the MAC before clicking Add.
+  into the visible fields, and re-derives them if you correct the MAC before clicking Add
+  playlist.
 - Once a device ID is stored, the playlist details dialog warns before you change or clear
   it, because the portal will not accept the new value.
 
@@ -155,10 +157,13 @@ exactly those values.
 
 ## Troubleshooting
 
+When the portal refuses the import, the dialog stays open and shows the reason under the
+portal URL, followed by the portal's own words when it sent any. Editing a field clears it.
+
 - **The portal requires a login and password**: fill in the optional username and password
-  fields and click Add again. Some Ministra portals demand a login on top of the MAC address.
+  fields and click Add playlist again. Some Ministra portals demand a login on top of the MAC address.
 - **The portal rejected the login and password**: the credentials are wrong or the
-  subscription lapsed; the portal's own message is shown below the headline.
+  subscription lapsed; the portal's own message follows the headline.
 - **The portal has a different device ID registered for this MAC address**: another box or
   emulator authenticated first. Restore the device ID you used there, or ask the provider to
   reset the device for this MAC.
diff --git a/apps/website/src/content/blog/xtream-codes-setup-guide.mdx b/apps/website/src/content/blog/xtream-codes-setup-guide.mdx
index 5016956c6..f0600967f 100644
--- a/apps/website/src/content/blog/xtream-codes-setup-guide.mdx
+++ b/apps/website/src/content/blog/xtream-codes-setup-guide.mdx
@@ -66,18 +66,21 @@ credentials. IPTVnator can read them out of the link for you, as shown below.
     'Open the Add playlist dialog. You will find the button on the dashboard, in the header playlist switcher, and in the command palette under "Add Xtream Codes playlist".',
     'Choose the "Xtream credentials" method.',
     'Fill in a playlist title of your choice, the server URL, the username and the password.',
-    'Click "Test Connection". IPTVnator asks the portal for the account status and shows the result under the form.',
-    'Click "Add". IPTVnator downloads the categories for live TV, movies and series and opens the new source.',
+    'Click "Test HTTPS and HTTP". IPTVnator asks the portal for the account status and shows the result under the server URL. If an `https://` address refuses the connection or does not speak HTTPS, the test retries the same address over plain HTTP once, which is why the dialog warns that your username and password may travel unencrypted.',
+    'Click "Add playlist". IPTVnator downloads the categories for live TV, movies and series and opens the new source.',
   ]}
 />
 
 ![Add playlist dialog with the Xtream credentials method selected and a successful connection test](/iptvnator/blog/guides/screenshots/guide-xtream-add-playlist-dark.png)
 
-The connection test reports one of four states. **Connection successful! Portal is active** is
-the one you want. **Portal subscription has expired** and **Portal is inactive** mean the
-portal answered but refuses the account; check the subscription with your provider. **Could
-not connect to the portal** means no answer at all: a typo in the server URL, a wrong port, a
-missing `http://` or `https://`, or a host that is down.
+**Connected. The portal is active.** is the result you want; **Connected using HTTP** means the
+same over an unencrypted connection, after the HTTPS attempt failed and the server URL was
+switched to `http://`. **The subscription has expired** and **The account is inactive or the
+credentials are incorrect** mean the portal answered but refuses the account: check the
+credentials, then the subscription with your provider. **Could not reach the server** means no
+answer at all: a typo in the server URL, a wrong port, or a host that is down. The remaining
+messages name what went wrong instead: a failed secure connection, an HTTP error status, or a
+server that answered without valid account information.
 
 <Alert type="success" title="Paste the whole link">
   If you paste a complete `get.php` or `player_api.php` link into the Server URL field while the
diff --git a/docs/architecture/embedded-inline-playback.md b/docs/architecture/embedded-inline-playback.md
index 38751413c..dca9795c3 100644
--- a/docs/architecture/embedded-inline-playback.md
+++ b/docs/architecture/embedded-inline-playback.md
@@ -383,15 +383,17 @@ meanwhile. The host reports busy-state back through the
 
 A series-level counterpart lives in a `⋮` menu at the end of the same
 header row (`SeasonWatchPresenter` in `libs/ui/components` owns the state
-math for both scopes; the container component sits at the max-lines cap).
+math for both scopes, which keeps the container component under the
+max-lines cap).
 `buildSeriesWatchToggleRequest` flattens every LOADED season with the same
 mark/unmark semantics, and the direction is always the one the label
 advertised (`markWatched: !seriesFullyWatched()`), never re-inferred from
 data at persist time. Hosts route the request through the same machinery
 as the season toggle — Xtream via the scope-parameterized
-`SerialDetailsSeasonWatchService.handle(..., scope)`, Stalker via the
-extracted `runWatchToggleBatch` core — sharing the busy flag, the
-ownership guards, and the catalog-badge refresh. Stalker lazy-VOD is the
+`SerialDetailsSeasonWatchService.handle(..., scope)`, Stalker via
+`StalkerSeriesWatchToggleService` and its `runStalkerWatchToggleBatch`
+core — sharing the busy flag, the ownership guards, and the catalog-badge
+refresh. Stalker lazy-VOD is the
 special case: unopened seasons have empty episode lists, so the container
 reports them through the `hasUnloadedSeasons` input (blocks the
 "fully watched" verdict and switches the label to its countless variant),
@@ -412,7 +414,8 @@ series-toggle hydration join one in-flight request instead of
 duplicating it (a second request's failure could abort a toggle whose
 original request succeeded).
 The host synchronously re-runs the position reconcile
-(`applyReconciledSeriesPositions` — the effect-fed maps only update on
+(`StalkerSeriesPositionsService.applyReconciledSeriesPositions` — the
+effect-fed maps only update on
 the next change-detection tick, and enqueuing against stale maps would
 miss the hydrated episodes' legacy rows), rebuilds the request from the
 now-complete seasons keeping the captured direction, and reports an
@@ -468,6 +471,58 @@ position telemetry overwrites this launch marker when available. This keeps the
 last-watched season and episode correct even when an external player's progress
 interface is unavailable; exact external timestamps remain best-effort.
 
+## Forced External Launches From Detail Pages
+
+The detail "…" menu's "Open in external player" sends the title to MPV/VLC
+through `PortalPlayer.openExternalPlayback(playback, player)` whatever the
+configured player is. The launch IPC cannot be cancelled, and until it
+resolves the session is at most `launching` and may not have a closer yet.
+Every detail host therefore keeps these rules:
+
+- **One external player per owner.** Before launching, the host closes the
+  external session the page owns: the session of the same title on the
+  Stalker pages and the Xtream series page; the session it launched, else the
+  one matching its movie, on the Xtream movie page. Sessions the page does not
+  own are left alone. With instance reuse off, a second detached player would
+  otherwise start beside the first. Stalker hosts use
+  `replaceOwnedExternalSession` from
+  `@iptvnator/portal/shared/util`; the Xtream pages use
+  `closeRunningExternalSession` with the same outcome rules.
+- **Unconfirmed teardown cancels the launch.** A live session without a
+  closer, or a close that rejects, leaves the running player in place and
+  nothing new launches.
+- **Ownership is rechecked after every await.** Stream resolution, the close
+  and the launch IPC can each outlive the page or be superseded by a newer
+  start. A stale step stops without reporting, and a launch that resolves
+  stale closes the session it just opened.
+- **No second player while a launch settles.** A repeat of the same launch is
+  ignored, or its control stays disabled. Movie pages refuse or disable every
+  other start of that title until the launch settles. Series pages hold the
+  latest episode choice and, once the launch settled, replace the player it
+  opened, only while that series is still on screen.
+- **Pending starts are owner-scoped.** A start still resolving holds the
+  actions of its own title only: another title shown by the reused page is
+  not blocked by it. Movie hosts track starts with
+  `createPendingPlaybackStart` (`@iptvnator/portal/shared/util`): only the
+  latest start may clear the flag, and `isPendingFor(owner)` answers for one
+  owner. The Stalker movie hosts, whose starts wait on a portal round trip,
+  also `retire(owner)` when the selection leaves it, so a start that never
+  settles does not keep the flag set on a return to the same title. A movie's
+  "Reset progress" is scoped the same way.
+- **Two gates are page-wide.** The Xtream movie page refuses Play, Start
+  over, source switches and the menu launch while an external launch it made
+  has not settled. A series page runs one watched or reset batch at a time,
+  whichever series is shown; the Stalker page also holds episode starts until
+  that batch settles.
+
+Owner keys and queueing are provider contracts:
+
+| Host | Contract |
+| --- | --- |
+| Xtream series | [Forced external launches from detail pages](./xtream-portal-compatibility.md#forced-external-launches-from-detail-pages) |
+| Xtream movie | [Menu launch and reset follow the primary button](./vod-multi-source.md#menu-launch-and-reset-follow-the-primary-button) |
+| Stalker series and movies | [Forced External Launches](./stalker-portal.md#forced-external-launches) |
+
 ## Series Quick Start CTA
 
 Xtream and Stalker series detail views share the quick-start decision helper in
diff --git a/docs/architecture/embedded-mpv-native.md b/docs/architecture/embedded-mpv-native.md
index 69f46a5d3..d3ac24548 100644
--- a/docs/architecture/embedded-mpv-native.md
+++ b/docs/architecture/embedded-mpv-native.md
@@ -185,6 +185,39 @@ support API from global workspace startup paths; use an explicit user action
 or idle preparation path when a renderer surface only needs to reveal optional
 Embedded MPV UI.
 
+An unsupported answer can be `inconclusive`. The Linux native-view `mpv`
+executable check runs `mpv --version` by bare name, so the support and prepare
+handlers wait for the login shell PATH lookup (`startup/login-shell-path.ts`)
+first. When that lookup runs out of its budget, the check runs on the
+inherited PATH: `EmbeddedMpvNativeService` then reports a missing `mpv` as
+`supported: false` with `inconclusive: true`, keeps doing so while the cached
+result stands, and probes again once the shell answers. Every other answer,
+including a missing `mpv` after the shell answered, is final. An inconclusive
+answer is not a verdict on the machine: never persist a decision made from it.
+Whatever holds on to one answer follows it through `watchEmbeddedMpvSupport()`
+(`@iptvnator/shared/interfaces`), which asks again after
+`EMBEDDED_MPV_SUPPORT_RECHECK_MS`, backing off to
+`EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS`, until the answer is final:
+
+- The settings store keeps a saved Embedded MPV selection while the answer is
+  inconclusive, falls back to the default player only on a final unsupported
+  answer, and never overwrites a player the user picked meanwhile.
+- The player (`EmbeddedMpvSessionController`) and the settings page stay
+  mounted on one answer: a player mounted in that window starts playback by
+  itself once `mpv` is found, and the option appears without reopening the
+  page.
+- The settings page also follows the answer for its search
+  (`SettingsSearchService.followEmbeddedMpvSupport()`) and ends that when it
+  closes: the Embedded MPV rows become searchable while the page stays open,
+  and nothing keeps asking once no surface shows them.
+
+The command palette asks on demand, on every open, for its player commands and
+its settings rows (`ensureEmbeddedMpvSupportLoaded()`). Only a final answer is
+kept for the session; after an inconclusive one, or a failed request, the next
+open asks again. An open palette is a snapshot of that moment: it does not wait
+for a final answer, because a login shell that never answers would then keep
+it from opening.
+
 When `embedded-mpv` is the saved player, the settings store schedules an idle `prepareEmbeddedMpv()` call. This intentionally moves the first native addon load away from the click-to-play path. It can still block the Electron main process briefly because Node native addon loading is synchronous, but doing it during idle is less visible than doing it when the user clicks a video. Actual MPV session creation still happens on playback because it needs the current Electron window handle and viewport bounds.
 
 For the native-view engine, the MPV video surface is a platform view/window,
@@ -967,7 +1000,7 @@ Defensive practice for this component:
 
 Concrete bugs from the audit, recorded so they don't get reintroduced:
 
-- **Infinite session-create loop.** `EmbeddedMpvSessionController.startSession` once wrote `this.support.set(prepared)` after the `prepareEmbeddedMpv` round-trip. The component's session-creation effect tracks `this.support()`, so the write fired the effect → cleanup disposed the session → new session was created → prepare ran again → support was set again. Symptom: endless "Loading stream…" spinner. Fix: do not write `support` inside `startSession`; the constructor's `loadSupport()` already populates it including capabilities.
+- **Infinite session-create loop.** `EmbeddedMpvSessionController.startSession` once wrote `this.support.set(prepared)` after the `prepareEmbeddedMpv` round-trip. The component's session-creation effect tracks `this.support()`, so the write fired the effect → cleanup disposed the session → new session was created → prepare ran again → support was set again. Symptom: endless "Loading stream…" spinner. Fix: do not write `support` inside `startSession`; the constructor's `watchSupport()` already populates it including capabilities.
 - **Stream restart on volume change.** The session-creation effect once read `this.volume()` directly to pass to `startSession`'s `initialVolume`. Each volume tick re-ran the effect, disposing and recreating the session — for VOD/series this restarted playback from the beginning. Fix: read it via `untracked(() => this.volume())`. Subsequent volume changes flow through `controller.applyVolume()`, never through the effect graph.
 - **Spurious `timeUpdate` re-emits and `volume.set` calls.** The session-fan-out effect calls `scheduleControlsHide()`, which reads `isPlaying`, `menus.anyOpen`, `statusLabel`, and `controlsVisible`. Those reads became tracked deps, so opening any popover, pausing, or hovering re-ran the body. No loop in isolation, but a parent that wires `timeUpdate` back into `playback.startTime` would have hit the volume-restart bug class. Fix: wrap the side-effect block in `untracked()` so the effect listens only to session changes.
 - **2 Hz no-op stalled-tracker re-runs.** Position polling updates `session` around 2 Hz. Tracking the full session would re-run stalled logic for snapshots with unchanged status, so the controller tracks only `sessionStatus` and invokes `EmbeddedMpvStalledTracker.track` inside `untracked()`, avoiding full-session reruns.
diff --git a/docs/architecture/iptvnator-ui-guidelines.md b/docs/architecture/iptvnator-ui-guidelines.md
index 2e9729532..d01940502 100644
--- a/docs/architecture/iptvnator-ui-guidelines.md
+++ b/docs/architecture/iptvnator-ui-guidelines.md
@@ -189,6 +189,18 @@ scrim after three idle seconds, with a 32px mute toggle in the corner. It
 never starts under `prefers-reduced-motion` or with `saveData`, and stops
 while the hero is off screen or the window is unfocused.
 
+## Back Navigation
+
+Page-level Back lives only in the workspace header's leading slot (see
+[Header Back](./workspace-shell.md#header-back)). A routed page, or the shell
+it renders in, registers it with `registerWorkspaceBack()` instead of drawing
+an arrow, so Back keeps one position and one look on every page and never
+floats over a scroll owner. Without a registration the header falls back to
+browser history while an in-app previous page exists, and shows nothing
+otherwise. An arrow that returns within a menu, dialog or player panel is not
+page navigation and stays in that surface; an error state may repeat the
+header's Back as a labelled recovery button beside its other actions.
+
 ## Electron Drag Regions
 
 Every interactive descendant of a drag region—including buttons, links,
@@ -902,7 +914,10 @@ Prefer removing a control over shrinking everything around it:
 - Counts and subtitles that a neighbouring control already states.
 
 Never drop the only way back to a hidden surface. A collapse toggle that is
-reachable by touch needs its restore affordance to be reachable too.
+reachable by touch needs its restore affordance to be reachable too. For the
+same reason the header's history Back yields to the context drawer toggle,
+and Settings keeps the toggle beside its Back; only a detail page's Back,
+whose list shows the toggle again, takes the toggle's slot.
 
 ## Typography
 
@@ -920,8 +935,10 @@ heavier faces would exceed the initial-bytes ratchet).
 - JetBrains Mono text stays at 500 or lighter, also where it is a fallback
   behind `ui-monospace` (only macOS resolves that). The check enforces this in
   any rule that sets the family, directly or through a variable, or inherits
-  it from an enclosing rule. It cannot see what a mono modifier class inherits
-  from its base rule; set `font-weight: 500` there.
+  it from an enclosing rule. A mixin's family and weights count where it is
+  included, from its own stylesheet module or another one. It cannot see what
+  a mono modifier class inherits from its base rule; set `font-weight: 500`
+  there.
 - Import whole `@fontsource/<family>/<weight>.css` files. The single-script
   files such as `cyrillic-600.css` have no `unicode-range`, so a Cyrillic-only
   face wins the weight match for Latin text in `Roboto, …` stacks and sends it
diff --git a/docs/architecture/performance-journeys.md b/docs/architecture/performance-journeys.md
index 776e5c3dd..25ab024cf 100644
--- a/docs/architecture/performance-journeys.md
+++ b/docs/architecture/performance-journeys.md
@@ -208,7 +208,8 @@ window, and `evidence.idle.domMutations` the mutation records in the whole
 document. The [idle work audit](idle-work-audit-2026-09.md) found Eager
 components re-rendering on every such tick in a dev build; this counter
 measures the ticks in the optimized build, so plan item C6 can show what
-zoneless change detection removes.
+zoneless change detection removes; its checklist is the
+[zoneless migration](zoneless-migration.md).
 
 The window opens when the settle window closes, so startup data still
 landing is not idle work, and it is timed by a renderer `setTimeout`. The
diff --git a/docs/architecture/portal-detail-navigation.md b/docs/architecture/portal-detail-navigation.md
index 4ce2e3f1c..e9aa03a65 100644
--- a/docs/architecture/portal-detail-navigation.md
+++ b/docs/architecture/portal-detail-navigation.md
@@ -23,27 +23,29 @@ do not reach global player shortcuts. Descendant controls retain their native
 keys and Tab order. Entering watch still scrolls to the top; Back and saved
 catalog scroll positions retain the existing navigation contract below.
 
-The shell owns the page's Back action, but the workspace header renders it.
-While `backAvailable()` is true, the shell registers a target with
-`WorkspaceBackNavigationService` (`@iptvnator/portal/shared/data-access`). The
-target, the `WorkspaceBackTarget` contract in `@iptvnator/portal/shared/util`,
-carries a label (the host's `backLabel`, else the translated "Back"), whether
-Escape currently runs it, and `run()`, which emits `backClicked`. The service
-keeps a stack in which the newest registration wins, and each release removes
-only its own target. A loading shell replaced by the loaded one therefore
-cannot clear its successor, whichever is destroyed first. The header shows the target as an `arrow_back`
-icon button in its leading slot (`data-test-id="workspace-header-back"`), to
-the right of the macOS traffic lights. That is where desktop apps and Material's
-top app bar keep navigation. The header never scrolls, so the control stays
-visible over long episode lists, and nothing floats over the scroll owner:
-detail columns keep symmetric insets and their full width. The button has
-Electron `no-drag` hit testing. In browse its tooltip and `aria-keyshortcuts`
+The shell owns the page's Back action, but the workspace header renders it
+(the general contract, other pages and the history fallback are in
+[Header Back](./workspace-shell.md#header-back)). While `backAvailable()` is
+true, the shell registers a target through `registerWorkspaceBack()`
+(`@iptvnator/portal/shared/data-access`). It carries the host's `backLabel`
+(else the translated "Back"), whether Escape currently runs it, and `run()`,
+which emits `backClicked`. The newest registration wins and each release
+removes only its own target, so a loading shell replaced by the loaded one
+cannot clear its successor, whichever is destroyed first. The header shows the
+target as an `arrow_back` icon button in its leading slot
+(`data-test-id="workspace-header-back"`), to the right of the macOS traffic
+lights. That is where desktop apps and Material's top app bar keep navigation.
+The header never scrolls, so the control stays visible over long episode
+lists, and nothing floats over the scroll owner: detail columns keep symmetric
+insets and their full width. In browse its tooltip and `aria-keyshortcuts`
 advertise Escape, and an Escape pressed on the focused button runs Back
 itself, because the shell's browse Escape requires focus inside the page. At
 ≤640 px Back takes the context drawer toggle's slot (one navigation icon); the
-list it returns to shows the toggle again. This replaced #1763's 72 px lane
-reserved beside a sticky in-page arrow, along with its phone bar. Electron E2E
-`detail-header-back.e2e.ts` covers 1280, 780 and 375 px in browse and watch.
+list it returns to shows the toggle again, and there the history fallback
+yields to it. This replaced #1763's 72 px lane reserved beside a sticky
+in-page arrow, along with its phone bar. Electron E2E
+`detail-header-back.e2e.ts` covers 1280, 780 and 375 px in browse and watch,
+and the history fallback on the list Back returns to.
 
 The header Back is route-level in both states: it emits `backClicked`
 whether or not inline playback is active, so the arrow keeps one meaning and
@@ -67,8 +69,13 @@ keep working on the page.
 Hosts without browse navigation set `backAvailable=false`: M3U uses its channel
 sidebar, and collection bootstrap placeholders have no return handler. They
 register no header Back in either state and have no browse Escape action; their
-watch exits are the bar's Close player button and Escape. Loading/error shells
-with a return handler keep Back available.
+watch exits are the bar's Close player button and Escape. The header may still
+show the history fallback there (a generic Back to the previous page, without
+Escape) when the page was reached by in-app navigation. Loading/error shells
+with a return handler keep Back available. The downloads offline and recording
+error states additionally keep a labelled "Back to Downloads" button beside
+Retry or Remove: it is the error state's recovery action and runs the same
+handler as the header Back.
 
 ## Summary
 
diff --git a/docs/architecture/release-pipeline.md b/docs/architecture/release-pipeline.md
index a9177677a..685d74e1b 100644
--- a/docs/architecture/release-pipeline.md
+++ b/docs/architecture/release-pipeline.md
@@ -168,7 +168,11 @@ into `apps/website/public/blog/guides/screenshots/` instead of a release folder
 guard a release shot does; the add-playlist dialog shots fill the form with the
 mock's fictional `marketing` credentials and use a labeled hand-out for the
 Auto-detect method rather than a `get.php?username=…` link, because G4 rejects
-any URL carrying query credentials. Shots that walk into a Stalker portal
+any URL carrying query credentials. The Xtream shot clicks **Test HTTPS and
+HTTP** against the plain-`http://` mock, so no HTTPS probe is made, and fails
+the run unless the status line reports an active portal; the mock does not
+check passwords, so that verdict proves the scenario answered, not that the
+password is right. Shots that walk into a Stalker portal
 (`open-stalker-live`) make the run start the stalker-mock-server on port 3210
 and seed its `marketing-demo` portal as a third source, which is why they are
 never part of a release run. That scenario's MAC, `00:1A:79:00:00:07`, is the
diff --git a/docs/architecture/stalker-mock-server.md b/docs/architecture/stalker-mock-server.md
index 93cd022ef..bd17dd53b 100644
--- a/docs/architecture/stalker-mock-server.md
+++ b/docs/architecture/stalker-mock-server.md
@@ -408,7 +408,8 @@ file running in parallel workers, so isolation is per-MAC rather than global:
   else is talking to the server — a spec that used it would wipe a sibling
   spec's session mid-test.
 - `apps/web-e2e/src/stalker.e2e.ts` declares its shared scenario MACs in
-  `OWNED_MACS` and clears them in one batched request. The sibling specs that
+  `OWNED_MACS` (the constants live in `stalker-portal.fixture.ts`) and clears
+  them in one batched request. The sibling specs that
   reach this server (`self-hosted.e2e.ts`, the `sources-pwa` helpers) own a
   disjoint `00:1A:79:5F:*` range, so neither file can clear the other's state.
 - Within each browser project, tests deliberately share content-scenario MACs
diff --git a/docs/architecture/stalker-portal.md b/docs/architecture/stalker-portal.md
index d39c1f61b..8d0520070 100644
--- a/docs/architecture/stalker-portal.md
+++ b/docs/architecture/stalker-portal.md
@@ -484,7 +484,8 @@ the format at all, so a large share of working installations use a non-Infomir
 MAC. Refusing one would stop those users adding or editing a portal that works
 for them. The mock encodes the same split (`enforceMacFormat` is set only on
 the strict endpoint; `/portal.php` ignores it), and `AUTH_REJECTED_MAC` in
-`stalker.e2e.ts` depends on it — a non-Infomir MAC that must reach the strict
+`stalker-portal.fixture.ts` (used by `stalker.e2e.ts`) depends on it — a
+non-Infomir MAC that must reach the strict
 endpoint and be refused _there_, not in the form.
 
 In the edit dialog **both** passes — blur and submit — normalize only a MAC the
@@ -1558,6 +1559,69 @@ Core decision logic and normalization are centralized in:
 - `libs/portal/stalker/data-access/src/lib/stalker-vod.utils.ts`
 - `libs/portal/stalker/data-access/src/lib/models/*.ts`
 
+## Forced External Launches
+
+"Open in external player" needs a `create_link` round trip before it reaches
+MPV/VLC. The shared rules are in
+[Forced External Launches From Detail Pages](./embedded-inline-playback.md#forced-external-launches-from-detail-pages);
+the Stalker keys and queues are:
+
+Series (`StalkerSeriesViewComponent`, `stalker-series-launch-queue.ts`):
+
+- Pending starts and the launch queue's held choices are keyed by
+  `playlist:series` (`currentSeriesKey`). The view is reused across series
+  and provider ids collide across playlists, so one series settling never
+  drops what another holds.
+- A start is pending for its series from the click until it settles. A forced
+  launch stays pending through the close of the previous player, the launch
+  and the release of a held choice. The pending flag disables the hero button
+  and the menu's external-player and watched rows.
+- Before launching, an episode of the same series still running externally is
+  closed (`replaceOwnedExternalSession`). The request is rechecked after that
+  close and after the launch IPC; a superseded launch closes the session it
+  opened.
+- An episode chosen while a forced launch of its series is mid-flight is held
+  (`StalkerSeriesLaunchQueue.hold`); the latest choice per series wins. On
+  release it is dropped when the series is no longer shown. Otherwise
+  `replacePlayer` closes what the launch opened before the choice starts, and
+  an unconfirmed close drops the choice.
+- An episode chosen while a watched or reset batch runs is held in one slot
+  tagged with its series; the last choice wins. When the batch settles it
+  goes through the usual gates only if that series is still shown: episode
+  identities overlap across series.
+
+Movies (`createStalkerVodDetailActions`, used by the catalog detail, the
+collection detail and search):
+
+- A repeat for the same `playlist:movie` while its launch is in flight is
+  ignored, also after leaving the movie and returning to it. Launches of
+  other movies are not held back.
+- The launch joins the host's starts (`beginPendingStart`): it supersedes an
+  earlier start, is dropped once a later one begins, and keeps Play, Start
+  over, the watched toggle and the menu rows disabled until it settles.
+- The resolved stream is discarded when the movie is no longer selected or a
+  newer start took over. Movie and series ids collide, so the catalog and
+  collection details include the content type in the selection check; in
+  search, a switch to a series changes the playback owner instead, which
+  supersedes the launch. Otherwise the movie's own external
+  session is replaced, the host's `beforeExternalLaunch` hook runs (the
+  catalog and collection details close their inline player there), and the
+  launch is sent. A launch that resolves after either condition changed
+  closes the session it opened; one that fails by then is not reported.
+- "Reset progress" counts as a pending start of the movie until the write
+  lands, so a start made meanwhile cannot resume from the row being cleared.
+- The pending start is owner-scoped (`createPendingPlaybackStart`). Each host
+  retires it when the selection leaves the owner; that clears the pending
+  flag, not the repeat guard of a launch still in flight.
+
+Regression coverage: `stalker-series-launch-queue.spec.ts`,
+`stalker-series-view.component.spec.ts`,
+`stalker-series-view.season-watch.spec.ts`,
+`stalker-vod-detail-actions.spec.ts`,
+`stalker-vod-playback-controller.spec.ts` and, in
+`libs/portal/shared/util/src/lib/`, `pending-playback-start.spec.ts` and
+`replace-owned-external-session.spec.ts`.
+
 ## Favorites and Recently Viewed
 
 Current implementation is shared via Stalker-specific helpers:
diff --git a/docs/architecture/tmdb-roadmap.md b/docs/architecture/tmdb-roadmap.md
index 67adfa664..64b429ad1 100644
--- a/docs/architecture/tmdb-roadmap.md
+++ b/docs/architecture/tmdb-roadmap.md
@@ -257,7 +257,7 @@ Zero i18n keys. Zero UI change.
 - populated in all three of `mergeVodInfoWithTmdb` (`:168`), `mergeSerieInfoWithTmdb` (`:215`), `mergeStalkerInfoWithTmdb` (`:257`)
 - through `NormalizedVodMeta` (`libs/shared/interfaces/src/lib/vod-details-item.interface.ts`) + **both** normalizers in `vod-details-adapters.ts` — the single convergence point where Xtream and Stalker meet
 
-**Component.** New standalone `app-tmdb-extras-shelf` in `libs/ui/shared-portals`. It must **not** go inline: `libs/ui/playback/src/lib/vod-details/vod-details.component.ts` is **388 lines and is NOT in `tools/eslint/max-lines-baseline.mjs`** — roughly 12 lines of headroom against the hard 400 lint cap.
+**Component.** New standalone `app-tmdb-extras-shelf` in `libs/ui/shared-portals`. It must **not** go inline: `libs/ui/playback/src/lib/vod-details/vod-details.component.ts` is **NOT in `tools/eslint/max-lines-baseline.mjs`** and stays under the hard 400 lint cap only because its state lives in sibling helpers (about 340 counted lines today).
 
 **Render** into the `detail-extras` projection slot at **four** sites (`vod-details.component.html:225`, `serial-details.component.html:201`, `vod-details-route.component.html:247`, `stalker-series-view.component.html:202`) — note Xtream `serial-details` has no trailer block today, so it either gains one or the shelf lands inconsistently. Reuse the existing nocookie iframe + `| safe` pipe so the Electron Referer shim keeps working; clicking swaps the embed `src` rather than opening a new player. Cards use `https://img.youtube.com/vi/{key}/hqdefault.jpg` (CSP verified: `img-src` covers it, `frame-src https://www.youtube-nocookie.com` covers the embed). `@if (extras().length > 1)` … `@else` the existing single-trailer markup **verbatim**.
 
diff --git a/docs/architecture/vod-multi-source.md b/docs/architecture/vod-multi-source.md
index ebd6e1cd2..11c13119b 100644
--- a/docs/architecture/vod-multi-source.md
+++ b/docs/architecture/vod-multi-source.md
@@ -757,6 +757,32 @@ lookup comes back empty, because "never watched" is an answer: the button must
 read Play, not `Resume 42:18` on a stream that starts at zero. A pin on the
 route's own row changes nothing; the loaded position already IS that copy's.
 
+## Menu launch and reset follow the primary button
+
+The "…" menu acts on the copy the primary button acts on. The shared launch
+rules are in
+[Forced External Launches From Detail Pages](./embedded-inline-playback.md#forced-external-launches-from-detail-pages).
+
+- "Open in external player" and "Start over" are host-owned
+  (`VodDetailsMenuBindings.openExternal` / `restart`); the menu service never
+  builds a playback itself. The route forces MPV/VLC for the pinned copy from
+  that copy's own resume point (`playPinnedSource` with `player` and
+  `replacePlaying`), also while that copy already plays: it is relaunched,
+  never swapped for the route copy. Only an `unavailable` pin falls through
+  to the route copy's Resume or Play.
+- "Reset progress" clears the row of `primaryTarget`: the pinned copy's own
+  row, otherwise the route copy's.
+- Resets in flight are a list of targets
+  (`VodDetailsPlaybackService.pendingResets`, `vod-details-reset-target.ts`),
+  not one flag: the reused page can show another movie and come back, and
+  resets of one copy can overlap, so each reset removes only its own entry.
+- A start is refused (`startResolvedPlayback`) while a launch this page made
+  has not settled or the list holds the copy the page currently acts on
+  (`resetTarget`). `startBlocked` disables Play, Start over and the menu
+  launch on those conditions and while a matched session is still
+  `launching`; the menu rows are also held while a start is pending. A reset
+  still writing for another copy does not block it.
+
 ## Provider codec metadata
 
 `info.video` / `info.audio` come back in two shapes: the declared string array
diff --git a/docs/architecture/workspace-dashboard.md b/docs/architecture/workspace-dashboard.md
index 692771f36..96caaf115 100644
--- a/docs/architecture/workspace-dashboard.md
+++ b/docs/architecture/workspace-dashboard.md
@@ -137,7 +137,33 @@ edges (no second, sharp copy); a live channel's logo sits on the right as key
 art over its own wash. Series titles drop their season marker
 (`splitSeasonSuffix`) — the `S1·E1` chip names the season. Chips are
 `app-meta-chip`; the primary is the details pages' light primary
-(`light-primary-button` from `libs/ui/styles`).
+(`light-primary-button` from `libs/ui/styles`). With no artwork at all the
+stage is a gradient in the title's hue (`--hero-hue`), light in the light
+theme and near-black in the dark one; a dark gradient under the light
+theme's page-coloured scrim read as a grey slab behind dark text.
+
+Legibility: slide text stays at 4.5:1 or more over any artwork. The side
+scrim holds 88% of the page colour up to the slide's right edge
+(`--hero-text-edge`: the inset plus `min(560px, 55%)`, the slide's own
+`max-width`) before it opens onto the art. In the narrow layout (`dashboard`
+container ≤ 720px) the slide spans the width, so a full-bleed scrim sits
+behind the text block (90%, fading in just above the eyebrow), the copy gets
+a scrim-coloured text shadow, and the slide enters without a fade so that
+scrim never flashes the art on a rotation. Body text is 85% of the heading
+colour; the rating chip uses `--app-rating-color`, set per theme in
+`m3-theme.scss`. Buttons end long labels in an ellipsis.
+`dashboard-hero-legibility.e2e.ts` replaces every image with a black-and-white
+checkerboard and measures each piece of slide text from the screen in both
+themes, at a wide and a narrow width, for a backdrop, a blurred-poster, a
+no-artwork and a live slide.
+
+Semantics: the page has one stable, visually hidden `h1` ("Dashboard",
+`dashboard-page-heading`); each slide title is an `h2`, like the rail titles.
+Slide changes are announced by one polite live region
+(`dashboard-hero-announcement`, position and title) that lives outside the
+re-created slide and is silent while the slides rotate on their own. A
+slide's progress bar is named after its title (a live slide: the programme)
+and a title's reads "N% watched". The dots are 24px targets (WCAG 2.5.8).
 
 Rotation is the active dot's CSS fill animation (8 s); its `animationend`
 advances. The fill animates `transform` only (a bar sliding in under the
diff --git a/docs/architecture/workspace-shell.md b/docs/architecture/workspace-shell.md
index bf70c49cf..44f4d2771 100644
--- a/docs/architecture/workspace-shell.md
+++ b/docs/architecture/workspace-shell.md
@@ -93,10 +93,9 @@ The shell is intentionally split into four persistent regions:
     4. No brand mark: it only repeated the first workspace link (Dashboard,
        or Sources when the dashboard is off).
 2. Top header:
-    1. Leading Back slot, shown while the current page registers a target
-       with `WorkspaceBackNavigationService` (detail pages today). At
-       ≤640 px it takes the context drawer toggle's place. See
-       [Portal Detail Navigation](./portal-detail-navigation.md).
+    1. Leading Back slot: the current page's registered Back, else browser
+       history while an in-app previous page exists, else nothing. See
+       [Header Back](#header-back).
     2. Playlist switcher.
     3. Route-aware search input and command palette trigger.
     4. Add source action.
@@ -130,6 +129,71 @@ When adding shell behavior, prefer placing it in the service that owns the
 nearest existing state. Keep `WorkspaceShellFacade` as a stable re-export layer
 for the template unless the template contract itself intentionally changes.
 
+## Header Back
+
+The header's leading slot is the workspace's one page-level Back. Pages do not
+render an arrow of their own: they register a `WorkspaceBackTarget`
+(`@iptvnator/portal/shared/util`) with `WorkspaceBackNavigationService`
+(`@iptvnator/portal/shared/data-access`), normally through
+`registerWorkspaceBack()`, which registers for the calling component's
+lifetime while its optional `available` predicate holds. The newest
+registration wins, and each release removes only its own target. The button
+(`data-test-id="workspace-header-back"`) sits beside the macOS traffic lights,
+never scrolls, and has Electron `no-drag` hit testing. A target supplies its
+label (else the translated "Back"), whether Escape on the page runs it, and
+`run()`.
+
+| Page | Registered by | Back runs | ≤640 px |
+| --- | --- | --- | --- |
+| Portal, collection, offline and recording details | `PortalDetailShellComponent` while `backAvailable()` | the host's `backClicked` | replaces the drawer toggle |
+| Xtream and Stalker Discover and actor pages | `DiscoverViewComponent`, `ActorViewComponent` | the route's `Location.back()` | (no drawer) |
+| In-portal search, Xtream and Stalker | `SearchLayoutComponent` while `backAvailable()` and no inline detail replaces the results | `Location.back()` | (no drawer) |
+| Settings | `WorkspaceSettingsContextPanelComponent`, which exists exactly while the settings route shows | `Location.back()` | beside the drawer toggle |
+
+Detail-page semantics (Escape, browse and watch) are in
+[Portal Detail Navigation](./portal-detail-navigation.md#detail-scroll-and-focus).
+
+**History fallback.** Without a registration, the header shows Back while the
+previous history entry is an in-app one, and runs `Location.back()`. The
+service reads that from the Navigation API: the previous entry must be
+same-document (`NavigationHistoryEntry.sameDocument`), so the router pushed it
+after this document loaded. Entries from before a reload or from another page
+of the origin never count, and the fallback can neither leave nor reload the
+app. `currententrychange` keeps it current through pushes, replacements,
+traversals and guard-cancelled Back navigations that the router rewrites.
+Without the Navigation API (older Safari and Firefox, jsdom) there is no
+fallback; registered pages are unaffected. The fallback reads "Back" and
+advertises no Escape, because no page handles one for it. Pages that set
+`backAvailable=false`, such as M3U details, therefore show it too when they
+were reached by navigation.
+
+When there is nowhere to go, the slot is empty rather than a disabled arrow.
+Sessions often start on a page that never navigates (an M3U playlist or live
+TV), where a disabled arrow would stay for the whole session. The cost is one
+shift of the switcher and search when Back first appears or leaves, which
+happens only at the start of the history and together with a route change.
+There is no Forward button: Stalker inline details are store state, not
+history entries, so Forward would skip them.
+
+**Phone width.** `phoneDrawerToggle` sets how Back shares the leading slot with
+the context drawer toggle. `replace` (the default) takes the toggle's slot: a
+detail page's drawer belongs to the list that Back returns to. `beside` keeps
+both: the settings drawer holds the page's own sections. `yield` hides Back
+while the toggle shows: the history fallback must not cost a category list its
+only way into the drawer, and two navigation icons do not fit beside the
+switcher. System and browser Back still work there.
+
+**Left in place.** These controls stay inside their surface on purpose:
+
+1. Downloads offline and recording detail error states keep their labelled
+   "Back to Downloads" button beside Retry or Remove. It is the error state's
+   recovery action, not page chrome; the header shows the same Back.
+2. Back controls internal to a surface, which leave a panel rather than the
+   page: the Embedded MPV dock panel and the alternative-sources panel inside
+   the VOD "…" menu.
+3. The M3U player sidebar's Home button, which renders only outside the
+   workspace shell.
+
 ## Context Panel Rules
 
 The shell decides which secondary panel to show from the current route:
@@ -326,7 +390,15 @@ The Electron window hides the native title bar on all desktop platforms
 (`titleBarStyle: 'hidden'` in `apps/electron-backend/src/app/app.ts`):
 
 1. macOS keeps the native traffic lights (`titleBarOverlay: true`,
-   `trafficLightPosition`); the renderer draws no window buttons.
+   `trafficLightPosition`); the renderer draws no window buttons. The lights
+   sit in the 56 px header band above the rail, so the macOS rail
+   (`.app-rail.is-macos`) starts its first link at 56 px: level with the
+   content area and the dashboard hero, with its hover surface clear of the
+   lights. App zoom scales CSS pixels but not the lights, so the rail
+   publishes the page zoom factor (`outerWidth / innerWidth`, refreshed on
+   `resize`) as `--rail-zoom-factor` and keeps at least 48 window pixels when
+   zoomed out. `window-controls.e2e.ts` checks the alignment and the gap at
+   default and minimum zoom on macOS.
 2. Windows and Linux use renderer-drawn window controls
    (`app-window-controls`, `libs/ui/components/src/lib/window-controls/`).
    `frame` is intentionally left untouched so native resize borders and
diff --git a/docs/architecture/xtream-portal-compatibility.md b/docs/architecture/xtream-portal-compatibility.md
index 6545321e0..bf3fb37da 100644
--- a/docs/architecture/xtream-portal-compatibility.md
+++ b/docs/architecture/xtream-portal-compatibility.md
@@ -405,3 +405,40 @@ deduplicated list, `hasMoreContent` derives from accumulated length vs
 and the facade maps page 0 to the skeleton and later pages to the tail
 spinner. These catalog/search surfaces use incremental loading instead of
 page buttons.
+
+## Forced external launches from detail pages
+
+The "…" menu's MPV/VLC launch follows the shared rules in
+[Forced External Launches From Detail Pages](./embedded-inline-playback.md#forced-external-launches-from-detail-pages).
+The movie page's pin and reset rules are in
+[VOD Multi-Source](./vod-multi-source.md#menu-launch-and-reset-follow-the-primary-button).
+
+The series page keeps its launch state at module level in
+`serial-details-external-launch.ts`, so it outlives a recreated page:
+
+- The owner is `playlist:series` (`launchOwner()`). It changes when the page
+  shows another series and is null once the page is gone.
+- Forced launches of one owner run on one chain. A later launch waits for the
+  earlier one to settle, closes the owner's running episode session and then
+  launches. Each step rechecks the owner, and a launch that resolves after the
+  page left the owner closes the session it opened.
+- The duplicate guard is keyed by page token plus episode. The token
+  (`pageToken()`) is owner, page instance and visit, so a launch left behind
+  by an earlier visit of the same series does not swallow a launch from the
+  reopened page; that launch queues on the owner's chain.
+- While a forced launch of the owner is pending (`forcedLaunchPending`), a
+  start that does not force a player is queued instead of started. One choice
+  is kept per owner, the latest wins, and it carries the host and `start` of
+  the page that made it. Once the chain settles, the player the launch opened
+  is closed first while the owner stays pending. The choice is dropped when
+  that page no longer shows the owner or the close was not confirmed.
+- The pending flag also disables the menu's external-player row and the
+  season and series watched actions, and counts as active playback for "Reset
+  progress".
+- The launch-position marker and a launch-failure message apply only while
+  the page token is unchanged.
+
+Regression coverage: `serial-details-external-launch.spec.ts` (chain,
+duplicate guard, queued choice), `serial-details-playback.service.spec.ts`
+(page token) and, for the external-player and reset rows,
+`libs/ui/components/src/lib/detail-ui/series-hero.state.spec.ts`.
diff --git a/docs/architecture/zoneless-migration.md b/docs/architecture/zoneless-migration.md
new file mode 100644
index 000000000..84fdb1ede
--- /dev/null
+++ b/docs/architecture/zoneless-migration.md
@@ -0,0 +1,257 @@
+# Zoneless change-detection migration
+
+Working checklist for plan item C6 of the performance journeys plan: move the
+renderer (`apps/web`) from zone.js to `provideZonelessChangeDetection()`.
+The win is measured with the change-detection tick counters described in
+[performance journeys](performance-journeys.md#change-detection-ticks); the
+[idle work audit](idle-work-audit-2026-09.md) found the Eager roots that
+re-render on every tick. Update this file in the same PR that converts an item.
+
+The inventory was taken on `e8b181fce` (2026-10-04, Angular 22.1.6). Run
+`pnpm nx run electron-backend-e2e:test-performance-harness` after editing the
+Eager list: `zoneless-migration.spec.ts` fails when the list and the code
+disagree, so a new Eager component cannot land unnoticed and a converted one
+must be ticked here.
+
+## Starting point
+
+- **OnPush is already the default.** Since Angular 22 an unset
+  `changeDetection` means OnPush, and the old `Default` strategy is spelled
+  `ChangeDetectionStrategy.Eager`. Only components that set `Eager` are
+  checked on every tick. `ChangeDetectionStrategy.Default` is not used.
+- **Renderer bootstrap.** `apps/web/src/app/app.config.ts` provides
+  `provideZoneChangeDetection({ eventCoalescing: true })` and
+  `apps/web/project.json` builds with `"polyfills": ["zone.js"]`.
+  `apps/remote-control-web` does the same; it is a separate app and outside
+  this migration unless a step says otherwise.
+- **Unit tests already run zoneless.** Every `src/test-setup.ts` (apps/web,
+  apps/remote-control-web and 24 libs) calls `setupZonelessTestEnv` and loads
+  `zone.js`/`zone.js/testing` only for `fakeAsync` and `waitForAsync`. A
+  component that passes its specs is therefore not proof of zone-free
+  production behavior when the spec calls `fixture.detectChanges()` itself.
+- **IPC callbacks never ran in the Angular zone.** `window.electron.on*`
+  listeners arrive through `contextBridge` and are not zone-patched, so every
+  one that works today already writes signals or calls `NgZone.run`.
+- **Counters before the migration** (macOS, from
+  [performance journeys](performance-journeys.md#change-detection-ticks)):
+  `renderer.cdTicksToFirstCard` 20–21 (the one-tick zone.js race),
+  `renderer.cdTicksIdle30s` 3, `renderer.cdTicksToFirstPage` 22;
+  `renderer.cdTicksToPlaying` has no recorded run yet.
+
+## PR sequence
+
+1. [ ] Keep `@ngrx/store-devtools` out of production bundles (#1810, open). Not a
+   zone change; it lowered `renderer.initialBytes` before the migration
+   starts moving it.
+2. [x] This inventory and its guard spec.
+3. [ ] Per-project PRs, in this order, each converting the project's Eager
+   components and fixing its zone-dependent sites while zone.js stays on:
+   `libs/ui/*`, `libs/workspace/*`, `libs/playlist/*`, `libs/portal/*`,
+   playback (`libs/ui/playback`, `libs/playlist/m3u/feature-player`),
+   `apps/web`. Each reports the tick counters before and after and runs the
+   affected unit and E2E tests.
+4. [ ] `provideZonelessChangeDetection()` behind a build-time
+   `fileReplacements` flag, off by default; all four journeys and the
+   Electron E2E suite run with it on.
+5. [ ] Flag on by default, `zone.js` out of `polyfills`, new tick baselines
+   (`renderer.cdTicksIdle30s` and any counter that becomes deterministic once
+   the zone.js race is gone).
+
+## Eager components
+
+66 production files, 67 components (`epg-progress-panel.component.ts` holds
+two). Tick an entry by deleting `changeDetection: ChangeDetectionStrategy.Eager`
+(or setting OnPush) once its template state is signals, signal inputs or
+explicitly marked. The guard spec compares the unticked entries with the
+files that still contain `ChangeDetectionStrategy.Eager`.
+
+### apps/web (15)
+
+- [ ] `apps/web/src/app/app.component.ts` (idle audit root)
+- [ ] `apps/web/src/app/app-update-notification-panel.component.ts` (idle audit root)
+- [ ] `apps/web/src/app/settings/app-update-release-notes-dialog.component.ts`
+- [ ] `apps/web/src/app/settings/settings.component.ts`
+- [ ] `apps/web/src/app/settings/settings-about-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-backup-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-dashboard-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-delete-all-playlists-dialog.component.ts`
+- [ ] `apps/web/src/app/settings/settings-epg-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-general-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-playback-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-remote-control-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-reset-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-tmdb-section.component.ts`
+- [ ] `apps/web/src/app/settings/settings-unsaved-changes-dialog.component.ts`
+
+### libs/ui (20 files, 21 components)
+
+- [x] `libs/ui/components/src/lib/confirm-dialog/confirm-dialog.component.ts`
+- [x] `libs/ui/components/src/lib/content-hero/content-hero.component.ts`
+- [x] `libs/ui/components/src/lib/expandable-text/expandable-text.component.ts`
+- [x] `libs/ui/components/src/lib/portal-detail-shell/content-about.component.ts`
+- [x] `libs/ui/components/src/lib/portal-detail-shell/portal-detail-shell.component.ts`
+- [x] `libs/ui/components/src/lib/progress-capsule/progress-capsule.component.ts`
+- [x] `libs/ui/components/src/lib/season-container/episode-info-dialog.component.ts`
+- [x] `libs/ui/components/src/lib/watched-badge/watched-badge.component.ts`
+- [x] `libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.ts`
+- [x] `libs/ui/epg/src/lib/epg-progress-panel/epg-progress-panel.component.ts` (idle audit root; also `EpgTrustConfirmDialogComponent`)
+- [x] `libs/ui/epg/src/lib/epg-source-status/epg-source-status.component.ts`
+- [ ] `libs/ui/remote-control/src/lib/remote-control/remote-control.component.ts` (`apps/remote-control-web` only)
+- [ ] `libs/ui/playback/src/lib/art-player/art-player.component.ts`
+- [ ] `libs/ui/playback/src/lib/audio-player/audio-player.component.ts`
+- [ ] `libs/ui/playback/src/lib/external-player-info-dialog/external-player-info-dialog.component.ts`
+- [ ] `libs/ui/playback/src/lib/html-video-player/html-video-player.component.ts`
+- [ ] `libs/ui/playback/src/lib/video-player/sidebar/sidebar.component.ts`
+- [ ] `libs/ui/playback/src/lib/vjs-player/vjs-player.component.ts`
+- [ ] `libs/ui/playback/src/lib/vod-details/vod-details.component.ts`
+- [ ] `libs/ui/playback/src/lib/web-player-view/web-player-view.component.ts`
+
+`libs/ui/playback` (8) goes with the playback PR, not the `libs/ui` one.
+
+### apps/remote-control-web (1)
+
+- [ ] `apps/remote-control-web/src/app/app.ts` (separate app; converts with `remote-control.component.ts`)
+
+### libs/workspace (7)
+
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-command-palette/workspace-command-palette.component.ts`
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-collection-context-panel.component.ts`
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.ts`
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.ts`
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts-dialog.component.ts`
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-shell/workspace-shell.component.ts` (idle audit root)
+- [ ] `libs/workspace/shell/feature/src/lib/workspace-sources/workspace-sources.component.ts`
+
+### libs/playlist (14)
+
+- [ ] `libs/playlist/import/feature/src/lib/add-playlist-dialog/add-playlist-dialog.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/auto-import/auto-import.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/file-upload/file-upload.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/stalker-portal-import/stalker-portal-import.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/text-import/text-import.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/url-upload/url-upload.component.ts`
+- [ ] `libs/playlist/import/feature/src/lib/xtream-code-import/xtream-code-import.component.ts`
+- [ ] `libs/playlist/m3u/feature-player/src/lib/m3u-vod-detail/m3u-vod-detail.component.ts`
+- [ ] `libs/playlist/m3u/feature-player/src/lib/video-player/video-player.component.ts`
+- [ ] `libs/playlist/shared/ui/src/lib/recent-playlists/empty-state/empty-state.component.ts`
+- [ ] `libs/playlist/shared/ui/src/lib/recent-playlists/playlist-info/playlist-info.component.ts`
+- [ ] `libs/playlist/shared/ui/src/lib/recent-playlists/playlist-item/playlist-item.component.ts`
+- [ ] `libs/playlist/shared/ui/src/lib/source-health/source-cleanup-dialog.component.ts`
+- [ ] `libs/playlist/shared/ui/src/lib/source-health/source-health-indicator.component.ts`
+
+`libs/playlist/m3u/feature-player` (2) goes with the playback PR.
+
+### libs/portal (9)
+
+- [ ] `libs/portal/shared/ui/src/lib/components/favorites-layout/favorites-layout.component.ts`
+- [ ] `libs/portal/shared/ui/src/lib/components/playlist-error-view/playlist-error-view.component.ts`
+- [ ] `libs/portal/shared/ui/src/lib/components/search-form/search-form.component.ts`
+- [ ] `libs/portal/shared/ui/src/lib/navigation/portal-rail-links.component.ts`
+- [ ] `libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-detail.component.ts`
+- [ ] `libs/portal/stalker/feature/src/lib/stalker-favorites-button/stalker-favorites-button.component.ts`
+- [ ] `libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.ts`
+- [ ] `libs/portal/xtream/feature/src/lib/global-search-results/global-search-results.component.ts`
+- [ ] `libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.ts`
+
+Test-only files that set Eager are not listed; they do not ship. The guard
+skips every `*.spec.ts` / `*.test.ts` file with or without a suffix of one
+or more segments (`*.spec-stubs.ts`, `*.test-helpers.ts`,
+`*.test-data-stubs.ts`, …),
+`test-setup.ts` and `test-stubs/` directories.
+
+## Zone-dependent sites
+
+Plain (non-signal) fields read by a template and written from a callback
+that is not an Angular template event. Under zone.js the next tick happens to
+refresh an Eager view; under zoneless nothing schedules one. Each fix makes
+the field a signal (or a `computed`), or writes it through one.
+
+| Done | Site | What depends on the zone | Owning PR |
+| --- | --- | --- | --- |
+| [ ] | `libs/playlist/m3u/feature-player/src/lib/video-player/video-player.component.ts` `onChannelNumberInput`/`clearChannelNumberInput` | 2 s `window.setTimeout` hides the channel-number overlay through plain `showChannelNumberOverlay`/`channelNumberInput` | playback |
+| [ ] | same file, `applySettings` and the settings `effect()` | IndexedDB `storage.get(...).subscribe` and an effect assign plain `playerSettings`, which picks the player in the template | playback |
+| [ ] | `libs/playlist/shared/ui/src/lib/recent-playlists/playlist-item/playlist-item.component.ts` `checkPortalStatus` | plain `portalStatus` assigned after `await` in `ngOnInit` (PWA only: skipped when source health is supported) | playlist |
+| [ ] | `libs/playlist/shared/ui/src/lib/recent-playlists/playlist-info/playlist-info.component.ts` (EPG clear and EPG file pick handlers) | plain `playlist` reassigned after `await` | playlist |
+| [ ] | `libs/playlist/import/feature/src/lib/stalker-portal-import/stalker-portal-import.component.ts` (device-id derivation) | `form.patchValue` after `await`; template getters read `control.value`, which is not signal-backed | playlist |
+| [ ] | `libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.ts` (favorites load) | `favorites` Map filled in a `subscribe` without `markForCheck`; the component is OnPush already, so this is a latent bug today | portal |
+| [ ] | `libs/portal/xtream/feature/src/lib/portal-channels-list/portal-channels-list.component.ts` (favorites load) | same pattern; the neighbouring `favoriteMarks.changes$` handler does call `markForCheck` | portal |
+| [ ] | same file, programme dialog `afterClosed` | deletes from `epgPrograms`/`currentProgramsProgress` after `await` without marking | portal |
+| [ ] | `apps/web/src/app/settings/settings-backup.facade.ts` (backup import) | `change` listener on a detached file input → `hydrateFromStore()`; section templates read `form().value.theme`/`coverSize` | apps/web |
+| [ ] | `libs/ui/remote-control/src/lib/remote-control/remote-control.component.ts` | plain `isLoading`/`error`/`status` written after `await` and from a 2 s `setInterval` | only if `apps/remote-control-web` goes zoneless |
+
+## Explicit zone and change-detector calls
+
+They keep working under zoneless (`NgZone` becomes `NoopNgZone`, so `run`
+and `runOutsideAngular` just call through). Remove them in the flip PR, not
+before: with zone.js on they still matter.
+
+- [ ] `apps/web/src/app/settings/settings-unload-guard.service.ts`: two
+  `zone.run` calls around the window-close dialog (IPC
+  `onWindowCloseRequested` and `beforeunload`).
+- [ ] `libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.ts`:
+  `runOutsideAngular(() => setInterval(...))` for the position poll;
+  `embedded-mpv-session-controller.position.spec.ts` asserts the call and
+  changes with it.
+- [ ] `libs/workspace/dashboard/data-access/src/lib/dashboard-data.service.ts`:
+  18 `ngZone.run(() => signal.set(...))` calls, all redundant around signal
+  writes.
+- [ ] `libs/workspace/dashboard/data-access/src/lib/dashboard-source-expiry.service.ts`:
+  one `ngZone.run` around a signal update.
+- `ChangeDetectorRef` in `stalker-live-stream-layout.component.ts`
+  (4 × `markForCheck`, 1 × `detectChanges` before measuring a row) and
+  `portal-channels-list.component.ts` (3 × `markForCheck`, 2 ×
+  `detectChanges`): correct under zoneless; replace the Maps with signals in
+  the portal PR if it stays small.
+
+## Checked and signal-safe
+
+No change needed; recorded so the flag PR knows where to look if a journey
+regresses. Embedded MPV and external players are the riskiest paths because
+their events arrive over IPC.
+
+- **IPC listeners** (17 registrations): app update status, external player
+  sessions, window close and window state, player errors, playlist open
+  requests, embedded MPV sessions, playback history gate, downloads,
+  recordings, playlist refresh, DB operation and save progress, EPG progress,
+  playback position updates, channel change and remote-control commands. All
+  write signals, signal stores or NgRx, or have no UI state.
+- **Player libraries** (video.js, mpegts.js, hls.js, artplayer, shaka, native
+  `<video>`): callbacks bump signals in the control adapters or emit outputs
+  whose parent handlers write signals.
+- **Observers** (13 Intersection/Resize/Mutation observers) and **document
+  and window listeners** (~40): signals or DOM only. `@HostListener`
+  bindings are Angular listeners and mark their view.
+- **Timers** (~130 `setTimeout`/`setInterval`/rAF/`queueMicrotask`): all
+  write signals, touch the DOM or focus, or have no UI state, apart from the
+  two in the table above.
+- **Dialogs and snackbars** (20 `afterClosed`/`onAction` sites): signals,
+  stores, outputs or navigation, apart from the one in the table above.
+- No production code uses `NgZone.onStable`, `onMicrotaskEmpty`, `isStable`,
+  `ApplicationRef.tick()`, `Zone.current` or `ngDoCheck`.
+
+## Build, tests and runtime details
+
+- [ ] `provideServiceWorker(..., { registrationStrategy:
+  'registerWhenStable:30000' })`: under zoneless "stable" means no pending
+  tasks. The 30 s bound still registers the worker; check the PWA build in
+  the flag PR.
+- [ ] `change-detection-tick-counter.ts` wraps `ApplicationRef._tick`, which
+  the zoneless scheduler also calls, so the counters stay comparable.
+- [ ] Specs that need zone.js: `fakeAsync` in
+  `playlist-switcher.component.spec.ts` and `stalker-live-navigation.spec.ts`,
+  `waitForAsync` in 13 files. They keep `zone.js/testing` until rewritten;
+  removing zone.js from the build polyfills does not affect them.
+- [ ] Unreferenced leftovers to delete in the flip PR:
+  `apps/web/src/polyfills.ts`, `apps/web/src/polyfills-test.ts`,
+  `apps/web/src/setup-jest.ts` (no project, tsconfig or Jest config uses
+  them).
+
+## Measuring a PR
+
+Build `electron-performance` and run the journeys as described in
+[performance journeys](performance-journeys.md), then paste
+`renderer.cdTicksToFirstCard`, `renderer.cdTicksIdle30s`,
+`renderer.cdTicksToFirstPage` and `renderer.cdTicksToPlaying` before and
+after. While zone.js is on, removing Eager does not change the number of
+ticks, only the work per tick; expect the counters to stay put until the flag
+PR and the template work (DOM mutations, profile time) to drop.
diff --git a/docs/maintenance/agent-context-map.md b/docs/maintenance/agent-context-map.md
index cc49ce265..41b6ba28c 100644
--- a/docs/maintenance/agent-context-map.md
+++ b/docs/maintenance/agent-context-map.md
@@ -15,6 +15,7 @@ are not prerequisites for reading repository contracts.
 | Angular conventions; docs and skills maintenance; local review before a pull request | [Agent workflow](../development/agent-workflow.md) | Use the area's skill below |
 | Unit, E2E, lint and coverage; `tools/coverage`, `tools/typecheck` | [Validation map](../architecture/validation-map.md) | Use the area's validation section |
 | Performance journeys, counters, benchmark probes and the CI ratchet; `apps/electron-backend-e2e/src/journeys`, `apps/electron-backend-e2e/src/performance`, `tools/performance` | [Performance journeys](../architecture/performance-journeys.md) | Read the contract directly |
+| Zoneless change detection, `ChangeDetectionStrategy.Eager` components, `NgZone` usage | [Zoneless migration](../architecture/zoneless-migration.md) | Read the checklist directly |
 | Electron entry/events/preload and CDP; `apps/electron-backend` | [Debugging and trace flags](../development/electron-debugging.md), [Electron security](../architecture/electron-security.md) | Use the available global electron skill for automation |
 | Releases, notes, screenshots, native assets, Linux manager metadata; `tools/release` | [Release pipeline](../architecture/release-pipeline.md), [note format](../../.changes/README.md) | [Release notes](../../.codex/skills/release-notes/SKILL.md), [release cut](../../.codex/skills/release-cut/SKILL.md) |
 
diff --git a/libs/portal/shared/data-access/src/index.ts b/libs/portal/shared/data-access/src/index.ts
index f34f8b9d1..eb5318d98 100644
--- a/libs/portal/shared/data-access/src/index.ts
+++ b/libs/portal/shared/data-access/src/index.ts
@@ -7,4 +7,5 @@ export * from './lib/source-health.service';
 
 export * from './lib/source-cleanup.service';
 
+export * from './lib/register-workspace-back';
 export * from './lib/workspace-back-navigation.service';
diff --git a/libs/portal/shared/data-access/src/lib/register-workspace-back.spec.ts b/libs/portal/shared/data-access/src/lib/register-workspace-back.spec.ts
new file mode 100644
index 000000000..ff0295ca7
--- /dev/null
+++ b/libs/portal/shared/data-access/src/lib/register-workspace-back.spec.ts
@@ -0,0 +1,54 @@
+import { Component, signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { registerWorkspaceBack } from './register-workspace-back';
+import { WorkspaceBackNavigationService } from './workspace-back-navigation.service';
+
+@Component({ template: '' })
+class PageComponent {
+    readonly available = signal(true);
+    readonly run = jest.fn();
+
+    constructor() {
+        registerWorkspaceBack({
+            available: this.available,
+            phoneDrawerToggle: 'beside',
+            run: () => this.run(),
+        });
+    }
+}
+
+describe('registerWorkspaceBack', () => {
+    function setup() {
+        TestBed.resetTestingModule();
+        const fixture = TestBed.createComponent(PageComponent);
+        fixture.detectChanges();
+        const backNavigation = TestBed.inject(WorkspaceBackNavigationService);
+        return { fixture, backNavigation, page: fixture.componentInstance };
+    }
+
+    it('offers a generic Back without Escape that runs the page handler', () => {
+        const { backNavigation, page } = setup();
+        const target = backNavigation.target();
+
+        expect(target?.label()).toBeNull();
+        expect(target?.escapeShortcut()).toBe(false);
+        expect(target?.phoneDrawerToggle).toBe('beside');
+        expect(backNavigation.goBack()).toBe(true);
+        expect(page.run).toHaveBeenCalledTimes(1);
+    });
+
+    it('registers only while available and releases with the page', () => {
+        const { fixture, backNavigation, page } = setup();
+
+        page.available.set(false);
+        TestBed.tick();
+        expect(backNavigation.target()).toBeNull();
+
+        page.available.set(true);
+        TestBed.tick();
+        expect(backNavigation.target()).not.toBeNull();
+
+        fixture.destroy();
+        expect(backNavigation.target()).toBeNull();
+    });
+});
diff --git a/libs/portal/shared/data-access/src/lib/register-workspace-back.ts b/libs/portal/shared/data-access/src/lib/register-workspace-back.ts
new file mode 100644
index 000000000..18c68ea90
--- /dev/null
+++ b/libs/portal/shared/data-access/src/lib/register-workspace-back.ts
@@ -0,0 +1,39 @@
+import { effect, inject, Signal, signal } from '@angular/core';
+import {
+    WorkspaceBackPhoneSlot,
+    WorkspaceBackTarget,
+} from '@iptvnator/portal/shared/util';
+import { WorkspaceBackNavigationService } from './workspace-back-navigation.service';
+
+export interface WorkspaceBackRegistration {
+    /** Registers only while this returns true; always when omitted. */
+    readonly available?: () => boolean;
+    /** Accessible name and tooltip; the generic "Back" when omitted. */
+    readonly label?: Signal<string | null>;
+    /** True while Escape on the page runs the same action; false if omitted. */
+    readonly escapeShortcut?: Signal<boolean>;
+    readonly phoneDrawerToggle?: WorkspaceBackPhoneSlot;
+    run(): void;
+}
+
+/**
+ * Offers a page's Back in the workspace header instead of an arrow of its
+ * own, for as long as the calling component lives and `available` holds.
+ * Must be called in an injection context (a field initializer or the
+ * constructor).
+ */
+export function registerWorkspaceBack(
+    registration: WorkspaceBackRegistration
+): void {
+    const backNavigation = inject(WorkspaceBackNavigationService);
+    const target: WorkspaceBackTarget = {
+        label: registration.label ?? signal(null),
+        escapeShortcut: registration.escapeShortcut ?? signal(false),
+        phoneDrawerToggle: registration.phoneDrawerToggle,
+        run: () => registration.run(),
+    };
+    effect((onCleanup) => {
+        if (registration.available && !registration.available()) return;
+        onCleanup(backNavigation.register(target));
+    });
+}
diff --git a/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.spec.ts b/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.spec.ts
index a229d8e42..168642daf 100644
--- a/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.spec.ts
+++ b/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.spec.ts
@@ -1,11 +1,62 @@
+import { Location } from '@angular/common';
 import { signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 import { WorkspaceBackTarget } from '@iptvnator/portal/shared/util';
-import { WorkspaceBackNavigationService } from './workspace-back-navigation.service';
+import {
+    WORKSPACE_HISTORY_NAVIGATION,
+    WorkspaceBackNavigationService,
+    WorkspaceHistoryNavigation,
+} from './workspace-back-navigation.service';
+
+/** Session history as the Navigation API reports it. */
+class FakeHistory extends EventTarget {
+    private list: { index: number; sameDocument: boolean }[] = [];
+    private current = -1;
+
+    constructor(sameDocument: boolean[] = [true]) {
+        super();
+        sameDocument.forEach((same) => this.push(same, false));
+    }
+
+    get currentEntry() {
+        return this.list[this.current] ?? null;
+    }
+
+    entries() {
+        return this.list;
+    }
+
+    /** A router push; earlier documents' entries are not same-document. */
+    push(sameDocument = true, notify = true): void {
+        this.list = this.list.slice(0, this.current + 1);
+        this.list.push({ index: this.list.length, sameDocument });
+        this.current = this.list.length - 1;
+        if (notify) this.dispatchEvent(new Event('currententrychange'));
+    }
+
+    traverseTo(index: number): void {
+        this.current = index;
+        this.dispatchEvent(new Event('currententrychange'));
+    }
+}
 
 describe('WorkspaceBackNavigationService', () => {
-    function createService(): WorkspaceBackNavigationService {
+    const back = jest.fn();
+
+    function createService(
+        history: FakeHistory | null = null
+    ): WorkspaceBackNavigationService {
+        back.mockReset();
         TestBed.resetTestingModule();
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: Location, useValue: { back } },
+                {
+                    provide: WORKSPACE_HISTORY_NAVIGATION,
+                    useValue: history as unknown as WorkspaceHistoryNavigation,
+                },
+            ],
+        });
         return TestBed.inject(WorkspaceBackNavigationService);
     }
 
@@ -74,4 +125,81 @@ describe('WorkspaceBackNavigationService', () => {
 
         expect(service.target()).toBe(second);
     });
+
+    describe('history fallback', () => {
+        it('shows nothing on the first page of the session', () => {
+            const service = createService(new FakeHistory());
+
+            expect(service.target()).toBeNull();
+            expect(service.goBack()).toBe(false);
+        });
+
+        it('goes back in history once the router pushed a page', () => {
+            const history = new FakeHistory();
+            const service = createService(history);
+
+            history.push();
+            const target = service.target();
+
+            expect(target?.label()).toBeNull();
+            // No page handles Escape, and a list keeps its phone drawer.
+            expect(target?.escapeShortcut()).toBe(false);
+            expect(target?.phoneDrawerToggle).toBe('yield');
+            expect(service.goBack()).toBe(true);
+            expect(back).toHaveBeenCalledTimes(1);
+        });
+
+        it('disappears when Back returns to the first page and returns on Forward', () => {
+            const history = new FakeHistory();
+            const service = createService(history);
+            history.push();
+
+            history.traverseTo(0);
+            expect(service.target()).toBeNull();
+
+            history.traverseTo(1);
+            expect(service.target()).not.toBeNull();
+        });
+
+        it('never leads out of the app or across a reload', () => {
+            // An entry from another page of the origin, or from this app's
+            // document before a reload, belongs to a different document.
+            const service = createService(new FakeHistory([false, true]));
+
+            expect(service.target()).toBeNull();
+        });
+
+        it('yields to a page that registers Back and returns after it goes', () => {
+            const history = new FakeHistory();
+            const service = createService(history);
+            history.push();
+            const fallback = service.target();
+            const page = createTarget();
+
+            const release = service.register(page);
+            expect(service.target()).toBe(page);
+
+            release();
+            expect(service.target()).toBe(fallback);
+        });
+
+        it('is absent without the Navigation API', () => {
+            const service = createService(null);
+
+            expect(service.target()).toBeNull();
+        });
+
+        it('stops listening when the injector is destroyed', () => {
+            const history = new FakeHistory();
+            const remove = jest.spyOn(history, 'removeEventListener');
+            createService(history);
+
+            TestBed.resetTestingModule();
+
+            expect(remove).toHaveBeenCalledWith(
+                'currententrychange',
+                expect.any(Function)
+            );
+        });
+    });
 });
diff --git a/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.ts b/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.ts
index ec983282a..fd79fd8da 100644
--- a/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.ts
+++ b/libs/portal/shared/data-access/src/lib/workspace-back-navigation.service.ts
@@ -1,20 +1,91 @@
-import { computed, Injectable, signal } from '@angular/core';
+import { DOCUMENT, Location } from '@angular/common';
+import {
+    computed,
+    DestroyRef,
+    inject,
+    Injectable,
+    InjectionToken,
+    signal,
+} from '@angular/core';
 import { WorkspaceBackTarget } from '@iptvnator/portal/shared/util';
 
+/** The parts of the browser's Navigation API the history fallback reads. */
+export type WorkspaceHistoryNavigation = Pick<
+    Navigation,
+    'currentEntry' | 'entries' | 'addEventListener' | 'removeEventListener'
+>;
+
+/**
+ * The browser's Navigation API; null where it is missing (older Safari and
+ * Firefox, jsdom), which leaves the header without the history fallback.
+ */
+export const WORKSPACE_HISTORY_NAVIGATION =
+    new InjectionToken<WorkspaceHistoryNavigation | null>(
+        'WORKSPACE_HISTORY_NAVIGATION',
+        {
+            providedIn: 'root',
+            factory: () => inject(DOCUMENT).defaultView?.navigation ?? null,
+        }
+    );
+
+/**
+ * True when the previous history entry belongs to this document, i.e. the
+ * router pushed it in this app session. Entries from before a reload or from
+ * another page of the origin are excluded, so the fallback never leaves the
+ * app or reloads it.
+ */
+function hasInAppPreviousEntry(history: WorkspaceHistoryNavigation): boolean {
+    const index = history.currentEntry?.index ?? -1;
+    return index > 0 && history.entries()[index - 1]?.sameDocument === true;
+}
+
 /**
  * Owns the header's Back slot. Pages register while they offer Back; the most
  * recent registration wins, so a page opened above another one takes the slot
- * and hands it back when it goes away.
+ * and hands it back when it goes away. Without a registration the slot falls
+ * back to browser history while an in-app previous entry exists, and is empty
+ * otherwise (never a disabled arrow).
  */
 @Injectable({ providedIn: 'root' })
 export class WorkspaceBackNavigationService {
+    private readonly location = inject(Location);
     private readonly targets = signal<readonly WorkspaceBackTarget[]>([]);
+    private readonly canGoBackInApp = signal(false);
+
+    /**
+     * Generic Back to the previous page. It advertises no Escape (no page
+     * handles one) and yields to the phone drawer toggle, so the categories
+     * of a list reached by navigation stay reachable.
+     */
+    private readonly historyTarget: WorkspaceBackTarget = {
+        label: signal(null),
+        escapeShortcut: signal(false),
+        phoneDrawerToggle: 'yield',
+        run: () => this.location.back(),
+    };
 
     readonly target = computed(() => {
         const targets = this.targets();
-        return targets[targets.length - 1] ?? null;
+        return (
+            targets[targets.length - 1] ??
+            (this.canGoBackInApp() ? this.historyTarget : null)
+        );
     });
 
+    constructor() {
+        const history = inject(WORKSPACE_HISTORY_NAVIGATION);
+        if (!history) return;
+        // Fires for router pushes and replacements and for traversals,
+        // including a guard-cancelled Back that the router rewrites.
+        const sync = () =>
+            this.canGoBackInApp.set(hasInAppPreviousEntry(history));
+        sync();
+        history.addEventListener('currententrychange', sync);
+        inject(DestroyRef).onDestroy(() =>
+            history.removeEventListener('currententrychange', sync)
+        );
+    }
+
     /**
      * Returns the release function. It removes only this target: when one
      * page replaces another (a loading shell by the loaded one), creation and
@@ -31,7 +102,7 @@ export class WorkspaceBackNavigationService {
             );
     }
 
-    /** Runs the current target; false when no page offers Back. */
+    /** Runs the current target; false when the header shows no Back. */
     goBack(): boolean {
         const target = this.target();
         if (!target) return false;
diff --git a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.html b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.html
index 2fa1ce742..ae9eaf798 100644
--- a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.html
+++ b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.html
@@ -7,19 +7,7 @@
             <div class="header sticky-header">
                 <div class="header-top">
                     <div class="header-left">
-                        <div class="header-title-group">
-                            @if (showBackButton()) {
-                                <button
-                                    mat-icon-button
-                                    class="header-back"
-                                    [attr.aria-label]="'BACK' | translate"
-                                    (click)="onBackClick()"
-                                >
-                                    <mat-icon>arrow_back</mat-icon>
-                                </button>
-                            }
-                            <h2>{{ title() | translate }}</h2>
-                        </div>
+                        <h2>{{ title() | translate }}</h2>
 
                         <!-- Filters slot -->
                         <div class="type-filters">
diff --git a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.scss b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.scss
index 39286e9ba..5d7d7600f 100644
--- a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.scss
+++ b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.scss
@@ -52,18 +52,6 @@
         flex: 1;
         flex-wrap: wrap;
 
-        // Keep the back arrow and title tightly grouped, independent of the
-        // wide gap between the title group and the filters (RTL-safe)
-        .header-title-group {
-            display: flex;
-            align-items: center;
-            gap: 4px;
-        }
-
-        .header-back {
-            flex-shrink: 0;
-        }
-
         h2 {
             margin: 0;
             white-space: nowrap;
diff --git a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.spec.ts b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.spec.ts
index e4f8bf705..7e8a44d51 100644
--- a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.spec.ts
+++ b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.spec.ts
@@ -2,6 +2,7 @@ import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
 import { TranslatePipe } from '@ngx-translate/core';
 import { MockPipe } from 'ng-mocks';
+import { WorkspaceBackNavigationService } from '@iptvnator/portal/shared/data-access';
 import { SearchLayoutComponent } from './search-layout.component';
 
 describe('SearchLayoutComponent', () => {
@@ -58,24 +59,35 @@ describe('SearchLayoutComponent', () => {
         });
     }
 
-    it('shows the back button only when showBackButton is set and emits backClick', () => {
-        fixture.detectChanges();
-        expect(
-            fixture.debugElement.query(By.css('.header-back'))
-        ).toBeNull();
-
-        fixture.componentRef.setInput('showBackButton', true);
-        fixture.detectChanges();
-
-        const backButton = fixture.debugElement.query(By.css('.header-back'));
-        expect(backButton).not.toBeNull();
-
+    it('offers the header Back only while backAvailable is set and the results show', () => {
+        const backNavigation = TestBed.inject(WorkspaceBackNavigationService);
         const emitted: unknown[] = [];
         fixture.componentInstance.backClick.subscribe((value) =>
             emitted.push(value)
         );
-        (backButton.nativeElement as HTMLButtonElement).click();
+        fixture.detectChanges();
+        expect(backNavigation.target()).toBeNull();
+
+        fixture.componentRef.setInput('backAvailable', true);
+        fixture.detectChanges();
+        // The page carries no arrow of its own.
+        expect(
+            fixture.debugElement.query(By.css('button[aria-label="BACK"]'))
+        ).toBeNull();
+        expect(backNavigation.goBack()).toBe(true);
         expect(emitted).toHaveLength(1);
+
+        // An inline detail replaces the results and registers its own Back.
+        fixture.componentRef.setInput('showDetails', true);
+        fixture.detectChanges();
+        expect(backNavigation.target()).toBeNull();
+
+        fixture.componentRef.setInput('showDetails', false);
+        fixture.detectChanges();
+        expect(backNavigation.target()).not.toBeNull();
+
+        fixture.destroy();
+        expect(backNavigation.target()).toBeNull();
     });
 
     it('emits nearEnd when the results container is scrolled near the bottom', () => {
diff --git a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.ts b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.ts
index 2ca68ddf3..da6e2d23e 100644
--- a/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.ts
+++ b/libs/portal/shared/ui/src/lib/components/search-layout/search-layout.component.ts
@@ -10,6 +10,7 @@ import { MatIconButton } from '@angular/material/button';
 import { MatIcon } from '@angular/material/icon';
 import { MatProgressSpinner } from '@angular/material/progress-spinner';
 import { TranslatePipe } from '@ngx-translate/core';
+import { registerWorkspaceBack } from '@iptvnator/portal/shared/data-access';
 import { InfiniteScrollDirective } from '../../directives/infinite-scroll.directive';
 import { SearchFormComponent } from '../search-form/search-form.component';
 
@@ -48,8 +49,12 @@ export class SearchLayoutComponent {
     /** Whether to show the close button (for dialog mode) */
     readonly showCloseButton = input<boolean>(false);
 
-    /** Whether to show the back button (nested search reached via navigation) */
-    readonly showBackButton = input<boolean>(false);
+    /**
+     * Whether the page offers Back (a nested search reached via navigation).
+     * It is the workspace header's Back, registered while the results show;
+     * an inline detail above them brings its own.
+     */
+    readonly backAvailable = input<boolean>(false);
 
     /** Whether to show results count */
     readonly showResultsCount = input<boolean>(true);
@@ -106,7 +111,7 @@ export class SearchLayoutComponent {
     /** Emitted when close button is clicked */
     readonly closeClick = output<void>();
 
-    /** Emitted when the back button is clicked */
+    /** Emitted by the header's Back while `backAvailable` is set */
     readonly backClick = output<void>();
 
     /**
@@ -116,6 +121,13 @@ export class SearchLayoutComponent {
      */
     readonly nearEnd = output<void>();
 
+    constructor() {
+        registerWorkspaceBack({
+            available: () => this.backAvailable() && !this.showDetails(),
+            run: () => this.backClick.emit(),
+        });
+    }
+
     /** Focus the search input */
     focusSearchInput(): void {
         this.searchFormComponent()?.focusSearchInput();
@@ -142,10 +154,6 @@ export class SearchLayoutComponent {
         this.closeClick.emit();
     }
 
-    onBackClick(): void {
-        this.backClick.emit();
-    }
-
     /** Check if we should show the "no results" state */
     get showNoResults(): boolean {
         return (
diff --git a/libs/portal/shared/util/src/lib/workspace-back-target.ts b/libs/portal/shared/util/src/lib/workspace-back-target.ts
index 0c4ebcba1..ee0a4933d 100644
--- a/libs/portal/shared/util/src/lib/workspace-back-target.ts
+++ b/libs/portal/shared/util/src/lib/workspace-back-target.ts
@@ -1,10 +1,25 @@
 import { Signal } from '@angular/core';
 
+/**
+ * How Back shares the phone header (≤640 px) with the context drawer toggle
+ * on routes that have one.
+ *
+ * - `replace` (default): Back takes the toggle's slot. The drawer belongs to
+ *   the list Back returns to (detail pages), which shows the toggle again.
+ * - `beside`: both stay. The drawer holds the page's own navigation
+ *   (settings sections), so hiding its toggle would strand it.
+ * - `yield`: Back hides while the toggle shows. Used by the history
+ *   fallback, so a category list never loses its drawer to it.
+ */
+export type WorkspaceBackPhoneSlot = 'replace' | 'beside' | 'yield';
+
 /** A page's Back action, rendered in the workspace header's leading slot. */
 export interface WorkspaceBackTarget {
     /** Accessible name and tooltip; null falls back to the generic "Back". */
     readonly label: Signal<string | null>;
     /** True while Escape on the page runs the same action. */
     readonly escapeShortcut: Signal<boolean>;
+    /** Phone-width placement beside the drawer toggle; `replace` if unset. */
+    readonly phoneDrawerToggle?: WorkspaceBackPhoneSlot;
     run(): void;
 }
diff --git a/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-detail.component.ts b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-detail.component.ts
index 23ed55ada..488abdeeb 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-detail.component.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-detail.component.ts
@@ -38,7 +38,6 @@ import {
     PlaylistsService,
 } from '@iptvnator/services';
 import {
-    PlaybackPositionData,
     ResolvedPortalPlayback,
     StalkerVodDetails,
     VodDetailsItem,
@@ -47,6 +46,8 @@ import {
 import { StalkerCatalogFacadeService } from '../stalker-catalog-facade.service';
 import { StalkerSeriesViewComponent } from '../stalker-series-view/stalker-series-view.component';
 
+import { startStalkerCatalogVodPlayback } from './stalker-catalog-vod-playback';
+import { StalkerCatalogVodPosition } from './stalker-catalog-vod-position';
 import { startStalkerVodDownload } from './stalker-vod-download';
 import { createStalkerVodWatchedToggle } from '../stalker-vod-watched-toggle';
 import {
@@ -107,13 +108,16 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
     readonly playbackOwnerKey = computed(() =>
         JSON.stringify([this.playbackSessionKey(), this.contentType()])
     );
-    private readonly selectedVodPosition = signal<PlaybackPositionData | null>(
-        null
-    );
-    private unsubscribePositionUpdates: (() => void) | null = null;
-    private positionLoadGeneration = 0;
+    private readonly vodPosition = new StalkerCatalogVodPosition({
+        playbackPositions: this.playbackPositions,
+        playbackPositionBridge: this.playbackPositionBridge,
+        playlistId: () => this.catalog.playlist()?.id,
+        selectedItem: this.selectedItem,
+        contentType: this.contentType,
+        isSeriesDetail: () => this.isSeriesDetail(),
+    });
     /** The stored row is in hand (not the placeholder shown while reading). */
-    readonly positionLoaded = signal(false);
+    readonly positionLoaded = this.vodPosition.loaded;
     /**
      * The start still waiting on the portal between the click and playback,
      * keyed by its owner: a stale resolution for the previous movie must not
@@ -146,13 +150,13 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
     });
 
     readonly selectedVodPlaybackDuration = computed<number | null>(
-        () => this.selectedVodPosition()?.durationSeconds ?? null
+        () => this.vodPosition.position()?.durationSeconds ?? null
     );
     readonly sourceLabel = computed(
         () => this.catalog.playlist()?.title ?? null
     );
     readonly selectedVodPlaybackPosition = computed<number | null>(
-        () => this.selectedVodPosition()?.positionSeconds ?? null
+        () => this.vodPosition.position()?.positionSeconds ?? null
     );
 
     /** Manual watched toggle; the child gates it on live playback itself. */
@@ -165,7 +169,7 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
                 : null;
         },
         playbackPositions: this.playbackPositions,
-        position: this.selectedVodPosition,
+        position: this.vodPosition.position,
         playingNow: computed(
             () => this.inlinePlayback() !== null || this.playbackStartPending()
         ),
@@ -173,8 +177,8 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
         applyPosition: (position) => {
             // A read still in flight started from the pre-write row; letting
             // it land would revert the toggle it never saw.
-            this.positionLoadGeneration++;
-            this.selectedVodPosition.set(position);
+            this.vodPosition.discardPendingLoad();
+            this.vodPosition.position.set(position);
         },
         snackBar: this.snackBar,
         translateService: this.translateService,
@@ -196,22 +200,7 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
     );
 
     constructor() {
-        effect(() => {
-            const item = this.selectedItem();
-            const playlistId = this.catalog.playlist()?.id;
-
-            if (
-                !item ||
-                !playlistId ||
-                this.contentType() !== 'vod' ||
-                this.isSeriesDetail()
-            ) {
-                this.selectedVodPosition.set(null);
-                return;
-            }
-
-            void this.loadSelectedVodPosition(playlistId, Number(item.id));
-        });
+        this.vodPosition.connect();
 
         effect(() => {
             const ownerKey = this.playbackOwnerKey();
@@ -222,22 +211,6 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
             this.currentPlaybackOwnerKey = ownerKey;
             this.closeInlinePlayer();
         });
-
-        this.unsubscribePositionUpdates =
-            this.playbackPositionBridge.onPlaybackPositionUpdate(
-                (data: PlaybackPositionData) => {
-                    const currentItem = this.selectedItem();
-                    if (
-                        data.contentType !== 'vod' ||
-                        data.playlistId !== this.catalog.playlist()?.id ||
-                        data.contentXtreamId !== Number(currentItem?.id)
-                    ) {
-                        return;
-                    }
-
-                    this.selectedVodPosition.set(data);
-                }
-            ) ?? null;
     }
 
     onVodPlay(item: VodDetailsItem, positionSeconds?: number): void {
@@ -281,8 +254,8 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
             this.contentType() === 'vod' && !this.isSeriesDetail()
                 ? Number(this.selectedItem()?.id) || null
                 : null,
-        selectedVodPosition: this.selectedVodPosition,
-        discardPendingPositionLoad: () => ++this.positionLoadGeneration,
+        selectedVodPosition: this.vodPosition.position,
+        discardPendingPositionLoad: () => this.vodPosition.discardPendingLoad(),
         beforeExternalLaunch: () => this.closeInlinePlayer(),
         beginPendingStart: () => beginTrackedExternalLaunch(this),
         afterProgressReset: (playlistId) =>
@@ -338,7 +311,7 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
                 playlistId,
                 position
             ),
-        onSaved: (position) => this.selectedVodPosition.set(position),
+        onSaved: (position) => this.vodPosition.position.set(position),
     });
 
     handleInlineTimeUpdate(event: {
@@ -356,36 +329,7 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
 
     ngOnDestroy(): void {
         this.closeInlinePlayer();
-        this.unsubscribePositionUpdates?.();
-    }
-
-    private async loadSelectedVodPosition(
-        playlistId: string,
-        vodId: number
-    ): Promise<void> {
-        const generation = ++this.positionLoadGeneration;
-        this.positionLoaded.set(false);
-        if (Number.isNaN(vodId)) {
-            this.selectedVodPosition.set(null);
-            return;
-        }
-
-        const position = await this.playbackPositions.getPlaybackPosition(
-            playlistId,
-            vodId,
-            'vod'
-        );
-        // Only the newest read for the item still on screen may land: an
-        // older one would revert a watched toggle or a later selection.
-        if (
-            generation !== this.positionLoadGeneration ||
-            this.catalog.playlist()?.id !== playlistId ||
-            Number(this.selectedItem()?.id) !== vodId
-        ) {
-            return;
-        }
-        this.selectedVodPosition.set(position ?? null);
-        this.positionLoaded.set(true);
+        this.vodPosition.disconnect();
     }
 
     private async startStalkerVodPlayback(
@@ -394,54 +338,19 @@ export class StalkerCatalogDetailComponent implements OnDestroy {
         thumbnail?: string,
         startTime?: number
     ): Promise<void> {
-        const requestId = ++this.playbackRequestId;
-        const sessionKey = this.playbackSessionKey();
-        const ownerKey = this.playbackOwnerKey();
-        const usesEmbeddedPlayer = this.portalPlayer.isEmbeddedPlayer();
-        if (usesEmbeddedPlayer && !sessionKey) return;
-
-        const startId = this.pendingStart.begin(ownerKey);
-        try {
-            const playback = await this.catalog.resolveVodPlayback(
-                cmd,
-                title,
-                thumbnail,
-                startTime
-            );
-            if (
-                requestId !== this.playbackRequestId ||
-                this.playbackOwnerKey() !== ownerKey
-            ) {
-                return;
-            }
-
-            this.positionWriter.reset();
-            if (usesEmbeddedPlayer) {
-                this.inlinePlayback.set(playback);
-                return;
-            }
-
-            this.closeInlinePlayer();
-            void this.portalPlayer.openResolvedPlayback(playback, true);
-        } catch (error) {
-            if (
-                requestId !== this.playbackRequestId ||
-                this.playbackOwnerKey() !== ownerKey
-            ) {
-                return;
-            }
-            this.logger.error('Failed to start inline VOD playback', error);
-            const errorMessage =
-                error instanceof Error && error.message === 'nothing_to_play'
-                    ? this.translateService.instant(
-                          'PORTALS.CONTENT_NOT_AVAILABLE'
-                      )
-                    : this.translateService.instant('PORTALS.PLAYBACK_ERROR');
-            this.snackBar.open(errorMessage, undefined, {
-                duration: 3000,
-            });
-        } finally {
-            this.pendingStart.settle(startId);
-        }
+        await startStalkerCatalogVodPlayback(this, {
+            resolvePlayback: () =>
+                this.catalog.resolveVodPlayback(
+                    cmd,
+                    title,
+                    thumbnail,
+                    startTime
+                ),
+            portalPlayer: this.portalPlayer,
+            resetPositionWriter: () => this.positionWriter.reset(),
+            logger: this.logger,
+            translate: this.translateService,
+            snackBar: this.snackBar,
+        });
     }
 }
diff --git a/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-playback.ts b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-playback.ts
new file mode 100644
index 000000000..b26f4f11c
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-playback.ts
@@ -0,0 +1,84 @@
+import type { WritableSignal } from '@angular/core';
+import type { MatSnackBar } from '@angular/material/snack-bar';
+import type { TranslateService } from '@ngx-translate/core';
+import type { Logger, PortalPlayer } from '@iptvnator/portal/shared/util';
+import type { ResolvedPortalPlayback } from '@iptvnator/shared/interfaces';
+
+/** The detail page as the owner of its inline player: it tracks its own request ids. */
+interface StalkerCatalogVodPlaybackHost {
+    playbackRequestId: number;
+    readonly pendingStart: {
+        begin(owner: string): number;
+        settle(startId: number): void;
+    };
+    playbackOwnerKey(): string;
+    playbackSessionKey(): string;
+    readonly inlinePlayback: WritableSignal<ResolvedPortalPlayback | null>;
+    closeInlinePlayer(): void;
+}
+
+interface StalkerCatalogVodPlaybackDeps {
+    readonly resolvePlayback: () => Promise<ResolvedPortalPlayback>;
+    readonly portalPlayer: Pick<
+        PortalPlayer,
+        'isEmbeddedPlayer' | 'openResolvedPlayback'
+    >;
+    /** Clears the inline position writer for the playback about to mount. */
+    readonly resetPositionWriter: () => void;
+    readonly logger: Pick<Logger, 'error'>;
+    readonly translate: Pick<TranslateService, 'instant'>;
+    readonly snackBar: Pick<MatSnackBar, 'open'>;
+}
+
+/**
+ * Play/Resume of the movie on the routed catalog detail: resolves the
+ * stream and hands it to the inline or the configured player, unless the
+ * page moved on or a newer start took over while the portal answered.
+ */
+export async function startStalkerCatalogVodPlayback(
+    host: StalkerCatalogVodPlaybackHost,
+    deps: StalkerCatalogVodPlaybackDeps
+): Promise<void> {
+    const requestId = ++host.playbackRequestId;
+    const sessionKey = host.playbackSessionKey();
+    const ownerKey = host.playbackOwnerKey();
+    const usesEmbeddedPlayer = deps.portalPlayer.isEmbeddedPlayer();
+    if (usesEmbeddedPlayer && !sessionKey) return;
+
+    const startId = host.pendingStart.begin(ownerKey);
+    try {
+        const playback = await deps.resolvePlayback();
+        if (
+            requestId !== host.playbackRequestId ||
+            host.playbackOwnerKey() !== ownerKey
+        ) {
+            return;
+        }
+
+        deps.resetPositionWriter();
+        if (usesEmbeddedPlayer) {
+            host.inlinePlayback.set(playback);
+            return;
+        }
+
+        host.closeInlinePlayer();
+        void deps.portalPlayer.openResolvedPlayback(playback, true);
+    } catch (error) {
+        if (
+            requestId !== host.playbackRequestId ||
+            host.playbackOwnerKey() !== ownerKey
+        ) {
+            return;
+        }
+        deps.logger.error('Failed to start inline VOD playback', error);
+        const errorMessage =
+            error instanceof Error && error.message === 'nothing_to_play'
+                ? deps.translate.instant('PORTALS.CONTENT_NOT_AVAILABLE')
+                : deps.translate.instant('PORTALS.PLAYBACK_ERROR');
+        deps.snackBar.open(errorMessage, undefined, {
+            duration: 3000,
+        });
+    } finally {
+        host.pendingStart.settle(startId);
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-position.ts b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-position.ts
new file mode 100644
index 000000000..f60b4176b
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-catalog-detail/stalker-catalog-vod-position.ts
@@ -0,0 +1,110 @@
+import { type Signal, effect, signal } from '@angular/core';
+import type { PortalPlaybackPositions } from '@iptvnator/portal/shared/util';
+import type { StalkerSelectedVodItem } from '@iptvnator/portal/stalker/data-access';
+import type { PlaybackPositionRuntimeBridgeService } from '@iptvnator/services';
+import type { PlaybackPositionData } from '@iptvnator/shared/interfaces';
+
+interface StalkerCatalogVodPositionConfig {
+    readonly playbackPositions: Pick<
+        PortalPlaybackPositions,
+        'getPlaybackPosition'
+    >;
+    readonly playbackPositionBridge: Pick<
+        PlaybackPositionRuntimeBridgeService,
+        'onPlaybackPositionUpdate'
+    >;
+    readonly playlistId: () => string | undefined;
+    readonly selectedItem: Signal<StalkerSelectedVodItem | null>;
+    readonly contentType: () => string;
+    readonly isSeriesDetail: () => boolean;
+}
+
+/**
+ * The stored playback position of the movie the routed catalog detail
+ * shows: read whenever the selection changes and kept current from the
+ * playback runtime while that movie stays on screen.
+ */
+export class StalkerCatalogVodPosition {
+    readonly position = signal<PlaybackPositionData | null>(null);
+    /** The stored row is in hand (not the placeholder shown while reading). */
+    readonly loaded = signal(false);
+    private unsubscribePositionUpdates: (() => void) | null = null;
+    private loadGeneration = 0;
+
+    constructor(private readonly config: StalkerCatalogVodPositionConfig) {}
+
+    /**
+     * Starts following the selection and the playback runtime. Registers an
+     * effect, so the host calls it from its constructor.
+     */
+    connect(): void {
+        effect(() => {
+            const item = this.config.selectedItem();
+            const playlistId = this.config.playlistId();
+
+            if (
+                !item ||
+                !playlistId ||
+                this.config.contentType() !== 'vod' ||
+                this.config.isSeriesDetail()
+            ) {
+                this.position.set(null);
+                return;
+            }
+
+            void this.load(playlistId, Number(item.id));
+        });
+
+        this.unsubscribePositionUpdates =
+            this.config.playbackPositionBridge.onPlaybackPositionUpdate(
+                (data: PlaybackPositionData) => {
+                    const currentItem = this.config.selectedItem();
+                    if (
+                        data.contentType !== 'vod' ||
+                        data.playlistId !== this.config.playlistId() ||
+                        data.contentXtreamId !== Number(currentItem?.id)
+                    ) {
+                        return;
+                    }
+
+                    this.position.set(data);
+                }
+            ) ?? null;
+    }
+
+    disconnect(): void {
+        this.unsubscribePositionUpdates?.();
+    }
+
+    /** Retires a stored-position read still in flight (a row was written since). */
+    discardPendingLoad(): void {
+        this.loadGeneration++;
+    }
+
+    private async load(playlistId: string, vodId: number): Promise<void> {
+        const generation = ++this.loadGeneration;
+        this.loaded.set(false);
+        if (Number.isNaN(vodId)) {
+            this.position.set(null);
+            return;
+        }
+
+        const position =
+            await this.config.playbackPositions.getPlaybackPosition(
+                playlistId,
+                vodId,
+                'vod'
+            );
+        // Only the newest read for the item still on screen may land: an
+        // older one would revert a watched toggle or a later selection.
+        if (
+            generation !== this.loadGeneration ||
+            this.config.playlistId() !== playlistId ||
+            Number(this.config.selectedItem()?.id) !== vodId
+        ) {
+            return;
+        }
+        this.position.set(position ?? null);
+        this.loaded.set(true);
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-paging.controller.ts b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-paging.controller.ts
new file mode 100644
index 000000000..f261c0598
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-paging.controller.ts
@@ -0,0 +1,391 @@
+import {
+    type Signal,
+    computed,
+    linkedSignal,
+    resource,
+    signal,
+} from '@angular/core';
+import type { Logger } from '@iptvnator/portal/shared/util';
+import {
+    executeStalkerRequest,
+    type StalkerPortalRepairService,
+    type StalkerSessionService,
+    type StalkerVodSource,
+    withoutWithheldStalkerItems,
+} from '@iptvnator/portal/stalker/data-access';
+import {
+    type DataService,
+    type ParentalLockService,
+    resetHostConnectivityGuard,
+} from '@iptvnator/services';
+import {
+    type PlaylistMeta,
+    StalkerPortalActions,
+} from '@iptvnator/shared/interfaces';
+import { isStalkerSearchRequestCurrent } from './stalker-search-request.util';
+import {
+    buildStalkerSearchRequestParams,
+    dedupeSearchResults,
+    recordNewWithheldRows,
+    resolveSearchWithheldCategoryIds,
+    type StalkerSearchContentType,
+    type StalkerSearchResponse,
+    withAbsoluteScreenshotUri,
+} from './stalker-search-results.util';
+
+interface StalkerSearchPagingControllerConfig {
+    searchTerm: Signal<string>;
+    selectedFilterType: Signal<StalkerSearchContentType>;
+    /** The portal being searched; null while none is resolved. */
+    currentPlaylist: Signal<PlaylistMeta | null>;
+    dataService: DataService;
+    parentalLock: ParentalLockService;
+    stalkerSession: StalkerSessionService;
+    portalRepair: StalkerPortalRepairService;
+    logger: Logger;
+    /** Closes the host's open detail when its genre became withheld. */
+    closeWithheldDetail: (withheldCategoryIds: ReadonlySet<string>) => void;
+}
+
+/**
+ * Owns the result paging of the Stalker search page: the portal page being
+ * requested, the pages accumulated into one list and the parental-lock
+ * bookkeeping that decides whether paging continues.
+ */
+export class StalkerSearchPagingController {
+    /** Lock version the accumulated results were built under. */
+    private searchResultsLockVersion: number | null = null;
+    /**
+     * Withheld row ids seen for the current search identity. A page adding
+     * only new withheld ids is still progress and is skipped automatically;
+     * a page adding nothing new is the end of the results.
+     */
+    private searchWithheldKey = '';
+    private readonly searchWithheldIds = new Set<string>();
+
+    constructor(private readonly config: StalkerSearchPagingControllerConfig) {}
+
+    /**
+     * Portal page for the current term+filter+portal; resets when any of
+     * them changes. The playlist belongs to the identity: Angular reuses the
+     * search route across `/stalker/A/search` -> `/stalker/B/search`, and a
+     * surviving page number would append portal B's later page onto portal
+     * A's accumulated results while skipping B's first page.
+     */
+    readonly searchPage = linkedSignal({
+        source: () => ({
+            term: this.config.searchTerm(),
+            type: this.config.selectedFilterType(),
+            playlistId: this.config.currentPlaylist()?._id ?? null,
+        }),
+        computation: () => 1,
+    });
+    /** Pages accumulated into one continuous, deduplicated result list. */
+    private readonly accumulatedSearchResults = signal<StalkerVodSource[]>([]);
+    readonly searchResults = this.accumulatedSearchResults.asReadonly();
+    readonly searchHasMore = signal(false);
+    /**
+     * A failed append page. The next near-end RETRIES that page instead of
+     * advancing — incrementing past it would silently omit its results.
+     */
+    readonly searchAppendError = signal(false);
+
+    readonly searchResultsResource = resource({
+        params: () => ({
+            contentType: this.config.selectedFilterType(),
+            search: this.config.searchTerm(),
+            page: this.searchPage(),
+            playlistId: this.config.currentPlaylist()?._id ?? null,
+            action: StalkerPortalActions.GetOrderedList,
+            // Lock/unlock re-fires the search: withheld rows are dropped at
+            // page time, so the results must be rebuilt when they change.
+            parentalLockVersion: this.config.parentalLock.version(),
+        }),
+        loader: async ({ params }) => {
+            if (params.search.length < 3) {
+                this.resetSearchAccumulator();
+                return [];
+            }
+            const playlist = this.config.currentPlaylist();
+            if (!playlist) {
+                // A reused route can land on a deleted/unresolved portal —
+                // the previous portal's cards must not keep rendering.
+                this.resetSearchAccumulator();
+                return [];
+            }
+            const { portalUrl, macAddress } = playlist;
+            if (!portalUrl || !macAddress) {
+                this.resetSearchAccumulator();
+                return [];
+            }
+            const contentType = params.contentType;
+            const withheldCategoryIds = resolveSearchWithheldCategoryIds(
+                this.config.parentalLock,
+                playlist._id,
+                contentType
+            );
+            const lockVersionChanged =
+                this.searchResultsLockVersion !== null &&
+                this.searchResultsLockVersion !== params.parentalLockVersion;
+            this.searchResultsLockVersion = params.parentalLockVersion;
+            if (lockVersionChanged) {
+                this.applyRelockToResults(withheldCategoryIds, contentType);
+            }
+            if (lockVersionChanged && params.page > 1) {
+                // A lock flip past page 1: rebuild from page 1 rather than
+                // appending to pages accumulated under the old lock state.
+                this.searchPage.set(1);
+                return this.accumulatedSearchResults();
+            }
+            const withheldKey = JSON.stringify([
+                params.playlistId,
+                contentType,
+                params.search,
+                params.parentalLockVersion,
+            ]);
+            if (params.page === 1 || this.searchWithheldKey !== withheldKey) {
+                this.searchWithheldKey = withheldKey;
+                this.searchWithheldIds.clear();
+            }
+
+            const requestParams = buildStalkerSearchRequestParams(
+                contentType,
+                params.search,
+                params.page
+            );
+
+            // A stale response (term/filter/page/portal — or the parental
+            // lock — moved on while this page was in flight) must not clobber
+            // the accumulated list: the request is not aborted, and a
+            // pre-relock response was filtered with the pre-relock set.
+            const isCurrent = (): boolean =>
+                isStalkerSearchRequestCurrent(params, {
+                    search: this.config.searchTerm(),
+                    contentType: this.config.selectedFilterType(),
+                    page: this.searchPage(),
+                    playlistId: this.config.currentPlaylist()?._id ?? null,
+                    parentalLockVersion: this.config.parentalLock.version(),
+                });
+
+            try {
+                // executeStalkerRequest owns the portal-mode decision (shared
+                // predicate with URL fallback for legacy rows) and the lazy
+                // portal repair, so search cannot drift from the catalog
+                // paths.
+                const response =
+                    await executeStalkerRequest<StalkerSearchResponse>(
+                        {
+                            dataService: this.config.dataService,
+                            stalkerSession: this.config.stalkerSession,
+                            portalRepair: this.config.portalRepair,
+                        },
+                        playlist,
+                        requestParams
+                    );
+                const rawItems = (response.js?.data || []).map(
+                    (item: StalkerVodSource) =>
+                        withAbsoluteScreenshotUri(item, portalUrl)
+                );
+                const items = withoutWithheldStalkerItems(
+                    rawItems,
+                    contentType,
+                    withheldCategoryIds
+                );
+                // Before the withheld-id bookkeeping: a stale page must not
+                // pre-record ids into a set a newer relock request cleared,
+                // or that request's page counts no new withheld rows and
+                // stops paging short of later visible matches.
+                if (!isCurrent()) {
+                    return items;
+                }
+                const newWithheldCount = recordNewWithheldRows(
+                    rawItems,
+                    items,
+                    this.searchWithheldIds
+                );
+
+                const merged = this.applySearchPageSuccess(
+                    params.page,
+                    items,
+                    response.js?.total_items,
+                    // A page made only of withheld rows still is a page the
+                    // portal served; judge progress on what it sent.
+                    rawItems.length > 0 &&
+                        (items.length > 0 || newWithheldCount > 0)
+                );
+                this.advancePastWithheldPage(
+                    params.page,
+                    items.length,
+                    newWithheldCount,
+                    isCurrent
+                );
+                return merged;
+            } catch (error) {
+                this.config.logger.warn('Stalker search page failed', {
+                    page: params.page,
+                    error,
+                });
+                if (!isCurrent()) {
+                    return this.accumulatedSearchResults();
+                }
+
+                return this.applySearchPageFailure(params.page);
+            }
+        },
+    });
+
+    /**
+     * Empties the accumulator and every paging flag — used whenever there is
+     * no searchable portal (short term, missing playlist, malformed row).
+     */
+    resetSearchAccumulator(): void {
+        this.accumulatedSearchResults.set([]);
+        this.searchHasMore.set(false);
+        this.searchAppendError.set(false);
+    }
+
+    /** Merges a successful portal page into the accumulated result list. */
+    applySearchPageSuccess(
+        page: number,
+        items: StalkerVodSource[],
+        totalItems: number | undefined,
+        pageHadRows: boolean = items.length > 0
+    ): StalkerVodSource[] {
+        const previous = page === 1 ? [] : this.accumulatedSearchResults();
+        const merged =
+            page === 1 ? items : dedupeSearchResults([...previous, ...items]);
+        // Paging continues only while pages make progress — with OR without
+        // a reported total. Dedup after mid-list portal mutations can leave
+        // the unique list permanently shorter than total_items, and a
+        // repeated page dedupes to no growth; either way a no-progress
+        // append is the practical end of the results. A page whose rows were
+        // all withheld by the parental lock counts as progress too.
+        const withheldRows = pageHadRows && items.length === 0;
+        const madeProgress =
+            page === 1 || merged.length > previous.length || withheldRows;
+        this.searchHasMore.set(
+            madeProgress &&
+                (typeof totalItems === 'number' && totalItems >= 0
+                    ? merged.length < totalItems
+                    : pageHadRows)
+        );
+        this.searchAppendError.set(false);
+        this.accumulatedSearchResults.set(merged);
+        return merged;
+    }
+
+    /**
+     * A failed FRESH search (page 1) must not keep rendering the previous
+     * query's cards; a failed append keeps the accumulated pages and flags
+     * the error so the next near-end retries this page instead of advancing.
+     */
+    applySearchPageFailure(page: number): StalkerVodSource[] {
+        if (page === 1) {
+            this.accumulatedSearchResults.set([]);
+            this.searchHasMore.set(false);
+            this.searchAppendError.set(false);
+            return [];
+        }
+
+        this.searchAppendError.set(true);
+        return this.accumulatedSearchResults();
+    }
+
+    /**
+     * Result-set identity for the layout's near-end latch and auto-fill
+     * budget — term, filter, and portal, mirroring the paging identity.
+     */
+    readonly searchScrollResetKey = computed(() =>
+        [
+            this.config.searchTerm(),
+            this.config.selectedFilterType(),
+            this.config.currentPlaylist()?._id ?? '',
+        ].join('|')
+    );
+
+    readonly isInitialSearchLoading = computed(
+        () => this.searchResultsResource.isLoading() && this.searchPage() === 1
+    );
+    readonly isAppendingSearchResults = computed(
+        () => this.searchResultsResource.isLoading() && this.searchPage() > 1
+    );
+
+    loadMoreSearchResults(): void {
+        if (this.searchResultsResource.isLoading() || !this.searchHasMore()) {
+            return;
+        }
+
+        if (this.searchAppendError()) {
+            // Retry the SAME page — advancing would permanently omit it.
+            void this.retrySearchPage();
+            return;
+        }
+
+        this.searchPage.update((page) => page + 1);
+    }
+
+    /**
+     * Two failed search pages are exactly what opens the main process'
+     * connectivity guard, so the reset has to precede the reload — otherwise
+     * this retry fast-fails without contacting a portal that may have
+     * recovered, and keeps repeating the same error until the window expires.
+     */
+    private async retrySearchPage(): Promise<void> {
+        // Clear the flag synchronously: awaiting first would leave this branch
+        // re-enterable, and the next `nearEnd` event would fire a second retry.
+        this.searchAppendError.set(false);
+        await resetHostConnectivityGuard(
+            this.config.dataService,
+            this.config.currentPlaylist()?.portalUrl
+        );
+        this.searchResultsResource.reload();
+    }
+
+    /**
+     * The infinite scroll gives up after a few loads that add no height, so
+     * a run of pages made only of parental-locked rows must advance by
+     * itself until a visible row (or the real end) is reached. Only a page
+     * that added withheld ids not seen before counts — a stalled portal
+     * repeating the same locked rows must still end the loop.
+     */
+    advancePastWithheldPage(
+        page: number,
+        visibleCount: number,
+        newWithheldCount: number,
+        isCurrent: () => boolean
+    ): void {
+        if (
+            visibleCount > 0 ||
+            newWithheldCount === 0 ||
+            !this.searchHasMore()
+        ) {
+            return;
+        }
+        queueMicrotask(() => {
+            if (isCurrent()) {
+                this.searchPage.set(page + 1);
+            }
+        });
+    }
+
+    /**
+     * A lock change reached the results on screen, which were read under
+     * the old lock state: close an open detail of a now-withheld genre (the
+     * list hiding it is not enough) and drop the withheld rows NOW, before
+     * the replacement page is awaited — on page 1 too, or they stay
+     * clickable while (or, if it hangs, after) that request is pending.
+     */
+    applyRelockToResults(
+        withheldCategoryIds: ReadonlySet<string>,
+        contentType: Parameters<typeof withoutWithheldStalkerItems>[1]
+    ): void {
+        this.config.closeWithheldDetail(withheldCategoryIds);
+        this.accumulatedSearchResults.set(
+            withoutWithheldStalkerItems(
+                this.accumulatedSearchResults(),
+                contentType,
+                withheldCategoryIds
+            )
+        );
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-results.util.ts b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-results.util.ts
new file mode 100644
index 000000000..d49a76884
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search-results.util.ts
@@ -0,0 +1,138 @@
+import {
+    StalkerContentTypes,
+    type StalkerVodSource,
+    stalkerWithheldRowKey,
+} from '@iptvnator/portal/stalker/data-access';
+import type { ParentalLockService } from '@iptvnator/services';
+import { ALL_CATEGORIES_WITHHELD } from '@iptvnator/shared/interfaces';
+
+export type StalkerSearchContentType = 'vod' | 'series';
+
+export interface StalkerSearchResponse {
+    js?: {
+        data?: StalkerVodSource[];
+        total_items?: number;
+    };
+    message?: string;
+    status?: number;
+}
+
+/** Portals can shift items between pages mid-append — drop duplicate ids. */
+export function dedupeSearchResults(
+    items: StalkerVodSource[]
+): StalkerVodSource[] {
+    const seenIds = new Set<string>();
+    return items.filter((item) => {
+        const id =
+            item.id === undefined || item.id === null ? null : String(item.id);
+        if (id === null) {
+            return true;
+        }
+        if (seenIds.has(id)) {
+            return false;
+        }
+        seenIds.add(id);
+        return true;
+    });
+}
+
+/**
+ * The dedicated search route has no category guard, so it filters the
+ * portal's rows itself: a locked genre's title must not reach the grid, its
+ * detail or playback through search.
+ */
+export function resolveSearchWithheldCategoryIds(
+    parentalLock: ParentalLockService,
+    playlistId: string,
+    contentType: StalkerSearchContentType
+): ReadonlySet<string> {
+    return !parentalLock.active()
+        ? new Set<string>()
+        : parentalLock.withholdsEverything?.()
+          ? ALL_CATEGORIES_WITHHELD
+          : new Set(parentalLock.lockedStalkerIds(playlistId, contentType));
+}
+
+/**
+ * Mirror the catalog request shape: many Ministra portals return an empty
+ * list for get_ordered_list without the category/genre/sortby params the STB
+ * client always sends. `max_page_items` is a HINT — plenty of portals ignore
+ * it and return their own page size, which is why paging cannot rely on it
+ * (progress and `total_items` decide hasMore instead).
+ */
+export function buildStalkerSearchRequestParams(
+    contentType: StalkerSearchContentType,
+    search: string,
+    page: number
+): Record<string, string | number> {
+    return {
+        action: StalkerContentTypes[contentType].getContentAction,
+        type: contentType,
+        sortby: 'added',
+        search,
+        p: page,
+        max_page_items: 100,
+        category: '*',
+        ...(contentType === 'vod' ? { genre: '0' } : {}),
+    };
+}
+
+/**
+ * Records the rows of `rawItems` the parental lock withheld (those missing
+ * from `keptItems`) into `seenWithheldIds` and returns how many of them were
+ * not seen before.
+ */
+export function recordNewWithheldRows(
+    rawItems: StalkerVodSource[],
+    keptItems: StalkerVodSource[],
+    seenWithheldIds: Set<string>
+): number {
+    let newWithheldCount = 0;
+    if (keptItems.length < rawItems.length) {
+        const kept = new Set(keptItems);
+        for (const item of rawItems) {
+            const id = stalkerWithheldRowKey(item);
+            if (!kept.has(item) && !seenWithheldIds.has(id)) {
+                seenWithheldIds.add(id);
+                newWithheldCount += 1;
+            }
+        }
+    }
+    return newWithheldCount;
+}
+
+/** Resolves a result row's portal-relative poster against the portal origin. */
+export function withAbsoluteScreenshotUri(
+    item: StalkerVodSource,
+    portalUrl: string
+): StalkerVodSource {
+    const processed = { ...item };
+
+    if (processed.screenshot_uri) {
+        processed.screenshot_uri = makeAbsoluteUrl(
+            portalUrl,
+            processed.screenshot_uri
+        );
+    }
+
+    return processed;
+}
+
+function makeAbsoluteUrl(baseUrl: string, relativePath: string): string {
+    if (!relativePath) return '';
+    if (
+        relativePath.startsWith('http://') ||
+        relativePath.startsWith('https://')
+    ) {
+        return relativePath;
+    }
+    try {
+        const url = new URL(baseUrl);
+        const path = relativePath.startsWith('/')
+            ? relativePath
+            : `/${relativePath}`;
+        return `${url.origin}${path}`;
+    } catch {
+        return relativePath;
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.html b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.html
index 83fe416f2..45b3fe7bd 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.html
+++ b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.html
@@ -4,7 +4,7 @@
     [isLoading]="isInitialSearchLoading()"
     [showResultsCount]="true"
     [showSearchInput]="!isWorkspaceLayout"
-    [showBackButton]="isWorkspaceLayout"
+    [backAvailable]="isWorkspaceLayout"
     [showDetails]="showingDetails"
     [nearEndHasMore]="searchHasMore()"
     [nearEndAppending]="isAppendingSearchResults()"
diff --git a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.spec.ts b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.spec.ts
index 9bc96671b..f1e5bdec6 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.spec.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.spec.ts
@@ -429,12 +429,12 @@ describe('StalkerSearchComponent result paging', () => {
             ...searchItems('page1', 3),
             { id: 'shared', name: 'Shared item' },
         ];
-        component.applySearchPageSuccess(1, pageOne, 7);
+        component.paging.applySearchPageSuccess(1, pageOne, 7);
         expect(component.searchResults()).toHaveLength(4);
         expect(component.searchHasMore()).toBe(true);
 
         // The portal shifted `shared` between pages — it must not duplicate.
-        component.applySearchPageSuccess(
+        component.paging.applySearchPageSuccess(
             2,
             [...searchItems('page2', 2), { id: 'shared', name: 'Shared item' }],
             7
@@ -442,31 +442,46 @@ describe('StalkerSearchComponent result paging', () => {
         expect(component.searchResults()).toHaveLength(6);
         expect(component.searchHasMore()).toBe(true);
 
-        component.applySearchPageSuccess(3, searchItems('page3', 1), 7);
+        component.paging.applySearchPageSuccess(3, searchItems('page3', 1), 7);
         expect(component.searchResults()).toHaveLength(7);
         expect(component.searchHasMore()).toBe(false);
     });
 
     it('advances past a page made only of parental-locked rows, but not past a repeated one', async () => {
-        component.applySearchPageSuccess(1, searchItems('page1', 3), 10);
-        const pageBefore = component.searchPage();
+        component.paging.applySearchPageSuccess(1, searchItems('page1', 3), 10);
+        const pageBefore = component.paging.searchPage();
 
         // Locked rows the list had not seen: schedule the next page.
-        component.advancePastWithheldPage(pageBefore, 0, 2, () => true);
+        component.paging.advancePastWithheldPage(pageBefore, 0, 2, () => true);
         await flushMicrotasks();
-        expect(component.searchPage()).toBe(pageBefore + 1);
+        expect(component.paging.searchPage()).toBe(pageBefore + 1);
 
         // A page with visible rows, or one adding no new withheld ids, or a
         // request that is no longer current: stay put.
-        component.advancePastWithheldPage(pageBefore + 1, 1, 2, () => true);
-        component.advancePastWithheldPage(pageBefore + 1, 0, 0, () => true);
-        component.advancePastWithheldPage(pageBefore + 1, 0, 2, () => false);
+        component.paging.advancePastWithheldPage(
+            pageBefore + 1,
+            1,
+            2,
+            () => true
+        );
+        component.paging.advancePastWithheldPage(
+            pageBefore + 1,
+            0,
+            0,
+            () => true
+        );
+        component.paging.advancePastWithheldPage(
+            pageBefore + 1,
+            0,
+            2,
+            () => false
+        );
         await flushMicrotasks();
-        expect(component.searchPage()).toBe(pageBefore + 1);
+        expect(component.paging.searchPage()).toBe(pageBefore + 1);
     });
 
     it('drops withheld rows on screen at relock time, page 1 included', () => {
-        component.applySearchPageSuccess(
+        component.paging.applySearchPageSuccess(
             1,
             [
                 { id: 'news-1', name: 'News', category_id: '5' },
@@ -476,7 +491,7 @@ describe('StalkerSearchComponent result paging', () => {
         );
         expect(component.searchResults()).toHaveLength(2);
 
-        component.applyRelockToResults(new Set(['9']), 'vod');
+        component.paging.applyRelockToResults(new Set(['9']), 'vod');
 
         expect(component.searchResults().map((item) => item.id)).toEqual([
             'news-1',
@@ -509,46 +524,54 @@ describe('StalkerSearchComponent result paging', () => {
     });
 
     it('keeps paging past a page whose rows were all withheld by the parental lock', () => {
-        component.applySearchPageSuccess(1, searchItems('page1', 3), 10);
+        component.paging.applySearchPageSuccess(1, searchItems('page1', 3), 10);
         expect(component.searchHasMore()).toBe(true);
 
         // The portal sent rows, every one of them locked: no visible growth,
         // but not the end of the results either.
-        component.applySearchPageSuccess(2, [], 10, true);
+        component.paging.applySearchPageSuccess(2, [], 10, true);
         expect(component.searchResults()).toHaveLength(3);
         expect(component.searchHasMore()).toBe(true);
 
         // An actually empty page still ends it.
-        component.applySearchPageSuccess(3, [], 10, false);
+        component.paging.applySearchPageSuccess(3, [], 10, false);
         expect(component.searchHasMore()).toBe(false);
     });
 
     it('stops paging when a total-backed append makes no progress', () => {
-        component.applySearchPageSuccess(1, searchItems('page1', 3), 10);
+        component.paging.applySearchPageSuccess(1, searchItems('page1', 3), 10);
         expect(component.searchHasMore()).toBe(true);
 
         // The portal repeats page 1 under a larger claimed total — dedupe
         // yields no growth, which must still end the paging loop.
-        component.applySearchPageSuccess(2, searchItems('page1', 3), 10);
+        component.paging.applySearchPageSuccess(2, searchItems('page1', 3), 10);
         expect(component.searchResults()).toHaveLength(3);
         expect(component.searchHasMore()).toBe(false);
     });
 
     it('stops paging without a total once pages stop making progress', () => {
-        component.applySearchPageSuccess(1, searchItems('page1', 3), undefined);
+        component.paging.applySearchPageSuccess(
+            1,
+            searchItems('page1', 3),
+            undefined
+        );
         expect(component.searchHasMore()).toBe(true);
 
         // The portal ignores paging and repeats the same page — dedupe
         // yields no growth, which must terminate the loop.
-        component.applySearchPageSuccess(2, searchItems('page1', 3), undefined);
+        component.paging.applySearchPageSuccess(
+            2,
+            searchItems('page1', 3),
+            undefined
+        );
         expect(component.searchHasMore()).toBe(false);
     });
 
     it('keeps accumulated pages on a failed append and retries the SAME page', async () => {
-        component.applySearchPageSuccess(1, searchItems('page1', 3), 6);
+        component.paging.applySearchPageSuccess(1, searchItems('page1', 3), 6);
         expect(component.searchHasMore()).toBe(true);
 
-        component.applySearchPageFailure(2);
+        component.paging.applySearchPageFailure(2);
         // The failed append kept page 1 on screen and flagged the error.
         expect(component.searchResults()).toHaveLength(3);
         expect(component.searchAppendError()).toBe(true);
@@ -557,16 +580,16 @@ describe('StalkerSearchComponent result paging', () => {
         // The real resource never settles in this template-less harness —
         // substitute a deterministic stand-in for the guard checks.
         const reload = jest.fn(() => true);
-        Object.defineProperty(component, 'searchResultsResource', {
+        Object.defineProperty(component.paging, 'searchResultsResource', {
             configurable: true,
             value: { isLoading: () => false, reload },
         });
 
         // The next near-end must RETRY page 2 (page stays put, the error is
         // consumed) instead of advancing to page 3 and skipping results.
-        const pageBefore = component.searchPage();
+        const pageBefore = component.paging.searchPage();
         component.loadMoreSearchResults();
-        expect(component.searchPage()).toBe(pageBefore);
+        expect(component.paging.searchPage()).toBe(pageBefore);
         // Cleared synchronously, so a second near-end cannot re-enter the retry
         // while the connectivity-guard reset is still in flight.
         expect(component.searchAppendError()).toBe(false);
@@ -583,15 +606,15 @@ describe('StalkerSearchComponent result paging', () => {
 
         // With the error cleared, the following near-end advances normally.
         component.loadMoreSearchResults();
-        expect(component.searchPage()).toBe(pageBefore + 1);
+        expect(component.paging.searchPage()).toBe(pageBefore + 1);
         expect(reload).toHaveBeenCalledTimes(1);
     });
 
     it("clears the previous query's results when a fresh search fails", () => {
-        component.applySearchPageSuccess(1, searchItems('matrix', 3), 3);
+        component.paging.applySearchPageSuccess(1, searchItems('matrix', 3), 3);
         expect(component.searchResults()).toHaveLength(3);
 
-        component.applySearchPageFailure(1);
+        component.paging.applySearchPageFailure(1);
 
         expect(component.searchResults()).toHaveLength(0);
         expect(component.searchHasMore()).toBe(false);
@@ -644,11 +667,15 @@ describe('StalkerSearchComponent result paging', () => {
         // The loader calls this on every no-portal early return (deleted or
         // malformed playlist on a reused route, short term) so the previous
         // portal's cards cannot keep rendering under the new context.
-        component.applySearchPageSuccess(1, searchItems('portalA', 3), 6);
-        component.applySearchPageFailure(2);
+        component.paging.applySearchPageSuccess(
+            1,
+            searchItems('portalA', 3),
+            6
+        );
+        component.paging.applySearchPageFailure(2);
         expect(component.searchResults()).toHaveLength(3);
 
-        component.resetSearchAccumulator();
+        component.paging.resetSearchAccumulator();
 
         expect(component.searchResults()).toHaveLength(0);
         expect(component.searchHasMore()).toBe(false);
@@ -659,13 +686,17 @@ describe('StalkerSearchComponent result paging', () => {
         // Regression: /stalker/A/search -> /stalker/B/search reuses the
         // component; a surviving page number would append portal B's later
         // page onto portal A's results and skip B's first page.
-        Object.defineProperty(component, 'searchResultsResource', {
+        Object.defineProperty(component.paging, 'searchResultsResource', {
             configurable: true,
             value: { isLoading: () => false, reload: jest.fn(() => true) },
         });
-        component.applySearchPageSuccess(1, searchItems('portalA', 3), 6);
+        component.paging.applySearchPageSuccess(
+            1,
+            searchItems('portalA', 3),
+            6
+        );
         component.loadMoreSearchResults();
-        expect(component.searchPage()).toBe(2);
+        expect(component.paging.searchPage()).toBe(2);
 
         activePlaylist.set({
             _id: 'playlist|two',
@@ -674,7 +705,7 @@ describe('StalkerSearchComponent result paging', () => {
             macAddress: '00:1A:79:00:00:02',
         });
 
-        expect(component.searchPage()).toBe(1);
+        expect(component.paging.searchPage()).toBe(1);
         expect(component.searchScrollResetKey()).toContain('playlist|two');
     });
 });
diff --git a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.ts b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.ts
index 15fc9eaea..0c2a71fd6 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-search/stalker-search.component.ts
@@ -4,8 +4,6 @@ import {
     computed,
     effect,
     inject,
-    linkedSignal,
-    resource,
     signal,
     untracked,
     viewChild,
@@ -18,30 +16,24 @@ import { MatSnackBar } from '@angular/material/snack-bar';
 import { ActivatedRoute } from '@angular/router';
 import { TranslatePipe, TranslateService } from '@ngx-translate/core';
 import {
-    executeStalkerRequest,
     StalkerPortalRepairService,
     StalkerSessionService,
-    stalkerWithheldRowKey,
-    withoutWithheldStalkerItems,
 } from '@iptvnator/portal/stalker/data-access';
 import {
     DataService,
     ParentalLockService,
     PlaylistsService,
-    resetHostConnectivityGuard,
 } from '@iptvnator/services';
 import {
     ALL_CATEGORIES_WITHHELD,
     PlaybackPositionData,
     ResolvedPortalPlayback,
-    StalkerPortalActions,
     VodDetailsItem,
 } from '@iptvnator/shared/interfaces';
 import type { PlaybackFallbackRequest } from '@iptvnator/ui/playback';
 import { ContentCardComponent } from '@iptvnator/portal/shared/ui';
 import { SearchLayoutComponent } from '@iptvnator/portal/shared/ui';
 import { StalkerInlineDetailComponent } from '../stalker-inline-detail/stalker-inline-detail.component';
-import { StalkerContentTypes } from '@iptvnator/portal/stalker/data-access';
 import { StalkerStore } from '@iptvnator/portal/stalker/data-access';
 import { PlaylistContextFacade } from '@iptvnator/playlist/shared/util';
 import {
@@ -71,7 +63,8 @@ import {
 import { StalkerVodPlaybackController } from '../stalker-vod-playback-controller';
 import { createPlaybackSessionKey } from '@iptvnator/playback/util';
 import { createStalkerVodDetailActions } from '../stalker-vod-detail-actions';
-import { isStalkerSearchRequestCurrent } from './stalker-search-request.util';
+import { StalkerSearchPagingController } from './stalker-search-paging.controller';
+import type { StalkerSearchContentType } from './stalker-search-results.util';
 
 interface StalkerFilter {
     key: StalkerSearchContentType;
@@ -79,34 +72,6 @@ interface StalkerFilter {
     translationKey: string;
 }
 
-type StalkerSearchContentType = 'vod' | 'series';
-
-interface StalkerSearchResponse {
-    js?: {
-        data?: StalkerVodSource[];
-        total_items?: number;
-    };
-    message?: string;
-    status?: number;
-}
-
-/** Portals can shift items between pages mid-append — drop duplicate ids. */
-function dedupeSearchResults(items: StalkerVodSource[]): StalkerVodSource[] {
-    const seenIds = new Set<string>();
-    return items.filter((item) => {
-        const id =
-            item.id === undefined || item.id === null ? null : String(item.id);
-        if (id === null) {
-            return true;
-        }
-        if (seenIds.has(id)) {
-            return false;
-        }
-        seenIds.add(id);
-        return true;
-    });
-}
-
 @Component({
     selector: 'app-stalker-search',
     imports: [
@@ -127,15 +92,6 @@ export class StalkerSearchComponent {
     private readonly location = inject(Location);
     private readonly dataService = inject(DataService);
     private readonly parentalLock = inject(ParentalLockService);
-    /** Lock version the accumulated results were built under. */
-    private searchResultsLockVersion: number | null = null;
-    /**
-     * Withheld row ids seen for the current search identity. A page adding
-     * only new withheld ids is still progress and is skipped automatically;
-     * a page adding nothing new is the end of the results.
-     */
-    private searchWithheldKey = '';
-    private readonly searchWithheldIds = new Set<string>();
     private readonly playlistContext = inject(PlaylistContextFacade);
     private readonly playlistService = inject(PlaylistsService);
     readonly externalPlayback = inject(PORTAL_EXTERNAL_PLAYBACK);
@@ -235,309 +191,28 @@ export class StalkerSearchComponent {
         () => this.favoritesRefresh.refreshVersion()
     );
 
-    /**
-     * Portal page for the current term+filter+portal; resets when any of
-     * them changes. The playlist belongs to the identity: Angular reuses the
-     * search route across `/stalker/A/search` -> `/stalker/B/search`, and a
-     * surviving page number would append portal B's later page onto portal
-     * A's accumulated results while skipping B's first page.
-     */
-    readonly searchPage = linkedSignal({
-        source: () => ({
-            term: this.searchTerm(),
-            type: this.selectedFilterType(),
-            playlistId: this.currentPlaylist()?._id ?? null,
-        }),
-        computation: () => 1,
+    /** Result paging: the portal page, the accumulated list and its flags. */
+    readonly paging = new StalkerSearchPagingController({
+        searchTerm: this.searchTerm,
+        selectedFilterType: this.selectedFilterType,
+        currentPlaylist: this.currentPlaylist,
+        dataService: this.dataService,
+        parentalLock: this.parentalLock,
+        stalkerSession: this.stalkerSession,
+        portalRepair: this.portalRepair,
+        logger: this.logger,
+        closeWithheldDetail: (withheldCategoryIds) =>
+            this.closeWithheldDetail(withheldCategoryIds),
     });
-    /** Pages accumulated into one continuous, deduplicated result list. */
-    private readonly accumulatedSearchResults = signal<StalkerVodSource[]>([]);
-    readonly searchResults = this.accumulatedSearchResults.asReadonly();
-    readonly searchHasMore = signal(false);
-    /**
-     * A failed append page. The next near-end RETRIES that page instead of
-     * advancing — incrementing past it would silently omit its results.
-     */
-    readonly searchAppendError = signal(false);
-
-    readonly searchResultsResource = resource({
-        params: () => ({
-            contentType: this.selectedFilterType(),
-            search: this.searchTerm(),
-            page: this.searchPage(),
-            playlistId: this.currentPlaylist()?._id ?? null,
-            action: StalkerPortalActions.GetOrderedList,
-            // Lock/unlock re-fires the search: withheld rows are dropped at
-            // page time, so the results must be rebuilt when they change.
-            parentalLockVersion: this.parentalLock.version(),
-        }),
-        loader: async ({ params }) => {
-            if (params.search.length < 3) {
-                this.resetSearchAccumulator();
-                return [];
-            }
-            const playlist = this.currentPlaylist();
-            if (!playlist) {
-                // A reused route can land on a deleted/unresolved portal —
-                // the previous portal's cards must not keep rendering.
-                this.resetSearchAccumulator();
-                return [];
-            }
-            const { portalUrl, macAddress } = playlist;
-            if (!portalUrl || !macAddress) {
-                this.resetSearchAccumulator();
-                return [];
-            }
-            const contentType = params.contentType;
-            // The dedicated search route has no category guard, so it filters
-            // the portal's rows itself: a locked genre's title must not reach
-            // the grid, its detail or playback through search.
-            const withheldCategoryIds: ReadonlySet<string> =
-                !this.parentalLock.active()
-                    ? new Set<string>()
-                    : this.parentalLock.withholdsEverything?.()
-                      ? ALL_CATEGORIES_WITHHELD
-                      : new Set(
-                            this.parentalLock.lockedStalkerIds(
-                                playlist._id,
-                                contentType
-                            )
-                        );
-            const lockVersionChanged =
-                this.searchResultsLockVersion !== null &&
-                this.searchResultsLockVersion !== params.parentalLockVersion;
-            this.searchResultsLockVersion = params.parentalLockVersion;
-            if (lockVersionChanged) {
-                this.applyRelockToResults(withheldCategoryIds, contentType);
-            }
-            if (lockVersionChanged && params.page > 1) {
-                // A lock flip past page 1: rebuild from page 1 rather than
-                // appending to pages accumulated under the old lock state.
-                this.searchPage.set(1);
-                return this.accumulatedSearchResults();
-            }
-            const withheldKey = JSON.stringify([
-                params.playlistId,
-                contentType,
-                params.search,
-                params.parentalLockVersion,
-            ]);
-            if (params.page === 1 || this.searchWithheldKey !== withheldKey) {
-                this.searchWithheldKey = withheldKey;
-                this.searchWithheldIds.clear();
-            }
-
-            // Mirror the catalog request shape: many Ministra portals
-            // return an empty list for get_ordered_list without the
-            // category/genre/sortby params the STB client always sends.
-            // `max_page_items` is a HINT — plenty of portals ignore it and
-            // return their own page size, which is why paging cannot rely
-            // on it (progress and `total_items` decide hasMore instead).
-            const requestParams: Record<string, string | number> = {
-                action: StalkerContentTypes[contentType].getContentAction,
-                type: contentType,
-                sortby: 'added',
-                search: params.search,
-                p: params.page,
-                max_page_items: 100,
-                category: '*',
-                ...(contentType === 'vod' ? { genre: '0' } : {}),
-            };
-
-            // A stale response (term/filter/page/portal — or the parental
-            // lock — moved on while this page was in flight) must not clobber
-            // the accumulated list: the request is not aborted, and a
-            // pre-relock response was filtered with the pre-relock set.
-            const isCurrent = (): boolean =>
-                isStalkerSearchRequestCurrent(params, {
-                    search: this.searchTerm(),
-                    contentType: this.selectedFilterType(),
-                    page: this.searchPage(),
-                    playlistId: this.currentPlaylist()?._id ?? null,
-                    parentalLockVersion: this.parentalLock.version(),
-                });
-
-            try {
-                // executeStalkerRequest owns the portal-mode decision (shared
-                // predicate with URL fallback for legacy rows) and the lazy
-                // portal repair, so search cannot drift from the catalog
-                // paths.
-                const response =
-                    await executeStalkerRequest<StalkerSearchResponse>(
-                        {
-                            dataService: this.dataService,
-                            stalkerSession: this.stalkerSession,
-                            portalRepair: this.portalRepair,
-                        },
-                        playlist,
-                        requestParams
-                    );
-                const rawItems = (response.js?.data || []).map(
-                    (item: StalkerVodSource) =>
-                        this.processItemUrls(item, portalUrl)
-                );
-                const items = withoutWithheldStalkerItems(
-                    rawItems,
-                    contentType,
-                    withheldCategoryIds
-                );
-                // Before the withheld-id bookkeeping: a stale page must not
-                // pre-record ids into a set a newer relock request cleared,
-                // or that request's page counts no new withheld rows and
-                // stops paging short of later visible matches.
-                if (!isCurrent()) {
-                    return items;
-                }
-                let newWithheldCount = 0;
-                if (items.length < rawItems.length) {
-                    const kept = new Set(items);
-                    for (const item of rawItems) {
-                        const id = stalkerWithheldRowKey(item);
-                        if (
-                            !kept.has(item) &&
-                            !this.searchWithheldIds.has(id)
-                        ) {
-                            this.searchWithheldIds.add(id);
-                            newWithheldCount += 1;
-                        }
-                    }
-                }
-
-                const merged = this.applySearchPageSuccess(
-                    params.page,
-                    items,
-                    response.js?.total_items,
-                    // A page made only of withheld rows still is a page the
-                    // portal served; judge progress on what it sent.
-                    rawItems.length > 0 &&
-                        (items.length > 0 || newWithheldCount > 0)
-                );
-                this.advancePastWithheldPage(
-                    params.page,
-                    items.length,
-                    newWithheldCount,
-                    isCurrent
-                );
-                return merged;
-            } catch (error) {
-                this.logger.warn('Stalker search page failed', {
-                    page: params.page,
-                    error,
-                });
-                if (!isCurrent()) {
-                    return this.accumulatedSearchResults();
-                }
-
-                return this.applySearchPageFailure(params.page);
-            }
-        },
-    });
-
-    /**
-     * Empties the accumulator and every paging flag — used whenever there is
-     * no searchable portal (short term, missing playlist, malformed row).
-     */
-    resetSearchAccumulator(): void {
-        this.accumulatedSearchResults.set([]);
-        this.searchHasMore.set(false);
-        this.searchAppendError.set(false);
-    }
-
-    /** Merges a successful portal page into the accumulated result list. */
-    applySearchPageSuccess(
-        page: number,
-        items: StalkerVodSource[],
-        totalItems: number | undefined,
-        pageHadRows: boolean = items.length > 0
-    ): StalkerVodSource[] {
-        const previous = page === 1 ? [] : this.accumulatedSearchResults();
-        const merged =
-            page === 1 ? items : dedupeSearchResults([...previous, ...items]);
-        // Paging continues only while pages make progress — with OR without
-        // a reported total. Dedup after mid-list portal mutations can leave
-        // the unique list permanently shorter than total_items, and a
-        // repeated page dedupes to no growth; either way a no-progress
-        // append is the practical end of the results. A page whose rows were
-        // all withheld by the parental lock counts as progress too.
-        const withheldRows = pageHadRows && items.length === 0;
-        const madeProgress =
-            page === 1 || merged.length > previous.length || withheldRows;
-        this.searchHasMore.set(
-            madeProgress &&
-                (typeof totalItems === 'number' && totalItems >= 0
-                    ? merged.length < totalItems
-                    : pageHadRows)
-        );
-        this.searchAppendError.set(false);
-        this.accumulatedSearchResults.set(merged);
-        return merged;
-    }
-
-    /**
-     * A failed FRESH search (page 1) must not keep rendering the previous
-     * query's cards; a failed append keeps the accumulated pages and flags
-     * the error so the next near-end retries this page instead of advancing.
-     */
-    applySearchPageFailure(page: number): StalkerVodSource[] {
-        if (page === 1) {
-            this.accumulatedSearchResults.set([]);
-            this.searchHasMore.set(false);
-            this.searchAppendError.set(false);
-            return [];
-        }
-
-        this.searchAppendError.set(true);
-        return this.accumulatedSearchResults();
-    }
-
-    /**
-     * Result-set identity for the layout's near-end latch and auto-fill
-     * budget — term, filter, and portal, mirroring the paging identity.
-     */
-    readonly searchScrollResetKey = computed(() =>
-        [
-            this.searchTerm(),
-            this.selectedFilterType(),
-            this.currentPlaylist()?._id ?? '',
-        ].join('|')
-    );
-
-    readonly isInitialSearchLoading = computed(
-        () => this.searchResultsResource.isLoading() && this.searchPage() === 1
-    );
-    readonly isAppendingSearchResults = computed(
-        () => this.searchResultsResource.isLoading() && this.searchPage() > 1
-    );
+    readonly searchResults = this.paging.searchResults;
+    readonly searchHasMore = this.paging.searchHasMore;
+    readonly searchAppendError = this.paging.searchAppendError;
+    readonly searchScrollResetKey = this.paging.searchScrollResetKey;
+    readonly isInitialSearchLoading = this.paging.isInitialSearchLoading;
+    readonly isAppendingSearchResults = this.paging.isAppendingSearchResults;
 
     loadMoreSearchResults(): void {
-        if (this.searchResultsResource.isLoading() || !this.searchHasMore()) {
-            return;
-        }
-
-        if (this.searchAppendError()) {
-            // Retry the SAME page — advancing would permanently omit it.
-            void this.retrySearchPage();
-            return;
-        }
-
-        this.searchPage.update((page) => page + 1);
-    }
-
-    /**
-     * Two failed search pages are exactly what opens the main process'
-     * connectivity guard, so the reset has to precede the reload — otherwise
-     * this retry fast-fails without contacting a portal that may have
-     * recovered, and keeps repeating the same error until the window expires.
-     */
-    private async retrySearchPage(): Promise<void> {
-        // Clear the flag synchronously: awaiting first would leave this branch
-        // re-enterable, and the next `nearEnd` event would fire a second retry.
-        this.searchAppendError.set(false);
-        await resetHostConnectivityGuard(
-            this.dataService,
-            this.currentPlaylist()?.portalUrl
-        );
-        this.searchResultsResource.reload();
+        this.paging.loadMoreSearchResults();
     }
 
     readonly isSelectedVodFavorite = signal<boolean>(false);
@@ -713,59 +388,11 @@ export class StalkerSearchComponent {
         });
     }
 
-    /**
-     * The infinite scroll gives up after a few loads that add no height, so
-     * a run of pages made only of parental-locked rows must advance by
-     * itself until a visible row (or the real end) is reached. Only a page
-     * that added withheld ids not seen before counts — a stalled portal
-     * repeating the same locked rows must still end the loop.
-     */
-    advancePastWithheldPage(
-        page: number,
-        visibleCount: number,
-        newWithheldCount: number,
-        isCurrent: () => boolean
-    ): void {
-        if (
-            visibleCount > 0 ||
-            newWithheldCount === 0 ||
-            !this.searchHasMore()
-        ) {
-            return;
-        }
-        queueMicrotask(() => {
-            if (isCurrent()) {
-                this.searchPage.set(page + 1);
-            }
-        });
-    }
-
     /**
      * Closes the open detail when its genre is withheld by the parental
      * lock (Lock now, idle relock): the title, its playback actions and the
      * store's selected item must not outlive the list row.
      */
-    /**
-     * A lock change reached the results on screen, which were read under
-     * the old lock state: close an open detail of a now-withheld genre (the
-     * list hiding it is not enough) and drop the withheld rows NOW, before
-     * the replacement page is awaited — on page 1 too, or they stay
-     * clickable while (or, if it hangs, after) that request is pending.
-     */
-    applyRelockToResults(
-        withheldCategoryIds: ReadonlySet<string>,
-        contentType: Parameters<typeof withoutWithheldStalkerItems>[1]
-    ): void {
-        this.closeWithheldDetail(withheldCategoryIds);
-        this.accumulatedSearchResults.set(
-            withoutWithheldStalkerItems(
-                this.accumulatedSearchResults(),
-                contentType,
-                withheldCategoryIds
-            )
-        );
-    }
-
     closeWithheldDetail(withheldCategoryIds: ReadonlySet<string>): void {
         const details = this.itemDetails();
         if (!details) {
@@ -871,41 +498,6 @@ export class StalkerSearchComponent {
         );
     }
 
-    private processItemUrls(
-        item: StalkerVodSource,
-        portalUrl: string
-    ): StalkerVodSource {
-        const processed = { ...item };
-
-        if (processed.screenshot_uri) {
-            processed.screenshot_uri = this.makeAbsoluteUrl(
-                portalUrl,
-                processed.screenshot_uri
-            );
-        }
-
-        return processed;
-    }
-
-    private makeAbsoluteUrl(baseUrl: string, relativePath: string): string {
-        if (!relativePath) return '';
-        if (
-            relativePath.startsWith('http://') ||
-            relativePath.startsWith('https://')
-        ) {
-            return relativePath;
-        }
-        try {
-            const url = new URL(baseUrl);
-            const path = relativePath.startsWith('/')
-                ? relativePath
-                : `/${relativePath}`;
-            return `${url.origin}${path}`;
-        } catch {
-            return relativePath;
-        }
-    }
-
     readonly vodDetailActions = createStalkerVodDetailActions({
         resolvePlayback: (cmd, title, thumbnail, startTime) =>
             this.stalkerStore.resolveVodPlayback(
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-id.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-id.ts
new file mode 100644
index 000000000..877482424
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-id.ts
@@ -0,0 +1,12 @@
+/**
+ * The numeric series id of a Stalker item id: the part before the first `:`
+ * when the id carries a suffix. An empty or non-numeric id resolves to 0,
+ * which callers treat as "no series".
+ */
+export function toStalkerSeriesId(id: string | number): number {
+    const raw = String(id ?? '').trim();
+    if (!raw) return 0;
+    const primary = raw.includes(':') ? raw.split(':')[0] : raw;
+    const parsed = Number(primary);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-position-queue.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-position-queue.ts
new file mode 100644
index 000000000..2a30fc75b
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-position-queue.ts
@@ -0,0 +1,187 @@
+import type { PlaybackPositionData } from '@iptvnator/shared/interfaces';
+
+/** The playlist and series one generation of position reads and writes belongs to. */
+export interface StalkerSeriesPositionContext {
+    readonly generation: number;
+    readonly playlistId: string;
+    readonly seriesXtreamId: number;
+    readonly mutationKey: string;
+}
+
+/** What the queue needs from the owner of the position rows. */
+export interface StalkerSeriesPositionQueueHost {
+    /** Whether the page still shows the playlist and series of `context`. */
+    readonly isShown: (context: StalkerSeriesPositionContext) => boolean;
+    /** Reads the persisted position rows of `context`. */
+    readonly read: (
+        context: StalkerSeriesPositionContext
+    ) => Promise<PlaybackPositionData[]>;
+    /** Takes over rows read for a context that is still the active one. */
+    readonly publish: (
+        context: StalkerSeriesPositionContext,
+        positions: PlaybackPositionData[]
+    ) => void;
+}
+
+/**
+ * Orders the position reads and writes of the Stalker series view. Writes of
+ * one playlist/series run one after another; a read waits for the writes
+ * queued before it, and its answer is dropped once a newer read or write
+ * started or the page moved on to another series. A write that overtakes a
+ * read still in flight re-reads the rows after the queue drained.
+ */
+export class StalkerSeriesPositionQueue {
+    private activeContext: StalkerSeriesPositionContext | null = null;
+    private contextGeneration = 0;
+    private readonly mutationQueues = new Map<string, Promise<void>>();
+    private readonly pendingLoads = new Map<
+        StalkerSeriesPositionContext,
+        Set<number>
+    >();
+    private readonly reloadKeys = new Set<string>();
+    private loadGeneration = 0;
+
+    constructor(private readonly host: StalkerSeriesPositionQueueHost) {}
+
+    /** Makes `playlistId`/`seriesXtreamId` the series reads and writes apply to. */
+    activate(
+        playlistId: string,
+        seriesXtreamId: number
+    ): StalkerSeriesPositionContext {
+        const context: StalkerSeriesPositionContext = {
+            generation: ++this.contextGeneration,
+            playlistId,
+            seriesXtreamId,
+            mutationKey: JSON.stringify([playlistId, seriesXtreamId]),
+        };
+        this.activeContext = context;
+        return context;
+    }
+
+    /** No series is shown: retires the active context and every read in flight. */
+    deactivate(): void {
+        this.activeContext = null;
+        this.contextGeneration++;
+        this.loadGeneration++;
+    }
+
+    isActive(context: StalkerSeriesPositionContext): boolean {
+        const activeContext = this.activeContext;
+        return (
+            activeContext === context &&
+            activeContext.generation === context.generation &&
+            this.host.isShown(context)
+        );
+    }
+
+    /** The active context when it belongs to `playlistId` (and `seriesXtreamId`, if given). */
+    mutationContext(
+        playlistId: string,
+        seriesXtreamId?: number | null
+    ): StalkerSeriesPositionContext | null {
+        const context = this.activeContext;
+        if (
+            !context ||
+            context.playlistId !== playlistId ||
+            (seriesXtreamId != null &&
+                context.seriesXtreamId !== seriesXtreamId)
+        ) {
+            return null;
+        }
+        return context;
+    }
+
+    async load(context: StalkerSeriesPositionContext): Promise<void> {
+        const generation = ++this.loadGeneration;
+        this.trackPendingLoad(context, generation);
+        try {
+            await this.waitForMutations(context.mutationKey);
+
+            if (generation !== this.loadGeneration || !this.isActive(context)) {
+                return;
+            }
+
+            const positions = await this.host.read(context);
+
+            if (generation !== this.loadGeneration || !this.isActive(context)) {
+                return;
+            }
+
+            this.host.publish(context, positions);
+        } finally {
+            this.untrackPendingLoad(context, generation);
+        }
+    }
+
+    enqueue(
+        context: StalkerSeriesPositionContext,
+        operation: () => Promise<void>
+    ): Promise<void> {
+        if (this.hasCurrentPendingLoad(context)) {
+            this.reloadKeys.add(context.mutationKey);
+        }
+        this.loadGeneration++;
+        const previous = this.waitForMutations(context.mutationKey);
+        const result = previous.then(operation);
+        const barrier = result.then(
+            () => undefined,
+            () => undefined
+        );
+        this.mutationQueues.set(context.mutationKey, barrier);
+        void barrier.then(() => {
+            if (this.mutationQueues.get(context.mutationKey) === barrier) {
+                this.mutationQueues.delete(context.mutationKey);
+                this.reloadAfterMutations(context.mutationKey);
+            }
+        });
+        return result;
+    }
+
+    private waitForMutations(mutationKey: string): Promise<void> {
+        return this.mutationQueues.get(mutationKey) ?? Promise.resolve();
+    }
+
+    private trackPendingLoad(
+        context: StalkerSeriesPositionContext,
+        generation: number
+    ): void {
+        const generations = this.pendingLoads.get(context) ?? new Set<number>();
+        generations.add(generation);
+        this.pendingLoads.set(context, generations);
+    }
+
+    private untrackPendingLoad(
+        context: StalkerSeriesPositionContext,
+        generation: number
+    ): void {
+        const generations = this.pendingLoads.get(context);
+        generations?.delete(generation);
+        if (generations?.size === 0) {
+            this.pendingLoads.delete(context);
+        }
+    }
+
+    private hasCurrentPendingLoad(
+        context: StalkerSeriesPositionContext
+    ): boolean {
+        return Boolean(
+            this.pendingLoads.get(context)?.has(this.loadGeneration)
+        );
+    }
+
+    private reloadAfterMutations(mutationKey: string): void {
+        if (!this.reloadKeys.delete(mutationKey)) {
+            return;
+        }
+        const context = this.activeContext;
+        if (
+            !context ||
+            context.mutationKey !== mutationKey ||
+            !this.isActive(context) ||
+            this.hasCurrentPendingLoad(context)
+        ) {
+            return;
+        }
+        void this.load(context);
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-positions.service.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-positions.service.ts
new file mode 100644
index 000000000..ee3004f93
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-positions.service.ts
@@ -0,0 +1,331 @@
+import { Injectable, Signal, inject, signal, untracked } from '@angular/core';
+import {
+    PORTAL_PLAYBACK_POSITIONS,
+    createLogger,
+} from '@iptvnator/portal/shared/util';
+import {
+    StalkerStore,
+    type StalkerSelectedVodItem,
+} from '@iptvnator/portal/stalker/data-access';
+import type {
+    PlaybackPositionData,
+    XtreamSerieEpisode,
+} from '@iptvnator/shared/interfaces';
+import { toStalkerSeriesId } from './stalker-series-id';
+import {
+    clearStalkerSeriesPosition,
+    reconcileStalkerSeriesPositions,
+    saveStalkerSeriesPosition,
+    StalkerSeriesPositionPartialSaveError,
+} from './stalker-series-position-compatibility';
+import { StalkerSeriesPositionQueue } from './stalker-series-position-queue';
+
+interface StalkerSeriesPositionsBindings {
+    readonly displayItem: Signal<StalkerSelectedVodItem | null>;
+    readonly mappedSeasons: Signal<Record<string, XtreamSerieEpisode[]>>;
+}
+
+/**
+ * Saved episode positions of the series the Stalker series view shows: the
+ * rows read from the repository, their mapping onto the episodes on the page
+ * (scoped rows plus compatible legacy promotions) and the writes that keep
+ * both in step. Component-scoped (provide it in the component's `providers`).
+ */
+@Injectable()
+export class StalkerSeriesPositionsService {
+    private readonly stalkerStore = inject(StalkerStore);
+    private readonly playbackPositions = inject(PORTAL_PLAYBACK_POSITIONS);
+    private readonly migrationPlaybackPositions = {
+        savePlaybackPosition: (
+            playlistId: string,
+            data: PlaybackPositionData
+        ) =>
+            this.playbackPositions.savePlaybackPositionOrThrow(
+                playlistId,
+                data
+            ),
+        clearPlaybackPosition: (
+            playlistId: string,
+            contentXtreamId: number,
+            contentType: 'vod' | 'episode'
+        ) =>
+            this.playbackPositions.clearPlaybackPositionOrThrow(
+                playlistId,
+                contentXtreamId,
+                contentType
+            ),
+    };
+    private readonly logger = createLogger('StalkerSeriesView');
+    private readonly bindings = signal<StalkerSeriesPositionsBindings | null>(
+        null
+    );
+    readonly episodePlaybackPositions = signal<
+        Map<number, PlaybackPositionData>
+    >(new Map());
+    readonly rawSeriesPositions = signal<readonly PlaybackPositionData[]>([]);
+    /**
+     * `playlistId:seriesId` once the persisted positions for the shown
+     * series have been READ (a failed read leaves it null): the dashboard
+     * resume handoff must not start an episode from the beginning because
+     * the offsets have not arrived yet.
+     */
+    readonly seriesPositionsLoadedKey = signal<string | null>(null);
+    private readonly legacyPositionByTrackingId = signal<
+        Map<number, PlaybackPositionData>
+    >(new Map());
+    private readonly queue = new StalkerSeriesPositionQueue({
+        isShown: (context) =>
+            this.stalkerStore.currentPlaylist()?._id === context.playlistId &&
+            this.shownSeriesId() === context.seriesXtreamId,
+        read: (context) =>
+            this.playbackPositions.getSeriesPlaybackPositions(
+                context.playlistId,
+                context.seriesXtreamId
+            ),
+        publish: (context, positions) => {
+            this.rawSeriesPositions.set(positions);
+            this.seriesPositionsLoadedKey.set(
+                this.seriesPositionsKey(
+                    context.playlistId,
+                    context.seriesXtreamId
+                )
+            );
+        },
+    });
+
+    bind(bindings: StalkerSeriesPositionsBindings): void {
+        this.bindings.set(bindings);
+    }
+
+    /**
+     * Starts over for the series on screen: drops what the previous series
+     * left behind and reads the persisted rows. Reads the shown item and the
+     * playlist, so an `effect` calling it re-runs when either changes.
+     */
+    loadShownSeries(): void {
+        const item = this.displayItem();
+        const playlist = this.stalkerStore.currentPlaylist();
+        const normalizedSeriesId = toStalkerSeriesId(item?.id ?? 0);
+        if (item && playlist?._id && normalizedSeriesId > 0) {
+            this.logger.debug('Loading positions for series', {
+                id: item.id,
+                seriesId: normalizedSeriesId,
+                isSeries: item.is_series,
+            });
+            this.rawSeriesPositions.set([]);
+            this.seriesPositionsLoadedKey.set(null);
+            this.episodePlaybackPositions.set(new Map());
+            this.legacyPositionByTrackingId.set(new Map());
+            const context = this.queue.activate(
+                playlist._id,
+                normalizedSeriesId
+            );
+            void this.queue.load(context);
+        } else {
+            this.queue.deactivate();
+        }
+    }
+
+    /**
+     * Maps the raw series position rows onto the currently mapped episodes
+     * (scoped rows plus compatible legacy promotions). Runs reactively from
+     * the component's constructor effect, and synchronously from the
+     * series-level watch toggle right after it hydrates lazy seasons — the
+     * effect only re-runs on the next change-detection tick, and enqueuing
+     * the batch against the stale maps would miss the hydrated episodes'
+     * legacy rows (an unwatch would leave rows behind that a later reconcile
+     * resurrects as watched).
+     */
+    applyReconciledSeriesPositions(): void {
+        const item = this.displayItem();
+        const playlistId = this.stalkerStore.currentPlaylist()?._id;
+        const seriesXtreamId = toStalkerSeriesId(item?.id ?? 0);
+        const rawSeriesPositions = this.rawSeriesPositions();
+        const episodesBySeason = this.bindings()?.mappedSeasons() ?? {};
+
+        if (!item || !playlistId || seriesXtreamId <= 0) {
+            if (rawSeriesPositions.length > 0) {
+                this.rawSeriesPositions.set([]);
+            }
+            if (this.episodePlaybackPositions().size > 0) {
+                this.episodePlaybackPositions.set(new Map());
+            }
+            if (this.legacyPositionByTrackingId().size > 0) {
+                this.legacyPositionByTrackingId.set(new Map());
+            }
+            return;
+        }
+
+        const reconciled = reconcileStalkerSeriesPositions({
+            seriesXtreamId,
+            episodesBySeason,
+            seriesPositions: rawSeriesPositions,
+        });
+        if (
+            rawSeriesPositions.length === 0 &&
+            reconciled.positionsByTrackingId.size === 0 &&
+            untracked(() => this.episodePlaybackPositions().size) > 0
+        ) {
+            return;
+        }
+        this.episodePlaybackPositions.set(reconciled.positionsByTrackingId);
+        this.legacyPositionByTrackingId.set(
+            reconciled.legacyPositionByTrackingId
+        );
+    }
+
+    seriesPositionsKey(playlistId: string, seriesXtreamId: number): string {
+        return `${playlistId}:${seriesXtreamId}`;
+    }
+
+    persistSeriesPosition(
+        playlistId: string,
+        position: PlaybackPositionData
+    ): Promise<void> {
+        const context = this.queue.mutationContext(
+            playlistId,
+            position.seriesXtreamId
+        );
+        if (!context) {
+            return Promise.resolve();
+        }
+        const legacyPosition = this.legacyPositionByTrackingId().get(
+            position.contentXtreamId
+        );
+        return this.queue.enqueue(context, async () => {
+            let clearedLegacy: boolean;
+            try {
+                clearedLegacy = await saveStalkerSeriesPosition({
+                    repository: this.migrationPlaybackPositions,
+                    playlistId,
+                    position,
+                    legacyPosition,
+                });
+            } catch (error) {
+                if (
+                    error instanceof StalkerSeriesPositionPartialSaveError &&
+                    this.queue.isActive(context)
+                ) {
+                    this.publishSavedSeriesPosition(
+                        position,
+                        legacyPosition,
+                        false
+                    );
+                }
+                throw error;
+            }
+            if (!this.queue.isActive(context)) {
+                return;
+            }
+            this.publishSavedSeriesPosition(
+                position,
+                legacyPosition,
+                clearedLegacy
+            );
+        });
+    }
+
+    clearSeriesPosition(
+        playlistId: string,
+        contentXtreamId: number
+    ): Promise<void> {
+        const context = this.queue.mutationContext(playlistId);
+        if (!context) {
+            return Promise.resolve();
+        }
+        const position = this.episodePlaybackPositions().get(
+            contentXtreamId
+        ) ?? {
+            contentXtreamId,
+            contentType: 'episode',
+            positionSeconds: 0,
+            playlistId,
+            seriesXtreamId: context.seriesXtreamId,
+        };
+        const legacyPosition =
+            this.legacyPositionByTrackingId().get(contentXtreamId);
+        return this.queue.enqueue(context, async () => {
+            const clearedLegacy = await clearStalkerSeriesPosition({
+                repository: this.migrationPlaybackPositions,
+                playlistId,
+                position,
+                legacyPosition,
+            });
+            if (!this.queue.isActive(context)) {
+                return;
+            }
+            this.publishClearedSeriesPosition(
+                contentXtreamId,
+                legacyPosition,
+                clearedLegacy
+            );
+        });
+    }
+
+    private displayItem(): StalkerSelectedVodItem | null {
+        return this.bindings()?.displayItem() ?? null;
+    }
+
+    private shownSeriesId(): number {
+        return toStalkerSeriesId(this.displayItem()?.id ?? 0);
+    }
+
+    private publishSavedSeriesPosition(
+        position: PlaybackPositionData,
+        legacyPosition: PlaybackPositionData | undefined,
+        clearedLegacy: boolean
+    ): void {
+        const removedTrackingIds = new Set([position.contentXtreamId]);
+        if (clearedLegacy && legacyPosition) {
+            removedTrackingIds.add(legacyPosition.contentXtreamId);
+            const legacyPositions = new Map(this.legacyPositionByTrackingId());
+            legacyPositions.delete(position.contentXtreamId);
+            this.legacyPositionByTrackingId.set(legacyPositions);
+        }
+
+        this.rawSeriesPositions.set([
+            ...this.rawSeriesPositions().filter(
+                (candidate) =>
+                    !removedTrackingIds.has(candidate.contentXtreamId)
+            ),
+            position,
+        ]);
+        this.updateEpisodePlaybackPosition(position);
+    }
+
+    private publishClearedSeriesPosition(
+        contentXtreamId: number,
+        legacyPosition: PlaybackPositionData | undefined,
+        clearedLegacy: boolean
+    ): void {
+        const removedTrackingIds = new Set([contentXtreamId]);
+        if (clearedLegacy && legacyPosition) {
+            removedTrackingIds.add(legacyPosition.contentXtreamId);
+            const legacyPositions = new Map(this.legacyPositionByTrackingId());
+            legacyPositions.delete(contentXtreamId);
+            this.legacyPositionByTrackingId.set(legacyPositions);
+        }
+
+        this.rawSeriesPositions.set(
+            this.rawSeriesPositions().filter(
+                (candidate) =>
+                    !removedTrackingIds.has(candidate.contentXtreamId)
+            )
+        );
+        this.removeEpisodePlaybackPosition(contentXtreamId);
+    }
+
+    private updateEpisodePlaybackPosition(
+        position: PlaybackPositionData
+    ): void {
+        const updated = new Map(this.episodePlaybackPositions());
+        updated.set(position.contentXtreamId, position);
+        this.episodePlaybackPositions.set(updated);
+    }
+
+    private removeEpisodePlaybackPosition(contentXtreamId: number): void {
+        const updated = new Map(this.episodePlaybackPositions());
+        updated.delete(contentXtreamId);
+        this.episodePlaybackPositions.set(updated);
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.spec.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.spec.ts
index d6937ca07..e27488ffc 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.spec.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.spec.ts
@@ -1,54 +1,30 @@
-import { signal } from '@angular/core';
-import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ComponentFixture } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
-import { Router } from '@angular/router';
-import { MatSnackBar } from '@angular/material/snack-bar';
-import { TranslatePipe, TranslateService } from '@ngx-translate/core';
-import { MockPipe } from 'ng-mocks';
-import { SeasonContainerComponent } from '@iptvnator/ui/components';
-import {
-    PORTAL_EXTERNAL_PLAYBACK,
-    PORTAL_PLAYBACK_POSITIONS,
-    PORTAL_PLAYER,
-} from '@iptvnator/portal/shared/util';
-import {
-    StalkerStore,
-    StalkerVodSource,
-} from '@iptvnator/portal/stalker/data-access';
 import { PlaybackPositionData } from '@iptvnator/shared/interfaces';
-import { PortalInlinePlayerComponent } from '@iptvnator/ui/playback';
-import { TmdbEnrichmentService } from '@iptvnator/services';
-import { EMPTY, of } from 'rxjs';
-import { FavoritesButtonComponent } from '../stalker-favorites-button/stalker-favorites-button.component';
 import { StalkerSeriesViewComponent } from './stalker-series-view.component';
+import { createStalkerSeriesViewHarness } from './stalker-series-view.test-harness';
 
 import {
-    StubFavoritesButtonComponent,
     StubPortalInlinePlayerComponent,
     StubSeasonContainerComponent,
 } from './stalker-series-view.test-helpers';
 
 describe('StalkerSeriesViewComponent', () => {
     let fixture: ComponentFixture<StalkerSeriesViewComponent>;
-    const selectedContentType = signal<'series' | 'vod'>('series');
-    const selectedItem = signal<StalkerVodSource | null>(null);
-    const serialSeasonsResource = signal<unknown[]>([]);
-    const vodSeriesSeasonsResource = signal<unknown[]>([]);
-    const isSerialSeasonsLoading = signal(false);
-    const fetchVodSeriesEpisodes = jest.fn();
-    const resolveVodPlayback = jest.fn();
-    const getSeriesPlaybackPositions = jest.fn().mockResolvedValue([]);
-    const openResolvedPlayback = jest.fn();
-    const openExternalPlayback = jest.fn();
-    const isEmbeddedPlayer = jest.fn();
-    const tmdbGetSeason = jest.fn();
-    const fetchLinkToPlay = jest.fn();
-    const currentPlaylist = signal({
-        _id: 'stalker-1',
-        title: 'Living Room Portal',
-        portalUrl: 'https://stalker.example.test',
-        macAddress: '00:1A:79:12:34:56',
-    });
+    const {
+        selectedContentType,
+        selectedItem,
+        serialSeasonsResource,
+        vodSeriesSeasonsResource,
+        fetchVodSeriesEpisodes,
+        resolveVodPlayback,
+        openResolvedPlayback,
+        openExternalPlayback,
+        isEmbeddedPlayer,
+        fetchLinkToPlay,
+        currentPlaylist,
+        createFixture,
+    } = createStalkerSeriesViewHarness(() => jest.fn());
 
     async function stabilize(): Promise<void> {
         fixture.detectChanges();
@@ -63,184 +39,7 @@ describe('StalkerSeriesViewComponent', () => {
     }
 
     beforeEach(async () => {
-        selectedContentType.set('series');
-        selectedItem.set({
-            id: '30001',
-            cmd: '/media/file_30001.mpg',
-            info: {
-                name: 'Regular Series',
-                description: 'Series description',
-                movie_image: 'poster.jpg',
-            },
-        });
-        serialSeasonsResource.set([
-            {
-                id: 'season-1',
-                name: 'Season 1',
-                cmd: '/media/file_30001.mpg',
-                series: [1, 2],
-            },
-        ]);
-        vodSeriesSeasonsResource.set([]);
-        isSerialSeasonsLoading.set(false);
-        fetchVodSeriesEpisodes.mockReset();
-        resolveVodPlayback.mockReset();
-        resolveVodPlayback.mockImplementation(
-            async (
-                _cmd?: string,
-                title?: string,
-                thumbnail?: string,
-                _episodeNum?: number,
-                episodeId?: number,
-                startTime?: number
-            ) => ({
-                streamUrl: 'http://stalker.example/episode.mpg',
-                title: title ?? 'Regular Series',
-                thumbnail: thumbnail ?? 'poster.jpg',
-                startTime,
-                contentInfo: {
-                    playlistId: 'stalker-1',
-                    contentXtreamId:
-                        episodeId ?? Number(selectedItem()?.id ?? 0),
-                    contentType: episodeId ? 'episode' : 'vod',
-                    seriesXtreamId: episodeId
-                        ? Number(selectedItem()?.id ?? 0)
-                        : undefined,
-                },
-            })
-        );
-        getSeriesPlaybackPositions.mockClear();
-        getSeriesPlaybackPositions.mockResolvedValue([]);
-        openResolvedPlayback.mockClear();
-        openExternalPlayback.mockReset();
-        isEmbeddedPlayer.mockReset();
-        isEmbeddedPlayer.mockReturnValue(false);
-        tmdbGetSeason.mockReset();
-        tmdbGetSeason.mockResolvedValue({
-            overview: 'Season overview from TMDB',
-            episodes: [],
-        });
-        fetchLinkToPlay
-            .mockReset()
-            .mockResolvedValue('https://cdn.example.test/episode.mpg');
-        currentPlaylist.set({
-            _id: 'stalker-1',
-            title: 'Living Room Portal',
-            portalUrl: 'https://stalker.example.test',
-            macAddress: '00:1A:79:12:34:56',
-        });
-
-        await TestBed.configureTestingModule({
-            imports: [StalkerSeriesViewComponent],
-            providers: [
-                {
-                    provide: StalkerStore,
-                    useValue: {
-                        selectedItem,
-                        selectedContentType,
-                        currentPlaylist,
-                        getSerialSeasonsResource: () => serialSeasonsResource(),
-                        getVodSeriesSeasonsResource: () =>
-                            vodSeriesSeasonsResource(),
-                        isVodSeriesSeasonsLoading: signal(false),
-                        isSerialSeasonsLoading,
-                        fetchVodSeriesEpisodes,
-                        resolveVodPlayback,
-                        fetchLinkToPlay,
-                    },
-                },
-                {
-                    provide: PORTAL_EXTERNAL_PLAYBACK,
-                    useValue: {
-                        activeSession: signal(null),
-                    },
-                },
-                {
-                    provide: PORTAL_PLAYBACK_POSITIONS,
-                    useValue: {
-                        getSeriesPlaybackPositions,
-                        savePlaybackPosition: jest.fn(),
-                        clearPlaybackPosition: jest.fn(),
-                    },
-                },
-                {
-                    provide: PORTAL_PLAYER,
-                    useValue: {
-                        isEmbeddedPlayer,
-                        openResolvedPlayback,
-                        openExternalPlayback,
-                    },
-                },
-                {
-                    provide: Router,
-                    useValue: {
-                        navigateByUrl: jest.fn(),
-                    },
-                },
-                {
-                    provide: TmdbEnrichmentService,
-                    useValue: {
-                        isEnabled: () => true,
-                        getSeason: tmdbGetSeason,
-                    },
-                },
-                {
-                    provide: MatSnackBar,
-                    useValue: {
-                        open: jest.fn(),
-                    },
-                },
-                {
-                    provide: TranslateService,
-                    useValue: {
-                        instant: (key: string) => key,
-                        get: (key: string) => of(key),
-                        stream: (key: string) => of(key),
-                        currentLang: 'en',
-                        defaultLang: 'en',
-                        // EMPTY (not of(null)): the real TranslatePipe inside
-                        // the detail shell reads `event.lang` from emissions.
-                        onLangChange: EMPTY,
-                        onTranslationChange: EMPTY,
-                        onDefaultLangChange: EMPTY,
-                    },
-                },
-            ],
-        })
-            .overrideComponent(StalkerSeriesViewComponent, {
-                remove: {
-                    imports: [
-                        FavoritesButtonComponent,
-                        PortalInlinePlayerComponent,
-                        SeasonContainerComponent,
-                        TranslatePipe,
-                    ],
-                },
-                add: {
-                    imports: [
-                        StubFavoritesButtonComponent,
-                        StubPortalInlinePlayerComponent,
-                        StubSeasonContainerComponent,
-                        MockPipe(
-                            TranslatePipe,
-                            (
-                                value: string | null | undefined,
-                                params?: Record<string, number>
-                            ) => {
-                                if (value === 'XTREAM.PLAY_EPISODE') {
-                                    return `Play episode ${
-                                        params?.['episode'] ?? '{{episode}}'
-                                    }`;
-                                }
-                                return value ?? '';
-                            }
-                        ),
-                    ],
-                },
-            })
-            .compileComponents();
-
-        fixture = TestBed.createComponent(StalkerSeriesViewComponent);
+        fixture = await createFixture();
     });
 
     afterEach(() => {
@@ -783,10 +582,12 @@ describe('StalkerSeriesViewComponent', () => {
                 }),
             })
         );
-        // Prettier expands these compact fixtures enough to breach the spec's
-        // hard 1,200-line lint limit.
-        // prettier-ignore
-        expect(inlinePlayer.episodeMetadata()).toEqual({ label: 'S01E01', title: 'Pilot', seasonNumber: 1, episodeNumber: 1 });
+        expect(inlinePlayer.episodeMetadata()).toEqual({
+            label: 'S01E01',
+            title: 'Pilot',
+            seasonNumber: 1,
+            episodeNumber: 1,
+        });
         expect(inlinePlayer.seriesNavigation()).toEqual({
             canPrevious: false,
             canNext: true,
@@ -834,251 +635,6 @@ describe('StalkerSeriesViewComponent', () => {
         );
     });
 
-    it('prefetches the next unopened season so the Up Next rail can spill over', async () => {
-        selectedContentType.set('vod');
-        selectedItem.set({
-            id: '50001',
-            is_series: true,
-            info: {
-                name: 'VOD Flagged Series',
-                description: 'Lazy seasons',
-                movie_image: 'vod-series.jpg',
-            },
-        });
-        serialSeasonsResource.set([]);
-        vodSeriesSeasonsResource.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-            },
-        ]);
-        isEmbeddedPlayer.mockReturnValue(true);
-
-        await stabilize();
-
-        // Season 1 loaded, season 2 still empty — the state a user is in
-        // right after opening the series and starting the first episode.
-        fixture.componentInstance.vodSeriesSeasons.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-                episodes: [
-                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
-                ],
-                isLoading: false,
-                isExpanded: false,
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-                episodes: [],
-                isLoading: false,
-                isExpanded: false,
-            },
-        ]);
-        fetchVodSeriesEpisodes.mockClear();
-        fetchVodSeriesEpisodes.mockResolvedValue([
-            { id: 'episode-3', series_number: 1, name: 'Next Season' },
-        ]);
-
-        const firstEpisode = fixture.componentInstance.mappedSeasons()['1'][0];
-        fixture.componentInstance.onEpisodeClicked(firstEpisode);
-        await fixture.whenStable();
-        await stabilize();
-        fixture.detectChanges();
-
-        expect(fetchVodSeriesEpisodes).toHaveBeenCalledWith(
-            '50001',
-            'season-2'
-        );
-
-        const inlinePlayer = fixture.debugElement.query(
-            By.directive(StubPortalInlinePlayerComponent)
-        ).componentInstance as StubPortalInlinePlayerComponent;
-        const railItems = inlinePlayer.upNextEpisodes() as Array<{
-            label: string;
-        }>;
-        expect(railItems.map((item) => item.label)).toEqual([
-            'S01E01',
-            'S02E01',
-        ]);
-    });
-
-    it('does not re-request a spillover season that came back empty', async () => {
-        selectedContentType.set('vod');
-        selectedItem.set({
-            id: '50001',
-            is_series: true,
-            info: {
-                name: 'VOD Flagged Series',
-                description: 'Lazy seasons',
-                movie_image: 'vod-series.jpg',
-            },
-        });
-        serialSeasonsResource.set([]);
-        vodSeriesSeasonsResource.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-            },
-        ]);
-        isEmbeddedPlayer.mockReturnValue(true);
-
-        await stabilize();
-
-        fixture.componentInstance.vodSeriesSeasons.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-                episodes: [
-                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
-                    { id: 'episode-2', series_number: 2, name: 'Second' },
-                ],
-                isLoading: false,
-                isExpanded: false,
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-                episodes: [],
-                isLoading: false,
-                isExpanded: false,
-            },
-        ]);
-        fetchVodSeriesEpisodes.mockClear();
-        // Failed or genuinely empty season: isLoading returns to false while
-        // episodes stays empty — the retry trap.
-        fetchVodSeriesEpisodes.mockResolvedValue([]);
-
-        const seasonOne = fixture.componentInstance.mappedSeasons()['1'];
-        fixture.componentInstance.onEpisodeClicked(seasonOne[0]);
-        await fixture.whenStable();
-        await stabilize();
-        fixture.detectChanges();
-
-        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
-
-        // Further playback activity in the same season must not retrigger it.
-        fixture.componentInstance.onEpisodeClicked(seasonOne[1]);
-        await fixture.whenStable();
-        await stabilize();
-        fixture.detectChanges();
-
-        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
-    });
-
-    it('retries a failed spillover prefetch on the next episode', async () => {
-        selectedContentType.set('vod');
-        selectedItem.set({
-            id: '50001',
-            is_series: true,
-            info: {
-                name: 'VOD Flagged Series',
-                description: 'Lazy seasons',
-                movie_image: 'vod-series.jpg',
-            },
-        });
-        serialSeasonsResource.set([]);
-        vodSeriesSeasonsResource.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-            },
-        ]);
-        isEmbeddedPlayer.mockReturnValue(true);
-
-        await stabilize();
-
-        fixture.componentInstance.vodSeriesSeasons.set([
-            {
-                id: 'season-1',
-                video_id: '50001',
-                season_number: '1',
-                name: 'Season 1',
-                episodes: [
-                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
-                    { id: 'episode-2', series_number: 2, name: 'Second' },
-                ],
-                isLoading: false,
-                isExpanded: false,
-            },
-            {
-                id: 'season-2',
-                video_id: '50001',
-                season_number: '2',
-                name: 'Season 2',
-                episodes: [],
-                isLoading: false,
-                isExpanded: false,
-            },
-        ]);
-        fetchVodSeriesEpisodes.mockClear();
-        fetchVodSeriesEpisodes.mockRejectedValueOnce(new Error('network'));
-
-        const seasonOne = fixture.componentInstance.mappedSeasons()['1'];
-        fixture.componentInstance.onEpisodeClicked(seasonOne[0]);
-        await fixture.whenStable();
-        await stabilize();
-        fixture.detectChanges();
-
-        // The failure must not loop while the same episode keeps playing.
-        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
-
-        // Moving to the next episode gives the transient failure a new chance.
-        fetchVodSeriesEpisodes.mockResolvedValue([
-            { id: 'episode-3', series_number: 1, name: 'Next Season' },
-        ]);
-        fixture.componentInstance.onEpisodeClicked(seasonOne[1]);
-        await fixture.whenStable();
-        await stabilize();
-        fixture.detectChanges();
-
-        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(2);
-
-        const inlinePlayer = fixture.debugElement.query(
-            By.directive(StubPortalInlinePlayerComponent)
-        ).componentInstance as StubPortalInlinePlayerComponent;
-        const railItems = inlinePlayer.upNextEpisodes() as Array<{
-            label: string;
-        }>;
-        expect(railItems.map((item) => item.label)).toEqual([
-            'S01E02',
-            'S02E01',
-        ]);
-    });
-
     it('loads the next unloaded VOD-series season after the loaded season is watched', async () => {
         selectedContentType.set('vod');
         selectedItem.set({
@@ -1180,162 +736,4 @@ describe('StalkerSeriesViewComponent', () => {
             undefined
         );
     });
-
-    it('fetches the TMDB season once the show-level match arrives after auto-select', async () => {
-        await stabilize();
-        fixture.detectChanges();
-
-        // Season tabs auto-select immediately — usually before the async
-        // show-level enrichment has written tmdb_id.
-        const seasonContainer = fixture.debugElement.query(
-            By.directive(StubSeasonContainerComponent)
-        ).componentInstance as StubSeasonContainerComponent;
-        seasonContainer.seasonSelected.emit('1');
-        await stabilize();
-        expect(tmdbGetSeason).not.toHaveBeenCalled();
-
-        // The TMDB match lands afterwards — the fetch must run now.
-        selectedItem.set({
-            id: '30001',
-            cmd: '/media/file_30001.mpg',
-            info: {
-                name: 'Regular Series',
-                description: 'Series description',
-                movie_image: 'poster.jpg',
-                tmdb_id: 777,
-            },
-        } as never);
-        await stabilize();
-
-        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 1);
-    });
-
-    it('waits for the season map before fetching so a per-season slice gets the title-marked season', async () => {
-        serialSeasonsResource.set([]);
-        selectedItem.set({
-            id: '30001',
-            cmd: '/media/file_30001.mpg',
-            info: {
-                name: 'Regular Series (2 season)',
-                description: 'Series description',
-                movie_image: 'poster.jpg',
-                tmdb_id: 777,
-            },
-        } as never);
-        await stabilize();
-
-        fixture.componentInstance.onSeasonSelected('2');
-        await stabilize();
-
-        // Season resource still loading — fetching now would pass a zero
-        // season count, suppress the title-marker override and cache the
-        // wrong season forever (fetchSeason is idempotent).
-        expect(tmdbGetSeason).not.toHaveBeenCalled();
-
-        serialSeasonsResource.set([
-            {
-                id: 'season-1',
-                name: 'Season 1',
-                cmd: '/media/file_30001.mpg',
-                series: [1, 2],
-            },
-        ]);
-        await stabilize();
-
-        // Single-season slice whose provider season is renumbered to 1:
-        // the title marker names the real TMDB season.
-        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 2);
-    });
-
-    it('gates the fetch on the reloading season resource during detail-to-detail navigation', async () => {
-        await stabilize();
-
-        fixture.componentInstance.onSeasonSelected('1');
-        await stabilize();
-        // No show-level TMDB match yet — nothing fetched for the first item
-        expect(tmdbGetSeason).not.toHaveBeenCalled();
-
-        // Detail-to-detail navigation reuses the component; the new item's
-        // TMDB match can arrive while the season resource reloads and the
-        // map still shows the previous series' seasons.
-        isSerialSeasonsLoading.set(true);
-        selectedItem.set({
-            id: '30002',
-            cmd: '/media/file_30002.mpg',
-            info: {
-                name: 'Other Series (2 season)',
-                description: 'Other description',
-                movie_image: 'poster2.jpg',
-                tmdb_id: 888,
-            },
-        } as never);
-        await stabilize();
-
-        // The new tmdb_id must NOT pair with the previous series' season
-        // context while the resource reloads.
-        expect(tmdbGetSeason).not.toHaveBeenCalled();
-
-        // Once the new item's own seasons land, the fetch runs without a
-        // stale-season fetch. The container selects the corrected key once
-        // the new season map is rendered.
-        serialSeasonsResource.set([
-            {
-                id: 'season-1',
-                name: 'Season 1',
-                cmd: '/media/file_30002.mpg',
-                series: [1, 2],
-            },
-        ]);
-        isSerialSeasonsLoading.set(false);
-        fixture.componentInstance.onSeasonSelected('2');
-        await stabilize();
-        expect(tmdbGetSeason).toHaveBeenCalledWith(888, 2);
-    });
-
-    it('enriches after equal-id navigation once the season resource settles', async () => {
-        await stabilize();
-        fixture.componentInstance.onSeasonSelected('1');
-        await stabilize();
-
-        // Distinct items can reuse a provider id; the loading gate (not an
-        // id comparison) keeps the stale map from being used.
-        isSerialSeasonsLoading.set(true);
-        selectedItem.set({
-            id: '30001',
-            cmd: '/media/file_30001.mpg',
-            info: {
-                name: 'Different Series (3 season)',
-                description: 'Different description',
-                movie_image: 'poster3.jpg',
-                tmdb_id: 999,
-            },
-        } as never);
-        await stabilize();
-        expect(tmdbGetSeason).not.toHaveBeenCalled();
-
-        isSerialSeasonsLoading.set(false);
-        fixture.componentInstance.onSeasonSelected('3');
-        await stabilize();
-        expect(tmdbGetSeason).toHaveBeenCalledWith(999, 3);
-    });
-
-    it('reads the season marker from o_name when name is generic', async () => {
-        selectedItem.set({
-            id: '30001',
-            cmd: '/media/file_30001.mpg',
-            info: {
-                name: 'Regular Series',
-                o_name: 'Regular Series (2 season)',
-                description: 'Series description',
-                movie_image: 'poster.jpg',
-                tmdb_id: 777,
-            },
-        } as never);
-        await stabilize();
-
-        fixture.componentInstance.onSeasonSelected('2');
-        await stabilize();
-
-        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 2);
-    });
 });
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.ts
index 3c250b61b..a4fd531f4 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.component.ts
@@ -16,7 +16,6 @@ import { MatSnackBar } from '@angular/material/snack-bar';
 import { Router } from '@angular/router';
 import { TranslatePipe, TranslateService } from '@ngx-translate/core';
 import { FavoritesButtonComponent } from '../stalker-favorites-button/stalker-favorites-button.component';
-import { StalkerCatalogFacadeService } from '../stalker-catalog-facade.service';
 import {
     findStalkerResumeLazySeason,
     resolveStalkerResumeEpisode,
@@ -40,7 +39,6 @@ import {
     SimilarRailComponent,
     ViewInPortalActionComponent,
     VodMoreMenuComponent,
-    buildSeriesWatchToggleRequest,
     scrollToCastCrewRow,
 } from '@iptvnator/ui/components';
 import {
@@ -53,14 +51,11 @@ import {
     XtreamSerieEpisode,
     pickSeasonMarkedTitle,
     seriesStatusLabelKey,
-    youtubeEmbedUrl,
 } from '@iptvnator/shared/interfaces';
 import {
     isLiveExternalPlayerSession,
     replaceOwnedExternalSession,
-    isPortalPlaybackWatched,
     PORTAL_EXTERNAL_PLAYBACK,
-    PORTAL_PLAYBACK_POSITIONS,
     PORTAL_PLAYER,
     createLogger,
     consumeStalkerReturnMarker,
@@ -108,12 +103,10 @@ import {
     getStalkerSeriesQuickStartButton,
     type StalkerQuickStartButton,
 } from './stalker-series-quick-start';
-import {
-    clearStalkerSeriesPosition,
-    reconcileStalkerSeriesPositions,
-    saveStalkerSeriesPosition,
-    StalkerSeriesPositionPartialSaveError,
-} from './stalker-series-position-compatibility';
+import { toStalkerSeriesId } from './stalker-series-id';
+import { StalkerSeriesPositionsService } from './stalker-series-positions.service';
+import { StalkerSeriesWatchToggleService } from './stalker-series-watch-toggle.service';
+import { StalkerVodSeasonEpisodeLoader } from './stalker-vod-season-episode-loader';
 import {
     createStalkerSeriesDownloadAdapter,
     STALKER_SERIES_DOWNLOAD_MODES,
@@ -128,40 +121,6 @@ import {
     type StalkerEpisodePlaybackStructuralIdentity,
 } from './stalker-episode-playback-session-key';
 
-interface SeriesPositionContext {
-    readonly generation: number;
-    readonly playlistId: string;
-    readonly seriesXtreamId: number;
-    readonly mutationKey: string;
-}
-
-interface StalkerWatchToggleFeedback {
-    readonly marked: string;
-    readonly unmarked: string;
-    readonly partialMarked: string;
-    readonly partialUnmarked: string;
-    readonly failed: string;
-}
-
-// The marked and partial keys are scope-generic on purpose ("{{count}}
-// episodes marked as watched", "{{count}} marked · {{failed}} failed");
-// only unmark-success and failure name their scope.
-const SEASON_WATCH_FEEDBACK: StalkerWatchToggleFeedback = {
-    marked: 'XTREAM.SEASON_MARKED_WATCHED',
-    unmarked: 'XTREAM.SEASON_MARKED_UNWATCHED',
-    partialMarked: 'XTREAM.SEASON_MARKED_WATCHED_PARTIAL',
-    partialUnmarked: 'XTREAM.SEASON_MARKED_UNWATCHED_PARTIAL',
-    failed: 'XTREAM.SEASON_WATCH_UPDATE_FAILED',
-};
-
-const SERIES_WATCH_FEEDBACK: StalkerWatchToggleFeedback = {
-    marked: 'XTREAM.SEASON_MARKED_WATCHED',
-    unmarked: 'XTREAM.SERIES_MARKED_UNWATCHED',
-    partialMarked: 'XTREAM.SEASON_MARKED_WATCHED_PARTIAL',
-    partialUnmarked: 'XTREAM.SEASON_MARKED_UNWATCHED_PARTIAL',
-    failed: 'XTREAM.SERIES_WATCH_UPDATE_FAILED',
-};
-
 interface StalkerSeriesPlaybackRequestContext {
     readonly generation: number;
     readonly usesEmbeddedPlayer: boolean;
@@ -201,6 +160,8 @@ interface StalkerSeriesPlaybackRequestContext {
         StalkerSeriesTmdbSeasonsService,
         StalkerSeriesHeroPresenter,
         StalkerSeriesMenuService,
+        StalkerSeriesPositionsService,
+        StalkerSeriesWatchToggleService,
     ],
 })
 export class StalkerSeriesViewComponent implements OnDestroy {
@@ -209,27 +170,8 @@ export class StalkerSeriesViewComponent implements OnDestroy {
     readonly menu = inject(StalkerSeriesMenuService);
     private readonly seasonContainerRef =
         viewChild<SeasonContainerComponent>('seasonContainer');
-    private readonly playbackPositions = inject(PORTAL_PLAYBACK_POSITIONS);
-    private readonly migrationPlaybackPositions = {
-        savePlaybackPosition: (
-            playlistId: string,
-            data: PlaybackPositionData
-        ) =>
-            this.playbackPositions.savePlaybackPositionOrThrow(
-                playlistId,
-                data
-            ),
-        clearPlaybackPosition: (
-            playlistId: string,
-            contentXtreamId: number,
-            contentType: 'vod' | 'episode'
-        ) =>
-            this.playbackPositions.clearPlaybackPositionOrThrow(
-                playlistId,
-                contentXtreamId,
-                contentType
-            ),
-    };
+    private readonly positions = inject(StalkerSeriesPositionsService);
+    private readonly watchToggle = inject(StalkerSeriesWatchToggleService);
     private readonly portalPlayer = inject(PORTAL_PLAYER);
     private readonly router = inject(Router);
     private readonly location = inject(Location);
@@ -238,46 +180,15 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         PlaybackPositionRuntimeBridgeService
     );
     private readonly snackBar = inject(MatSnackBar);
-    // Optional: absent in collection-detail mounts outside the catalog.
-    private readonly catalogFacade = inject(StalkerCatalogFacadeService, {
-        optional: true,
-    });
     private readonly translateService = inject(TranslateService);
     readonly backClicked = output<void>();
     private readonly logger = createLogger('StalkerSeriesView');
     readonly inlinePlayback = signal<ResolvedPortalPlayback | null>(null);
-    readonly episodePlaybackPositions = signal<
-        Map<number, PlaybackPositionData>
-    >(new Map());
-    private readonly rawSeriesPositions = signal<
-        readonly PlaybackPositionData[]
-    >([]);
-    /**
-     * `playlistId:seriesId` once the persisted positions for the shown
-     * series have been READ (a failed read leaves it null): the dashboard
-     * resume handoff must not start an episode from the beginning because
-     * the offsets have not arrived yet.
-     */
-    private readonly seriesPositionsLoadedKey = signal<string | null>(null);
+    readonly episodePlaybackPositions = this.positions.episodePlaybackPositions;
     private readonly seriesResumeTarget = inject(STALKER_SERIES_RESUME_TARGET);
     private consumedSeriesResumeKey: string | null = null;
     private readonly seriesResumeSeasonHydration =
         new StalkerResumeSeasonHydration();
-    private readonly legacyPositionByTrackingId = signal<
-        Map<number, PlaybackPositionData>
-    >(new Map());
-    private activeSeriesPositionContext: SeriesPositionContext | null = null;
-    private seriesPositionContextGeneration = 0;
-    private readonly seriesPositionMutationQueues = new Map<
-        string,
-        Promise<void>
-    >();
-    private readonly pendingSeriesPositionLoads = new Map<
-        SeriesPositionContext,
-        Set<number>
-    >();
-    private readonly seriesPositionReloadKeys = new Set<string>();
-    private seriesPositionsLoadGeneration = 0;
     private seriesPlaybackRequestGeneration = 0;
     private currentSeriesPlaybackOwnerKey = '';
     private readonly inlinePlaybackEpisodeIdentity =
@@ -294,15 +205,6 @@ export class StalkerSeriesViewComponent implements OnDestroy {
     private readonly pendingStartSeriesIds = signal<readonly string[]>([]);
     /** Episode choices made while a forced MPV/VLC launch is mid-flight. */
     private readonly launchQueue = new StalkerSeriesLaunchQueue();
-    /**
-     * The episode chosen while a watched/reset batch still rewrote the rows
-     * a start resumes from; the last choice plays once the batch settled,
-     * and only on the series it was made for.
-     */
-    private choiceHeldForBatch: {
-        readonly seriesKey: string;
-        readonly play: () => void;
-    } | null = null;
     /** `playlist:series` of the series on screen; provider ids collide across playlists. */
     readonly currentSeriesKey = computed(
         () =>
@@ -312,7 +214,7 @@ export class StalkerSeriesViewComponent implements OnDestroy {
     readonly startPending = computed(() =>
         this.pendingStartSeriesIds().includes(this.currentSeriesKey())
     );
-    readonly seasonWatchBatchRunning = signal(false);
+    readonly seasonWatchBatchRunning = this.watchToggle.seasonWatchBatchRunning;
 
     /**
      * Optional input for VOD items with embedded series array (vclub mode)
@@ -437,6 +339,20 @@ export class StalkerSeriesViewComponent implements OnDestroy {
             resetProgress: () => this.resetProgress(),
             openExternal: (player) => this.openQuickStartExternally(player),
         });
+        this.positions.bind({
+            displayItem: this.displayItem,
+            mappedSeasons: this.mappedSeasons,
+        });
+        this.watchToggle.bind({
+            displayItem: this.displayItem,
+            currentSeriesKey: this.currentSeriesKey,
+            isVodSeries: this.isVodSeries,
+            vodSeriesSeasons: this.vodSeriesSeasons,
+            mappedSeasons: this.mappedSeasons,
+            excludedEpisodeIds: () => this.seriesWatchExcludedIds(),
+            loadEpisodesForSeason: (season) =>
+                this.loadEpisodesForSeason(season),
+        });
         effect(() => {
             const ownerKey = this.seriesPlaybackOwnerKey();
             untracked(() => this.syncSeriesPlaybackOwner(ownerKey));
@@ -506,33 +422,11 @@ export class StalkerSeriesViewComponent implements OnDestroy {
 
         // Effect to load playback positions for Stalker series
         effect(() => {
-            const item = this.displayItem();
-            const playlist = this.stalkerStore.currentPlaylist();
-            const normalizedSeriesId = this.toSeriesId(item?.id ?? 0);
-            if (item && playlist?._id && normalizedSeriesId > 0) {
-                this.logger.debug('Loading positions for series', {
-                    id: item.id,
-                    seriesId: normalizedSeriesId,
-                    isSeries: item.is_series,
-                });
-                this.rawSeriesPositions.set([]);
-                this.seriesPositionsLoadedKey.set(null);
-                this.episodePlaybackPositions.set(new Map());
-                this.legacyPositionByTrackingId.set(new Map());
-                const context = this.activateSeriesPositionContext(
-                    playlist._id,
-                    normalizedSeriesId
-                );
-                void this.loadSeriesPositions(context);
-            } else {
-                this.activeSeriesPositionContext = null;
-                this.seriesPositionContextGeneration++;
-                this.seriesPositionsLoadGeneration++;
-            }
+            this.positions.loadShownSeries();
         });
 
         effect(() => {
-            this.applyReconciledSeriesPositions();
+            this.positions.applyReconciledSeriesPositions();
         });
 
         // Dashboard "Continue watching" handoff: once the persisted
@@ -557,8 +451,11 @@ export class StalkerSeriesViewComponent implements OnDestroy {
                 !playlistId ||
                 seriesXtreamId <= 0 ||
                 target.seriesXtreamId !== seriesXtreamId ||
-                this.seriesPositionsLoadedKey() !==
-                    this.seriesPositionsKey(playlistId, seriesXtreamId)
+                this.positions.seriesPositionsLoadedKey() !==
+                    this.positions.seriesPositionsKey(
+                        playlistId,
+                        seriesXtreamId
+                    )
             ) {
                 return;
             }
@@ -577,10 +474,12 @@ export class StalkerSeriesViewComponent implements OnDestroy {
                 // Reconciliation attaches positions by exact or legacy
                 // tracking id only; an episode found by coordinates still
                 // resumes at the offset the dashboard card displayed.
-                const savedOffset = this.rawSeriesPositions().find(
-                    (position) =>
-                        position.contentXtreamId === target.contentXtreamId
-                )?.positionSeconds;
+                const savedOffset = this.positions
+                    .rawSeriesPositions()
+                    .find(
+                        (position) =>
+                            position.contentXtreamId === target.contentXtreamId
+                    )?.positionSeconds;
                 untracked(() => this.onEpisodeClicked(episode, savedOffset));
                 return;
             }
@@ -661,14 +560,14 @@ export class StalkerSeriesViewComponent implements OnDestroy {
                     // The facade/runtime already saved this row. Repeat the
                     // idempotent upsert because only this view owns the
                     // scoped-to-legacy cleanup mapping.
-                    void this.persistSeriesPosition(playlistId, data).catch(
-                        (error: unknown) => {
+                    void this.positions
+                        .persistSeriesPosition(playlistId, data)
+                        .catch((error: unknown) => {
                             this.logger.error(
                                 'Failed to persist runtime series position',
                                 error
                             );
-                        }
-                    );
+                        });
                 }
             ) ?? null;
     }
@@ -915,106 +814,17 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         }
     }
 
-    private readonly vodSeasonEpisodeLoads = new Map<
-        string,
-        { season: VodSeriesSeasonVm; promise: Promise<boolean> }
-    >();
+    private readonly vodSeasonLoader = new StalkerVodSeasonEpisodeLoader({
+        seasons: this.vodSeriesSeasons,
+        ownerKey: () => this.seriesPlaybackOwnerKey(),
+        fetchEpisodes: (videoId, seasonId) =>
+            this.stalkerStore.fetchVodSeriesEpisodes(videoId, seasonId),
+        logError: (message, error) => this.logger.error(message, error),
+    });
 
-    /**
-     * Loads episodes for a specific VOD season.
-     *
-     * Single-flight per season: a tab click, the spillover prefetch, the
-     * quick-start recursion, and the series-toggle hydration can all ask for
-     * the same season — a second concurrent request would duplicate portal
-     * traffic, and its failure could abort a series toggle whose original
-     * request succeeded.
-     */
     /** Resolves true when the portal answered, false when the request failed. */
     loadEpisodesForSeason(season: VodSeriesSeasonVm): Promise<boolean> {
-        const key = JSON.stringify([
-            this.seriesPlaybackOwnerKey(),
-            season.video_id,
-            season.id,
-            getVodSeriesSeasonKey(season),
-        ]);
-        const inFlight = this.vodSeasonEpisodeLoads.get(key);
-        if (inFlight && this.vodSeriesSeasons().includes(inFlight.season)) {
-            return inFlight.promise;
-        }
-        const load = this.fetchEpisodesForSeason(season).finally(() => {
-            if (this.vodSeasonEpisodeLoads.get(key)?.promise === load) {
-                this.vodSeasonEpisodeLoads.delete(key);
-            }
-        });
-        const loadingSeason = this.vodSeriesSeasons().find(
-            (candidate) =>
-                candidate.id === season.id &&
-                candidate.video_id === season.video_id
-        );
-        if (loadingSeason) {
-            this.vodSeasonEpisodeLoads.set(key, {
-                season: loadingSeason,
-                promise: load,
-            });
-        }
-        return load;
-    }
-
-    private async fetchEpisodesForSeason(
-        season: VodSeriesSeasonVm
-    ): Promise<boolean> {
-        // Set loading state in local signal
-        const seasons = this.vodSeriesSeasons();
-        const index = seasons.findIndex(
-            (s) =>
-                s.id === season.id &&
-                s.video_id === season.video_id &&
-                getVodSeriesSeasonKey(s) === getVodSeriesSeasonKey(season)
-        );
-        if (index === -1) return false;
-
-        const updatedSeasons = [...seasons];
-        const loadingSeason = { ...updatedSeasons[index], isLoading: true };
-        updatedSeasons[index] = loadingSeason;
-        this.vodSeriesSeasons.set(updatedSeasons);
-
-        try {
-            const episodes = await this.stalkerStore.fetchVodSeriesEpisodes(
-                season.video_id,
-                season.id
-            );
-
-            // Update with loaded episodes
-            const newSeasons = [...this.vodSeriesSeasons()];
-            // Only the exact loading VM owns this response. A navigation or
-            // refresh can reuse provider ids while replacing the season list.
-            const newIndex = newSeasons.indexOf(loadingSeason);
-            if (newIndex !== -1) {
-                newSeasons[newIndex] = {
-                    ...newSeasons[newIndex],
-                    episodes: episodes,
-                    // Even an EMPTY answer marks the season loaded: the
-                    // portal spoke, so it must stop counting as "unloaded"
-                    // (label/verdict gating and series-toggle hydration).
-                    episodesLoaded: true,
-                    isLoading: false,
-                };
-                this.vodSeriesSeasons.set(newSeasons);
-            }
-            return newIndex !== -1;
-        } catch (error) {
-            this.logger.error('Failed to load episodes', error);
-            const newSeasons = [...this.vodSeriesSeasons()];
-            const newIndex = newSeasons.indexOf(loadingSeason);
-            if (newIndex !== -1) {
-                newSeasons[newIndex] = {
-                    ...newSeasons[newIndex],
-                    isLoading: false,
-                };
-                this.vodSeriesSeasons.set(newSeasons);
-            }
-            return false;
-        }
+        return this.vodSeasonLoader.load(season);
     }
 
     /**
@@ -1045,15 +855,9 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         if (this.seasonWatchBatchRunning()) {
             // The batch rewrites the very rows a start resumes from: the
             // choice waits for it, like the Reset and watched rows do.
-            this.choiceHeldForBatch = {
-                seriesKey: this.currentSeriesKey(),
-                play: () =>
-                    this.onEpisodeClicked(
-                        episode,
-                        startTimeOverride,
-                        forcePlayer
-                    ),
-            };
+            this.watchToggle.holdChoice(() =>
+                this.onEpisodeClicked(episode, startTimeOverride, forcePlayer)
+            );
             return;
         }
         const seriesKey = this.currentSeriesKey();
@@ -1068,20 +872,6 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         this.startEpisode(episode, startTimeOverride, forcePlayer);
     }
 
-    /**
-     * The batch settled: the choice held meanwhile goes through the usual
-     * gates, unless the viewer switched series since. Episode identities
-     * overlap across series, so it must never resolve against another one.
-     */
-    private endWatchBatch(): void {
-        this.seasonWatchBatchRunning.set(false);
-        const held = this.choiceHeldForBatch;
-        this.choiceHeldForBatch = null;
-        if (held && held.seriesKey === this.currentSeriesKey()) {
-            held.play();
-        }
-    }
-
     private startEpisode(
         episode: XtreamSerieEpisode,
         startTimeOverride?: number,
@@ -1208,11 +998,7 @@ export class StalkerSeriesViewComponent implements OnDestroy {
     }
 
     toSeriesId(id: string | number): number {
-        const raw = String(id ?? '').trim();
-        if (!raw) return 0;
-        const primary = raw.includes(':') ? raw.split(':')[0] : raw;
-        const parsed = Number(primary);
-        return Number.isFinite(parsed) ? parsed : 0;
+        return toStalkerSeriesId(id);
     }
 
     closeInlinePlayer(): void {
@@ -1239,15 +1025,14 @@ export class StalkerSeriesViewComponent implements OnDestroy {
             positionSeconds: Math.floor(event.currentTime),
             durationSeconds: Math.floor(event.duration),
         };
-        void this.persistSeriesPosition(
-            playback.contentInfo.playlistId,
-            position
-        ).catch((error: unknown) => {
-            this.logger.error(
-                'Failed to persist inline series position',
-                error
-            );
-        });
+        void this.positions
+            .persistSeriesPosition(playback.contentInfo.playlistId, position)
+            .catch((error: unknown) => {
+                this.logger.error(
+                    'Failed to persist inline series position',
+                    error
+                );
+            });
     }
 
     showCopyNotification(): void {
@@ -1517,27 +1302,10 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         this.closeInlinePlayer();
     }
 
-    async handlePlaybackToggleRequested(
+    handlePlaybackToggleRequested(
         request: SeasonContainerPlaybackToggleRequest
     ): Promise<void> {
-        const playlistId = this.stalkerStore.currentPlaylist()?._id;
-        if (!playlistId) {
-            return;
-        }
-
-        if (request.nextPosition) {
-            await this.persistSeriesPosition(playlistId, request.nextPosition);
-        } else {
-            await this.clearSeriesPosition(playlistId, request.contentXtreamId);
-        }
-        // Keep the catalog grid's progress badge in sync (ownership-checked
-        // inside the facade; no-op outside the catalog context). A failed
-        // refresh keeps the cache populated-but-stale.
-        await this.catalogFacade
-            ?.refreshPositions(playlistId)
-            .catch((error: unknown) =>
-                this.logger.warn('Catalog position refresh failed', error)
-            );
+        return this.watchToggle.handlePlaybackToggleRequested(request);
     }
 
     handlePlaybackToggleRequestedFromUi(
@@ -1553,36 +1321,10 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         );
     }
 
-    async handleSeasonPlaybackToggleRequested(
+    handleSeasonPlaybackToggleRequested(
         request: SeasonContainerSeasonPlaybackToggleRequest
     ): Promise<void> {
-        const playlistId = this.stalkerStore.currentPlaylist()?._id;
-        if (
-            !playlistId ||
-            request.requests.length === 0 ||
-            this.seasonWatchBatchRunning()
-        ) {
-            return;
-        }
-        // The mutation context already keeps a stale batch out of the next
-        // series' state; the snackbars need the same ownership so feedback
-        // for the old season is not presented on a newly opened page.
-        const seriesXtreamId = this.toSeriesId(this.displayItem()?.id ?? 0);
-        const stillCurrent = () =>
-            this.stalkerStore.currentPlaylist()?._id === playlistId &&
-            this.toSeriesId(this.displayItem()?.id ?? 0) === seriesXtreamId;
-
-        this.seasonWatchBatchRunning.set(true);
-        try {
-            await this.runWatchToggleBatch(
-                request,
-                playlistId,
-                stillCurrent,
-                SEASON_WATCH_FEEDBACK
-            );
-        } finally {
-            this.endWatchBatch();
-        }
+        return this.watchToggle.handleSeasonPlaybackToggleRequested(request);
     }
 
     handleSeasonPlaybackToggleRequestedFromUi(
@@ -1624,89 +1366,10 @@ export class StalkerSeriesViewComponent implements OnDestroy {
             : {}
     );
 
-    async handleSeriesPlaybackToggleRequested(
+    handleSeriesPlaybackToggleRequested(
         request: SeasonContainerSeriesPlaybackToggleRequest
     ): Promise<void> {
-        const playlistId = this.stalkerStore.currentPlaylist()?._id;
-        if (!playlistId || this.seasonWatchBatchRunning()) {
-            return;
-        }
-        const pendingSeasons = this.isVodSeries()
-            ? this.vodSeriesSeasons().filter((season) =>
-                  this.isSeasonHydrationPending(season)
-              )
-            : [];
-        // An empty request is only meaningful when unloaded seasons remain:
-        // every loaded episode is watched, so the container could not build
-        // a target list, but hydration below may still surface unwatched
-        // episodes to mark.
-        if (request.requests.length === 0 && pendingSeasons.length === 0) {
-            return;
-        }
-
-        const seriesXtreamId = this.toSeriesId(this.displayItem()?.id ?? 0);
-        const stillCurrent = () =>
-            this.stalkerStore.currentPlaylist()?._id === playlistId &&
-            this.toSeriesId(this.displayItem()?.id ?? 0) === seriesXtreamId;
-
-        this.seasonWatchBatchRunning.set(true);
-        try {
-            let effective: SeasonContainerSeriesPlaybackToggleRequest | null =
-                request;
-            if (pendingSeasons.length > 0) {
-                const hydrated = await this.hydrateSeasonsForSeriesToggle(
-                    pendingSeasons,
-                    stillCurrent
-                );
-                if (hydrated !== 'complete') {
-                    if (hydrated === 'failed' && stillCurrent()) {
-                        this.notifySeasonWatchToggle(
-                            SERIES_WATCH_FEEDBACK.failed
-                        );
-                    }
-                    return;
-                }
-                // The reconcile effect only flushes on the next change-
-                // detection tick; rebuild the maps synchronously so the
-                // batch below sees the hydrated episodes' scoped and legacy
-                // rows (see applyReconciledSeriesPositions).
-                this.applyReconciledSeriesPositions();
-                effective = buildSeriesWatchToggleRequest({
-                    seasons: this.mappedSeasons(),
-                    seriesId: seriesXtreamId,
-                    playlistId,
-                    isEpisodeWatched: (episode) =>
-                        isPortalPlaybackWatched(
-                            this.episodePlaybackPositions().get(
-                                Number(episode.id)
-                            )
-                        ),
-                    excludedEpisodeIds: this.seriesWatchExcludedIds(),
-                    // Keep the direction the user clicked; re-inference over
-                    // the now-complete data could flip a "mark" into an
-                    // unwatch when everything turned out watched.
-                    markWatched: request.markWatched,
-                });
-                if (!effective) {
-                    if (stillCurrent()) {
-                        this.notifySeasonWatchToggle(
-                            SERIES_WATCH_FEEDBACK.marked,
-                            { count: 0 }
-                        );
-                    }
-                    return;
-                }
-            }
-
-            await this.runWatchToggleBatch(
-                effective,
-                playlistId,
-                stillCurrent,
-                SERIES_WATCH_FEEDBACK
-            );
-        } finally {
-            this.endWatchBatch();
-        }
+        return this.watchToggle.handleSeriesPlaybackToggleRequested(request);
     }
 
     handleSeriesPlaybackToggleRequestedFromUi(
@@ -1722,34 +1385,6 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         );
     }
 
-    /**
-     * Sequential on purpose: loadEpisodesForSeason snapshots the season VM
-     * array before its writes, so concurrent calls clobber each other's
-     * loading flags; and one request at a time keeps the portal load bounded.
-     */
-    private async hydrateSeasonsForSeriesToggle(
-        pendingSeasons: readonly VodSeriesSeasonVm[],
-        stillCurrent: () => boolean
-    ): Promise<'complete' | 'failed' | 'superseded'> {
-        for (const season of pendingSeasons) {
-            // A tab click may have loaded this season meanwhile.
-            const current = this.vodSeriesSeasons().find(
-                (candidate) => candidate.id === season.id
-            );
-            if (!current || !this.isSeasonHydrationPending(current)) {
-                continue;
-            }
-            const answered = await this.loadEpisodesForSeason(current);
-            if (!stillCurrent()) {
-                return 'superseded';
-            }
-            if (!answered) {
-                return 'failed';
-            }
-        }
-        return 'complete';
-    }
-
     /**
      * Mirrors the exclusions the template binds into the season container
      * (playingEpisodeId / activeEpisodeId / openingEpisodeId): the episode
@@ -1765,427 +1400,6 @@ export class StalkerSeriesViewComponent implements OnDestroy {
         return new Set(ids);
     }
 
-    private async runWatchToggleBatch(
-        request: SeasonContainerSeriesPlaybackToggleRequest,
-        playlistId: string,
-        stillCurrent: () => boolean,
-        feedback: StalkerWatchToggleFeedback
-    ): Promise<void> {
-        // Enqueue every episode synchronously: each mutation chains on
-        // the previous one's never-rejecting barrier, so the queue
-        // serializes the writes (incl. per-episode legacy-row cleanup)
-        // and reloads positions once after the whole chain drains.
-        const outcomes = await Promise.all(
-            request.requests.map((item) =>
-                (item.nextPosition
-                    ? this.persistSeriesPosition(playlistId, item.nextPosition)
-                    : this.clearSeriesPosition(playlistId, item.contentXtreamId)
-                ).then(
-                    () => true,
-                    // The scoped watched row was saved and published —
-                    // only the legacy-row cleanup failed. The episode IS
-                    // watched, so it must not count against the batch.
-                    (error: unknown) =>
-                        error instanceof StalkerSeriesPositionPartialSaveError
-                )
-            )
-        );
-
-        const failed = outcomes.filter((ok) => !ok).length;
-        const succeeded = outcomes.length - failed;
-        if (failed > 0) {
-            this.logger.error(
-                `Watched toggle: ${failed} of ${outcomes.length} episodes failed`
-            );
-        }
-        if (succeeded > 0) {
-            // Partial successes changed rows too — the catalog badge
-            // must follow even when the user already moved on. A failed
-            // refresh must not break the feedback flow below.
-            await this.catalogFacade
-                ?.refreshPositions(playlistId)
-                .catch((error: unknown) =>
-                    this.logger.warn('Catalog position refresh failed', error)
-                );
-        }
-        if (!stillCurrent()) {
-            return;
-        }
-
-        if (failed === 0) {
-            this.notifySeasonWatchToggle(
-                request.markWatched ? feedback.marked : feedback.unmarked,
-                { count: succeeded }
-            );
-        } else if (succeeded > 0) {
-            this.notifySeasonWatchToggle(
-                request.markWatched
-                    ? feedback.partialMarked
-                    : feedback.partialUnmarked,
-                { count: succeeded, failed }
-            );
-        } else {
-            this.notifySeasonWatchToggle(feedback.failed);
-        }
-    }
-
-    /**
-     * Maps the raw series position rows onto the currently mapped episodes
-     * (scoped rows plus compatible legacy promotions). Runs reactively from
-     * the constructor effect, and synchronously from the series-level watch
-     * toggle right after it hydrates lazy seasons — the effect only re-runs
-     * on the next change-detection tick, and enqueuing the batch against the
-     * stale maps would miss the hydrated episodes' legacy rows (an unwatch
-     * would leave rows behind that a later reconcile resurrects as watched).
-     */
-    private applyReconciledSeriesPositions(): void {
-        const item = this.displayItem();
-        const playlistId = this.stalkerStore.currentPlaylist()?._id;
-        const seriesXtreamId = this.toSeriesId(item?.id ?? 0);
-        const rawSeriesPositions = this.rawSeriesPositions();
-        const episodesBySeason = this.mappedSeasons();
-
-        if (!item || !playlistId || seriesXtreamId <= 0) {
-            if (rawSeriesPositions.length > 0) {
-                this.rawSeriesPositions.set([]);
-            }
-            if (this.episodePlaybackPositions().size > 0) {
-                this.episodePlaybackPositions.set(new Map());
-            }
-            if (this.legacyPositionByTrackingId().size > 0) {
-                this.legacyPositionByTrackingId.set(new Map());
-            }
-            return;
-        }
-
-        const reconciled = reconcileStalkerSeriesPositions({
-            seriesXtreamId,
-            episodesBySeason,
-            seriesPositions: rawSeriesPositions,
-        });
-        if (
-            rawSeriesPositions.length === 0 &&
-            reconciled.positionsByTrackingId.size === 0 &&
-            untracked(() => this.episodePlaybackPositions().size) > 0
-        ) {
-            return;
-        }
-        this.episodePlaybackPositions.set(reconciled.positionsByTrackingId);
-        this.legacyPositionByTrackingId.set(
-            reconciled.legacyPositionByTrackingId
-        );
-    }
-
-    private notifySeasonWatchToggle(key: string, params?: object): void {
-        this.snackBar.open(
-            this.translateService.instant(key, params),
-            undefined,
-            { duration: 5000 }
-        );
-    }
-
-    private async loadSeriesPositions(
-        context: SeriesPositionContext
-    ): Promise<void> {
-        const generation = ++this.seriesPositionsLoadGeneration;
-        this.trackPendingSeriesPositionLoad(context, generation);
-        try {
-            await this.waitForSeriesPositionMutations(context.mutationKey);
-
-            if (
-                generation !== this.seriesPositionsLoadGeneration ||
-                !this.isSeriesPositionContextActive(context)
-            ) {
-                return;
-            }
-
-            const positions =
-                await this.playbackPositions.getSeriesPlaybackPositions(
-                    context.playlistId,
-                    context.seriesXtreamId
-                );
-
-            if (
-                generation !== this.seriesPositionsLoadGeneration ||
-                !this.isSeriesPositionContextActive(context)
-            ) {
-                return;
-            }
-
-            this.rawSeriesPositions.set(positions);
-            this.seriesPositionsLoadedKey.set(
-                this.seriesPositionsKey(
-                    context.playlistId,
-                    context.seriesXtreamId
-                )
-            );
-        } finally {
-            this.untrackPendingSeriesPositionLoad(context, generation);
-        }
-    }
-
-    private seriesPositionsKey(
-        playlistId: string,
-        seriesXtreamId: number
-    ): string {
-        return `${playlistId}:${seriesXtreamId}`;
-    }
-
-    private activateSeriesPositionContext(
-        playlistId: string,
-        seriesXtreamId: number
-    ): SeriesPositionContext {
-        const context: SeriesPositionContext = {
-            generation: ++this.seriesPositionContextGeneration,
-            playlistId,
-            seriesXtreamId,
-            mutationKey: JSON.stringify([playlistId, seriesXtreamId]),
-        };
-        this.activeSeriesPositionContext = context;
-        return context;
-    }
-
-    private isSeriesPositionContextActive(
-        context: SeriesPositionContext
-    ): boolean {
-        const activeContext = this.activeSeriesPositionContext;
-        return (
-            activeContext === context &&
-            activeContext.generation === context.generation &&
-            this.stalkerStore.currentPlaylist()?._id === context.playlistId &&
-            this.toSeriesId(this.displayItem()?.id ?? 0) ===
-                context.seriesXtreamId
-        );
-    }
-
-    private waitForSeriesPositionMutations(mutationKey: string): Promise<void> {
-        return (
-            this.seriesPositionMutationQueues.get(mutationKey) ??
-            Promise.resolve()
-        );
-    }
-
-    private trackPendingSeriesPositionLoad(
-        context: SeriesPositionContext,
-        generation: number
-    ): void {
-        const generations =
-            this.pendingSeriesPositionLoads.get(context) ?? new Set<number>();
-        generations.add(generation);
-        this.pendingSeriesPositionLoads.set(context, generations);
-    }
-
-    private untrackPendingSeriesPositionLoad(
-        context: SeriesPositionContext,
-        generation: number
-    ): void {
-        const generations = this.pendingSeriesPositionLoads.get(context);
-        generations?.delete(generation);
-        if (generations?.size === 0) {
-            this.pendingSeriesPositionLoads.delete(context);
-        }
-    }
-
-    private hasCurrentPendingSeriesPositionLoad(
-        context: SeriesPositionContext
-    ): boolean {
-        return Boolean(
-            this.pendingSeriesPositionLoads
-                .get(context)
-                ?.has(this.seriesPositionsLoadGeneration)
-        );
-    }
-
-    private enqueueSeriesPositionMutation(
-        context: SeriesPositionContext,
-        operation: () => Promise<void>
-    ): Promise<void> {
-        if (this.hasCurrentPendingSeriesPositionLoad(context)) {
-            this.seriesPositionReloadKeys.add(context.mutationKey);
-        }
-        this.seriesPositionsLoadGeneration++;
-        const previous = this.waitForSeriesPositionMutations(
-            context.mutationKey
-        );
-        const result = previous.then(operation);
-        const barrier = result.then(
-            () => undefined,
-            () => undefined
-        );
-        this.seriesPositionMutationQueues.set(context.mutationKey, barrier);
-        void barrier.then(() => {
-            if (
-                this.seriesPositionMutationQueues.get(context.mutationKey) ===
-                barrier
-            ) {
-                this.seriesPositionMutationQueues.delete(context.mutationKey);
-                this.reloadSeriesPositionsAfterMutations(context.mutationKey);
-            }
-        });
-        return result;
-    }
-
-    private reloadSeriesPositionsAfterMutations(mutationKey: string): void {
-        if (!this.seriesPositionReloadKeys.delete(mutationKey)) {
-            return;
-        }
-        const context = this.activeSeriesPositionContext;
-        if (
-            !context ||
-            context.mutationKey !== mutationKey ||
-            !this.isSeriesPositionContextActive(context) ||
-            this.hasCurrentPendingSeriesPositionLoad(context)
-        ) {
-            return;
-        }
-        void this.loadSeriesPositions(context);
-    }
-
-    private getSeriesPositionMutationContext(
-        playlistId: string,
-        seriesXtreamId?: number | null
-    ): SeriesPositionContext | null {
-        const context = this.activeSeriesPositionContext;
-        if (
-            !context ||
-            context.playlistId !== playlistId ||
-            (seriesXtreamId != null &&
-                context.seriesXtreamId !== seriesXtreamId)
-        ) {
-            return null;
-        }
-        return context;
-    }
-
-    private persistSeriesPosition(
-        playlistId: string,
-        position: PlaybackPositionData
-    ): Promise<void> {
-        const context = this.getSeriesPositionMutationContext(
-            playlistId,
-            position.seriesXtreamId
-        );
-        if (!context) {
-            return Promise.resolve();
-        }
-        const legacyPosition = this.legacyPositionByTrackingId().get(
-            position.contentXtreamId
-        );
-        return this.enqueueSeriesPositionMutation(context, async () => {
-            let clearedLegacy: boolean;
-            try {
-                clearedLegacy = await saveStalkerSeriesPosition({
-                    repository: this.migrationPlaybackPositions,
-                    playlistId,
-                    position,
-                    legacyPosition,
-                });
-            } catch (error) {
-                if (
-                    error instanceof StalkerSeriesPositionPartialSaveError &&
-                    this.isSeriesPositionContextActive(context)
-                ) {
-                    this.publishSavedSeriesPosition(
-                        position,
-                        legacyPosition,
-                        false
-                    );
-                }
-                throw error;
-            }
-            if (!this.isSeriesPositionContextActive(context)) {
-                return;
-            }
-            this.publishSavedSeriesPosition(
-                position,
-                legacyPosition,
-                clearedLegacy
-            );
-        });
-    }
-
-    private publishSavedSeriesPosition(
-        position: PlaybackPositionData,
-        legacyPosition: PlaybackPositionData | undefined,
-        clearedLegacy: boolean
-    ): void {
-        const removedTrackingIds = new Set([position.contentXtreamId]);
-        if (clearedLegacy && legacyPosition) {
-            removedTrackingIds.add(legacyPosition.contentXtreamId);
-            const legacyPositions = new Map(this.legacyPositionByTrackingId());
-            legacyPositions.delete(position.contentXtreamId);
-            this.legacyPositionByTrackingId.set(legacyPositions);
-        }
-
-        this.rawSeriesPositions.set([
-            ...this.rawSeriesPositions().filter(
-                (candidate) =>
-                    !removedTrackingIds.has(candidate.contentXtreamId)
-            ),
-            position,
-        ]);
-        this.updateEpisodePlaybackPosition(position);
-    }
-
-    private clearSeriesPosition(
-        playlistId: string,
-        contentXtreamId: number
-    ): Promise<void> {
-        const context = this.getSeriesPositionMutationContext(playlistId);
-        if (!context) {
-            return Promise.resolve();
-        }
-        const position = this.episodePlaybackPositions().get(
-            contentXtreamId
-        ) ?? {
-            contentXtreamId,
-            contentType: 'episode',
-            positionSeconds: 0,
-            playlistId,
-            seriesXtreamId: context.seriesXtreamId,
-        };
-        const legacyPosition =
-            this.legacyPositionByTrackingId().get(contentXtreamId);
-        return this.enqueueSeriesPositionMutation(context, async () => {
-            const clearedLegacy = await clearStalkerSeriesPosition({
-                repository: this.migrationPlaybackPositions,
-                playlistId,
-                position,
-                legacyPosition,
-            });
-            if (!this.isSeriesPositionContextActive(context)) {
-                return;
-            }
-            this.publishClearedSeriesPosition(
-                contentXtreamId,
-                legacyPosition,
-                clearedLegacy
-            );
-        });
-    }
-
-    private publishClearedSeriesPosition(
-        contentXtreamId: number,
-        legacyPosition: PlaybackPositionData | undefined,
-        clearedLegacy: boolean
-    ): void {
-        const removedTrackingIds = new Set([contentXtreamId]);
-        if (clearedLegacy && legacyPosition) {
-            removedTrackingIds.add(legacyPosition.contentXtreamId);
-            const legacyPositions = new Map(this.legacyPositionByTrackingId());
-            legacyPositions.delete(contentXtreamId);
-            this.legacyPositionByTrackingId.set(legacyPositions);
-        }
-
-        this.rawSeriesPositions.set(
-            this.rawSeriesPositions().filter(
-                (candidate) =>
-                    !removedTrackingIds.has(candidate.contentXtreamId)
-            )
-        );
-        this.removeEpisodePlaybackPosition(contentXtreamId);
-    }
-
     private async loadAndPlayVodSeriesSeason(
         season: VodSeriesSeasonVm,
         visitedSeasonIds = new Set<string>()
@@ -2216,18 +1430,4 @@ export class StalkerSeriesViewComponent implements OnDestroy {
             );
         }
     }
-
-    private updateEpisodePlaybackPosition(
-        position: PlaybackPositionData
-    ): void {
-        const updated = new Map(this.episodePlaybackPositions());
-        updated.set(position.contentXtreamId, position);
-        this.episodePlaybackPositions.set(updated);
-    }
-
-    private removeEpisodePlaybackPosition(contentXtreamId: number): void {
-        const updated = new Map(this.episodePlaybackPositions());
-        updated.delete(contentXtreamId);
-        this.episodePlaybackPositions.set(updated);
-    }
 }
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.spillover-prefetch.spec.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.spillover-prefetch.spec.ts
new file mode 100644
index 000000000..d7a506ff8
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.spillover-prefetch.spec.ts
@@ -0,0 +1,281 @@
+import { ComponentFixture } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { StalkerSeriesViewComponent } from './stalker-series-view.component';
+import { createStalkerSeriesViewHarness } from './stalker-series-view.test-harness';
+import { StubPortalInlinePlayerComponent } from './stalker-series-view.test-helpers';
+
+/**
+ * The inline player's "Up Next" rail across lazy Ministra VOD-series seasons:
+ * the season after the playing one is fetched ahead so the rail can spill
+ * over into it.
+ */
+describe('StalkerSeriesViewComponent Up Next spillover prefetch', () => {
+    let fixture: ComponentFixture<StalkerSeriesViewComponent>;
+    const {
+        selectedContentType,
+        selectedItem,
+        serialSeasonsResource,
+        vodSeriesSeasonsResource,
+        fetchVodSeriesEpisodes,
+        isEmbeddedPlayer,
+        createFixture,
+    } = createStalkerSeriesViewHarness(() => jest.fn());
+
+    async function stabilize(): Promise<void> {
+        fixture.detectChanges();
+        await fixture.whenStable();
+    }
+
+    beforeEach(async () => {
+        fixture = await createFixture();
+    });
+
+    afterEach(() => {
+        fixture?.destroy();
+    });
+
+    it('prefetches the next unopened season so the Up Next rail can spill over', async () => {
+        selectedContentType.set('vod');
+        selectedItem.set({
+            id: '50001',
+            is_series: true,
+            info: {
+                name: 'VOD Flagged Series',
+                description: 'Lazy seasons',
+                movie_image: 'vod-series.jpg',
+            },
+        });
+        serialSeasonsResource.set([]);
+        vodSeriesSeasonsResource.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+            },
+        ]);
+        isEmbeddedPlayer.mockReturnValue(true);
+
+        await stabilize();
+
+        // Season 1 loaded, season 2 still empty — the state a user is in
+        // right after opening the series and starting the first episode.
+        fixture.componentInstance.vodSeriesSeasons.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+                episodes: [
+                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
+                ],
+                isLoading: false,
+                isExpanded: false,
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+                episodes: [],
+                isLoading: false,
+                isExpanded: false,
+            },
+        ]);
+        fetchVodSeriesEpisodes.mockClear();
+        fetchVodSeriesEpisodes.mockResolvedValue([
+            { id: 'episode-3', series_number: 1, name: 'Next Season' },
+        ]);
+
+        const firstEpisode = fixture.componentInstance.mappedSeasons()['1'][0];
+        fixture.componentInstance.onEpisodeClicked(firstEpisode);
+        await fixture.whenStable();
+        await stabilize();
+        fixture.detectChanges();
+
+        expect(fetchVodSeriesEpisodes).toHaveBeenCalledWith(
+            '50001',
+            'season-2'
+        );
+
+        const inlinePlayer = fixture.debugElement.query(
+            By.directive(StubPortalInlinePlayerComponent)
+        ).componentInstance as StubPortalInlinePlayerComponent;
+        const railItems = inlinePlayer.upNextEpisodes() as Array<{
+            label: string;
+        }>;
+        expect(railItems.map((item) => item.label)).toEqual([
+            'S01E01',
+            'S02E01',
+        ]);
+    });
+
+    it('does not re-request a spillover season that came back empty', async () => {
+        selectedContentType.set('vod');
+        selectedItem.set({
+            id: '50001',
+            is_series: true,
+            info: {
+                name: 'VOD Flagged Series',
+                description: 'Lazy seasons',
+                movie_image: 'vod-series.jpg',
+            },
+        });
+        serialSeasonsResource.set([]);
+        vodSeriesSeasonsResource.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+            },
+        ]);
+        isEmbeddedPlayer.mockReturnValue(true);
+
+        await stabilize();
+
+        fixture.componentInstance.vodSeriesSeasons.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+                episodes: [
+                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
+                    { id: 'episode-2', series_number: 2, name: 'Second' },
+                ],
+                isLoading: false,
+                isExpanded: false,
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+                episodes: [],
+                isLoading: false,
+                isExpanded: false,
+            },
+        ]);
+        fetchVodSeriesEpisodes.mockClear();
+        // Failed or genuinely empty season: isLoading returns to false while
+        // episodes stays empty — the retry trap.
+        fetchVodSeriesEpisodes.mockResolvedValue([]);
+
+        const seasonOne = fixture.componentInstance.mappedSeasons()['1'];
+        fixture.componentInstance.onEpisodeClicked(seasonOne[0]);
+        await fixture.whenStable();
+        await stabilize();
+        fixture.detectChanges();
+
+        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
+
+        // Further playback activity in the same season must not retrigger it.
+        fixture.componentInstance.onEpisodeClicked(seasonOne[1]);
+        await fixture.whenStable();
+        await stabilize();
+        fixture.detectChanges();
+
+        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
+    });
+
+    it('retries a failed spillover prefetch on the next episode', async () => {
+        selectedContentType.set('vod');
+        selectedItem.set({
+            id: '50001',
+            is_series: true,
+            info: {
+                name: 'VOD Flagged Series',
+                description: 'Lazy seasons',
+                movie_image: 'vod-series.jpg',
+            },
+        });
+        serialSeasonsResource.set([]);
+        vodSeriesSeasonsResource.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+            },
+        ]);
+        isEmbeddedPlayer.mockReturnValue(true);
+
+        await stabilize();
+
+        fixture.componentInstance.vodSeriesSeasons.set([
+            {
+                id: 'season-1',
+                video_id: '50001',
+                season_number: '1',
+                name: 'Season 1',
+                episodes: [
+                    { id: 'episode-1', series_number: 1, name: 'Pilot' },
+                    { id: 'episode-2', series_number: 2, name: 'Second' },
+                ],
+                isLoading: false,
+                isExpanded: false,
+            },
+            {
+                id: 'season-2',
+                video_id: '50001',
+                season_number: '2',
+                name: 'Season 2',
+                episodes: [],
+                isLoading: false,
+                isExpanded: false,
+            },
+        ]);
+        fetchVodSeriesEpisodes.mockClear();
+        fetchVodSeriesEpisodes.mockRejectedValueOnce(new Error('network'));
+
+        const seasonOne = fixture.componentInstance.mappedSeasons()['1'];
+        fixture.componentInstance.onEpisodeClicked(seasonOne[0]);
+        await fixture.whenStable();
+        await stabilize();
+        fixture.detectChanges();
+
+        // The failure must not loop while the same episode keeps playing.
+        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(1);
+
+        // Moving to the next episode gives the transient failure a new chance.
+        fetchVodSeriesEpisodes.mockResolvedValue([
+            { id: 'episode-3', series_number: 1, name: 'Next Season' },
+        ]);
+        fixture.componentInstance.onEpisodeClicked(seasonOne[1]);
+        await fixture.whenStable();
+        await stabilize();
+        fixture.detectChanges();
+
+        expect(fetchVodSeriesEpisodes).toHaveBeenCalledTimes(2);
+
+        const inlinePlayer = fixture.debugElement.query(
+            By.directive(StubPortalInlinePlayerComponent)
+        ).componentInstance as StubPortalInlinePlayerComponent;
+        const railItems = inlinePlayer.upNextEpisodes() as Array<{
+            label: string;
+        }>;
+        expect(railItems.map((item) => item.label)).toEqual([
+            'S01E02',
+            'S02E01',
+        ]);
+    });
+});
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.test-harness.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.test-harness.ts
new file mode 100644
index 000000000..d9b043755
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.test-harness.ts
@@ -0,0 +1,273 @@
+import { signal } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { TranslatePipe, TranslateService } from '@ngx-translate/core';
+import { MockPipe } from 'ng-mocks';
+import { SeasonContainerComponent } from '@iptvnator/ui/components';
+import {
+    PORTAL_EXTERNAL_PLAYBACK,
+    PORTAL_PLAYBACK_POSITIONS,
+    PORTAL_PLAYER,
+} from '@iptvnator/portal/shared/util';
+import {
+    StalkerStore,
+    StalkerVodSource,
+} from '@iptvnator/portal/stalker/data-access';
+import { PortalInlinePlayerComponent } from '@iptvnator/ui/playback';
+import { TmdbEnrichmentService } from '@iptvnator/services';
+import { EMPTY, of } from 'rxjs';
+import { FavoritesButtonComponent } from '../stalker-favorites-button/stalker-favorites-button.component';
+import { StalkerSeriesViewComponent } from './stalker-series-view.component';
+import {
+    StubFavoritesButtonComponent,
+    StubPortalInlinePlayerComponent,
+    StubSeasonContainerComponent,
+} from './stalker-series-view.test-helpers';
+
+/**
+ * The slice of a Jest mock the harness drives. This file is part of the
+ * library's own type-check, which has no Jest globals, so a spec hands in
+ * the factory (`() => jest.fn()`) and gets its own mock type back.
+ */
+export interface StalkerSeriesViewTestMock {
+    mockReset(): this;
+    mockClear(): this;
+    mockReturnValue(value: unknown): this;
+    mockResolvedValue(value: unknown): this;
+    mockImplementation(implementation: (...args: never[]) => unknown): this;
+}
+
+/**
+ * The TestBed the Stalker series-view component specs share: the store
+ * signals and collaborator mocks a case drives, and `createFixture()`, which
+ * puts them back to the state every case starts from (a regular series with
+ * one two-episode season, no embedded player) before building the component
+ * with its stubbed children.
+ *
+ * Call it once per `describe`; the mocks live as long as that block.
+ */
+export function createStalkerSeriesViewHarness<
+    TMock extends StalkerSeriesViewTestMock,
+>(createMock: () => TMock) {
+    const selectedContentType = signal<'series' | 'vod'>('series');
+    const selectedItem = signal<StalkerVodSource | null>(null);
+    const serialSeasonsResource = signal<unknown[]>([]);
+    const vodSeriesSeasonsResource = signal<unknown[]>([]);
+    const isSerialSeasonsLoading = signal(false);
+    const fetchVodSeriesEpisodes = createMock();
+    const resolveVodPlayback = createMock();
+    const getSeriesPlaybackPositions = createMock().mockResolvedValue([]);
+    const openResolvedPlayback = createMock();
+    const openExternalPlayback = createMock();
+    const isEmbeddedPlayer = createMock();
+    const tmdbGetSeason = createMock();
+    const fetchLinkToPlay = createMock();
+    const currentPlaylist = signal({
+        _id: 'stalker-1',
+        title: 'Living Room Portal',
+        portalUrl: 'https://stalker.example.test',
+        macAddress: '00:1A:79:12:34:56',
+    });
+
+    async function createFixture(): Promise<
+        ComponentFixture<StalkerSeriesViewComponent>
+    > {
+        selectedContentType.set('series');
+        selectedItem.set({
+            id: '30001',
+            cmd: '/media/file_30001.mpg',
+            info: {
+                name: 'Regular Series',
+                description: 'Series description',
+                movie_image: 'poster.jpg',
+            },
+        });
+        serialSeasonsResource.set([
+            {
+                id: 'season-1',
+                name: 'Season 1',
+                cmd: '/media/file_30001.mpg',
+                series: [1, 2],
+            },
+        ]);
+        vodSeriesSeasonsResource.set([]);
+        isSerialSeasonsLoading.set(false);
+        fetchVodSeriesEpisodes.mockReset();
+        resolveVodPlayback.mockReset();
+        resolveVodPlayback.mockImplementation(
+            async (
+                _cmd?: string,
+                title?: string,
+                thumbnail?: string,
+                _episodeNum?: number,
+                episodeId?: number,
+                startTime?: number
+            ) => ({
+                streamUrl: 'http://stalker.example/episode.mpg',
+                title: title ?? 'Regular Series',
+                thumbnail: thumbnail ?? 'poster.jpg',
+                startTime,
+                contentInfo: {
+                    playlistId: 'stalker-1',
+                    contentXtreamId:
+                        episodeId ?? Number(selectedItem()?.id ?? 0),
+                    contentType: episodeId ? 'episode' : 'vod',
+                    seriesXtreamId: episodeId
+                        ? Number(selectedItem()?.id ?? 0)
+                        : undefined,
+                },
+            })
+        );
+        getSeriesPlaybackPositions.mockClear();
+        getSeriesPlaybackPositions.mockResolvedValue([]);
+        openResolvedPlayback.mockClear();
+        openExternalPlayback.mockReset();
+        isEmbeddedPlayer.mockReset();
+        isEmbeddedPlayer.mockReturnValue(false);
+        tmdbGetSeason.mockReset();
+        tmdbGetSeason.mockResolvedValue({
+            overview: 'Season overview from TMDB',
+            episodes: [],
+        });
+        fetchLinkToPlay
+            .mockReset()
+            .mockResolvedValue('https://cdn.example.test/episode.mpg');
+        currentPlaylist.set({
+            _id: 'stalker-1',
+            title: 'Living Room Portal',
+            portalUrl: 'https://stalker.example.test',
+            macAddress: '00:1A:79:12:34:56',
+        });
+
+        await TestBed.configureTestingModule({
+            imports: [StalkerSeriesViewComponent],
+            providers: [
+                {
+                    provide: StalkerStore,
+                    useValue: {
+                        selectedItem,
+                        selectedContentType,
+                        currentPlaylist,
+                        getSerialSeasonsResource: () => serialSeasonsResource(),
+                        getVodSeriesSeasonsResource: () =>
+                            vodSeriesSeasonsResource(),
+                        isVodSeriesSeasonsLoading: signal(false),
+                        isSerialSeasonsLoading,
+                        fetchVodSeriesEpisodes,
+                        resolveVodPlayback,
+                        fetchLinkToPlay,
+                    },
+                },
+                {
+                    provide: PORTAL_EXTERNAL_PLAYBACK,
+                    useValue: {
+                        activeSession: signal(null),
+                    },
+                },
+                {
+                    provide: PORTAL_PLAYBACK_POSITIONS,
+                    useValue: {
+                        getSeriesPlaybackPositions,
+                        savePlaybackPosition: createMock(),
+                        clearPlaybackPosition: createMock(),
+                    },
+                },
+                {
+                    provide: PORTAL_PLAYER,
+                    useValue: {
+                        isEmbeddedPlayer,
+                        openResolvedPlayback,
+                        openExternalPlayback,
+                    },
+                },
+                {
+                    provide: Router,
+                    useValue: {
+                        navigateByUrl: createMock(),
+                    },
+                },
+                {
+                    provide: TmdbEnrichmentService,
+                    useValue: {
+                        isEnabled: () => true,
+                        getSeason: tmdbGetSeason,
+                    },
+                },
+                {
+                    provide: MatSnackBar,
+                    useValue: {
+                        open: createMock(),
+                    },
+                },
+                {
+                    provide: TranslateService,
+                    useValue: {
+                        instant: (key: string) => key,
+                        get: (key: string) => of(key),
+                        stream: (key: string) => of(key),
+                        currentLang: 'en',
+                        defaultLang: 'en',
+                        // EMPTY (not of(null)): the real TranslatePipe inside
+                        // the detail shell reads `event.lang` from emissions.
+                        onLangChange: EMPTY,
+                        onTranslationChange: EMPTY,
+                        onDefaultLangChange: EMPTY,
+                    },
+                },
+            ],
+        })
+            .overrideComponent(StalkerSeriesViewComponent, {
+                remove: {
+                    imports: [
+                        FavoritesButtonComponent,
+                        PortalInlinePlayerComponent,
+                        SeasonContainerComponent,
+                        TranslatePipe,
+                    ],
+                },
+                add: {
+                    imports: [
+                        StubFavoritesButtonComponent,
+                        StubPortalInlinePlayerComponent,
+                        StubSeasonContainerComponent,
+                        MockPipe(
+                            TranslatePipe,
+                            (
+                                value: string | null | undefined,
+                                params?: Record<string, number>
+                            ) => {
+                                if (value === 'XTREAM.PLAY_EPISODE') {
+                                    return `Play episode ${
+                                        params?.['episode'] ?? '{{episode}}'
+                                    }`;
+                                }
+                                return value ?? '';
+                            }
+                        ),
+                    ],
+                },
+            })
+            .compileComponents();
+
+        return TestBed.createComponent(StalkerSeriesViewComponent);
+    }
+
+    return {
+        selectedContentType,
+        selectedItem,
+        serialSeasonsResource,
+        vodSeriesSeasonsResource,
+        isSerialSeasonsLoading,
+        fetchVodSeriesEpisodes,
+        resolveVodPlayback,
+        getSeriesPlaybackPositions,
+        openResolvedPlayback,
+        openExternalPlayback,
+        isEmbeddedPlayer,
+        tmdbGetSeason,
+        fetchLinkToPlay,
+        currentPlaylist,
+        createFixture,
+    };
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.tmdb-season.spec.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.tmdb-season.spec.ts
new file mode 100644
index 000000000..3440d321c
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-view.tmdb-season.spec.ts
@@ -0,0 +1,192 @@
+import { ComponentFixture } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { StalkerSeriesViewComponent } from './stalker-series-view.component';
+import { createStalkerSeriesViewHarness } from './stalker-series-view.test-harness';
+import { StubSeasonContainerComponent } from './stalker-series-view.test-helpers';
+
+/**
+ * The lazy TMDB season fetch of the Stalker series view: when it runs
+ * relative to the show-level TMDB match and the season resource, and which
+ * TMDB season it asks for.
+ */
+describe('StalkerSeriesViewComponent TMDB season fetch', () => {
+    let fixture: ComponentFixture<StalkerSeriesViewComponent>;
+    const {
+        selectedItem,
+        serialSeasonsResource,
+        isSerialSeasonsLoading,
+        tmdbGetSeason,
+        createFixture,
+    } = createStalkerSeriesViewHarness(() => jest.fn());
+
+    async function stabilize(): Promise<void> {
+        fixture.detectChanges();
+        await fixture.whenStable();
+    }
+
+    beforeEach(async () => {
+        fixture = await createFixture();
+    });
+
+    afterEach(() => {
+        fixture?.destroy();
+    });
+
+    it('fetches the TMDB season once the show-level match arrives after auto-select', async () => {
+        await stabilize();
+        fixture.detectChanges();
+
+        // Season tabs auto-select immediately — usually before the async
+        // show-level enrichment has written tmdb_id.
+        const seasonContainer = fixture.debugElement.query(
+            By.directive(StubSeasonContainerComponent)
+        ).componentInstance as StubSeasonContainerComponent;
+        seasonContainer.seasonSelected.emit('1');
+        await stabilize();
+        expect(tmdbGetSeason).not.toHaveBeenCalled();
+
+        // The TMDB match lands afterwards — the fetch must run now.
+        selectedItem.set({
+            id: '30001',
+            cmd: '/media/file_30001.mpg',
+            info: {
+                name: 'Regular Series',
+                description: 'Series description',
+                movie_image: 'poster.jpg',
+                tmdb_id: 777,
+            },
+        } as never);
+        await stabilize();
+
+        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 1);
+    });
+
+    it('waits for the season map before fetching so a per-season slice gets the title-marked season', async () => {
+        serialSeasonsResource.set([]);
+        selectedItem.set({
+            id: '30001',
+            cmd: '/media/file_30001.mpg',
+            info: {
+                name: 'Regular Series (2 season)',
+                description: 'Series description',
+                movie_image: 'poster.jpg',
+                tmdb_id: 777,
+            },
+        } as never);
+        await stabilize();
+
+        fixture.componentInstance.onSeasonSelected('2');
+        await stabilize();
+
+        // Season resource still loading — fetching now would pass a zero
+        // season count, suppress the title-marker override and cache the
+        // wrong season forever (fetchSeason is idempotent).
+        expect(tmdbGetSeason).not.toHaveBeenCalled();
+
+        serialSeasonsResource.set([
+            {
+                id: 'season-1',
+                name: 'Season 1',
+                cmd: '/media/file_30001.mpg',
+                series: [1, 2],
+            },
+        ]);
+        await stabilize();
+
+        // Single-season slice whose provider season is renumbered to 1:
+        // the title marker names the real TMDB season.
+        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 2);
+    });
+
+    it('gates the fetch on the reloading season resource during detail-to-detail navigation', async () => {
+        await stabilize();
+
+        fixture.componentInstance.onSeasonSelected('1');
+        await stabilize();
+        // No show-level TMDB match yet — nothing fetched for the first item
+        expect(tmdbGetSeason).not.toHaveBeenCalled();
+
+        // Detail-to-detail navigation reuses the component; the new item's
+        // TMDB match can arrive while the season resource reloads and the
+        // map still shows the previous series' seasons.
+        isSerialSeasonsLoading.set(true);
+        selectedItem.set({
+            id: '30002',
+            cmd: '/media/file_30002.mpg',
+            info: {
+                name: 'Other Series (2 season)',
+                description: 'Other description',
+                movie_image: 'poster2.jpg',
+                tmdb_id: 888,
+            },
+        } as never);
+        await stabilize();
+
+        // The new tmdb_id must NOT pair with the previous series' season
+        // context while the resource reloads.
+        expect(tmdbGetSeason).not.toHaveBeenCalled();
+
+        // Once the new item's own seasons land, the fetch runs without a
+        // stale-season fetch. The container selects the corrected key once
+        // the new season map is rendered.
+        serialSeasonsResource.set([
+            {
+                id: 'season-1',
+                name: 'Season 1',
+                cmd: '/media/file_30002.mpg',
+                series: [1, 2],
+            },
+        ]);
+        isSerialSeasonsLoading.set(false);
+        fixture.componentInstance.onSeasonSelected('2');
+        await stabilize();
+        expect(tmdbGetSeason).toHaveBeenCalledWith(888, 2);
+    });
+
+    it('enriches after equal-id navigation once the season resource settles', async () => {
+        await stabilize();
+        fixture.componentInstance.onSeasonSelected('1');
+        await stabilize();
+
+        // Distinct items can reuse a provider id; the loading gate (not an
+        // id comparison) keeps the stale map from being used.
+        isSerialSeasonsLoading.set(true);
+        selectedItem.set({
+            id: '30001',
+            cmd: '/media/file_30001.mpg',
+            info: {
+                name: 'Different Series (3 season)',
+                description: 'Different description',
+                movie_image: 'poster3.jpg',
+                tmdb_id: 999,
+            },
+        } as never);
+        await stabilize();
+        expect(tmdbGetSeason).not.toHaveBeenCalled();
+
+        isSerialSeasonsLoading.set(false);
+        fixture.componentInstance.onSeasonSelected('3');
+        await stabilize();
+        expect(tmdbGetSeason).toHaveBeenCalledWith(999, 3);
+    });
+
+    it('reads the season marker from o_name when name is generic', async () => {
+        selectedItem.set({
+            id: '30001',
+            cmd: '/media/file_30001.mpg',
+            info: {
+                name: 'Regular Series',
+                o_name: 'Regular Series (2 season)',
+                description: 'Series description',
+                movie_image: 'poster.jpg',
+                tmdb_id: 777,
+            },
+        } as never);
+        await stabilize();
+
+        fixture.componentInstance.onSeasonSelected('2');
+        await stabilize();
+
+        expect(tmdbGetSeason).toHaveBeenCalledWith(777, 2);
+    });
+});
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-batch.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-batch.ts
new file mode 100644
index 000000000..73c4d510c
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-batch.ts
@@ -0,0 +1,113 @@
+import type { Logger } from '@iptvnator/portal/shared/util';
+import type { PlaybackPositionData } from '@iptvnator/shared/interfaces';
+import type { SeasonContainerSeriesPlaybackToggleRequest } from '@iptvnator/ui/components';
+import { StalkerSeriesPositionPartialSaveError } from './stalker-series-position-compatibility';
+
+export interface StalkerWatchToggleFeedback {
+    readonly marked: string;
+    readonly unmarked: string;
+    readonly partialMarked: string;
+    readonly partialUnmarked: string;
+    readonly failed: string;
+}
+
+// The marked and partial keys are scope-generic on purpose ("{{count}}
+// episodes marked as watched", "{{count}} marked · {{failed}} failed");
+// only unmark-success and failure name their scope.
+export const SEASON_WATCH_FEEDBACK: StalkerWatchToggleFeedback = {
+    marked: 'XTREAM.SEASON_MARKED_WATCHED',
+    unmarked: 'XTREAM.SEASON_MARKED_UNWATCHED',
+    partialMarked: 'XTREAM.SEASON_MARKED_WATCHED_PARTIAL',
+    partialUnmarked: 'XTREAM.SEASON_MARKED_UNWATCHED_PARTIAL',
+    failed: 'XTREAM.SEASON_WATCH_UPDATE_FAILED',
+};
+
+export const SERIES_WATCH_FEEDBACK: StalkerWatchToggleFeedback = {
+    marked: 'XTREAM.SEASON_MARKED_WATCHED',
+    unmarked: 'XTREAM.SERIES_MARKED_UNWATCHED',
+    partialMarked: 'XTREAM.SEASON_MARKED_WATCHED_PARTIAL',
+    partialUnmarked: 'XTREAM.SEASON_MARKED_UNWATCHED_PARTIAL',
+    failed: 'XTREAM.SERIES_WATCH_UPDATE_FAILED',
+};
+
+/** One watched/unwatched batch and what it needs from the page running it. */
+export interface StalkerWatchToggleBatch {
+    readonly request: SeasonContainerSeriesPlaybackToggleRequest;
+    readonly playlistId: string;
+    /** Whether the page still shows the series the batch was started on. */
+    readonly stillCurrent: () => boolean;
+    readonly feedback: StalkerWatchToggleFeedback;
+    readonly persist: (
+        playlistId: string,
+        position: PlaybackPositionData
+    ) => Promise<void>;
+    readonly clear: (
+        playlistId: string,
+        contentXtreamId: number
+    ) => Promise<void>;
+    /** Re-reads the catalog grid's progress badges; must not reject. */
+    readonly refreshCatalogPositions: (
+        playlistId: string
+    ) => Promise<void> | undefined;
+    /** Shows the translated feedback for `key`. */
+    readonly notify: (key: string, params?: object) => void;
+    readonly logger: Logger;
+}
+
+export async function runStalkerWatchToggleBatch(
+    batch: StalkerWatchToggleBatch
+): Promise<void> {
+    const { request, playlistId, feedback } = batch;
+    // Enqueue every episode synchronously: each mutation chains on
+    // the previous one's never-rejecting barrier, so the queue
+    // serializes the writes (incl. per-episode legacy-row cleanup)
+    // and reloads positions once after the whole chain drains.
+    const outcomes = await Promise.all(
+        request.requests.map((item) =>
+            (item.nextPosition
+                ? batch.persist(playlistId, item.nextPosition)
+                : batch.clear(playlistId, item.contentXtreamId)
+            ).then(
+                () => true,
+                // The scoped watched row was saved and published —
+                // only the legacy-row cleanup failed. The episode IS
+                // watched, so it must not count against the batch.
+                (error: unknown) =>
+                    error instanceof StalkerSeriesPositionPartialSaveError
+            )
+        )
+    );
+
+    const failed = outcomes.filter((ok) => !ok).length;
+    const succeeded = outcomes.length - failed;
+    if (failed > 0) {
+        batch.logger.error(
+            `Watched toggle: ${failed} of ${outcomes.length} episodes failed`
+        );
+    }
+    if (succeeded > 0) {
+        // Partial successes changed rows too — the catalog badge
+        // must follow even when the user already moved on. A failed
+        // refresh must not break the feedback flow below.
+        await batch.refreshCatalogPositions(playlistId);
+    }
+    if (!batch.stillCurrent()) {
+        return;
+    }
+
+    if (failed === 0) {
+        batch.notify(
+            request.markWatched ? feedback.marked : feedback.unmarked,
+            { count: succeeded }
+        );
+    } else if (succeeded > 0) {
+        batch.notify(
+            request.markWatched
+                ? feedback.partialMarked
+                : feedback.partialUnmarked,
+            { count: succeeded, failed }
+        );
+    } else {
+        batch.notify(feedback.failed);
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-toggle.service.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-toggle.service.ts
new file mode 100644
index 000000000..98fdb20a8
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-series-watch-toggle.service.ts
@@ -0,0 +1,323 @@
+import { Injectable, Signal, inject, signal } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { TranslateService } from '@ngx-translate/core';
+import {
+    createLogger,
+    isPortalPlaybackWatched,
+} from '@iptvnator/portal/shared/util';
+import {
+    isVodSeasonHydrationPending,
+    StalkerStore,
+    type StalkerSelectedVodItem,
+    type VodSeriesSeasonVm,
+} from '@iptvnator/portal/stalker/data-access';
+import type { XtreamSerieEpisode } from '@iptvnator/shared/interfaces';
+import {
+    buildSeriesWatchToggleRequest,
+    type SeasonContainerPlaybackToggleRequest,
+    type SeasonContainerSeasonPlaybackToggleRequest,
+    type SeasonContainerSeriesPlaybackToggleRequest,
+} from '@iptvnator/ui/components';
+import { StalkerCatalogFacadeService } from '../stalker-catalog-facade.service';
+import { toStalkerSeriesId } from './stalker-series-id';
+import { StalkerSeriesPositionsService } from './stalker-series-positions.service';
+import {
+    runStalkerWatchToggleBatch,
+    SEASON_WATCH_FEEDBACK,
+    SERIES_WATCH_FEEDBACK,
+    type StalkerWatchToggleFeedback,
+} from './stalker-series-watch-batch';
+
+interface StalkerSeriesWatchToggleBindings {
+    readonly displayItem: Signal<StalkerSelectedVodItem | null>;
+    /** `playlist:series` of the series on screen. */
+    readonly currentSeriesKey: Signal<string>;
+    readonly isVodSeries: Signal<boolean>;
+    readonly vodSeriesSeasons: Signal<VodSeriesSeasonVm[]>;
+    readonly mappedSeasons: Signal<Record<string, XtreamSerieEpisode[]>>;
+    /** Episodes playing or launching, which a series toggle never marks. */
+    readonly excludedEpisodeIds: () => ReadonlySet<number>;
+    /** Resolves true when the portal answered, false when the request failed. */
+    readonly loadEpisodesForSeason: (
+        season: VodSeriesSeasonVm
+    ) => Promise<boolean>;
+}
+
+/**
+ * Watched toggles of the Stalker series view: one episode, a season or the
+ * whole series (which also backs "Reset progress"). Component-scoped
+ * (provide it in the component's `providers`).
+ */
+@Injectable()
+export class StalkerSeriesWatchToggleService {
+    private readonly stalkerStore = inject(StalkerStore);
+    private readonly positions = inject(StalkerSeriesPositionsService);
+    private readonly snackBar = inject(MatSnackBar);
+    private readonly translateService = inject(TranslateService);
+    // Optional: absent in collection-detail mounts outside the catalog.
+    private readonly catalogFacade = inject(StalkerCatalogFacadeService, {
+        optional: true,
+    });
+    private readonly logger = createLogger('StalkerSeriesView');
+    private readonly bindings = signal<StalkerSeriesWatchToggleBindings | null>(
+        null
+    );
+    readonly seasonWatchBatchRunning = signal(false);
+    /**
+     * The episode chosen while a watched/reset batch still rewrote the rows
+     * a start resumes from; the last choice plays once the batch settled,
+     * and only on the series it was made for.
+     */
+    private choiceHeldForBatch: {
+        readonly seriesKey: string;
+        readonly play: () => void;
+    } | null = null;
+
+    bind(bindings: StalkerSeriesWatchToggleBindings): void {
+        this.bindings.set(bindings);
+    }
+
+    /** Holds `play` until the running batch settled, replacing an earlier choice. */
+    holdChoice(play: () => void): void {
+        this.choiceHeldForBatch = {
+            seriesKey: this.currentSeriesKey(),
+            play,
+        };
+    }
+
+    async handlePlaybackToggleRequested(
+        request: SeasonContainerPlaybackToggleRequest
+    ): Promise<void> {
+        const playlistId = this.stalkerStore.currentPlaylist()?._id;
+        if (!playlistId) {
+            return;
+        }
+
+        if (request.nextPosition) {
+            await this.positions.persistSeriesPosition(
+                playlistId,
+                request.nextPosition
+            );
+        } else {
+            await this.positions.clearSeriesPosition(
+                playlistId,
+                request.contentXtreamId
+            );
+        }
+        // Keep the catalog grid's progress badge in sync (ownership-checked
+        // inside the facade; no-op outside the catalog context). A failed
+        // refresh keeps the cache populated-but-stale.
+        await this.catalogFacade
+            ?.refreshPositions(playlistId)
+            .catch((error: unknown) =>
+                this.logger.warn('Catalog position refresh failed', error)
+            );
+    }
+
+    async handleSeasonPlaybackToggleRequested(
+        request: SeasonContainerSeasonPlaybackToggleRequest
+    ): Promise<void> {
+        const playlistId = this.stalkerStore.currentPlaylist()?._id;
+        if (
+            !playlistId ||
+            request.requests.length === 0 ||
+            this.seasonWatchBatchRunning()
+        ) {
+            return;
+        }
+        // The mutation context already keeps a stale batch out of the next
+        // series' state; the snackbars need the same ownership so feedback
+        // for the old season is not presented on a newly opened page.
+        const seriesXtreamId = this.shownSeriesId();
+        const stillCurrent = () =>
+            this.stalkerStore.currentPlaylist()?._id === playlistId &&
+            this.shownSeriesId() === seriesXtreamId;
+
+        this.seasonWatchBatchRunning.set(true);
+        try {
+            await this.runWatchToggleBatch(
+                request,
+                playlistId,
+                stillCurrent,
+                SEASON_WATCH_FEEDBACK
+            );
+        } finally {
+            this.endWatchBatch();
+        }
+    }
+
+    async handleSeriesPlaybackToggleRequested(
+        request: SeasonContainerSeriesPlaybackToggleRequest
+    ): Promise<void> {
+        const bindings = this.bindings();
+        const playlistId = this.stalkerStore.currentPlaylist()?._id;
+        if (!bindings || !playlistId || this.seasonWatchBatchRunning()) {
+            return;
+        }
+        const pendingSeasons = bindings.isVodSeries()
+            ? bindings
+                  .vodSeriesSeasons()
+                  .filter((season) => isVodSeasonHydrationPending(season))
+            : [];
+        // An empty request is only meaningful when unloaded seasons remain:
+        // every loaded episode is watched, so the container could not build
+        // a target list, but hydration below may still surface unwatched
+        // episodes to mark.
+        if (request.requests.length === 0 && pendingSeasons.length === 0) {
+            return;
+        }
+
+        const seriesXtreamId = this.shownSeriesId();
+        const stillCurrent = () =>
+            this.stalkerStore.currentPlaylist()?._id === playlistId &&
+            this.shownSeriesId() === seriesXtreamId;
+
+        this.seasonWatchBatchRunning.set(true);
+        try {
+            let effective: SeasonContainerSeriesPlaybackToggleRequest | null =
+                request;
+            if (pendingSeasons.length > 0) {
+                const hydrated = await this.hydrateSeasonsForSeriesToggle(
+                    bindings,
+                    pendingSeasons,
+                    stillCurrent
+                );
+                if (hydrated !== 'complete') {
+                    if (hydrated === 'failed' && stillCurrent()) {
+                        this.notifySeasonWatchToggle(
+                            SERIES_WATCH_FEEDBACK.failed
+                        );
+                    }
+                    return;
+                }
+                // The reconcile effect only flushes on the next change-
+                // detection tick; rebuild the maps synchronously so the
+                // batch below sees the hydrated episodes' scoped and legacy
+                // rows (see applyReconciledSeriesPositions).
+                this.positions.applyReconciledSeriesPositions();
+                effective = buildSeriesWatchToggleRequest({
+                    seasons: bindings.mappedSeasons(),
+                    seriesId: seriesXtreamId,
+                    playlistId,
+                    isEpisodeWatched: (episode) =>
+                        isPortalPlaybackWatched(
+                            this.positions
+                                .episodePlaybackPositions()
+                                .get(Number(episode.id))
+                        ),
+                    excludedEpisodeIds: bindings.excludedEpisodeIds(),
+                    // Keep the direction the user clicked; re-inference over
+                    // the now-complete data could flip a "mark" into an
+                    // unwatch when everything turned out watched.
+                    markWatched: request.markWatched,
+                });
+                if (!effective) {
+                    if (stillCurrent()) {
+                        this.notifySeasonWatchToggle(
+                            SERIES_WATCH_FEEDBACK.marked,
+                            { count: 0 }
+                        );
+                    }
+                    return;
+                }
+            }
+
+            await this.runWatchToggleBatch(
+                effective,
+                playlistId,
+                stillCurrent,
+                SERIES_WATCH_FEEDBACK
+            );
+        } finally {
+            this.endWatchBatch();
+        }
+    }
+
+    private currentSeriesKey(): string {
+        return this.bindings()?.currentSeriesKey() ?? '';
+    }
+
+    private shownSeriesId(): number {
+        return toStalkerSeriesId(this.bindings()?.displayItem()?.id ?? 0);
+    }
+
+    /**
+     * The batch settled: the choice held meanwhile goes through the usual
+     * gates, unless the viewer switched series since. Episode identities
+     * overlap across series, so it must never resolve against another one.
+     */
+    private endWatchBatch(): void {
+        this.seasonWatchBatchRunning.set(false);
+        const held = this.choiceHeldForBatch;
+        this.choiceHeldForBatch = null;
+        if (held && held.seriesKey === this.currentSeriesKey()) {
+            held.play();
+        }
+    }
+
+    /**
+     * Sequential on purpose: loadEpisodesForSeason snapshots the season VM
+     * array before its writes, so concurrent calls clobber each other's
+     * loading flags; and one request at a time keeps the portal load bounded.
+     */
+    private async hydrateSeasonsForSeriesToggle(
+        bindings: StalkerSeriesWatchToggleBindings,
+        pendingSeasons: readonly VodSeriesSeasonVm[],
+        stillCurrent: () => boolean
+    ): Promise<'complete' | 'failed' | 'superseded'> {
+        for (const season of pendingSeasons) {
+            // A tab click may have loaded this season meanwhile.
+            const current = bindings
+                .vodSeriesSeasons()
+                .find((candidate) => candidate.id === season.id);
+            if (!current || !isVodSeasonHydrationPending(current)) {
+                continue;
+            }
+            const answered = await bindings.loadEpisodesForSeason(current);
+            if (!stillCurrent()) {
+                return 'superseded';
+            }
+            if (!answered) {
+                return 'failed';
+            }
+        }
+        return 'complete';
+    }
+
+    private runWatchToggleBatch(
+        request: SeasonContainerSeriesPlaybackToggleRequest,
+        playlistId: string,
+        stillCurrent: () => boolean,
+        feedback: StalkerWatchToggleFeedback
+    ): Promise<void> {
+        return runStalkerWatchToggleBatch({
+            request,
+            playlistId,
+            stillCurrent,
+            feedback,
+            persist: (id, position) =>
+                this.positions.persistSeriesPosition(id, position),
+            clear: (id, contentXtreamId) =>
+                this.positions.clearSeriesPosition(id, contentXtreamId),
+            refreshCatalogPositions: (id) =>
+                this.catalogFacade
+                    ?.refreshPositions(id)
+                    .catch((error: unknown) =>
+                        this.logger.warn(
+                            'Catalog position refresh failed',
+                            error
+                        )
+                    ),
+            notify: (key, params) => this.notifySeasonWatchToggle(key, params),
+            logger: this.logger,
+        });
+    }
+
+    private notifySeasonWatchToggle(key: string, params?: object): void {
+        this.snackBar.open(
+            this.translateService.instant(key, params),
+            undefined,
+            { duration: 5000 }
+        );
+    }
+}
diff --git a/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-vod-season-episode-loader.ts b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-vod-season-episode-loader.ts
new file mode 100644
index 000000000..585f71e05
--- /dev/null
+++ b/libs/portal/stalker/feature/src/lib/stalker-series-view/stalker-vod-season-episode-loader.ts
@@ -0,0 +1,125 @@
+import type { WritableSignal } from '@angular/core';
+import {
+    getVodSeriesSeasonKey,
+    type VodSeriesSeasonVm,
+} from '@iptvnator/portal/stalker/data-access';
+
+/** What the loader needs from the page that shows the seasons. */
+export interface StalkerVodSeasonEpisodeLoaderHost {
+    /** Seasons of the series on screen; a load writes its loading flag and episodes here. */
+    readonly seasons: WritableSignal<VodSeriesSeasonVm[]>;
+    /** Identity of the series on screen: part of the key in-flight loads are shared by. */
+    readonly ownerKey: () => string;
+    readonly fetchEpisodes: (
+        videoId: string,
+        seasonId: string
+    ) => Promise<VodSeriesSeasonVm['episodes']>;
+    readonly logError: (message: string, error: unknown) => void;
+}
+
+/** Lazy episode loads of Ministra VOD-series seasons (`is_series=1`). */
+export class StalkerVodSeasonEpisodeLoader {
+    private readonly loads = new Map<
+        string,
+        { season: VodSeriesSeasonVm; promise: Promise<boolean> }
+    >();
+
+    constructor(private readonly host: StalkerVodSeasonEpisodeLoaderHost) {}
+
+    /**
+     * Loads episodes for a specific VOD season.
+     *
+     * Single-flight per season: a tab click, the spillover prefetch, the
+     * quick-start recursion, and the series-toggle hydration can all ask for
+     * the same season — a second concurrent request would duplicate portal
+     * traffic, and its failure could abort a series toggle whose original
+     * request succeeded.
+     */
+    /** Resolves true when the portal answered, false when the request failed. */
+    load(season: VodSeriesSeasonVm): Promise<boolean> {
+        const key = JSON.stringify([
+            this.host.ownerKey(),
+            season.video_id,
+            season.id,
+            getVodSeriesSeasonKey(season),
+        ]);
+        const inFlight = this.loads.get(key);
+        if (inFlight && this.host.seasons().includes(inFlight.season)) {
+            return inFlight.promise;
+        }
+        const load = this.fetch(season).finally(() => {
+            if (this.loads.get(key)?.promise === load) {
+                this.loads.delete(key);
+            }
+        });
+        const loadingSeason = this.host
+            .seasons()
+            .find(
+                (candidate) =>
+                    candidate.id === season.id &&
+                    candidate.video_id === season.video_id
+            );
+        if (loadingSeason) {
+            this.loads.set(key, {
+                season: loadingSeason,
+                promise: load,
+            });
+        }
+        return load;
+    }
+
+    private async fetch(season: VodSeriesSeasonVm): Promise<boolean> {
+        // Set loading state in local signal
+        const seasons = this.host.seasons();
+        const index = seasons.findIndex(
+            (s) =>
+                s.id === season.id &&
+                s.video_id === season.video_id &&
+                getVodSeriesSeasonKey(s) === getVodSeriesSeasonKey(season)
+        );
+        if (index === -1) return false;
+
+        const updatedSeasons = [...seasons];
+        const loadingSeason = { ...updatedSeasons[index], isLoading: true };
+        updatedSeasons[index] = loadingSeason;
+        this.host.seasons.set(updatedSeasons);
+
+        try {
+            const episodes = await this.host.fetchEpisodes(
+                season.video_id,
+                season.id
+            );
+
+            // Update with loaded episodes
+            const newSeasons = [...this.host.seasons()];
+            // Only the exact loading VM owns this response. A navigation or
+            // refresh can reuse provider ids while replacing the season list.
+            const newIndex = newSeasons.indexOf(loadingSeason);
+            if (newIndex !== -1) {
+                newSeasons[newIndex] = {
+                    ...newSeasons[newIndex],
+                    episodes: episodes,
+                    // Even an EMPTY answer marks the season loaded: the
+                    // portal spoke, so it must stop counting as "unloaded"
+                    // (label/verdict gating and series-toggle hydration).
+                    episodesLoaded: true,
+                    isLoading: false,
+                };
+                this.host.seasons.set(newSeasons);
+            }
+            return newIndex !== -1;
+        } catch (error) {
+            this.host.logError('Failed to load episodes', error);
+            const newSeasons = [...this.host.seasons()];
+            const newIndex = newSeasons.indexOf(loadingSeason);
+            if (newIndex !== -1) {
+                newSeasons[newIndex] = {
+                    ...newSeasons[newIndex],
+                    isLoading: false,
+                };
+                this.host.seasons.set(newSeasons);
+            }
+            return false;
+        }
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/search-results/search-results.component.html b/libs/portal/xtream/feature/src/lib/search-results/search-results.component.html
index c54dfdef3..d4443bf8e 100644
--- a/libs/portal/xtream/feature/src/lib/search-results/search-results.component.html
+++ b/libs/portal/xtream/feature/src/lib/search-results/search-results.component.html
@@ -3,7 +3,7 @@
     [resultsCount]="xtreamStore.searchResults().length"
     [isLoading]="xtreamStore.isSearching()"
     [showCloseButton]="false"
-    [showBackButton]="showBackButton"
+    [backAvailable]="backAvailable"
     [showResultsCount]="!isGlobalSearch || !groupByPlaylist()"
     [showSearchInput]="showInlineSearchInput"
     [minSearchLength]="minSearchLength"
diff --git a/libs/portal/xtream/feature/src/lib/search-results/search-results.component.ts b/libs/portal/xtream/feature/src/lib/search-results/search-results.component.ts
index 117a8252d..cfa8c7e44 100644
--- a/libs/portal/xtream/feature/src/lib/search-results/search-results.component.ts
+++ b/libs/portal/xtream/feature/src/lib/search-results/search-results.component.ts
@@ -575,11 +575,12 @@ export class SearchResultsComponent implements AfterViewInit {
 
     /**
      * The in-portal search is a nested view (reached from the toolbar
-     * search box or an actor page); the global search is a top-level
-     * sidebar destination, and the dialog has its own close button — a
-     * back arrow there would navigate the page behind the open dialog.
+     * search box or an actor page), so it offers the header's Back; the
+     * global search is a top-level sidebar destination, and the dialog has
+     * its own close button — a Back there would navigate the page behind
+     * the open dialog.
      */
-    get showBackButton(): boolean {
+    get backAvailable(): boolean {
         return (
             this.isWorkspaceLayout && !this.isGlobalSearch && !this.dialogRef
         );
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-external-launch.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-external-launch.ts
index 1b7b16a75..699069e5b 100644
--- a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-external-launch.ts
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-external-launch.ts
@@ -198,10 +198,11 @@ function closeOwnedEpisodeSession(
  * still running externally is closed first: with instance reuse off a
  * second detached player would start beside it. When that close fails, or
  * the user moved on while it ran, the running player stays and nothing new
- * launches. A repeat of the same episode before its launch settled
- * (Electron publishes the session only afterwards) is ignored; another
- * episode of the series waits for that launch to settle and then replaces
- * it like any later start.
+ * launches. A repeat of the same episode before its launch settled is
+ * ignored (the session cannot stand in for this guard: Electron publishes
+ * it only once the launch IPC arrives, as `launching` until that resolves);
+ * another episode of the series waits for that launch to settle and then
+ * replaces it like any later start.
  */
 export async function openEpisodeExternally(
     host: SeriesExternalLaunchHost,
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-playback.service.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-playback.service.ts
index 023dd595e..0ebc12109 100644
--- a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-playback.service.ts
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-playback.service.ts
@@ -23,7 +23,6 @@ import {
     ExternalPlayerName,
     ExternalPlayerSession,
     PlaybackPositionData,
-    PlayerContentInfo,
     ResolvedPortalPlayback,
     XtreamSerieDetails,
     XtreamSerieEpisode,
@@ -37,7 +36,6 @@ import {
     getSeriesPlaybackNavigation,
     inlineSeriesEpisodeState,
     type PlaybackFallbackRequest,
-    resolveSeriesPlaybackEpisodeState,
     type SeriesPlaybackEpisodeState,
 } from '@iptvnator/ui/playback';
 import { injectXtreamRecentHistory } from '../xtream-recent-history';
@@ -53,6 +51,8 @@ import {
     SerialDetailsSeasonWatchService,
     type SerialDetailsWatchScope,
 } from './serial-details-season-watch.service';
+import { SerialDetailsWatchToggles } from './serial-details-watch-toggles';
+import { buildSerialEpisodePlayback } from './serial-episode-playback';
 
 export type XtreamSerieDetailsView = XtreamSerieDetails & {
     readonly series_id: number;
@@ -97,6 +97,15 @@ export class SerialDetailsPlaybackService {
     );
     private readonly playbackPositionState =
         new SerialDetailsPlaybackPositionState();
+    private readonly watchToggles = new SerialDetailsWatchToggles({
+        playbackPositions: this.playbackPositions,
+        seasonWatch: this.seasonWatch,
+        state: this.playbackPositionState,
+        playlistId: () => this.currentPlaylistId(),
+        seriesXtreamId: () => Number(this.selectedItem()?.series_id ?? 0),
+        reloadStorePositions: (playlistId) =>
+            this.xtreamStore.loadAllPositions(playlistId),
+    });
     private lastSaveTime = 0;
 
     readonly inlinePlayback = signal<ResolvedPortalPlayback | null>(null);
@@ -229,32 +238,15 @@ export class SerialDetailsPlaybackService {
             contentType: 'series',
             backdropUrl: selectedItem.info?.backdrop_path?.[0],
         });
-        const contentInfo: PlayerContentInfo = {
-            playlistId: playlist.id,
-            contentXtreamId: Number(episode.id),
-            contentType: 'episode',
-            seriesXtreamId: Number(selectedItem.series_id),
-            seasonNumber: Number(episode.season),
-            episodeNumber: Number(episode.episode_num),
-        };
-
         const position = this.episodePlaybackPositions().get(
             Number(episode.id)
         );
-
-        const playback: ResolvedPortalPlayback = {
+        const { playback, episodeState } = buildSerialEpisodePlayback({
+            playlistId: playlist.id,
+            selectedItem,
+            episode,
             streamUrl,
-            title: episode.title,
-            thumbnail: selectedItem.info.cover,
             startTime: position?.positionSeconds,
-            contentInfo,
-        };
-
-        const episodeState = resolveSeriesPlaybackEpisodeState({
-            episodesBySeason: selectedItem.episodes,
-            currentEpisodeId: episode.id,
-            fallbackSeasonNumber: Number(episode.season),
-            fallbackEpisodeNumber: Number(episode.episode_num),
         });
         return this.startPlayback(playback, episodeState, player);
     }
@@ -322,68 +314,17 @@ export class SerialDetailsPlaybackService {
         );
     }
 
-    async handlePlaybackToggleRequested(
+    handlePlaybackToggleRequested(
         request: SeasonContainerPlaybackToggleRequest
     ): Promise<void> {
-        const playlistId = this.currentPlaylistId();
-        if (!playlistId) {
-            return;
-        }
-
-        if (request.nextPosition) {
-            await this.playbackPositions.savePlaybackPosition(
-                playlistId,
-                request.nextPosition
-            );
-            this.playbackPositionState.update(request.nextPosition);
-        } else {
-            await this.playbackPositions.clearPlaybackPosition(
-                playlistId,
-                request.contentXtreamId,
-                'episode'
-            );
-            this.playbackPositionState.remove(request.contentXtreamId);
-        }
-        await this.refreshStorePositions(playlistId);
+        return this.watchToggles.toggleEpisode(request);
     }
 
-    async handleWatchToggleRequested(
+    handleWatchToggleRequested(
         request: SeasonContainerSeriesPlaybackToggleRequest,
         scope: SerialDetailsWatchScope
     ): Promise<void> {
-        const playlistId = this.currentPlaylistId();
-        const seriesXtreamId = Number(this.selectedItem()?.series_id ?? 0);
-        const persisted = await this.seasonWatch.handle(
-            request,
-            playlistId,
-            this.playbackPositionState,
-            () =>
-                this.currentPlaylistId() === playlistId &&
-                Number(this.selectedItem()?.series_id ?? 0) === seriesXtreamId,
-            scope
-        );
-        if (persisted) {
-            await this.refreshStorePositions(playlistId);
-        }
-    }
-
-    /**
-     * The catalog reads series progress from XtreamStore, whose positions
-     * load once per playlist (XtreamCatalogFacadeService.initialize), so a
-     * toggle must push the change back or badges go stale on return. Skipped
-     * after a playlist switch — the store then holds the other playlist.
-     */
-    private async refreshStorePositions(playlistId: string): Promise<void> {
-        if (this.currentPlaylistId() !== playlistId) {
-            return;
-        }
-        try {
-            await this.xtreamStore.loadAllPositions(playlistId);
-        } catch (error) {
-            // The toggle itself succeeded; a failed refresh keeps the store
-            // populated-but-stale, which beats wiping it with a bad read.
-            this.logger.warn('Store position refresh failed', error);
-        }
+        return this.watchToggles.toggleBatch(request, scope);
     }
 
     async loadSeriesPlaybackPositions(
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-route.service.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-route.service.ts
new file mode 100644
index 000000000..c819a3631
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-route.service.ts
@@ -0,0 +1,75 @@
+import { computed, inject, Injectable, signal } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute } from '@angular/router';
+import { isProviderOnlyDetailState } from '@iptvnator/portal/shared/util';
+import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
+import { SerialDetailsPlaybackService } from './serial-details-playback.service';
+
+/**
+ * Route side of the series page: its params, the provider-only flag of the
+ * navigation that opened it, and the (re)load of the series the route
+ * addresses.
+ */
+@Injectable()
+export class SerialDetailsRouteService {
+    private readonly route = inject(ActivatedRoute);
+    private readonly xtreamStore = inject(XtreamStore);
+    private readonly playback = inject(SerialDetailsPlaybackService);
+    /** `playlistId:categoryId:serialId` of the last initialized view */
+    private readonly lastInitKey = signal<string | null>(null);
+
+    /**
+     * Reactive route params: the component is reused when navigating
+     * between two series details (e.g. via the Similar rail).
+     */
+    readonly params = toSignal(this.route.params, {
+        initialValue: this.route.snapshot.params,
+    });
+    readonly providerOnly = computed(() => {
+        this.params();
+        return isProviderOnlyDetailState(window.history.state);
+    });
+
+    /**
+     * Initializes on first render and RE-initializes when the route params
+     * change while the component is reused (Similar rail). Reads signals, so
+     * the owning component runs it from an effect.
+     */
+    loadAddressedSeries(): void {
+        const playlistId = this.xtreamStore.currentPlaylist()?.id;
+        const { categoryId, serialId } = this.params();
+        if (!playlistId || !serialId) {
+            return;
+        }
+
+        const initKey = `${playlistId}:${categoryId}:${serialId}`;
+        if (this.lastInitKey() === initKey) {
+            return;
+        }
+        this.lastInitKey.set(initKey);
+
+        this.playback.resetForNewSeries();
+        this.initializeSerialDetails(playlistId, categoryId, serialId);
+    }
+
+    private initializeSerialDetails(
+        playlistId: string,
+        categoryId: string | number,
+        serialId: string
+    ): void {
+        this.xtreamStore.fetchSerialDetailsWithMetadata({
+            serialId,
+            categoryId: Number(categoryId),
+        });
+        const serialXtreamId = Number(serialId);
+        this.xtreamStore.checkFavoriteStatus(
+            serialXtreamId,
+            playlistId,
+            'series'
+        );
+        void this.playback.loadSeriesPlaybackPositions(
+            playlistId,
+            serialXtreamId
+        );
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-seasons.service.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-seasons.service.ts
new file mode 100644
index 000000000..7da3ed964
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-seasons.service.ts
@@ -0,0 +1,75 @@
+import {
+    computed,
+    effect,
+    inject,
+    Injectable,
+    Signal,
+    signal,
+    untracked,
+} from '@angular/core';
+import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
+import { buildSeasonDescriptions } from './season-descriptions.util';
+import { buildSeasonPosters } from './season-posters.util';
+import type { XtreamSerieDetailsView } from './serial-details-playback.service';
+
+interface SerialDetailsSeasonsBindings {
+    readonly selectedItem: Signal<XtreamSerieDetailsView | null>;
+}
+
+/**
+ * Season presentation of the series page: the descriptions and posters the
+ * season container and the inline player show, and the TMDB enrichment of
+ * the season the viewer selected.
+ */
+@Injectable()
+export class SerialDetailsSeasonsService {
+    private readonly xtreamStore = inject(XtreamStore);
+    private readonly bindings = signal<SerialDetailsSeasonsBindings | null>(
+        null
+    );
+    private readonly selectedItem = computed(
+        () => this.bindings()?.selectedItem() ?? null
+    );
+
+    /** Season currently selected in the season container. */
+    private readonly selectedSeasonKey = signal<string | null>(null);
+
+    /** Season descriptions (provider text, TMDB fallback, URL junk dropped). */
+    readonly descriptions = computed<Record<string, string>>(() =>
+        buildSeasonDescriptions(this.selectedItem())
+    );
+
+    /** Season posters (TMDB season poster first, provider season cover next). */
+    readonly posters = computed<Record<string, string>>(() =>
+        buildSeasonPosters(this.selectedItem())
+    );
+
+    constructor() {
+        // TMDB season enrichment, keyed on (tmdb_id, selected season). With
+        // season tabs the first seasonSelected fires as soon as seasons load —
+        // usually BEFORE the async show-level TMDB match has written
+        // info.tmdb_id, and enrichSelectedSerialSeason no-ops without it. So
+        // the call must re-run when the match arrives, not only on selection.
+        // The store-side enrichment is idempotent per (serial, season).
+        effect(() => {
+            const tmdbId = this.selectedItem()?.info?.tmdb_id;
+            const seasonKey = this.selectedSeasonKey();
+            if (tmdbId && seasonKey) {
+                untracked(() =>
+                    this.xtreamStore.enrichSelectedSerialSeason(seasonKey)
+                );
+            }
+        });
+    }
+
+    /** Connects the service to the owning component's reactive state. */
+    bind(bindings: SerialDetailsSeasonsBindings): void {
+        this.bindings.set(bindings);
+    }
+
+    select(seasonKey: string): void {
+        // The enrichment call itself runs from the constructor effect keyed
+        // on (tmdb_id, selectedSeasonKey) — see the race note there.
+        this.selectedSeasonKey.set(seasonKey);
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details-watch-toggles.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-watch-toggles.ts
new file mode 100644
index 000000000..e3df80803
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details-watch-toggles.ts
@@ -0,0 +1,104 @@
+import {
+    createLogger,
+    type PortalPlaybackPositions,
+} from '@iptvnator/portal/shared/util';
+import type {
+    SeasonContainerPlaybackToggleRequest,
+    SeasonContainerSeriesPlaybackToggleRequest,
+} from '@iptvnator/ui/components';
+import type { SerialDetailsPlaybackPositionState } from './serial-details-playback-position-state';
+import type {
+    SerialDetailsSeasonWatchService,
+    SerialDetailsWatchScope,
+} from './serial-details-season-watch.service';
+
+const logger = createLogger('SerialDetailsPlayback');
+
+/** What the watched toggles of the series page persist through and report to. */
+export interface SerialDetailsWatchToggleDeps {
+    readonly playbackPositions: Pick<
+        PortalPlaybackPositions,
+        'savePlaybackPosition' | 'clearPlaybackPosition'
+    >;
+    readonly seasonWatch: Pick<SerialDetailsSeasonWatchService, 'handle'>;
+    readonly state: SerialDetailsPlaybackPositionState;
+    /** Playlist on screen, empty while none is current. */
+    readonly playlistId: () => string;
+    /** Series on screen, 0 while none is selected. */
+    readonly seriesXtreamId: () => number;
+    /** Reloads the catalog store's positions of a playlist. */
+    readonly reloadStorePositions: (playlistId: string) => Promise<unknown>;
+}
+
+/**
+ * Episode, season and series watched toggles of the series page: persists
+ * the change, mirrors it into the page's position state, and pushes it back
+ * to the catalog store.
+ */
+export class SerialDetailsWatchToggles {
+    constructor(private readonly deps: SerialDetailsWatchToggleDeps) {}
+
+    async toggleEpisode(
+        request: SeasonContainerPlaybackToggleRequest
+    ): Promise<void> {
+        const playlistId = this.deps.playlistId();
+        if (!playlistId) {
+            return;
+        }
+
+        if (request.nextPosition) {
+            await this.deps.playbackPositions.savePlaybackPosition(
+                playlistId,
+                request.nextPosition
+            );
+            this.deps.state.update(request.nextPosition);
+        } else {
+            await this.deps.playbackPositions.clearPlaybackPosition(
+                playlistId,
+                request.contentXtreamId,
+                'episode'
+            );
+            this.deps.state.remove(request.contentXtreamId);
+        }
+        await this.refreshStorePositions(playlistId);
+    }
+
+    async toggleBatch(
+        request: SeasonContainerSeriesPlaybackToggleRequest,
+        scope: SerialDetailsWatchScope
+    ): Promise<void> {
+        const playlistId = this.deps.playlistId();
+        const seriesXtreamId = this.deps.seriesXtreamId();
+        const persisted = await this.deps.seasonWatch.handle(
+            request,
+            playlistId,
+            this.deps.state,
+            () =>
+                this.deps.playlistId() === playlistId &&
+                this.deps.seriesXtreamId() === seriesXtreamId,
+            scope
+        );
+        if (persisted) {
+            await this.refreshStorePositions(playlistId);
+        }
+    }
+
+    /**
+     * The catalog reads series progress from XtreamStore, whose positions
+     * load once per playlist (XtreamCatalogFacadeService.initialize), so a
+     * toggle must push the change back or badges go stale on return. Skipped
+     * after a playlist switch — the store then holds the other playlist.
+     */
+    private async refreshStorePositions(playlistId: string): Promise<void> {
+        if (this.deps.playlistId() !== playlistId) {
+            return;
+        }
+        try {
+            await this.deps.reloadStorePositions(playlistId);
+        } catch (error) {
+            // The toggle itself succeeded; a failed refresh keeps the store
+            // populated-but-stale, which beats wiping it with a bad read.
+            logger.warn('Store position refresh failed', error);
+        }
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.spec.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.spec.ts
index 7b2b21177..6cb7cc12d 100644
--- a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.spec.ts
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.spec.ts
@@ -1,361 +1,46 @@
-import {
-    Component,
-    input,
-    output,
-    signal,
-    ChangeDetectionStrategy,
-} from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
-import { Location } from '@angular/common';
-import { MatIcon } from '@angular/material/icon';
-import { MatSnackBar } from '@angular/material/snack-bar';
-import { ActivatedRoute } from '@angular/router';
-import { TranslatePipe, TranslateService } from '@ngx-translate/core';
-import { MockPipe } from 'ng-mocks';
-import {
-    ContentHeroComponent,
-    SeasonContainerComponent,
-} from '@iptvnator/ui/components';
-import {
-    PORTAL_EXTERNAL_PLAYBACK,
-    PORTAL_PLAYBACK_POSITIONS,
-    PORTAL_PLAYER,
-    SeriesResumeTarget,
-} from '@iptvnator/portal/shared/util';
-import type { SeasonEpisodeDownloadAdapter } from '@iptvnator/portal/shared/data-access';
-import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
-import {
-    DownloadsService,
-    PlaybackPositionRuntimeBridgeService,
-    SettingsStore,
-} from '@iptvnator/services';
+import { ContentHeroComponent } from '@iptvnator/ui/components';
 import { PlaybackHistoryGate } from '@iptvnator/playback/data-access';
-import {
-    PlaybackPositionData,
-    VideoPlayer,
-} from '@iptvnator/shared/interfaces';
-import { PortalInlinePlayerComponent } from '@iptvnator/ui/playback';
-import { BehaviorSubject, EMPTY, of } from 'rxjs';
+import { PlaybackPositionData } from '@iptvnator/shared/interfaces';
 import { SerialDetailsComponent } from './serial-details.component';
 import { SerialDetailsMenuService } from './serial-details-menu.service';
 import { SerialDetailsPlaybackService } from './serial-details-playback.service';
-import { XTREAM_SERIES_RESUME_TARGET } from './serial-details-resume-target.token';
 import { createPlaybackSessionKey } from '@iptvnator/playback/util';
-
-@Component({
-    selector: 'app-season-container',
-    standalone: true,
-    changeDetection: ChangeDetectionStrategy.Eager,
-    template: '<div data-testid="season-container"></div>',
-})
-class StubSeasonContainerComponent {
-    readonly seasons = input<unknown>(null);
-    readonly seriesId = input<number | string | null>(null);
-    readonly playlistId = input('');
-    readonly seriesTitle = input<string | undefined>(undefined);
-    readonly playbackPositions = input<unknown>(null);
-    readonly downloadAdapter = input<SeasonEpisodeDownloadAdapter | null>(null);
-    readonly downloadsEnabled = input(true);
-    readonly openingEpisodeId = input<number | null>(null);
-    readonly activeEpisodeId = input<number | null>(null);
-    readonly playingEpisodeId = input<number | null>(null);
-    readonly seasonDescriptions = input<unknown>(null);
-    readonly seasonPosters = input<unknown>(null);
-    readonly seasonWatchBatchRunning = input(false);
-    readonly episodeClicked = output<unknown>();
-    readonly playbackToggleRequested = output<unknown>();
-    readonly seasonPlaybackToggleRequested = output<unknown>();
-}
-
-@Component({
-    selector: 'app-portal-inline-player',
-    standalone: true,
-    changeDetection: ChangeDetectionStrategy.Eager,
-    template: '',
-})
-class StubPortalInlinePlayerComponent {
-    readonly playbackSessionKey = input.required<string>();
-    readonly playback = input<unknown>(null);
-    readonly episodeMetadata = input<unknown>(null);
-    readonly seriesTitle = input<string | null>(null);
-    readonly seriesNavigation = input<unknown>(null);
-    readonly upNextEpisodes = input<unknown>(null);
-    readonly seriesEpisodes = input<unknown>(null);
-    readonly seasonPosters = input<unknown>(null);
-    readonly episodePlaybackPositions = input<unknown>(null);
-    readonly seasonLoadStates = input<unknown>(null);
-    readonly timeUpdate = output<unknown>();
-    readonly closed = output<void>();
-    readonly streamUrlCopied = output<void>();
-    readonly externalFallbackRequested = output<unknown>();
-    readonly playbackEnded = output<void>();
-    readonly previousEpisodeRequested = output<void>();
-    readonly nextEpisodeRequested = output<void>();
-    readonly upNextEpisodeSelected = output<unknown>();
-    readonly episodePanelSeasonSelected = output<string>();
-}
-
-@Component({
-    selector: 'mat-icon',
-    standalone: true,
-    changeDetection: ChangeDetectionStrategy.Eager,
-    template: '<ng-content />',
-})
-class StubMatIconComponent {}
+import {
+    configureSerialDetailsTestBed,
+    createSerialDetailsStubs,
+    resetSerialDetailsStubs,
+} from './serial-details.harness';
+import {
+    StubPortalInlinePlayerComponent,
+    StubSeasonContainerComponent,
+} from './serial-details.test-stubs';
 
 describe('SerialDetailsComponent', () => {
     let fixture: ComponentFixture<SerialDetailsComponent>;
-    const selectedItem = signal<unknown>(null);
-    const selectedContentType = signal<'series'>('series');
-    const isFavorite = signal(false);
-    const isLoadingDetails = signal(false);
-    const detailsError = signal<string | null>(null);
-    const currentPlaylist = signal({
-        id: 'xtream-1',
-        serverUrl: 'http://xtream.example',
-        username: 'user',
-        password: 'pass',
-        userAgent: 'ProtectedProvider/2.0',
-        referrer: 'https://referrer.example/series',
-        origin: 'https://origin.example',
-    });
-    const fetchSerialDetailsWithMetadata = jest.fn();
-    const cancelDetailsRequest = jest.fn();
-    const checkFavoriteStatus = jest.fn();
-    const constructEpisodeStreamUrl = jest.fn();
-    const addRecentItem = jest.fn();
-    const openResolvedPlayback = jest.fn();
-    const openExternalPlayback = jest.fn();
-    const savePlaybackPosition = jest.fn();
-    const clearPlaybackPosition = jest.fn();
-    const savePlaybackPositionsBatch = jest.fn();
-    const clearPlaybackPositionsBatch = jest.fn();
-    const loadAllPositions = jest.fn();
-    const isEmbeddedPlayer = jest.fn();
-    const getSeriesPlaybackPositions = jest.fn().mockResolvedValue([]);
-    let positionUpdateCallback: ((data: PlaybackPositionData) => void) | null =
-        null;
-    let seriesResumeTarget: ReturnType<
-        typeof signal<SeriesResumeTarget | null>
-    >;
-    let routeParams: BehaviorSubject<{
-        categoryId: string;
-        serialId: string;
-    }>;
+    const stubs = createSerialDetailsStubs();
+    const {
+        selectedItem,
+        currentPlaylist,
+        fetchSerialDetailsWithMetadata,
+        cancelDetailsRequest,
+        checkFavoriteStatus,
+        constructEpisodeStreamUrl,
+        addRecentItem,
+        openResolvedPlayback,
+        openExternalPlayback,
+        savePlaybackPosition,
+        isEmbeddedPlayer,
+        getSeriesPlaybackPositions,
+        seriesResumeTarget,
+        routeParams,
+    } = stubs;
 
     beforeEach(async () => {
         window.history.replaceState({}, '', window.location.href);
-        selectedItem.set({
-            series_id: 103,
-            info: {
-                name: 'Series One',
-                plot: 'Series plot',
-                cover: 'cover.jpg',
-                backdrop_path: [],
-                genre: 'Drama',
-                category_id: '3',
-                tmdb_id: 901,
-                tmdb_cast: [{ name: 'Sienna Wave', character: 'Mara' }],
-            },
-            episodes: {
-                '1': [
-                    {
-                        id: '1001',
-                        episode_num: 1,
-                        title: 'Episode 1',
-                        season: 1,
-                    },
-                    {
-                        id: '1002',
-                        episode_num: 2,
-                        title: 'Episode 2',
-                        season: 1,
-                    },
-                ],
-                '2': [
-                    {
-                        id: '2001',
-                        episode_num: 1,
-                        title: 'Season 2 Episode 1',
-                        season: 2,
-                    },
-                ],
-            },
-        });
-        isFavorite.set(false);
-        isLoadingDetails.set(false);
-        detailsError.set(null);
-        fetchSerialDetailsWithMetadata.mockClear();
-        cancelDetailsRequest.mockClear();
-        checkFavoriteStatus.mockClear();
-        constructEpisodeStreamUrl.mockReset();
-        constructEpisodeStreamUrl.mockImplementation(
-            (episode: { id: string | number }) =>
-                `http://xtream.example/series/${episode.id}.mp4`
-        );
-        addRecentItem.mockClear();
-        openResolvedPlayback.mockReset();
-        openResolvedPlayback.mockResolvedValue(undefined);
-        openExternalPlayback.mockReset();
-        openExternalPlayback.mockResolvedValue(undefined);
-        savePlaybackPosition.mockReset();
-        savePlaybackPosition.mockResolvedValue(undefined);
-        clearPlaybackPosition.mockReset();
-        clearPlaybackPosition.mockResolvedValue(undefined);
-        savePlaybackPositionsBatch.mockReset();
-        savePlaybackPositionsBatch.mockResolvedValue(undefined);
-        clearPlaybackPositionsBatch.mockReset();
-        clearPlaybackPositionsBatch.mockResolvedValue(undefined);
-        loadAllPositions.mockReset();
-        loadAllPositions.mockResolvedValue(undefined);
-        positionUpdateCallback = null;
-        isEmbeddedPlayer.mockReset();
-        isEmbeddedPlayer.mockReturnValue(false);
-        getSeriesPlaybackPositions.mockClear();
-        getSeriesPlaybackPositions.mockResolvedValue([]);
-        seriesResumeTarget = signal<SeriesResumeTarget | null>(null);
-        routeParams = new BehaviorSubject({
-            categoryId: '3',
-            serialId: '103',
-        });
-
-        await TestBed.configureTestingModule({
-            imports: [SerialDetailsComponent],
-            providers: [
-                {
-                    provide: ActivatedRoute,
-                    useValue: {
-                        params: routeParams,
-                        snapshot: {
-                            params: {
-                                categoryId: '3',
-                                serialId: '103',
-                            },
-                        },
-                    },
-                },
-                {
-                    provide: XtreamStore,
-                    useValue: {
-                        selectedItem,
-                        selectedContentType,
-                        isFavorite,
-                        isLoadingDetails,
-                        detailsError,
-                        currentPlaylist,
-                        fetchSerialDetailsWithMetadata,
-                        cancelDetailsRequest,
-                        checkFavoriteStatus,
-                        setSelectedItem: jest.fn((value: unknown) =>
-                            selectedItem.set(value)
-                        ),
-                        toggleFavorite: jest.fn(),
-                        constructEpisodeStreamUrl,
-                        addRecentItem,
-                        backfillContentMetadata: jest.fn(),
-                        loadAllPositions,
-                        recentItems: signal([]),
-                        serialCategories: signal([]),
-                        loadRecentItems: jest.fn(),
-                    },
-                },
-                {
-                    provide: SettingsStore,
-                    useValue: { player: signal(VideoPlayer.Html5Player) },
-                },
-                {
-                    provide: DownloadsService,
-                    useValue: { isAvailable: signal(false) },
-                },
-                {
-                    provide: PORTAL_EXTERNAL_PLAYBACK,
-                    useValue: {
-                        activeSession: signal(null),
-                    },
-                },
-                {
-                    provide: PORTAL_PLAYBACK_POSITIONS,
-                    useValue: {
-                        getSeriesPlaybackPositions,
-                        savePlaybackPosition,
-                        clearPlaybackPosition,
-                        savePlaybackPositionsBatch,
-                        clearPlaybackPositionsBatch,
-                    },
-                },
-                {
-                    provide: PORTAL_PLAYER,
-                    useValue: {
-                        isEmbeddedPlayer,
-                        openResolvedPlayback,
-                        openExternalPlayback,
-                    },
-                },
-                {
-                    provide: PlaybackPositionRuntimeBridgeService,
-                    useValue: {
-                        onPlaybackPositionUpdate: (
-                            callback: (data: PlaybackPositionData) => void
-                        ) => {
-                            positionUpdateCallback = callback;
-                            return () => {
-                                positionUpdateCallback = null;
-                            };
-                        },
-                    },
-                },
-                {
-                    provide: XTREAM_SERIES_RESUME_TARGET,
-                    useValue: seriesResumeTarget,
-                },
-                {
-                    provide: MatSnackBar,
-                    useValue: {
-                        open: jest.fn(),
-                    },
-                },
-                {
-                    provide: TranslateService,
-                    useValue: {
-                        instant: (key: string) => key,
-                        get: (key: string) => of(key),
-                        stream: (key: string) => of(key),
-                        onLangChange: EMPTY,
-                        onTranslationChange: EMPTY,
-                        onDefaultLangChange: EMPTY,
-                    },
-                },
-                {
-                    provide: Location,
-                    useValue: {
-                        back: jest.fn(),
-                    },
-                },
-            ],
-        })
-            .overrideComponent(SerialDetailsComponent, {
-                remove: {
-                    imports: [
-                        MatIcon,
-                        PortalInlinePlayerComponent,
-                        SeasonContainerComponent,
-                        TranslatePipe,
-                    ],
-                },
-                add: {
-                    imports: [
-                        StubMatIconComponent,
-                        StubPortalInlinePlayerComponent,
-                        StubSeasonContainerComponent,
-                        MockPipe(
-                            TranslatePipe,
-                            (value: string | null | undefined) => value ?? ''
-                        ),
-                    ],
-                },
-            })
-            .compileComponents();
+        resetSerialDetailsStubs(stubs);
+        await configureSerialDetailsTestBed(stubs);
 
         fixture = TestBed.createComponent(SerialDetailsComponent);
     });
@@ -779,6 +464,7 @@ describe('SerialDetailsComponent', () => {
     it('applies streamed playback-position updates for the selected series only', async () => {
         fixture.detectChanges();
         await fixture.whenStable();
+        const positionUpdateCallback = stubs.positionUpdates.callback;
         if (!positionUpdateCallback) {
             throw new Error('expected a playback-position subscription');
         }
@@ -936,238 +622,6 @@ describe('SerialDetailsComponent', () => {
         expect(savePlaybackPosition).not.toHaveBeenCalled();
     });
 
-    it('saves and clears positions for season-container toggle requests', async () => {
-        fixture.detectChanges();
-        await fixture.whenStable();
-
-        const playbackService = fixture.debugElement.injector.get(
-            SerialDetailsPlaybackService
-        );
-        await playbackService.handlePlaybackToggleRequested({
-            contentXtreamId: 1001,
-            nextPosition: {
-                playlistId: 'xtream-1',
-                contentXtreamId: 1001,
-                contentType: 'episode',
-                seriesXtreamId: 103,
-                seasonNumber: 1,
-                episodeNumber: 1,
-                positionSeconds: 950,
-                durationSeconds: 1000,
-            },
-        } as never);
-        expect(savePlaybackPosition).toHaveBeenCalledWith(
-            'xtream-1',
-            expect.objectContaining({ contentXtreamId: 1001 })
-        );
-
-        await playbackService.handlePlaybackToggleRequested({
-            contentXtreamId: 1001,
-            nextPosition: null,
-        } as never);
-        expect(clearPlaybackPosition).toHaveBeenCalledWith(
-            'xtream-1',
-            1001,
-            'episode'
-        );
-    });
-
-    it('marks a season watched through one batch save and updates rendered positions', async () => {
-        fixture.detectChanges();
-        await fixture.whenStable();
-
-        const playbackService = fixture.debugElement.injector.get(
-            SerialDetailsPlaybackService
-        );
-        const snackBar = TestBed.inject(MatSnackBar);
-        const seasonPosition = (
-            contentXtreamId: number,
-            episodeNumber: number
-        ) => ({
-            playlistId: 'xtream-1',
-            contentXtreamId,
-            contentType: 'episode' as const,
-            seriesXtreamId: 103,
-            seasonNumber: 1,
-            episodeNumber,
-            positionSeconds: 1200,
-            durationSeconds: 1200,
-        });
-
-        await playbackService.handleWatchToggleRequested(
-            {
-                seasonKey: '1',
-                markWatched: true,
-                requests: [
-                    {
-                        contentXtreamId: 1001,
-                        nextPosition: seasonPosition(1001, 1),
-                    },
-                    {
-                        contentXtreamId: 1002,
-                        nextPosition: seasonPosition(1002, 2),
-                    },
-                ],
-            } as never,
-            'season'
-        );
-
-        expect(savePlaybackPositionsBatch).toHaveBeenCalledTimes(1);
-        expect(savePlaybackPositionsBatch).toHaveBeenCalledWith('xtream-1', [
-            expect.objectContaining({ contentXtreamId: 1001 }),
-            expect.objectContaining({ contentXtreamId: 1002 }),
-        ]);
-        expect(savePlaybackPosition).not.toHaveBeenCalled();
-        expect(playbackService.episodePlaybackPositions().get(1001)).toEqual(
-            expect.objectContaining({ positionSeconds: 1200 })
-        );
-        expect(
-            playbackService.episodePlaybackPositions().get(1002)
-        ).toBeDefined();
-        expect(snackBar.open).toHaveBeenCalledWith(
-            'XTREAM.SEASON_MARKED_WATCHED',
-            undefined,
-            { duration: 5000 }
-        );
-        // The catalog badge source must follow the batch.
-        expect(loadAllPositions).toHaveBeenCalledWith('xtream-1');
-        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
-    });
-
-    it('unwatches a season through one batch clear', async () => {
-        fixture.detectChanges();
-        await fixture.whenStable();
-
-        const playbackService = fixture.debugElement.injector.get(
-            SerialDetailsPlaybackService
-        );
-        await playbackService.handleWatchToggleRequested(
-            {
-                seasonKey: '1',
-                markWatched: false,
-                requests: [
-                    { contentXtreamId: 1001, nextPosition: null },
-                    { contentXtreamId: 1002, nextPosition: null },
-                ],
-            } as never,
-            'season'
-        );
-
-        expect(clearPlaybackPositionsBatch).toHaveBeenCalledTimes(1);
-        expect(clearPlaybackPositionsBatch).toHaveBeenCalledWith('xtream-1', [
-            { contentXtreamId: 1001, contentType: 'episode' },
-            { contentXtreamId: 1002, contentType: 'episode' },
-        ]);
-        expect(clearPlaybackPosition).not.toHaveBeenCalled();
-        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
-            false
-        );
-    });
-
-    it('does not write a stale season batch into another playlist state', async () => {
-        fixture.detectChanges();
-        await fixture.whenStable();
-
-        let resolveBatch!: () => void;
-        savePlaybackPositionsBatch.mockImplementation(
-            () =>
-                new Promise<void>((resolve) => {
-                    resolveBatch = resolve;
-                })
-        );
-        const playbackService = fixture.debugElement.injector.get(
-            SerialDetailsPlaybackService
-        );
-        const pending = playbackService.handleWatchToggleRequested(
-            {
-                seasonKey: '1',
-                markWatched: true,
-                requests: [
-                    {
-                        contentXtreamId: 1001,
-                        nextPosition: {
-                            playlistId: 'xtream-1',
-                            contentXtreamId: 1001,
-                            contentType: 'episode',
-                            seriesXtreamId: 103,
-                            seasonNumber: 1,
-                            episodeNumber: 1,
-                            positionSeconds: 1200,
-                            durationSeconds: 1200,
-                        },
-                    },
-                ],
-            } as never,
-            'season'
-        );
-
-        // The user navigates to another playlist while the batch is pending.
-        const initialPlaylist = currentPlaylist();
-        currentPlaylist.set({ ...initialPlaylist, id: 'xtream-2' });
-        resolveBatch();
-        await pending;
-
-        expect(savePlaybackPositionsBatch).toHaveBeenCalledWith(
-            'xtream-1',
-            expect.anything()
-        );
-        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
-            false
-        );
-        expect(TestBed.inject(MatSnackBar).open).not.toHaveBeenCalled();
-        // The store now belongs to the other playlist — no stale refresh.
-        expect(loadAllPositions).not.toHaveBeenCalled();
-        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
-        currentPlaylist.set(initialPlaylist);
-    });
-
-    it('keeps rendered positions and reports the error when the season batch fails', async () => {
-        const consoleError = jest
-            .spyOn(console, 'error')
-            .mockImplementation(() => undefined);
-        savePlaybackPositionsBatch.mockRejectedValue(new Error('batch failed'));
-        fixture.detectChanges();
-        await fixture.whenStable();
-
-        const playbackService = fixture.debugElement.injector.get(
-            SerialDetailsPlaybackService
-        );
-        const snackBar = TestBed.inject(MatSnackBar);
-        await playbackService.handleWatchToggleRequested(
-            {
-                seasonKey: '1',
-                markWatched: true,
-                requests: [
-                    {
-                        contentXtreamId: 1001,
-                        nextPosition: {
-                            playlistId: 'xtream-1',
-                            contentXtreamId: 1001,
-                            contentType: 'episode',
-                            seriesXtreamId: 103,
-                            seasonNumber: 1,
-                            episodeNumber: 1,
-                            positionSeconds: 1200,
-                            durationSeconds: 1200,
-                        },
-                    },
-                ],
-            } as never,
-            'season'
-        );
-
-        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
-            false
-        );
-        expect(snackBar.open).toHaveBeenCalledWith(
-            'XTREAM.SEASON_WATCH_UPDATE_FAILED',
-            undefined,
-            { duration: 5000 }
-        );
-        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
-        consoleError.mockRestore();
-    });
-
     it('passes inline episode metadata and autoplays only inside the current season', async () => {
         isEmbeddedPlayer.mockReturnValue(true);
         fixture.detectChanges();
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.ts
index 9c40d2b12..c29a4e087 100644
--- a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.ts
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.component.ts
@@ -6,13 +6,11 @@ import {
     inject,
     OnDestroy,
     signal,
-    untracked,
     ChangeDetectionStrategy,
     viewChild,
 } from '@angular/core';
-import { toSignal } from '@angular/core/rxjs-interop';
 import { MatSnackBar } from '@angular/material/snack-bar';
-import { ActivatedRoute, Router } from '@angular/router';
+import { ActivatedRoute } from '@angular/router';
 import { TranslatePipe, TranslateService } from '@ngx-translate/core';
 import {
     CastCrewRowComponent,
@@ -49,24 +47,15 @@ import {
     XtreamSerieEpisode,
     XtreamSerieInfo,
 } from '@iptvnator/shared/interfaces';
-import { buildSeasonDescriptions } from './season-descriptions.util';
-import { buildSeasonPosters } from './season-posters.util';
-import {
-    createDiscoverFacetNavigation,
-    isProviderOnlyDetailState,
-} from '@iptvnator/portal/shared/util';
-import {
-    CrossPortalSimilarItem,
-    CrossPortalSimilarService,
-    TmdbEnrichmentService,
-} from '@iptvnator/services';
+import { injectXtreamDetailNavigation } from '../xtream-detail-navigation';
 import {
     SerialDetailsPlaybackService,
     type XtreamSerieDetailsView,
 } from './serial-details-playback.service';
+import { SerialDetailsRouteService } from './serial-details-route.service';
 import { SerialDetailsSeasonWatchService } from './serial-details-season-watch.service';
+import { SerialDetailsSeasonsService } from './serial-details-seasons.service';
 import { SerialDetailsSimilarService } from './serial-details-similar.service';
-import { SimilarCatalogItem } from '../tmdb-similar.util';
 import { createSerialPlaybackSessionKey } from './serial-playback-session-key';
 import { SerialDetailsHeroPresenter } from './serial-details-hero.presenter';
 import { SerialDetailsMenuService } from './serial-details-menu.service';
@@ -90,7 +79,9 @@ import { SerialDetailsDownloadAdapterService } from './serial-details-download-a
     ],
     providers: [
         SerialDetailsPlaybackService,
+        SerialDetailsRouteService,
         SerialDetailsSeasonWatchService,
+        SerialDetailsSeasonsService,
         SerialDetailsSimilarService,
         SerialDetailsHeroPresenter,
         SerialDetailsMenuService,
@@ -118,8 +109,7 @@ import { SerialDetailsDownloadAdapterService } from './serial-details-download-a
 export class SerialDetailsComponent implements OnDestroy {
     private readonly location = inject(Location);
     private readonly route = inject(ActivatedRoute);
-    private readonly router = inject(Router);
-    private readonly crossPortalSimilar = inject(CrossPortalSimilarService);
+    private readonly navigation = injectXtreamDetailNavigation('tv');
 
     private readonly xtreamStore = inject(XtreamStore);
     private readonly playback = inject(SerialDetailsPlaybackService);
@@ -142,20 +132,9 @@ export class SerialDetailsComponent implements OnDestroy {
         SerialDetailsDownloadAdapterService
     );
     readonly episodeDownloadAdapter = this.downloadAdapter.adapter;
-    /** `playlistId:categoryId:serialId` of the last initialized view */
-    private readonly lastInitKey = signal<string | null>(null);
-
-    /**
-     * Reactive route params: the component is reused when navigating
-     * between two series details (e.g. via the Similar rail).
-     */
-    private readonly routeParams = toSignal(this.route.params, {
-        initialValue: this.route.snapshot.params,
-    });
-    readonly providerOnly = computed(() => {
-        this.routeParams();
-        return isProviderOnlyDetailState(window.history.state);
-    });
+    private readonly routeState = inject(SerialDetailsRouteService);
+    private readonly routeParams = this.routeState.params;
+    readonly providerOnly = this.routeState.providerOnly;
 
     // Episode playback state, re-exposed for the template.
     readonly inlinePlayback = this.playback.inlinePlayback;
@@ -182,27 +161,27 @@ export class SerialDetailsComponent implements OnDestroy {
         })
     );
 
-    /** Season currently selected in the season container. */
-    private readonly selectedSeasonKey = signal<string | null>(null);
-
-    /** Season descriptions (provider text, TMDB fallback, URL junk dropped). */
-    readonly seasonDescriptions = computed<Record<string, string>>(() =>
-        buildSeasonDescriptions(this.selectedItem())
-    );
-
-    /** Season posters (TMDB season poster first, provider season cover next). */
-    readonly seasonPosters = computed<Record<string, string>>(() =>
-        buildSeasonPosters(this.selectedItem())
-    );
-
     /** The "Similar" rail: catalog matches plus cross-portal matches */
     private readonly similar = inject(SerialDetailsSimilarService);
     readonly similarItems = this.similar.similarItems;
     readonly similarInPortals = this.similar.similarInPortals;
 
+    /**
+     * Season descriptions and posters, and the selected season's enrichment.
+     * Injected after the other services that register effects: its enrichment
+     * effect then runs after theirs and before the constructor's.
+     */
+    private readonly seasons = inject(SerialDetailsSeasonsService);
+    readonly seasonDescriptions = this.seasons.descriptions;
+    readonly seasonPosters = this.seasons.posters;
+
+    /** Clickable year/genre/country chips (Discover pages) */
+    readonly discover = this.navigation.discover;
+
     constructor() {
         this.playback.bind({ selectedItem: this.selectedItem });
         this.similar.bind({ selectedItem: this.selectedItem });
+        this.seasons.bind({ selectedItem: this.selectedItem });
         this.downloadAdapter.bind(this.selectedItem);
         this.heroPresenter.bind({
             selectedItem: this.selectedItem,
@@ -210,8 +189,9 @@ export class SerialDetailsComponent implements OnDestroy {
             yearLabel: (releaseDate) => this.discover.yearLabel(releaseDate),
             similarItems: this.similarItems,
             similarInPortals: this.similarInPortals,
-            openSimilar: (item) => this.openSimilar(item),
-            openSimilarInPortals: (item) => this.openSimilarInPortals(item),
+            openSimilar: (item) => this.navigation.openSimilar(item),
+            openSimilarInPortals: (item) =>
+                this.navigation.openSimilarInPortals(item),
         });
         this.menu.bind({
             selectedItem: this.selectedItem,
@@ -235,22 +215,6 @@ export class SerialDetailsComponent implements OnDestroy {
                 this.playback.playEpisode(episode, player),
         });
 
-        // TMDB season enrichment, keyed on (tmdb_id, selected season). With
-        // season tabs the first seasonSelected fires as soon as seasons load —
-        // usually BEFORE the async show-level TMDB match has written
-        // info.tmdb_id, and enrichSelectedSerialSeason no-ops without it. So
-        // the call must re-run when the match arrives, not only on selection.
-        // The store-side enrichment is idempotent per (serial, season).
-        effect(() => {
-            const tmdbId = this.selectedItem()?.info?.tmdb_id;
-            const seasonKey = this.selectedSeasonKey();
-            if (tmdbId && seasonKey) {
-                untracked(() =>
-                    this.xtreamStore.enrichSelectedSerialSeason(seasonKey)
-                );
-            }
-        });
-
         effect(() => {
             const item = this.xtreamStore.selectedItem() as unknown as
                 | (XtreamSerieDetails & {
@@ -274,22 +238,7 @@ export class SerialDetailsComponent implements OnDestroy {
 
         // Initializes on first render and RE-initializes when the route
         // params change while the component is reused (Similar rail).
-        effect(() => {
-            const playlistId = this.xtreamStore.currentPlaylist()?.id;
-            const { categoryId, serialId } = this.routeParams();
-            if (!playlistId || !serialId) {
-                return;
-            }
-
-            const initKey = `${playlistId}:${categoryId}:${serialId}`;
-            if (this.lastInitKey() === initKey) {
-                return;
-            }
-            this.lastInitKey.set(initKey);
-
-            this.playback.resetForNewSeries();
-            this.initializeSerialDetails(playlistId, categoryId, serialId);
-        });
+        effect(() => this.routeState.loadAddressedSeries());
 
         registerContentMetadataBackfill({
             store: this.xtreamStore,
@@ -306,10 +255,6 @@ export class SerialDetailsComponent implements OnDestroy {
         this.xtreamStore.setSelectedItem(null);
     }
 
-    openSimilarInPortals(item: CrossPortalSimilarItem): void {
-        void this.router.navigate(this.crossPortalSimilar.buildLink(item));
-    }
-
     /** Clears every saved episode position of the series. */
     resetProgress(): Promise<void> {
         const request =
@@ -319,41 +264,12 @@ export class SerialDetailsComponent implements OnDestroy {
             : Promise.resolve();
     }
 
-    openSimilar(item: SimilarCatalogItem): void {
-        void this.router.navigate(['../..', item.categoryId, item.id], {
-            relativeTo: this.route,
-        });
-    }
-
     openActor(member: TmdbEnrichedCastMember): void {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        if (!playlistId || !member.tmdbPersonId) {
-            return;
-        }
-        void this.router.navigate([
-            '/workspace/xtreams',
-            playlistId,
-            'actor',
-            member.tmdbPersonId,
-        ]);
+        this.navigation.openActor(member);
     }
 
-    /** Clickable year/genre/country chips (Discover pages) */
-    private readonly tmdbEnrichment = inject(TmdbEnrichmentService);
-
-    readonly discover = createDiscoverFacetNavigation(() => {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        // Discover reads its results from TMDB, so a chip must not offer a
-        // page that enrichment cannot fill
-        return playlistId && this.tmdbEnrichment.isEnabled()
-            ? { portal: 'xtream', mediaType: 'tv', playlistId }
-            : null;
-    });
-
     onSeasonSelected(seasonKey: string): void {
-        // The enrichment call itself runs from the constructor effect keyed
-        // on (tmdb_id, selectedSeasonKey) — see the race note there.
-        this.selectedSeasonKey.set(seasonKey);
+        this.seasons.select(seasonKey);
     }
 
     playEpisode(episode: XtreamSerieEpisode): void {
@@ -445,25 +361,4 @@ export class SerialDetailsComponent implements OnDestroy {
             }
         );
     }
-
-    private initializeSerialDetails(
-        playlistId: string,
-        categoryId: string | number,
-        serialId: string
-    ): void {
-        this.xtreamStore.fetchSerialDetailsWithMetadata({
-            serialId,
-            categoryId: Number(categoryId),
-        });
-        const serialXtreamId = Number(serialId);
-        this.xtreamStore.checkFavoriteStatus(
-            serialXtreamId,
-            playlistId,
-            'series'
-        );
-        void this.playback.loadSeriesPlaybackPositions(
-            playlistId,
-            serialXtreamId
-        );
-    }
 }
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.harness.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.harness.ts
new file mode 100644
index 000000000..5a57feb7f
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.harness.ts
@@ -0,0 +1,314 @@
+import { Location } from '@angular/common';
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { MatIcon } from '@angular/material/icon';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { ActivatedRoute } from '@angular/router';
+import { TranslatePipe, TranslateService } from '@ngx-translate/core';
+import { MockPipe } from 'ng-mocks';
+import {
+    PORTAL_EXTERNAL_PLAYBACK,
+    PORTAL_PLAYBACK_POSITIONS,
+    PORTAL_PLAYER,
+    SeriesResumeTarget,
+} from '@iptvnator/portal/shared/util';
+import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
+import {
+    DownloadsService,
+    PlaybackPositionRuntimeBridgeService,
+    SettingsStore,
+} from '@iptvnator/services';
+import {
+    PlaybackPositionData,
+    VideoPlayer,
+} from '@iptvnator/shared/interfaces';
+import { SeasonContainerComponent } from '@iptvnator/ui/components';
+import { PortalInlinePlayerComponent } from '@iptvnator/ui/playback';
+import { BehaviorSubject, EMPTY, of } from 'rxjs';
+import { SerialDetailsComponent } from './serial-details.component';
+import { XTREAM_SERIES_RESUME_TARGET } from './serial-details-resume-target.token';
+import {
+    StubMatIconComponent,
+    StubPortalInlinePlayerComponent,
+    StubSeasonContainerComponent,
+} from './serial-details.test-stubs';
+
+/**
+ * The TestBed every series-details component spec needs.
+ *
+ * The page pulls in the store, the playback ports, the position bridge,
+ * downloads, settings and the router, so standing it up costs ~200 lines.
+ * One harness keeps the specs split by concern from carrying a copy each.
+ */
+
+/** The series every spec starts from: two seasons, three episodes. */
+function createSeriesFixture(): unknown {
+    return {
+        series_id: 103,
+        info: {
+            name: 'Series One',
+            plot: 'Series plot',
+            cover: 'cover.jpg',
+            backdrop_path: [],
+            genre: 'Drama',
+            category_id: '3',
+            tmdb_id: 901,
+            tmdb_cast: [{ name: 'Sienna Wave', character: 'Mara' }],
+        },
+        episodes: {
+            '1': [
+                {
+                    id: '1001',
+                    episode_num: 1,
+                    title: 'Episode 1',
+                    season: 1,
+                },
+                {
+                    id: '1002',
+                    episode_num: 2,
+                    title: 'Episode 2',
+                    season: 1,
+                },
+            ],
+            '2': [
+                {
+                    id: '2001',
+                    episode_num: 1,
+                    title: 'Season 2 Episode 1',
+                    season: 2,
+                },
+            ],
+        },
+    };
+}
+
+const initialPlaylist = {
+    id: 'xtream-1',
+    serverUrl: 'http://xtream.example',
+    username: 'user',
+    password: 'pass',
+    userAgent: 'ProtectedProvider/2.0',
+    referrer: 'https://referrer.example/series',
+    origin: 'https://origin.example',
+};
+
+/** Every stub the harness installs, so specs can drive and assert on them. */
+export function createSerialDetailsStubs() {
+    return {
+        selectedItem: signal<unknown>(null),
+        selectedContentType: signal<'series'>('series'),
+        isFavorite: signal(false),
+        isLoadingDetails: signal(false),
+        detailsError: signal<string | null>(null),
+        currentPlaylist: signal(initialPlaylist),
+        fetchSerialDetailsWithMetadata: jest.fn(),
+        cancelDetailsRequest: jest.fn(),
+        checkFavoriteStatus: jest.fn(),
+        constructEpisodeStreamUrl: jest.fn(),
+        addRecentItem: jest.fn(),
+        openResolvedPlayback: jest.fn(),
+        openExternalPlayback: jest.fn(),
+        savePlaybackPosition: jest.fn(),
+        clearPlaybackPosition: jest.fn(),
+        savePlaybackPositionsBatch: jest.fn(),
+        clearPlaybackPositionsBatch: jest.fn(),
+        loadAllPositions: jest.fn(),
+        isEmbeddedPlayer: jest.fn(),
+        getSeriesPlaybackPositions: jest.fn().mockResolvedValue([]),
+        seriesResumeTarget: signal<SeriesResumeTarget | null>(null),
+        routeParams: new BehaviorSubject({
+            categoryId: '3',
+            serialId: '103',
+        }),
+        /** The page's subscription to streamed position updates, once made. */
+        positionUpdates: {
+            callback: null as ((data: PlaybackPositionData) => void) | null,
+        },
+    };
+}
+
+export type SerialDetailsStubs = ReturnType<typeof createSerialDetailsStubs>;
+
+/** Back to the state a fresh `beforeEach` expects. */
+export function resetSerialDetailsStubs(stubs: SerialDetailsStubs): void {
+    stubs.selectedItem.set(createSeriesFixture());
+    stubs.isFavorite.set(false);
+    stubs.isLoadingDetails.set(false);
+    stubs.detailsError.set(null);
+    stubs.currentPlaylist.set(initialPlaylist);
+    stubs.fetchSerialDetailsWithMetadata.mockClear();
+    stubs.cancelDetailsRequest.mockClear();
+    stubs.checkFavoriteStatus.mockClear();
+    stubs.constructEpisodeStreamUrl.mockReset();
+    stubs.constructEpisodeStreamUrl.mockImplementation(
+        (episode: { id: string | number }) =>
+            `http://xtream.example/series/${episode.id}.mp4`
+    );
+    stubs.addRecentItem.mockClear();
+    stubs.openResolvedPlayback.mockReset();
+    stubs.openResolvedPlayback.mockResolvedValue(undefined);
+    stubs.openExternalPlayback.mockReset();
+    stubs.openExternalPlayback.mockResolvedValue(undefined);
+    stubs.savePlaybackPosition.mockReset();
+    stubs.savePlaybackPosition.mockResolvedValue(undefined);
+    stubs.clearPlaybackPosition.mockReset();
+    stubs.clearPlaybackPosition.mockResolvedValue(undefined);
+    stubs.savePlaybackPositionsBatch.mockReset();
+    stubs.savePlaybackPositionsBatch.mockResolvedValue(undefined);
+    stubs.clearPlaybackPositionsBatch.mockReset();
+    stubs.clearPlaybackPositionsBatch.mockResolvedValue(undefined);
+    stubs.loadAllPositions.mockReset();
+    stubs.loadAllPositions.mockResolvedValue(undefined);
+    stubs.positionUpdates.callback = null;
+    stubs.isEmbeddedPlayer.mockReset();
+    stubs.isEmbeddedPlayer.mockReturnValue(false);
+    stubs.getSeriesPlaybackPositions.mockClear();
+    stubs.getSeriesPlaybackPositions.mockResolvedValue([]);
+    stubs.seriesResumeTarget.set(null);
+    stubs.routeParams.next({ categoryId: '3', serialId: '103' });
+}
+
+export async function configureSerialDetailsTestBed(
+    stubs: SerialDetailsStubs
+): Promise<void> {
+    await TestBed.configureTestingModule({
+        imports: [SerialDetailsComponent],
+        providers: [
+            {
+                provide: ActivatedRoute,
+                useValue: {
+                    params: stubs.routeParams,
+                    snapshot: {
+                        params: {
+                            categoryId: '3',
+                            serialId: '103',
+                        },
+                    },
+                },
+            },
+            {
+                provide: XtreamStore,
+                useValue: {
+                    selectedItem: stubs.selectedItem,
+                    selectedContentType: stubs.selectedContentType,
+                    isFavorite: stubs.isFavorite,
+                    isLoadingDetails: stubs.isLoadingDetails,
+                    detailsError: stubs.detailsError,
+                    currentPlaylist: stubs.currentPlaylist,
+                    fetchSerialDetailsWithMetadata:
+                        stubs.fetchSerialDetailsWithMetadata,
+                    cancelDetailsRequest: stubs.cancelDetailsRequest,
+                    checkFavoriteStatus: stubs.checkFavoriteStatus,
+                    setSelectedItem: jest.fn((value: unknown) =>
+                        stubs.selectedItem.set(value)
+                    ),
+                    toggleFavorite: jest.fn(),
+                    constructEpisodeStreamUrl: stubs.constructEpisodeStreamUrl,
+                    addRecentItem: stubs.addRecentItem,
+                    backfillContentMetadata: jest.fn(),
+                    loadAllPositions: stubs.loadAllPositions,
+                    recentItems: signal([]),
+                    serialCategories: signal([]),
+                    loadRecentItems: jest.fn(),
+                },
+            },
+            {
+                provide: SettingsStore,
+                useValue: { player: signal(VideoPlayer.Html5Player) },
+            },
+            {
+                provide: DownloadsService,
+                useValue: { isAvailable: signal(false) },
+            },
+            {
+                provide: PORTAL_EXTERNAL_PLAYBACK,
+                useValue: {
+                    activeSession: signal(null),
+                },
+            },
+            {
+                provide: PORTAL_PLAYBACK_POSITIONS,
+                useValue: {
+                    getSeriesPlaybackPositions:
+                        stubs.getSeriesPlaybackPositions,
+                    savePlaybackPosition: stubs.savePlaybackPosition,
+                    clearPlaybackPosition: stubs.clearPlaybackPosition,
+                    savePlaybackPositionsBatch:
+                        stubs.savePlaybackPositionsBatch,
+                    clearPlaybackPositionsBatch:
+                        stubs.clearPlaybackPositionsBatch,
+                },
+            },
+            {
+                provide: PORTAL_PLAYER,
+                useValue: {
+                    isEmbeddedPlayer: stubs.isEmbeddedPlayer,
+                    openResolvedPlayback: stubs.openResolvedPlayback,
+                    openExternalPlayback: stubs.openExternalPlayback,
+                },
+            },
+            {
+                provide: PlaybackPositionRuntimeBridgeService,
+                useValue: {
+                    onPlaybackPositionUpdate: (
+                        callback: (data: PlaybackPositionData) => void
+                    ) => {
+                        stubs.positionUpdates.callback = callback;
+                        return () => {
+                            stubs.positionUpdates.callback = null;
+                        };
+                    },
+                },
+            },
+            {
+                provide: XTREAM_SERIES_RESUME_TARGET,
+                useValue: stubs.seriesResumeTarget,
+            },
+            {
+                provide: MatSnackBar,
+                useValue: {
+                    open: jest.fn(),
+                },
+            },
+            {
+                provide: TranslateService,
+                useValue: {
+                    instant: (key: string) => key,
+                    get: (key: string) => of(key),
+                    stream: (key: string) => of(key),
+                    onLangChange: EMPTY,
+                    onTranslationChange: EMPTY,
+                    onDefaultLangChange: EMPTY,
+                },
+            },
+            {
+                provide: Location,
+                useValue: {
+                    back: jest.fn(),
+                },
+            },
+        ],
+    })
+        .overrideComponent(SerialDetailsComponent, {
+            remove: {
+                imports: [
+                    MatIcon,
+                    PortalInlinePlayerComponent,
+                    SeasonContainerComponent,
+                    TranslatePipe,
+                ],
+            },
+            add: {
+                imports: [
+                    StubMatIconComponent,
+                    StubPortalInlinePlayerComponent,
+                    StubSeasonContainerComponent,
+                    MockPipe(
+                        TranslatePipe,
+                        (value: string | null | undefined) => value ?? ''
+                    ),
+                ],
+            },
+        })
+        .compileComponents();
+}
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.season-watch.spec.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.season-watch.spec.ts
new file mode 100644
index 000000000..a4e9252b2
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.season-watch.spec.ts
@@ -0,0 +1,267 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { SerialDetailsComponent } from './serial-details.component';
+import { SerialDetailsPlaybackService } from './serial-details-playback.service';
+import {
+    configureSerialDetailsTestBed,
+    createSerialDetailsStubs,
+    resetSerialDetailsStubs,
+} from './serial-details.harness';
+
+describe('SerialDetailsComponent watched toggles', () => {
+    let fixture: ComponentFixture<SerialDetailsComponent>;
+    const stubs = createSerialDetailsStubs();
+    const {
+        currentPlaylist,
+        savePlaybackPosition,
+        clearPlaybackPosition,
+        savePlaybackPositionsBatch,
+        clearPlaybackPositionsBatch,
+        loadAllPositions,
+    } = stubs;
+
+    beforeEach(async () => {
+        window.history.replaceState({}, '', window.location.href);
+        resetSerialDetailsStubs(stubs);
+        await configureSerialDetailsTestBed(stubs);
+
+        fixture = TestBed.createComponent(SerialDetailsComponent);
+    });
+
+    afterEach(() => {
+        window.history.replaceState({}, '', window.location.href);
+        fixture?.destroy();
+    });
+
+    it('saves and clears positions for season-container toggle requests', async () => {
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        const playbackService = fixture.debugElement.injector.get(
+            SerialDetailsPlaybackService
+        );
+        await playbackService.handlePlaybackToggleRequested({
+            contentXtreamId: 1001,
+            nextPosition: {
+                playlistId: 'xtream-1',
+                contentXtreamId: 1001,
+                contentType: 'episode',
+                seriesXtreamId: 103,
+                seasonNumber: 1,
+                episodeNumber: 1,
+                positionSeconds: 950,
+                durationSeconds: 1000,
+            },
+        } as never);
+        expect(savePlaybackPosition).toHaveBeenCalledWith(
+            'xtream-1',
+            expect.objectContaining({ contentXtreamId: 1001 })
+        );
+
+        await playbackService.handlePlaybackToggleRequested({
+            contentXtreamId: 1001,
+            nextPosition: null,
+        } as never);
+        expect(clearPlaybackPosition).toHaveBeenCalledWith(
+            'xtream-1',
+            1001,
+            'episode'
+        );
+    });
+
+    it('marks a season watched through one batch save and updates rendered positions', async () => {
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        const playbackService = fixture.debugElement.injector.get(
+            SerialDetailsPlaybackService
+        );
+        const snackBar = TestBed.inject(MatSnackBar);
+        const seasonPosition = (
+            contentXtreamId: number,
+            episodeNumber: number
+        ) => ({
+            playlistId: 'xtream-1',
+            contentXtreamId,
+            contentType: 'episode' as const,
+            seriesXtreamId: 103,
+            seasonNumber: 1,
+            episodeNumber,
+            positionSeconds: 1200,
+            durationSeconds: 1200,
+        });
+
+        await playbackService.handleWatchToggleRequested(
+            {
+                seasonKey: '1',
+                markWatched: true,
+                requests: [
+                    {
+                        contentXtreamId: 1001,
+                        nextPosition: seasonPosition(1001, 1),
+                    },
+                    {
+                        contentXtreamId: 1002,
+                        nextPosition: seasonPosition(1002, 2),
+                    },
+                ],
+            } as never,
+            'season'
+        );
+
+        expect(savePlaybackPositionsBatch).toHaveBeenCalledTimes(1);
+        expect(savePlaybackPositionsBatch).toHaveBeenCalledWith('xtream-1', [
+            expect.objectContaining({ contentXtreamId: 1001 }),
+            expect.objectContaining({ contentXtreamId: 1002 }),
+        ]);
+        expect(savePlaybackPosition).not.toHaveBeenCalled();
+        expect(playbackService.episodePlaybackPositions().get(1001)).toEqual(
+            expect.objectContaining({ positionSeconds: 1200 })
+        );
+        expect(
+            playbackService.episodePlaybackPositions().get(1002)
+        ).toBeDefined();
+        expect(snackBar.open).toHaveBeenCalledWith(
+            'XTREAM.SEASON_MARKED_WATCHED',
+            undefined,
+            { duration: 5000 }
+        );
+        // The catalog badge source must follow the batch.
+        expect(loadAllPositions).toHaveBeenCalledWith('xtream-1');
+        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
+    });
+
+    it('unwatches a season through one batch clear', async () => {
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        const playbackService = fixture.debugElement.injector.get(
+            SerialDetailsPlaybackService
+        );
+        await playbackService.handleWatchToggleRequested(
+            {
+                seasonKey: '1',
+                markWatched: false,
+                requests: [
+                    { contentXtreamId: 1001, nextPosition: null },
+                    { contentXtreamId: 1002, nextPosition: null },
+                ],
+            } as never,
+            'season'
+        );
+
+        expect(clearPlaybackPositionsBatch).toHaveBeenCalledTimes(1);
+        expect(clearPlaybackPositionsBatch).toHaveBeenCalledWith('xtream-1', [
+            { contentXtreamId: 1001, contentType: 'episode' },
+            { contentXtreamId: 1002, contentType: 'episode' },
+        ]);
+        expect(clearPlaybackPosition).not.toHaveBeenCalled();
+        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
+            false
+        );
+    });
+
+    it('does not write a stale season batch into another playlist state', async () => {
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        let resolveBatch!: () => void;
+        savePlaybackPositionsBatch.mockImplementation(
+            () =>
+                new Promise<void>((resolve) => {
+                    resolveBatch = resolve;
+                })
+        );
+        const playbackService = fixture.debugElement.injector.get(
+            SerialDetailsPlaybackService
+        );
+        const pending = playbackService.handleWatchToggleRequested(
+            {
+                seasonKey: '1',
+                markWatched: true,
+                requests: [
+                    {
+                        contentXtreamId: 1001,
+                        nextPosition: {
+                            playlistId: 'xtream-1',
+                            contentXtreamId: 1001,
+                            contentType: 'episode',
+                            seriesXtreamId: 103,
+                            seasonNumber: 1,
+                            episodeNumber: 1,
+                            positionSeconds: 1200,
+                            durationSeconds: 1200,
+                        },
+                    },
+                ],
+            } as never,
+            'season'
+        );
+
+        // The user navigates to another playlist while the batch is pending.
+        const initialPlaylist = currentPlaylist();
+        currentPlaylist.set({ ...initialPlaylist, id: 'xtream-2' });
+        resolveBatch();
+        await pending;
+
+        expect(savePlaybackPositionsBatch).toHaveBeenCalledWith(
+            'xtream-1',
+            expect.anything()
+        );
+        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
+            false
+        );
+        expect(TestBed.inject(MatSnackBar).open).not.toHaveBeenCalled();
+        // The store now belongs to the other playlist — no stale refresh.
+        expect(loadAllPositions).not.toHaveBeenCalled();
+        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
+        currentPlaylist.set(initialPlaylist);
+    });
+
+    it('keeps rendered positions and reports the error when the season batch fails', async () => {
+        const consoleError = jest
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        savePlaybackPositionsBatch.mockRejectedValue(new Error('batch failed'));
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        const playbackService = fixture.debugElement.injector.get(
+            SerialDetailsPlaybackService
+        );
+        const snackBar = TestBed.inject(MatSnackBar);
+        await playbackService.handleWatchToggleRequested(
+            {
+                seasonKey: '1',
+                markWatched: true,
+                requests: [
+                    {
+                        contentXtreamId: 1001,
+                        nextPosition: {
+                            playlistId: 'xtream-1',
+                            contentXtreamId: 1001,
+                            contentType: 'episode',
+                            seriesXtreamId: 103,
+                            seasonNumber: 1,
+                            episodeNumber: 1,
+                            positionSeconds: 1200,
+                            durationSeconds: 1200,
+                        },
+                    },
+                ],
+            } as never,
+            'season'
+        );
+
+        expect(playbackService.episodePlaybackPositions().has(1001)).toBe(
+            false
+        );
+        expect(snackBar.open).toHaveBeenCalledWith(
+            'XTREAM.SEASON_WATCH_UPDATE_FAILED',
+            undefined,
+            { duration: 5000 }
+        );
+        expect(playbackService.seasonWatchBatchRunning()).toBe(false);
+        consoleError.mockRestore();
+    });
+});
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-details.test-stubs.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.test-stubs.ts
new file mode 100644
index 000000000..a093e78f9
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-details.test-stubs.ts
@@ -0,0 +1,70 @@
+import {
+    ChangeDetectionStrategy,
+    Component,
+    input,
+    output,
+} from '@angular/core';
+import type { SeasonEpisodeDownloadAdapter } from '@iptvnator/portal/shared/data-access';
+
+/** Stand-ins for the heavy children of the series-details page in specs. */
+
+@Component({
+    selector: 'app-season-container',
+    standalone: true,
+    changeDetection: ChangeDetectionStrategy.Eager,
+    template: '<div data-testid="season-container"></div>',
+})
+export class StubSeasonContainerComponent {
+    readonly seasons = input<unknown>(null);
+    readonly seriesId = input<number | string | null>(null);
+    readonly playlistId = input('');
+    readonly seriesTitle = input<string | undefined>(undefined);
+    readonly playbackPositions = input<unknown>(null);
+    readonly downloadAdapter = input<SeasonEpisodeDownloadAdapter | null>(null);
+    readonly downloadsEnabled = input(true);
+    readonly openingEpisodeId = input<number | null>(null);
+    readonly activeEpisodeId = input<number | null>(null);
+    readonly playingEpisodeId = input<number | null>(null);
+    readonly seasonDescriptions = input<unknown>(null);
+    readonly seasonPosters = input<unknown>(null);
+    readonly seasonWatchBatchRunning = input(false);
+    readonly episodeClicked = output<unknown>();
+    readonly playbackToggleRequested = output<unknown>();
+    readonly seasonPlaybackToggleRequested = output<unknown>();
+}
+
+@Component({
+    selector: 'app-portal-inline-player',
+    standalone: true,
+    changeDetection: ChangeDetectionStrategy.Eager,
+    template: '',
+})
+export class StubPortalInlinePlayerComponent {
+    readonly playbackSessionKey = input.required<string>();
+    readonly playback = input<unknown>(null);
+    readonly episodeMetadata = input<unknown>(null);
+    readonly seriesTitle = input<string | null>(null);
+    readonly seriesNavigation = input<unknown>(null);
+    readonly upNextEpisodes = input<unknown>(null);
+    readonly seriesEpisodes = input<unknown>(null);
+    readonly seasonPosters = input<unknown>(null);
+    readonly episodePlaybackPositions = input<unknown>(null);
+    readonly seasonLoadStates = input<unknown>(null);
+    readonly timeUpdate = output<unknown>();
+    readonly closed = output<void>();
+    readonly streamUrlCopied = output<void>();
+    readonly externalFallbackRequested = output<unknown>();
+    readonly playbackEnded = output<void>();
+    readonly previousEpisodeRequested = output<void>();
+    readonly nextEpisodeRequested = output<void>();
+    readonly upNextEpisodeSelected = output<unknown>();
+    readonly episodePanelSeasonSelected = output<string>();
+}
+
+@Component({
+    selector: 'mat-icon',
+    standalone: true,
+    changeDetection: ChangeDetectionStrategy.Eager,
+    template: '<ng-content />',
+})
+export class StubMatIconComponent {}
diff --git a/libs/portal/xtream/feature/src/lib/serial-details/serial-episode-playback.ts b/libs/portal/xtream/feature/src/lib/serial-details/serial-episode-playback.ts
new file mode 100644
index 000000000..28766621f
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/serial-details/serial-episode-playback.ts
@@ -0,0 +1,58 @@
+import type {
+    PlayerContentInfo,
+    ResolvedPortalPlayback,
+    XtreamSerieEpisode,
+} from '@iptvnator/shared/interfaces';
+import {
+    resolveSeriesPlaybackEpisodeState,
+    type SeriesPlaybackEpisodeState,
+} from '@iptvnator/ui/playback';
+import type { XtreamSerieDetailsView } from './serial-details-playback.service';
+
+export interface SerialEpisodePlaybackRequest {
+    readonly playlistId: string;
+    readonly selectedItem: XtreamSerieDetailsView;
+    readonly episode: XtreamSerieEpisode;
+    readonly streamUrl: string;
+    /** The episode's saved offset, when it has one. */
+    readonly startTime: number | undefined;
+}
+
+export interface SerialEpisodePlayback {
+    readonly playback: ResolvedPortalPlayback;
+    readonly episodeState: SeriesPlaybackEpisodeState<XtreamSerieEpisode> | null;
+}
+
+/**
+ * The playback an episode of the series on screen resolves to, and its place
+ * among the series' episodes for the inline player's navigation.
+ */
+export function buildSerialEpisodePlayback(
+    request: SerialEpisodePlaybackRequest
+): SerialEpisodePlayback {
+    const { episode, selectedItem } = request;
+    const contentInfo: PlayerContentInfo = {
+        playlistId: request.playlistId,
+        contentXtreamId: Number(episode.id),
+        contentType: 'episode',
+        seriesXtreamId: Number(selectedItem.series_id),
+        seasonNumber: Number(episode.season),
+        episodeNumber: Number(episode.episode_num),
+    };
+
+    const playback: ResolvedPortalPlayback = {
+        streamUrl: request.streamUrl,
+        title: episode.title,
+        thumbnail: selectedItem.info.cover,
+        startTime: request.startTime,
+        contentInfo,
+    };
+
+    const episodeState = resolveSeriesPlaybackEpisodeState({
+        episodesBySeason: selectedItem.episodes,
+        currentEpisodeId: episode.id,
+        fallbackSeasonNumber: Number(episode.season),
+        fallbackEpisodeNumber: Number(episode.episode_num),
+    });
+    return { playback, episodeState };
+}
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-downloads.service.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-downloads.service.ts
index 653897d79..7535070e5 100644
--- a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-downloads.service.ts
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-downloads.service.ts
@@ -2,6 +2,7 @@ import { Injectable, Signal, computed, inject, signal } from '@angular/core';
 import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
 import { createMovieDownloadSnapshot } from '@iptvnator/portal/shared/util';
 import { DownloadsService } from '@iptvnator/services';
+import { DialogService } from '@iptvnator/ui/components';
 import { resolveXtreamVodPlaybackSource } from '@iptvnator/portal/xtream/data-access';
 import {
     getXtreamVodInfo,
@@ -54,6 +55,7 @@ export class VodDetailsDownloadsService {
     private readonly downloadsService = inject(DownloadsService);
     private readonly xtreamStore = inject(XtreamStore);
     private readonly translateService = inject(TranslateService);
+    private readonly dialogService = inject(DialogService);
 
     private routeContentId: Signal<number> = signal(NaN);
 
@@ -124,6 +126,20 @@ export class VodDetailsDownloadsService {
             : null;
     });
 
+    /** 2πr of the r=15.5 progress-ring circle in its 36×36 viewBox. */
+    readonly ringCircumference = 2 * Math.PI * 15.5;
+
+    /**
+     * Dash offset that leaves the arc at the real percent — or a fixed
+     * quarter arc when the total size is unknown and the ring spins instead.
+     */
+    readonly ringOffset = computed(() => {
+        const percent = this.downloadPercent();
+        return percent === null
+            ? this.ringCircumference * 0.75
+            : this.ringCircumference * (1 - percent / 100);
+    });
+
     /** Cancel whatever download is running or queued for this movie. */
     async cancelActive(): Promise<void> {
         const item = this.activeDownload();
@@ -132,6 +148,28 @@ export class VodDetailsDownloadsService {
         }
     }
 
+    /**
+     * A running download is destroyed by one click, so the icon button asks
+     * first — there is no label left to warn what the click does.
+     */
+    promptCancel(): void {
+        this.dialogService.openConfirmDialog({
+            title: this.translateService.instant(
+                'DOWNLOADS.CANCEL_CONFIRM_TITLE'
+            ),
+            message: this.translateService.instant(
+                'DOWNLOADS.CANCEL_CONFIRM_MESSAGE'
+            ),
+            confirmLabel: this.translateService.instant(
+                'DOWNLOADS.CANCEL_CONFIRM_TITLE'
+            ),
+            // "Cancel" next to "Cancel download" would read as the same action.
+            cancelLabel: this.translateService.instant('CLOSE'),
+            tone: 'destructive',
+            onConfirm: () => void this.cancelActive(),
+        });
+    }
+
     /** Open the finished file's location in the system file manager. */
     async revealDownloaded(): Promise<void> {
         const playlistId = this.xtreamStore.currentPlaylist()?.id;
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-external-launch.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-external-launch.ts
index 7575eee04..233353a99 100644
--- a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-external-launch.ts
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-external-launch.ts
@@ -1,4 +1,9 @@
-import type { ExternalPlayerSession } from '@iptvnator/shared/interfaces';
+import { signal } from '@angular/core';
+import type {
+    ExternalPlayerSession,
+    ResolvedPortalPlayback,
+} from '@iptvnator/shared/interfaces';
+import type { ExternalLaunchOwner } from './vod-details-external-launch-owner';
 
 interface OwnedExternalLaunchOptions {
     launch: Promise<ExternalPlayerSession | void>;
@@ -63,3 +68,44 @@ function isClosableExternalLaunch(
             (session.status === 'error' && session.canClose))
     );
 }
+
+/**
+ * The MPV/VLC launch a VOD page made last and the one it still waits on.
+ *
+ * What was launched is remembered independently of the controller's active
+ * source, so a refresh or an overlapping handoff cannot make the exact
+ * process this page launched look foreign before its teardown has been
+ * confirmed. Its route owner prevents a reused component from attributing
+ * that process to a different movie.
+ */
+export class VodExternalLaunchClaim {
+    private launchedGeneration = 0;
+    /** Start generation of the launch still awaiting its player, if any. */
+    readonly pendingGeneration = signal<number | null>(null);
+
+    constructor(private readonly owner: ExternalLaunchOwner) {}
+
+    claim(playback: ResolvedPortalPlayback, generation: number): void {
+        this.owner.set(playback.contentInfo);
+        this.launchedGeneration = generation;
+        this.pendingGeneration.set(generation);
+    }
+
+    /** An inline start took over: nothing external is owned or awaited. */
+    release(): void {
+        this.owner.clear();
+        this.pendingGeneration.set(null);
+    }
+
+    clearOwnership(generation: number): void {
+        if (this.launchedGeneration === generation) {
+            this.owner.clear();
+        }
+    }
+
+    clearPending(generation: number): void {
+        if (this.pendingGeneration() === generation) {
+            this.pendingGeneration.set(null);
+        }
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-hero.presenter.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-hero.presenter.ts
index 5093b4cdb..6ef9f4c61 100644
--- a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-hero.presenter.ts
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-hero.presenter.ts
@@ -10,17 +10,20 @@ import {
     type RemainingTimeLabel,
 } from '@iptvnator/portal/shared/util';
 import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
-import type {
-    PlaybackPositionData,
-    TmdbCountryFacet,
-    TmdbEnrichedCastMember,
-    TmdbGenreFacet,
-    XtreamVodInfo,
+import {
+    youtubeEmbedUrl,
+    type PlaybackPositionData,
+    type TmdbCountryFacet,
+    type TmdbEnrichedCastMember,
+    type TmdbGenreFacet,
+    type XtreamVodInfo,
 } from '@iptvnator/shared/interfaces';
+import { SettingsStore } from '@iptvnator/services';
 import type { CrossPortalSimilarItem } from '@iptvnator/services';
 import {
     castMembersFromNames,
     splitPeopleNames,
+    TrailerDialogService,
     type DetailActionButtonState,
     type SimilarRailItem,
 } from '@iptvnator/ui/components';
@@ -54,17 +57,21 @@ interface VodDetailsHeroBindings {
     readonly formatPosition: () => string;
     readonly similarItems: Signal<readonly SimilarCatalogItem[]>;
     readonly similarInPortals: Signal<readonly CrossPortalSimilarItem[]>;
+    readonly openSimilar: (item: SimilarCatalogItem) => void;
+    readonly openSimilarInPortals: (item: CrossPortalSimilarItem) => void;
 }
 
 /**
  * Presentation of the Xtream movie hero: the kind label, the chips, the
- * primary button's two lines, the resume bar, the credits and the Similar
- * rail, all derived from the route's selected movie.
+ * primary button's two lines, the resume bar, the credits, the trailer and
+ * the Similar rail, all derived from the route's selected movie.
  */
 @Injectable()
 export class VodDetailsHeroPresenter {
     private readonly translate = inject(TranslateService);
     private readonly xtreamStore = inject(XtreamStore);
+    private readonly settingsStore = inject(SettingsStore);
+    private readonly trailerDialog = inject(TrailerDialogService);
     private readonly bindings = signal<VodDetailsHeroBindings | null>(null);
 
     bind(bindings: VodDetailsHeroBindings): void {
@@ -208,6 +215,45 @@ export class VodDetailsHeroPresenter {
         return [...local, ...crossPortal];
     });
 
+    readonly trailerEmbedUrl = computed(() =>
+        youtubeEmbedUrl(this.info()?.youtube_trailer)
+    );
+    /** Settings → Playback → Play trailers in details background. */
+    readonly trailerBackdropUrl = computed(() =>
+        this.settingsStore.detailTrailerBackdrop?.() === true
+            ? this.trailerEmbedUrl()
+            : null
+    );
+
+    openTrailer(): void {
+        const embedUrl = this.trailerEmbedUrl();
+        const title = this.info()?.name;
+        if (embedUrl) {
+            this.trailerDialog.open({ embedUrl, title: title ?? '' });
+        }
+    }
+
+    openSimilarRailItem(item: SimilarRailItem): void {
+        const bindings = this.bindings();
+        const local = bindings
+            ?.similarItems()
+            .find((candidate) => `c${candidate.id}` === item.key);
+        if (local) {
+            bindings?.openSimilar(local);
+            return;
+        }
+        const crossPortal = bindings
+            ?.similarInPortals()
+            .find(
+                (candidate) =>
+                    `x${candidate.match.playlistId}-${candidate.match.xtreamId}` ===
+                    item.key
+            );
+        if (crossPortal) {
+            bindings?.openSimilarInPortals(crossPortal);
+        }
+    }
+
     private label(label: RemainingTimeLabel | null): string | null {
         return label ? this.translate.instant(label.key, label.params) : null;
     }
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-playback.service.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-playback.service.ts
index b43a64d66..8984fe555 100644
--- a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-playback.service.ts
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-playback.service.ts
@@ -32,7 +32,6 @@ import {
 import type { PlaybackFallbackRequest } from '@iptvnator/ui/playback';
 import {
     closeRunningExternalSession,
-    ownsContent,
     runningExternalSession,
 } from './vod-details-external-session';
 import {
@@ -40,13 +39,16 @@ import {
     startRouteOwnedPlayback,
 } from './vod-details-external-launch-owner';
 import { injectXtreamRecentHistory } from '../xtream-recent-history';
-import { settleOwnedExternalLaunch } from './vod-details-external-launch';
+import {
+    settleOwnedExternalLaunch,
+    VodExternalLaunchClaim,
+} from './vod-details-external-launch';
 import { resolveXtreamVodPlaybackPresentation } from './vod-details-playback-presentation';
+import { VodDetailsPositionState } from './vod-details-position-state';
 import {
     hasVodResetTarget,
     type VodResetTarget,
 } from './vod-details-reset-target';
-import { isResumablePosition } from './vod-primary-action-position';
 
 export interface VodDetailsPlaybackBindings {
     /** Current vod id resolved from the route */
@@ -83,8 +85,6 @@ export class VodDetailsPlaybackService {
         PlaybackPositionRuntimeBridgeService
     );
     private readonly logger = createLogger('VodDetailsPlayback');
-    private positionLoadGeneration = 0;
-    private destroyed = false;
 
     /** Signals bound from the host component via `bind()` */
     private readonly bindings = signal<VodDetailsPlaybackBindings | null>(null);
@@ -92,27 +92,23 @@ export class VodDetailsPlaybackService {
         () => this.xtreamStore.currentPlaylist()?.id,
         () => this.bindings()?.vodId()
     );
+    /** What this page launched externally, see {@link VodExternalLaunchClaim}. */
+    private readonly externalLaunch = new VodExternalLaunchClaim(
+        this.externalLaunchOwner
+    );
+
+    /** Stored positions of the page, see {@link VodDetailsPositionState}. */
+    private readonly positions = new VodDetailsPositionState({
+        playlistId: () => this.xtreamStore.currentPlaylist()?.id,
+        contentId: () => this.bindings()?.vodId(),
+        alternative: () => this.bindings()?.activeSource?.() ?? null,
+    });
 
     readonly inlinePlayback = signal<ResolvedPortalPlayback | null>(null);
-    /**
-     * The LAST position seen, whichever copy produced it.
-     *
-     * Multi-source can put playback on a copy in another playlist, and this
-     * follows it — the progress bar and the switch feed both want the stream
-     * on screen, not the one the route happens to address.
-     */
-    readonly vodPlaybackPosition = signal<PlaybackPositionData | null>(null);
-
-    /**
-     * The ROUTE copy's own row.
-     *
-     * Everything that acts on the route's stream — Resume, its label, its
-     * timecode — has to read this instead. Positions are keyed by (playlist,
-     * stream), so once an alternative has played, `vodPlaybackPosition` names
-     * a different film's row entirely and resuming from it would jump the
-     * route copy to a timecode nobody reached in it.
-     */
-    readonly routePlaybackPosition = signal<PlaybackPositionData | null>(null);
+    /** The LAST position seen, whichever copy produced it. */
+    readonly vodPlaybackPosition = this.positions.last;
+    /** The ROUTE copy's own row: what Resume, its label and its timecode read. */
+    readonly routePlaybackPosition = this.positions.route;
 
     private readonly externalButton = createExternalPlaybackButtonState({
         session: this.externalPlayback.activeSession,
@@ -131,59 +127,27 @@ export class VodDetailsPlaybackService {
     readonly externalPrimaryIcon = this.externalButton.primaryIcon;
     readonly isExternalLaunchPending = computed(
         () =>
-            this.externalLaunchGeneration() !== null ||
+            this.externalLaunch.pendingGeneration() !== null ||
             this.externalButton.isLaunchPending()
     );
     readonly isExternalStopAction = this.externalButton.isStopAction;
     readonly externalPrimaryButtonState = this.externalButton.buttonState;
-    /** Mirrors an incoming position into the route's row when it owns it. */
-    private trackPosition(position: PlaybackPositionData | null): void {
-        this.vodPlaybackPosition.set(position);
-        if (this.isRouteContent(position)) {
-            this.routePlaybackPosition.set(position);
-        }
-    }
-
-    private isRouteContent(position: PlaybackPositionData | null): boolean {
-        return (
-            !!position &&
-            position.playlistId === this.xtreamStore.currentPlaylist()?.id &&
-            position.contentXtreamId === this.bindings()?.vodId()
-        );
-    }
 
     /** Whether the ROUTE copy has somewhere to resume from. */
-    readonly hasPlaybackPosition = computed(() =>
-        isResumablePosition(this.routePlaybackPosition())
-    );
+    readonly hasPlaybackPosition = this.positions.hasResumable;
 
     constructor() {
         const unsubscribePositionUpdates =
             this.playbackPositionBridge.onPlaybackPositionUpdate(
-                (data: PlaybackPositionData) => {
-                    // An external player on an ALTERNATIVE reports under
-                    // that playlist's ids; dropping those rewinds a switch.
-                    if (this.ownsContent(data)) {
-                        this.trackPosition(data);
-                    }
-                }
+                (data: PlaybackPositionData) => this.positions.trackOwned(data)
             ) ?? null;
 
         inject(DestroyRef).onDestroy(() => {
-            this.destroyed = true;
-            this.positionLoadGeneration++;
+            this.positions.destroy();
             unsubscribePositionUpdates?.();
         });
     }
 
-    private ownsContent(info: Parameters<typeof ownsContent>[0]): boolean {
-        return ownsContent(info, {
-            routePlaylistId: this.xtreamStore.currentPlaylist()?.id,
-            routeContentId: this.bindings()?.vodId(),
-            alternative: this.bindings()?.activeSource?.() ?? null,
-        });
-    }
-
     /** Wires the host component's context signals. Call once at construction. */
     bind(bindings: VodDetailsPlaybackBindings): void {
         this.bindings.set(bindings);
@@ -285,7 +249,7 @@ export class VodDetailsPlaybackService {
                 playlistId,
                 position
             ),
-        onSaved: (position) => this.trackPosition(position),
+        onSaved: (position) => this.positions.track(position),
     });
 
     /**
@@ -318,7 +282,7 @@ export class VodDetailsPlaybackService {
         const routeIdentity = this.externalLaunchOwner.captureRoute();
         this.bindings()?.supersedePendingSwitch();
         const generation = ++this.startGeneration;
-        this.claimExternalLaunch(playback, generation);
+        this.externalLaunch.claim(playback, generation);
         const launch = this.portalPlayer.openExternalPlayback(playback, player);
         void this.settleExternalLaunch(
             generation,
@@ -334,32 +298,16 @@ export class VodDetailsPlaybackService {
      * answer that read started from.
      */
     discardPendingPositionLoads(): void {
-        this.positionLoadGeneration++;
+        this.positions.discardPendingLoads();
     }
 
     /** The route copy's row is in hand; fails closed while a read is in flight. */
-    readonly positionLoaded = signal(false);
+    readonly positionLoaded = this.positions.loaded;
 
-    async loadPosition(playlistId: string, vodId: number): Promise<void> {
-        const generation = ++this.positionLoadGeneration;
-        this.positionLoaded.set(false);
-        const position = await this.playbackPositions.getPlaybackPosition(
-            playlistId,
-            vodId,
-            'vod'
+    loadPosition(playlistId: string, vodId: number): Promise<void> {
+        return this.positions.load(playlistId, vodId, () =>
+            this.playbackPositions.getPlaybackPosition(playlistId, vodId, 'vod')
         );
-        if (
-            this.destroyed ||
-            generation !== this.positionLoadGeneration ||
-            this.xtreamStore.currentPlaylist()?.id !== playlistId ||
-            this.bindings()?.vodId() !== vodId
-        ) {
-            return;
-        }
-
-        this.vodPlaybackPosition.set(position);
-        this.routePlaybackPosition.set(position);
-        this.positionLoaded.set(true);
     }
 
     /**
@@ -374,18 +322,6 @@ export class VodDetailsPlaybackService {
     /** Bumped by every start; only the newest may launch after its close. */
     private startGeneration = 0;
 
-    /**
-     * What we last launched externally, remembered independently of the
-     * controller's active source.
-     *
-     * Kept independently of the controller so a refresh or an overlapping
-     * handoff cannot make the exact process this page launched look foreign
-     * before its teardown has been confirmed. Its route owner prevents a
-     * reused component from attributing that process to a different movie.
-     */
-    private launchedExternallyGeneration = 0;
-    private readonly externalLaunchGeneration = signal<number | null>(null);
-
     /**
      * Starts still between the click and `inlinePlayback` / the external
      * launch (closing the previous player is a round-trip). The watched
@@ -421,7 +357,10 @@ export class VodDetailsPlaybackService {
         isCurrent: () => boolean = () => true,
         player?: ExternalPlayerName
     ): Promise<boolean> {
-        if (this.externalLaunchGeneration() !== null || this.resetPending()) {
+        if (
+            this.externalLaunch.pendingGeneration() !== null ||
+            this.resetPending()
+        ) {
             return false;
         }
         const runningSession = runningExternalSession(
@@ -497,28 +436,18 @@ export class VodDetailsPlaybackService {
         this.positionWriter.reset();
         if (!player && this.portalPlayer.isEmbeddedPlayer()) {
             this.inlinePlayback.set(playback);
-            this.externalLaunchOwner.clear();
-            this.externalLaunchGeneration.set(null);
+            this.externalLaunch.release();
             return true;
         }
 
         this.closeInlinePlayer();
-        this.claimExternalLaunch(playback, generation);
+        this.externalLaunch.claim(playback, generation);
         const launch = player
             ? this.portalPlayer.openExternalPlayback(playback, player)
             : this.portalPlayer.openResolvedPlayback(playback, true);
         return await this.settleExternalLaunch(generation, isCurrent, launch);
     }
 
-    private claimExternalLaunch(
-        playback: ResolvedPortalPlayback,
-        generation: number
-    ): void {
-        this.externalLaunchOwner.set(playback.contentInfo);
-        this.launchedExternallyGeneration = generation;
-        this.externalLaunchGeneration.set(generation);
-    }
-
     private async settleExternalLaunch(
         generation: number,
         isCurrent: () => boolean,
@@ -535,20 +464,9 @@ export class VodDetailsPlaybackService {
                 ),
             reportLaunchFailure: (error) =>
                 this.bindings()?.reportExternalLaunchFailure?.(error),
-            clearPending: () => this.clearExternalLaunchPending(generation),
-            clearOwnership: () => this.clearExternalLaunchOwnership(generation),
+            clearPending: () => this.externalLaunch.clearPending(generation),
+            clearOwnership: () =>
+                this.externalLaunch.clearOwnership(generation),
         });
     }
-
-    private clearExternalLaunchOwnership(generation: number): void {
-        if (this.launchedExternallyGeneration === generation) {
-            this.externalLaunchOwner.clear();
-        }
-    }
-
-    private clearExternalLaunchPending(generation: number): void {
-        if (this.externalLaunchGeneration() === generation) {
-            this.externalLaunchGeneration.set(null);
-        }
-    }
 }
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-position-state.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-position-state.ts
new file mode 100644
index 000000000..24571b753
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-position-state.ts
@@ -0,0 +1,121 @@
+import { computed, signal } from '@angular/core';
+import type {
+    PlaybackPositionData,
+    PlayerContentInfo,
+} from '@iptvnator/shared/interfaces';
+import { ownsContent } from './vod-details-external-session';
+import { isResumablePosition } from './vod-primary-action-position';
+
+/** The copies the page's position state belongs to. */
+export interface VodDetailsPositionRoute {
+    readonly playlistId: () => string | undefined;
+    readonly contentId: () => number | undefined;
+    /** The alternative currently in use, if it is not the route's own. */
+    readonly alternative: () => PlayerContentInfo | null;
+}
+
+/**
+ * Stored playback positions of the VOD details page: the last one seen, the
+ * route copy's own row, and the guarded read that fills both.
+ */
+export class VodDetailsPositionState {
+    private loadGeneration = 0;
+    private destroyed = false;
+
+    /**
+     * The LAST position seen, whichever copy produced it.
+     *
+     * Multi-source can put playback on a copy in another playlist, and this
+     * follows it — the progress bar and the switch feed both want the stream
+     * on screen, not the one the route happens to address.
+     */
+    readonly last = signal<PlaybackPositionData | null>(null);
+
+    /**
+     * The ROUTE copy's own row.
+     *
+     * Everything that acts on the route's stream — Resume, its label, its
+     * timecode — has to read this instead. Positions are keyed by (playlist,
+     * stream), so once an alternative has played, `last` names a different
+     * film's row entirely and resuming from it would jump the route copy to
+     * a timecode nobody reached in it.
+     */
+    readonly route = signal<PlaybackPositionData | null>(null);
+
+    /** Whether the ROUTE copy has somewhere to resume from. */
+    readonly hasResumable = computed(() => isResumablePosition(this.route()));
+
+    /** The route copy's row is in hand; fails closed while a read is in flight. */
+    readonly loaded = signal(false);
+
+    constructor(private readonly routeCopy: VodDetailsPositionRoute) {}
+
+    /** Mirrors an incoming position into the route's row when it owns it. */
+    track(position: PlaybackPositionData | null): void {
+        this.last.set(position);
+        if (this.isRouteContent(position)) {
+            this.route.set(position);
+        }
+    }
+
+    /**
+     * Takes a streamed position when the page owns its content. An external
+     * player on an ALTERNATIVE reports under that playlist's ids; dropping
+     * those rewinds a switch.
+     */
+    trackOwned(position: PlaybackPositionData): void {
+        const owned = {
+            routePlaylistId: this.routeCopy.playlistId(),
+            routeContentId: this.routeCopy.contentId(),
+            alternative: this.routeCopy.alternative(),
+        };
+        if (ownsContent(position, owned)) {
+            this.track(position);
+        }
+    }
+
+    /**
+     * Retires every stored-position read still in flight. A row written
+     * since (the manual watched toggle) must not be overwritten by the older
+     * answer that read started from.
+     */
+    discardPendingLoads(): void {
+        this.loadGeneration++;
+    }
+
+    /** The page is gone: no read still in flight may land. */
+    destroy(): void {
+        this.destroyed = true;
+        this.loadGeneration++;
+    }
+
+    async load(
+        playlistId: string,
+        vodId: number,
+        read: () => Promise<PlaybackPositionData | null>
+    ): Promise<void> {
+        const generation = ++this.loadGeneration;
+        this.loaded.set(false);
+        const position = await read();
+        if (
+            this.destroyed ||
+            generation !== this.loadGeneration ||
+            this.routeCopy.playlistId() !== playlistId ||
+            this.routeCopy.contentId() !== vodId
+        ) {
+            return;
+        }
+
+        this.last.set(position);
+        this.route.set(position);
+        this.loaded.set(true);
+    }
+
+    private isRouteContent(position: PlaybackPositionData | null): boolean {
+        return (
+            !!position &&
+            position.playlistId === this.routeCopy.playlistId() &&
+            position.contentXtreamId === this.routeCopy.contentId()
+        );
+    }
+}
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-route.component.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-route.component.ts
index ffa450009..68b956e63 100644
--- a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-route.component.ts
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-route.component.ts
@@ -8,13 +8,10 @@ import {
     effect,
     inject,
     signal,
-    untracked,
 } from '@angular/core';
-import { toSignal } from '@angular/core/rxjs-interop';
 import { MatIcon } from '@angular/material/icon';
 import { MatSnackBar } from '@angular/material/snack-bar';
-import { MatTooltip } from '@angular/material/tooltip';
-import { ActivatedRoute, Router } from '@angular/router';
+import { ActivatedRoute } from '@angular/router';
 import { TranslateModule, TranslateService } from '@ngx-translate/core';
 import {
     CastCrewRowComponent,
@@ -24,90 +21,40 @@ import {
     DetailIconButtonComponent,
     DetailMetaTemplateDirective,
     DetailTagsTemplateDirective,
-    DialogService,
     MetaChipComponent,
     PortalDetailShellComponent,
     SimilarRailComponent,
     type SimilarRailItem,
-    TrailerDialogService,
     ViewInPortalActionComponent,
     VodMoreMenuComponent,
+    scrollToCastCrewRow,
 } from '@iptvnator/ui/components';
-import {
-    createDiscoverFacetNavigation,
-    createLogger,
-    isProviderOnlyDetailState,
-} from '@iptvnator/portal/shared/util';
+import { createLogger } from '@iptvnator/portal/shared/util';
 import {
     registerContentMetadataBackfill,
-    resolveXtreamVodPlaybackSource,
     XtreamStore,
 } from '@iptvnator/portal/xtream/data-access';
 import {
     type PlaybackFallbackRequest,
     PortalInlinePlayerComponent,
 } from '@iptvnator/ui/playback';
+import { DownloadsService, SettingsStore } from '@iptvnator/services';
 import {
-    CrossPortalSimilarItem,
-    CrossPortalSimilarService,
-    DownloadsService,
-    SettingsStore,
-    TmdbEnrichmentService,
-} from '@iptvnator/services';
-import {
-    getXtreamVodInfo,
-    normalizeTitleKeys,
-    playlistDisplayLabel,
-    reportsPlaybackFailures,
     TmdbEnrichedCastMember,
-    XtreamCategory,
     XtreamVodDetails,
     XtreamVodInfo,
-    XtreamVodStream,
-    youtubeEmbedUrl,
     type ExternalPlayerName,
-    type PlaybackPositionData,
-    type VodSourceCandidate,
-    type VodSourceDescriptor,
 } from '@iptvnator/shared/interfaces';
-import {
-    SimilarCatalogItem,
-    matchRecommendationsToCatalog,
-} from '../tmdb-similar.util';
-import {
-    buildXtreamVodFallbackViewModel,
-    hasUsableXtreamVodMetadata,
-} from './vod-details-fallback.util';
+import { injectXtreamDetailNavigation } from '../xtream-detail-navigation';
 import { VodDetailsPlaybackService } from './vod-details-playback.service';
 import { VodDetailsMultiSourceUiService } from './vod-details-multi-source-ui.service';
 import { VodDetailsDownloadsService } from './vod-details-downloads.service';
 import { VodDetailsWatchedService } from './vod-details-watched.service';
 import { VodDetailsHeroPresenter } from './vod-details-hero.presenter';
 import { VodDetailsMenuService } from './vod-details-menu.service';
+import { VodDetailsSelectionService } from './vod-details-selection.service';
 import { VodDetailsSimilarService } from './vod-details-similar.service';
 import { VodMultiSourceHostService } from './vod-multi-source-host.service';
-import { resolveVodMultiSourceMovie } from './vod-multi-source-identity';
-import { createPlaybackSessionKey } from '@iptvnator/playback/util';
-
-type XtreamVodIdentityItem = XtreamVodDetails & {
-    readonly id?: number | string;
-    readonly stream_id?: number | string;
-    readonly xtream_id?: number | string;
-};
-
-function resolveVodIdentity(item: XtreamVodDetails): number | null {
-    const candidate = item as XtreamVodIdentityItem;
-    const value =
-        item.movie_data?.stream_id ??
-        candidate.xtream_id ??
-        candidate.stream_id ??
-        candidate.id;
-    const id = typeof value === 'string' ? Number(value) : value;
-
-    return typeof id === 'number' && Number.isSafeInteger(id) && id > 0
-        ? id
-        : null;
-}
 
 @Component({
     templateUrl: './vod-details-route.component.html',
@@ -117,6 +64,7 @@ function resolveVodIdentity(item: XtreamVodDetails): number | null {
     ],
     changeDetection: ChangeDetectionStrategy.OnPush,
     providers: [
+        VodDetailsSelectionService,
         VodDetailsPlaybackService,
         VodMultiSourceHostService,
         VodDetailsMultiSourceUiService,
@@ -131,7 +79,6 @@ function resolveVodIdentity(item: XtreamVodDetails): number | null {
         DetailMetaTemplateDirective,
         DetailTagsTemplateDirective,
         MatIcon,
-        MatTooltip,
         NgTemplateOutlet,
         PortalDetailShellComponent,
         ViewInPortalActionComponent,
@@ -151,11 +98,9 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
     private readonly location = inject(Location);
     private readonly settingsStore = inject(SettingsStore);
     private readonly route = inject(ActivatedRoute);
-    private readonly router = inject(Router);
-    private readonly crossPortalSimilar = inject(CrossPortalSimilarService);
+    private readonly navigation = injectXtreamDetailNavigation('movie');
     private readonly xtreamStore = inject(XtreamStore);
     private readonly downloadsService = inject(DownloadsService);
-    private readonly dialogService = inject(DialogService);
     private readonly snackBar = inject(MatSnackBar);
     private readonly translateService = inject(TranslateService);
     private readonly playback = inject(VodDetailsPlaybackService);
@@ -167,7 +112,8 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
     private readonly watched = inject(VodDetailsWatchedService);
     readonly hero = inject(VodDetailsHeroPresenter);
     readonly menu = inject(VodDetailsMenuService);
-    private readonly trailerDialog = inject(TrailerDialogService);
+    /** The movie the route addresses, see {@link VodDetailsSelectionService}. */
+    private readonly selection = inject(VodDetailsSelectionService);
     private readonly logger = createLogger('VodDetailsRoute');
     /** `playlistId:vodId` of the last initialized detail view */
     private readonly lastInitKey = signal<string | null>(null);
@@ -176,167 +122,22 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
     /** The route copy's own row — what Resume acts on. */
     readonly routePlaybackPosition = this.playback.routePlaybackPosition;
 
-    /**
-     * Reactive route params: the component is reused when navigating
-     * between two VOD details (e.g. via the Similar rail), so computeds
-     * must not read the one-shot snapshot.
-     */
-    private readonly routeParams = toSignal(this.route.params, {
-        initialValue: this.route.snapshot.params,
-    });
-
     readonly theme = this.settingsStore.theme;
     readonly isElectron = this.downloadsService.isAvailable;
 
     readonly isFavorite = this.xtreamStore.isFavorite;
     readonly isWatched = this.watched.isWatched;
     readonly canToggleWatched = this.watched.canToggle;
-    readonly selectedVodId = computed(() =>
-        Number(this.routeParams()['vodId'])
-    );
-    readonly playbackSessionKey = computed(() => {
-        const sourceId = this.xtreamStore.currentPlaylist()?.id;
-        const contentId = this.selectedVodId();
-        return sourceId && Number.isFinite(contentId) && contentId > 0
-            ? createPlaybackSessionKey({ kind: 'vod', sourceId, contentId })
-            : '';
-    });
-    readonly providerOnly = computed(() => {
-        this.routeParams();
-        return isProviderOnlyDetailState(window.history.state);
-    });
-    readonly selectedItem = computed(() => {
-        const item =
-            this.xtreamStore.selectedItem() as unknown as XtreamVodDetails | null;
-
-        return item && resolveVodIdentity(item) === this.selectedVodId()
-            ? item
-            : null;
-    });
-    private readonly scopedVodCategories = computed(() => {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        return playlistId &&
-            this.xtreamStore.vodCategoriesPlaylistId() === playlistId
-            ? this.xtreamStore.vodCategories()
-            : [];
-    });
-    private readonly scopedVodStreams = computed(() => {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        return playlistId &&
-            this.xtreamStore.vodStreamsPlaylistId() === playlistId
-            ? this.xtreamStore.vodStreams()
-            : [];
-    });
-    readonly selectedCategory = computed<Partial<XtreamCategory> | null>(() => {
-        const categoryId = this.routeParams()['categoryId'];
-        if (!categoryId) {
-            return null;
-        }
-
-        return (
-            this.scopedVodCategories().find(
-                (category) =>
-                    String(
-                        (
-                            category as XtreamCategory & {
-                                id?: string | number;
-                            }
-                        ).category_id ??
-                            (
-                                category as XtreamCategory & {
-                                    id?: string | number;
-                                }
-                            ).id
-                    ) === String(categoryId)
-            ) ?? null
-        );
-    });
-    readonly selectedCatalogItem = computed<
-        | (Partial<XtreamVodStream> & {
-              id?: string | number;
-              poster_url?: string;
-              title?: string;
-              xtream_id?: string | number;
-          })
-        | null
-    >(() => {
-        const vodId = this.selectedVodId();
-        if (!Number.isFinite(vodId) || vodId <= 0) {
-            return null;
-        }
-
-        return (
-            this.scopedVodStreams().find(
-                (item) =>
-                    Number(
-                        (
-                            item as XtreamVodStream & {
-                                id?: string | number;
-                                xtream_id?: string | number;
-                            }
-                        ).xtream_id ??
-                            (
-                                item as XtreamVodStream & {
-                                    id?: string | number;
-                                }
-                            ).stream_id ??
-                            (
-                                item as XtreamVodStream & {
-                                    id?: string | number;
-                                }
-                            ).id
-                    ) === vodId
-            ) ?? null
-        );
-    });
-    /** Movie identity for multi-source discovery; null until a title exists */
-    private readonly multiSourceMovie = computed(() => {
-        // Electron stores categories under `name`, the live API under
-        // `category_name` — the same duality the fallback view reads.
-        const category = this.selectedCategory() as {
-            name?: string;
-            category_name?: string;
-        } | null;
-
-        return resolveVodMultiSourceMovie({
-            playlistId: this.xtreamStore.currentPlaylist()?.id,
-            // `title` is the alias the Xtream data source actually writes
-            // (createPlaylist maps name -> title), so reading only `name`
-            // would fall back to the raw playlist UUID in the sources list.
-            playlistName:
-                this.xtreamStore.currentPlaylist()?.name ??
-                this.xtreamStore.currentPlaylist()?.title,
-            vodId: this.selectedVodId(),
-            vodInfo: this.selectedVodInfo(),
-            catalogItem: this.selectedCatalogItem(),
-            containerExtension:
-                this.selectedItem()?.movie_data?.container_extension,
-            categoryName: category?.name ?? category?.category_name ?? null,
-        });
-    });
-    readonly selectedVodInfo = computed(() => {
-        const item = this.selectedItem();
-        return item && hasUsableXtreamVodMetadata(item)
-            ? getXtreamVodInfo(item)
-            : null;
-    });
-    readonly playableVodItem = computed(() => {
-        const item = this.selectedItem();
-        return item && resolveXtreamVodPlaybackSource(item) ? item : null;
-    });
-    readonly fallbackView = computed(() => {
-        const item = this.selectedItem();
-        if (!item || this.selectedVodInfo()) {
-            return null;
-        }
-
-        return buildXtreamVodFallbackViewModel({
-            vodDetails: item,
-            catalogItem: this.selectedCatalogItem(),
-            category: this.selectedCategory(),
-            vodId: this.selectedVodId(),
-        });
-    });
+    readonly selectedVodId = this.selection.selectedVodId;
+    readonly playbackSessionKey = this.selection.playbackSessionKey;
+    readonly providerOnly = this.selection.providerOnly;
+    readonly selectedItem = this.selection.selectedItem;
+    readonly selectedCategory = this.selection.selectedCategory;
+    readonly selectedCatalogItem = this.selection.selectedCatalogItem;
+    private readonly multiSourceMovie = this.selection.multiSourceMovie;
+    readonly selectedVodInfo = this.selection.selectedVodInfo;
+    readonly playableVodItem = this.selection.playableVodItem;
+    readonly fallbackView = this.selection.fallbackView;
     readonly isLoadingDetails = this.xtreamStore.isLoadingDetails;
     readonly detailsError = this.xtreamStore.detailsError;
     readonly matchedExternalPlayback = this.playback.matchedExternalPlayback;
@@ -362,38 +163,19 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
             this.isDownloaded() && this.externalPrimaryButtonState() === 'idle'
     );
 
-    /** 2πr of the r=15.5 progress-ring circle in its 36×36 viewBox. */
-    readonly downloadRingCircumference = 2 * Math.PI * 15.5;
-
-    /**
-     * Dash offset that leaves the arc at the real percent — or a fixed
-     * quarter arc when the total size is unknown and the ring spins instead.
-     */
-    readonly downloadRingOffset = computed(() => {
-        const percent = this.downloadPercent();
-        return percent === null
-            ? this.downloadRingCircumference * 0.75
-            : this.downloadRingCircumference * (1 - percent / 100);
-    });
+    readonly downloadRingCircumference = this.downloads.ringCircumference;
+    readonly downloadRingOffset = this.downloads.ringOffset;
 
     /** Drives the heart's brief scale pulse when favoriting toggles. */
     readonly favoritePulse = signal(false);
     private favoritePulseTimer: ReturnType<typeof setTimeout> | null = null;
 
-    readonly trailerEmbedUrl = computed(() =>
-        youtubeEmbedUrl(this.selectedVodInfo()?.youtube_trailer)
-    );
-    /** `playlist:vod`: the hero keys its one-time layout decision on it. */
-    readonly contentKey = computed(
-        () =>
-            `xtream-vod:${this.xtreamStore.currentPlaylist()?.id ?? ''}:${this.selectedVodId()}`
-    );
-    /** Settings → Playback → Play trailers in details background. */
-    readonly trailerBackdropUrl = computed(() =>
-        this.settingsStore.detailTrailerBackdrop?.() === true
-            ? this.trailerEmbedUrl()
-            : null
-    );
+    readonly trailerEmbedUrl = this.hero.trailerEmbedUrl;
+    readonly contentKey = this.selection.contentKey;
+    readonly trailerBackdropUrl = this.hero.trailerBackdropUrl;
+    readonly scrollToCast = scrollToCastCrewRow;
+    /** Clickable year/genre/country chips (Discover pages) */
+    readonly discover = this.navigation.discover;
 
     readonly similarItems = this.similar.similarItems;
     readonly similarInPortals = this.similar.similarInPortals;
@@ -511,6 +293,9 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
             formatPosition: () => this.formatPosition(),
             similarItems: this.similarItems,
             similarInPortals: this.similarInPortals,
+            openSimilar: (item) => this.navigation.openSimilar(item),
+            openSimilarInPortals: (item) =>
+                this.navigation.openSimilarInPortals(item),
         });
         this.menu.bind({
             item: this.playableVodItem,
@@ -538,73 +323,18 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
         }
     }
 
-    openSimilarInPortals(item: CrossPortalSimilarItem): void {
-        void this.router.navigate(this.crossPortalSimilar.buildLink(item));
-    }
-
-    openSimilar(item: SimilarCatalogItem): void {
-        void this.router.navigate(['../..', item.categoryId, item.id], {
-            relativeTo: this.route,
-        });
-    }
-
     openSimilarRailItem(item: SimilarRailItem): void {
-        const local = this.similarItems().find(
-            (candidate) => `c${candidate.id}` === item.key
-        );
-        if (local) {
-            this.openSimilar(local);
-            return;
-        }
-        const crossPortal = this.similarInPortals().find(
-            (candidate) =>
-                `x${candidate.match.playlistId}-${candidate.match.xtreamId}` ===
-                item.key
-        );
-        if (crossPortal) {
-            this.openSimilarInPortals(crossPortal);
-        }
+        this.hero.openSimilarRailItem(item);
     }
 
     openTrailer(): void {
-        const embedUrl = this.trailerEmbedUrl();
-        const title = this.selectedVodInfo()?.name;
-        if (embedUrl) {
-            this.trailerDialog.open({ embedUrl, title: title ?? '' });
-        }
-    }
-
-    scrollToCast(): void {
-        document
-            .getElementById('detail-cast-crew')
-            ?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        this.hero.openTrailer();
     }
 
     openActor(member: TmdbEnrichedCastMember): void {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        if (!playlistId || !member.tmdbPersonId) {
-            return;
-        }
-        void this.router.navigate([
-            '/workspace/xtreams',
-            playlistId,
-            'actor',
-            member.tmdbPersonId,
-        ]);
+        this.navigation.openActor(member);
     }
 
-    /** Clickable year/genre/country chips (Discover pages) */
-    private readonly tmdbEnrichment = inject(TmdbEnrichmentService);
-
-    readonly discover = createDiscoverFacetNavigation(() => {
-        const playlistId = this.xtreamStore.currentPlaylist()?.id;
-        // Discover reads its results from TMDB, so a chip must not offer a
-        // page that enrichment cannot fill
-        return playlistId && this.tmdbEnrichment.isEnabled()
-            ? { portal: 'xtream', mediaType: 'movie', playlistId }
-            : null;
-    });
-
     ngOnDestroy(): void {
         if (this.favoritePulseTimer) {
             clearTimeout(this.favoritePulseTimer);
@@ -869,26 +599,8 @@ export class VodDetailsRouteComponent implements OnInit, OnDestroy {
         return this.downloads.resumePaused();
     }
 
-    /**
-     * A running download is destroyed by one click, so the icon button asks
-     * first — there is no label left to warn what the click does.
-     */
     promptCancelDownload(): void {
-        this.dialogService.openConfirmDialog({
-            title: this.translateService.instant(
-                'DOWNLOADS.CANCEL_CONFIRM_TITLE'
-            ),
-            message: this.translateService.instant(
-                'DOWNLOADS.CANCEL_CONFIRM_MESSAGE'
-            ),
-            confirmLabel: this.translateService.instant(
-                'DOWNLOADS.CANCEL_CONFIRM_TITLE'
-            ),
-            // "Cancel" next to "Cancel download" would read as the same action.
-            cancelLabel: this.translateService.instant('CLOSE'),
-            tone: 'destructive',
-            onConfirm: () => void this.downloads.cancelActive(),
-        });
+        this.downloads.promptCancel();
     }
 
     revealDownloadedFile(): Promise<void> {
diff --git a/libs/portal/xtream/feature/src/lib/vod-details/vod-details-selection.service.ts b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-selection.service.ts
new file mode 100644
index 000000000..cc4458b67
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/vod-details/vod-details-selection.service.ts
@@ -0,0 +1,213 @@
+import { Injectable, computed, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute } from '@angular/router';
+import { createPlaybackSessionKey } from '@iptvnator/playback/util';
+import { isProviderOnlyDetailState } from '@iptvnator/portal/shared/util';
+import {
+    resolveXtreamVodPlaybackSource,
+    XtreamStore,
+} from '@iptvnator/portal/xtream/data-access';
+import {
+    getXtreamVodInfo,
+    XtreamCategory,
+    XtreamVodDetails,
+    XtreamVodStream,
+} from '@iptvnator/shared/interfaces';
+import {
+    buildXtreamVodFallbackViewModel,
+    hasUsableXtreamVodMetadata,
+} from './vod-details-fallback.util';
+import { resolveVodMultiSourceMovie } from './vod-multi-source-identity';
+
+type XtreamVodIdentityItem = XtreamVodDetails & {
+    readonly id?: number | string;
+    readonly stream_id?: number | string;
+    readonly xtream_id?: number | string;
+};
+
+function resolveVodIdentity(item: XtreamVodDetails): number | null {
+    const candidate = item as XtreamVodIdentityItem;
+    const value =
+        item.movie_data?.stream_id ??
+        candidate.xtream_id ??
+        candidate.stream_id ??
+        candidate.id;
+    const id = typeof value === 'string' ? Number(value) : value;
+
+    return typeof id === 'number' && Number.isSafeInteger(id) && id > 0
+        ? id
+        : null;
+}
+
+/**
+ * What the VOD details route selects: the movie the params address, as the
+ * store, the loaded catalog and the route's category describe it. Read-only
+ * derivations of the route and the store, shared by the page and the
+ * services it binds.
+ */
+@Injectable()
+export class VodDetailsSelectionService {
+    private readonly route = inject(ActivatedRoute);
+    private readonly xtreamStore = inject(XtreamStore);
+
+    /**
+     * Reactive route params: the component is reused when navigating
+     * between two VOD details (e.g. via the Similar rail), so computeds
+     * must not read the one-shot snapshot.
+     */
+    private readonly routeParams = toSignal(this.route.params, {
+        initialValue: this.route.snapshot.params,
+    });
+
+    readonly selectedVodId = computed(() =>
+        Number(this.routeParams()['vodId'])
+    );
+    readonly playbackSessionKey = computed(() => {
+        const sourceId = this.xtreamStore.currentPlaylist()?.id;
+        const contentId = this.selectedVodId();
+        return sourceId && Number.isFinite(contentId) && contentId > 0
+            ? createPlaybackSessionKey({ kind: 'vod', sourceId, contentId })
+            : '';
+    });
+    readonly providerOnly = computed(() => {
+        this.routeParams();
+        return isProviderOnlyDetailState(window.history.state);
+    });
+    readonly selectedItem = computed(() => {
+        const item =
+            this.xtreamStore.selectedItem() as unknown as XtreamVodDetails | null;
+
+        return item && resolveVodIdentity(item) === this.selectedVodId()
+            ? item
+            : null;
+    });
+    private readonly scopedVodCategories = computed(() => {
+        const playlistId = this.xtreamStore.currentPlaylist()?.id;
+        return playlistId &&
+            this.xtreamStore.vodCategoriesPlaylistId() === playlistId
+            ? this.xtreamStore.vodCategories()
+            : [];
+    });
+    private readonly scopedVodStreams = computed(() => {
+        const playlistId = this.xtreamStore.currentPlaylist()?.id;
+        return playlistId &&
+            this.xtreamStore.vodStreamsPlaylistId() === playlistId
+            ? this.xtreamStore.vodStreams()
+            : [];
+    });
+    readonly selectedCategory = computed<Partial<XtreamCategory> | null>(() => {
+        const categoryId = this.routeParams()['categoryId'];
+        if (!categoryId) {
+            return null;
+        }
+
+        return (
+            this.scopedVodCategories().find(
+                (category) =>
+                    String(
+                        (
+                            category as XtreamCategory & {
+                                id?: string | number;
+                            }
+                        ).category_id ??
+                            (
+                                category as XtreamCategory & {
+                                    id?: string | number;
+                                }
+                            ).id
+                    ) === String(categoryId)
+            ) ?? null
+        );
+    });
+    readonly selectedCatalogItem = computed<
+        | (Partial<XtreamVodStream> & {
+              id?: string | number;
+              poster_url?: string;
+              title?: string;
+              xtream_id?: string | number;
+          })
+        | null
+    >(() => {
+        const vodId = this.selectedVodId();
+        if (!Number.isFinite(vodId) || vodId <= 0) {
+            return null;
+        }
+
+        return (
+            this.scopedVodStreams().find(
+                (item) =>
+                    Number(
+                        (
+                            item as XtreamVodStream & {
+                                id?: string | number;
+                                xtream_id?: string | number;
+                            }
+                        ).xtream_id ??
+                            (
+                                item as XtreamVodStream & {
+                                    id?: string | number;
+                                }
+                            ).stream_id ??
+                            (
+                                item as XtreamVodStream & {
+                                    id?: string | number;
+                                }
+                            ).id
+                    ) === vodId
+            ) ?? null
+        );
+    });
+    /** Movie identity for multi-source discovery; null until a title exists */
+    readonly multiSourceMovie = computed(() => {
+        // Electron stores categories under `name`, the live API under
+        // `category_name` — the same duality the fallback view reads.
+        const category = this.selectedCategory() as {
+            name?: string;
+            category_name?: string;
+        } | null;
+
+        return resolveVodMultiSourceMovie({
+            playlistId: this.xtreamStore.currentPlaylist()?.id,
+            // `title` is the alias the Xtream data source actually writes
+            // (createPlaylist maps name -> title), so reading only `name`
+            // would fall back to the raw playlist UUID in the sources list.
+            playlistName:
+                this.xtreamStore.currentPlaylist()?.name ??
+                this.xtreamStore.currentPlaylist()?.title,
+            vodId: this.selectedVodId(),
+            vodInfo: this.selectedVodInfo(),
+            catalogItem: this.selectedCatalogItem(),
+            containerExtension:
+                this.selectedItem()?.movie_data?.container_extension,
+            categoryName: category?.name ?? category?.category_name ?? null,
+        });
+    });
+    readonly selectedVodInfo = computed(() => {
+        const item = this.selectedItem();
+        return item && hasUsableXtreamVodMetadata(item)
+            ? getXtreamVodInfo(item)
+            : null;
+    });
+    readonly playableVodItem = computed(() => {
+        const item = this.selectedItem();
+        return item && resolveXtreamVodPlaybackSource(item) ? item : null;
+    });
+    readonly fallbackView = computed(() => {
+        const item = this.selectedItem();
+        if (!item || this.selectedVodInfo()) {
+            return null;
+        }
+
+        return buildXtreamVodFallbackViewModel({
+            vodDetails: item,
+            catalogItem: this.selectedCatalogItem(),
+            category: this.selectedCategory(),
+            vodId: this.selectedVodId(),
+        });
+    });
+    /** `playlist:vod`: the hero keys its one-time layout decision on it. */
+    readonly contentKey = computed(
+        () =>
+            `xtream-vod:${this.xtreamStore.currentPlaylist()?.id ?? ''}:${this.selectedVodId()}`
+    );
+}
diff --git a/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.spec.ts b/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.spec.ts
new file mode 100644
index 000000000..aa6cc02c7
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.spec.ts
@@ -0,0 +1,114 @@
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { ActivatedRoute, Router } from '@angular/router';
+import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
+import {
+    CrossPortalSimilarService,
+    TmdbEnrichmentService,
+} from '@iptvnator/services';
+import {
+    injectXtreamDetailNavigation,
+    type XtreamDetailNavigation,
+} from './xtream-detail-navigation';
+
+describe('injectXtreamDetailNavigation', () => {
+    const route = { snapshot: { params: {} } };
+    const navigate = jest.fn();
+    const buildLink = jest.fn();
+    const currentPlaylist = signal<{ id: string } | null>(null);
+    const enrichmentEnabled = signal(true);
+
+    function create(mediaType: 'movie' | 'tv'): XtreamDetailNavigation {
+        return TestBed.runInInjectionContext(() =>
+            injectXtreamDetailNavigation(mediaType)
+        );
+    }
+
+    beforeEach(() => {
+        navigate.mockReset();
+        buildLink.mockReset();
+        currentPlaylist.set({ id: 'xtream-1' });
+        enrichmentEnabled.set(true);
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: Router, useValue: { navigate } },
+                { provide: ActivatedRoute, useValue: route },
+                { provide: XtreamStore, useValue: { currentPlaylist } },
+                { provide: CrossPortalSimilarService, useValue: { buildLink } },
+                {
+                    provide: TmdbEnrichmentService,
+                    useValue: { isEnabled: () => enrichmentEnabled() },
+                },
+            ],
+        });
+    });
+
+    it('opens the actor page of a TMDB-matched cast member', () => {
+        create('movie').openActor({ name: 'Mara', tmdbPersonId: 77 } as never);
+
+        expect(navigate).toHaveBeenCalledWith([
+            '/workspace/xtreams',
+            'xtream-1',
+            'actor',
+            77,
+        ]);
+    });
+
+    it('opens no actor page without a playlist or a TMDB person', () => {
+        const navigation = create('movie');
+
+        navigation.openActor({ name: 'Mara' } as never);
+        currentPlaylist.set(null);
+        navigation.openActor({ name: 'Mara', tmdbPersonId: 77 } as never);
+
+        expect(navigate).not.toHaveBeenCalled();
+    });
+
+    it('opens a similar title of this playlist relative to the details route', () => {
+        create('tv').openSimilar({ categoryId: 12, id: 345 } as never);
+
+        expect(navigate).toHaveBeenCalledWith(['../..', 12, 345], {
+            relativeTo: route,
+        });
+    });
+
+    it('opens a similar title of another portal through its link', () => {
+        const item = { match: { playlistId: 'xtream-2' } } as never;
+        const link = ['/workspace/xtreams', 'xtream-2', 'series', '3', '9'];
+        buildLink.mockReturnValue(link);
+
+        create('tv').openSimilarInPortals(item);
+
+        expect(buildLink).toHaveBeenCalledWith(item);
+        expect(navigate).toHaveBeenCalledWith(link);
+    });
+
+    it.each(['movie', 'tv'] as const)(
+        'sends the facet chips to the %s Discover page of the playlist',
+        (mediaType) => {
+            const { discover } = create(mediaType);
+
+            expect(discover.canOpenYear('1999-03-31')).toBe(true);
+            discover.openYear('1999-03-31');
+
+            expect(navigate).toHaveBeenCalledWith(
+                ['/workspace', 'xtreams', 'xtream-1', 'discover'],
+                { queryParams: { type: mediaType, year: '1999' } }
+            );
+        }
+    );
+
+    it('offers no facet chip while enrichment cannot fill Discover', () => {
+        const { discover } = create('movie');
+
+        enrichmentEnabled.set(false);
+        expect(discover.canOpenYear('1999-03-31')).toBe(false);
+
+        enrichmentEnabled.set(true);
+        currentPlaylist.set(null);
+        expect(discover.canOpenYear('1999-03-31')).toBe(false);
+        discover.openYear('1999-03-31');
+
+        expect(navigate).not.toHaveBeenCalled();
+    });
+});
diff --git a/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.ts b/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.ts
new file mode 100644
index 000000000..f0c2d93a2
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/xtream-detail-navigation.ts
@@ -0,0 +1,73 @@
+import { inject } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import {
+    createDiscoverFacetNavigation,
+    type DiscoverFacetNavigation,
+} from '@iptvnator/portal/shared/util';
+import { XtreamStore } from '@iptvnator/portal/xtream/data-access';
+import {
+    CrossPortalSimilarItem,
+    CrossPortalSimilarService,
+    TmdbEnrichmentService,
+} from '@iptvnator/services';
+import type { TmdbEnrichedCastMember } from '@iptvnator/shared/interfaces';
+import type { SimilarCatalogItem } from './tmdb-similar.util';
+
+/** Where an Xtream movie or series details page can send the viewer. */
+export interface XtreamDetailNavigation {
+    /** Clickable year/genre/country chips (Discover pages) */
+    readonly discover: DiscoverFacetNavigation;
+    /** The actor page of a TMDB-matched cast member. */
+    openActor(member: TmdbEnrichedCastMember): void;
+    /** A Similar-rail title of this playlist: the same route, another id. */
+    openSimilar(item: SimilarCatalogItem): void;
+    /** A Similar-rail title found in another of the user's portals. */
+    openSimilarInPortals(item: CrossPortalSimilarItem): void;
+}
+
+/**
+ * Outbound navigation shared by the Xtream movie (`movie`) and series (`tv`)
+ * details pages.
+ *
+ * Must run in an injection context.
+ */
+export function injectXtreamDetailNavigation(
+    mediaType: 'movie' | 'tv'
+): XtreamDetailNavigation {
+    const router = inject(Router);
+    const route = inject(ActivatedRoute);
+    const xtreamStore = inject(XtreamStore);
+    const crossPortalSimilar = inject(CrossPortalSimilarService);
+    const tmdbEnrichment = inject(TmdbEnrichmentService);
+
+    return {
+        discover: createDiscoverFacetNavigation(() => {
+            const playlistId = xtreamStore.currentPlaylist()?.id;
+            // Discover reads its results from TMDB, so a chip must not offer a
+            // page that enrichment cannot fill
+            return playlistId && tmdbEnrichment.isEnabled()
+                ? { portal: 'xtream', mediaType, playlistId }
+                : null;
+        }),
+        openActor(member) {
+            const playlistId = xtreamStore.currentPlaylist()?.id;
+            if (!playlistId || !member.tmdbPersonId) {
+                return;
+            }
+            void router.navigate([
+                '/workspace/xtreams',
+                playlistId,
+                'actor',
+                member.tmdbPersonId,
+            ]);
+        },
+        openSimilar(item) {
+            void router.navigate(['../..', item.categoryId, item.id], {
+                relativeTo: route,
+            });
+        },
+        openSimilarInPortals(item) {
+            void router.navigate(crossPortalSimilar.buildLink(item));
+        },
+    };
+}
diff --git a/libs/services/src/lib/settings-store.defaults.ts b/libs/services/src/lib/settings-store.defaults.ts
index 75d4da6c2..aec852a0b 100644
--- a/libs/services/src/lib/settings-store.defaults.ts
+++ b/libs/services/src/lib/settings-store.defaults.ts
@@ -8,6 +8,7 @@ import {
     StreamFormat,
     Theme,
     VideoPlayer,
+    watchEmbeddedMpvSupport,
 } from '@iptvnator/shared/interfaces';
 
 /** Defaults and boot-time helpers of `SettingsStore`, split out for size. */
@@ -115,3 +116,52 @@ export function scheduleEmbeddedMpvPrepare(): void {
         window.setTimeout(prepare, 2000);
     }
 }
+
+/**
+ * Checks a saved Embedded MPV selection against this machine: schedules the
+ * idle prepare when it is supported, and calls `fallBack` when it is not or
+ * when the check itself fails. An inconclusive answer is no verdict: the
+ * selection stays and the answer is followed until it is final. Nothing is
+ * done once `isSaved` turns false, because the user picked another player
+ * meanwhile. Resolves when the first answer has been handled.
+ */
+export function verifySavedEmbeddedMpvPlayer(
+    isSaved: () => boolean,
+    fallBack: () => Promise<void>
+): Promise<void> {
+    const electron =
+        typeof window === 'undefined' ? undefined : window.electron;
+    if (!electron?.getEmbeddedMpvSupport) {
+        return fallBack();
+    }
+
+    return new Promise<void>((handled, failed) => {
+        const stop = watchEmbeddedMpvSupport(
+            () => electron.getEmbeddedMpvSupport(),
+            (support) => {
+                if (!isSaved()) {
+                    stop();
+                    handled();
+                } else if (support.supported) {
+                    scheduleEmbeddedMpvPrepare();
+                    handled();
+                } else if (support.inconclusive) {
+                    handled();
+                } else {
+                    fallBack().then(handled, failed);
+                }
+            },
+            (error) => {
+                console.warn(
+                    'Failed to verify embedded MPV support; reverting to the default inline player.',
+                    error
+                );
+                if (isSaved()) {
+                    fallBack().then(handled, failed);
+                } else {
+                    handled();
+                }
+            }
+        );
+    });
+}
diff --git a/libs/services/src/lib/settings-store.embedded-mpv.spec.ts b/libs/services/src/lib/settings-store.embedded-mpv.spec.ts
new file mode 100644
index 000000000..243477609
--- /dev/null
+++ b/libs/services/src/lib/settings-store.embedded-mpv.spec.ts
@@ -0,0 +1,190 @@
+import { Injector } from '@angular/core';
+import { StorageMap } from '@ngx-pwa/local-storage';
+import { of } from 'rxjs';
+import {
+    EMBEDDED_MPV_SUPPORT_RECHECK_MS,
+    EmbeddedMpvSupport,
+    Settings,
+    STORE_KEY,
+    VideoPlayer,
+} from '@iptvnator/shared/interfaces';
+import { EpgSourceSettingsService } from './epg-source-settings.service';
+import { SettingsStore } from './settings-store.service';
+
+/** What the main process answers when the Linux `mpv` probe finds nothing. */
+const MPV_MISSING: EmbeddedMpvSupport = {
+    supported: false,
+    platform: 'linux',
+    reason: 'Embedded MPV on Linux requires the mpv executable on PATH.',
+    frameCopyAvailable: false,
+    frameCopyUnavailableReason: 'helper-probe-failed',
+};
+/** A slow login shell: mpv was looked up before its PATH arrived. */
+const INCONCLUSIVE: EmbeddedMpvSupport = { ...MPV_MISSING, inconclusive: true };
+const SUPPORTED: EmbeddedMpvSupport = {
+    supported: true,
+    platform: 'linux',
+    engine: 'native',
+};
+
+describe('SettingsStore saved Embedded MPV selection', () => {
+    const testWindow = window as unknown as {
+        electron?: { getEmbeddedMpvSupport: jest.Mock };
+    };
+    const originalElectron = testWindow.electron;
+    let getEmbeddedMpvSupport: jest.Mock;
+    let storage: { get: jest.Mock; set: jest.Mock };
+    let injector: Injector;
+
+    /** Loads settings as on startup and lets the first answer be handled. */
+    async function start(): Promise<InstanceType<typeof SettingsStore>> {
+        const store = injector.get(SettingsStore);
+        await store.loadSettings();
+        await jest.advanceTimersByTimeAsync(0);
+        expect(getEmbeddedMpvSupport).toHaveBeenCalled();
+        return store;
+    }
+
+    const persistedPlayers = () =>
+        storage.set.mock.calls.map(([, settings]) => settings.player);
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        const saved: Partial<Settings> = { player: VideoPlayer.EmbeddedMpv };
+        storage = {
+            get: jest.fn(() => of(saved)),
+            set: jest.fn(() => of(undefined)),
+        };
+        getEmbeddedMpvSupport = jest.fn();
+        testWindow.electron = { getEmbeddedMpvSupport };
+        injector = Injector.create({
+            providers: [
+                SettingsStore,
+                EpgSourceSettingsService,
+                { provide: StorageMap, useValue: storage },
+            ],
+        });
+        jest.spyOn(
+            injector.get(EpgSourceSettingsService),
+            'synchronize'
+        ).mockResolvedValue(undefined);
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+        testWindow.electron = originalElectron;
+    });
+
+    it('keeps the saved player while the support check is inconclusive', async () => {
+        getEmbeddedMpvSupport.mockResolvedValue(INCONCLUSIVE);
+
+        const store = await start();
+        await jest.advanceTimersByTimeAsync(EMBEDDED_MPV_SUPPORT_RECHECK_MS);
+
+        expect(store.player()).toBe(VideoPlayer.EmbeddedMpv);
+        expect(storage.set).not.toHaveBeenCalled();
+    });
+
+    it('falls back to the default player on a final unsupported answer', async () => {
+        getEmbeddedMpvSupport.mockResolvedValue(MPV_MISSING);
+
+        const store = await start();
+
+        expect(store.player()).toBe(VideoPlayer.VideoJs);
+        expect(storage.set).toHaveBeenCalledWith(
+            STORE_KEY.Settings,
+            expect.objectContaining({ player: VideoPlayer.VideoJs })
+        );
+    });
+
+    it('keeps the saved player when Embedded MPV is supported', async () => {
+        getEmbeddedMpvSupport.mockResolvedValue(SUPPORTED);
+
+        const store = await start();
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+        );
+
+        expect(store.player()).toBe(VideoPlayer.EmbeddedMpv);
+        expect(storage.set).not.toHaveBeenCalled();
+        expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(1);
+    });
+
+    it('follows an inconclusive answer and falls back once mpv is finally missing', async () => {
+        getEmbeddedMpvSupport
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValue(MPV_MISSING);
+
+        const store = await start();
+        expect(store.player()).toBe(VideoPlayer.EmbeddedMpv);
+
+        // The login shell answered: mpv really is not installed.
+        await jest.advanceTimersByTimeAsync(EMBEDDED_MPV_SUPPORT_RECHECK_MS);
+
+        expect(store.player()).toBe(VideoPlayer.VideoJs);
+        expect(persistedPlayers()).toEqual([VideoPlayer.VideoJs]);
+    });
+
+    it('follows an inconclusive answer and keeps the player once mpv is found', async () => {
+        getEmbeddedMpvSupport
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValue(SUPPORTED);
+
+        const store = await start();
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+        );
+
+        expect(store.player()).toBe(VideoPlayer.EmbeddedMpv);
+        expect(storage.set).not.toHaveBeenCalled();
+        // The final answer ended the checks.
+        expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+    });
+
+    it('leaves a player the user picked meanwhile alone and stops checking', async () => {
+        getEmbeddedMpvSupport
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValue(MPV_MISSING);
+        const store = await start();
+
+        await store.updateSettings({ player: VideoPlayer.MPV });
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+        );
+
+        expect(store.player()).toBe(VideoPlayer.MPV);
+        expect(persistedPlayers()).toEqual([VideoPlayer.MPV]);
+        expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+    });
+
+    it('leaves a player picked while the first answer was pending alone', async () => {
+        let answer: (support: EmbeddedMpvSupport) => void = () => undefined;
+        getEmbeddedMpvSupport.mockReturnValue(
+            new Promise<EmbeddedMpvSupport>((resolve) => {
+                answer = resolve;
+            })
+        );
+        const store = await start();
+
+        await store.updateSettings({ player: VideoPlayer.VLC });
+        answer(MPV_MISSING);
+        await jest.advanceTimersByTimeAsync(0);
+
+        expect(store.player()).toBe(VideoPlayer.VLC);
+        expect(persistedPlayers()).toEqual([VideoPlayer.VLC]);
+    });
+
+    it('falls back to the default player when the support check fails', async () => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation();
+        getEmbeddedMpvSupport.mockRejectedValue(new Error('bridge failed'));
+
+        try {
+            const store = await start();
+
+            expect(store.player()).toBe(VideoPlayer.VideoJs);
+            expect(persistedPlayers()).toEqual([VideoPlayer.VideoJs]);
+        } finally {
+            warn.mockRestore();
+        }
+    });
+});
diff --git a/libs/services/src/lib/settings-store.service.ts b/libs/services/src/lib/settings-store.service.ts
index a517f1fcb..e6ae6aa9f 100644
--- a/libs/services/src/lib/settings-store.service.ts
+++ b/libs/services/src/lib/settings-store.service.ts
@@ -41,6 +41,7 @@ import {
     DEFAULT_SETTINGS,
     scheduleEmbeddedMpvPrepare,
     SettingsStorageState,
+    verifySavedEmbeddedMpvPlayer,
 } from './settings-store.defaults';
 
 export type { SettingsStorageFailure } from './settings-store.defaults';
@@ -324,39 +325,14 @@ export const SettingsStore = signalStore(
             },
 
             async sanitizeEmbeddedMpvSelection() {
-                if (store.player() !== VideoPlayer.EmbeddedMpv) {
-                    return;
-                }
-
-                if (
-                    typeof window === 'undefined' ||
-                    !window.electron?.getEmbeddedMpvSupport
-                ) {
-                    await this.updateSettings({
-                        player: DEFAULT_SETTINGS.player,
-                    });
-                    return;
-                }
-
-                try {
-                    const support =
-                        await window.electron.getEmbeddedMpvSupport();
-                    if (!support.supported) {
-                        await this.updateSettings({
+                const isSaved = () =>
+                    store.player() === VideoPlayer.EmbeddedMpv;
+                if (isSaved()) {
+                    await verifySavedEmbeddedMpvPlayer(isSaved, () =>
+                        this.updateSettings({
                             player: DEFAULT_SETTINGS.player,
-                        });
-                        return;
-                    }
-
-                    scheduleEmbeddedMpvPrepare();
-                } catch (error) {
-                    console.warn(
-                        'Failed to verify embedded MPV support; reverting to the default inline player.',
-                        error
+                        })
                     );
-                    await this.updateSettings({
-                        player: DEFAULT_SETTINGS.player,
-                    });
                 }
             },
         };
diff --git a/libs/shared/interfaces/src/index.ts b/libs/shared/interfaces/src/index.ts
index 6e8ee1abf..95a3a08f2 100644
--- a/libs/shared/interfaces/src/index.ts
+++ b/libs/shared/interfaces/src/index.ts
@@ -6,6 +6,7 @@ export * from './lib/content-metadata.interface';
 export * from './lib/dev-logger.util';
 export * from './lib/download-metadata.interface';
 export * from './lib/embedded-mpv-session.interface';
+export * from './lib/embedded-mpv-support-watch.util';
 export * from './lib/subtitle-style.util';
 export * from './lib/zoom-level.util';
 export * from './lib/electron-api.interface';
diff --git a/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts b/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts
index f452966c5..0f90c67c0 100644
--- a/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts
@@ -39,6 +39,13 @@ export interface EmbeddedMpvSupport {
     supported: boolean;
     platform: string;
     reason?: string;
+    /**
+     * True when `supported: false` is not a verdict on this machine yet: the
+     * Linux native-view `mpv` executable was looked up before the login shell
+     * PATH arrived, and is looked up again once the shell answers. Never
+     * persist a decision made from such an answer; ask again later.
+     */
+    inconclusive?: boolean;
     capabilities?: EmbeddedMpvCapabilities;
     /**
      * Rendering engine the main process will use for new sessions.
diff --git a/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.spec.ts b/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.spec.ts
new file mode 100644
index 000000000..8cccf13d7
--- /dev/null
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.spec.ts
@@ -0,0 +1,169 @@
+import type { EmbeddedMpvSupport } from './embedded-mpv-session.interface';
+import {
+    EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS,
+    EMBEDDED_MPV_SUPPORT_RECHECK_MS,
+    watchEmbeddedMpvSupport,
+} from './embedded-mpv-support-watch.util';
+
+const SUPPORTED: EmbeddedMpvSupport = { supported: true, platform: 'linux' };
+const UNSUPPORTED: EmbeddedMpvSupport = {
+    supported: false,
+    platform: 'linux',
+    reason: 'no mpv',
+};
+const INCONCLUSIVE: EmbeddedMpvSupport = { ...UNSUPPORTED, inconclusive: true };
+
+describe('watchEmbeddedMpvSupport', () => {
+    let onAnswer: jest.Mock;
+    let onError: jest.Mock;
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        onAnswer = jest.fn();
+        onError = jest.fn();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it.each([SUPPORTED, UNSUPPORTED])(
+        'delivers a final answer once and asks no more: %j',
+        async (answer) => {
+            const getSupport = jest.fn().mockResolvedValue(answer);
+
+            watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+            await jest.advanceTimersByTimeAsync(
+                EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+            );
+
+            expect(getSupport).toHaveBeenCalledTimes(1);
+            expect(onAnswer.mock.calls).toEqual([[answer]]);
+            expect(onError).not.toHaveBeenCalled();
+        }
+    );
+
+    it('asks again while the answer is inconclusive, until a final one', async () => {
+        const getSupport = jest
+            .fn()
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValueOnce(INCONCLUSIVE)
+            .mockResolvedValue(SUPPORTED);
+
+        watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+        await jest.advanceTimersByTimeAsync(0);
+        expect(getSupport).toHaveBeenCalledTimes(1);
+        expect(onAnswer).toHaveBeenLastCalledWith(INCONCLUSIVE);
+
+        await jest.advanceTimersByTimeAsync(EMBEDDED_MPV_SUPPORT_RECHECK_MS);
+        expect(getSupport).toHaveBeenCalledTimes(2);
+        expect(onAnswer).toHaveBeenLastCalledWith(INCONCLUSIVE);
+
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MS * 2
+        );
+        expect(getSupport).toHaveBeenCalledTimes(3);
+        expect(onAnswer).toHaveBeenLastCalledWith(SUPPORTED);
+
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS * 3
+        );
+        expect(getSupport).toHaveBeenCalledTimes(3);
+    });
+
+    it('backs off to the slowest rate while the answer stays inconclusive', async () => {
+        const getSupport = jest.fn().mockResolvedValue(INCONCLUSIVE);
+
+        watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+        // Rechecks after 3, 6, 12 and 24 s, then every 30 s.
+        await jest.advanceTimersByTimeAsync(3000 + 6000 + 12_000 + 24_000);
+        expect(getSupport).toHaveBeenCalledTimes(5);
+
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS - 1
+        );
+        expect(getSupport).toHaveBeenCalledTimes(5);
+        await jest.advanceTimersByTimeAsync(1);
+        expect(getSupport).toHaveBeenCalledTimes(6);
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS
+        );
+        expect(getSupport).toHaveBeenCalledTimes(7);
+    });
+
+    it('asks no more when the answer handler stops the watch', async () => {
+        const getSupport = jest.fn().mockResolvedValue(INCONCLUSIVE);
+        const stop: () => void = watchEmbeddedMpvSupport(
+            getSupport,
+            () => stop(),
+            onError
+        );
+
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS * 3
+        );
+
+        expect(getSupport).toHaveBeenCalledTimes(1);
+    });
+
+    it('asks no more once stopped', async () => {
+        const getSupport = jest.fn().mockResolvedValue(INCONCLUSIVE);
+
+        const stop = watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+        await jest.advanceTimersByTimeAsync(0);
+        stop();
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS * 3
+        );
+
+        expect(getSupport).toHaveBeenCalledTimes(1);
+        expect(onAnswer).toHaveBeenCalledTimes(1);
+    });
+
+    it('drops an answer that arrives after it was stopped', async () => {
+        let answer: (support: EmbeddedMpvSupport) => void = () => undefined;
+        const getSupport = jest.fn(
+            () =>
+                new Promise<EmbeddedMpvSupport>((resolve) => {
+                    answer = resolve;
+                })
+        );
+
+        const stop = watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+        stop();
+        answer(INCONCLUSIVE);
+        await jest.advanceTimersByTimeAsync(
+            EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS * 3
+        );
+
+        expect(onAnswer).not.toHaveBeenCalled();
+        expect(getSupport).toHaveBeenCalledTimes(1);
+    });
+
+    it.each([
+        ['rejects', () => Promise.reject(new Error('bridge failed'))],
+        [
+            'throws',
+            () => {
+                throw new Error('bridge failed');
+            },
+        ],
+    ])(
+        'ends the watch with the error when the request %s',
+        async (_how, request) => {
+            const getSupport = jest.fn(request);
+
+            watchEmbeddedMpvSupport(getSupport, onAnswer, onError);
+            await jest.advanceTimersByTimeAsync(
+                EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+            );
+
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(onError.mock.calls[0][0]).toEqual(
+                new Error('bridge failed')
+            );
+            expect(onAnswer).not.toHaveBeenCalled();
+            expect(getSupport).toHaveBeenCalledTimes(1);
+        }
+    );
+});
diff --git a/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.ts b/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.ts
new file mode 100644
index 000000000..67317411f
--- /dev/null
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-support-watch.util.ts
@@ -0,0 +1,64 @@
+import type { EmbeddedMpvSupport } from './embedded-mpv-session.interface';
+
+/**
+ * How soon an inconclusive support answer is asked for again. The main
+ * process answers from its cached probe meanwhile, so a recheck costs one
+ * IPC round trip and spawns nothing.
+ */
+export const EMBEDDED_MPV_SUPPORT_RECHECK_MS = 3000;
+
+/**
+ * Each further recheck waits twice as long, up to this: a login shell that
+ * never answers must not keep the app polling at the first rate for good.
+ */
+export const EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS = 30_000;
+
+/**
+ * Asks for embedded MPV support and hands every answer to `onAnswer`. An
+ * `inconclusive` answer is not final, so it is asked for again until a final
+ * one arrives or the returned function is called. A failed request ends the
+ * watch through `onError`, as a final answer would.
+ *
+ * For whatever holds on to one answer: the surfaces that stay mounted on it
+ * (the player, the settings page) and the settings store, which has to reach
+ * a decision. A surface that asks on demand simply asks again the next time.
+ */
+export function watchEmbeddedMpvSupport(
+    getSupport: () => Promise<EmbeddedMpvSupport>,
+    onAnswer: (support: EmbeddedMpvSupport) => void,
+    onError: (error: unknown) => void
+): () => void {
+    let stopped = false;
+    let recheck: ReturnType<typeof setTimeout> | undefined;
+    let recheckMs = EMBEDDED_MPV_SUPPORT_RECHECK_MS;
+
+    const ask = async (): Promise<void> => {
+        let support: EmbeddedMpvSupport;
+        try {
+            support = await getSupport();
+        } catch (error) {
+            if (!stopped) {
+                onError(error);
+            }
+            return;
+        }
+        if (stopped) {
+            return;
+        }
+        onAnswer(support);
+        // `onAnswer` may have stopped the watch.
+        if (support.inconclusive && !stopped) {
+            recheck = setTimeout(() => void ask(), recheckMs);
+            recheckMs = Math.min(
+                recheckMs * 2,
+                EMBEDDED_MPV_SUPPORT_RECHECK_MAX_MS
+            );
+        }
+    };
+    void ask();
+
+    return () => {
+        stopped = true;
+        clearTimeout(recheck);
+    };
+}
diff --git a/libs/ui/components/src/lib/confirm-dialog/confirm-dialog.component.ts b/libs/ui/components/src/lib/confirm-dialog/confirm-dialog.component.ts
index 937c06e54..375f073d2 100644
--- a/libs/ui/components/src/lib/confirm-dialog/confirm-dialog.component.ts
+++ b/libs/ui/components/src/lib/confirm-dialog/confirm-dialog.component.ts
@@ -29,8 +29,7 @@ export interface ConfirmDialogData {
 
 @Component({
     imports: [MatButtonModule, MatDialogModule, TranslateModule],
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     template: `
         <h2 mat-dialog-title>
             {{ dialogData.title }}
diff --git a/libs/ui/components/src/lib/content-hero/content-hero.component.ts b/libs/ui/components/src/lib/content-hero/content-hero.component.ts
index 5917e374e..6413a66b5 100644
--- a/libs/ui/components/src/lib/content-hero/content-hero.component.ts
+++ b/libs/ui/components/src/lib/content-hero/content-hero.component.ts
@@ -34,8 +34,7 @@ export type ContentHeroLayout = 'stage' | 'compact';
         TranslateModule,
     ],
     templateUrl: './content-hero.component.html',
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styleUrls: ['./content-hero.component.scss'],
 })
 export class ContentHeroComponent {
diff --git a/libs/ui/components/src/lib/expandable-text/expandable-text.component.ts b/libs/ui/components/src/lib/expandable-text/expandable-text.component.ts
index a35f18b95..1b50a3fcf 100644
--- a/libs/ui/components/src/lib/expandable-text/expandable-text.component.ts
+++ b/libs/ui/components/src/lib/expandable-text/expandable-text.component.ts
@@ -47,8 +47,7 @@ import { TranslateModule } from '@ngx-translate/core';
             </button>
         }
     `,
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styles: [
         `
             :host {
diff --git a/libs/ui/components/src/lib/portal-detail-shell/content-about.component.ts b/libs/ui/components/src/lib/portal-detail-shell/content-about.component.ts
index 1d55c39f6..71328b8bd 100644
--- a/libs/ui/components/src/lib/portal-detail-shell/content-about.component.ts
+++ b/libs/ui/components/src/lib/portal-detail-shell/content-about.component.ts
@@ -56,8 +56,7 @@ import { TranslateModule } from '@ngx-translate/core';
             </div>
         </section>
     `,
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styleUrls: ['./content-about.component.scss'],
 })
 export class ContentAboutComponent {
diff --git a/libs/ui/components/src/lib/portal-detail-shell/portal-detail-shell.component.ts b/libs/ui/components/src/lib/portal-detail-shell/portal-detail-shell.component.ts
index de069c8e7..4b368c609 100644
--- a/libs/ui/components/src/lib/portal-detail-shell/portal-detail-shell.component.ts
+++ b/libs/ui/components/src/lib/portal-detail-shell/portal-detail-shell.component.ts
@@ -12,8 +12,7 @@ import {
     output,
     ChangeDetectionStrategy,
 } from '@angular/core';
-import { WorkspaceBackNavigationService } from '@iptvnator/portal/shared/data-access';
-import { WorkspaceBackTarget } from '@iptvnator/portal/shared/util';
+import { registerWorkspaceBack } from '@iptvnator/portal/shared/data-access';
 import { ContentHeroComponent } from '../content-hero/content-hero.component';
 import { ContentAboutComponent } from './content-about.component';
 import {
@@ -44,8 +43,7 @@ import {
     imports: [ContentHeroComponent, ContentAboutComponent, NgTemplateOutlet],
     templateUrl: './portal-detail-shell.component.html',
     styleUrls: ['./portal-detail-shell.component.scss'],
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     host: {
         tabindex: '0',
         role: 'region',
@@ -61,7 +59,6 @@ import {
 export class PortalDetailShellComponent {
     private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);
     private readonly injector = inject(Injector);
-    private readonly backNavigation = inject(WorkspaceBackNavigationService);
 
     readonly title = input<string>();
     /** "Movie · playlist name" eyebrow above the hero title. */
@@ -96,13 +93,13 @@ export class PortalDetailShellComponent {
 
     readonly isWatch = computed(() => this.playbackActive());
 
-    private readonly backTarget: WorkspaceBackTarget = {
-        label: computed(() => this.backLabel() || null),
-        escapeShortcut: computed(() => !this.isWatch()),
-        run: () => this.backClicked.emit(),
-    };
-
     constructor() {
+        registerWorkspaceBack({
+            available: this.backAvailable,
+            label: computed(() => this.backLabel() || null),
+            escapeShortcut: computed(() => !this.isWatch()),
+            run: () => this.backClicked.emit(),
+        });
         afterNextRender(() => {
             const element = this.host.nativeElement;
             const active = element.ownerDocument.activeElement;
@@ -115,10 +112,6 @@ export class PortalDetailShellComponent {
                 element.focus({ preventScroll: true });
             }
         });
-        effect((onCleanup) => {
-            if (!this.backAvailable()) return;
-            onCleanup(this.backNavigation.register(this.backTarget));
-        });
         let wasWatch = false;
         effect(() => {
             const watch = this.isWatch();
diff --git a/libs/ui/components/src/lib/progress-capsule/progress-capsule.component.ts b/libs/ui/components/src/lib/progress-capsule/progress-capsule.component.ts
index c1394d165..253703482 100644
--- a/libs/ui/components/src/lib/progress-capsule/progress-capsule.component.ts
+++ b/libs/ui/components/src/lib/progress-capsule/progress-capsule.component.ts
@@ -19,8 +19,7 @@ import {
             ></div>
         </div>
     `,
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styles: [
         `
             .progress-capsule {
diff --git a/libs/ui/components/src/lib/season-container/episode-info-dialog.component.ts b/libs/ui/components/src/lib/season-container/episode-info-dialog.component.ts
index 59c78ca4c..e08e4dbf4 100644
--- a/libs/ui/components/src/lib/season-container/episode-info-dialog.component.ts
+++ b/libs/ui/components/src/lib/season-container/episode-info-dialog.component.ts
@@ -105,8 +105,7 @@ export const EPISODE_INFO_PLAY = 'play' as const;
             </button>
         </div>
     `,
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styles: [
         `
             :host {
diff --git a/libs/ui/components/src/lib/season-container/episode-subline.util.ts b/libs/ui/components/src/lib/season-container/episode-subline.util.ts
new file mode 100644
index 000000000..2b73f8b50
--- /dev/null
+++ b/libs/ui/components/src/lib/season-container/episode-subline.util.ts
@@ -0,0 +1,37 @@
+import type { TranslateService } from '@ngx-translate/core';
+import {
+    formatDurationLabel,
+    formatRemainingLabel,
+    isPortalPlaybackWatched,
+} from '@iptvnator/portal/shared/util';
+import {
+    PlaybackPositionData,
+    XtreamSerieEpisodeInfo,
+} from '@iptvnator/shared/interfaces';
+import {
+    episodeRuntimeSeconds,
+    formatEpisodePositionText,
+} from './episode-progress.util';
+
+/**
+ * The line under an episode card's title, built from the episode's runtime
+ * and its saved playback position:
+ * "42 min · 18m left", "42 min · watched", "42 min" — or null.
+ */
+export function buildEpisodeSubline(
+    info: XtreamSerieEpisodeInfo | undefined,
+    position: PlaybackPositionData | undefined,
+    translate: Pick<TranslateService, 'instant'>
+): string | null {
+    const duration = formatDurationLabel(episodeRuntimeSeconds(info));
+    const remaining = formatRemainingLabel(position);
+    const parts = [
+        duration ? translate.instant(duration.key, duration.params) : null,
+        isPortalPlaybackWatched(position)
+            ? translate.instant('PORTALS.DETAIL.WATCHED')
+            : remaining
+              ? translate.instant(remaining.key, remaining.params)
+              : formatEpisodePositionText(position),
+    ].filter((part): part is string => !!part);
+    return parts.length ? parts.join(' · ') : null;
+}
diff --git a/libs/ui/components/src/lib/season-container/season-auto-select.state.ts b/libs/ui/components/src/lib/season-container/season-auto-select.state.ts
new file mode 100644
index 000000000..d7a4ce22e
--- /dev/null
+++ b/libs/ui/components/src/lib/season-container/season-auto-select.state.ts
@@ -0,0 +1,136 @@
+import {
+    type Signal,
+    type WritableSignal,
+    computed,
+    effect,
+    untracked,
+} from '@angular/core';
+import {
+    PlaybackPositionData,
+    XtreamSerieEpisode,
+} from '@iptvnator/shared/interfaces';
+import { resolveAutoSelectedSeason } from './season-auto-select.util';
+
+export interface SeasonAutoSelectSources {
+    /**
+     * The container's selection (see `SeasonContainerComponent.selectedSeason`).
+     * Auto-select writes to it; user tab clicks write to it too and stick
+     * until the auto-select key changes.
+     */
+    readonly selectedSeason: WritableSignal<string | undefined>;
+    readonly seasons: Signal<Record<string, XtreamSerieEpisode[]>>;
+    /** Season keys in display order. */
+    readonly sortedSeasonKeys: Signal<readonly string[]>;
+    /** Season key of the inline-playing episode, if it is in the loaded set. */
+    readonly playingSeasonKey: Signal<string | null>;
+    readonly playbackPositions: Signal<
+        ReadonlyMap<number, PlaybackPositionData>
+    >;
+    readonly positionOf: (
+        episode: XtreamSerieEpisode
+    ) => PlaybackPositionData | undefined;
+    /** Stalker lazy-VOD: some seasons' episode lists are not loaded yet. */
+    readonly hasUnloadedSeasons: Signal<boolean>;
+    readonly episodeCounts: Signal<Record<string, number>>;
+    readonly watchedCounts: Signal<Record<string, number>>;
+    readonly emitSeasonSelected: (seasonKey: string) => void;
+}
+
+export interface SeasonAutoSelectState {
+    /**
+     * Record that this session toggled watched state itself: the positions
+     * flip that follows is then not treated as an initial load.
+     */
+    markLocalWatchedMutation(): void;
+}
+
+/** Key of the loaded season that holds the episode with this content id. */
+export function findSeasonOfEpisode(
+    seasons: Record<string, XtreamSerieEpisode[]>,
+    episodeId: number
+): string | null {
+    for (const [key, episodes] of Object.entries(seasons)) {
+        if (episodes?.some((episode) => Number(episode.id) === episodeId)) {
+            return key;
+        }
+    }
+    return null;
+}
+
+/**
+ * Season auto-selection and `seasonSelected` emission of
+ * `SeasonContainerComponent`. The selection re-resolves when the season key
+ * set changes or when playback positions first arrive; ongoing position
+ * saves do not reset it — only the empty→loaded transition of the positions
+ * map does, and even that is ignored once this session toggled watched state
+ * itself.
+ *
+ * Registers two effects, so it must be called in an injection context (the
+ * container's constructor).
+ */
+export function createSeasonAutoSelectState(
+    sources: SeasonAutoSelectSources
+): SeasonAutoSelectState {
+    const autoSelectKey = computed(
+        () =>
+            `${sources.sortedSeasonKeys().join('|')}::${
+                sources.playbackPositions().size > 0 ? '1' : '0'
+            }`
+    );
+    let lastAutoSelectKey: string | null = null;
+    let lastAutoSelectSeasonSet: string | null = null;
+    /**
+     * True once this session toggled watched state itself. From then on an
+     * empty↔loaded flip of the positions map is the echo of that action, not
+     * an async initial load — re-resolving on it would yank the user off the
+     * season they just marked (e.g. all-watched season 1 → jump to season 2).
+     */
+    let hasLocalWatchedMutation = false;
+    let lastEmittedSeason: string | undefined;
+
+    /** Auto-select rules live in season-auto-select.util.ts. */
+    const resolveAutoSeason = (): string | undefined =>
+        resolveAutoSelectedSeason({
+            keys: sources.sortedSeasonKeys(),
+            playingSeasonKey: sources.playingSeasonKey(),
+            seasons: sources.seasons(),
+            positionOf: sources.positionOf,
+            hasUnloadedSeasons: sources.hasUnloadedSeasons(),
+            episodeCounts: sources.episodeCounts(),
+            watchedCounts: sources.watchedCounts(),
+        });
+
+    effect(() => {
+        const key = autoSelectKey();
+        if (key === lastAutoSelectKey) {
+            return;
+        }
+        const seasonSet = untracked(() => sources.sortedSeasonKeys().join('|'));
+        const seasonSetUnchanged = seasonSet === lastAutoSelectSeasonSet;
+        lastAutoSelectKey = key;
+        lastAutoSelectSeasonSet = seasonSet;
+        // A positions-emptiness flip after a local watched toggle keeps
+        // the current selection; only the async initial positions load
+        // (or a season-set change) re-resolves the season.
+        if (seasonSetUnchanged && hasLocalWatchedMutation) {
+            return;
+        }
+        sources.selectedSeason.set(untracked(() => resolveAutoSeason()));
+    });
+
+    // Fire the lazy-load/enrichment hooks for auto-selected seasons too —
+    // with tabs there is no initial "pick a season" click anymore.
+    effect(() => {
+        const selected = sources.selectedSeason();
+        if (selected && selected !== lastEmittedSeason) {
+            lastEmittedSeason = selected;
+            sources.emitSeasonSelected(selected);
+        }
+    });
+
+    return {
+        markLocalWatchedMutation: () => {
+            hasLocalWatchedMutation = true;
+        },
+    };
+}
diff --git a/libs/ui/components/src/lib/season-container/season-container.component.ts b/libs/ui/components/src/lib/season-container/season-container.component.ts
index 26b265c13..c857f5530 100644
--- a/libs/ui/components/src/lib/season-container/season-container.component.ts
+++ b/libs/ui/components/src/lib/season-container/season-container.component.ts
@@ -4,12 +4,10 @@ import {
     ElementRef,
     OnInit,
     computed,
-    effect,
     inject,
     input,
     output,
     signal,
-    untracked,
 } from '@angular/core';
 import { MatButtonModule } from '@angular/material/button';
 import { MatButtonToggleModule } from '@angular/material/button-toggle';
@@ -21,8 +19,6 @@ import { TranslateModule, TranslateService } from '@ngx-translate/core';
 import { type SeasonEpisodeDownloadAdapter } from '@iptvnator/portal/shared/data-access';
 import {
     createLogger,
-    formatDurationLabel,
-    formatRemainingLabel,
     getPortalPlaybackProgressPercent,
     isPortalPlaybackInProgress,
     isPortalPlaybackWatched,
@@ -38,11 +34,13 @@ import {
     EpisodeInfoDialogComponent,
     buildEpisodeInfoDialogData,
 } from './episode-info-dialog.component';
+import { formatEpisodePositionText } from './episode-progress.util';
+import { buildEpisodeSubline } from './episode-subline.util';
 import {
-    formatEpisodePositionText,
-    episodeRuntimeSeconds,
-} from './episode-progress.util';
-import { resolveAutoSelectedSeason } from './season-auto-select.util';
+    type SeasonAutoSelectState,
+    createSeasonAutoSelectState,
+    findSeasonOfEpisode,
+} from './season-auto-select.state';
 import { SeasonDownloadPresenter } from './season-download-presenter';
 import { SeasonTabsComponent } from './season-tabs.component';
 import { SeasonWatchPresenter } from './season-watch-presenter';
@@ -80,7 +78,8 @@ export class SeasonContainerComponent implements OnInit {
     private readonly translate = inject(TranslateService);
     private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);
     private readonly logger = createLogger('SeasonContainer');
-    private lastEmittedSeason: string | undefined;
+    /** Auto-select + `seasonSelected` emission; wired in the constructor. */
+    private readonly autoSelect: SeasonAutoSelectState;
     readonly downloadPresenter = inject(SeasonDownloadPresenter);
     readonly watchPresenter = inject(SeasonWatchPresenter);
 
@@ -148,9 +147,12 @@ export class SeasonContainerComponent implements OnInit {
     });
 
     /** Season key of the inline-playing episode, if it is in the loaded set. */
-    readonly playingSeasonKey = computed(() =>
-        this.findSeasonOfEpisode(this.playingEpisodeId())
-    );
+    readonly playingSeasonKey = computed(() => {
+        const episodeId = this.playingEpisodeId();
+        return episodeId === null
+            ? null
+            : findSeasonOfEpisode(this.seasons(), episodeId);
+    });
 
     /**
      * Selected season. Auto-resolves when the season key set changes or when
@@ -171,22 +173,6 @@ export class SeasonContainerComponent implements OnInit {
         return selected ? (this.seasons()[selected] ?? []) : [];
     });
 
-    private readonly autoSelectKey = computed(
-        () =>
-            `${this.sortedSeasonKeys().join('|')}::${
-                this.playbackPositions().size > 0 ? '1' : '0'
-            }`
-    );
-    private lastAutoSelectKey: string | null = null;
-    private lastAutoSelectSeasonSet: string | null = null;
-    /**
-     * True once this session toggled watched state itself. From then on an
-     * empty↔loaded flip of the positions map is the echo of that action, not
-     * an async initial load — re-resolving on it would yank the user off the
-     * season they just marked (e.g. all-watched season 1 → jump to season 2).
-     */
-    private hasLocalWatchedMutation = false;
-
     /**
      * Show thumbnails in the list view only when episodes have genuinely
      * distinct stills (TMDB or per-episode provider art). When every episode
@@ -254,44 +240,29 @@ export class SeasonContainerComponent implements OnInit {
             openingEpisodeId: this.openingEpisodeId,
             isEpisodeWatched: (episode) => this.isEpisodeWatched(episode),
             emitSeasonToggle: (request) => {
-                this.hasLocalWatchedMutation = true;
+                this.autoSelect.markLocalWatchedMutation();
                 this.seasonPlaybackToggleRequested.emit(request);
             },
             emitSeriesToggle: (request) => {
-                this.hasLocalWatchedMutation = true;
+                this.autoSelect.markLocalWatchedMutation();
                 this.seriesPlaybackToggleRequested.emit(request);
             },
         });
 
-        effect(() => {
-            const key = this.autoSelectKey();
-            if (key === this.lastAutoSelectKey) {
-                return;
-            }
-            const seasonSet = untracked(() =>
-                this.sortedSeasonKeys().join('|')
-            );
-            const seasonSetUnchanged =
-                seasonSet === this.lastAutoSelectSeasonSet;
-            this.lastAutoSelectKey = key;
-            this.lastAutoSelectSeasonSet = seasonSet;
-            // A positions-emptiness flip after a local watched toggle keeps
-            // the current selection; only the async initial positions load
-            // (or a season-set change) re-resolves the season.
-            if (seasonSetUnchanged && this.hasLocalWatchedMutation) {
-                return;
-            }
-            this.selectedSeason.set(untracked(() => this.resolveAutoSeason()));
-        });
-
-        // Fire the lazy-load/enrichment hooks for auto-selected seasons too —
-        // with tabs there is no initial "pick a season" click anymore.
-        effect(() => {
-            const selected = this.selectedSeason();
-            if (selected && selected !== this.lastEmittedSeason) {
-                this.lastEmittedSeason = selected;
-                this.seasonSelected.emit(selected);
-            }
+        // Auto-select rules and the effects driving them live in
+        // season-auto-select.state.ts / season-auto-select.util.ts.
+        this.autoSelect = createSeasonAutoSelectState({
+            selectedSeason: this.selectedSeason,
+            seasons: this.seasons,
+            sortedSeasonKeys: this.sortedSeasonKeys,
+            playingSeasonKey: this.playingSeasonKey,
+            playbackPositions: this.playbackPositions,
+            positionOf: (episode) => this.getEpisodePosition(episode),
+            hasUnloadedSeasons: this.hasUnloadedSeasons,
+            episodeCounts: this.episodeCounts,
+            watchedCounts: this.watchedCounts,
+            emitSeasonSelected: (seasonKey) =>
+                this.seasonSelected.emit(seasonKey),
         });
     }
 
@@ -376,7 +347,7 @@ export class SeasonContainerComponent implements OnInit {
             this.logger.warn('Cannot toggle watched: no playlist ID');
             return;
         }
-        this.hasLocalWatchedMutation = true;
+        this.autoSelect.markLocalWatchedMutation();
 
         const contentXtreamId = this.getEpisodeContentId(episode);
         const currentPosition = this.getEpisodePosition(episode);
@@ -434,21 +405,11 @@ export class SeasonContainerComponent implements OnInit {
 
     /** "42 min · 18m left", "42 min · watched", "42 min" — or null. */
     getEpisodeSubline(episode: XtreamSerieEpisode): string | null {
-        const info = this.getEpisodeInfo(episode);
-        const duration = formatDurationLabel(episodeRuntimeSeconds(info));
-        const position = this.playbackPositions().get(Number(episode.id));
-        const remaining = formatRemainingLabel(position);
-        const parts = [
-            duration
-                ? this.translate.instant(duration.key, duration.params)
-                : null,
-            this.isEpisodeWatched(episode)
-                ? this.translate.instant('PORTALS.DETAIL.WATCHED')
-                : remaining
-                  ? this.translate.instant(remaining.key, remaining.params)
-                  : this.getEpisodePositionText(episode),
-        ].filter((part): part is string => !!part);
-        return parts.length ? parts.join(' · ') : null;
+        return buildEpisodeSubline(
+            this.getEpisodeInfo(episode),
+            this.getEpisodePosition(episode),
+            this.translate
+        );
     }
 
     getEpisodePositionText(episode: XtreamSerieEpisode): string | null {
@@ -464,33 +425,4 @@ export class SeasonContainerComponent implements OnInit {
     ): PlaybackPositionData | undefined {
         return this.playbackPositions().get(this.getEpisodeContentId(episode));
     }
-
-    private findSeasonOfEpisode(episodeId: number | null): string | null {
-        if (episodeId === null) {
-            return null;
-        }
-        for (const [key, episodes] of Object.entries(this.seasons())) {
-            if (
-                episodes?.some(
-                    (episode) => this.getEpisodeContentId(episode) === episodeId
-                )
-            ) {
-                return key;
-            }
-        }
-        return null;
-    }
-
-    /** Auto-select rules live in season-auto-select.util.ts. */
-    private resolveAutoSeason(): string | undefined {
-        return resolveAutoSelectedSeason({
-            keys: this.sortedSeasonKeys(),
-            playingSeasonKey: this.playingSeasonKey(),
-            seasons: this.seasons(),
-            positionOf: (episode) => this.getEpisodePosition(episode),
-            hasUnloadedSeasons: this.hasUnloadedSeasons(),
-            episodeCounts: this.episodeCounts(),
-            watchedCounts: this.watchedCounts(),
-        });
-    }
 }
diff --git a/libs/ui/components/src/lib/watched-badge/watched-badge.component.ts b/libs/ui/components/src/lib/watched-badge/watched-badge.component.ts
index cba3fe79a..582e7dcb5 100644
--- a/libs/ui/components/src/lib/watched-badge/watched-badge.component.ts
+++ b/libs/ui/components/src/lib/watched-badge/watched-badge.component.ts
@@ -12,8 +12,7 @@ import { MatIcon } from '@angular/material/icon';
             </div>
         }
     `,
-    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection -- Preserve pre-Angular 22 eager checking during the framework upgrade.
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styles: [
         `
             .watched-badge {
diff --git a/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.spec.ts b/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.spec.ts
index ce7dd3c79..bd8c5ec1f 100644
--- a/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.spec.ts
+++ b/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.spec.ts
@@ -1,4 +1,4 @@
-import { signal } from '@angular/core';
+import { ChangeDetectorRef, signal } from '@angular/core';
 import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 import { MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
 import { By } from '@angular/platform-browser';
@@ -72,8 +72,12 @@ describe('EpgItemDescriptionComponent', () => {
     });
 
     it('offers archive URL copying only with explicit capability and explains credentials', () => {
+        // The component is OnPush and dialog data is fixed once the dialog
+        // opens, so the test marks the component's own view after mutating it.
+        const componentView =
+            fixture.debugElement.injector.get(ChangeDetectorRef);
         Object.assign(component.dialogData, { archiveUrlAvailable: true });
-        fixture.changeDetectorRef.markForCheck();
+        componentView.markForCheck();
         fixture.detectChanges();
         expect(
             fixture.nativeElement.querySelector(
@@ -84,7 +88,7 @@ describe('EpgItemDescriptionComponent', () => {
             'EPG.PROGRAM_DIALOG.ARCHIVE_URL_NOTICE'
         );
         Object.assign(component.dialogData, { archiveUrlAvailable: false });
-        fixture.changeDetectorRef.markForCheck();
+        componentView.markForCheck();
         fixture.detectChanges();
         expect(
             fixture.nativeElement.querySelector(
diff --git a/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.ts b/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.ts
index de527bda8..98ad0ff77 100644
--- a/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.ts
+++ b/libs/ui/epg/src/lib/epg-item-description/epg-item-description.component.ts
@@ -38,7 +38,7 @@ export type EpgItemDialogData = EpgProgram & {
     selector: 'app-epg-item-description',
     templateUrl: './epg-item-description.component.html',
     styleUrls: ['./epg-item-description.component.scss'],
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     imports: [DatePipe, MatDialogModule, MatIcon, TranslatePipe],
 })
 export class EpgItemDescriptionComponent {
diff --git a/libs/ui/epg/src/lib/epg-progress-panel/epg-progress-panel.component.ts b/libs/ui/epg/src/lib/epg-progress-panel/epg-progress-panel.component.ts
index d0e47b8e9..a1011039b 100644
--- a/libs/ui/epg/src/lib/epg-progress-panel/epg-progress-panel.component.ts
+++ b/libs/ui/epg/src/lib/epg-progress-panel/epg-progress-panel.component.ts
@@ -32,7 +32,7 @@ interface EpgTrustConfirmDialogData {
 @Component({
     selector: 'app-epg-trust-confirm-dialog',
     imports: [MatButtonModule, MatDialogModule, TranslatePipe],
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     template: `
         <h2 mat-dialog-title>{{ data.title }}</h2>
         <mat-dialog-content class="mat-typography">
@@ -64,7 +64,7 @@ class EpgTrustConfirmDialogComponent {
         TranslatePipe,
     ],
     templateUrl: './epg-progress-panel.component.html',
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styleUrl: './epg-progress-panel.component.scss',
 })
 export class EpgProgressPanelComponent {
diff --git a/libs/ui/epg/src/lib/epg-source-status/epg-source-status.component.ts b/libs/ui/epg/src/lib/epg-source-status/epg-source-status.component.ts
index e5fb3777d..12d5fc93d 100644
--- a/libs/ui/epg/src/lib/epg-source-status/epg-source-status.component.ts
+++ b/libs/ui/epg/src/lib/epg-source-status/epg-source-status.component.ts
@@ -30,7 +30,7 @@ type BadgeStatus =
         TranslatePipe,
     ],
     templateUrl: './epg-source-status.component.html',
-    changeDetection: ChangeDetectionStrategy.Eager,
+    changeDetection: ChangeDetectionStrategy.OnPush,
     styleUrl: './epg-source-status.component.scss',
 })
 export class EpgSourceStatusComponent implements OnInit {
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.lifecycle.spec.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.lifecycle.spec.ts
index 2a3ee9e6a..c9cb22bf6 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.lifecycle.spec.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.lifecycle.spec.ts
@@ -1,5 +1,6 @@
 import { TestBed } from '@angular/core/testing';
 import {
+    EMBEDDED_MPV_SUPPORT_RECHECK_MS,
     EmbeddedMpvEngine,
     EmbeddedMpvSession,
     ResolvedPortalPlayback,
@@ -106,6 +107,58 @@ describe('EmbeddedMpvSessionController (lifecycle & support edges)', () => {
         });
     });
 
+    describe('an inconclusive support answer', () => {
+        // A slow login shell: mpv was looked up before its PATH arrived.
+        const inconclusive = {
+            supported: false,
+            platform: 'linux',
+            reason: 'mpv executable missing',
+            inconclusive: true,
+        };
+
+        it('is asked for again, so a mounted player recovers by itself', async () => {
+            const settled = createSupport('native');
+            electron.getEmbeddedMpvSupport
+                .mockResolvedValueOnce(inconclusive)
+                .mockResolvedValue(settled);
+            const controller = TestBed.inject(EmbeddedMpvSessionController);
+
+            await waitFor(
+                () => controller.support() !== null,
+                'the first support answer'
+            );
+            expect(controller.support()).toBe(inconclusive);
+
+            await jest.advanceTimersByTimeAsync(
+                EMBEDDED_MPV_SUPPORT_RECHECK_MS
+            );
+            expect(controller.support()).toBe(settled);
+            expect(electron.getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+
+            // A final answer is kept.
+            await jest.advanceTimersByTimeAsync(
+                EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+            );
+            expect(electron.getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+        });
+
+        it('is no longer asked for once the player is gone', async () => {
+            electron.getEmbeddedMpvSupport.mockResolvedValue(inconclusive);
+            const controller = TestBed.inject(EmbeddedMpvSessionController);
+            await waitFor(
+                () => controller.support() !== null,
+                'the first support answer'
+            );
+
+            TestBed.resetTestingModule();
+            await jest.advanceTimersByTimeAsync(
+                EMBEDDED_MPV_SUPPORT_RECHECK_MS * 3
+            );
+
+            expect(electron.getEmbeddedMpvSupport).toHaveBeenCalledTimes(1);
+        });
+    });
+
     it('preserves the constructor support probe after preparing a session', async () => {
         const probedSupport = createSupport('native');
         const preparedSupport = createSupport('frame-copy');
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.ts
index 61064b980..f7ea0c166 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-session-controller.ts
@@ -15,6 +15,7 @@ import {
     EmbeddedMpvSupport,
     RecordingStartMetadata,
     ResolvedPortalPlayback,
+    watchEmbeddedMpvSupport,
 } from '@iptvnator/shared/interfaces';
 import { EmbeddedMpvCommandRunner } from './embedded-mpv-command-runner';
 import { measureBounds } from './embedded-mpv-format.utils';
@@ -95,8 +96,9 @@ export class EmbeddedMpvSessionController {
                 this.session.set(session);
             });
 
+        let stopSupportWatch: (() => void) | undefined;
         if (typeof window.electron?.getEmbeddedMpvSupport === 'function') {
-            void this.loadSupport();
+            stopSupportWatch = this.watchSupport();
         } else {
             this.support.set({
                 supported: false,
@@ -114,6 +116,7 @@ export class EmbeddedMpvSessionController {
 
         this.destroyRef.onDestroy(() => {
             this.unsubscribeSessionUpdate?.();
+            stopSupportWatch?.();
             this.stalledTracker.cancel();
             if (this.boundsAnimationFrame !== null) {
                 cancelAnimationFrame(this.boundsAnimationFrame);
@@ -381,22 +384,31 @@ export class EmbeddedMpvSessionController {
         EmbeddedMpvSession['recording'] | null
     > => this.commands.stopRecording();
 
-    private async loadSupport(): Promise<void> {
-        try {
-            const electron = this.getElectronBridge();
-            if (!electron?.getEmbeddedMpvSupport) {
-                throw new Error(
-                    'Embedded MPV requires the Electron desktop build.'
-                );
-            }
-            this.support.set(await electron.getEmbeddedMpvSupport());
-        } catch (error) {
-            this.support.set({
-                supported: false,
-                platform: window.electron?.platform ?? 'unknown',
-                reason: error instanceof Error ? error.message : String(error),
-            });
-        }
+    /**
+     * Loads support and keeps asking while the answer is inconclusive: the
+     * session effect starts playback as soon as `support` turns supported,
+     * so a player mounted during that window recovers by itself.
+     */
+    private watchSupport(): () => void {
+        return watchEmbeddedMpvSupport(
+            () => {
+                const electron = this.getElectronBridge();
+                if (!electron?.getEmbeddedMpvSupport) {
+                    throw new Error(
+                        'Embedded MPV requires the Electron desktop build.'
+                    );
+                }
+                return electron.getEmbeddedMpvSupport();
+            },
+            (support) => this.support.set(support),
+            (error) =>
+                this.support.set({
+                    supported: false,
+                    platform: window.electron?.platform ?? 'unknown',
+                    reason:
+                        error instanceof Error ? error.message : String(error),
+                })
+        );
     }
 
     private getElectronBridge(): ElectronBridge | undefined {
diff --git a/libs/ui/playback/src/lib/vod-details/vod-details-navigation.util.ts b/libs/ui/playback/src/lib/vod-details/vod-details-navigation.util.ts
new file mode 100644
index 000000000..0e5ddea55
--- /dev/null
+++ b/libs/ui/playback/src/lib/vod-details/vod-details-navigation.util.ts
@@ -0,0 +1,43 @@
+import type { CrossPortalSimilarItem } from '@iptvnator/services';
+import type {
+    TmdbEnrichedCastMember,
+    VodDetailsItem,
+} from '@iptvnator/shared/interfaces';
+
+/**
+ * Pure helpers resolving where the VOD details page's extras rows (cast &
+ * crew, Similar rail) lead. The component owns the actual navigation.
+ */
+
+/**
+ * Router commands of the actor page for a cast/crew member, inside the
+ * item's own portal workspace. Null when the member has no TMDB person id
+ * (names parsed from provider text): there is no actor page to open.
+ */
+export function buildVodActorRoute(
+    item: VodDetailsItem,
+    member: TmdbEnrichedCastMember
+): (string | number)[] | null {
+    if (!member.tmdbPersonId) {
+        return null;
+    }
+    const basePath =
+        item.type === 'stalker' ? '/workspace/stalker' : '/workspace/xtreams';
+    return [basePath, item.playlistId, 'actor', member.tmdbPersonId];
+}
+
+/**
+ * The cross-portal match behind a Similar-rail card. Rail keys are built by
+ * `buildSimilarRailItems` (vod-details-presentation.ts) as
+ * `x<playlistId>-<xtreamId>`.
+ */
+export function findSimilarByRailKey(
+    items: readonly CrossPortalSimilarItem[],
+    railKey: string
+): CrossPortalSimilarItem | undefined {
+    return items.find(
+        (candidate) =>
+            `x${candidate.match.playlistId}-${candidate.match.xtreamId}` ===
+            railKey
+    );
+}
diff --git a/libs/ui/playback/src/lib/vod-details/vod-details.component.ts b/libs/ui/playback/src/lib/vod-details/vod-details.component.ts
index a2d6eb523..4d3b658e2 100644
--- a/libs/ui/playback/src/lib/vod-details/vod-details.component.ts
+++ b/libs/ui/playback/src/lib/vod-details/vod-details.component.ts
@@ -1,12 +1,9 @@
 import {
     Component,
     computed,
-    effect,
     inject,
     input,
     output,
-    signal,
-    untracked,
     ChangeDetectionStrategy,
 } from '@angular/core';
 import { TranslatePipe, TranslateService } from '@ngx-translate/core';
@@ -53,9 +50,14 @@ import {
 } from '@iptvnator/services';
 import { VOD_DETAILS_MENU_ACTION } from './vod-details-presentation';
 import { createVodDetailsHeroState } from './vod-details-hero.state';
+import {
+    buildVodActorRoute,
+    findSimilarByRailKey,
+} from './vod-details-navigation.util';
 import type { PlaybackFallbackRequest } from '@iptvnator/playback/util';
 import { PortalInlinePlayerComponent } from '../portal-inline-player/portal-inline-player.component';
-import { createVodDownloadState } from './vod-download-state.util';
+import { createVodLocalDownloadState } from './vod-download-state.util';
+import { createVodSimilarInPortals } from './vod-similar-in-portals.state';
 
 /**
  * Unified VOD details component for both Xtream and Stalker portals.
@@ -231,38 +233,12 @@ export class VodDetailsComponent {
      * TMDB recommendations found in the user's OTHER portals (batched DB
      * match, Electron only). Loaded async — the section appears when
      * resolved; staleness-guarded against item changes in flight.
+     * Filtered on read: a relock hides matches cached while unlocked.
      */
-    private readonly similarInPortalsMatched = signal<CrossPortalSimilarItem[]>(
-        []
+    readonly similarInPortals = createVodSimilarInPortals(
+        this.normalizedMeta,
+        this.crossPortalSimilar
     );
-    /** Filtered on read: a relock hides matches cached while unlocked. */
-    readonly similarInPortals = computed(() =>
-        this.crossPortalSimilar.visible(this.similarInPortalsMatched())
-    );
-
-    private readonly loadSimilarInPortals = effect(() => {
-        const meta = this.normalizedMeta();
-        const recommendations = meta.tmdbRecommendations;
-        untracked(() => {
-            this.similarInPortalsMatched.set([]);
-            if (
-                !recommendations?.length ||
-                !this.crossPortalSimilar.isAvailable
-            ) {
-                return;
-            }
-            void this.crossPortalSimilar
-                .matchRecommendations(recommendations, 'movie')
-                .then((items) => {
-                    if (
-                        this.normalizedMeta().tmdbRecommendations ===
-                        recommendations
-                    ) {
-                        this.similarInPortalsMatched.set(items);
-                    }
-                });
-        });
-    });
 
     openSimilarInPortals(item: CrossPortalSimilarItem): void {
         void this.router.navigate(this.crossPortalSimilar.buildLink(item));
@@ -276,19 +252,14 @@ export class VodDetailsComponent {
         () => (this.playbackPosition() ?? 0) > 0 && !this.isWatched()
     );
 
-    private readonly downloadState = createVodDownloadState(
-        this.downloadsService,
-        this.item
-    );
-    readonly isDownloaded = computed(
-        () => !this.providerOnly() && this.downloadState.isDownloaded()
-    );
-    readonly isDownloading = computed(
-        () => !this.providerOnly() && this.downloadState.isDownloading()
-    );
-    readonly isPausedDownload = computed(
-        () => !this.providerOnly() && this.downloadState.isPausedDownload()
-    );
+    private readonly localDownload = createVodLocalDownloadState({
+        downloadsService: this.downloadsService,
+        item: this.item,
+        providerOnly: this.providerOnly,
+    });
+    readonly isDownloaded = this.localDownload.isDownloaded;
+    readonly isDownloading = this.localDownload.isDownloading;
+    readonly isPausedDownload = this.localDownload.isPausedDownload;
 
     private readonly externalButton = createExternalPlaybackButtonState({
         session: this.externalPlayback,
@@ -360,11 +331,7 @@ export class VodDetailsComponent {
     readonly scrollToCast = scrollToCastCrewRow;
 
     openSimilarRailItem(item: SimilarRailItem): void {
-        const match = this.similarInPortals().find(
-            (candidate) =>
-                `x${candidate.match.playlistId}-${candidate.match.xtreamId}` ===
-                item.key
-        );
+        const match = findSimilarByRailKey(this.similarInPortals(), item.key);
         if (match) {
             this.openSimilarInPortals(match);
         }
@@ -450,20 +417,10 @@ export class VodDetailsComponent {
 
     /** Handle back navigation - emit event for parent to handle */
     openActor(member: TmdbEnrichedCastMember): void {
-        if (!member.tmdbPersonId) {
-            return;
+        const commands = buildVodActorRoute(this.item(), member);
+        if (commands) {
+            void this.router.navigate(commands);
         }
-        const item = this.item();
-        const basePath =
-            item.type === 'stalker'
-                ? '/workspace/stalker'
-                : '/workspace/xtreams';
-        void this.router.navigate([
-            basePath,
-            item.playlistId,
-            'actor',
-            member.tmdbPersonId,
-        ]);
     }
 
     goBack(): void {
@@ -494,13 +451,8 @@ export class VodDetailsComponent {
     }
 
     /** Resume the paused download of this VOD */
-    async resumePausedDownload(): Promise<void> {
-        const item = this.item();
-        await this.downloadsService.resumeDownloadByContent(
-            getVodNumericId(item),
-            item.playlistId,
-            'vod'
-        );
+    resumePausedDownload(): Promise<void> {
+        return this.localDownload.resumePausedDownload();
     }
 
     onInlineTimeUpdate(event: { currentTime: number; duration: number }): void {
@@ -526,18 +478,7 @@ export class VodDetailsComponent {
     }
 
     /** Play from local downloaded file */
-    async playFromLocal(): Promise<void> {
-        const item = this.item();
-        const vodId = getVodNumericId(item);
-
-        const filePath = this.downloadsService.getDownloadedFilePath(
-            vodId,
-            item.playlistId,
-            'vod'
-        );
-
-        if (filePath) {
-            await this.downloadsService.playDownload(filePath);
-        }
+    playFromLocal(): Promise<void> {
+        return this.localDownload.playFromLocal();
     }
 }
diff --git a/libs/ui/playback/src/lib/vod-details/vod-download-state.util.ts b/libs/ui/playback/src/lib/vod-details/vod-download-state.util.ts
index 7adf76ba5..b17070ec8 100644
--- a/libs/ui/playback/src/lib/vod-details/vod-download-state.util.ts
+++ b/libs/ui/playback/src/lib/vod-details/vod-download-state.util.ts
@@ -32,3 +32,58 @@ export function createVodDownloadState(
         ),
     };
 }
+
+export interface VodLocalDownloadStateDeps {
+    readonly downloadsService: DownloadsService;
+    readonly item: Signal<VodDetailsItem>;
+    /** Provider detail handoff hides local/download presentation only. */
+    readonly providerOnly: Signal<boolean>;
+}
+
+/**
+ * The VOD details page's view of its own download: the download-state
+ * signals (always false in provider-only mode) and the two actions that
+ * act on the local copy.
+ */
+export function createVodLocalDownloadState(deps: VodLocalDownloadStateDeps) {
+    const { downloadsService, item, providerOnly } = deps;
+    const downloadState = createVodDownloadState(downloadsService, item);
+
+    return {
+        isDownloaded: computed(
+            () => !providerOnly() && downloadState.isDownloaded()
+        ),
+        isDownloading: computed(
+            () => !providerOnly() && downloadState.isDownloading()
+        ),
+        isPausedDownload: computed(
+            () => !providerOnly() && downloadState.isPausedDownload()
+        ),
+
+        /** Resume the paused download of this VOD */
+        async resumePausedDownload(): Promise<void> {
+            const currentItem = item();
+            await downloadsService.resumeDownloadByContent(
+                getVodNumericId(currentItem),
+                currentItem.playlistId,
+                'vod'
+            );
+        },
+
+        /** Play from local downloaded file */
+        async playFromLocal(): Promise<void> {
+            const currentItem = item();
+            const vodId = getVodNumericId(currentItem);
+
+            const filePath = downloadsService.getDownloadedFilePath(
+                vodId,
+                currentItem.playlistId,
+                'vod'
+            );
+
+            if (filePath) {
+                await downloadsService.playDownload(filePath);
+            }
+        },
+    };
+}
diff --git a/libs/ui/playback/src/lib/vod-details/vod-similar-in-portals.state.ts b/libs/ui/playback/src/lib/vod-details/vod-similar-in-portals.state.ts
new file mode 100644
index 000000000..5e3855a89
--- /dev/null
+++ b/libs/ui/playback/src/lib/vod-details/vod-similar-in-portals.state.ts
@@ -0,0 +1,51 @@
+import {
+    type Signal,
+    computed,
+    effect,
+    signal,
+    untracked,
+} from '@angular/core';
+import type {
+    CrossPortalSimilarItem,
+    CrossPortalSimilarService,
+} from '@iptvnator/services';
+import type { NormalizedVodMeta } from '@iptvnator/shared/interfaces';
+
+/**
+ * TMDB recommendations found in the user's OTHER portals (batched DB
+ * match, Electron only). Loaded async — the section appears when
+ * resolved; staleness-guarded against item changes in flight.
+ *
+ * Registers the loading effect, so call it from a field initializer
+ * (injection context).
+ */
+export function createVodSimilarInPortals(
+    normalizedMeta: Signal<NormalizedVodMeta>,
+    crossPortalSimilar: CrossPortalSimilarService
+): Signal<CrossPortalSimilarItem[]> {
+    const matched = signal<CrossPortalSimilarItem[]>([]);
+    /** Filtered on read: a relock hides matches cached while unlocked. */
+    const visible = computed(() => crossPortalSimilar.visible(matched()));
+
+    effect(() => {
+        const meta = normalizedMeta();
+        const recommendations = meta.tmdbRecommendations;
+        untracked(() => {
+            matched.set([]);
+            if (!recommendations?.length || !crossPortalSimilar.isAvailable) {
+                return;
+            }
+            void crossPortalSimilar
+                .matchRecommendations(recommendations, 'movie')
+                .then((items) => {
+                    if (
+                        normalizedMeta().tmdbRecommendations === recommendations
+                    ) {
+                        matched.set(items);
+                    }
+                });
+        });
+    });
+
+    return visible;
+}
diff --git a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.html b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.html
index 408626567..97219e9de 100644
--- a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.html
+++ b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.html
@@ -1,13 +1,4 @@
 <div class="actor-view">
-    <button
-        class="actor-view__back"
-        type="button"
-        (click)="backClicked.emit()"
-        [attr.aria-label]="'BACK' | translate"
-    >
-        <mat-icon>arrow_back</mat-icon>
-    </button>
-
     @if (isLoading()) {
         <div class="actor-view__loading">
             <mat-spinner diameter="48" />
diff --git a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.scss b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.scss
index 42d21dae4..da24e731f 100644
--- a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.scss
+++ b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.scss
@@ -32,24 +32,6 @@
     padding: 24px 32px 48px;
     position: relative;
 
-    &__back {
-        align-items: center;
-        background: var(--chip-bg);
-        border: none;
-        border-radius: 50%;
-        color: var(--text-primary);
-        cursor: pointer;
-        display: inline-flex;
-        height: 40px;
-        justify-content: center;
-        margin-bottom: 16px;
-        width: 40px;
-
-        &:hover {
-            background: var(--chip-border);
-        }
-    }
-
     &__loading {
         align-items: center;
         display: flex;
diff --git a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.spec.ts b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.spec.ts
new file mode 100644
index 000000000..f4c5fe0b9
--- /dev/null
+++ b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.spec.ts
@@ -0,0 +1,28 @@
+import { TestBed } from '@angular/core/testing';
+import { TranslateModule } from '@ngx-translate/core';
+import { WorkspaceBackNavigationService } from '@iptvnator/portal/shared/data-access';
+import { ActorViewComponent } from './actor-view.component';
+
+describe('ActorViewComponent', () => {
+    it('offers its Back in the workspace header instead of its own arrow', () => {
+        TestBed.configureTestingModule({
+            imports: [ActorViewComponent, TranslateModule.forRoot()],
+        });
+        const fixture = TestBed.createComponent(ActorViewComponent);
+        const backClicked = jest.fn();
+        fixture.componentInstance.backClicked.subscribe(backClicked);
+        fixture.detectChanges();
+        const backNavigation = TestBed.inject(WorkspaceBackNavigationService);
+
+        // Available while the profile loads, too.
+        expect(
+            (fixture.nativeElement as HTMLElement).querySelector('button')
+        ).toBeNull();
+        expect(backNavigation.target()?.escapeShortcut()).toBe(false);
+        backNavigation.goBack();
+        expect(backClicked).toHaveBeenCalledTimes(1);
+
+        fixture.destroy();
+        expect(backNavigation.target()).toBeNull();
+    });
+});
diff --git a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.ts b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.ts
index ed253b563..a578093d9 100644
--- a/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.ts
+++ b/libs/ui/shared-portals/src/lib/actor-view/actor-view.component.ts
@@ -4,9 +4,9 @@ import {
     input,
     output,
 } from '@angular/core';
-import { MatIcon } from '@angular/material/icon';
 import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
 import { TranslatePipe } from '@ngx-translate/core';
+import { registerWorkspaceBack } from '@iptvnator/portal/shared/data-access';
 import {
     ActorFilmographyCredit,
     ActorProfile,
@@ -32,7 +32,6 @@ export type ActorViewScope = TitleResultsScope;
 @Component({
     selector: 'app-actor-view',
     imports: [
-        MatIcon,
         MatProgressSpinnerModule,
         TranslatePipe,
         TitleResultsComponent,
@@ -54,6 +53,11 @@ export class ActorViewComponent {
     readonly scope = input<ActorViewScope>('portal');
 
     readonly itemClicked = output<ActorViewItem>();
+    /** The workspace header's Back on this page. */
     readonly backClicked = output<void>();
     readonly scopeChanged = output<ActorViewScope>();
+
+    constructor() {
+        registerWorkspaceBack({ run: () => this.backClicked.emit() });
+    }
 }
diff --git a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.html b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.html
index e56cbb033..46d7e30ee 100644
--- a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.html
+++ b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.html
@@ -1,13 +1,4 @@
 <div class="discover-view">
-    <button
-        class="discover-view__back"
-        type="button"
-        (click)="backClicked.emit()"
-        [attr.aria-label]="'BACK' | translate"
-    >
-        <mat-icon>arrow_back</mat-icon>
-    </button>
-
     <header class="discover-view__header">
         <h1>{{ 'XTREAM.DISCOVER_TITLE' | translate }}</h1>
         <div class="discover-view__facets">
diff --git a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.scss b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.scss
index a9b37d245..7425fa384 100644
--- a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.scss
+++ b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.scss
@@ -30,24 +30,6 @@
     padding: 24px 32px 48px;
     position: relative;
 
-    &__back {
-        align-items: center;
-        background: var(--chip-bg);
-        border: none;
-        border-radius: 50%;
-        color: var(--text-primary);
-        cursor: pointer;
-        display: inline-flex;
-        height: 40px;
-        justify-content: center;
-        margin-bottom: 16px;
-        width: 40px;
-
-        &:hover {
-            background: var(--chip-border);
-        }
-    }
-
     &__loading {
         align-items: center;
         display: flex;
diff --git a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.spec.ts b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.spec.ts
new file mode 100644
index 000000000..b626a38e6
--- /dev/null
+++ b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.spec.ts
@@ -0,0 +1,37 @@
+import { TestBed } from '@angular/core/testing';
+import { TranslateModule } from '@ngx-translate/core';
+import { WorkspaceBackNavigationService } from '@iptvnator/portal/shared/data-access';
+import { DiscoverViewComponent } from './discover-view.component';
+
+describe('DiscoverViewComponent', () => {
+    it('offers its Back in the workspace header instead of its own arrow', () => {
+        TestBed.configureTestingModule({
+            imports: [DiscoverViewComponent, TranslateModule.forRoot()],
+        });
+        const fixture = TestBed.createComponent(DiscoverViewComponent);
+        fixture.componentRef.setInput('facets', {
+            type: 'movie',
+            genreId: 18,
+            genreLabel: 'Drama',
+            year: null,
+            countryCode: null,
+            countryLabel: null,
+        });
+        const backClicked = jest.fn();
+        fixture.componentInstance.backClicked.subscribe(backClicked);
+        fixture.detectChanges();
+        const backNavigation = TestBed.inject(WorkspaceBackNavigationService);
+
+        expect(
+            (fixture.nativeElement as HTMLElement).querySelector(
+                '.discover-view > button'
+            )
+        ).toBeNull();
+        expect(backNavigation.target()?.escapeShortcut()).toBe(false);
+        backNavigation.goBack();
+        expect(backClicked).toHaveBeenCalledTimes(1);
+
+        fixture.destroy();
+        expect(backNavigation.target()).toBeNull();
+    });
+});
diff --git a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.ts b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.ts
index d15231544..948659e65 100644
--- a/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.ts
+++ b/libs/ui/shared-portals/src/lib/discover-view/discover-view.component.ts
@@ -5,9 +5,9 @@ import {
     input,
     output,
 } from '@angular/core';
-import { MatIcon } from '@angular/material/icon';
 import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
 import { TranslatePipe } from '@ngx-translate/core';
+import { registerWorkspaceBack } from '@iptvnator/portal/shared/data-access';
 import {
     TitleResultItem,
     TitleResultsComponent,
@@ -23,7 +23,6 @@ import { DiscoverRouteParams } from './discover-params';
 @Component({
     selector: 'app-discover-view',
     imports: [
-        MatIcon,
         MatProgressSpinnerModule,
         TranslatePipe,
         TitleResultsComponent,
@@ -45,6 +44,7 @@ export class DiscoverViewComponent<T extends TitleResultItem> {
     readonly scope = input<TitleResultsScope>('portal');
 
     readonly itemClicked = output<T>();
+    /** The workspace header's Back on this page. */
     readonly backClicked = output<void>();
     readonly scopeChanged = output<TitleResultsScope>();
 
@@ -63,4 +63,8 @@ export class DiscoverViewComponent<T extends TitleResultItem> {
             facets.countryLabel ?? facets.countryCode,
         ].filter((label): label is string => label !== null);
     });
+
+    constructor() {
+        registerWorkspaceBack({ run: () => this.backClicked.emit() });
+    }
 }
diff --git a/libs/ui/shared-portals/tsconfig.spec.json b/libs/ui/shared-portals/tsconfig.spec.json
index 65a0eb8ce..3e5b21617 100644
--- a/libs/ui/shared-portals/tsconfig.spec.json
+++ b/libs/ui/shared-portals/tsconfig.spec.json
@@ -7,7 +7,7 @@
         "types": ["jest", "node"],
         "moduleResolution": "bundler"
     },
-    "files": ["src/test-setup.ts"],
+    "files": ["src/test-setup.ts", "../../../global.d.ts"],
     "include": [
         "jest.config.ts",
         "src/**/*.test.ts",
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero-slides.presenter.ts b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero-slides.presenter.ts
index bbc15e4d0..c94f0f1f7 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero-slides.presenter.ts
+++ b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero-slides.presenter.ts
@@ -221,7 +221,6 @@ export class DashboardHeroSlidesPresenter {
             {
                 backdropUrl: item.backdrop_url || extras?.backdropUrl || null,
                 posterUrl: item.poster_url,
-                title: item.title,
             },
             this.failedImages()
         );
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.html b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.html
index 078bd04e7..cb0d80a23 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.html
+++ b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.html
@@ -26,14 +26,7 @@
                     [class.hero__backdrop--live]="slide.contentType === 'live'"
                     [style.--hero-hue]="slide.accentHue"
                 >
-                    <span
-                        class="hero__backdrop-fallback"
-                        [style.background]="
-                            slide.contentType === 'live'
-                                ? null
-                                : slide.fallbackBackdropBackground
-                        "
-                    ></span>
+                    <span class="hero__backdrop-fallback"></span>
                     @if (slide.backdropUrl; as backdropUrl) {
                         <img
                             class="hero__backdrop-image"
@@ -80,7 +73,6 @@
                                   count: slides().length,
                               }
                 "
-                [attr.aria-live]="canRotate() && !paused() ? 'off' : 'polite'"
             >
                 <p class="hero__eyebrow">
                     <span
@@ -92,7 +84,7 @@
                     <span>{{ slide.reasonLabelKey | translate }}</span>
                 </p>
 
-                <h1 class="hero__title">{{ slide.title }}</h1>
+                <h2 class="hero__title">{{ slide.title }}</h2>
 
                 <p class="hero__meta" data-test-id="dashboard-hero-badges">
                     @if (slide.episodeBadge) {
@@ -154,6 +146,13 @@
                         aria-valuemin="0"
                         aria-valuemax="100"
                         [attr.aria-valuenow]="slide.progress"
+                        [attr.aria-label]="slide.programmeTitle ?? slide.title"
+                        [attr.aria-valuetext]="
+                            slide.contentType === 'live'
+                                ? null
+                                : ('WORKSPACE.DASHBOARD.PERCENT_WATCHED'
+                                  | translate: { value: slide.progress })
+                        "
                     >
                         <i [style.--hero-progress]="slide.progress"></i>
                     </span>
@@ -196,6 +195,22 @@
                 </div>
             </div>
         }
+        <!-- Outside the @for: a live region has to be in the page before
+             its text changes, or the change is not announced. Silent while
+             the slides rotate on their own. -->
+        <p
+            class="visually-hidden"
+            data-test-id="dashboard-hero-announcement"
+            aria-atomic="true"
+            [attr.aria-live]="canRotate() && !paused() ? 'off' : 'polite'"
+        >
+            {{
+                'WORKSPACE.DASHBOARD.HERO_SLIDE_POSITION'
+                    | translate
+                        : { index: activeIndex() + 1, count: slides().length }
+            }}
+            {{ active.title }}
+        </p>
 
         @if (slides().length > 1) {
             <div class="hero__controls">
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.scss b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.scss
index d7a580fd7..07ce89e4e 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.scss
+++ b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.scss
@@ -24,13 +24,22 @@
         var(--dashboard-gutter, 28px) +
             max(0px, (100cqw - var(--dashboard-max-width, 1440px)) / 2)
     );
+    // The slide's widest extent, and its right edge measured from the
+    // hero's left edge: the scrim holds its text-safe opacity up to there.
+    --hero-text-width: min(560px, 55%);
+    --hero-text-edge: calc(var(--hero-inset) + var(--hero-text-width));
     --hero-scrim: var(--app-content-bg, #161a22);
     --hero-heading: var(--app-heading-color, #d8dce8);
     --hero-body: color-mix(
         in srgb,
-        var(--app-heading-color, #d8dce8) 72%,
+        var(--app-heading-color, #d8dce8) 85%,
         var(--hero-scrim)
     );
+    // Saturation and lightness of the no-artwork gradient. Light by
+    // default: a near-black gradient under the light theme's page-coloured
+    // scrim turned into a grey slab behind dark text.
+    --hero-fallback-from: 55% 90%;
+    --hero-fallback-to: 60% 78%;
     --hero-pill-bg: color-mix(
         in srgb,
         var(--app-on-surface, #e6e1e5) 12%,
@@ -61,6 +70,11 @@
     }
 }
 
+:host-context(.dark-theme) .hero {
+    --hero-fallback-from: 50% 15%;
+    --hero-fallback-to: 80% 5%;
+}
+
 // ── Backdrops ──────────────────────────────────────────────────────────────
 .hero__stage {
     position: absolute;
@@ -88,6 +102,15 @@
     height: 100%;
 }
 
+// No artwork at all: a gradient tinted by the title's hue (`--hero-hue`).
+.hero__backdrop-fallback {
+    background: linear-gradient(
+        135deg,
+        hsl(var(--hero-hue) var(--hero-fallback-from)) 0%,
+        hsl(calc(var(--hero-hue) + 60) var(--hero-fallback-to)) 100%
+    );
+}
+
 .hero__backdrop-image {
     display: block;
     object-fit: cover;
@@ -173,6 +196,9 @@
     }
 }
 
+// Text never sits on less than 88% of the page colour: the side gradient
+// holds that up to the slide's right edge and only then opens onto the art.
+// Fixed stops at 30% / 60% left the end of a full-width slide on ~45%.
 .hero__scrim {
     position: absolute;
     inset: 0;
@@ -180,8 +206,10 @@
         linear-gradient(
             90deg,
             color-mix(in srgb, var(--hero-scrim) 96%, transparent) 0%,
-            color-mix(in srgb, var(--hero-scrim) 85%, transparent) 30%,
-            color-mix(in srgb, var(--hero-scrim) 35%, transparent) 60%,
+            color-mix(in srgb, var(--hero-scrim) 88%, transparent)
+                var(--hero-text-edge),
+            color-mix(in srgb, var(--hero-scrim) 35%, transparent)
+                calc(var(--hero-text-edge) + 18%),
             transparent 100%
         ),
         linear-gradient(
@@ -205,7 +233,7 @@
     flex-direction: column;
     align-items: flex-start;
     gap: 12px;
-    max-width: min(560px, 55%);
+    max-width: var(--hero-text-width);
     animation: hero-content-in 420ms cubic-bezier(0.2, 0.7, 0.2, 1) both;
 }
 
@@ -220,6 +248,17 @@
     }
 }
 
+// The narrow layout's entrance: no fade, because the slide carries its own
+// scrim there and a fading scrim would flash the art on every rotation.
+@keyframes hero-content-rise {
+    from {
+        transform: translateY(8px);
+    }
+    to {
+        transform: none;
+    }
+}
+
 .hero__eyebrow {
     display: flex;
     align-items: center;
@@ -356,6 +395,10 @@
     padding: 0 18px 0 14px;
     box-sizing: border-box;
     border-radius: 10px;
+    // A long label (or translation) ends in an ellipsis instead of pushing
+    // the button past a narrow slide; the icon keeps its size.
+    max-width: 100%;
+    min-width: 0;
     font-size: 13px;
     font-weight: 600;
     line-height: 1;
@@ -366,7 +409,14 @@
         box-shadow 0.15s ease,
         transform 0.15s ease;
 
+    > span {
+        min-width: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+
     mat-icon {
+        flex: 0 0 auto;
         width: 20px;
         height: 20px;
         font-size: 20px;
@@ -471,15 +521,16 @@
 .hero__dots {
     display: flex;
     align-items: center;
+    gap: 2px;
 }
 
-// 6px dots inside a 20px hit area; the active one stretches into a pill
-// whose fill runs for one rotation interval.
+// 6px dots inside a 24px hit area (WCAG 2.5.8 target size), 2px apart; the
+// active one stretches into a pill whose fill runs for one rotation interval.
 .hero__dot {
     display: grid;
     place-items: center;
-    width: 20px;
-    height: 20px;
+    width: 24px;
+    height: 24px;
     padding: 0;
     border: 0;
     background: transparent;
@@ -516,7 +567,7 @@
     }
 
     &--active {
-        width: 30px;
+        width: 32px;
 
         &::before {
             width: 18px;
@@ -527,8 +578,8 @@
 .hero__dot-fill {
     grid-area: 1 / 1;
     justify-self: start;
-    // Aligns with the 18px pill centred in the 30px button.
-    margin-left: 6px;
+    // Aligns with the 18px pill centred in the 32px button.
+    margin-left: 7px;
     width: 0;
     height: 6px;
     border-radius: 3px;
@@ -632,6 +683,29 @@
         // Clears the rotation controls, which move to the top here.
         padding: 64px 0 28px;
         max-width: none;
+        animation-name: hero-content-rise;
+        text-shadow: 0 1px 2px
+            color-mix(in srgb, var(--hero-scrim) 80%, transparent);
+    }
+
+    // The slide spans the whole width here, over the art: the full-bleed
+    // scrim behind the text block keeps it on at least 90% of the page
+    // colour, fading in just above the eyebrow.
+    .hero__content::before {
+        content: '';
+        position: absolute;
+        z-index: -1;
+        inset: 24px calc(-1 * var(--hero-inset)) 0;
+        background: linear-gradient(
+            180deg,
+            transparent,
+            color-mix(in srgb, var(--hero-scrim) 90%, transparent) 40px
+        );
+        pointer-events: none;
+    }
+
+    .hero__button {
+        text-shadow: none;
     }
 
     .hero__controls {
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.spec.ts b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.spec.ts
index 3e63eb74b..68000d5f4 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.spec.ts
+++ b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.component.spec.ts
@@ -27,8 +27,6 @@ const slide = (id: string, title: string): DashboardHeroSlide => ({
     progress: null,
     accentHue: 200,
     backdropSource: 'fallback',
-    fallbackBackdropBackground: 'none',
-    fallbackPosterBackground: 'none',
     hasBackdrop: false,
     primaryAction: {
         labelKey: 'WORKSPACE.DASHBOARD.HERO_CONTINUE',
@@ -46,7 +44,7 @@ describe('DashboardHeroComponent', () => {
 
     const host = () => fixture.nativeElement as HTMLElement;
     const activeTitle = () =>
-        host().querySelector('[data-test-id=dashboard-hero-slide] h1')
+        host().querySelector('[data-test-id=dashboard-hero-slide] h2')
             ?.textContent;
     const dots = () =>
         Array.from(
@@ -256,6 +254,78 @@ describe('DashboardHeroComponent', () => {
         ).toBe('/workspace/a');
     });
 
+    it('titles each slide with an h2 and leaves the h1 to the page', () => {
+        render();
+
+        expect(host().querySelector('h1')).toBeNull();
+        expect(activeTitle()).toBe('First');
+    });
+
+    it('announces slide changes through one live region that outlives the slides', () => {
+        // A live region inserted together with its text is not announced,
+        // so it must not belong to the slide that the @for re-creates.
+        render();
+        const announcement = () =>
+            host().querySelector<HTMLElement>(
+                '[data-test-id=dashboard-hero-announcement]'
+            );
+        const region = announcement();
+        expect(region).not.toBeNull();
+        expect(
+            region?.closest('[data-test-id=dashboard-hero-slide]')
+        ).toBeNull();
+        expect(
+            host()
+                .querySelector('[data-test-id=dashboard-hero-slide]')
+                ?.hasAttribute('aria-live')
+        ).toBe(false);
+        // Rotating on its own: silent.
+        expect(region?.getAttribute('aria-live')).toBe('off');
+        expect(region?.textContent).toContain('First');
+
+        const section = host().querySelector(
+            '[data-test-id=dashboard-hero]'
+        ) as HTMLElement;
+        section.dispatchEvent(new Event('focusin'));
+        dots()[1].click();
+        fixture.detectChanges();
+
+        expect(announcement()).toBe(region);
+        expect(region?.getAttribute('aria-live')).toBe('polite');
+        expect(region?.getAttribute('aria-atomic')).toBe('true');
+        expect(region?.textContent).toContain('Second');
+    });
+
+    it('names the progress bar after what is progressing', () => {
+        slides.set([
+            { ...slide('a', 'Movie'), progress: 42 },
+            {
+                ...slide('b', 'Channel'),
+                contentType: 'live',
+                programmeTitle: 'Evening programme',
+                progress: 10,
+            },
+        ]);
+        render();
+        const bar = () =>
+            host().querySelector(
+                '[data-test-id=dashboard-hero-slide] [role=progressbar]'
+            );
+
+        expect(bar()?.getAttribute('aria-label')).toBe('Movie');
+        // The translate pipe echoes the key in this test bed.
+        expect(bar()?.getAttribute('aria-valuetext')).toBe(
+            'WORKSPACE.DASHBOARD.PERCENT_WATCHED'
+        );
+
+        dots()[1].click();
+        fixture.detectChanges();
+        expect(bar()?.getAttribute('aria-label')).toBe('Evening programme');
+        // Elapsed share of a live programme: the plain percentage.
+        expect(bar()?.hasAttribute('aria-valuetext')).toBe(false);
+        expect(bar()?.getAttribute('aria-valuenow')).toBe('10');
+    });
+
     it('positions the progress fill through a custom property, never its width', () => {
         // Animating width re-lays out the page on every live-EPG tick; the
         // stylesheet slides the fill with a transform driven by this property.
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.utils.ts b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.utils.ts
index 6f210ac20..4171992bb 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.utils.ts
+++ b/libs/workspace/dashboard/feature/src/lib/rails/dashboard-hero.utils.ts
@@ -40,7 +40,7 @@ export interface DashboardHeroSlide extends DashboardHeroArtwork {
     readonly description: string | null;
     /** 0-100: watched share, or elapsed share of the live programme */
     readonly progress: number | null;
-    /** Title-derived hue for the live slide's glow (0-359) */
+    /** Title-derived hue (0-359): the live glow and the no-artwork gradient */
     readonly accentHue: number;
     readonly primaryAction: DashboardHeroAction;
     readonly secondaryAction: DashboardHeroAction | null;
@@ -51,14 +51,11 @@ export type DashboardHeroBackdropSource = 'backdrop' | 'poster' | 'fallback';
 export interface DashboardHeroArtworkInput {
     readonly backdropUrl?: string | null;
     readonly posterUrl?: string | null;
-    readonly title: string;
 }
 
 export interface DashboardHeroArtwork {
     readonly backdropUrl?: string;
     readonly backdropSource: DashboardHeroBackdropSource;
-    readonly fallbackBackdropBackground: string;
-    readonly fallbackPosterBackground: string;
     readonly hasBackdrop: boolean;
     readonly posterUrl?: string;
 }
@@ -85,49 +82,17 @@ export function resolveDashboardHeroArtwork(
     return {
         backdropUrl,
         backdropSource,
-        fallbackBackdropBackground: buildFallbackBackground(
-            item.title,
-            50,
-            15,
-            80,
-            5,
-            60
-        ),
-        fallbackPosterBackground: buildFallbackBackground(
-            item.title,
-            40,
-            25,
-            50,
-            15,
-            40
-        ),
         hasBackdrop: backdropSource === 'backdrop',
         posterUrl,
     };
 }
 
-function buildFallbackBackground(
-    title: string,
-    saturationA: number,
-    lightnessA: number,
-    saturationB: number,
-    lightnessB: number,
-    hueOffset: number
-): string {
-    const hue = calculateHue(title || 'placeholder');
-    const h2 = (hue + hueOffset) % 360;
-    return `linear-gradient(135deg, hsl(${hue}, ${saturationA}%, ${lightnessA}%) 0%, hsl(${h2}, ${saturationB}%, ${lightnessB}%) 100%)`;
-}
-
 /** Stable hue for a title, shared by every generated fallback surface. */
 export function dashboardHeroHue(text: string): number {
-    return calculateHue(text || 'placeholder');
-}
-
-function calculateHue(text: string): number {
+    const key = text || 'placeholder';
     let hash = 0;
-    for (let i = 0; i < text.length; i++) {
-        hash = text.charCodeAt(i) + ((hash << 5) - hash);
+    for (let i = 0; i < key.length; i++) {
+        hash = key.charCodeAt(i) + ((hash << 5) - hash);
         hash = hash & hash;
     }
     return Math.abs(hash) % 360;
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.html b/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.html
index a842cb511..29406c54e 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.html
+++ b/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.html
@@ -3,6 +3,11 @@
     [class.rails-page--empty]="ready() && !hasPlaylists()"
     data-test-id="dashboard-page"
 >
+    <!-- The page's one stable h1: the rail already names the page, and the
+         hero's rotating title is only the current slide (an h2). -->
+    <h1 class="visually-hidden" data-test-id="dashboard-page-heading">
+        {{ 'WORKSPACE.SHELL.RAIL_DASHBOARD' | translate }}
+    </h1>
     @if (data.playlistsLoaded() && !hasPlaylists()) {
         <app-empty-state
             [type]="'welcome-dashboard'"
diff --git a/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.spec.ts b/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.spec.ts
index 6d16a412c..7d3a2fc1f 100644
--- a/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.spec.ts
+++ b/libs/workspace/dashboard/feature/src/lib/rails/workspace-dashboard-rails.component.spec.ts
@@ -146,7 +146,6 @@ describe('buildDashboardContinueWatchingActions', () => {
 
 describe('resolveDashboardHeroArtwork', () => {
     const item = {
-        title: 'Broken Hero',
         posterUrl: 'https://images.example.test/poster.jpg',
         backdropUrl: 'https://images.example.test/backdrop.jpg',
     };
@@ -173,7 +172,8 @@ describe('resolveDashboardHeroArtwork', () => {
         });
     });
 
-    it('uses generated fallback artwork when backdrop and poster both fail', () => {
+    // The stylesheet paints the no-artwork gradient from the slide's hue.
+    it('reports no artwork when backdrop and poster both fail', () => {
         const artwork = resolveDashboardHeroArtwork(item, {
             [item.backdropUrl]: true,
             [item.posterUrl]: true,
@@ -185,8 +185,6 @@ describe('resolveDashboardHeroArtwork', () => {
             posterUrl: undefined,
             backdropUrl: undefined,
         });
-        expect(artwork.fallbackBackdropBackground).toContain('linear-gradient');
-        expect(artwork.fallbackPosterBackground).toContain('linear-gradient');
     });
 });
 
diff --git a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.scss b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.scss
index faf6063f2..24b1d1c6f 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.scss
+++ b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.scss
@@ -32,17 +32,14 @@
 }
 
 // `height: 100%` here does not resolve against a stretched flex item, so the
-// list kept its full content height and painted over the footer whenever the
+// list kept its full content height and overflowed the panel whenever the
 // panel was shorter than its sections (a phone, or a short desktop window).
 .settings-sections-list {
     flex: 1;
     min-height: 0;
-}
-
-.settings-panel-footer {
-    flex-shrink: 0;
-    padding: 12px 8px calc(20px + env(safe-area-inset-bottom, 0px));
-    border-top: 1px solid var(--app-separator);
+    // The list now reaches the panel's bottom edge (Back moved to the
+    // header), so it clears the home indicator itself.
+    padding-bottom: calc(12px + env(safe-area-inset-bottom, 0px));
 }
 
 // Sections without settings-search matches stay reachable but recede.
@@ -50,16 +47,13 @@
     opacity: 0.55;
 }
 
-.settings-section-item:hover:not(.active):not(.selected),
-.settings-back-button:hover:not(.active):not(.selected) {
+.settings-section-item:hover:not(.active):not(.selected) {
     background: var(--app-selection-surface);
 }
 
-// On a landscape phone the stacked panel gets ~108-148px, and this panel's
-// fixed chrome (title + footer) alone is about that tall — the section list
-// was collapsing to nothing behind an overlapping footer. The rail already
-// labels the page, so the caption is what gives way, and the footer sheds
-// the padding it carries for taller screens.
+// On a landscape phone the panel is only ~108-148px tall, and its caption
+// would take a third of that from the section list. The rail already labels
+// the page, so the caption is what gives way.
 @media (max-width: 640px) and (max-height: 599px) {
     .panel-title {
         display: none;
@@ -68,8 +62,4 @@
     .settings-panel-body {
         padding-top: 8px;
     }
-
-    .settings-panel-footer {
-        padding: 6px 8px calc(6px + env(safe-area-inset-bottom, 0px));
-    }
 }
diff --git a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.spec.ts
index effb04e5c..5f57e5cee 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.spec.ts
@@ -1,7 +1,9 @@
+import { Location } from '@angular/common';
 import { TestBed } from '@angular/core/testing';
 import { provideRouter } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { of } from 'rxjs';
+import { WorkspaceBackNavigationService } from '@iptvnator/portal/shared/data-access';
 import { SettingsContextService } from '@iptvnator/workspace/shell/util/settings-context';
 import { WorkspaceSettingsContextPanelComponent } from './workspace-settings-context-panel.component';
 
@@ -46,6 +48,29 @@ describe('WorkspaceSettingsContextPanelComponent', () => {
         return { ctx, fixture, link };
     }
 
+    it('offers Back in the header, beside the phone drawer toggle', () => {
+        const { fixture } = setup();
+        const back = jest
+            .spyOn(TestBed.inject(Location), 'back')
+            .mockImplementation(() => undefined);
+        const backNavigation = TestBed.inject(WorkspaceBackNavigationService);
+
+        // The panel carries no footer arrow of its own.
+        expect(
+            (fixture.nativeElement as HTMLElement).querySelector('button')
+        ).toBeNull();
+        const target = backNavigation.target();
+        // The drawer holds the sections, so its toggle must stay reachable.
+        expect(target?.phoneDrawerToggle).toBe('beside');
+        expect(target?.label()).toBeNull();
+
+        backNavigation.goBack();
+        expect(back).toHaveBeenCalledTimes(1);
+
+        fixture.destroy();
+        expect(backNavigation.target()).toBeNull();
+    });
+
     it('shows no counts while settings search is idle', () => {
         const { link } = setup();
 
diff --git a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.ts b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.ts
index ced7aef8b..5a93f9125 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-settings-context-panel.component.ts
@@ -3,6 +3,7 @@ import { Component, inject, ChangeDetectionStrategy } from '@angular/core';
 import { MatIconModule } from '@angular/material/icon';
 import { RouterLink, RouterLinkActive } from '@angular/router';
 import { TranslateModule } from '@ngx-translate/core';
+import { registerWorkspaceBack } from '@iptvnator/portal/shared/data-access';
 import { WorkspaceShellContextDrawerService } from '@iptvnator/workspace/shell/util';
 import { SettingsContextService } from '@iptvnator/workspace/shell/util/settings-context';
 
@@ -18,7 +19,7 @@ import { SettingsContextService } from '@iptvnator/workspace/shell/util/settings
                 @for (section of ctx.sections(); track section.id) {
                     <!-- replaceUrl keeps a single settings entry in the
                          browser history: switching sections must not turn
-                         "Back" (footer or browser) into a walk through every
+                         "Back" (header or browser) into a walk through every
                          visited section page before finally leaving. -->
                     <a
                         class="nav-item settings-section-item"
@@ -51,16 +52,6 @@ import { SettingsContextService } from '@iptvnator/workspace/shell/util/settings
                 }
             </div>
         </div>
-        <div class="settings-panel-footer">
-            <button
-                type="button"
-                class="nav-item settings-back-button"
-                (click)="onBack()"
-            >
-                <mat-icon>arrow_back</mat-icon>
-                <span>{{ 'SETTINGS.BACK_TO_HOME' | translate }}</span>
-            </button>
-        </div>
     `,
 })
 export class WorkspaceSettingsContextPanelComponent {
@@ -77,11 +68,17 @@ export class WorkspaceSettingsContextPanelComponent {
         }
     );
 
+    constructor() {
+        // The panel exists exactly while the settings route shows, so it
+        // offers the page's Back in the header. On a phone the toggle for
+        // this drawer stays beside it: the drawer holds the sections.
+        registerWorkspaceBack({
+            phoneDrawerToggle: 'beside',
+            run: () => this.location.back(),
+        });
+    }
+
     onSectionClicked() {
         this.contextDrawer?.close();
     }
-
-    onBack() {
-        this.location.back();
-    }
 }
diff --git a/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.spec.ts
index 6fd6a4a32..f3c93b8a0 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.spec.ts
@@ -53,7 +53,7 @@ describe('WorkspacePlayerCommandsContributor', () => {
     let electronStub:
         | {
               getEmbeddedMpvSupport: jest.Mock<
-                  Promise<{ supported: boolean }>,
+                  Promise<{ supported: boolean; inconclusive?: boolean }>,
                   []
               >;
           }
@@ -63,7 +63,10 @@ describe('WorkspacePlayerCommandsContributor', () => {
     function bootstrap(options: {
         supportsManagedExternalPlayers: boolean;
         supportsEmbeddedMpv?: boolean;
-        embeddedMpvSupportResult?: { supported: boolean } | null;
+        embeddedMpvSupportResult?: {
+            supported: boolean;
+            inconclusive?: boolean;
+        } | null;
     }) {
         viewCommands = {
             registerCommand: jest.fn().mockReturnValue(() => undefined),
@@ -200,6 +203,77 @@ describe('WorkspacePlayerCommandsContributor', () => {
         expect(resolveBoolean(embedded?.visible)).toBe(false);
     });
 
+    it('keeps a final unsupported answer, but asks again after an inconclusive one', async () => {
+        const contributor = bootstrap({
+            supportsManagedExternalPlayers: true,
+            supportsEmbeddedMpv: true,
+            // A slow login shell: mpv was looked up before its PATH arrived.
+            embeddedMpvSupportResult: { supported: false, inconclusive: true },
+        });
+        const embedded = getRegistered(viewCommands).find(
+            (c) => c.id === 'switch-player-embedded-mpv'
+        );
+
+        await contributor.ensureEmbeddedMpvSupportLoaded();
+        expect(resolveBoolean(embedded?.visible)).toBe(false);
+
+        // The shell answered without mpv: that answer is final.
+        electronStub?.getEmbeddedMpvSupport.mockResolvedValue({
+            supported: false,
+        });
+        await contributor.ensureEmbeddedMpvSupportLoaded();
+        expect(resolveBoolean(embedded?.visible)).toBe(false);
+        expect(contributor.ensureEmbeddedMpvSupportLoaded()).toBeUndefined();
+        expect(electronStub?.getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+    });
+
+    it('shows embedded MPV once an inconclusive answer turns into supported', async () => {
+        const contributor = bootstrap({
+            supportsManagedExternalPlayers: true,
+            supportsEmbeddedMpv: true,
+            embeddedMpvSupportResult: { supported: false, inconclusive: true },
+        });
+        const embedded = getRegistered(viewCommands).find(
+            (c) => c.id === 'switch-player-embedded-mpv'
+        );
+        await contributor.ensureEmbeddedMpvSupportLoaded();
+
+        electronStub?.getEmbeddedMpvSupport.mockResolvedValue({
+            supported: true,
+        });
+        await contributor.ensureEmbeddedMpvSupportLoaded();
+
+        expect(resolveBoolean(embedded?.visible)).toBe(true);
+        expect(contributor.ensureEmbeddedMpvSupportLoaded()).toBeUndefined();
+    });
+
+    it('asks again after a failed request instead of giving up for the session', async () => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation();
+        const contributor = bootstrap({
+            supportsManagedExternalPlayers: true,
+            supportsEmbeddedMpv: true,
+        });
+        const embedded = getRegistered(viewCommands).find(
+            (c) => c.id === 'switch-player-embedded-mpv'
+        );
+        electronStub?.getEmbeddedMpvSupport.mockRejectedValueOnce(
+            new Error('bridge failed')
+        );
+
+        try {
+            await contributor.ensureEmbeddedMpvSupportLoaded();
+            expect(resolveBoolean(embedded?.visible)).toBe(false);
+
+            await contributor.ensureEmbeddedMpvSupportLoaded();
+            expect(resolveBoolean(embedded?.visible)).toBe(true);
+            expect(electronStub?.getEmbeddedMpvSupport).toHaveBeenCalledTimes(
+                2
+            );
+        } finally {
+            warn.mockRestore();
+        }
+    });
+
     it('switches to embedded MPV on run', () => {
         bootstrap({
             supportsManagedExternalPlayers: true,
diff --git a/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.ts b/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.ts
index 4d0893e39..fc9f58dd3 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-player-commands/workspace-player-commands.contributor.ts
@@ -120,16 +120,20 @@ export class WorkspacePlayerCommandsContributor {
     }
 
     private async loadEmbeddedMpvSupport(): Promise<void> {
+        // Only a final answer is kept. An inconclusive one, or a failed
+        // request, hides the command for now: the next palette open asks again.
+        let final = false;
         try {
             const support = await window.electron?.getEmbeddedMpvSupport?.();
             this.embeddedMpvSupported.set(!!support?.supported);
+            final = !support?.inconclusive;
         } catch (error) {
             console.warn(
                 'Failed to verify embedded MPV support for the command palette.',
                 error
             );
         } finally {
-            this.embeddedMpvSupportChecked = true;
+            this.embeddedMpvSupportChecked = final;
             this.embeddedMpvSupportLoad = null;
         }
     }
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.html b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.html
index 0fd5d1429..65c586af5 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.html
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.html
@@ -1,12 +1,14 @@
 <header class="workspace-header" [class.is-settings-route]="isSettingsRoute()">
-    <!-- The page's Back, at the leading edge where desktop apps and Material's
-         top app bar keep navigation (beside the macOS traffic lights). The
+    <!-- The page's Back, or browser history while an in-app previous page
+         exists, at the leading edge where desktop apps and Material's top
+         app bar keep navigation (beside the macOS traffic lights). The
          header never scrolls, so the control stays put over long pages. -->
     @if (backTarget(); as back) {
         @let backLabel = back.label() || ('BACK' | translate);
         <button
             type="button"
             class="header-back"
+            [class.header-back--yields]="backYieldsToDrawerToggle()"
             mat-icon-button
             data-test-id="workspace-header-back"
             (click)="backRequested.emit()"
@@ -23,9 +25,10 @@
 
     <!-- Phone-only (≤640px, CSS-hidden above): on phones the context panel
          is an off-canvas drawer, and this button is the only way to open
-         it. A page with Back takes its slot (one navigation icon, as in
-         Material's top app bar); the list Back returns to shows it again. -->
-    @if (showContextDrawerToggle() && !backTarget()) {
+         it. A detail page's Back takes its slot (one navigation icon, as in
+         Material's top app bar); the list Back returns to shows it again.
+         Settings keeps both, and the history fallback yields to it. -->
+    @if (showDrawerToggle()) {
         <button
             #contextDrawerToggle
             type="button"
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.scss b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.scss
index 69ed2a61d..169a8561f 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.scss
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.scss
@@ -351,6 +351,12 @@
         flex-shrink: 0;
     }
 
+    // The history fallback must not cost a list its only way into the
+    // drawer, and two navigation icons do not fit beside the switcher.
+    .header-back--yields {
+        display: none;
+    }
+
     .playlist-switcher {
         width: auto;
         // Fixed at 140px this crowded the search field off a 320px header
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.spec.ts
index 85b45e86c..199bbc135 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.spec.ts
@@ -15,7 +15,10 @@ import { MatTooltip } from '@angular/material/tooltip';
 import { TranslateService } from '@ngx-translate/core';
 import { of } from 'rxjs';
 import { TranslatePipe } from '@ngx-translate/core';
-import { WorkspaceBackTarget } from '@iptvnator/portal/shared/util';
+import {
+    WorkspaceBackPhoneSlot,
+    WorkspaceBackTarget,
+} from '@iptvnator/portal/shared/util';
 import { WorkspaceShellHeaderComponent } from './workspace-shell-header.component';
 
 @Component({
@@ -384,13 +387,20 @@ describe('WorkspaceShellHeaderComponent', () => {
                 '[data-test-id="workspace-header-back"]'
             );
 
+        const drawerToggle = (): HTMLButtonElement | null =>
+            fixture.nativeElement.querySelector(
+                '[data-test-id="context-drawer-toggle"]'
+            );
+
         function setBackTarget(
             label: string | null,
-            escapeShortcut: boolean
+            escapeShortcut: boolean,
+            phoneDrawerToggle?: WorkspaceBackPhoneSlot
         ): WorkspaceBackTarget {
             const target: WorkspaceBackTarget = {
                 label: signal(label),
                 escapeShortcut: signal(escapeShortcut),
+                phoneDrawerToggle,
                 run: jest.fn(),
             };
             fixture.componentRef.setInput('backTarget', target);
@@ -479,6 +489,48 @@ describe('WorkspaceShellHeaderComponent', () => {
                 )
             ).not.toBeNull();
         });
+
+        it('keeps the drawer toggle after Back for a page whose sections live in the drawer', () => {
+            fixture.componentRef.setInput('showContextDrawerToggle', true);
+            setBackTarget(null, false, 'beside');
+
+            expect(drawerToggle()).not.toBeNull();
+            expect(backButton()?.nextElementSibling).toBe(drawerToggle());
+            expect(backButton()?.classList).not.toContain(
+                'header-back--yields'
+            );
+        });
+
+        it('lets the history fallback yield to the drawer toggle at phone width', () => {
+            fixture.componentRef.setInput('showContextDrawerToggle', true);
+            setBackTarget(null, false, 'yield');
+
+            expect(drawerToggle()).not.toBeNull();
+            // Hidden by the ≤640px rule; above it the toggle itself is hidden.
+            expect(backButton()?.classList).toContain('header-back--yields');
+
+            // Routes without a drawer keep the fallback at every width.
+            fixture.componentRef.setInput('showContextDrawerToggle', false);
+            fixture.detectChanges();
+            expect(backButton()?.classList).not.toContain(
+                'header-back--yields'
+            );
+        });
+    });
+
+    it('hides a yielding Back only in the phone layout', () => {
+        const styleSource = readFileSync(
+            join(__dirname, 'workspace-shell-header.component.scss'),
+            'utf8'
+        );
+        const phoneStart = styleSource.indexOf('@media (max-width: 640px)');
+
+        expect(styleSource.indexOf('.header-back--yields')).toBeGreaterThan(
+            phoneStart
+        );
+        expect(styleSource.slice(phoneStart)).toMatch(
+            /\.header-back--yields\s*\{\s*display:\s*none;/
+        );
     });
 
     it('uses the paired Material primary tokens for the download badge', () => {
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.ts b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.ts
index cd726797c..1592b03f1 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-header/workspace-shell-header.component.ts
@@ -49,7 +49,7 @@ export class WorkspaceShellHeaderComponent {
         /Mac|iPhone|iPad|iPod/i.test(navigator.platform);
     readonly commandShortcutLabel = this.isMac ? '⌘K' : 'Ctrl+K';
 
-    /** The current page's Back action; null when the page has none. */
+    /** The page's Back or the history fallback; null when there is neither. */
     readonly backTarget = input<WorkspaceBackTarget | null>(null);
     readonly playlistTitle = input('');
     readonly playlistSubtitle = input('');
@@ -110,6 +110,20 @@ export class WorkspaceShellHeaderComponent {
         'WORKSPACE.SHELL.CONTEXT_DRAWER_CATEGORIES_TOOLTIP'
     );
 
+    private readonly backPhoneSlot = computed(() => {
+        const back = this.backTarget();
+        return back ? (back.phoneDrawerToggle ?? 'replace') : null;
+    });
+    /** The drawer toggle renders unless Back takes its phone slot. */
+    readonly showDrawerToggle = computed(
+        () =>
+            this.showContextDrawerToggle() && this.backPhoneSlot() !== 'replace'
+    );
+    /** At phone width, Back hides behind a shown drawer toggle. */
+    readonly backYieldsToDrawerToggle = computed(
+        () => this.showDrawerToggle() && this.backPhoneSlot() === 'yield'
+    );
+
     readonly backRequested = output<void>();
     readonly searchChanged = output<string>();
     readonly searchSubmitted = output<string>();
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.html b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.html
index 04dadb780..13e259f50 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.html
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.html
@@ -1,6 +1,10 @@
 <!-- No brand mark: it linked to the page the first workspace link opens.
      The page's Back lives in the header's leading slot. -->
-<aside class="app-rail" [class.is-macos]="isMacOS()">
+<aside
+    class="app-rail"
+    [class.is-macos]="isMacOS()"
+    [style.--rail-zoom-factor]="isMacOS() ? zoomFactor() : null"
+>
     <app-workspace-shell-rail-links [links]="workspaceLinks()" />
 
     @if (primaryContextLinks().length > 0) {
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.scss b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.scss
index d3e056d90..31c6b985a 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.scss
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.scss
@@ -29,8 +29,13 @@
     --rail-link-active-border: var(--app-selection-border);
     --rail-link-active-glow: var(--app-selection-glow);
 
+    // The traffic lights sit in the header band (56px, see the shell grid).
+    // The first link starts below that band, where the content area and the
+    // dashboard hero start, so its hover surface never touches the lights.
+    // App zoom scales CSS pixels but not the lights: zoomed out, the inset
+    // keeps 48 window pixels (lights' bottom plus a gap) instead.
     &.is-macos {
-        padding-top: 36px;
+        padding-top: max(56px, calc(48px / var(--rail-zoom-factor, 1)));
     }
 
     &::-webkit-scrollbar {
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.spec.ts
index 212bbf2b5..efd193052 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.spec.ts
@@ -84,6 +84,48 @@ describe('WorkspaceShellRailComponent', () => {
         ).not.toBeNull();
     });
 
+    describe('macOS zoom inset', () => {
+        const setWindowWidths = (outer: number, inner: number) => {
+            Object.defineProperty(window, 'outerWidth', {
+                configurable: true,
+                value: outer,
+            });
+            Object.defineProperty(window, 'innerWidth', {
+                configurable: true,
+                value: inner,
+            });
+        };
+        const zoomVar = () =>
+            (
+                fixture.nativeElement.querySelector('.app-rail') as HTMLElement
+            ).style.getPropertyValue('--rail-zoom-factor');
+
+        afterEach(() => setWindowWidths(1024, 1024));
+
+        it('publishes the page zoom factor on macOS and follows resize', () => {
+            setWindowWidths(1200, 1200);
+            fixture.componentRef.setInput('isMacOS', true);
+            fixture.detectChanges();
+            TestBed.tick();
+            fixture.detectChanges();
+            expect(zoomVar()).toBe('1');
+
+            // Zoomed out to 50%: the viewport holds twice the CSS pixels.
+            setWindowWidths(1200, 2400);
+            window.dispatchEvent(new Event('resize'));
+            fixture.detectChanges();
+            expect(zoomVar()).toBe('0.5');
+        });
+
+        it('leaves the inset alone off macOS', () => {
+            setWindowWidths(1200, 2400);
+            fixture.detectChanges();
+            TestBed.tick();
+            fixture.detectChanges();
+            expect(zoomVar()).toBe('');
+        });
+    });
+
     it('has no brand mark duplicating the first workspace link', () => {
         fixture.detectChanges();
 
diff --git a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.ts b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.ts
index 980d29bf0..95343f6e9 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-shell/components/workspace-shell-rail/workspace-shell-rail.component.ts
@@ -1,4 +1,12 @@
-import { ChangeDetectionStrategy, Component, input } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import {
+    ChangeDetectionStrategy,
+    Component,
+    effect,
+    inject,
+    input,
+    signal,
+} from '@angular/core';
 import { MatIcon } from '@angular/material/icon';
 import { MatTooltip } from '@angular/material/tooltip';
 import { RouterLink } from '@angular/router';
@@ -32,4 +40,29 @@ export class WorkspaceShellRailComponent {
     >(null);
     readonly railProviderClass = input('rail-context-region');
     readonly isSettingsRoute = input(false);
+
+    /**
+     * The page zoom factor. App zoom (`webFrame.setZoomLevel`) scales CSS
+     * pixels but not the native traffic lights, so the macOS top inset is
+     * kept in window pixels when zoomed out. Chromium reports the window in
+     * window pixels and the viewport in CSS pixels, and fires `resize` when
+     * the zoom changes.
+     */
+    protected readonly zoomFactor = signal(1);
+
+    constructor() {
+        const view = inject(DOCUMENT).defaultView;
+        effect((onCleanup) => {
+            if (!this.isMacOS() || !view) return;
+            const update = () =>
+                this.zoomFactor.set(
+                    view.innerWidth > 0 && view.outerWidth > 0
+                        ? view.outerWidth / view.innerWidth
+                        : 1
+                );
+            update();
+            view.addEventListener('resize', update);
+            onCleanup(() => view.removeEventListener('resize', update));
+        });
+    }
 }
diff --git a/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.spec.ts b/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.spec.ts
index 355d5c911..260e83686 100644
--- a/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.spec.ts
+++ b/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.spec.ts
@@ -3,6 +3,7 @@ import { Router } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { VodSourceDiscoveryService } from '@iptvnator/portal/shared/data-access';
 import { RuntimeCapabilitiesService } from '@iptvnator/services';
+import { EMBEDDED_MPV_SUPPORT_RECHECK_MS } from '@iptvnator/shared/interfaces';
 import { SETTINGS_SEARCH_ENTRIES } from './settings-search-entries';
 import { SETTINGS_SECTION_DEFINITIONS } from './settings-search-sections';
 import { SettingsSearchService } from './settings-search.service';
@@ -142,6 +143,7 @@ describe('SettingsSearchService', () => {
 
         function probeWith(support: {
             supported: boolean;
+            inconclusive?: boolean;
             frameCopyAvailable?: boolean;
         }) {
             const getEmbeddedMpvSupport = jest
@@ -186,6 +188,144 @@ describe('SettingsSearchService', () => {
             );
         });
 
+        it('asks again after an inconclusive answer and keeps the final one', async () => {
+            // A slow login shell: mpv was looked up before its PATH arrived.
+            const getEmbeddedMpvSupport = probeWith({
+                supported: false,
+                inconclusive: true,
+            });
+            const { service } = setup({
+                ...DESKTOP,
+                supportsEmbeddedMpv: true,
+            });
+            const entries = () => service.visibleEntries().map(({ id }) => id);
+
+            await service.ensureEmbeddedMpvSupportLoaded();
+            expect(entries()).not.toContain('embedded-mpv-extra-options');
+
+            // The shell answered meanwhile, and mpv is there.
+            getEmbeddedMpvSupport.mockResolvedValue({
+                platform: 'linux',
+                supported: true,
+            });
+            await service.ensureEmbeddedMpvSupportLoaded();
+            expect(entries()).toContain('embedded-mpv-extra-options');
+            expect(service.ensureEmbeddedMpvSupportLoaded()).toBeUndefined();
+            expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+        });
+
+        it('asks again after a failed request instead of giving up for the session', async () => {
+            const getEmbeddedMpvSupport = probeWith({ supported: true });
+            getEmbeddedMpvSupport.mockRejectedValueOnce(
+                new Error('bridge failed')
+            );
+            const { service } = setup({
+                ...DESKTOP,
+                supportsEmbeddedMpv: true,
+            });
+            const entries = () => service.visibleEntries().map(({ id }) => id);
+
+            await service.ensureEmbeddedMpvSupportLoaded();
+            expect(entries()).not.toContain('embedded-mpv-extra-options');
+
+            await service.ensureEmbeddedMpvSupportLoaded();
+            expect(entries()).toContain('embedded-mpv-extra-options');
+            expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+        });
+
+        describe('while the settings page stays open', () => {
+            const inconclusive = { supported: false, inconclusive: true };
+            const mountedSetup = () =>
+                setup({ ...DESKTOP, supportsEmbeddedMpv: true });
+
+            beforeEach(() => jest.useFakeTimers());
+            afterEach(() => jest.useRealTimers());
+
+            it('follows an inconclusive answer without being asked again', async () => {
+                const getEmbeddedMpvSupport = probeWith(inconclusive);
+                const { service } = mountedSetup();
+                const entries = () =>
+                    service.visibleEntries().map(({ id }) => id);
+
+                // The page starts following once, when it is created.
+                service.followEmbeddedMpvSupport();
+                await jest.advanceTimersByTimeAsync(0);
+                expect(entries()).not.toContain('embedded-mpv-extra-options');
+
+                getEmbeddedMpvSupport.mockResolvedValue({
+                    platform: 'linux',
+                    supported: true,
+                });
+                await jest.advanceTimersByTimeAsync(
+                    EMBEDDED_MPV_SUPPORT_RECHECK_MS
+                );
+
+                expect(entries()).toContain('embedded-mpv-extra-options');
+                expect(
+                    service.ensureEmbeddedMpvSupportLoaded()
+                ).toBeUndefined();
+                await jest.advanceTimersByTimeAsync(
+                    EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+                );
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+            });
+
+            it('stops asking once the page is closed, and asks again on the next use', async () => {
+                const getEmbeddedMpvSupport = probeWith(inconclusive);
+                const { service } = mountedSetup();
+                const stopFollowing = service.followEmbeddedMpvSupport();
+                await jest.advanceTimersByTimeAsync(0);
+
+                // Nothing shows these rows any more: no polling is left.
+                stopFollowing();
+                await jest.advanceTimersByTimeAsync(
+                    EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+                );
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(1);
+
+                await service.ensureEmbeddedMpvSupportLoaded();
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+            });
+
+            it('ends on a failed recheck, and the next use asks again', async () => {
+                const getEmbeddedMpvSupport = probeWith(inconclusive);
+                const { service } = mountedSetup();
+                service.followEmbeddedMpvSupport();
+                await jest.advanceTimersByTimeAsync(0);
+
+                getEmbeddedMpvSupport.mockRejectedValueOnce(
+                    new Error('bridge failed')
+                );
+                await jest.advanceTimersByTimeAsync(
+                    EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+                );
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(2);
+
+                getEmbeddedMpvSupport.mockResolvedValue({
+                    platform: 'linux',
+                    supported: true,
+                });
+                await service.ensureEmbeddedMpvSupportLoaded();
+                expect(service.visibleEntries().map(({ id }) => id)).toContain(
+                    'embedded-mpv-extra-options'
+                );
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(3);
+            });
+
+            it('has nothing to follow once a final answer is in hand', async () => {
+                const getEmbeddedMpvSupport = probeWith({ supported: true });
+                const { service } = mountedSetup();
+                await service.ensureEmbeddedMpvSupportLoaded();
+
+                service.followEmbeddedMpvSupport();
+                await jest.advanceTimersByTimeAsync(
+                    EMBEDDED_MPV_SUPPORT_RECHECK_MS * 20
+                );
+
+                expect(getEmbeddedMpvSupport).toHaveBeenCalledTimes(1);
+            });
+        });
+
         it('does not probe where the runtime has no embedded MPV bridge', () => {
             const getEmbeddedMpvSupport = probeWith({ supported: true });
             const { service } = setup(DESKTOP);
diff --git a/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.ts b/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.ts
index 0dddc9e8d..1a17827c1 100644
--- a/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.ts
+++ b/libs/workspace/shell/util/src/lib/settings-search/settings-search.service.ts
@@ -3,7 +3,10 @@ import { Router } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { VodSourceDiscoveryService } from '@iptvnator/portal/shared/data-access';
 import { RuntimeCapabilitiesService } from '@iptvnator/services';
-import { EmbeddedMpvSupport } from '@iptvnator/shared/interfaces';
+import {
+    EmbeddedMpvSupport,
+    watchEmbeddedMpvSupport,
+} from '@iptvnator/shared/interfaces';
 import { SETTINGS_SEARCH_ENTRIES } from './settings-search-entries';
 import { rankSearchMatch, tokenizeSearchQuery } from './settings-search-rank';
 import {
@@ -62,13 +65,51 @@ export class SettingsSearchService {
     }
 
     /**
-     * Probes embedded MPV support once so rows that need it become
-     * searchable. Returns the pending probe, or `undefined` when there is
-     * nothing to wait for. Call it lazily (palette open, settings page),
-     * never from shell bootstrap: supported desktop builds may load the
-     * native addon while answering.
+     * Probes embedded MPV support so rows that need it become searchable.
+     * Returns the pending probe, or `undefined` when there is nothing to
+     * wait for. Call it lazily (palette open), never from shell bootstrap:
+     * supported desktop builds may load the native addon while answering.
+     * Only a final answer is kept; after an inconclusive one, or a failed
+     * request, the next call asks again.
      */
     ensureEmbeddedMpvSupportLoaded(): Promise<void> | undefined {
+        const getSupport = this.embeddedMpvSupportProbe();
+        if (!getSupport) {
+            return undefined;
+        }
+
+        this.embeddedMpvSupportLoad ??= getSupport()
+            .then((support) => this.takeEmbeddedMpvSupport(support))
+            .catch(() => this.takeEmbeddedMpvSupport(null))
+            .finally(() => {
+                this.embeddedMpvSupportLoad = undefined;
+            });
+        return this.embeddedMpvSupportLoad;
+    }
+
+    /**
+     * For a surface that keeps showing these rows (the settings page): probes
+     * like `ensureEmbeddedMpvSupportLoaded()` and follows an inconclusive
+     * answer until it is final, so the rows appear by themselves. Returns
+     * the function that ends it; call it when the surface goes away, so
+     * nothing keeps asking for an answer no one shows.
+     */
+    followEmbeddedMpvSupport(): () => void {
+        const getSupport = this.embeddedMpvSupportProbe();
+        if (!getSupport) {
+            return () => undefined;
+        }
+
+        return watchEmbeddedMpvSupport(
+            getSupport,
+            (support) => this.takeEmbeddedMpvSupport(support),
+            () => this.takeEmbeddedMpvSupport(null)
+        );
+    }
+
+    /** The support request, or `undefined` when there is nothing to ask. */
+    private embeddedMpvSupportProbe():
+        (() => Promise<EmbeddedMpvSupport>) | undefined {
         if (this.embeddedMpvSupportChecked) {
             return undefined;
         }
@@ -83,14 +124,13 @@ export class SettingsSearchService {
             return undefined;
         }
 
-        this.embeddedMpvSupportLoad ??= electron
-            .getEmbeddedMpvSupport()
-            .then((support) => this.embeddedMpvSupport.set(support))
-            .catch(() => this.embeddedMpvSupport.set(null))
-            .finally(() => {
-                this.embeddedMpvSupportChecked = true;
-            });
-        return this.embeddedMpvSupportLoad;
+        return () => electron.getEmbeddedMpvSupport();
+    }
+
+    private takeEmbeddedMpvSupport(support: EmbeddedMpvSupport | null): void {
+        this.embeddedMpvSupport.set(support);
+        this.embeddedMpvSupportChecked =
+            support !== null && !support.inconclusive;
     }
 
     /**
diff --git a/tools/nx/check-font-weights.mjs b/tools/nx/check-font-weights.mjs
index c112d133d..2f26d2b26 100644
--- a/tools/nx/check-font-weights.mjs
+++ b/tools/nx/check-font-weights.mjs
@@ -73,7 +73,9 @@ import {
  * the callables their named arguments go to are followed by name (`-` and `_`
  * alike), through `@forward … as prefix-*` and its `show`/`hide` lists too.
  * A parameter default counts where a call leaves it out, or when no call is
- * in sight. A weight set from code is read per value it can take, so a
+ * in sight; against the JetBrains Mono cap, only a call that meets that
+ * family passes a weight (one in a mixin another module includes always
+ * may). A weight set from code is read per value it can take, so a
  * condition's numbers are not weights, a template literal as each text its
  * literal `${…}` parts produce (`` `65${0}` `` is 650; a weight it builds
  * around another value is computed), and CSS text that a string leaves to
@@ -94,35 +96,45 @@ import {
  * A stylesheet rule set in JetBrains Mono (its own `font-family` or `font`,
  * written out or through variables, or one a nested rule inherits; see
  * `familiesOf`) is capped at `MONO_WEIGHT_CAP`. A mixin's top-level
- * declarations land where this file includes it, in the order Sass writes
- * them out, a content block's too where the mixin places `@content` at its
- * top level, a rule this file `@extend`s whole applies to its extenders, and
- * a keyframe's declarations (of its last definition) apply where a rule's
- * last `animation` runs it, over the rule's own and under `!important` ones,
- * while it runs and, unless it holds a frame (`forwards`, `both`,
- * `infinite`), the rule's own after. An `:is()` or `:where()` reads as the
- * selectors it holds (`:where(.p) .c` is `.p .c`). A rule also sets the
- * family of the narrower selectors it reaches (`.x` for `.x:hover`, `.p .x`
- * for `.w .p .x:hover`), compound by compound across what its combinators
- * allow; of those, the element's own rule and `*`, the cascade winner counts
- * (`!important`, layer, specificity, source order; a `@layer` always
- * applies, and `revert-layer` falls back past its own). Without a family of
- * its own, a rule takes one from an ancestor its compiled selector names (an
- * `@at-root` rule's as Sass writes it out), else from the document root
- * (`:host`, `body`, `html`, `:root`) in its file; a family applies under
- * conditions (`@media`, `@supports`, `@if`) that the reader shares, or
- * always. Sass conditions are not evaluated: each `@if`/`@else` branch
- * counts as one that may run, in a rule, a mixin or a content block alike.
+ * declarations land where it is included, in the order Sass writes them
+ * out: in its own file, as the definition in scope when the include runs
+ * (a rule's declared before it, a mixin body's where that mixin is
+ * included), or in another module that includes its last definition by a
+ * name Sass resolves to it (`ns.m`,
+ * through `@forward` prefixes and `show`/`hide`, or a bare `m` that
+ * `@use … as *` or `@import` brings in; see `scanWorkspace`). There its weights meet the including rule's family,
+ * reported once at the mixin's own line, and its family becomes that
+ * rule's. A content block lands too where a mixin of the same file places
+ * `@content` at its top level, a rule this file `@extend`s whole applies to
+ * its extenders, and a keyframe's declarations (of its last definition)
+ * apply where a rule's last `animation` runs it, over the rule's own and
+ * under `!important` ones, while it runs and, unless it holds a frame
+ * (`forwards`, `both`, `infinite`), the rule's own after. An `:is()` or
+ * `:where()` reads as the selectors it holds (`:where(.p) .c` is `.p .c`).
+ * A rule also sets the family of the narrower selectors it reaches (`.x`
+ * for `.x:hover`, `.p .x` for `.w .p .x:hover`), compound by compound
+ * across what its combinators allow; of those, the element's own rule and
+ * `*`, the cascade winner counts (`!important`, layer, specificity, source
+ * order; a `@layer` always applies, and `revert-layer` falls back past its
+ * own). Without a family of its own, a rule takes one from an ancestor its
+ * compiled selector names (an `@at-root` rule's as Sass writes it out),
+ * else from the document root (`:host`, `body`, `html`, `:root`) in its
+ * file; a family applies under conditions (`@media`, `@supports`, `@if`)
+ * that the reader shares, or always. Sass conditions are not evaluated: each
+ * `@if`/`@else` branch counts as one that may run, in a rule, a mixin or a
+ * content block alike.
  *
  * Not traced: global styles in another file, a weight inherited from another
- * rule, a mixin from another module, a mixin's nested rules and at-rules
- * (and a `@content` placed in one), a family set on an element from code,
- * and one that reaches only some of a rule's elements (a more specific
- * `.x.active`, or `@extend .m` into `.m.active`). Animations are read as a
- * whole: a keyframe's steps cascade as one rule rather than as states in
- * turn, a rule's last `animation` runs whatever an earlier `!important` one
- * sets, one layer holding a frame holds all of them, and a quoted name is
- * read word by word.
+ * rule, a mixin's nested rules and at-rules (and a `@content` placed in one,
+ * or in another module's mixin), a mixin name that two `@import`ed files
+ * define (the later wins), a custom property a mixin's family reads
+ * (resolved where the mixin is written, not on the rule that includes it),
+ * a family set on an element from code, and one that reaches only some of a
+ * rule's elements (a more specific `.x.active`, or `@extend .m` into
+ * `.m.active`). Animations are read as a whole: a keyframe's steps cascade
+ * as one rule rather than as states in turn, a rule's last `animation` runs
+ * whatever an earlier `!important` one sets, one layer holding a frame
+ * holds all of them, and a quoted name is read word by word.
  */
 export const WEIGHT_SCALE = Object.freeze([400, 500, 600, 700]);
 
@@ -886,17 +898,41 @@ function callSitesOf(text, blocks) {
     return calls;
 }
 
+/**
+ * An `@include` of a mixin: `ns.name` names another module's, as does a
+ * bare name that no mixin of the including file has.
+ */
+const INCLUDE = /@include\s+(?:([\w-]+)\.)?([\w-]+)(?![\w.-])/g;
+
 /**
  * One file's weight declarations: off-scale findings, the custom properties
  * and Sass variables its weights refer to, and every such variable it defines
  * (checked later, once the whole workspace has named what it refers to).
  * A keyframe that sets a font only while it runs is read both ways: its
  * frames over the rule that runs it, and that rule after it.
+ * Its module mixins' top-level families and weights (`mixins`) land where
+ * other modules include them, and theirs here: `included` gives, by the
+ * position of each such `@include` (`includes`), the mixins it reaches, and
+ * `elsewhere` names this file's mixins that other modules include (see
+ * `scanWorkspace`). A mixin read both ways carries the second (`after`), so
+ * a module that includes it reads it both ways too.
  */
-export function scanWeights(file, written) {
-    const running = scanPass(file, written, true);
-    if (!running.transient) return running;
-    const after = scanPass(file, written, false);
+export function scanWeights(file, written, modules = {}) {
+    const { included = new Map() } = modules;
+    const running = scanPass(file, written, true, modules);
+    const mixins = [...included.values()].flat();
+    if (!running.transient && !mixins.some((mixin) => mixin.after)) {
+        return running;
+    }
+    const after = scanPass(file, written, false, {
+        ...modules,
+        included: new Map(
+            [...included].map(([site, reached]) => [
+                site,
+                reached.map((mixin) => mixin.after ?? mixin),
+            ])
+        ),
+    });
     const keyOf = (item) => JSON.stringify(item);
     const union = (a, b) => [
         ...new Map([...a, ...b].map((item) => [keyOf(item), item])).values(),
@@ -905,10 +941,35 @@ export function scanWeights(file, written) {
         ...running,
         findings: union(running.findings, after.findings),
         deferred: union(running.deferred, after.deferred),
+        // A call meets the families of either reading.
+        includeCalls: new Map(
+            [...running.includeCalls].map(([index, call]) => {
+                const other = after.includeCalls.get(index);
+                return [
+                    index,
+                    {
+                        ...call,
+                        mono: call.mono || Boolean(other?.mono),
+                        families: union(call.families, other?.families ?? []),
+                    },
+                ];
+            })
+        ),
+        mixins: new Map(
+            [...running.mixins].map(([name, mixin]) => [
+                name,
+                { ...mixin, after: after.mixins.get(name) },
+            ])
+        ),
     };
 }
 
-function scanPass(file, written, transient) {
+function scanPass(
+    file,
+    written,
+    transient,
+    { included = new Map(), elsewhere = new Set() }
+) {
     // Read as the browser reads it (markup references and CSS escapes
     // decoded); lines are the file's own.
     const { text: source, origin } = decodeSource(file, written);
@@ -1067,12 +1128,52 @@ function scanPass(file, written, transient) {
             selectors: selectorsOf(place.scopes),
         });
     const monoAt = stylesheet
-        ? familiesOf(lexed, blocks, {
-              ...{ inString, placeOf, refsIn, rulesOf, transient },
-          })
+        ? familiesOf(
+              lexed,
+              blocks,
+              { inString, placeOf, refsIn, rulesOf, transient },
+              {
+                  included: new Map(
+                      [...included].map(([site, mixins]) => [
+                          site,
+                          mixins.flatMap((mixin) => mixin.families),
+                      ])
+                  ),
+                  elsewhere,
+              }
+          )
         : Object.assign(() => ({ mono: false, refs: [] }), {
-              landings: () => [],
+              ...{ landings: () => [], landingsAt: () => [] },
+              ...{ memberOf: () => null, exported: new Map() },
+              ...{ definitionsAt: () => ({ defs: [], open: true }) },
+              callAt: () => null,
           });
+    // Where a family declaration sits, for its variables to resolve later
+    // there; one from another module's mixin carries its own.
+    const siteOf = (entry) =>
+        entry.at.file
+            ? entry.at
+            : {
+                  ...{ ...entry.at, file },
+                  guards: guardsAt(entry.at.index),
+                  rule: blockAt.get(entry.at.scope)?.prelude ?? null,
+                  selectors: selectorsOf(entry.at.scopes ?? []),
+              };
+    // A weight's terms and variables as a JetBrains Mono rule caps them,
+    // with where to report them.
+    const capped = (name, index, mode, value) => {
+        const analysis = analyse(mode, value, { cap: MONO_WEIGHT_CAP });
+        const place = placeOf(blocks, index);
+        return {
+            ...{ file, line: lineOf(index), name },
+            terms: analysis.terms.filter(capOnly),
+            references: analysis.references.map((reference) => ({
+                ...{ ...reference, file, index },
+                ...{ scopes: place.scopes, callable: place.callable },
+                inCallable: place.inCallable,
+            })),
+        };
+    };
     // Weights in rules whose family is named through variables: capped once
     // that family resolves to JetBrains Mono.
     const deferred = [];
@@ -1080,15 +1181,31 @@ function scanPass(file, written, transient) {
     // shorthand): a later one, unless only the earlier is `!important`,
     // replaces it, so only the one in effect meets the cap.
     const setters = new Map();
+    // The weight declarations landing in this file's module mixins (one of
+    // another module's too), for the modules that include them, and how
+    // this file's own read where a JetBrains Mono rule caps them.
+    const setInMixins = [];
+    const weightAt = new Map();
     // A weight declaration registers in each rule it lands in (a mixin's
-    // where it is included), at the place it lands.
-    const setAt = (index, important) => {
-        // A keyframe's weight, where a rule runs it, outranks the rule's own.
-        for (const { rules, key, animated } of monoAt.landings(index)) {
+    // where it is included), at the place it lands; `id` is its position,
+    // or for another module's, its file and position there. A keyframe's
+    // weight, where a rule runs it, outranks the rule's own (`animated`, on
+    // the way to a mixin another module includes, or here).
+    const setAt = (id, important, landings, weight = null, ran = false) => {
+        for (const landing of landings) {
+            const { rules, key, scope, animated: here } = landing;
+            const animated = ran || Boolean(here);
             for (const rule of rules) {
                 if (!setters.has(rule)) setters.set(rule, []);
                 const level = levelOf({ important, animated });
-                setters.get(rule).push({ key, index, level });
+                setters.get(rule).push({ key, index: id, level });
+            }
+            const mixin = monoAt.memberOf(scope);
+            if (mixin !== null && landing.external !== false) {
+                setInMixins.push({
+                    ...{ mixin, key, id },
+                    ...{ important, animated, weight },
+                });
             }
         }
     };
@@ -1109,15 +1226,30 @@ function scanPass(file, written, transient) {
         if (match[1].toLowerCase() === 'weight' && namespace === undefined) {
             continue;
         }
-        setAt(match.index, IMPORTANT.test(value));
+        setAt(match.index, IMPORTANT.test(value), monoAt.landings(match.index));
     }
     // An `all` reset replaces an earlier weight too.
     for (const match of stylesheet ? text.matchAll(ALL_RESET) : []) {
         if (inString(match.index) || inConditionPrelude(lexed, match.index)) {
             continue;
         }
-        if (startsDeclaration(text, match.index))
-            setAt(match.index, Boolean(match[2]));
+        if (startsDeclaration(text, match.index)) {
+            const landings = monoAt.landings(match.index);
+            setAt(match.index, Boolean(match[2]), landings);
+        }
+    }
+    // Another module's mixin sets its weights where this file includes it.
+    const landed = [...included].flatMap(([site, mixins]) =>
+        mixins.flatMap((mixin) =>
+            mixin.setters.map((setter) => ({
+                ...{ site, setter },
+                landings: monoAt.landingsAt(site, setter.key),
+            }))
+        )
+    );
+    for (const { setter, landings } of landed) {
+        const { id, important, weight, animated } = setter;
+        setAt(id, important, landings, weight, animated);
     }
 
     // A shorthand that fails to parse is dropped, so it sets nothing.
@@ -1126,8 +1258,8 @@ function scanPass(file, written, transient) {
     // replaces it and nothing earlier outranks it (`!important`): the
     // scopes of those landings, the only ones whose family it meets.
     const after = (a, b) => keyOrder(a.key, b.key) > 0;
-    const effectiveIn = (index) => {
-        const landings = monoAt.landings(index).filter(({ rules, key }) =>
+    const effectiveIn = (index, landings = monoAt.landings(index)) => {
+        const kept = landings.filter(({ rules, key }) =>
             rules.some((id) => {
                 const rule = setters.get(id) ?? [];
                 const own = rule.find(
@@ -1147,7 +1279,7 @@ function scanPass(file, written, transient) {
                 );
             })
         );
-        return new Set(landings.map(({ scope }) => scope));
+        return new Set(kept.map(({ scope }) => scope));
     };
 
     // CSS text in a string (an inline `style="…"`, a component style) meets
@@ -1247,26 +1379,45 @@ function scanPass(file, written, transient) {
             const cssOf = (text) => analyse(mode, text, { cap });
             record(name, match.index, merged((texts ?? [css]).map(cssOf)));
             if (!family.mono && family.refs.length > 0) {
-                const capped = analyse(mode, value, { cap: MONO_WEIGHT_CAP });
-                const place = placeOf(blocks, match.index);
                 deferred.push({
-                    ...{ file, line: lineOf(match.index), name },
+                    ...capped(name, match.index, mode, value),
                     family: family.text,
                     shorthand: family.shorthand,
-                    at: {
-                        ...{ ...family.at, file },
-                        guards: guardsAt(family.at.index),
-                        rule: blockAt.get(family.at.scope)?.prelude ?? null,
-                        selectors: selectorsOf(family.at.scopes ?? []),
-                    },
-                    terms: capped.terms.filter(capOnly),
-                    references: capped.references.map((reference) => ({
-                        ...{ ...reference, file, index: match.index },
-                        ...{ scopes: place.scopes, callable: place.callable },
-                        inCallable: place.inCallable,
-                    })),
+                    at: siteOf(family),
                 });
             }
+            if (stylesheet && weightName) {
+                weightAt.set(match.index, () =>
+                    capped(name, match.index, mode, value)
+                );
+            }
+        }
+    }
+    // Another module's weight landing here meets the family of the rule
+    // that includes it, and is reported where it is written.
+    for (const { site, setter, landings } of landed) {
+        const { id, weight } = setter;
+        if (!weight) continue;
+        const effective = effectiveIn(id, landings);
+        const family =
+            effective.size > 0
+                ? monoAt(site, (scope) => effective.has(scope))
+                : { mono: false, refs: [] };
+        // Reported once, however many rules it lands in.
+        const terms = weight.terms.map((term) => ({ ...term, landed: true }));
+        if (family.mono) {
+            const { file: from, line, name } = weight;
+            findings.push(
+                ...terms.map((term) => ({ file: from, line, name, ...term }))
+            );
+            references.push(...weight.references);
+        } else if (family.refs.length > 0) {
+            deferred.push({
+                ...{ ...weight, terms },
+                family: family.text,
+                shorthand: family.shorthand,
+                at: siteOf(family),
+            });
         }
     }
     // A weight set from code is checked here; any other custom property it
@@ -1517,12 +1668,70 @@ function scanPass(file, written, transient) {
             references: analyses.flatMap((analysis) => analysis.references),
         });
     }
+    // This file's module mixins as a module that includes one sees them:
+    // the families and weights they set at their top level, each at its
+    // place in the mixin (`key`), a family with where to resolve it.
+    const mixins = new Map();
+    for (const block of blocks.filter((b) => b.kind === 'callable')) {
+        const name = monoAt.memberOf(block.start);
+        if (name !== null && !mixins.has(name)) {
+            mixins.set(name, { families: [], setters: [] });
+        }
+    }
+    const portable = new Map();
+    const portableOf = (entry) => {
+        if (!portable.has(entry)) {
+            portable.set(entry, { ...entry, at: siteOf(entry) });
+        }
+        return portable.get(entry);
+    };
+    for (const [name, families] of monoAt.exported) {
+        mixins.get(name)?.families.push(
+            ...families.map(({ key, entry }) => ({
+                key,
+                entry: portableOf(entry),
+            }))
+        );
+    }
+    for (const { mixin, key, id, important, animated, weight } of setInMixins) {
+        const own = typeof id === 'number';
+        mixins.get(mixin)?.setters.push({
+            ...{ key, important, animated, id: own ? `${file}:${id}` : id },
+            weight: own ? (weightAt.get(id)?.() ?? null) : weight,
+        });
+    }
+    // Where it includes another module's mixin (see `INCLUDE`): a bare
+    // name runs one of this file's own where one is in scope there.
+    const includes = [];
+    for (const match of stylesheet ? text.matchAll(INCLUDE) : []) {
+        if (inString(match.index)) continue;
+        const namespace = match[1] ?? null;
+        const name = match[2].replace(/_/g, '-');
+        const { defs, open } = monoAt.definitionsAt(name, match.index);
+        if (namespace === null && defs.length > 0 && !open) continue;
+        includes.push({ index: match.index, callee: { name, namespace } });
+    }
     const loads = stylesheet ? extractStylesheetLoads(source) : [];
     const calls = callSitesOf(text, blocks);
     const invocations = stylesheet ? invocationsOf(lexed) : [];
+    // Each `@include` here, by position, with the families it meets (see
+    // `callAt` in `familiesOf`): a parameter capped for JetBrains Mono takes
+    // only the arguments of a call that meets one.
+    const includeCalls = new Map();
+    for (const { index, paren } of invocations) {
+        if (!/^@include\b/.test(text.slice(index, index + 8))) continue;
+        const { mono, families } = monoAt.callAt(index);
+        includeCalls.set(index, {
+            ...{ paren, mono },
+            families: families.map((entry) => ({
+                ...{ text: entry.text, shorthand: entry.shorthand },
+                at: siteOf(entry),
+            })),
+        });
+    }
     return {
         ...{ file, loads, declarations, findings, references, definitions },
-        ...{ calls, invocations, deferred },
+        ...{ calls, invocations, deferred, mixins, includes, includeCalls },
         transient: Boolean(monoAt.transient),
     };
 }
@@ -1539,7 +1748,8 @@ function scanPass(file, written, transient) {
 export function findIndirectWeights(scans) {
     const definitions = scans.flatMap((scan) => scan.definitions);
     const pending = scans.flatMap((scan) => scan.references);
-    const { qualified, unqualified, imports, loadsOf } = sassScopes(scans);
+    const { qualified, unqualified, imports, loadsOf, reaches } =
+        sassScopes(scans);
     const callsByFile = new Map(scans.map((scan) => [scan.file, scan.calls]));
     // Whether a declaration is what `name` reads, through one of the ways
     // `access` exposes its file (a `@forward` prefix, `show`/`hide`).
@@ -1563,35 +1773,45 @@ export function findIndirectWeights(scans) {
                         : exposedName(exposure, definition.key) === name)
             )
         );
-    // Whether an argument is passed to `callable`, defined in `file`:
-    // `ns.name(` must load `file` (or a module forwarding it) as `ns`, under
-    // the name it exposes `callable` by; a bare `name(` is defined in the
-    // caller itself or in what it brings in.
-    const passedTo = ({ callee, file: caller }, file, callable) => {
-        if (!callee || !callable) return false;
-        if (!callee.namespace && caller === file) {
-            return callee.name === callable;
-        }
-        const scope = callee.namespace
-            ? qualified(caller, callee.namespace)
-            : unqualified(caller);
-        const access = scope.get(file);
-        return (
-            Boolean(access?.declarations) &&
-            access.exposures.some(
-                (exposure) => exposedName(exposure, callable) === callee.name
-            )
-        );
-    };
+    // Whether an argument is passed to `callable`, defined in `file` (see
+    // `reaches` in `sassScopes`).
+    const passedTo = reaches;
     // A parameter default is the value only at calls that leave it out. A
     // callable with no call in sight may be called from where the scan
     // cannot see, so its defaults count.
     const invocations = scans.flatMap(({ file, invocations: calls = [] }) =>
         calls.map((call) => ({ ...call, file }))
     );
+    // A parameter that a JetBrains Mono rule caps (`capped`) takes only the
+    // arguments, or default, of an `@include` that meets one (see
+    // `includeCalls` in `scanWeights`); any other call is read as before.
+    const includeCalls = new Map(
+        scans.map(({ file, includeCalls: calls = new Map() }) => [file, calls])
+    );
+    const monoCalls = new Map();
+    const meetsMono = (call) => {
+        if (!call) return true;
+        if (!monoCalls.has(call)) {
+            monoCalls.set(
+                call,
+                call.mono ||
+                    call.families.some((f) =>
+                        familyIsMono(f.text, f.at, new Set(), f.shorthand)
+                    )
+            );
+        }
+        return monoCalls.get(call);
+    };
+    const includeAt = (file, paren) =>
+        [...(includeCalls.get(file)?.values() ?? [])].find(
+            (call) => call.paren === paren
+        );
     const defaultUsed = new Map();
-    const usesDefault = (definition) => {
-        if (defaultUsed.has(definition)) return defaultUsed.get(definition);
+    const usesDefault = (definition, capped = false) => {
+        const id = `${capped}`;
+        if (!defaultUsed.has(definition)) defaultUsed.set(definition, {});
+        const cached = defaultUsed.get(definition);
+        if (id in cached) return cached[id];
         const callable = definition.callee.name;
         const calls = invocations.filter(
             (call) =>
@@ -1606,8 +1826,13 @@ export function findIndirectWeights(scans) {
                     d.callee?.paren === call.paren &&
                     d.key === definition.key
             );
-        const used = calls.length === 0 || calls.some((call) => !names(call));
-        defaultUsed.set(definition, used);
+        const counted = capped
+            ? calls.filter((call) =>
+                  meetsMono(includeCalls.get(call.file)?.get(call.index))
+              )
+            : calls;
+        const used = calls.length === 0 || counted.some((call) => !names(call));
+        cached[id] = used;
         return used;
     };
     // A partial runs only where it is loaded, so its `!default` for a name
@@ -1806,10 +2031,19 @@ export function findIndirectWeights(scans) {
                 if (!visible) return false;
             }
             if (scope) {
+                const capped = Boolean(reference.cap);
                 const passed =
                     definition.key === name &&
                     passedTo(definition, file, reference.callable) &&
-                    (!definition.callee.signature || usesDefault(definition));
+                    (definition.callee.signature
+                        ? usesDefault(definition, capped)
+                        : !capped ||
+                          meetsMono(
+                              includeAt(
+                                  definition.file,
+                                  definition.callee.paren
+                              )
+                          ));
                 const configured = configures(access, definition, name);
                 // A textual importer's later code has not run when this
                 // file's rules render, unless they sit in a mixin body.
@@ -2131,6 +2365,108 @@ export function findIndirectWeights(scans) {
     return findings;
 }
 
+/**
+ * Every file's scan (`sources` holds `{ file, source }`), with the mixins
+ * it includes from other modules landed where it includes them: an
+ * `@include ns.name`, or a bare name that `@use … as *` or `@import` brings
+ * in, resolved as Sass resolves the call (see `sassScopes`). A file that
+ * includes one, or whose mixin another includes, is scanned again with
+ * them, after the modules it includes (Sass rejects a loop of `@use`s; a
+ * file met again on one keeps its first scan).
+ */
+export function scanWorkspace(sources) {
+    const sourceOf = new Map(sources.map(({ file, source }) => [file, source]));
+    const first = new Map(
+        sources.map(({ file, source }) => [file, scanWeights(file, source)])
+    );
+    const { reaches } = sassScopes([...first.values()]);
+    const providers = [...first.values()].filter(
+        (scan) => scan.mixins?.size > 0
+    );
+    // Each file's includes of other modules' mixins, by `@include`, with
+    // the mixins each reaches; and each file's mixins others include.
+    const reached = new Map();
+    const elsewhere = new Map();
+    for (const scan of first.values()) {
+        for (const { index, callee } of scan.includes ?? []) {
+            const call = { callee, file: scan.file };
+            // A file's own definitions land through `familiesOf`.
+            const found = providers
+                .filter(({ file }) => file !== scan.file)
+                .flatMap(({ file, mixins }) =>
+                    [...mixins.keys()]
+                        .filter((name) => reaches(call, file, name))
+                        .map((name) => ({ file, name }))
+                );
+            // Only `@import`s can bring in two mixins of one name (anything
+            // else is a Sass error), and the later one wins; the scan does
+            // not order them, so it leaves such an include out.
+            if (found.length !== 1) continue;
+            if (!reached.has(scan.file)) reached.set(scan.file, new Map());
+            reached.get(scan.file).set(index, found);
+            for (const { file, name } of found) {
+                if (!elsewhere.has(file)) elsewhere.set(file, new Set());
+                elsewhere.get(file).add(name);
+            }
+        }
+    }
+    const done = new Map();
+    const scanning = new Set();
+    const scanOf = (file) => {
+        if (done.has(file)) return done.get(file);
+        const sites = reached.get(file) ?? new Map();
+        const involved = sites.size > 0 || elsewhere.has(file);
+        if (!involved || scanning.has(file)) return first.get(file);
+        scanning.add(file);
+        const included = new Map(
+            [...sites].map(([index, found]) => [
+                index,
+                found.map(({ file: from, name }) =>
+                    scanOf(from).mixins.get(name)
+                ),
+            ])
+        );
+        const scan = scanWeights(file, sourceOf.get(file), {
+            included,
+            elsewhere: elsewhere.get(file),
+        });
+        scanning.delete(file);
+        done.set(file, scan);
+        return scan;
+    };
+    return sources.map(({ file }) => scanOf(file));
+}
+
+/**
+ * Every finding in the workspace (see `scanWorkspace`), and how many weight
+ * declarations it checked. A mixin's weight landing in several JetBrains
+ * Mono rules, in other modules or its own, is reported once.
+ */
+export function findWorkspaceWeights(sources) {
+    const scans = scanWorkspace(sources);
+    const all = [
+        ...scans.flatMap((scan) => scan.findings),
+        ...findIndirectWeights(scans),
+    ];
+    const keyOf = ({ file, line, name, value, cap, computed }) =>
+        JSON.stringify([file, line, name, value, cap, computed]);
+    const seen = new Set(all.filter((f) => !f.landed).map(keyOf));
+    const findings = [];
+    for (const { landed, ...finding } of all) {
+        if (landed) {
+            const key = keyOf(finding);
+            if (seen.has(key)) continue;
+            seen.add(key);
+        }
+        findings.push(finding);
+    }
+    const declarations = scans.reduce(
+        (sum, scan) => sum + scan.declarations,
+        0
+    );
+    return { declarations, findings };
+}
+
 /** Every off-scale weight one file can reach on its own. */
 export function findOffScaleWeights(file, source) {
     const scan = scanWeights(file, source);
@@ -2183,23 +2519,16 @@ if (isMain) {
         .filter(Boolean)
         .filter(isScannedFile);
 
-    const scans = [];
+    const sources = [];
     for (const file of files) {
         const source = await readFile(path.resolve(rootDir, file), 'utf8');
-        scans.push(scanWeights(file, source));
+        sources.push({ file, source });
     }
-    const findings = [
-        ...scans.flatMap((scan) => scan.findings),
-        ...findIndirectWeights(scans),
-    ];
+    const { declarations, findings } = findWorkspaceWeights(sources);
     const diagnostics = [
         ...validateScanCoverage(files),
         ...findings.map(describeFinding),
     ];
-    const declarations = scans.reduce(
-        (sum, scan) => sum + scan.declarations,
-        0
-    );
 
     if (diagnostics.length > 0) {
         console.error('Font weight scale check failed:');
diff --git a/tools/nx/check-font-weights.test.mjs b/tools/nx/check-font-weights.test.mjs
index 84b4fd1fc..79eecf32b 100644
--- a/tools/nx/check-font-weights.test.mjs
+++ b/tools/nx/check-font-weights.test.mjs
@@ -7,6 +7,7 @@ import {
     describeFinding,
     findIndirectWeights,
     findOffScaleWeights,
+    findWorkspaceWeights,
     isScannedFile,
     nearestScaleWeight,
     scanWeights,
@@ -19,6 +20,14 @@ const offScale = (file, source) =>
         ({ line, name, value }) => `${line} ${name}: ${value}`
     );
 
+/** The findings across `files` (`{ path: source }`), scanned together. */
+const workspace = (files) =>
+    findWorkspaceWeights(
+        Object.entries(files).map(([file, source]) => ({ file, source }))
+    ).findings.map(
+        ({ file, line, name, value }) => `${file}:${line} ${name}: ${value}`
+    );
+
 test('flags an off-scale font-weight with its line number', () => {
     const source = ['.title {', '    font-weight: 650;', '}'].join('\n');
 
@@ -3962,6 +3971,576 @@ test('reads mixin weights where they land, through nested includes', () => {
     }
 });
 
+test("lands another module's mixin weights where they are included", () => {
+    const mono = "'JetBrains Mono'";
+    const type = [
+        '@mixin heavy {',
+        '    font-weight: 700;',
+        '}',
+        '@mixin light { font-weight: 400; }',
+        '@mixin firm { font-weight: 700 !important; }',
+        '@mixin settled { font-weight: 700; font-weight: 500; }',
+    ].join('\n');
+    const report = (rules) =>
+        workspace({
+            'libs/w1/_type.scss': type,
+            'libs/w1/c.scss': `@use 'type';\n${rules}`,
+        });
+    const heavy = ['libs/w1/_type.scss:2 font-weight: 700'];
+    for (const [rules, expected] of [
+        [`.x { font-family: ${mono}; @include type.heavy; }`, heavy],
+        [`.x { font-family: Roboto; @include type.heavy; }`, []],
+        // At the `@include`, in Sass's output order with the rule's own.
+        [
+            `.x { font-family: ${mono}; @include type.heavy; font-weight: 500; }`,
+            [],
+        ],
+        [
+            `.x { font-family: ${mono}; font-weight: 500; @include type.heavy; }`,
+            heavy,
+        ],
+        [`.x { @include type.heavy; font-family: ${mono}; }`, heavy],
+        [
+            `.x { font-family: ${mono}; @include type.heavy; @include type.light; }`,
+            [],
+        ],
+        [
+            `.x { font-family: ${mono}; @include type.firm; font-weight: 500; }`,
+            ['libs/w1/_type.scss:5 font-weight: 700'],
+        ],
+        // And in its order within the mixin.
+        [`.x { font-family: ${mono}; @include type.settled; }`, []],
+        // A nested rule inherits the family; one named through a variable
+        // is resolved once the workspace is scanned.
+        [`.x { font-family: ${mono}; .y { @include type.heavy; } }`, heavy],
+        [
+            `:root { --face: ${mono}; } .x { font-family: var(--face); @include type.heavy; }`,
+            heavy,
+        ],
+    ]) {
+        assert.deepEqual(report(rules), expected, rules);
+    }
+});
+
+test("reports another module's mixin weight once, at its own line", () => {
+    const mono = "'JetBrains Mono'";
+    const users = {
+        'libs/w2/a.scss': `@use 'type'; .a { font-family: ${mono}; @include type.heavy; }`,
+        'libs/w2/b.scss': [
+            "@use 'type';",
+            `:root { --face: ${mono}; }`,
+            '.b { font-family: var(--face); @include type.heavy; }',
+        ].join('\n'),
+    };
+    const heavy = ['libs/w2/_type.scss:1 font-weight: 700'];
+    assert.deepEqual(
+        workspace({
+            'libs/w2/_type.scss': '@mixin heavy { font-weight: 700; }',
+            ...users,
+        }),
+        heavy
+    );
+    // Its own module includes it in a JetBrains Mono rule too.
+    assert.deepEqual(
+        workspace({
+            'libs/w2/_type.scss': `@mixin heavy { font-weight: 700; } .own { font-family: ${mono}; @include heavy; }`,
+            ...users,
+        }),
+        heavy
+    );
+});
+
+test("gives a rule the family another module's mixin sets there", () => {
+    const mono = "'JetBrains Mono'";
+    const report = (rules, face = `${mono}, monospace`) =>
+        workspace({
+            'libs/w3/_mono.scss': `$face: ${mono}, monospace;\n@mixin face {\n    font-family: ${face};\n}`,
+            'libs/w3/_other.scss': '@mixin face { font-family: Roboto; }',
+            'libs/w3/c.scss': `@use 'mono';\n@use 'other';\n${rules}`,
+        });
+    const heavy = ['libs/w3/c.scss:3 font-weight: 700'];
+    for (const [rules, expected, face] of [
+        [`.x { @include mono.face; font-weight: 700; }`, heavy],
+        [
+            `.x { @include mono.face; font-family: Roboto; font-weight: 700; }`,
+            [],
+        ],
+        [
+            `.x { font-family: Roboto; @include mono.face; font-weight: 700; }`,
+            heavy,
+        ],
+        [`.x { @include mono.face; .y { font-weight: 700; } }`, heavy],
+        [
+            `.x { @include mono.face; &:hover { font-weight: 600; } }`,
+            ['libs/w3/c.scss:3 font-weight: 600'],
+        ],
+        // Named through its own module's variable, resolved there.
+        [`.x { @include mono.face; font-weight: 700; }`, heavy, '$face'],
+        // A namesake in another module is not the mixin included.
+        [`.x { @include other.face; font-weight: 700; }`, []],
+    ]) {
+        assert.deepEqual(report(rules, face), expected, rules);
+    }
+});
+
+test('reads a mixin another module includes where it lands', () => {
+    const mono = "'JetBrains Mono'";
+    const report = (rules) =>
+        workspace({
+            'libs/w4/_badge.scss': `@mixin badge {\n    font-family: ${mono};\n    font-weight: 700;\n}`,
+            'libs/w4/c.scss': `@use 'badge';\n${rules}`,
+        });
+    const heavy = ['libs/w4/_badge.scss:3 font-weight: 700'];
+    assert.deepEqual(
+        report('.x { @include badge.badge; font-family: Roboto; }'),
+        []
+    );
+    assert.deepEqual(report('.x { @include badge.badge; }'), heavy);
+    // Included nowhere, it is read where it is written.
+    assert.deepEqual(report('.x { color: red; }'), heavy);
+});
+
+test("resolves another module's mixin as Sass does", () => {
+    const mono = "'JetBrains Mono'";
+    // A bare name a mixin of the file has is its own.
+    assert.deepEqual(
+        scanWeights(
+            'libs/w5/a.scss',
+            '@mixin m_a { color: red; } .x { @include m-a; @include n_b; @include t.c_d; }'
+        ).includes.map(({ callee }) => callee),
+        [
+            { name: 'n-b', namespace: null },
+            { name: 'c-d', namespace: 't' },
+        ]
+    );
+    const type = { 'libs/w5/_type.scss': '@mixin heavy { font-weight: 700; }' };
+    const heavy = ['libs/w5/_type.scss:1 font-weight: 700'];
+    // Through a `@forward` prefix, and as a bare name `as *` or `@import`
+    // brings in.
+    assert.deepEqual(
+        workspace({
+            ...type,
+            'libs/w5/_theme.scss': "@forward 'type' as type-*;",
+            'libs/w5/c.scss': `@use 'theme'; .x { font-family: ${mono}; @include theme.type-heavy; }`,
+        }),
+        heavy
+    );
+    for (const load of ["@use 'type' as *;", "@import 'type';"]) {
+        assert.deepEqual(
+            workspace({
+                ...type,
+                'libs/w5/c.scss': `${load} .x { font-family: ${mono}; @include heavy; }`,
+            }),
+            heavy,
+            load
+        );
+    }
+    // A mixin that `hide` leaves out is not the one included.
+    assert.deepEqual(
+        workspace({
+            ...type,
+            'libs/w5/_quiet.scss': '@mixin heavy { font-weight: 400; }',
+            'libs/w5/_theme.scss':
+                "@forward 'type' hide heavy;\n@forward 'quiet';",
+            'libs/w5/c.scss': `@use 'theme'; .x { font-family: ${mono}; @include theme.heavy; }`,
+        }),
+        []
+    );
+    // Nor one declared in a rule, which is local to it.
+    assert.deepEqual(
+        workspace({
+            'libs/w5/_type.scss':
+                '@mixin heavy { font-weight: 400; } .p { @mixin heavy { font-weight: 700; } @include heavy; }',
+            'libs/w5/c.scss': `@use 'type'; .x { font-family: ${mono}; @include type.heavy; }`,
+        }),
+        []
+    );
+    // Two `@import`ed files that define it: Sass includes the later one,
+    // which the scan does not order, so neither lands.
+    assert.deepEqual(
+        workspace({
+            'libs/w5/_a.scss': '\n\n@mixin heavy { font-weight: 700; }',
+            'libs/w5/_b.scss': '@mixin heavy { font-weight: 400; }',
+            'libs/w5/c.scss': `@import 'a'; @import 'b'; .x { font-family: ${mono}; @include heavy; }`,
+        }),
+        []
+    );
+});
+
+test("follows another module's mixin through the mixins it includes", () => {
+    const mono = "'JetBrains Mono'";
+    for (const [files, expected] of [
+        // Its family, from a mixin it includes from a third module or its
+        // own.
+        [
+            {
+                'libs/w6/_inner.scss': `@mixin face { font-family: ${mono}; }`,
+                'libs/w6/_outer.scss':
+                    "@use 'inner'; @mixin title { @include inner.face; }",
+                'libs/w6/c.scss':
+                    "@use 'outer'; .x { @include outer.title; font-weight: 700; }",
+            },
+            ['libs/w6/c.scss:1 font-weight: 700'],
+        ],
+        [
+            {
+                'libs/w6/_outer.scss': `@mixin face { font-family: ${mono}; } @mixin title { @include face; }`,
+                'libs/w6/c.scss':
+                    "@use 'outer'; .x { @include outer.title; font-weight: 700; }",
+            },
+            ['libs/w6/c.scss:1 font-weight: 700'],
+        ],
+        // In the order Sass writes them out, wherever each is declared.
+        [
+            {
+                'libs/w6/_outer.scss': `@mixin title { @include face; font-family: ${mono}; } @mixin face { font-family: Roboto; }`,
+                'libs/w6/c.scss':
+                    "@use 'outer'; .x { @include outer.title; font-weight: 700; }",
+            },
+            ['libs/w6/c.scss:1 font-weight: 700'],
+        ],
+        // Its weight, from a third module's mixin.
+        [
+            {
+                'libs/w6/_inner.scss': '@mixin heavy { font-weight: 700; }',
+                'libs/w6/_outer.scss':
+                    "@use 'inner'; @mixin title { @include inner.heavy; }",
+                'libs/w6/c.scss': `@use 'outer'; .x { font-family: ${mono}; @include outer.title; }`,
+            },
+            ['libs/w6/_inner.scss:1 font-weight: 700'],
+        ],
+    ]) {
+        assert.deepEqual(workspace(files), expected, JSON.stringify(files));
+    }
+});
+
+test("reads another module's mixin while its animation runs and after", () => {
+    const mono = "'JetBrains Mono'";
+    const anim = {
+        'libs/w8/_anim.scss': [
+            `@keyframes face { from { font-family: ${mono}; } }`,
+            '@keyframes swap { from { font-family: Roboto; } }',
+            '@keyframes heavy { from { font-weight: 700; } }',
+            '@mixin mono-hold { animation: face 1s forwards; }',
+            '@mixin roboto-while { animation: swap 1s; }',
+            '@mixin heavy { animation: heavy 1s; }',
+            `@mixin mono { font-family: ${mono}; }`,
+        ].join('\n'),
+        'libs/w8/_outer.scss':
+            "@use 'anim'; @mixin title { @include anim.roboto-while; }",
+    };
+    const report = (rules) =>
+        workspace({ ...anim, 'libs/w8/c.scss': `@use 'anim';\n${rules}` });
+    const own = ['libs/w8/c.scss:2 font-weight: 700'];
+    for (const [rules, expected] of [
+        // A frame it holds sets the family over the rule's own.
+        [
+            `.x { font-family: Roboto; @include anim.mono-hold; font-weight: 700; }`,
+            own,
+        ],
+        // One it only runs leaves the rule its own family after, also
+        // through a third module's mixin.
+        [
+            `.x { font-family: ${mono}; @include anim.roboto-while; font-weight: 700; }`,
+            own,
+        ],
+        [
+            `.x { font-family: Roboto; @include anim.roboto-while; font-weight: 700; }`,
+            [],
+        ],
+        // Its family in a keyframe here outranks the rule's own too.
+        [
+            `@keyframes k { from { @include anim.mono; } } .x { animation: k 1s forwards; font-family: Roboto; font-weight: 700; }`,
+            own,
+        ],
+        [
+            `@use 'outer'; .x { font-family: ${mono}; @include outer.title; font-weight: 700; }`,
+            own,
+        ],
+        // A keyframe's weight outranks the rule's own while it runs, a
+        // later one too.
+        [
+            `.x { font-family: ${mono}; font-weight: 500; @include anim.heavy; }`,
+            ['libs/w8/_anim.scss:3 font-weight: 700'],
+        ],
+        [
+            `.x { font-family: ${mono}; @include anim.heavy; font-weight: 500; }`,
+            ['libs/w8/_anim.scss:3 font-weight: 700'],
+        ],
+    ]) {
+        assert.deepEqual(report(rules), expected, rules);
+    }
+});
+
+test("caps a named argument another module's mixin sets a weight from", () => {
+    const mono = "'JetBrains Mono'";
+    const report = (mixin, rules) =>
+        workspace({
+            'libs/w7/_type.scss': mixin,
+            'libs/w7/c.scss': `@use 'type';\n${rules}`,
+        });
+    assert.deepEqual(
+        report(
+            '@mixin heavy($w: 400) { font-weight: $w; }',
+            `.x {\n    font-family: ${mono};\n    @include type.heavy($w: 700);\n}`
+        ),
+        ['libs/w7/c.scss:4 $w: 700']
+    );
+    // Its default, where the call leaves it out.
+    assert.deepEqual(
+        report(
+            '@mixin heavy($w: 700) { font-weight: $w; }',
+            `.x { font-family: ${mono}; @include type.heavy; }`
+        ),
+        ['libs/w7/_type.scss:1 $w: 700']
+    );
+});
+
+test('runs the definition of a mixin Sass resolves at each include', () => {
+    const mono = "'JetBrains Mono'";
+    const heavy = {
+        'libs/w9/_type.scss': '@mixin heavy { font-weight: 700; }',
+    };
+    const imported = ['libs/w9/_type.scss:1 font-weight: 700'];
+    for (const [files, expected] of [
+        // One declared in a rule is visible there, once declared; elsewhere
+        // the name runs the one brought in.
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *;\n.p { @mixin heavy { font-weight: 400; } @include heavy; }\n.x { font-family: ${mono}; @include heavy; }`,
+            },
+            imported,
+        ],
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *; .p { font-family: ${mono}; @mixin heavy { font-weight: 400; } @include heavy; }`,
+            },
+            [],
+        ],
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *; .p { font-family: ${mono}; @include heavy; @mixin heavy { font-weight: 400; } }`,
+            },
+            imported,
+        ],
+        // A rule runs the definition declared before it.
+        [
+            {
+                'libs/w9/c.scss': `@mixin m { font-weight: 700; } .x { font-family: ${mono}; @include m; } @mixin m { font-weight: 400; }`,
+            },
+            ['libs/w9/c.scss:1 font-weight: 700'],
+        ],
+        [
+            {
+                'libs/w9/c.scss': `@mixin m { font-weight: 700; } @mixin m { font-weight: 400; } .x { font-family: ${mono}; @include m; }`,
+            },
+            [],
+        ],
+        // A mixin body runs the definition in scope where it is included.
+        [
+            {
+                'libs/w9/c.scss': `@mixin m { font-weight: 700 !important; }\n@mixin m { font-weight: 400; }\n@mixin outer { @include m; }\n.x { font-family: ${mono}; @include outer; }`,
+            },
+            [],
+        ],
+        [
+            {
+                'libs/w9/c.scss': `@mixin m { font-weight: 700; }\n@mixin outer { @include m; }\n.x { font-family: ${mono}; @include outer; }\n@mixin m { font-weight: 400; }\n.y { font-family: Roboto; @include outer; }`,
+            },
+            ['libs/w9/c.scss:1 font-weight: 700'],
+        ],
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *;\n@mixin outer { @include heavy; }\n.x { font-family: ${mono}; @include outer; }\n@mixin heavy { font-weight: 400; }`,
+            },
+            imported,
+        ],
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *;\n@mixin outer { @include heavy; }\n@mixin heavy { font-weight: 400; }\n.x { font-family: ${mono}; @include outer; }`,
+            },
+            [],
+        ],
+        // Where it is included both before and after a local definition,
+        // each include runs its own.
+        [
+            {
+                ...heavy,
+                'libs/w9/c.scss': `@use 'type' as *;\n@mixin outer { @include heavy; }\n.x { font-family: ${mono}; @include outer; }\n@mixin heavy { font-weight: 400; }\n.y { font-family: Roboto; @include outer; }`,
+            },
+            imported,
+        ],
+        [
+            {
+                'libs/w9/_firm.scss':
+                    '@mixin heavy { font-weight: 700 !important; }',
+                'libs/w9/c.scss': `@use 'firm' as *;\n@mixin outer { @include heavy; }\n.x { font-family: Roboto; @include outer; }\n@mixin heavy { font-weight: 400; }\n.y { font-family: ${mono}; @include outer; }`,
+            },
+            [],
+        ],
+        [
+            {
+                'libs/w9/c.scss': `@mixin w { @content; font-weight: 400; }\n@mixin outer { @include w { font-weight: 700; } }\n.x { font-family: ${mono}; @include outer; }\n@mixin w { font-weight: 400; @content; }\n.y { font-family: Roboto; @include outer; }`,
+            },
+            [],
+        ],
+        // A call in a definition that does not run passes nothing.
+        [
+            {
+                'libs/w9/c.scss': `@mixin w($weight) { font-weight: $weight; }\n@mixin m { @include w($weight: 700); }\n@mixin outer { @include m; }\n.x { font-family: Roboto; @include outer; }\n@mixin m { @include w($weight: 400); }\n.y { font-family: ${mono}; @include outer; }`,
+            },
+            [],
+        ],
+        // Included from another module, once its own module has run.
+        [
+            {
+                ...heavy,
+                'libs/w9/_c.scss':
+                    "@use 'type' as *;\n@mixin outer { @include heavy; }\n@mixin heavy { font-weight: 400; }",
+                'libs/w9/d.scss': `@use 'c'; .x { font-family: ${mono}; @include c.outer; }`,
+            },
+            [],
+        ],
+        [
+            {
+                ...heavy,
+                'libs/w9/_c.scss':
+                    "@use 'type' as *;\n@mixin outer { @include heavy; }",
+                'libs/w9/d.scss': `@use 'c'; .x { font-family: ${mono}; @include c.outer; }`,
+            },
+            imported,
+        ],
+        // A content block goes where that definition places `@content`.
+        [
+            {
+                'libs/w9/c.scss': `@mixin w { @content; font-weight: 500; } .x { font-family: ${mono}; @include w { font-weight: 700; } } @mixin w { font-weight: 500; @content; }`,
+            },
+            [],
+        ],
+        // Another module sees the last definition only.
+        [
+            {
+                'libs/w9/_t.scss': `@mixin m { font-family: ${mono}; }\n@mixin m { font-weight: 700; }`,
+                'libs/w9/c.scss': "@use 't'; .x { @include t.m; }",
+            },
+            [],
+        ],
+        [
+            {
+                'libs/w9/_t.scss':
+                    '@mixin m { font-weight: 700; }\n@mixin m { font-weight: 400; }',
+                'libs/w9/c.scss': `@use 't'; .x { font-family: ${mono}; @include t.m; }`,
+            },
+            [],
+        ],
+        [
+            {
+                'libs/w9/_t.scss':
+                    '@mixin m { font-weight: 400; }\n@mixin m { font-weight: 700; }',
+                'libs/w9/c.scss': `@use 't'; .x { font-family: ${mono}; @include t.m; }`,
+            },
+            ['libs/w9/_t.scss:2 font-weight: 700'],
+        ],
+        [
+            {
+                'libs/w9/_p.scss':
+                    '@mixin m { font-weight: 700 !important; }\n@mixin outer { @include m; }\n.p { @include outer; }\n@mixin m { font-weight: 400; }',
+                'libs/w9/d.scss': `@use 'p'; .x { font-family: ${mono}; @include p.outer; }`,
+            },
+            [],
+        ],
+    ]) {
+        assert.deepEqual(workspace(files), expected, JSON.stringify(files));
+    }
+});
+
+test('caps a parameter only with what calls in JetBrains Mono rules pass', () => {
+    const mono = "'JetBrains Mono'";
+    const w = (fallback) => ({
+        'libs/w10/_m.scss': `@mixin w($weight: ${fallback}) { font-weight: $weight; }`,
+    });
+    const hops = {
+        'libs/w10/_p.scss':
+            '@mixin inner($weight) { font-weight: $weight; }\n@mixin outer($w: 400) { @include inner($weight: $w); }',
+    };
+    for (const [files, expected] of [
+        // A call in a Roboto rule passes its own weight.
+        [
+            {
+                ...w(400),
+                'libs/w10/c.scss': `@use 'm';\n.a { font-family: ${mono}; @include m.w($weight: 400); }\n.b { font-family: Roboto; @include m.w($weight: 700); }`,
+            },
+            [],
+        ],
+        [
+            {
+                'libs/w10/c.scss': `@mixin w($weight: 400) { font-weight: $weight; }\n.a { font-family: ${mono}; @include w($weight: 400); }\n.b { font-family: Roboto; @include w($weight: 700); }`,
+            },
+            [],
+        ],
+        // Its default counts where a JetBrains Mono call leaves it out.
+        [
+            {
+                ...w(700),
+                'libs/w10/c.scss': `@use 'm';\n.a { font-family: ${mono}; @include m.w($weight: 400); }\n.b { font-family: Roboto; @include m.w; }`,
+            },
+            [],
+        ],
+        [
+            {
+                ...w(700),
+                'libs/w10/c.scss': `@use 'm';\n.a { font-family: ${mono}; @include m.w; }\n.b { font-family: Roboto; @include m.w($weight: 400); }`,
+            },
+            ['libs/w10/_m.scss:1 $weight: 700'],
+        ],
+        // Through a mixin that passes its own parameter on.
+        [
+            {
+                ...hops,
+                'libs/w10/c.scss': `@use 'p';\n.a { font-family: ${mono}; @include p.outer($w: 400); }\n.b { font-family: Roboto; @include p.outer($w: 700); }`,
+            },
+            [],
+        ],
+        [
+            {
+                ...hops,
+                'libs/w10/c.scss': `@use 'p';\n.a { font-family: ${mono}; @include p.outer($w: 700); }\n.b { font-family: Roboto; @include p.outer($w: 400); }`,
+            },
+            ['libs/w10/c.scss:2 $w: 700'],
+        ],
+        // A call's family named through a variable, resolved.
+        [
+            {
+                ...w(400),
+                'libs/w10/c.scss': `@use 'm';\n:root { --f: ${mono}; }\n.a { font-family: var(--f); @include m.w($weight: 700); }`,
+            },
+            ['libs/w10/c.scss:3 $weight: 700'],
+        ],
+        [
+            {
+                ...w(400),
+                'libs/w10/c.scss': `@use 'm';\n:root { --f: Roboto; }\n.a { font-family: var(--f); @include m.w($weight: 700); }\n.b { font-family: ${mono}; @include m.w($weight: 400); }`,
+            },
+            [],
+        ],
+        // Or once a keyframe that sets another family for a while ends.
+        [
+            {
+                ...w(400),
+                'libs/w10/c.scss': `@use 'm';\n:root { --f: ${mono}; }\n@keyframes swap { from { font-family: Roboto; } }\n.a { font-family: var(--f); animation: swap 1s; @include m.w($weight: 700); }`,
+            },
+            ['libs/w10/c.scss:4 $weight: 700'],
+        ],
+    ]) {
+        assert.deepEqual(workspace(files), expected, JSON.stringify(files));
+    }
+});
+
 test("inherits the document root's family", () => {
     const mono = "'JetBrains Mono'";
     const media = '@media (min-width: 1px)';
diff --git a/tools/nx/font-weight-family.mjs b/tools/nx/font-weight-family.mjs
index 2732c64dd..a369a9a96 100644
--- a/tools/nx/font-weight-family.mjs
+++ b/tools/nx/font-weight-family.mjs
@@ -33,6 +33,8 @@ export function fontNamespaceRule(blocks, { scope, scopes }) {
 /** At-rules whose body styles the enclosing rule's own element. */
 const SAME_ELEMENT = /^@(?:media|supports|container|layer|include)\b/i;
 const NONE = Object.freeze({ mono: false, refs: [] });
+/** A family met in another module, which the scan of this one cannot read. */
+const OUTSIDE = Object.freeze({ mono: false, refs: [] });
 
 /**
  * A declaration's whole value, to its `;`: a family list is comma-separated.
@@ -915,13 +917,116 @@ export function keyOrder(a, b) {
  * `monoAt(index)`: the family in effect for a declaration there, from the
  * innermost rule that sets one and that the declaration's rule inherits
  * from. `@font-face` describes a face, so nothing in it is capped.
+ *
+ * Another module's mixin lands too: `included` gives, by the position of
+ * each `@include` of one, the families its top-level declarations set
+ * (`{ key, entry }`, `key` its place in that mixin), and `elsewhere` names
+ * this file's module mixins that another module includes, which style
+ * nothing where they are written (see `scanWorkspace`).
  */
 export function familiesOf(
     lexed,
     blocks,
-    { inString, placeOf, refsIn, rulesOf, transient = true }
+    { inString, placeOf, refsIn, rulesOf, transient = true },
+    { included = new Map(), elsewhere = new Set() } = {}
 ) {
     const family = new Map();
+    // This file's mixins, in source order, with the scope each is declared
+    // in (`null` for the module; one declared in a rule is local to it).
+    const mixins = blocks.filter(
+        (b) => b.kind === 'callable' && /^@mixin\b/i.test(b.prelude)
+    );
+    const declaredIn = new Map(
+        mixins.map((b) => [b.start, placeOf(blocks, b.start).scope])
+    );
+    const named = (name, scope) =>
+        mixins.filter(
+            (b) => b.name === name && declaredIn.get(b.start) === scope
+        );
+    // The outermost callable body between `scope` and `site`, if any: a
+    // site in one runs where that callable is included, not where it is.
+    const deferredBy = (scope, site) =>
+        blocks.find(
+            (b) =>
+                b.kind === 'callable' &&
+                b.start < site &&
+                site < b.end &&
+                (scope === null || b.start > scope)
+        ) ?? null;
+    // When a site runs, as places in the module's own run: itself outside
+    // any mixin body, else where each `@include` of the mixin it sits in
+    // runs, and the module's end (`Infinity`) where another module includes
+    // it or nothing here does.
+    const runsAt = (site, seen = new Set()) => {
+        const callable = deferredBy(null, site);
+        if (!callable) return [site];
+        if (seen.has(callable.start)) return [];
+        const scope = declaredIn.get(callable.start);
+        if (scope === undefined) return [Infinity];
+        const next = new Set([...seen, callable.start]);
+        const sites = (includes.get(callable.name) ?? []).filter((t) =>
+            placeOf(blocks, t).scopes.includes(scope)
+        );
+        const outside =
+            elsewhere.has(memberOf(callable.start)) ||
+            (sites.length === 0 && scope === null);
+        return [
+            ...sites.flatMap((t) => runsAt(t, next)),
+            ...(outside ? [Infinity] : []),
+        ];
+    };
+    // The definition of `name` an `@include` at `site` runs when the module
+    // has run to `point` (see `runsAt`), as Sass resolves it: in the
+    // innermost scope around the site that has declared one by then, the
+    // last; in a mixin body declared in a rule or another mixin, any.
+    const resolveAt = (name, site, point) => {
+        for (const scope of placeOf(blocks, site).scopes) {
+            const declared = named(name, scope);
+            if (declared.length === 0) continue;
+            const deferred = deferredBy(scope, site) !== null;
+            if (deferred && scope !== null) return declared;
+            const by = deferred ? point : site;
+            const ran = declared.filter((b) => b.start < by).slice(-1);
+            if (ran.length > 0) return ran;
+        }
+        return [];
+    };
+    // The definitions an `@include` of `name` at `site` can run, wherever
+    // it runs (`defs`), and whether somewhere none of this file's is in
+    // scope (`open`), so one another module brings in runs.
+    const definitions = new Map();
+    const definitionsAt = (name, site) => {
+        const id = `${name} ${site}`;
+        if (!definitions.has(id)) {
+            const each = runsAt(site).map((point) =>
+                resolveAt(name, site, point)
+            );
+            definitions.set(id, {
+                defs: [...new Set(each.flat())],
+                open: each.some((found) => found.length === 0),
+            });
+        }
+        return definitions.get(id);
+    };
+    // Whether the definitions a landing went through (`{ name, site, def }`,
+    // `def` `null` for another module's) are the ones that run when the
+    // module has run to `point`.
+    const ranAt = (checks, point) =>
+        checks.every(({ name, site, def }) => {
+            const found = resolveAt(name, site, point);
+            return def === null ? found.length === 0 : found.includes(def);
+        });
+    // A module mixin's name, for its last module-level definition: the one
+    // another module includes (one declared in a rule never is).
+    const memberOf = (scope) => {
+        const block = mixins.find((b) => b.start === scope);
+        if (!block) return null;
+        const last = mixins
+            .filter((b) => b.name === block.name)
+            .filter((b) => declaredIn.get(b.start) === null)
+            .at(-1);
+        return last === block ? block.name : null;
+    };
     // This file's `@include` sites, by mixin: a declaration in a mixin's
     // body lands in the rule that includes it, at the `@include`.
     const includes = new Map();
@@ -931,12 +1036,14 @@ export function familiesOf(
         if (!includes.has(name)) includes.set(name, []);
         includes.get(name).push(match.index);
     }
+    // Only a mixin is included (a function's body sets nothing), where the
+    // name runs this definition of it.
     const sitesOf = (scope) => {
-        const block = blocks.find((b) => b.start === scope);
-        // Only a mixin is included (a function's body sets nothing).
-        return block?.kind === 'callable'
-            ? (includes.get(block.name) ?? [])
-            : [];
+        const block = mixins.find((b) => b.start === scope);
+        if (!block) return [];
+        return (includes.get(block.name) ?? []).filter((site) =>
+            definitionsAt(block.name, site).defs.includes(block)
+        );
     };
     // A content block (`@include m { … }`) passed to a mixin of this file
     // that places `@content` at its top level is the including rule's
@@ -945,24 +1052,24 @@ export function familiesOf(
     // `@media`) is not traced, as the mixin's own nested blocks are not.
     const contentOf = (scope) => {
         const block = blocks.find((b) => b.start === scope);
-        const named = /^@include\s+([\w-]+)/i.exec(block?.prelude ?? '');
+        const named = /^@include\s+([\w-]+)(?![\w.-])/i.exec(
+            block?.prelude ?? ''
+        );
         if (!named) return null;
         const name = named[1].replace(/_/g, '-');
-        const places = blocks
-            .filter((b) => b.kind === 'callable' && b.name === name)
-            .filter((b) => /^@mixin\b/i.test(b.prelude))
-            .flatMap((mixin) =>
-                [...lexed.text.slice(mixin.start, mixin.end).matchAll(CONTENT)]
-                    .map((match) => mixin.start + match.index)
-                    .filter((index) => !inString(index))
-                    .filter(
-                        (index) => placeOf(blocks, index).scope === mixin.start
-                    )
-            );
         const site = Math.max(
             ...(includes.get(name) ?? []).filter((index) => index < scope)
         );
-        return places.length && Number.isFinite(site) ? { places, site } : null;
+        if (!Number.isFinite(site)) return null;
+        // Each place with the definition it sits in, as that runs there.
+        const places = definitionsAt(name, site).defs.flatMap((mixin) =>
+            [...lexed.text.slice(mixin.start, mixin.end).matchAll(CONTENT)]
+                .map((match) => mixin.start + match.index)
+                .filter((index) => !inString(index))
+                .filter((index) => placeOf(blocks, index).scope === mixin.start)
+                .map((index) => ({ index, check: { name, site, def: mixin } }))
+        );
+        return places.length ? { places, site } : null;
     };
     // Cascade layers in declared order within their parent layer: as
     // `@layer a, b;` names them, or as a `@layer name { … }` block first
@@ -1128,22 +1235,33 @@ export function familiesOf(
                   (run) => transient || run.hold
               )
             : [];
-    const landingsOf = (scope, at, path = [], inner = []) => {
+    const landingsOf = (scope, at, path = [], inner = [], checks = []) => {
         if (path.includes(scope)) return [];
         const next = [...path, scope];
         const key = [at, ...inner];
+        // Outside any mixin body it runs at `at`, where each definition it
+        // went through must be the one that runs; a module mixin runs for
+        // another module once the module has run (`external`).
+        if (!deferredBy(null, at) && !ranAt(checks, at)) return [];
+        const own = {
+            ...{ at, scope, rules: rulesOf(scope), key },
+            ...(memberOf(scope) === null
+                ? {}
+                : { external: ranAt(checks, Infinity) }),
+        };
         // A keyframe's declarations meet each other in its step, and run
         // from elsewhere too (another file, unseen here).
         const frames = scope === null ? null : framesOf(scope);
         if (frames) {
             return [
-                { at, scope, rules: rulesOf(scope), key },
+                own,
                 ...runsOf(frames).flatMap(({ index: site }) =>
                     landingsOf(
                         placeOf(blocks, site).scope,
                         site,
                         next,
-                        key
+                        key,
+                        checks
                     ).map((landing) => ({ ...landing, animated: true }))
                 ),
             ];
@@ -1151,23 +1269,45 @@ export function familiesOf(
         const content = contentOf(scope);
         if (content) {
             const { places, site } = content;
-            return places.flatMap((place) =>
-                landingsOf(placeOf(blocks, site).scope, site, next, [
-                    place,
-                    ...key,
-                ])
+            return places.flatMap(({ index: place, check }) =>
+                landingsOf(
+                    placeOf(blocks, site).scope,
+                    site,
+                    next,
+                    [place, ...key],
+                    [...checks, check]
+                )
             );
         }
+        const block = mixins.find((b) => b.start === scope);
         return [
-            { at, scope, rules: rulesOf(scope), key },
+            own,
             ...sitesOf(scope).flatMap((site) =>
-                landingsOf(placeOf(blocks, site).scope, site, next, key)
+                landingsOf(placeOf(blocks, site).scope, site, next, key, [
+                    ...checks,
+                    { name: block.name, site, def: block },
+                ])
             ),
             ...extendersOf(scope).flatMap((extender) =>
-                landingsOf(extender.scope, at, next, inner)
+                landingsOf(extender.scope, at, next, inner, checks)
             ),
         ];
     };
+
+    // Where a declaration at `key` in another module's mixin lands through
+    // the `@include` at `site`: as one written there, its key that place's
+    // followed by `key`.
+    const landingsAt = (site, key) => {
+        // A bare name lands another module's only where none of this file's
+        // runs there.
+        const bare = /^@include\s+([\w-]+)(?![\w.-])/i.exec(
+            lexed.text.slice(site, site + 256)
+        );
+        const checks = bare
+            ? [{ name: bare[1].replace(/_/g, '-'), site, def: null }]
+            : [];
+        return landingsOf(placeOf(blocks, site).scope, site, [], key, checks);
+    };
     // Each declaration, where it applies, in source order.
     const applied = [];
     for (const match of lexed.text.matchAll(FONT_FAMILY)) {
@@ -1230,6 +1370,27 @@ export function familiesOf(
             });
         }
     }
+    for (const [site, families] of included) {
+        for (const { key, entry } of families) {
+            for (const landing of landingsAt(site, key)) {
+                applied.push({
+                    ...landing,
+                    entry: landing.animated
+                        ? { ...entry, animated: true }
+                        : entry,
+                });
+            }
+        }
+    }
+    // What each module mixin sets at its top level, for the modules that
+    // include it: its own declarations and those landing in it.
+    const exported = new Map();
+    for (const { scope, key, entry, external } of applied) {
+        const name = memberOf(scope);
+        if (name === null || external === false) continue;
+        if (!exported.has(name)) exported.set(name, []);
+        exported.get(name).push({ key, entry });
+    }
     // Keyed by rule, so a later block with one of its selectors wins.
     applied.sort((a, b) => keyOrder(a.key, b.key));
     // Where each rule's family was set, for the cascade between rules.
@@ -1520,41 +1681,57 @@ export function familiesOf(
     // family where it lands: each rule that includes or extends it (whose
     // own later family wins), of those `keep` accepts (where the weight is
     // in effect). A mixin's body, or a placeholder (`%x`), styles nothing
-    // where it is written.
-    const familyAt = (index, keep, seen = new Set()) => {
+    // where it is written; one another module includes meets the family
+    // there instead.
+    const familyAt = (index, keep, seen = new Set(), checks = []) => {
         const place = placeOf(blocks, index);
         const scope = fontNamespaceRule(blocks, place) ?? place.scope;
         if (seen.has(scope)) return [];
         seen.add(scope);
+        // Read where it runs, if the definitions on the way run there (see
+        // `landingsOf`); a mixin body included nowhere, once the module ran.
+        const runs = ranAt(checks, deferredBy(null, index) ? Infinity : index);
         // A content block's declaration meets the family at its `@include`,
         // a keyframe's where a rule runs it.
         const content = contentOf(scope);
-        if (content) return familyAt(content.site, keep, seen);
+        if (content) return familyAt(content.site, keep, seen, checks);
         const frames = scope === null ? null : framesOf(scope);
         if (frames) {
             if (!frames.live) return [];
             return [
-                ...(keep(scope) ? [lookup(index)] : []),
+                ...(keep(scope) && runs ? [lookup(index)] : []),
                 ...runsOf(frames).flatMap(({ index: site }) =>
-                    familyAt(site, keep, seen)
+                    familyAt(site, keep, seen, checks)
                 ),
             ];
         }
         const block = blocks.find((b) => b.start === scope);
         const includes = sitesOf(scope);
         const extended = extendersOf(scope).map((extender) => extender.index);
+        // Where another module includes it, it meets families unseen here.
+        const outside =
+            elsewhere.has(memberOf(scope)) && ranAt(checks, Infinity);
         const silent =
             includes.length > 0 ||
+            elsewhere.has(memberOf(scope)) ||
             (extended.length > 0 && /^%/.test(block?.prelude ?? ''));
         return [
-            ...(silent || !keep(scope) ? [] : [lookup(index)]),
-            ...[...includes, ...extended].flatMap((site) =>
-                familyAt(site, keep, seen)
+            ...(silent || !keep(scope) || !runs ? [] : [lookup(index)]),
+            ...(outside ? [OUTSIDE] : []),
+            ...includes.flatMap((site) =>
+                familyAt(site, keep, seen, [
+                    ...checks,
+                    { name: block.name, site, def: block },
+                ])
             ),
+            ...extended.flatMap((site) => familyAt(site, keep, seen, checks)),
         ];
     };
+
     const monoAt = (index, keep = () => true) => {
-        const found = familyAt(index, keep).filter((entry) => entry !== NONE);
+        const found = familyAt(index, keep).filter(
+            (entry) => entry !== NONE && entry !== OUTSIDE
+        );
         return (
             found.find((entry) => entry.mono) ??
             found.find((entry) => entry.refs.length > 0) ??
@@ -1562,6 +1739,19 @@ export function familiesOf(
             NONE
         );
     };
+    // The families an `@include` at `site` meets, wherever it lands:
+    // whether one renders JetBrains Mono (`mono`, also when the mixin it
+    // sits in lands in another module, unseen here), and those named
+    // through variables (`families`), resolved later.
+    monoAt.callAt = (site) => {
+        const found = familyAt(site, () => true);
+        return {
+            mono: found.some((entry) => entry.mono || entry === OUTSIDE),
+            families: found.filter(
+                (entry) => !entry.mono && entry.refs.length > 0
+            ),
+        };
+    };
     // Where a declaration at `index` lands (`{ at, scope, rules }`, see
     // `landingsOf`), for the weights in effect.
     // Whether a rule runs a keyframe that sets a font only for a while,
@@ -1576,5 +1766,10 @@ export function familiesOf(
         const scope = fontNamespaceRule(blocks, place) ?? place.scope;
         return scope === null ? [] : landingsOf(scope, index);
     };
+    monoAt.landingsAt = landingsAt;
+    monoAt.memberOf = memberOf;
+    monoAt.definitionsAt = definitionsAt;
+    // Each module mixin's top-level families, by name (`{ key, entry }`).
+    monoAt.exported = exported;
     return monoAt;
 }
diff --git a/tools/nx/font-weight-scope.mjs b/tools/nx/font-weight-scope.mjs
index add412ed8..b024ee7bd 100644
--- a/tools/nx/font-weight-scope.mjs
+++ b/tools/nx/font-weight-scope.mjs
@@ -317,7 +317,30 @@ export function sassScopes(scans) {
             .filter((edge) => edge.rule === 'import')
             .map(({ loaded, index }) => ({ loaded, index }));
 
-    return { qualified, unqualified, imports, loadsOf };
+    /**
+     * Whether a call written in `caller` reaches `callable`, defined in
+     * `file`: `ns.name` must load `file` (or a module forwarding it) as
+     * `ns`, under the name it exposes `callable` by; a bare `name` is
+     * defined in the caller itself or in what it brings in.
+     */
+    const reaches = ({ callee, file: caller }, file, callable) => {
+        if (!callee || !callable) return false;
+        if (!callee.namespace && caller === file) {
+            return callee.name === callable;
+        }
+        const scope = callee.namespace
+            ? qualified(caller, callee.namespace)
+            : unqualified(caller);
+        const access = scope.get(file);
+        return (
+            Boolean(access?.declarations) &&
+            access.exposures.some(
+                (exposure) => exposedName(exposure, callable) === callee.name
+            )
+        );
+    };
+
+    return { qualified, unqualified, imports, loadsOf, reaches };
 }
 
 /**
diff --git a/tools/release/capture-navigation-setup-actions.ts b/tools/release/capture-navigation-setup-actions.ts
index fbfbdaa2a..3689f0f49 100644
--- a/tools/release/capture-navigation-setup-actions.ts
+++ b/tools/release/capture-navigation-setup-actions.ts
@@ -63,17 +63,31 @@ async function openAddPlaylistXtream(page: Page): Promise<void> {
     await dialog.locator('#serverUrl').fill(XTREAM_MOCK_ORIGIN);
     await dialog.locator('#username').fill(XTREAM_FIXTURE_CREDENTIALS.username);
     await dialog.locator('#password').fill(XTREAM_FIXTURE_CREDENTIALS.password);
-    // The status probe only talks to the local mock, so the frame can
-    // show the successful "portal is active" verdict the guide explains.
+    // The server URL is plain http://, so the probe never tries HTTPS and
+    // only talks to the local mock; the frame can show the successful
+    // "portal is active" verdict the guide explains.
     await dialog
-        .getByRole('button', { name: /test connection/i })
-        .first()
+        .getByRole('button', { name: 'Test HTTPS and HTTP', exact: true })
         .click();
-    const status = dialog.locator('.connection-status');
-    await status.waitFor({ state: 'visible', timeout: 30_000 });
-    // The dialog body scrolls; bring the verdict the guide explains
-    // into frame together with the credential fields above it.
-    await status.scrollIntoViewIfNeeded();
+    // The status line first reads "Testing connection…"; wait for the
+    // verdict itself, so a refused account fails the shot instead of
+    // publishing a frame that contradicts the guide.
+    const status = dialog.getByRole('status');
+    await status
+        .filter({ hasText: /portal is active/i })
+        .waitFor({ state: 'visible', timeout: 30_000 })
+        .catch(async () => {
+            const shown = await status
+                .textContent({ timeout: 1_000 })
+                .catch(() => null);
+            throw new Error(
+                `Xtream connection test did not report an active portal within 30s (status: ${shown?.trim() || 'none'})`
+            );
+        });
+    // The dialog body scrolls. The verdict sits under the server URL,
+    // above the credentials, so scrolling to the last field frames the
+    // whole filled form together with the verdict the guide explains.
+    await dialog.locator('#password').scrollIntoViewIfNeeded();
     await page.waitForTimeout(500);
 }
 
diff --git a/tools/testing/website-guides.test.mjs b/tools/testing/website-guides.test.mjs
index 30699e0ab..97bd4e8f4 100644
--- a/tools/testing/website-guides.test.mjs
+++ b/tools/testing/website-guides.test.mjs
@@ -15,6 +15,14 @@ const distRoot = new URL('../../dist/apps/website/', import.meta.url);
 const SITE = 'https://4gray.github.io/iptvnator';
 
 const GUIDES = [
+  {
+    slug: 'stable-nightly-updates-guide',
+    screenshots: ['blog/feature-guides/screenshots/guide-update-channel-dark.png'],
+  },
+  {
+    slug: 'playlist-backup-restore-guide',
+    screenshots: ['blog/feature-guides/screenshots/guide-backup-dark.png'],
+  },
   {
     slug: 'fullscreen-channel-episode-guide',
     screenshots: ['blog/feature-guides/screenshots/guide-fullscreen-channels-dark.png'],