From cc048ba6bd56edb63a603536958f4acedc838eed Mon Sep 17 00:00:00 2001
From: Mahmut YUM <mahmut_yum@hotmail.com>
Date: Sun, 15 Nov 2026 01:48:27 +0300
Subject: [PATCH 1/2] fix(parental-lock): close external players on relock,
 count them as playback, release stalled video

- A relock closes an MPV/VLC session whose media was opened while
  unlocked when its source has a locked category (any source, when it
  cannot be told) or the lock store is unreadable. Sessions opened while
  locked keep playing. Xtream Live claims its own sessions through
  ParentalLockSessionOwners and keeps closing only withheld categories.
  A session that could not be closed before an unlock is shown again.
- The idle relock counts Embedded MPV while playing and an MPV/VLC film
  or episode while its reported position moves; players that report no
  position (live, M3U films, Flatpak MPV) cannot report a pause and do
  not hold the lock open.
- Keep-awake releases a video that stalls without advancing for 60 s and
  keeps checking one that advanced until playing reports it resumed, so a
  dead stream no longer pins the display or defers the relock.
---
 .changes/parental-lock-external-players.md    |   6 +
 .../src/parental-lock-external-player.e2e.ts  | 182 ++++++++
 .../parental-lock-enforcement.service.spec.ts |  49 ++-
 .../parental-lock-enforcement.service.ts      |  14 +-
 .../parental-lock-external-sessions.spec.ts   | 416 ++++++++++++++++++
 .../parental-lock-external-sessions.ts        | 250 +++++++++++
 .../playback-keep-awake.service.spec.ts       |  92 +++-
 .../services/playback-keep-awake.service.ts   |  57 +++
 docs/architecture/parental-lock.md            |  43 +-
 docs/architecture/player-controls-contract.md |   6 +
 ...eam-external-live-sessions.service.spec.ts |  22 +-
 .../xtream-external-live-sessions.service.ts  |  48 +-
 .../live-stream-layout/xtream-live-owner.ts   |  30 ++
 libs/services/src/lib/parental-lock/index.ts  |   1 +
 .../parental-lock-lock-store.service.spec.ts  |  24 +
 .../parental-lock-lock-store.service.ts       |  14 +
 .../parental-lock-session-owners.ts           |  28 ++
 17 files changed, 1243 insertions(+), 39 deletions(-)
 create mode 100644 .changes/parental-lock-external-players.md
 create mode 100644 apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
 create mode 100644 apps/web/src/app/services/parental-lock-external-sessions.spec.ts
 create mode 100644 apps/web/src/app/services/parental-lock-external-sessions.ts
 create mode 100644 libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts
 create mode 100644 libs/services/src/lib/parental-lock/parental-lock-session-owners.ts

diff --git a/.changes/parental-lock-external-players.md b/.changes/parental-lock-external-players.md
new file mode 100644
index 0000000000..f381c2cab9
--- /dev/null
+++ b/.changes/parental-lock-external-players.md
@@ -0,0 +1,6 @@
+---
+type: fix
+area: parental-lock
+---
+
+Locking the app again now closes an MPV or VLC window opened while it was unlocked from a source with locked categories. Films in MPV, VLC and Embedded MPV no longer lock half way. A stream that stops playing no longer keeps the screen awake and the app unlocked.
diff --git a/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
new file mode 100644
index 0000000000..bc77816b17
--- /dev/null
+++ b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
@@ -0,0 +1,182 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Page } from '@playwright/test';
+import {
+    addXtreamPortal,
+    closeElectronApp,
+    expect,
+    launchElectronApp,
+    openSettings,
+    openSettingsSection,
+    openWorkspaceSection,
+    test,
+    waitForXtreamWorkspaceReady,
+} from './electron-test-fixtures';
+
+const PIN = '2468';
+const PID_KEY = '__parentalLockPlayerPids';
+
+function stopPlayer(pid: number): void {
+    try {
+        process.kill(pid);
+    } catch {
+        // Already gone.
+    }
+}
+
+function playerIsAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function launchPlayer(
+    app: Awaited<ReturnType<typeof launchElectronApp>>,
+    playerPath: string,
+    title: string
+): Promise<number> {
+    const before = await app.electronApp.evaluate(
+        (_, key) => (Reflect.get(globalThis, key) as number[]).length,
+        PID_KEY
+    );
+    await app.mainWindow.evaluate(
+        async ({ playerPath, title }) => {
+            await window.electron.setMpvPlayerPath(playerPath);
+            await window.electron.openInMpv(
+                'https://streams.example.test/synthetic.ts',
+                title,
+                '',
+                ''
+            );
+        },
+        { playerPath, title }
+    );
+    await expect
+        .poll(() =>
+            app.electronApp.evaluate(
+                (_, key) => (Reflect.get(globalThis, key) as number[]).length,
+                PID_KEY
+            )
+        )
+        .toBe(before + 1);
+    return app.electronApp.evaluate(
+        (_, key) => (Reflect.get(globalThis, key) as number[]).at(-1) ?? 0,
+        PID_KEY
+    );
+}
+
+async function enterPin(page: Page): Promise<void> {
+    await page.getByTestId('parental-lock-pin').fill(PIN);
+    await page.getByTestId('parental-lock-pin-submit').click();
+}
+
+/**
+ * A relock closes an MPV session opened while unlocked from a source with
+ * a locked category, and leaves one opened while locked. The native process
+ * boundary is replaced by a quiet, long-lived child; CI installs no MPV.
+ */
+test('@electron @parental @playback relock closes an MPV session opened while unlocked', async ({
+    dataDir,
+}) => {
+    test.setTimeout(120_000);
+    const directory = mkdtempSync(join(tmpdir(), 'iptvnator-lock-player-'));
+    const playerPath = join(directory, 'synthetic-mpv');
+    const app = await launchElectronApp(dataDir);
+    const pids: number[] = [];
+    try {
+        const page = app.mainWindow;
+        await app.electronApp.evaluate(
+            (_, { playerPath, nodePath, key }) => {
+                const childProcess = process.getBuiltinModule('child_process');
+                const spawn = childProcess.spawn;
+                Reflect.set(globalThis, key, []);
+                childProcess.spawn = ((command, ...args) => {
+                    if (command !== playerPath)
+                        return Reflect.apply(spawn, childProcess, [
+                            command,
+                            ...args,
+                        ]);
+                    const child = spawn(
+                        nodePath,
+                        ['-e', 'setInterval(() => {}, 1000)'],
+                        { stdio: ['ignore', 'pipe', 'pipe'], detached: false }
+                    );
+                    (Reflect.get(globalThis, key) as number[]).push(
+                        child.pid as number
+                    );
+                    return child;
+                }) as typeof spawn;
+            },
+            { playerPath, nodePath: process.execPath, key: PID_KEY }
+        );
+        await page.evaluate(() =>
+            window.electron.updateSettings({ mpvReuseInstance: true })
+        );
+
+        // Enabling the lock leaves this session unlocked.
+        await openSettings(page);
+        await openSettingsSection(page, 'parental');
+        const toggle = page.locator(
+            '[data-test-id="parental-lock-enabled"] button[role="switch"]'
+        );
+        await toggle.click();
+        await page.getByTestId('parental-lock-pin').fill(PIN);
+        await page.getByTestId('parental-lock-pin-confirm').fill(PIN);
+        await page.getByTestId('parental-lock-pin-submit').click();
+        await expect(toggle).toHaveAttribute('aria-checked', 'true');
+
+        await addXtreamPortal(page, { name: 'Synthetic Lock Portal' });
+        await waitForXtreamWorkspaceReady(page);
+        await openWorkspaceSection(page, 'Live TV');
+        await page.getByTestId('context-manage-categories').click();
+        const dialog = page.locator('app-category-management-dialog');
+        await dialog
+            .locator('[data-test-id^="category-lock-"]')
+            .first()
+            .click();
+        await dialog.getByRole('button', { name: 'Save', exact: true }).click();
+        await expect(dialog).toBeHidden();
+        await expect(page).toHaveURL(/\/workspace\/xtreams\/[^/]+\/live/);
+
+        // Opened while unlocked, from a source with a locked category.
+        const unlockedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic unlocked launch'
+        );
+        pids.push(unlockedPid);
+        expect(playerIsAlive(unlockedPid)).toBe(true);
+
+        const lockButton = page.getByTestId('header-parental-lock');
+        await lockButton.click();
+        await expect(lockButton).toHaveClass(/is-active/);
+        await expect.poll(() => playerIsAlive(unlockedPid)).toBe(false);
+
+        // Opened while locked: it came from the filtered catalog and must
+        // survive an unlock and the next relock.
+        const lockedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic locked launch'
+        );
+        pids.push(lockedPid);
+        await lockButton.click();
+        await enterPin(page);
+        await expect(lockButton).not.toHaveClass(/is-active/);
+        await lockButton.click();
+        await expect(lockButton).toHaveClass(/is-active/);
+        // Nothing to wait for when the session is rightly left alone: give
+        // a wrong close (sent at once on relock) time to land.
+        // eslint-disable-next-line playwright/no-wait-for-timeout
+        await page.waitForTimeout(3_000);
+        expect(playerIsAlive(lockedPid)).toBe(true);
+    } finally {
+        pids.forEach(stopPlayer);
+        await closeElectronApp(app);
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
diff --git a/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts b/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
index 8549df0fee..1eec1c784e 100644
--- a/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
+++ b/apps/web/src/app/services/parental-lock-enforcement.service.spec.ts
@@ -9,6 +9,7 @@ import {
 } from '@iptvnator/portal/xtream/data-access';
 import { ParentalLockService } from '@iptvnator/services';
 import { ParentalLockEnforcementService } from './parental-lock-enforcement.service';
+import { ParentalLockExternalSessions } from './parental-lock-external-sessions';
 import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
 
 interface Applier {
@@ -546,18 +547,40 @@ describe('ParentalLockEnforcementService apply serialization', () => {
 });
 
 describe('ParentalLockEnforcementService busy probe', () => {
-    it('counts playing audio (the radio player) as activity', () => {
-        let probe: (() => boolean) | undefined;
+    let probe: (() => boolean) | undefined;
+    let version: ReturnType<typeof signal<number>>;
+    let active: ReturnType<typeof signal<boolean>>;
+    let externalSessions: {
+        start: jest.Mock;
+        isBusy: jest.Mock;
+        onLockChange: jest.Mock;
+    };
+
+    beforeEach(() => {
+        probe = undefined;
+        version = signal(0);
+        active = signal(false);
+        externalSessions = {
+            start: jest.fn(),
+            isBusy: jest.fn(() => false),
+            onLockChange: jest.fn(),
+        };
         TestBed.resetTestingModule();
         TestBed.configureTestingModule({
             providers: [
                 {
                     provide: ParentalLockService,
                     useValue: {
-                        version: signal(0),
+                        version,
+                        active,
+                        isM3uGroupLocked: () => false,
                         registerBusyProbe: (fn: () => boolean) => (probe = fn),
                     },
                 },
+                {
+                    provide: ParentalLockExternalSessions,
+                    useValue: externalSessions,
+                },
                 { provide: XtreamStore, useValue: {} },
                 { provide: XTREAM_DATA_SOURCE, useValue: {} },
                 { provide: StalkerStore, useValue: {} },
@@ -574,6 +597,26 @@ describe('ParentalLockEnforcementService busy probe', () => {
         });
         const service = TestBed.inject(ParentalLockEnforcementService);
         TestBed.runInInjectionContext(() => service.start());
+        TestBed.flushEffects();
+    });
+
+    it('counts players outside the page (Embedded MPV, MPV/VLC films)', () => {
+        expect(externalSessions.start).toHaveBeenCalled();
+        expect(probe?.()).toBe(false);
+
+        externalSessions.isBusy.mockReturnValue(true);
+        expect(probe?.()).toBe(true);
+    });
+
+    it('hands a relock to the external session closer', () => {
+        active.set(true);
+        version.set(1);
+        TestBed.flushEffects();
+
+        expect(externalSessions.onLockChange).toHaveBeenCalledTimes(1);
+    });
+
+    it('counts playing audio (the radio player) as activity', () => {
         expect(probe?.()).toBe(false);
 
         const audio = document.createElement('audio');
diff --git a/apps/web/src/app/services/parental-lock-enforcement.service.ts b/apps/web/src/app/services/parental-lock-enforcement.service.ts
index 16a0927559..1b78d8ebd6 100644
--- a/apps/web/src/app/services/parental-lock-enforcement.service.ts
+++ b/apps/web/src/app/services/parental-lock-enforcement.service.ts
@@ -14,6 +14,7 @@ import {
 } from '@iptvnator/portal/xtream/data-access';
 import { ParentalLockService } from '@iptvnator/services';
 import { toParentalLockXtreamCategoryType } from '@iptvnator/shared/interfaces';
+import { ParentalLockExternalSessions } from './parental-lock-external-sessions';
 import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
 
 const XTREAM_ROUTE =
@@ -37,6 +38,7 @@ export class ParentalLockEnforcementService {
     private readonly router = inject(Router);
     private readonly store = inject(Store);
     private readonly keepAwake = inject(PlaybackKeepAwakeService);
+    private readonly externalSessions = inject(ParentalLockExternalSessions);
     private readonly activeChannel = this.store.selectSignal(selectActive);
     private started = false;
     private lastVersion = -1;
@@ -50,10 +52,15 @@ export class ParentalLockEnforcementService {
         }
         this.started = true;
         // Playback counts as activity: video through the keep-awake
-        // tracker, and audio (the radio player) read directly, since the
-        // keep-awake service deliberately ignores <audio>.
+        // tracker, audio (the radio player) read directly, since the
+        // keep-awake service deliberately ignores <audio>, and the players
+        // that render outside the page (Embedded MPV, MPV/VLC films).
+        this.externalSessions.start();
         this.parentalLock.registerBusyProbe(
-            () => this.keepAwake.hasPlayingVideo() || hasPlayingAudio()
+            () =>
+                this.keepAwake.hasPlayingVideo() ||
+                hasPlayingAudio() ||
+                this.externalSessions.isBusy()
         );
         // The Stalker step is loaded as soon as a Stalker route opens, so a
         // relock there can run it synchronously instead of awaiting a chunk.
@@ -94,6 +101,7 @@ export class ParentalLockEnforcementService {
                 if (this.parentalLock.active()) {
                     this.failClosedNow();
                 }
+                this.externalSessions.onLockChange();
                 this.scheduleApply();
             });
         });
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.spec.ts b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
new file mode 100644
index 0000000000..7408364b86
--- /dev/null
+++ b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
@@ -0,0 +1,416 @@
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import {
+    ParentalLockLockStore,
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
+import type {
+    EmbeddedMpvSession,
+    ExternalPlayerSession,
+    PlaybackPositionData,
+} from '@iptvnator/shared/interfaces';
+import { ExternalPlaybackService } from './external-playback.service';
+import {
+    EXTERNAL_PROGRESS_WINDOW_MS,
+    ParentalLockExternalSessions,
+} from './parental-lock-external-sessions';
+
+type Listener<T> = (value: T) => void;
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function session(
+    overrides: Partial<ExternalPlayerSession> = {}
+): ExternalPlayerSession {
+    return {
+        id: 'session-1',
+        player: 'mpv',
+        status: 'playing',
+        title: 'Synthetic Film',
+        streamUrl: 'http://stream.example/film.mkv',
+        startedAt: new Date(1_000).toISOString(),
+        updatedAt: new Date(1_000).toISOString(),
+        canClose: true,
+        ...overrides,
+    };
+}
+
+describe('ParentalLockExternalSessions', () => {
+    let clock: number;
+    let active: ReturnType<typeof signal<boolean>>;
+    let hasLocks: jest.Mock;
+    let withholdsEverything: ReturnType<typeof signal<boolean>>;
+    let activeSession: ReturnType<typeof signal<ExternalPlayerSession | null>>;
+    let dismissActiveSession: jest.Mock;
+    let restoreDismissedSession: jest.Mock;
+    let closeExternalPlayerSession: jest.Mock;
+    let router: { url: string };
+    let emitSession: Listener<ExternalPlayerSession>;
+    let emitPosition: Listener<PlaybackPositionData>;
+    let emitEmbedded: Listener<EmbeddedMpvSession>;
+    let service: ParentalLockExternalSessions;
+
+    /** Lock now: the enforcement calls `onLockChange` on the new version. */
+    const relock = () => {
+        active.set(true);
+        service.onLockChange();
+    };
+
+    beforeEach(() => {
+        clock = 10_000;
+        active = signal(false);
+        hasLocks = jest.fn(() => true);
+        withholdsEverything = signal(false);
+        activeSession = signal<ExternalPlayerSession | null>(null);
+        dismissActiveSession = jest.fn();
+        restoreDismissedSession = jest.fn();
+        closeExternalPlayerSession = jest.fn(
+            async (id: string): Promise<ExternalPlayerSession | null> =>
+                session({ id, status: 'closed', canClose: false })
+        );
+        router = { url: '/workspace/playlists/m3u-1/all' };
+        (window as { electron?: unknown }).electron = {
+            closeExternalPlayerSession,
+            onExternalPlayerSessionUpdate: (
+                callback: Listener<ExternalPlayerSession>
+            ) => (emitSession = callback),
+            onPlaybackPositionUpdate: (
+                callback: Listener<PlaybackPositionData>
+            ) => (emitPosition = callback),
+            onEmbeddedMpvSessionUpdate: (
+                callback: Listener<EmbeddedMpvSession>
+            ) => (emitEmbedded = callback),
+        };
+        TestBed.configureTestingModule({
+            providers: [
+                {
+                    provide: ParentalLockService,
+                    useValue: { active, withholdsEverything },
+                },
+                { provide: ParentalLockLockStore, useValue: { hasLocks } },
+                {
+                    provide: ExternalPlaybackService,
+                    useValue: {
+                        activeSession,
+                        dismissActiveSession,
+                        restoreDismissedSession,
+                    },
+                },
+                { provide: Router, useValue: router },
+            ],
+        });
+        service = TestBed.inject(ParentalLockExternalSessions);
+        service.now = () => clock;
+        service.start();
+    });
+
+    afterEach(() => {
+        delete (window as { electron?: unknown }).electron;
+        TestBed.resetTestingModule();
+    });
+
+    describe('relock', () => {
+        it('closes a session started while unlocked and hides it from the dock', async () => {
+            const started = session();
+            emitSession(started);
+            activeSession.set(started);
+
+            relock();
+            await flush();
+
+            expect(hasLocks).toHaveBeenCalledWith('m3u-1');
+            expect(dismissActiveSession).toHaveBeenCalled();
+            expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                'session-1',
+                true
+            );
+        });
+
+        it('judges a session by its own source over the route', () => {
+            router.url = '/workspace/dashboard';
+            emitSession(
+                session({
+                    contentInfo: {
+                        playlistId: 'xtream-1',
+                        contentXtreamId: 7,
+                        contentType: 'vod',
+                    },
+                })
+            );
+
+            relock();
+
+            expect(hasLocks).toHaveBeenCalledWith('xtream-1');
+        });
+
+        it('treats a launch from outside a source route as any source', () => {
+            router.url = '/workspace/favorites';
+            emitSession(session());
+
+            relock();
+
+            expect(hasLocks).toHaveBeenCalledWith(null);
+            expect(closeExternalPlayerSession).toHaveBeenCalled();
+        });
+
+        it('keeps a session whose source has no locked category', () => {
+            hasLocks.mockReturnValue(false);
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+            expect(dismissActiveSession).not.toHaveBeenCalled();
+        });
+
+        it('closes any such session while the lock store is unreadable', () => {
+            hasLocks.mockReturnValue(false);
+            withholdsEverything.set(true);
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).toHaveBeenCalled();
+        });
+
+        it('keeps a session launched while locked (from the filtered catalog)', () => {
+            relock();
+            clock += 1_000;
+            emitSession(
+                session({ startedAt: new Date(clock).toISOString() })
+            );
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('closes a launch that raced the relock', () => {
+            relock();
+            // Started before the relock, first reported after it.
+            emitSession(session({ startedAt: new Date(clock - 1).toISOString() }));
+
+            expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                'session-1',
+                true
+            );
+        });
+
+        it('closes a locked-time session switched in place while unlocked', () => {
+            relock();
+            clock += 1_000;
+            const startedAt = new Date(clock).toISOString();
+            emitSession(session({ startedAt }));
+            active.set(false);
+            emitSession(
+                session({
+                    startedAt,
+                    streamUrl: 'http://stream.example/other.mkv',
+                })
+            );
+
+            relock();
+
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+        });
+
+        it('keeps a locked-time session that only reports status while unlocked', () => {
+            relock();
+            clock += 1_000;
+            const startedAt = new Date(clock).toISOString();
+            emitSession(session({ startedAt, status: 'opened' }));
+            active.set(false);
+            emitSession(session({ startedAt, status: 'playing' }));
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('leaves a session its owner enforces', () => {
+            TestBed.inject(ParentalLockSessionOwners).claim(
+                (candidate) => candidate.id === 'session-1'
+            );
+            emitSession(session());
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('retries a close that failed', async () => {
+            jest.useFakeTimers();
+            try {
+                closeExternalPlayerSession.mockRejectedValueOnce(
+                    new Error('synthetic close failure')
+                );
+                emitSession(session());
+
+                relock();
+                await Promise.resolve();
+                await Promise.resolve();
+                expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+
+                jest.advanceTimersByTime(1_000);
+                expect(closeExternalPlayerSession).toHaveBeenCalledTimes(2);
+            } finally {
+                jest.useRealTimers();
+            }
+        });
+
+        it('closes a launch again once it can be closed', async () => {
+            const launching = session({ status: 'launching' });
+            closeExternalPlayerSession.mockResolvedValueOnce(launching);
+            emitSession(launching);
+
+            relock();
+            await flush();
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(1);
+
+            emitSession(session());
+            await flush();
+            expect(closeExternalPlayerSession).toHaveBeenCalledTimes(2);
+        });
+
+        it('only hides a session that cannot be closed', () => {
+            const stuck = session({ canClose: false });
+            emitSession(stuck);
+            activeSession.set(stuck);
+
+            relock();
+
+            expect(dismissActiveSession).toHaveBeenCalled();
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('never closes while unlocked', () => {
+            emitSession(session());
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+
+        it('shows a hidden session again when unlocked before it could be closed', () => {
+            const stuck = session({ canClose: false });
+            emitSession(stuck);
+            activeSession.set(stuck);
+            relock();
+            expect(restoreDismissedSession).not.toHaveBeenCalled();
+
+            active.set(false);
+            service.onLockChange();
+
+            expect(restoreDismissedSession).toHaveBeenCalledWith('session-1');
+        });
+
+        it.each(['returns the session open', 'fails'] as const)(
+            'shows a hidden session again when unlocked while its close %s',
+            async (outcome) => {
+                const started = session();
+                let settle: () => void = () => undefined;
+                closeExternalPlayerSession.mockImplementationOnce(
+                    () =>
+                        new Promise((resolve, reject) => {
+                            settle = () =>
+                                outcome === 'fails'
+                                    ? reject(new Error('synthetic failure'))
+                                    : resolve(started);
+                        })
+                );
+                emitSession(started);
+                activeSession.set(started);
+                relock();
+
+                active.set(false);
+                service.onLockChange();
+                expect(restoreDismissedSession).not.toHaveBeenCalled();
+
+                settle();
+                await flush();
+                expect(restoreDismissedSession).toHaveBeenCalledWith(
+                    'session-1'
+                );
+            }
+        );
+
+        it('forgets a closed session', () => {
+            emitSession(session());
+            emitSession(session({ status: 'closed', canClose: false }));
+
+            relock();
+
+            expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('busy probe for the idle relock', () => {
+        const film = () =>
+            session({
+                contentInfo: {
+                    playlistId: 'xtream-1',
+                    contentXtreamId: 7,
+                    contentType: 'vod',
+                },
+            });
+        const position = (positionSeconds: number): PlaybackPositionData => ({
+            sessionId: 'session-1',
+            playlistId: 'xtream-1',
+            contentXtreamId: 7,
+            contentType: 'vod',
+            positionSeconds,
+        });
+
+        it('counts an MPV/VLC film while its position moves', () => {
+            emitSession(film());
+            expect(service.isBusy()).toBe(false);
+
+            emitPosition(position(100));
+            expect(service.isBusy()).toBe(true);
+
+            clock += 5_000;
+            emitPosition(position(105));
+            clock += EXTERNAL_PROGRESS_WINDOW_MS;
+            expect(service.isBusy()).toBe(true);
+        });
+
+        it('stops counting a paused film', () => {
+            emitSession(film());
+            emitPosition(position(100));
+            clock += 5_000;
+            emitPosition(position(100));
+            clock += EXTERNAL_PROGRESS_WINDOW_MS - 4_000;
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('stops counting a film whose player closed', () => {
+            emitSession(film());
+            emitPosition(position(100));
+            emitSession({ ...film(), status: 'closed', canClose: false });
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('does not count live MPV/VLC, which cannot report a pause', () => {
+            emitSession(session());
+            emitPosition(position(100));
+
+            expect(service.isBusy()).toBe(false);
+        });
+
+        it('counts Embedded MPV while any session plays', () => {
+            const embedded = (
+                id: string,
+                status: EmbeddedMpvSession['status']
+            ) => ({ id, status }) as EmbeddedMpvSession;
+
+            emitEmbedded(embedded('a', 'playing'));
+            emitEmbedded(embedded('b', 'playing'));
+            emitEmbedded(embedded('a', 'paused'));
+            expect(service.isBusy()).toBe(true);
+
+            emitEmbedded(embedded('b', 'closed'));
+            expect(service.isBusy()).toBe(false);
+        });
+    });
+});
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.ts b/apps/web/src/app/services/parental-lock-external-sessions.ts
new file mode 100644
index 0000000000..513f05e003
--- /dev/null
+++ b/apps/web/src/app/services/parental-lock-external-sessions.ts
@@ -0,0 +1,250 @@
+import { inject, Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import {
+    ParentalLockLockStore,
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
+import type {
+    EmbeddedMpvSession,
+    ExternalPlayerSession,
+    PlaybackPositionData,
+} from '@iptvnator/shared/interfaces';
+import { ExternalPlaybackService } from './external-playback.service';
+
+/** A source route; a launch from it plays that source's content. */
+const SOURCE_ROUTE = /^\/workspace\/(?:playlists|xtreams|stalker)\/([^/?#]+)/;
+
+/**
+ * MPV/VLC report a film's position every 5 s. A position that moved within
+ * this window means the film is playing; a paused one stops moving.
+ */
+export const EXTERNAL_PROGRESS_WINDOW_MS = 15_000;
+
+const CLOSE_RETRY_MS = 1_000;
+
+type Tracked = {
+    session: ExternalPlayerSession;
+    /** Its media was opened while unlocked: may show withheld content. */
+    tainted: boolean;
+    /** The session's source; `null` when it cannot be told. */
+    sourceId: string | null;
+    closing: boolean;
+    /** Dismissed from the dock by the relock. */
+    hidden?: boolean;
+    retry?: ReturnType<typeof setTimeout>;
+    position?: number;
+    progressAt?: number;
+};
+
+function isOpen(session: ExternalPlayerSession): boolean {
+    return (
+        session.status !== 'closed' &&
+        (session.status !== 'error' || session.canClose)
+    );
+}
+
+/**
+ * The parental lock for players that render outside the page.
+ *
+ * Relock: an MPV/VLC session carries no category, so a session started (or
+ * switched) while unlocked is closed when its source has any locked
+ * category — any source has, when the source is unknown — or the lock store
+ * is unreadable. A session launched while locked came from the filtered
+ * catalog and keeps playing. Features that know the category claim their
+ * sessions through `ParentalLockSessionOwners` and close only withheld ones.
+ *
+ * Idle relock: Embedded MPV counts as busy while `playing`, an MPV/VLC film
+ * or episode while its reported position moves. Live MPV/VLC cannot report a
+ * pause, so it does not hold the lock open.
+ */
+@Injectable({ providedIn: 'root' })
+export class ParentalLockExternalSessions {
+    private readonly lock = inject(ParentalLockService);
+    private readonly locks = inject(ParentalLockLockStore);
+    private readonly owners = inject(ParentalLockSessionOwners);
+    private readonly playback = inject(ExternalPlaybackService);
+    private readonly router = inject(Router);
+    private readonly sessions = new Map<string, Tracked>();
+    private readonly embeddedPlaying = new Set<string>();
+    private lockedAt = Number.NEGATIVE_INFINITY;
+    private started = false;
+
+    /** The clock; a field so specs can substitute it. */
+    now = (): number => Date.now();
+
+    start(): void {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        const bridge = window.electron;
+        bridge?.onExternalPlayerSessionUpdate?.((session) =>
+            this.observe(session)
+        );
+        bridge?.onPlaybackPositionUpdate?.((position) =>
+            this.observePosition(position)
+        );
+        bridge?.onEmbeddedMpvSessionUpdate?.((session) =>
+            this.observeEmbedded(session)
+        );
+    }
+
+    /** Called on every lock version change: closes on relock, shows on unlock. */
+    onLockChange(): void {
+        if (this.lock.active()) {
+            this.lockedAt = this.now();
+        }
+        for (const entry of [...this.sessions.values()]) {
+            this.enforce(entry);
+        }
+    }
+
+    isBusy(): boolean {
+        if (this.embeddedPlaying.size > 0) {
+            return true;
+        }
+        const now = this.now();
+        return [...this.sessions.values()].some(
+            ({ session, progressAt }) =>
+                !!session.contentInfo &&
+                (session.status === 'opened' || session.status === 'playing') &&
+                progressAt !== undefined &&
+                now - progressAt <= EXTERNAL_PROGRESS_WINDOW_MS
+        );
+    }
+
+    private observe(session: ExternalPlayerSession): void {
+        const current = this.sessions.get(session.id);
+        if (!isOpen(session)) {
+            clearTimeout(current?.retry);
+            this.sessions.delete(session.id);
+            return;
+        }
+        const entry: Tracked = current ?? {
+            session,
+            tainted: false,
+            sourceId: this.routeSourceId(),
+            closing: false,
+        };
+        // New media while unlocked: a launch, or an in-place switch of a
+        // reused player (status reports alone do not count). A session first
+        // seen after a relock it started before raced that relock.
+        const unlockedMedia =
+            !this.lock.active() &&
+            (!current || current.session.streamUrl !== session.streamUrl);
+        if (
+            unlockedMedia ||
+            (!current && Date.parse(session.startedAt) <= this.lockedAt)
+        ) {
+            entry.tainted = true;
+        }
+        entry.session = session;
+        entry.sourceId = session.contentInfo?.playlistId ?? entry.sourceId;
+        this.sessions.set(session.id, entry);
+        this.enforce(entry);
+    }
+
+    private observePosition(position: PlaybackPositionData): void {
+        const entry = position.sessionId
+            ? this.sessions.get(position.sessionId)
+            : undefined;
+        if (!entry || entry.position === position.positionSeconds) {
+            return;
+        }
+        entry.position = position.positionSeconds;
+        entry.progressAt = this.now();
+    }
+
+    private observeEmbedded(session: EmbeddedMpvSession): void {
+        if (session.status === 'playing') {
+            this.embeddedPlaying.add(session.id);
+        } else {
+            this.embeddedPlaying.delete(session.id);
+        }
+    }
+
+    private needsClose(entry: Tracked): boolean {
+        return (
+            this.lock.active() &&
+            entry.tainted &&
+            !this.owners.isOwned(entry.session) &&
+            // Unreadable locks withhold every category; otherwise any
+            // locked category of the source (of any, when unknown) counts.
+            (this.lock.withholdsEverything() ||
+                this.locks.hasLocks(entry.sourceId))
+        );
+    }
+
+    private enforce(entry: Tracked): void {
+        const { session } = entry;
+        if (this.sessions.get(session.id) !== entry) {
+            return;
+        }
+        if (!this.needsClose(entry)) {
+            clearTimeout(entry.retry);
+            entry.retry = undefined;
+            // Unlocked before it could be closed: show it in the dock again.
+            if (entry.hidden && !entry.closing) {
+                entry.hidden = false;
+                this.playback.restoreDismissedSession(session.id);
+            }
+            return;
+        }
+        if (this.playback.activeSession()?.id === session.id) {
+            entry.hidden = true;
+            this.playback.dismissActiveSession();
+        }
+        const bridge = window.electron;
+        if (
+            !session.canClose ||
+            !bridge?.closeExternalPlayerSession ||
+            entry.closing ||
+            entry.retry
+        ) {
+            return;
+        }
+        entry.closing = true;
+        bridge.closeExternalPlayerSession(session.id, true).then(
+            (result) => {
+                entry.closing = false;
+                if (result && isOpen(result)) {
+                    // The launch has no closer yet; its next update runs the
+                    // close again. Recheck now when an update already
+                    // arrived or the app was unlocked meanwhile.
+                    if (entry.session !== session || !this.needsClose(entry)) {
+                        this.enforce(entry);
+                    }
+                    return;
+                }
+                this.observe(
+                    result ?? {
+                        ...session,
+                        status: 'closed',
+                        canClose: false,
+                        closedByRequest: true,
+                    }
+                );
+            },
+            () => {
+                entry.closing = false;
+                if (this.sessions.get(session.id) !== entry) {
+                    return;
+                }
+                if (!this.needsClose(entry)) {
+                    this.enforce(entry);
+                    return;
+                }
+                entry.retry = setTimeout(() => {
+                    entry.retry = undefined;
+                    this.enforce(entry);
+                }, CLOSE_RETRY_MS);
+            }
+        );
+    }
+
+    private routeSourceId(): string | null {
+        const match = SOURCE_ROUTE.exec(this.router.url ?? '');
+        return match ? decodeURIComponent(match[1]) : null;
+    }
+}
diff --git a/apps/web/src/app/services/playback-keep-awake.service.spec.ts b/apps/web/src/app/services/playback-keep-awake.service.spec.ts
index 5a62246cde..e62948c381 100644
--- a/apps/web/src/app/services/playback-keep-awake.service.spec.ts
+++ b/apps/web/src/app/services/playback-keep-awake.service.spec.ts
@@ -1,4 +1,7 @@
-import { PlaybackKeepAwakeService } from './playback-keep-awake.service';
+import {
+    PLAYBACK_STALL_RELEASE_MS,
+    PlaybackKeepAwakeService,
+} from './playback-keep-awake.service';
 
 type ElectronWindow = {
     electron?: Pick<typeof window.electron, 'setPlaybackKeepAwake'>;
@@ -87,6 +90,93 @@ describe('PlaybackKeepAwakeService', () => {
             second.remove();
         });
 
+        describe('a stream that stops advancing', () => {
+            let currentTime: number;
+
+            beforeEach(() => {
+                jest.useFakeTimers();
+                currentTime = 10;
+                Object.defineProperty(video, 'currentTime', {
+                    configurable: true,
+                    get: () => currentTime,
+                });
+            });
+
+            afterEach(() => {
+                jest.useRealTimers();
+            });
+
+            it.each(['waiting', 'stalled'] as const)(
+                'releases after %s without progress and holds again on playing',
+                (eventType) => {
+                    video.dispatchEvent(new Event('playing'));
+                    video.dispatchEvent(new Event(eventType));
+                    jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS - 1);
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(true);
+
+                    jest.advanceTimersByTime(1);
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(
+                        false
+                    );
+                    expect(service.hasPlayingVideo()).toBe(false);
+
+                    video.dispatchEvent(new Event('playing'));
+                    expect(setPlaybackKeepAwake).toHaveBeenLastCalledWith(true);
+                    expect(setPlaybackKeepAwake).toHaveBeenCalledTimes(3);
+                }
+            );
+
+            it('keeps the lock when the video plays on from its buffer', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('stalled'));
+                currentTime = 40;
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(setPlaybackKeepAwake).toHaveBeenCalledTimes(1);
+                expect(service.hasPlayingVideo()).toBe(true);
+            });
+
+            it('releases a video that advanced a little and froze without another event', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                currentTime = 11;
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(service.hasPlayingVideo()).toBe(true);
+
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+
+            it('stops checking once playing reports the video resumed', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                video.dispatchEvent(new Event('playing'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS * 2);
+                expect(service.hasPlayingVideo()).toBe(true);
+            });
+
+            it('restarts the check when a recovered video stalls again', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(5_000);
+                currentTime = 15;
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS - 5_000);
+                expect(service.hasPlayingVideo()).toBe(true);
+
+                jest.advanceTimersByTime(5_000);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+
+            it('does not let repeated stall events postpone the release', () => {
+                video.dispatchEvent(new Event('playing'));
+                video.dispatchEvent(new Event('waiting'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS / 2);
+                video.dispatchEvent(new Event('stalled'));
+                jest.advanceTimersByTime(PLAYBACK_STALL_RELEASE_MS / 2);
+                expect(service.hasPlayingVideo()).toBe(false);
+            });
+        });
+
         it('does not react to repeated playing events of a tracked video', () => {
             video.dispatchEvent(new Event('playing'));
             video.dispatchEvent(new Event('playing'));
diff --git a/apps/web/src/app/services/playback-keep-awake.service.ts b/apps/web/src/app/services/playback-keep-awake.service.ts
index eb2f512b79..27962d99f9 100644
--- a/apps/web/src/app/services/playback-keep-awake.service.ts
+++ b/apps/web/src/app/services/playback-keep-awake.service.ts
@@ -16,6 +16,17 @@ type WakeLockNavigator = Navigator & {
 /** Events on a tracked video that mean it is no longer playing. */
 const RELEASE_EVENTS = ['pause', 'ended', 'emptied', 'error'] as const;
 
+/** Events on a tracked video that mean it may have stopped advancing. */
+const STALL_EVENTS = ['waiting', 'stalled'] as const;
+
+/**
+ * A tracked video that has not advanced this long after `waiting` or
+ * `stalled` is released: a stream that dies after starting (starved MSE,
+ * a dropped live source) never fires `pause` or `ended`. Its next `playing`
+ * tracks it again.
+ */
+export const PLAYBACK_STALL_RELEASE_MS = 60_000;
+
 /**
  * Keeps the display awake while any built-in web player (HTML5/hls.js,
  * Video.js, ArtPlayer) is playing video (issue #1095).
@@ -50,6 +61,10 @@ export class PlaybackKeepAwakeService {
     private started = false;
     private readonly playingVideos = new Set<HTMLVideoElement>();
     private readonly releaseCleanups = new Map<HTMLVideoElement, () => void>();
+    private readonly stallChecks = new Map<
+        HTMLVideoElement,
+        { handle: ReturnType<typeof setTimeout>; time: number }
+    >();
 
     private lastSentToBridge: boolean | null = null;
     private wakeLock: WakeLockSentinelLike | null = null;
@@ -127,17 +142,58 @@ export class PlaybackKeepAwakeService {
         }
         this.playingVideos.add(video);
         const onRelease = () => this.untrackVideo(video);
+        const onStall = () => this.scheduleStallCheck(video);
+        const onResume = () => this.clearStallCheck(video);
         for (const type of RELEASE_EVENTS) {
             video.addEventListener(type, onRelease);
         }
+        for (const type of STALL_EVENTS) {
+            video.addEventListener(type, onStall);
+        }
+        video.addEventListener('playing', onResume);
         this.releaseCleanups.set(video, () => {
+            video.removeEventListener('playing', onResume);
             for (const type of RELEASE_EVENTS) {
                 video.removeEventListener(type, onRelease);
             }
+            for (const type of STALL_EVENTS) {
+                video.removeEventListener(type, onStall);
+            }
         });
         this.sync();
     }
 
+    /**
+     * Judged by progress, not by the event: `stalled` also fires while the
+     * buffer still plays. A pending check restarts only when the video moved
+     * since it was taken (a recovery followed by a new stall), so repeated
+     * stall events on a frozen video cannot postpone the release. A video
+     * that moved is checked again until `playing` reports it resumed: it may
+     * advance a little and freeze without another event.
+     */
+    private scheduleStallCheck(video: HTMLVideoElement): void {
+        const pending = this.stallChecks.get(video);
+        if (pending && pending.time === video.currentTime) {
+            return;
+        }
+        clearTimeout(pending?.handle);
+        const time = video.currentTime;
+        const handle = setTimeout(() => {
+            this.stallChecks.delete(video);
+            if (video.currentTime === time) {
+                this.untrackVideo(video);
+            } else {
+                this.scheduleStallCheck(video);
+            }
+        }, PLAYBACK_STALL_RELEASE_MS);
+        this.stallChecks.set(video, { handle, time });
+    }
+
+    private clearStallCheck(video: HTMLVideoElement): void {
+        clearTimeout(this.stallChecks.get(video)?.handle);
+        this.stallChecks.delete(video);
+    }
+
     private untrackVideo(video: HTMLVideoElement): void {
         if (!this.playingVideos.delete(video)) {
             return;
@@ -145,6 +201,7 @@ export class PlaybackKeepAwakeService {
         const cleanup = this.releaseCleanups.get(video);
         this.releaseCleanups.delete(video);
         cleanup?.();
+        this.clearStallCheck(video);
         this.sync();
     }
 
diff --git a/docs/architecture/parental-lock.md b/docs/architecture/parental-lock.md
index ff04565bdd..a1e4288658 100644
--- a/docs/architecture/parental-lock.md
+++ b/docs/architecture/parental-lock.md
@@ -31,7 +31,9 @@ follow in a second PR.
   player counts as interaction, so a film never locks half way — video
   through the keep-awake tracker, and audio (the radio player) read from
   the playing `<audio>` elements, since the keep-awake service ignores
-  them.
+  them. Players outside the page count too (see "External players"): an
+  Embedded MPV session while `playing`, an MPV/VLC film or episode while
+  its reported position moves.
 - This is a child lock, not a security boundary: the PIN hash and the lock
   store sit in user-readable app data. The UI says so. There is no PIN
   recovery; resetting the app data is the way out.
@@ -582,6 +584,44 @@ opinion" and restore leaves the target's locks alone; present replaces them
 (`replacePlaylistLocks`, which also re-stamps the Xtream index). The PIN is
 never exported.
 
+## External players
+
+MPV/VLC play in their own process, and the session the main process
+reports carries no category. `ParentalLockExternalSessions`
+(`apps/web/src/app/services/parental-lock-external-sessions.ts`), started
+by the enforcement service, tracks every session from
+`onExternalPlayerSessionUpdate`:
+
+- **Relock.** A session whose media was opened while unlocked — a launch,
+  or an in-place switch of a reused player (a changed stream URL; status
+  reports do not count) — is closed on relock when its source may hold
+  withheld content: the lock store is unreadable, or the source has a
+  locked category (any source has, when the source cannot be told). The
+  source is the session's `contentInfo.playlistId`, otherwise the source
+  route the launch was made from; a launch from a global page (dashboard,
+  favorites, search) has none. A session first reported after a relock it
+  started before raced that relock and counts as opened while unlocked. A
+  session opened while locked came from the filtered catalog and keeps
+  playing. Closing uses `closeExternalPlayerSession(id, true)` and hides
+  the session from the dock first; a launch without a closer yet is closed
+  on its next update, a rejected close is retried every second, and a
+  session that cannot be closed (`canClose: false`) is only hidden — shown
+  again if the session is unlocked before it closes.
+- **Owners.** A feature that knows the category of its sessions claims them
+  through `ParentalLockSessionOwners` (`libs/services`) and closes only
+  those in a withheld category. Xtream Live does:
+  `XtreamExternalLiveSessions` keeps the playing channel's category and
+  closes a session of a withheld one, so an unlocked channel keeps
+  playing.
+- **Idle relock.** Embedded MPV counts as busy while any session is
+  `playing` (two with multiview). An MPV/VLC film or episode counts while
+  its position, reported every 5 s, moved within the last 15 s, so a pause
+  lets the timer run. A session that reports no position does not count,
+  like live MPV/VLC: those players cannot report a pause, and an open,
+  paused window must not keep the app unlocked indefinitely. Positions
+  need `contentInfo` and, for MPV, the IPC socket, so this also covers M3U
+  films (no `contentInfo`) and Flatpak MPV (no socket bridge).
+
 ## Not yet covered (phase 2)
 
 Favorites, recently viewed, playback positions / Continue Watching, the
@@ -603,6 +643,7 @@ predicate is `ParentalLockService.is*Locked`.
   persisted lock set, its unreadable state and the SQLite re-stamp),
   `apps/web/src/app/services/parental-lock-prompt.service.ts`,
   `parental-lock-enforcement.service.ts`,
+  `parental-lock-external-sessions.ts` (MPV/VLC and Embedded MPV),
   `apps/web/src/app/settings/settings-parental-section.component.*` and `settings-parental-lock.facade.ts` (rows anchored and indexed for settings search),
   `libs/ui/components/src/lib/parental-lock-pin-dialog/`,
   `libs/portal/stalker/feature/src/lib/stalker-category-lock-dialog/`.
diff --git a/docs/architecture/player-controls-contract.md b/docs/architecture/player-controls-contract.md
index dcfc9583c3..23e343330c 100644
--- a/docs/architecture/player-controls-contract.md
+++ b/docs/architecture/player-controls-contract.md
@@ -1953,6 +1953,12 @@ capture listeners because media events do not bubble. Release listeners also
 attach to the tracked element: Chromium's pause after DOM removal never reaches
 the document. A playing video holds a display-sleep lock only while the document
 is visible or that video is in picture-in-picture, which survives minimization.
+A tracked video that fires `waiting` or `stalled` and then does not advance for
+60 seconds is released too (`PLAYBACK_STALL_RELEASE_MS`): a stream that dies
+after starting fires neither `pause` nor `ended`. It is judged by `currentTime`,
+since `stalled` also fires while the buffer still plays; a video that moved is
+checked again until `playing` reports it resumed. After a release the next
+`playing` tracks the video again.
 In Electron this relies on the main window keeping Chromium background
 throttling on: with `backgroundThrottling: false` a minimized window keeps
 reporting `visible`, so the gate would never release the display.
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
index 97c2c5cbf0..40c4a8981b 100644
--- a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.spec.ts
@@ -1,7 +1,10 @@
 import { signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 import { PORTAL_EXTERNAL_PLAYBACK } from '@iptvnator/portal/shared/util';
-import { ParentalLockService } from '@iptvnator/services';
+import {
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
 import type { ExternalPlayerSession } from '@iptvnator/shared/interfaces';
 import { XtreamExternalLiveSessions } from './xtream-external-live-sessions.service';
 
@@ -150,6 +153,23 @@ describe('XtreamExternalLiveSessions', () => {
         expect(closeSession).not.toHaveBeenCalled();
     });
 
+    it('claims its launches from the app-wide relock closer', () => {
+        const owners = TestBed.inject(ParentalLockSessionOwners);
+        const { finish, launchId } = guard.begin(original);
+        const launching = {
+            ...session('owned', oldUrl, 'launching'),
+            launchId,
+        };
+        expect(owners.isOwned(launching)).toBe(true);
+
+        finish({ ...launching, status: 'opened', canClose: true });
+        expect(owners.isOwned(session('owned', oldUrl, 'opened'))).toBe(true);
+        expect(owners.isOwned(session('other', newUrl, 'opened'))).toBe(false);
+
+        receive(session('owned', oldUrl, 'closed'));
+        expect(owners.isOwned(session('owned', oldUrl, 'opened'))).toBe(false);
+    });
+
     it('does not restore the old category when a launch response arrives after a copy switch', () => {
         const { finish, launchId } = guard.begin(original);
         const opened = { ...session('old', oldUrl, 'opened'), launchId };
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
index 24213cc2e9..e311f85991 100644
--- a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-external-live-sessions.service.ts
@@ -10,8 +10,10 @@ import {
     isLiveExternalPlayerSession,
     PORTAL_EXTERNAL_PLAYBACK,
 } from '@iptvnator/portal/shared/util';
-import { ParentalLockService } from '@iptvnator/services';
-import type { XtreamPlaylistData } from '@iptvnator/portal/xtream/data-access';
+import {
+    ParentalLockService,
+    ParentalLockSessionOwners,
+} from '@iptvnator/services';
 import type {
     EpgProgram,
     ExternalPlayerSession,
@@ -28,35 +30,13 @@ import {
     type GuideLaunchOutcome,
     type XtreamOwnedLaunch as Launch,
 } from './xtream-native-handoff';
+import { sameXtreamLiveOwner, type XtreamLiveOwner } from './xtream-live-owner';
 
-export type XtreamLiveOwner = Pick<
-    XtreamPlaylistData,
-    'serverUrl' | 'username' | 'password'
-> & {
-    playlistId: string;
-};
-
-export function captureXtreamLiveOwner(
-    playlist?: XtreamPlaylistData | null
-): XtreamLiveOwner | undefined {
-    if (!playlist?.id) return undefined;
-    const { id: playlistId, serverUrl, username, password } = playlist;
-    return { playlistId, serverUrl, username, password };
-}
-
-export function sameXtreamLiveOwner(
-    left: XtreamLiveOwner | undefined,
-    right: XtreamLiveOwner | undefined
-): boolean {
-    return (
-        !!left &&
-        !!right &&
-        left.playlistId === right.playlistId &&
-        left.serverUrl === right.serverUrl &&
-        left.username === right.username &&
-        left.password === right.password
-    );
-}
+export {
+    captureXtreamLiveOwner,
+    sameXtreamLiveOwner,
+    type XtreamLiveOwner,
+} from './xtream-live-owner';
 
 export interface XtreamLiveSource extends XtreamLiveOwner {
     categoryId: number | null | 'unknown';
@@ -118,7 +98,15 @@ export class XtreamExternalLiveSessions {
         const unsubscribe = window.electron?.onExternalPlayerSessionUpdate?.(
             (session) => this.update(session)
         );
+        // Relock closes only sessions of a withheld category (enforce), so
+        // the app-wide closer for uncategorized sessions leaves these alone.
+        const release = inject(ParentalLockSessionOwners).claim(
+            (session) =>
+                this.sessions.has(session.id) ||
+                (!!session.launchId && this.pending.has(session.launchId))
+        );
         this.destroyRef.onDestroy(() => {
+            release();
             unsubscribe?.();
             this.sessions.forEach((entry) => clearTimeout(entry.retry));
         });
diff --git a/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts
new file mode 100644
index 0000000000..712b8b2795
--- /dev/null
+++ b/libs/portal/xtream/feature/src/lib/live-stream-layout/xtream-live-owner.ts
@@ -0,0 +1,30 @@
+import type { XtreamPlaylistData } from '@iptvnator/portal/xtream/data-access';
+
+export type XtreamLiveOwner = Pick<
+    XtreamPlaylistData,
+    'serverUrl' | 'username' | 'password'
+> & {
+    playlistId: string;
+};
+
+export function captureXtreamLiveOwner(
+    playlist?: XtreamPlaylistData | null
+): XtreamLiveOwner | undefined {
+    if (!playlist?.id) return undefined;
+    const { id: playlistId, serverUrl, username, password } = playlist;
+    return { playlistId, serverUrl, username, password };
+}
+
+export function sameXtreamLiveOwner(
+    left: XtreamLiveOwner | undefined,
+    right: XtreamLiveOwner | undefined
+): boolean {
+    return (
+        !!left &&
+        !!right &&
+        left.playlistId === right.playlistId &&
+        left.serverUrl === right.serverUrl &&
+        left.username === right.username &&
+        left.password === right.password
+    );
+}
diff --git a/libs/services/src/lib/parental-lock/index.ts b/libs/services/src/lib/parental-lock/index.ts
index 00b264892b..e706f802dc 100644
--- a/libs/services/src/lib/parental-lock/index.ts
+++ b/libs/services/src/lib/parental-lock/index.ts
@@ -1,5 +1,6 @@
 export * from './parental-lock-idle-timer';
 export * from './parental-lock-prompt.token';
+export * from './parental-lock-session-owners';
 export * from './parental-lock-lock-store.service';
 export * from './parental-lock-playlist-cleanup';
 export * from './parental-lock-storage';
diff --git a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
index afde973dfb..0400a031e2 100644
--- a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
+++ b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.spec.ts
@@ -107,6 +107,30 @@ describe('ParentalLockLockStore', () => {
         expect(store.readable()).toBe(true);
     });
 
+    it('tells which sources have a locked category', async () => {
+        storage.readLocks.mockResolvedValueOnce({
+            ...stored,
+            'pl-2': { xtream: [], stalker: [], m3u: [] },
+            'pl-3': { xtream: [], stalker: [], m3u: ['Synthetic Group'] },
+        });
+        await store.load();
+
+        expect(store.hasLocks('pl-1')).toBe(true);
+        expect(store.hasLocks('pl-2')).toBe(false);
+        expect(store.hasLocks('pl-3')).toBe(true);
+        expect(store.hasLocks('pl-4')).toBe(false);
+        expect(store.hasLocks(null)).toBe(true);
+    });
+
+    it('reports no locked source when every entry is empty', async () => {
+        storage.readLocks.mockResolvedValueOnce({
+            'pl-2': { xtream: [], stalker: [], m3u: [] },
+        });
+        await store.load();
+
+        expect(store.hasLocks(null)).toBe(false);
+    });
+
     it('re-derives the SQLite index from the store on load', async () => {
         await store.load();
         // ensureReadable awaits the reconcile that load() started.
diff --git a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
index 76c210bf8e..87a866739a 100644
--- a/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
+++ b/libs/services/src/lib/parental-lock/parental-lock-lock-store.service.ts
@@ -208,6 +208,20 @@ export class ParentalLockLockStore {
         return this.locks()[playlistId]?.m3u ?? [];
     }
 
+    /** Whether the source (any source when `null`) has a locked category. */
+    hasLocks(playlistId: string | null): boolean {
+        const store = this.locks();
+        const entries =
+            playlistId === null ? Object.values(store) : [store[playlistId]];
+        return entries.some(
+            (locks) =>
+                !!locks &&
+                (locks.xtream.length > 0 ||
+                    locks.stalker.length > 0 ||
+                    locks.m3u.length > 0)
+        );
+    }
+
     /**
      * Every mutation re-reads a store that failed to read BEFORE building
      * the edit: `locksFor` on the empty fail-closed store would otherwise
diff --git a/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts b/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts
new file mode 100644
index 0000000000..ec84c01624
--- /dev/null
+++ b/libs/services/src/lib/parental-lock/parental-lock-session-owners.ts
@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import type { ExternalPlayerSession } from '@iptvnator/shared/interfaces';
+
+/**
+ * External player sessions whose parental lock a feature enforces itself.
+ *
+ * The app-wide relock closes MPV/VLC sessions it cannot judge (their
+ * category is not on the session). A feature that knows the category of the
+ * sessions it launched — Xtream Live keeps the playing channel's category —
+ * claims them here, so the generic closer leaves them to the owner, which
+ * closes only those in a now-withheld category.
+ */
+@Injectable({ providedIn: 'root' })
+export class ParentalLockSessionOwners {
+    private readonly owners = new Set<
+        (session: ExternalPlayerSession) => boolean
+    >();
+
+    /** Registers an ownership test. Returns the unregister function. */
+    claim(owns: (session: ExternalPlayerSession) => boolean): () => void {
+        this.owners.add(owns);
+        return () => this.owners.delete(owns);
+    }
+
+    isOwned(session: ExternalPlayerSession): boolean {
+        return [...this.owners].some((owns) => owns(session));
+    }
+}

From a6bd2f1698ecbf3edd04ad9af5268cd110076571 Mon Sep 17 00:00:00 2001
From: Mahmut YUM <mahmut_yum@hotmail.com>
Date: Sun, 15 Nov 2026 02:07:49 +0300
Subject: [PATCH 2/2] fix(parental-lock): close players a reloaded page left
 running

A renderer reload or crash cleared the tracked sessions while MPV/VLC kept
running. The page now reads the open sessions from the main process on
start, and treats any session that started before it as opened while
unlocked with an unknown source, so the relock rule still closes it.
---
 .changes/parental-lock-external-players.md    |  2 +-
 .../src/parental-lock-external-player.e2e.ts  | 26 ++++++++--
 .../src/app/api/main.preload.ts               |  2 +
 .../external-player-session-registry.spec.ts  | 21 ++++++++
 .../external-player-session-registry.ts       |  7 +++
 .../src/app/events/player.events.ts           |  5 ++
 .../parental-lock-external-sessions.spec.ts   | 52 ++++++++++++++++++-
 .../parental-lock-external-sessions.ts        | 19 ++++++-
 docs/architecture/parental-lock.md            |  7 +++
 .../src/lib/electron-api.interface.ts         |  2 +
 .../shared/interfaces/src/lib/ipc-commands.ts |  1 +
 11 files changed, 137 insertions(+), 7 deletions(-)

diff --git a/.changes/parental-lock-external-players.md b/.changes/parental-lock-external-players.md
index f381c2cab9..18d9aa515a 100644
--- a/.changes/parental-lock-external-players.md
+++ b/.changes/parental-lock-external-players.md
@@ -3,4 +3,4 @@ type: fix
 area: parental-lock
 ---
 
-Locking the app again now closes an MPV or VLC window opened while it was unlocked from a source with locked categories. Films in MPV, VLC and Embedded MPV no longer lock half way. A stream that stops playing no longer keeps the screen awake and the app unlocked.
+Locking the app again now closes an MPV or VLC window opened while it was unlocked from a source with locked categories, also after the window reloads. Films in MPV, VLC and Embedded MPV no longer lock half way. A stream that stops playing no longer keeps the screen awake and the app unlocked.
diff --git a/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
index bc77816b17..69c3dc26a2 100644
--- a/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
+++ b/apps/electron-backend-e2e/src/parental-lock-external-player.e2e.ts
@@ -13,6 +13,7 @@ import {
     test,
     waitForXtreamWorkspaceReady,
 } from './electron-test-fixtures';
+import { reloadFromMainProcess } from './renderer-reload.support';
 
 const PIN = '2468';
 const PID_KEY = '__parentalLockPlayerPids';
@@ -76,10 +77,11 @@ async function enterPin(page: Page): Promise<void> {
 
 /**
  * A relock closes an MPV session opened while unlocked from a source with
- * a locked category, and leaves one opened while locked. The native process
- * boundary is replaced by a quiet, long-lived child; CI installs no MPV.
+ * a locked category, and leaves one opened while locked; a renderer reload
+ * closes one the unlocked page left running. The native process boundary is
+ * replaced by a quiet, long-lived child; CI installs no MPV.
  */
-test('@electron @parental @playback relock closes an MPV session opened while unlocked', async ({
+test('@electron @parental @playback relock and reload close an MPV session opened while unlocked', async ({
     dataDir,
 }) => {
     test.setTimeout(120_000);
@@ -174,6 +176,24 @@ test('@electron @parental @playback relock closes an MPV session opened while un
         // eslint-disable-next-line playwright/no-wait-for-timeout
         await page.waitForTimeout(3_000);
         expect(playerIsAlive(lockedPid)).toBe(true);
+        stopPlayer(lockedPid);
+
+        // A reload forgets what the page saw; the new page starts locked and
+        // closes a player still running from the unlocked page.
+        await lockButton.click();
+        await enterPin(page);
+        await expect(lockButton).not.toHaveClass(/is-active/);
+        const reloadedPid = await launchPlayer(
+            app,
+            playerPath,
+            'Synthetic launch before a reload'
+        );
+        pids.push(reloadedPid);
+        await reloadFromMainProcess(app);
+        await expect(page.getByTestId('header-parental-lock')).toHaveClass(
+            /is-active/
+        );
+        await expect.poll(() => playerIsAlive(reloadedPid)).toBe(false);
     } finally {
         pids.forEach(stopPlayer);
         await closeElectronApp(app);
diff --git a/apps/electron-backend/src/app/api/main.preload.ts b/apps/electron-backend/src/app/api/main.preload.ts
index 4e1a177caa..b4b120a6be 100644
--- a/apps/electron-backend/src/app/api/main.preload.ts
+++ b/apps/electron-backend/src/app/api/main.preload.ts
@@ -631,6 +631,8 @@ const electronApi: ElectronBridgeApi = {
             sessionId,
             ...(exact ? [true] : [])
         ),
+    listExternalPlayerSessions: (): Promise<ExternalPlayerSession[]> =>
+        ipcRenderer.invoke('LIST_EXTERNAL_PLAYER_SESSIONS'),
     getEmbeddedMpvSupport: (): Promise<EmbeddedMpvSupport> =>
         ipcRenderer.invoke('EMBEDDED_MPV_SUPPORT'),
     prepareEmbeddedMpv: (): Promise<EmbeddedMpvSupport> =>
diff --git a/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts b/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
index d0dcccde09..6c70baaa25 100644
--- a/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
+++ b/apps/electron-backend/src/app/events/external-player-session-registry.spec.ts
@@ -55,6 +55,27 @@ describe('ExternalPlayerSessionRegistry', () => {
         );
     });
 
+    it('lists the sessions whose player may still run', () => {
+        const begin = (title: string) =>
+            registry.beginSession({
+                player: 'mpv',
+                title,
+                streamUrl: 'https://streams.example.test/one.m3u8',
+            });
+        const launching = begin('Launching');
+        const opened = begin('Opened');
+        const closed = begin('Closed');
+        const failed = begin('Failed');
+        registry.markOpened(opened.id);
+        registry.markClosed(closed.id);
+        registry.markError(failed.id, 'synthetic failure');
+
+        expect(registry.listOpenSessions().map(({ id }) => id)).toEqual([
+            launching.id,
+            opened.id,
+        ]);
+    });
+
     it('keeps close capability and closes the session explicitly', async () => {
         const session = registry.beginSession({
             player: 'vlc',
diff --git a/apps/electron-backend/src/app/events/external-player-session-registry.ts b/apps/electron-backend/src/app/events/external-player-session-registry.ts
index b143d9457c..0a5cf3d6e6 100644
--- a/apps/electron-backend/src/app/events/external-player-session-registry.ts
+++ b/apps/electron-backend/src/app/events/external-player-session-registry.ts
@@ -96,6 +96,13 @@ export class ExternalPlayerSessionRegistry {
         return this.sessions.get(id)?.snapshot ?? null;
     }
 
+    /** Every session whose player may still be running. */
+    listOpenSessions(): ExternalPlayerSession[] {
+        return [...this.sessions.values()]
+            .map(({ snapshot }) => snapshot)
+            .filter(isRestorableSession);
+    }
+
     isNewerLaunch(id: string | null, session: ExternalPlayerSession): boolean {
         const order = id ? this.getSession(id)?.launchOrder : undefined;
         return (order ?? 0) > (session.launchOrder ?? 0);
diff --git a/apps/electron-backend/src/app/events/player.events.ts b/apps/electron-backend/src/app/events/player.events.ts
index bb52f8734c..fbfb2b606e 100644
--- a/apps/electron-backend/src/app/events/player.events.ts
+++ b/apps/electron-backend/src/app/events/player.events.ts
@@ -1,6 +1,7 @@
 import { ipcMain } from 'electron';
 import {
     CLOSE_EXTERNAL_PLAYER_SESSION,
+    LIST_EXTERNAL_PLAYER_SESSIONS,
     type ExternalPlayerName,
     PLAYBACK_SET_KEEP_AWAKE,
     PlayerContentInfo,
@@ -188,6 +189,10 @@ ipcMain.handle(
     }
 );
 
+ipcMain.handle(LIST_EXTERNAL_PLAYER_SESSIONS, () =>
+    externalPlayerSessions.listOpenSessions()
+);
+
 ipcMain.handle(PLAYBACK_SET_KEEP_AWAKE, (event, active: boolean) => {
     setPlaybackKeepAwake(event.sender, active === true);
 });
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.spec.ts b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
index 7408364b86..de3de0316e 100644
--- a/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
+++ b/apps/web/src/app/services/parental-lock-external-sessions.spec.ts
@@ -30,8 +30,8 @@ function session(
         status: 'playing',
         title: 'Synthetic Film',
         streamUrl: 'http://stream.example/film.mkv',
-        startedAt: new Date(1_000).toISOString(),
-        updatedAt: new Date(1_000).toISOString(),
+        startedAt: new Date(15_000).toISOString(),
+        updatedAt: new Date(15_000).toISOString(),
         canClose: true,
         ...overrides,
     };
@@ -50,6 +50,7 @@ describe('ParentalLockExternalSessions', () => {
     let emitSession: Listener<ExternalPlayerSession>;
     let emitPosition: Listener<PlaybackPositionData>;
     let emitEmbedded: Listener<EmbeddedMpvSession>;
+    let listed: ExternalPlayerSession[];
     let service: ParentalLockExternalSessions;
 
     /** Lock now: the enforcement calls `onLockChange` on the new version. */
@@ -71,8 +72,10 @@ describe('ParentalLockExternalSessions', () => {
                 session({ id, status: 'closed', canClose: false })
         );
         router = { url: '/workspace/playlists/m3u-1/all' };
+        listed = [];
         (window as { electron?: unknown }).electron = {
             closeExternalPlayerSession,
+            listExternalPlayerSessions: async () => listed,
             onExternalPlayerSessionUpdate: (
                 callback: Listener<ExternalPlayerSession>
             ) => (emitSession = callback),
@@ -333,6 +336,51 @@ describe('ParentalLockExternalSessions', () => {
             }
         );
 
+        describe('sessions still running from before the page loaded', () => {
+            const earlier = () =>
+                session({ startedAt: new Date(5_000).toISOString() });
+
+            /** A reloaded page: a fresh service, started while locked. */
+            const reloadedPage = () => {
+                active.set(true);
+                const page = TestBed.runInInjectionContext(
+                    () => new ParentalLockExternalSessions()
+                );
+                page.now = () => clock;
+                page.start();
+                return page;
+            };
+
+            it('closes one the main process lists, judged as any source', async () => {
+                listed = [earlier()];
+                reloadedPage();
+                await flush();
+
+                expect(hasLocks).toHaveBeenCalledWith(null);
+                expect(closeExternalPlayerSession).toHaveBeenCalledWith(
+                    'session-1',
+                    true
+                );
+            });
+
+            it('closes one first reported by an update after the reload', () => {
+                reloadedPage();
+                emitSession(earlier());
+
+                expect(hasLocks).toHaveBeenCalledWith(null);
+                expect(closeExternalPlayerSession).toHaveBeenCalled();
+            });
+
+            it('keeps one when no source has a locked category', async () => {
+                hasLocks.mockReturnValue(false);
+                listed = [earlier()];
+                reloadedPage();
+                await flush();
+
+                expect(closeExternalPlayerSession).not.toHaveBeenCalled();
+            });
+        });
+
         it('forgets a closed session', () => {
             emitSession(session());
             emitSession(session({ status: 'closed', canClose: false }));
diff --git a/apps/web/src/app/services/parental-lock-external-sessions.ts b/apps/web/src/app/services/parental-lock-external-sessions.ts
index 513f05e003..dbed90d5de 100644
--- a/apps/web/src/app/services/parental-lock-external-sessions.ts
+++ b/apps/web/src/app/services/parental-lock-external-sessions.ts
@@ -68,6 +68,7 @@ export class ParentalLockExternalSessions {
     private readonly sessions = new Map<string, Tracked>();
     private readonly embeddedPlaying = new Set<string>();
     private lockedAt = Number.NEGATIVE_INFINITY;
+    private pageStartedAt = Number.NEGATIVE_INFINITY;
     private started = false;
 
     /** The clock; a field so specs can substitute it. */
@@ -78,6 +79,10 @@ export class ParentalLockExternalSessions {
             return;
         }
         this.started = true;
+        // A page starts locked (or with the feature off), and a session it
+        // did not see open — still running across a reload or a crashed
+        // renderer — has an unknown history: treated as opened unlocked.
+        this.pageStartedAt = this.lockedAt = this.now();
         const bridge = window.electron;
         bridge?.onExternalPlayerSessionUpdate?.((session) =>
             this.observe(session)
@@ -88,6 +93,14 @@ export class ParentalLockExternalSessions {
         bridge?.onEmbeddedMpvSessionUpdate?.((session) =>
             this.observeEmbedded(session)
         );
+        void bridge
+            ?.listExternalPlayerSessions?.()
+            .then((sessions) =>
+                sessions.forEach((session) => {
+                    if (!this.sessions.has(session.id)) this.observe(session);
+                })
+            )
+            .catch(() => undefined);
     }
 
     /** Called on every lock version change: closes on relock, shows on unlock. */
@@ -124,7 +137,11 @@ export class ParentalLockExternalSessions {
         const entry: Tracked = current ?? {
             session,
             tainted: false,
-            sourceId: this.routeSourceId(),
+            // The route at a reload is not the one the launch was made from.
+            sourceId:
+                Date.parse(session.startedAt) < this.pageStartedAt
+                    ? null
+                    : this.routeSourceId(),
             closing: false,
         };
         // New media while unlocked: a launch, or an in-place switch of a
diff --git a/docs/architecture/parental-lock.md b/docs/architecture/parental-lock.md
index a1e4288658..1a24f5145b 100644
--- a/docs/architecture/parental-lock.md
+++ b/docs/architecture/parental-lock.md
@@ -607,6 +607,13 @@ by the enforcement service, tracks every session from
   on its next update, a rejected close is retried every second, and a
   session that cannot be closed (`canClose: false`) is only hidden — shown
   again if the session is unlocked before it closes.
+- **Reload.** A page starts locked (or with the feature off) and knows
+  nothing of earlier sessions. On start it reads the sessions still open
+  in the main process (`listExternalPlayerSessions`); a session that
+  started before the page — listed, or first reported by a later update —
+  has an unknown history and counts as opened while unlocked, with an
+  unknown source. A player left running by a reloaded or crashed page is
+  therefore closed under the same rule.
 - **Owners.** A feature that knows the category of its sessions claims them
   through `ParentalLockSessionOwners` (`libs/services`) and closes only
   those in a withheld category. Xtream Live does:
diff --git a/libs/shared/interfaces/src/lib/electron-api.interface.ts b/libs/shared/interfaces/src/lib/electron-api.interface.ts
index 9bbfecdff1..b6a7b1ce46 100644
--- a/libs/shared/interfaces/src/lib/electron-api.interface.ts
+++ b/libs/shared/interfaces/src/lib/electron-api.interface.ts
@@ -1398,6 +1398,8 @@ export interface ElectronBridgeApi {
         sessionId: string,
         exact?: boolean
     ) => Promise<ExternalPlayerSession | null>;
+    /** Sessions still open in the main process, e.g. after a page reload. */
+    listExternalPlayerSessions?: () => Promise<ExternalPlayerSession[]>;
     getEmbeddedMpvSupport: () => Promise<EmbeddedMpvSupport>;
     prepareEmbeddedMpv?: () => Promise<EmbeddedMpvSupport>;
     createEmbeddedMpvSession: (
diff --git a/libs/shared/interfaces/src/lib/ipc-commands.ts b/libs/shared/interfaces/src/lib/ipc-commands.ts
index 08a4f715d5..3c929f56cb 100644
--- a/libs/shared/interfaces/src/lib/ipc-commands.ts
+++ b/libs/shared/interfaces/src/lib/ipc-commands.ts
@@ -63,6 +63,7 @@ export const OPEN_VLC_PLAYER = 'OPEN_VLC_PLAYER';
 export const SET_VLC_PLAYER_PATH = 'SET_VLC_PLAYER_PATH';
 export const SET_VLC_REUSE_INSTANCE = 'SET_VLC_REUSE_INSTANCE';
 export const CLOSE_EXTERNAL_PLAYER_SESSION = 'CLOSE_EXTERNAL_PLAYER_SESSION';
+export const LIST_EXTERNAL_PLAYER_SESSIONS = 'LIST_EXTERNAL_PLAYER_SESSIONS';
 export const EXTERNAL_PLAYER_SESSION_UPDATE = 'EXTERNAL_PLAYER_SESSION_UPDATE';
 export const EMBEDDED_MPV_SUPPORT = 'EMBEDDED_MPV_SUPPORT';
 export const EMBEDDED_MPV_CREATE_SESSION = 'EMBEDDED_MPV_CREATE_SESSION';