diff --git a/.changes/README.md b/.changes/README.md
index 318217075..ac69427f5 100644
--- a/.changes/README.md
+++ b/.changes/README.md
@@ -55,8 +55,10 @@ The body is capped at 400 characters — depth belongs in the blog post.
 gives it a short, poster-worthy name. The 60-character cap keeps it roughly to
 one line on the hero card; card text wraps by estimated width, so a headline of
 unusually wide glyphs may still wrap or ellipsize rather than overflow. Highlights lead the Telegram/Reddit
-announcements (everything else collapses into a "+N more" counter) and become
-ready-made section headings in the blog scaffold. Set it on the two or three
+announcements (everything else collapses into a "+N more" counter) and open the
+blog scaffold: a row in its "What changed" table and a `##` section ahead of
+the themed sections, while fixes without a highlight collapse under a spoiler
+there. Set it on the two or three
 changes worth announcing — a release where everything is a highlight has none.
 Not allowed on `type: internal`.
 
diff --git a/.changes/embedded-mpv-extra-options-reconnect.md b/.changes/embedded-mpv-extra-options-reconnect.md
new file mode 100644
index 000000000..8e5d60152
--- /dev/null
+++ b/.changes/embedded-mpv-extra-options-reconnect.md
@@ -0,0 +1,11 @@
+---
+type: feature
+area: embedded-mpv
+highlight: Embedded MPV reconnects dropped streams
+---
+
+The embedded MPV player now reloads a live stream that drops mid-playback on
+its own, with increasing delays and an "attempt N of 6" line instead of a
+dead error screen; a new Settings > Playback toggle turns this off. The same
+section gains an advanced field for extra libmpv options (one key=value per
+line) that applies on every engine, with a short network timeout on by default.
diff --git a/.changes/playback-shortcuts-after-button-click.md b/.changes/playback-shortcuts-after-button-click.md
new file mode 100644
index 000000000..0067f1a7a
--- /dev/null
+++ b/.changes/playback-shortcuts-after-button-click.md
@@ -0,0 +1,10 @@
+---
+type: fix
+area: playback
+---
+
+Keyboard shortcuts work again right after you click a button in the built-in
+player controls. Previously the clicked button kept the keyboard: after
+clicking fullscreen, Space left fullscreen instead of pausing, and the seek,
+volume and mute keys did nothing until you clicked the video. Applies to the
+shared controls in the web players and the Embedded MPV frame-copy engine.
diff --git a/.changes/playback-videojs-shortcuts-after-button-click.md b/.changes/playback-videojs-shortcuts-after-button-click.md
new file mode 100644
index 000000000..6a9e38625
--- /dev/null
+++ b/.changes/playback-videojs-shortcuts-after-button-click.md
@@ -0,0 +1,10 @@
+---
+type: fix
+area: playback
+---
+
+With IPTVnator's shared controls turned off, the Video.js player's keyboard
+shortcuts now work again right after you click a button in its control bar.
+Previously the clicked button kept the keyboard: after clicking fullscreen,
+Space left fullscreen instead of pausing, and the seek, volume and mute keys
+did nothing until you clicked the video.
diff --git a/.changes/shell-startup-window-mode.md b/.changes/shell-startup-window-mode.md
new file mode 100644
index 000000000..fbe45baa0
--- /dev/null
+++ b/.changes/shell-startup-window-mode.md
@@ -0,0 +1,10 @@
+---
+type: feature
+area: shell
+issues: [1455]
+---
+
+Settings → General has a new "Window on startup" option: open the desktop app
+at its last size, maximized, or fullscreen — handy on a TV or HTPC. Starting
+with `--fullscreen` forces a single fullscreen launch without changing the
+setting, and F11 now toggles fullscreen anywhere in the app.
diff --git a/.changes/stalker-keep-live-playback-on-category-switch.md b/.changes/stalker-keep-live-playback-on-category-switch.md
new file mode 100644
index 000000000..a6ae14ae9
--- /dev/null
+++ b/.changes/stalker-keep-live-playback-on-category-switch.md
@@ -0,0 +1,9 @@
+---
+type: fix
+area: stalker
+---
+
+In Stalker portals, switching the Live TV or radio category in the sidebar no
+longer stops the channel that is playing. The category only changes which
+channels are listed, matching how Xtream portals and M3U playlists already
+behave.
diff --git a/AGENTS.md b/AGENTS.md
index 73276dca9..f3ac937ef 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -213,7 +213,18 @@ Key files:
   discarded on the first bar focus event it is asked about or on any
   `keydown`, a `pointerdown` inside the bar releases a keyboard pin, and a
   `keydown` bubbling out of a bar control re-pins it, since operating a
-  focused control produces no focus event. Contract:
+  focused control produces no focus event. A completed pointer click then
+  releases the focus it left on the control (`onBarClick` →
+  `ControlsSurface.releasePointerFocus`, attributed by `wasPointerClick`:
+  non-empty click `pointerType`, else a recent press inside the clicked
+  element), because a focused control captures the keyboard: Space and
+  Enter re-activated the clicked button and `ControlsShortcuts` yields to
+  any interactive element in the key's path, so after a click on fullscreen
+  Space left fullscreen instead of pausing. Keyboard activation (empty
+  `pointerType`) keeps focus, only buttons and range sliders are released,
+  Chromium keeps its sequential-focus starting point at the blurred control
+  so Tab continues from it, and the volume popover ignores the release's
+  `focusout` (`wasPointerFocusRelease`). Contract:
   `docs/architecture/player-controls-contract.md` (auto-hide paragraph).
 - Persisted `Settings.webPlayerSharedControls` is default-ON (absent stored
   values coerce with `!== false`; only an explicit false opts out to the legacy
@@ -446,7 +457,27 @@ Key files:
   path keeps the existing Video.js skin and legacy series navigation unchanged
   (still without `userActions.hotkeys`), while the playback keyboard shortcuts
   attach through `LegacyPlayerShortcuts` and drive the player API so the
-  vendor control bar stays in sync (`vjs-legacy-shortcuts.ts`).
+  vendor control bar stays in sync (`vjs-legacy-shortcuts.ts`). That chrome
+  also releases the focus a pointer interaction leaves on a control
+  (`vjs-pointer-focus-release.ts`, sharing `pointer-focus-release.ts`'s
+  `blurFocusedControl` with `ControlsSurface`): a focused Video.js component
+  stops every key before the document and turns Space/Enter into a click, so
+  after a click on fullscreen Space left fullscreen instead of pausing. It is
+  driven mainly by `focusin`, not the click, because choosing a menu item
+  moves focus to the menu button a tick later and that click never bubbles to
+  the shell: an eligible control (button/`role=button`/slider, never a menu
+  item) is released when its focus is attributable to a recent shell
+  `pointerdown` not yet ended by a document `keydown`, so `Tab` focus is kept.
+  A `click` runs the same release for a control clicked while already focused
+  (Tab, then a mouse click), which fires no `focusin`. The release is scoped
+  to `.vjs-control-bar`, so the caption-settings dialog (a modal sibling of
+  the bar) keeps its focus trap. Menu buttons live in the bar and are not
+  exempt: a popup is navigated through its focused item, so releasing the
+  button never disturbs an open menu, and the button focus a pointer moves
+  through (open, item selection, toggling an open menu shut) is released so
+  Space works again after the menu closes. ArtPlayer
+  (non-focusable divs) and the native HTML5 controls (focus lands on the
+  `<video>`) need no counterpart.
 - ArtPlayer is the fourth guarded consumer. `ArtPlayerComponent` provides a
   component-scoped `WebVideoControlsAdapter`; `ArtPlayerSourceSession` owns
   HLS/DASH(Shaka)/MPEG-TS/native sources, the neutral web-video bridge, exact cleanup, and
diff --git a/CLAUDE.md b/CLAUDE.md
index 420d4ab9a..48fd8ee70 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -32,7 +32,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - Name it `<area>-<short-slug>.md`; `area` matches the conventional-commit scope. There is no version field — the release version is chosen at release time.
 - Write the body for a user, not a reviewer: "the player now remembers volume between episodes", not "hoist volume state into the session". Max 400 characters; depth belongs in the release blog post.
 - `type: internal` records invisible maintenance. Internal notes stay collapsed in `CHANGELOG.md`, are omitted from the blog scaffold, and are removed from the authored public GitHub body by `extract-changelog-section.mjs --public`; GitHub's generated commit list remains separate, so an internal-only release can have an empty authored body.
-- `highlight: <short headline>` (max 60 characters, rejected on `type: internal`) marks a note as one of the release's two or three headline changes. Highlights lead the Telegram/Reddit announcement drafts, become ready-made blog section headings, and are the input the highlight-card generator renders from. A release where everything is a highlight has none.
+- `highlight: <short headline>` (max 60 characters, rejected on `type: internal`) marks a note as one of the release's two or three headline changes. Highlights lead the Telegram/Reddit announcement drafts, open the blog scaffold (a "What changed" table row plus a leading `##` section each, while the remaining features fold into themed sections and non-highlighted fixes collapse under a spoiler — `tools/release/release-notes-blog.mjs`), and are the input the highlight-card generator renders from. A release where everything is a highlight has none.
 - Skip the note for test-only changes, docs, CI/workflow plumbing, and pure refactors with no behavior change. When skipping on a PR that touches `apps/**` or `libs/**`, apply the `no-release-note` label.
 - CI enforces this: the "Release note gate" job in `.github/workflows/ci.yml` fails PRs that change runtime code without an added `.changes/*.md` or the label (policy in `tools/release/check-release-note-gate.mjs`; tests/e2e/website/mock-server/docs paths are auto-exempt).
 - The `release-notes` skill covers writing notes; the `release-cut` skill covers the full release sequence. Canonical contract — surfaces, ordering constraints, the required draft asset set: `docs/architecture/release-pipeline.md`.
@@ -41,7 +41,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - Pushes to `master` and `v*` can publish Docker images. A `v*` tag build creates a draft GitHub release.
 - `pnpm run release:verify:draft` waits for that tag build (polling until the run is indexed, then `gh run watch`) and verifies the draft's status, authored body, and complete required asset set. It is read-only and deliberately fails on an already-published release, because it is the gate that runs before publication.
 - Publishing the GitHub release verifies its Snap assets and automatically uploads them to `edge`; installed-Snap smoke and candidate/stable promotion remain manual.
-- Release-post screenshots come only from the release capture script running against the mock servers. Never add a screenshot taken from a real playlist or account to `apps/website/public/blog/**` — real streams, logos, and metadata are copyrighted, and credentials must never reach a published image.
+- Release-post screenshots come only from the release capture script running against the mock servers. Never add a screenshot taken from a real playlist or account to `apps/website/public/blog/**` — real streams, logos, and metadata are copyrighted, and credentials must never reach a published image. Website guide screenshots use the same script: manifest shots with `"group": "guides"` are captured only by `pnpm release:screenshots --group guides` and land in `apps/website/public/blog/guides/screenshots/`.
 - Final task summaries should state whether a release note was added or why it was skipped.
 
 ## Regression Prevention And Test Updates
@@ -187,7 +187,7 @@ Useful narrower flags:
 - `IPTVNATOR_TRACE_DB=1` traces DB worker requests and DB progress events
 - `IPTVNATOR_TRACE_SQL=1` traces SQLite statements in both main and worker connections
 - `IPTVNATOR_TRACE_WINDOW=1` traces BrowserWindow navigation/load lifecycle
-- `IPTVNATOR_TRACE_PLAYER=1` traces external-player activity and bounded Embedded MPV runtime-probe stderr
+- `IPTVNATOR_TRACE_PLAYER=1` traces external-player activity, bounded Embedded MPV runtime-probe stderr, and embedded MPV session status transitions (the input of the reconnect policy; never the stream URL)
 - `IPTVNATOR_TRACE_RENDERER_CONSOLE=1` mirrors renderer console logs into the Electron terminal
 - `IPTVNATOR_PERF_CAPTURE=1` enables development/test-only, redacted M3U and Xtream preload IPC request/completion markers plus count-only M3U acquire/parse/normalize, Xtream main network/JSON-transform/success-response-ready/cancel-dispatch, and renderer store phase capture; renderer wrappers emit only while the benchmark installs its Symbol hook, benchmark tooling sets the flag explicitly, and production launches must leave it unset
 - `IPTVNATOR_PERF_WORKER_PROFILING=1` enables development/test-only, request-scoped worker receive/work/response-post timestamps, thread CPU, event-loop utilization/delay, count-only playlist serialization/SQLite write/read/deserialization plus Xtream category/content/cache-clear/delete/in-source-search phase events, profiling-only worker cancel-receipt acknowledgements, valid-sample-counted isolate peak memory, and the database worker's idle-only one-shot post-GC heap probe; overlapping database requests are explicitly invalidated instead of misattributed, the performance benchmark sets the flag automatically, and production launches must leave it unset
@@ -337,7 +337,7 @@ This is an Nx monorepo with the following structure:
     - **shared/host-health** - Per-host circuit breaker for portal requests (`HostConnectivityGuard`), shared by the Electron main process and the web backend; transport-free, the owning app supplies the clock and owns the instance
     - **shared/database** - Canonical Drizzle schema and DB connection (used by the Electron backend)
     - **shared/m3u-utils** - M3U playlist utilities
-    - **shared/marketing-fixtures** - Provider-neutral fictional movie metadata shared by the Xtream and Stalker marketing mocks
+    - **shared/marketing-fixtures** - Provider-neutral fictional movie metadata, live channel list and the generated channel-logo SVG renderer shared by the Xtream and Stalker marketing mocks (both serve `/assets/marketing/logo/<slug>.svg`)
     - **shared/testing** - Shared test helpers
     - **ui/components** - Reusable UI components (incl. channel list)
     - **ui/epg** - EPG UI (timeline ribbon, multi-EPG, progress panel, program dialogs)
@@ -566,7 +566,7 @@ See `docs/architecture/m3u-playlist-module.md` for complete documentation.
   `/workspace/xtreams/:id/downloads/:downloadId` and
   `/workspace/stalker/:id/downloads/:downloadId`. Focused download details hide
   the workspace context panel.
-- Settings: `/workspace/settings/:section` — one page per section (`general`, `playback`, `epg`, `dashboard`, `remote-control`, `tmdb`, `backup`, `reset`, `about`); `/workspace/settings` redirects to `general`, unknown or capability-gated sections redirect there too, and `/settings` redirects into the workspace. The shared form lives on the parent `SettingsComponent`, so edits survive section switches; a floating unsaved-changes bar (Save/Discard) replaces the old always-visible footer Save button. Leaving the settings AREA with a dirty form triggers `settingsUnsavedChangesGuard` (canDeactivate) and a save/discard/stay dialog — section switches deliberately bypass it, and a failed save cancels the navigation. Non-router exits are covered too: `SettingsUnloadGuardService` (provided by `SettingsComponent`) arms a `beforeunload` handler while the form is dirty (native leave prompt in the PWA) and arms an Electron main-process close guard (`window-close-guard.service.ts`) for the whole settings mount — mount-long on purpose, since arming on the first edit would race the close it protects against. The guard intercepts window close/app quit before `beforeunload` fires and completes the original intent only after the renderer confirms through the same dialog (a pristine form auto-confirms); Electron reloads are cancelled and re-triggered the same way, a failed save always keeps the window open, and installing an app update suspends the whole guard so the updater's quit passes unchallenged — every install entry point (settings About section and the global update notification panel) must go through the root `AppUpdateInstallService`, which owns that suspend/restore choreography
+- Settings: `/workspace/settings/:section` — one page per section (`general`, `playback`, `epg`, `dashboard`, `remote-control`, `tmdb`, `backup`, `reset`, `about`); `/workspace/settings` redirects to `general`, unknown or capability-gated sections redirect there too, and `/settings` redirects into the workspace. The `general` section's "Window on startup" select (`Settings.startupWindowMode`: `normal` / `maximized` / `fullscreen`, Electron only, gated on `RuntimeCapabilitiesService.supportsStartupWindowMode`) is mirrored into the main-process config by the `SETTINGS_UPDATE` handler and read synchronously at the next window creation — the renderer's IndexedDB is unreachable then, so it is the same pattern as `embeddedMpvFrameCopy`; `iptvnator --fullscreen` forces one fullscreen launch without persisting it, and F11 (`WINDOW:TOGGLE_FULLSCREEN`, bound in `WorkspaceKeyboardShortcutsService`, skipped while the player owns `document.fullscreenElement`) is the exit path on Windows/Linux, where the title bar is hidden (contract: `docs/architecture/workspace-shell.md`, "Startup window mode"). The shared form lives on the parent `SettingsComponent`, so edits survive section switches; a floating unsaved-changes bar (Save/Discard) replaces the old always-visible footer Save button. Leaving the settings AREA with a dirty form triggers `settingsUnsavedChangesGuard` (canDeactivate) and a save/discard/stay dialog — section switches deliberately bypass it, and a failed save cancels the navigation. Non-router exits are covered too: `SettingsUnloadGuardService` (provided by `SettingsComponent`) arms a `beforeunload` handler while the form is dirty (native leave prompt in the PWA) and arms an Electron main-process close guard (`window-close-guard.service.ts`) for the whole settings mount — mount-long on purpose, since arming on the first edit would race the close it protects against. The guard intercepts window close/app quit before `beforeunload` fires and completes the original intent only after the renderer confirms through the same dialog (a pristine form auto-confirms); Electron reloads are cancelled and re-triggered the same way, a failed save always keeps the window open, and installing an app update suspends the whole guard so the updater's quit passes unchallenged — every install entry point (settings About section and the global update notification panel) must go through the root `AppUpdateInstallService`, which owns that suspend/restore choreography
 
 **Service Architecture** (Factory Pattern):
 
@@ -700,6 +700,7 @@ This project uses modern Angular signal-based APIs and patterns. **ALWAYS** use
 
 - Bootstraps Electron app and initializes database
 - Registers event handlers for IPC communication
+- Creates the main window per the startup window mode (`app/app.ts` `initMainWindow`, resolver in `app/services/startup-window-mode.ts`): the electron-conf `STARTUP_WINDOW_MODE` mirror or the one-shot `--fullscreen` switch (consumed by the first window, so a window the macOS Dock re-creates in the same process follows the stored setting); `fullscreen: true` is a constructor option that Windows/Linux honour before the first paint, while macOS ignores it on a hidden window, so `ready-to-show` repeats the request after `show()` only when `isFullScreen()` is still false, through the same tracker the F11 toggle uses (`app/services/native-fullscreen-transitions.ts`: per-window fullscreen state seeded once at creation via `trackNativeFullScreen` and fed only by the enter/leave events afterwards, plus a pending record holding the latest target, cleared when an event lands on it, kept when an event lands on the other state, and ignored after 2 s; the tracker only observes and never issues a request itself, since a "repeat on mismatch" cannot be told apart from reversing the user's own green-button action — a toggle is never decided against `isFullScreen()`, which is stale mid-transition and, on Windows, even during the event), so F11 during the startup animation exits instead of re-requesting; `maximize()` waits for `ready-to-show` too (it would show a hidden window early). `attachWindowStateEvents` tracks native and HTML-element fullscreen as two flags OR-ed into `WINDOW:STATE_CHANGED`, because Electron leaves only the HTML state when the window was already natively fullscreen
 - Holds a single-instance lock (`app/services/single-instance.ts`), requested after the `userData` override so E2E runs with their own data dir keep independent locks. A second launch quits and focuses the running window; concurrent instances would otherwise share a Chromium profile whose IndexedDB only one of them can lock, silently breaking renderer-side settings persistence. `IPTVNATOR_ALLOW_MULTIPLE_INSTANCES=1` opts out for local debugging. The guard also forwards that launch's argv and working directory, so `iptvnator playlist.m3u` against a running app opens the playlist instead of being discarded.
 
 **Database**:
@@ -996,7 +997,7 @@ app as a real argument, so it is not an option.
   API. Radio's `<audio>` deliberately never blocks display sleep. Embedded
   MPV holds its own blocker in `EmbeddedMpvNativeService`; external MPV/VLC
   inhibit the screensaver themselves.
-- Embedded MPV (experimental, macOS/Windows/Linux): renders mpv video inside the Electron window through a native addon. macOS uses the libmpv render API in an `NSOpenGLView`; Windows uses in-process libmpv with `--wid` against an app-owned child `HWND`; Linux spawns an out-of-process `mpv --wid=<x11-window>` controlled over a JSON IPC socket (X11/XWayland only, requires system `mpv` on PATH; subtitles/speed/aspect/recording are not exported there). mpv's own screensaver inhibition does not apply to any of these paths, so `EmbeddedMpvNativeService` holds an Electron `powerSaveBlocker` (`prevent-display-sleep`) whenever any session's status is `playing`, and releases it on pause, dispose, or shutdown. Renderer bounds are CSS pixels; the service converts them to native units in the main process (`embedded-mpv-bounds.util.ts`: × page zoom everywhere, × display scale on Windows/Linux whose child windows are positioned in physical pixels; frame-copy bounds stay unscaled), and the session controller re-syncs bounds when `devicePixelRatio` changes and polls (500 ms, drift-gated) for position-only layout shifts that `ResizeObserver` cannot observe. Arrow-key and ±10 s button steps go through the relative `seekEmbeddedMpvBy` IPC (mpv `seek <delta> relative+exact`; addon export `seekBy`, helper stdin command `seek-by`, Linux JSON IPC), never an absolute target computed from the renderer's whole-second, 500 ms-polled `positionSeconds` — that stale base collapsed rapid presses onto one target (about 1 s of progress per press); only the timeline scrub commits an absolute `seek`. Service: `apps/electron-backend/src/app/services/embedded-mpv-native.service.ts`; full architecture: `docs/architecture/embedded-mpv-native.md`.
+- Embedded MPV (experimental, macOS/Windows/Linux): renders mpv video inside the Electron window through a native addon. Two per-session knobs are captured at session creation from the main-process settings mirror (`readEmbeddedMpvSessionOptions()`, read in the `EMBEDDED_MPV_CREATE_SESSION` handler — never inside the service, whose specs would otherwise construct electron-conf): `Settings.embeddedMpvExtraOptions` (free-form `key=value` libmpv lines, forbidden embed-critical keys refused by the form, network defaults `network-timeout=10` + ffmpeg `reconnect` prepended, applied on every engine after its built-ins — Windows/macOS via `mpv_set_option_string`, Linux through a user-only `--include` config file, frame-copy as the helper's first stdin line — never on a command line, where `ps` could read a credential-bearing header option) and `Settings.embeddedMpvAutoReconnect` (default on: `EmbeddedMpvReconnectCoordinator` in `embedded-mpv-reconnect.ts` reloads the last playback on `error`, or `ended` for live, only if it had played, with 2 s→30 s backoff, six attempts per outage, budget reset after 30 s stable playing, cancelled by user loads/pause/dispose; a recording running at the drop is finalized as an interrupted partial when the reload actually replaces the stream (a stream that recovers on its own keeps recording) and restarted into a new file once that reload plays, and an external subtitle file added through `sub-add` is re-added once the reload plays unless the user picked another track or loaded something else since; the renderer only displays `EmbeddedMpvSession.reconnect`). Contract: `docs/architecture/embedded-mpv-native.md` ("Session Options", "Network Auto-Reconnect"). macOS uses the libmpv render API in an `NSOpenGLView`; Windows uses in-process libmpv with `--wid` against an app-owned child `HWND`; Linux spawns an out-of-process `mpv --wid=<x11-window>` controlled over a JSON IPC socket (X11/XWayland only, requires system `mpv` on PATH; subtitles/speed/aspect/recording are not exported there). mpv's own screensaver inhibition does not apply to any of these paths, so `EmbeddedMpvNativeService` holds an Electron `powerSaveBlocker` (`prevent-display-sleep`) whenever any session's status is `playing`, and releases it on pause, dispose, or shutdown. Renderer bounds are CSS pixels; the service converts them to native units in the main process (`embedded-mpv-bounds.util.ts`: × page zoom everywhere, × display scale on Windows/Linux whose child windows are positioned in physical pixels; frame-copy bounds stay unscaled), and the session controller re-syncs bounds when `devicePixelRatio` changes and polls (500 ms, drift-gated) for position-only layout shifts that `ResizeObserver` cannot observe. Arrow-key and ±10 s button steps go through the relative `seekEmbeddedMpvBy` IPC (mpv `seek <delta> relative+exact`; addon export `seekBy`, helper stdin command `seek-by`, Linux JSON IPC), never an absolute target computed from the renderer's whole-second, 500 ms-polled `positionSeconds` — that stale base collapsed rapid presses onto one target (about 1 s of progress per press); only the timeline scrub commits an absolute `seek`. Service: `apps/electron-backend/src/app/services/embedded-mpv-native.service.ts`; full architecture: `docs/architecture/embedded-mpv-native.md`.
 - Embedded MPV frame-copy engine (experimental, macOS Apple Silicon + Linux
   x64 + Windows; enabled via `Settings > Playback > Embedded MPV: frame-copy
 engine` (restart required) or
@@ -1129,7 +1130,7 @@ engine` (restart required) or
   helper: `apps/electron-backend/native/helper/`; canonical packaging/runtime
   contracts: `docs/architecture/embedded-mpv-native.md` and
   `tools/embedded-mpv/README.md`.
-- Shared player-controls layer: `libs/ui/playback/src/lib/player-controls/` exports the engine-neutral `PlayerController` contract, standalone `app-player-controls`, a generic web-video adapter/helper, and component-scoped `WEB_PLAYER_SHARED_CONTROLS` rollout token. Its subtitle menu carries capability-gated advanced subtitle support (#1408): external subtitle file loading, a ±0.5 s timing-offset row, and size/color styling persisted in the shared `subtitleStyle` localStorage key. HTML5/ArtPlayer implement it through the neutral source bridge (`.srt`/`.vtt` via a DOM file picker with encoding detection, native `TextTrack` rendering, `::cue` styling, delay only while the loaded file is the selected track; picks are source-generation-guarded and engine deselection precedes external track activation); the canonical style shape and clamp/normalize rules are shared with the main process via `@iptvnator/shared/interfaces` (`subtitle-style.util.ts`). Embedded MPV frame-copy implements it through new helper protocol commands (`sub-add`/`sub-delay`/`sub-scale`/`sub-color`, main-process file dialog, ASS supported, delay for all tracks). Video.js shared mode, vendor-chrome paths, native-view, and the Linux out-of-process path advertise no such capability and render no UI. Contract details: `docs/architecture/player-controls-contract.md` ("Advanced subtitle support"). Shared controls include a per-session quality menu (Auto + “1080p”-style levels via `setQualityLevel`; `AUTO_QUALITY_LEVEL_ID` restores ABR): the capability derives from the manifest — advertised only when the source exposes >1 video rendition (multi-variant HLS via hls.js `nextLevel`/`manualLevel`, DASH via Shaka variant tracks pinned to the active variant's exact audio stream (`audioId`, language fallback) with ABR toggled off for manual picks, Video.js via videojs-contrib-quality-levels) — so single-bitrate VOD and raw MPEG-TS never show it, nothing persists to Settings, and Embedded MPV/external players report the capability false. In fullscreen, `app-player-controls` shows a pointer-transparent media-title overlay at the top while controls are revealed (`mediaTitle` input: movie/channel/series name, plus an `S01E03` second line for episodes; series names flow from the detail views through `PortalInlinePlayerComponent.seriesTitle` and `WebPlayerViewComponent.mediaTitle`). Persisted `Settings.webPlayerSharedControls` is default-ON (absent stored values coerce with `!== false` in every normalization site; only an explicit false — the Settings > Playback checkbox — opts out to the legacy vendor chrome), and its checkbox appears only when HTML5, Video.js, or ArtPlayer is selected. The shared surface has explicit touch semantics (`ControlsSurface.wasTouchInteraction`): viewport taps toggle overlay visibility instead of pausing, the volume popover opens on tap instead of hover, coarse pointers get a taller scrub strip, and at container widths ≤640px the bar reflows to two rows (full-width timeline above transport + an end-aligned, wrapping actions cluster with 40px buttons whose panels remain unclipped). Only keyboard-originated focus pins the bar open: Chromium also focuses a clicked `<button>`, so `ControlsSurface.wasPointerInteraction` attributes a `focusin` to a recent `pointerdown` inside the focused element and such focus reveals without blocking auto-hide (otherwise the fullscreen button left the controls on screen until a click-to-pause on the viewport); the press record is discarded on the first bar focus event or any `keydown`, a `pointerdown` inside the bar releases a keyboard pin, and a `keydown` bubbling out of a bar control re-pins it, since operating a focused control produces no focus event. Deliberately dropped vs. vendor chrome (opt-out retains them): Video.js spatial navigation, ArtPlayer screenshot/AirPlay/web-fullscreen/mini-progress/vendor gestures — listed in the contract doc's "Known differences" section. `WebPlayerViewComponent` snapshots the preference into the immutable token for each new player host. The parent `/workspace` route awaits the initial `SettingsStore` load, including cold-start direct links, before this snapshot can occur. Saving applies to the next host without an application restart; an existing session never changes controls mode in place. Embedded MPV ignores the web-player preference: frame-copy always uses shared DOM controls through `EmbeddedMpvControlsAdapter`, native-view retains its compositor-safe legacy dock, and external MPV/VLC retain their own UI. The Embedded MPV host selects exactly one controls UI for its reported engine. `showControls=false` detaches the shared surface, modal overlays gate frame-copy playback shortcuts, fullscreen remains DOM-based with Embedded MPV bounds sync — its owner is the `app-web-player-view` host (`WebPlayerViewComponent.fullscreenSurface`, passed to every engine as `fullscreenTarget`), not the engine shell, because the view remounts the engine component per playback application and the Fullscreen API exits when its element leaves the document; that is what keeps fullscreen across episode/channel/alternative-source switches (the vendor-chrome opt-out still loses it) — and a playback/session transition key prevents engine or session handoff from presenting stale recording feedback while timers and pending commands are cancelled. Same-session IPC replies yield to a broadcast snapshot received while the command was pending, so a successful recording acknowledgement cannot be rolled back by a stale reply. The built-in HTML5/hls.js player is the second guarded consumer: `HtmlVideoPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`, while its neutral `web-video-support` bridge is shared with ArtPlayer and owns HLS/Shaka(DASH)/native tracks, MPEG-TS VOD duration correction, caption preference, and source cleanup. `HtmlVideoElementSession` owns native video-event lifecycle, persisted volume, and start-time/time/ended propagation. Video.js is the third guarded consumer: `VjsPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`; its bridge rebinds the current Tech video after `playerreset`, exposes source-stable audio/subtitle IDs, preserves caption preference and explicit subtitle-off state, and reads Video.js duration. Reset-driven raw MPEG-TS changes pause first, coalesce to the latest desired source, preserve actual volume across Video.js's reset, and restart when authoritative live/VOD metadata changes. In shared-controls mode, Video.js native controls, click/double-click/hotkey actions, and spatial navigation are disabled. ArtPlayer is the fourth guarded consumer: `ArtPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`; `ArtPlayerSourceSession` owns HLS/DASH(Shaka)/MPEG-TS/native sources, the neutral web-video bridge, exact cleanup, and a destroyed-session guard for delayed `customType` callbacks, while `ArtPlayerVideoSession` owns native media/ArtPlayer events. Shared ArtPlayer mode uses authoritative live/VOD metadata, HLS/Shaka/native tracks and caption preference, MPEG-TS VOD duration correction, and reapplies app volume directly after ArtPlayer restores its own stored volume. Vendor chrome/hotkeys are disabled, and a transparent capture layer gives shared controls exclusive click and double-click ownership. `WebPlayerViewComponent.resolvedIsLive` supplies authoritative metadata; visible playback diagnostics disable shared pointer/keyboard ownership and exit only the shared controls' resolved fullscreen owner (the host-supplied `fullscreenTarget`, i.e. the `app-web-player-view` host, else the engine shell) so ranked recovery actions remain visible. On the preference-off path, all three web players retain their existing controls, source behavior, and legacy series navigation — but the playback keyboard shortcuts (Space/K, F, arrow seek/volume, M) still work: each vendor-chrome player attaches `LegacyPlayerShortcuts` (a wrapper over the same `ControlsShortcuts` arbitration/ignore rules) with engine-specific command wiring (`html-video-legacy-shortcuts.ts`, `vjs-legacy-shortcuts.ts`, `art-player-legacy-shortcuts.ts`); seek is gated on authoritative `isLive` plus a finite positive duration, `interactionEnabled` (visible playback diagnostic) disables the keys, and the legacy ArtPlayer chrome passes `hotkey: false` because ArtPlayer's focus-scoped hotkeys ignore `defaultPrevented` and would double-handle every key (its lost Escape-exits-`fullscreenWeb` behavior is restored by the wiring). `Settings.showCaptions` is deliberately outside this rollout gate: it is engine state, so the preference-off players apply it through the same helpers without an adapter (`WebVideoSourceTracks` for HTML5/ArtPlayer, `VjsLegacyTracks` for Video.js), re-applying it as the engine adds or switches text tracks. The two modes differ in how long it is enforced: shared controls are authoritative for the session (user intent arrives via `setSubtitleTrack`), while vendor chrome is source-default — the preference seeds each new source and is released once the media reports `playing`, so the engine's own caption menu keeps working. Mode selection is the optional `playbackStarted` probe the legacy owners pass to all three helpers (HLS, native text tracks, Shaka); in that mode the HLS helper deselects (`subtitleTrack = -1`) rather than hiding, since `subtitleDisplay` would override the vendor menu, and DASH is seeded by `ShakaVideoSession.start()` after the manifest loads. `WebPlayerViewComponent` reads it from `SettingsStore` instead of a host input so every host (M3U, Xtream/Stalker live layouts, portal detail inline player) inherits it. Contract: `docs/architecture/player-controls-contract.md`.
+- Shared player-controls layer: `libs/ui/playback/src/lib/player-controls/` exports the engine-neutral `PlayerController` contract, standalone `app-player-controls`, a generic web-video adapter/helper, and component-scoped `WEB_PLAYER_SHARED_CONTROLS` rollout token. Its subtitle menu carries capability-gated advanced subtitle support (#1408): external subtitle file loading, a ±0.5 s timing-offset row, and size/color styling persisted in the shared `subtitleStyle` localStorage key. HTML5/ArtPlayer implement it through the neutral source bridge (`.srt`/`.vtt` via a DOM file picker with encoding detection, native `TextTrack` rendering, `::cue` styling, delay only while the loaded file is the selected track; picks are source-generation-guarded and engine deselection precedes external track activation); the canonical style shape and clamp/normalize rules are shared with the main process via `@iptvnator/shared/interfaces` (`subtitle-style.util.ts`). Embedded MPV frame-copy implements it through new helper protocol commands (`sub-add`/`sub-delay`/`sub-scale`/`sub-color`, main-process file dialog, ASS supported, delay for all tracks). Video.js shared mode, vendor-chrome paths, native-view, and the Linux out-of-process path advertise no such capability and render no UI. Contract details: `docs/architecture/player-controls-contract.md` ("Advanced subtitle support"). Shared controls include a per-session quality menu (Auto + “1080p”-style levels via `setQualityLevel`; `AUTO_QUALITY_LEVEL_ID` restores ABR): the capability derives from the manifest — advertised only when the source exposes >1 video rendition (multi-variant HLS via hls.js `nextLevel`/`manualLevel`, DASH via Shaka variant tracks pinned to the active variant's exact audio stream (`audioId`, language fallback) with ABR toggled off for manual picks, Video.js via videojs-contrib-quality-levels) — so single-bitrate VOD and raw MPEG-TS never show it, nothing persists to Settings, and Embedded MPV/external players report the capability false. In fullscreen, `app-player-controls` shows a pointer-transparent media-title overlay at the top while controls are revealed (`mediaTitle` input: movie/channel/series name, plus an `S01E03` second line for episodes; series names flow from the detail views through `PortalInlinePlayerComponent.seriesTitle` and `WebPlayerViewComponent.mediaTitle`). Persisted `Settings.webPlayerSharedControls` is default-ON (absent stored values coerce with `!== false` in every normalization site; only an explicit false — the Settings > Playback checkbox — opts out to the legacy vendor chrome), and its checkbox appears only when HTML5, Video.js, or ArtPlayer is selected. The shared surface has explicit touch semantics (`ControlsSurface.wasTouchInteraction`): viewport taps toggle overlay visibility instead of pausing, the volume popover opens on tap instead of hover, coarse pointers get a taller scrub strip, and at container widths ≤640px the bar reflows to two rows (full-width timeline above transport + an end-aligned, wrapping actions cluster with 40px buttons whose panels remain unclipped). Only keyboard-originated focus pins the bar open: Chromium also focuses a clicked `<button>`, so `ControlsSurface.wasPointerInteraction` attributes a `focusin` to a recent `pointerdown` inside the focused element and such focus reveals without blocking auto-hide (otherwise the fullscreen button left the controls on screen until a click-to-pause on the viewport); the press record is discarded on the first bar focus event or any `keydown`, a `pointerdown` inside the bar releases a keyboard pin, and a `keydown` bubbling out of a bar control re-pins it, since operating a focused control produces no focus event. A completed pointer click then releases the focus it left on the control (`onBarClick` → `ControlsSurface.releasePointerFocus`, attributed by `wasPointerClick`: non-empty click `pointerType`, else a recent press inside the clicked element): a focused control captures the keyboard — Space and Enter re-activated the clicked button and `ControlsShortcuts` yields to any interactive element in the key's path, so after a click on fullscreen Space left fullscreen instead of pausing. Keyboard activation (empty `pointerType`) keeps focus, only buttons and range sliders are released, Chromium keeps its sequential-focus starting point at the blurred control so Tab continues from it, and the volume popover ignores the release's `focusout` (`wasPointerFocusRelease`). Deliberately dropped vs. vendor chrome (opt-out retains them): Video.js spatial navigation, ArtPlayer screenshot/AirPlay/web-fullscreen/mini-progress/vendor gestures — listed in the contract doc's "Known differences" section. `WebPlayerViewComponent` snapshots the preference into the immutable token for each new player host. The parent `/workspace` route awaits the initial `SettingsStore` load, including cold-start direct links, before this snapshot can occur. Saving applies to the next host without an application restart; an existing session never changes controls mode in place. Embedded MPV ignores the web-player preference: frame-copy always uses shared DOM controls through `EmbeddedMpvControlsAdapter`, native-view retains its compositor-safe legacy dock, and external MPV/VLC retain their own UI. The Embedded MPV host selects exactly one controls UI for its reported engine. `showControls=false` detaches the shared surface, modal overlays gate frame-copy playback shortcuts, fullscreen remains DOM-based with Embedded MPV bounds sync — its owner is the `app-web-player-view` host (`WebPlayerViewComponent.fullscreenSurface`, passed to every engine as `fullscreenTarget`), not the engine shell, because the view remounts the engine component per playback application and the Fullscreen API exits when its element leaves the document; that is what keeps fullscreen across episode/channel/alternative-source switches (the vendor-chrome opt-out still loses it) — and a playback/session transition key prevents engine or session handoff from presenting stale recording feedback while timers and pending commands are cancelled. Same-session IPC replies yield to a broadcast snapshot received while the command was pending, so a successful recording acknowledgement cannot be rolled back by a stale reply. The built-in HTML5/hls.js player is the second guarded consumer: `HtmlVideoPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`, while its neutral `web-video-support` bridge is shared with ArtPlayer and owns HLS/Shaka(DASH)/native tracks, MPEG-TS VOD duration correction, caption preference, and source cleanup. `HtmlVideoElementSession` owns native video-event lifecycle, persisted volume, and start-time/time/ended propagation. Video.js is the third guarded consumer: `VjsPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`; its bridge rebinds the current Tech video after `playerreset`, exposes source-stable audio/subtitle IDs, preserves caption preference and explicit subtitle-off state, and reads Video.js duration. Reset-driven raw MPEG-TS changes pause first, coalesce to the latest desired source, preserve actual volume across Video.js's reset, and restart when authoritative live/VOD metadata changes. In shared-controls mode, Video.js native controls, click/double-click/hotkey actions, and spatial navigation are disabled. ArtPlayer is the fourth guarded consumer: `ArtPlayerComponent` provides a component-scoped `WebVideoControlsAdapter`; `ArtPlayerSourceSession` owns HLS/DASH(Shaka)/MPEG-TS/native sources, the neutral web-video bridge, exact cleanup, and a destroyed-session guard for delayed `customType` callbacks, while `ArtPlayerVideoSession` owns native media/ArtPlayer events. Shared ArtPlayer mode uses authoritative live/VOD metadata, HLS/Shaka/native tracks and caption preference, MPEG-TS VOD duration correction, and reapplies app volume directly after ArtPlayer restores its own stored volume. Vendor chrome/hotkeys are disabled, and a transparent capture layer gives shared controls exclusive click and double-click ownership. `WebPlayerViewComponent.resolvedIsLive` supplies authoritative metadata; visible playback diagnostics disable shared pointer/keyboard ownership and exit only the shared controls' resolved fullscreen owner (the host-supplied `fullscreenTarget`, i.e. the `app-web-player-view` host, else the engine shell) so ranked recovery actions remain visible. On the preference-off path, all three web players retain their existing controls, source behavior, and legacy series navigation — but the playback keyboard shortcuts (Space/K, F, arrow seek/volume, M) still work: each vendor-chrome player attaches `LegacyPlayerShortcuts` (a wrapper over the same `ControlsShortcuts` arbitration/ignore rules) with engine-specific command wiring (`html-video-legacy-shortcuts.ts`, `vjs-legacy-shortcuts.ts`, `art-player-legacy-shortcuts.ts`); seek is gated on authoritative `isLive` plus a finite positive duration, `interactionEnabled` (visible playback diagnostic) disables the keys, and the legacy ArtPlayer chrome passes `hotkey: false` because ArtPlayer's focus-scoped hotkeys ignore `defaultPrevented` and would double-handle every key (its lost Escape-exits-`fullscreenWeb` behavior is restored by the wiring). The legacy Video.js chrome also releases the focus a pointer interaction leaves on a control (`vjs-pointer-focus-release.ts`, sharing `pointer-focus-release.ts`'s `blurFocusedControl` with `ControlsSurface`): a focused Video.js component stops every key before the document and turns Space/Enter into a click, so after a click on fullscreen Space left fullscreen instead of pausing. It is driven mainly by `focusin`, not the click, because choosing a menu item moves focus to the menu button a tick later (`MenuItem.handleTapClick`) and that selection click never bubbles to the shell: an eligible control (button/`role=button`/slider, never a `role=menuitem*`) is released when its focus is attributable to a recent shell `pointerdown` not yet ended by a document `keydown`, so keyboard `Tab` focus is kept — plus a `click` runs the same release for a control clicked while already focused (Tab then a mouse click, which fires no `focusin`). The release is scoped to `.vjs-control-bar` so the caption-settings dialog (a modal sibling of the bar) keeps its focus trap; menu buttons live in the bar and are not exempt (a popup is navigated through its focused item, so releasing the button never disturbs an open menu, and the button focus a pointer moves through on open, item selection, or toggling an open menu shut is released so Space works after the menu closes) — ArtPlayer (non-focusable divs) and the native HTML5 controls (focus lands on the `<video>`) need no counterpart. `Settings.showCaptions` is deliberately outside this rollout gate: it is engine state, so the preference-off players apply it through the same helpers without an adapter (`WebVideoSourceTracks` for HTML5/ArtPlayer, `VjsLegacyTracks` for Video.js), re-applying it as the engine adds or switches text tracks. The two modes differ in how long it is enforced: shared controls are authoritative for the session (user intent arrives via `setSubtitleTrack`), while vendor chrome is source-default — the preference seeds each new source and is released once the media reports `playing`, so the engine's own caption menu keeps working. Mode selection is the optional `playbackStarted` probe the legacy owners pass to all three helpers (HLS, native text tracks, Shaka); in that mode the HLS helper deselects (`subtitleTrack = -1`) rather than hiding, since `subtitleDisplay` would override the vendor menu, and DASH is seeded by `ShakaVideoSession.start()` after the manifest loads. `WebPlayerViewComponent` reads it from `SettingsStore` instead of a host input so every host (M3U, Xtream/Stalker live layouts, portal detail inline player) inherits it. Contract: `docs/architecture/player-controls-contract.md`.
 - Shared web picture-in-picture stays inside that default-on rollout.
   `PlayerController` exposes capability `pictureInPicture`, state
   `pictureInPictureActive`/`canPictureInPicture`, and command
diff --git a/README.md b/README.md
index 2d39ae451..298ace49d 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,7 @@ Press `?` or `Shift+/` in the workspace to open the in-app shortcuts list.
 | Global            | `Ctrl/Cmd+F`                | Open global search in the desktop app                      |
 | Global            | `Ctrl/Cmd+R`                | Open recently viewed in the desktop app                    |
 | Global            | `Enter` in workspace search | Submit the current search                                  |
+| Global            | `F11`                       | Toggle app window fullscreen in the desktop app            |
 | Navigation        | `Ctrl/Cmd+B`                | Toggle the live sidebar                                    |
 | Navigation        | `0-9`                       | Select an M3U channel by number                            |
 | Playback          | `Space` / `K`               | Play or pause playback                                     |
@@ -90,6 +91,11 @@ Press `?` or `Shift+/` in the workspace to open the in-app shortcuts list.
 | Dialogs and lists | `Enter`                     | Run the selected command or open a focused item            |
 | Dialogs and lists | `Escape`                    | Close dialogs and dismiss overlays                         |
 
+The desktop app can also open at its last size, maximized, or fullscreen on
+every launch (Settings → General → "Window on startup"), and `iptvnator
+--fullscreen` forces a single fullscreen launch for TV or HTPC autostart
+scripts without changing that setting.
+
 ## Screenshots:
 
 |                                     Dashboard with recently watched content                                     |                               Live channels with inline player and EPG                                |
diff --git a/apps/electron-backend-e2e/src/settings.e2e.ts b/apps/electron-backend-e2e/src/settings.e2e.ts
index be7fa1ccc..ea958fc65 100644
--- a/apps/electron-backend-e2e/src/settings.e2e.ts
+++ b/apps/electron-backend-e2e/src/settings.e2e.ts
@@ -837,8 +837,129 @@ test.describe('Electron Settings', () => {
         }
     });
 
+    test('@settings @persistence @electron launches fullscreen once the startup window mode is saved and toggles it with F11', async ({
+        dataDir,
+    }) => {
+        let app = await launchElectronApp(dataDir);
+
+        try {
+            await openSettings(app.mainWindow);
+            await expect(
+                app.mainWindow.getByTestId('startup-window-mode-setting')
+            ).toBeVisible();
+            await selectSettingsOption(
+                app.mainWindow,
+                'select-startup-window-mode',
+                'startup-window-mode-fullscreen'
+            );
+            await saveSettings(app.mainWindow);
+
+            // The mode is read when the window is created, so saving it
+            // leaves the running window alone.
+            expect(await isMainWindowFullScreen(app)).toBe(false);
+        } finally {
+            app = await restartElectronApp(app, dataDir);
+        }
+
+        try {
+            await expect
+                .poll(() => isMainWindowFullScreen(app), { timeout: 10_000 })
+                .toBe(true);
+            await openSettings(app.mainWindow);
+            await expect(
+                app.mainWindow.getByTestId('select-startup-window-mode')
+            ).toContainText(/Fullscreen/);
+
+            // F11 is the way out on Windows/Linux, where the title bar is
+            // hidden and the custom window controls hide while fullscreen.
+            await app.mainWindow.keyboard.press('F11');
+            await expect
+                .poll(() => isMainWindowFullScreen(app), { timeout: 10_000 })
+                .toBe(false);
+
+            await app.mainWindow.keyboard.press('F11');
+            await expect
+                .poll(() => isMainWindowFullScreen(app), { timeout: 10_000 })
+                .toBe(true);
+        } finally {
+            await closeElectronApp(app);
+        }
+    });
+
+    test('@settings @electron --fullscreen forces one fullscreen launch without persisting it', async ({
+        dataDir,
+    }) => {
+        let app = await launchElectronApp(dataDir, {
+            appArgs: ['--fullscreen'],
+        });
+
+        try {
+            await expect
+                .poll(() => isMainWindowFullScreen(app), { timeout: 10_000 })
+                .toBe(true);
+        } finally {
+            app = await restartElectronApp(app, dataDir);
+        }
+
+        try {
+            // The switch is a one-shot: the next plain launch follows the
+            // stored setting, which is still the default.
+            expect(await isMainWindowFullScreen(app)).toBe(false);
+            await openSettings(app.mainWindow);
+            await expect(
+                app.mainWindow.getByTestId('select-startup-window-mode')
+            ).toContainText(/Last window size/);
+        } finally {
+            await closeElectronApp(app);
+        }
+    });
+
+    test('@settings @persistence @electron launches maximized when the startup window mode says so', async ({
+        dataDir,
+    }) => {
+        test.skip(
+            process.platform === 'linux' && !!process.env['CI'],
+            'xvfb on Linux CI has no window manager, so maximize never takes effect'
+        );
+        let app = await launchElectronApp(dataDir);
+
+        try {
+            await openSettings(app.mainWindow);
+            await selectSettingsOption(
+                app.mainWindow,
+                'select-startup-window-mode',
+                'startup-window-mode-maximized'
+            );
+            await saveSettings(app.mainWindow);
+        } finally {
+            app = await restartElectronApp(app, dataDir);
+        }
+
+        try {
+            await expect
+                .poll(
+                    () =>
+                        app.electronApp.evaluate(({ BrowserWindow }) => {
+                            const mainWindow = BrowserWindow.getAllWindows()[0];
+                            return mainWindow ? mainWindow.isMaximized() : false;
+                        }),
+                    { timeout: 10_000 }
+                )
+                .toBe(true);
+            expect(await isMainWindowFullScreen(app)).toBe(false);
+        } finally {
+            await closeElectronApp(app);
+        }
+    });
 });
 
+function isMainWindowFullScreen(app: LaunchedElectronApp): Promise<boolean> {
+    return app.electronApp.evaluate(({ BrowserWindow }) => {
+        const mainWindow = BrowserWindow.getAllWindows()[0];
+        return mainWindow ? mainWindow.isFullScreen() : false;
+    });
+}
+
 async function selectSettingsOption(
     page: Page,
     selectTestId: string,
diff --git a/apps/electron-backend/native/helper/mpv_frame_helper.cpp b/apps/electron-backend/native/helper/mpv_frame_helper.cpp
index cafb052bd..204de5b27 100644
--- a/apps/electron-backend/native/helper/mpv_frame_helper.cpp
+++ b/apps/electron-backend/native/helper/mpv_frame_helper.cpp
@@ -16,6 +16,7 @@
  * Usage:
  *   iptvnator_mpv_helper --shm-base /impv-<id> --width 1280 --height 720
  *                        [--volume 0..1] [--hwdec auto]
+ *                        [--mpv-options-stdin]
  */
 #include <mpv/client.h>
 
@@ -72,6 +73,9 @@ struct SnapshotState {
     std::string recordingStartedAt;
     std::string recordingError;
     std::string error;
+    /* True when `error` is the engine's own failure (a fatal libmpv log)
+     * rather than the stream's: the app must not reload media for it. */
+    bool engineError = false;
 };
 
 struct HelperState {
@@ -173,7 +177,10 @@ std::string composeSnapshotLocked() {
         recording.str("startedAt", s.recordingStartedAt);
     if (!s.recordingError.empty()) recording.str("error", s.recordingError);
     writer.raw("recording", recording.finish());
-    if (!s.error.empty()) writer.str("error", s.error);
+    if (!s.error.empty()) {
+        writer.str("error", s.error);
+        if (s.engineError) writer.str("errorOrigin", "engine");
+    }
     return writer.finish();
 }
 
@@ -382,6 +389,7 @@ void runMpvEventLoop() {
                 case MPV_EVENT_START_FILE:
                     s.status = "loading";
                     s.error.clear();
+                    s.engineError = false;
                     s.audioTracks.clear();
                     s.selectedAudioTrackId = -1;
                     s.subtitleTracks.clear();
@@ -413,6 +421,7 @@ void runMpvEventLoop() {
                                g_state.running.load()) {
                         s.status = "loading";
                         s.error.clear();
+                        s.engineError = false;
                         g_state.loadedPath = false;
                     } else if (g_state.running.load()) {
                         s.status = "idle";
@@ -440,6 +449,7 @@ void runMpvEventLoop() {
                     }
                     if (level == "fatal") {
                         s.status = "error";
+                        s.engineError = true;
                     }
                     emitLine(JsonWriter()
                                  .str("event", "log")
@@ -486,6 +496,7 @@ void handleLoadCommand(const Command& command) {
         }
         g_state.snapshot.streamUrl = url;
         g_state.snapshot.error.clear();
+        g_state.snapshot.engineError = false;
         g_state.snapshot.status = "loading";
         g_state.dirty = true;
     }
@@ -640,6 +651,12 @@ struct HelperArgs {
     std::string shmBase = "/impv";
     std::string hwdec = "auto";
     std::string audioDelay; /* seconds, mpv audio-delay passthrough */
+    /* Read the session's "key=value" libmpv options (network defaults plus
+     * the user's Settings > Playback lines) from the first stdin line and
+     * apply them after the built-in block so they override it. They never
+     * travel on argv: a credential-bearing option must not be readable
+     * through `ps` or /proc/<pid>/cmdline. */
+    bool mpvOptionsOnStdin = false;
     int width = 1280;
     int height = 720;
     double volume = 1;
@@ -659,6 +676,7 @@ HelperArgs parseArgs(int argc, char** argv) {
         else if (arg == "--volume") args.volume = std::atof(next().c_str());
         else if (arg == "--hwdec") args.hwdec = next();
         else if (arg == "--audio-delay") args.audioDelay = next();
+        else if (arg == "--mpv-options-stdin") args.mpvOptionsOnStdin = true;
         else if (arg == "--runtime-probe") args.runtimeProbe = true;
     }
     args.width = std::max(16, args.width);
@@ -822,6 +840,53 @@ int main(int argc, char** argv) {
         mpv_set_option_string(g_state.mpv, "audio-delay",
                               args.audioDelay.c_str());
     }
+    if (args.mpvOptionsOnStdin) {
+        /* `mpv-options\to000=<key=value>\to001=...` in the regular command
+         * encoding; zero-padded keys keep the application order (network
+         * defaults first, then the user's lines) through the field map. */
+        std::string preamble;
+        if (!std::getline(std::cin, preamble)) {
+            emitLine(JsonWriter()
+                         .str("event", "fatal")
+                         .str("error", "mpv-options preamble missing on stdin")
+                         .finish());
+            return 1;
+        }
+        const frame_helper::Command preambleCommand =
+            frame_helper::parseCommandLine(preamble);
+        if (preambleCommand.name != "mpv-options") {
+            emitLine(JsonWriter()
+                         .str("event", "fatal")
+                         .str("error", "expected the mpv-options preamble on stdin")
+                         .finish());
+            return 1;
+        }
+        std::vector<std::pair<std::string, std::string>> entries(
+            preambleCommand.args.begin(), preambleCommand.args.end());
+        std::sort(entries.begin(), entries.end());
+        for (const auto& entry : entries) {
+            const std::string& option = entry.second;
+            const size_t separator = option.find('=');
+            if (separator == std::string::npos || separator == 0 ||
+                separator + 1 >= option.size()) {
+                continue;
+            }
+            const std::string key = option.substr(0, separator);
+            const std::string value = option.substr(separator + 1);
+            const int optionResult = mpv_set_option_string(
+                g_state.mpv, key.c_str(), value.c_str());
+            if (optionResult < 0) {
+                emitLine(JsonWriter()
+                             .str("event", "log")
+                             .str("level", "warn")
+                             .str("prefix", "iptvnator")
+                             .str("text", "rejected session option " + key +
+                                              ": " +
+                                              mpv_error_string(optionResult))
+                             .finish());
+            }
+        }
+    }
     if (mpv_initialize(g_state.mpv) < 0) {
         emitLine(JsonWriter()
                      .str("event", "fatal")
diff --git a/apps/electron-backend/native/src/embedded_mpv.mm b/apps/electron-backend/native/src/embedded_mpv.mm
index 3df139bae..c5b6f0aab 100644
--- a/apps/electron-backend/native/src/embedded_mpv.mm
+++ b/apps/electron-backend/native/src/embedded_mpv.mm
@@ -13,6 +13,8 @@
 #include <mpv/render.h>
 #include <mpv/render_gl.h>
 
+#include "embedded_mpv_extra_options.h"
+
 #include <algorithm>
 #include <atomic>
 #include <chrono>
@@ -96,6 +98,12 @@ struct SessionSnapshot {
     double volumePercent = 100.0;
     std::string streamUrl;
     std::string error;
+    // True when `error` is the engine's own failure (render context, fatal
+    // libmpv log) rather than the stream's: the app must not reload for it.
+    bool engineError = false;
+    // Keys of session options libmpv refused at creation (names only, never
+    // values: a value may carry credentials). Reported once by the service.
+    std::vector<std::string> rejectedOptionKeys;
     std::vector<AudioTrack> audioTracks;
     int64_t selectedAudioTrackId = -1;
     std::vector<AudioTrack> subtitleTracks;
@@ -203,7 +211,11 @@ std::shared_ptr<Session> getSessionOrThrow(
 
 void scheduleRender(const std::shared_ptr<Session>& session);
 void requestRender(const std::shared_ptr<Session>& session);
-void updateSessionError(const std::shared_ptr<Session>& session, const std::string& error);
+void updateSessionError(
+    const std::shared_ptr<Session>& session,
+    const std::string& error,
+    bool engineError = false
+);
 
 bool isEmbeddedMpvTraceEnabled()
 {
@@ -550,7 +562,8 @@ void renderSoftwareFrame(const std::shared_ptr<Session>& session)
     if (result < 0) {
         updateSessionError(
             session,
-            std::string("Failed to render frame: ") + mpv_error_string(result)
+            std::string("Failed to render frame: ") + mpv_error_string(result),
+            true
         );
         return;
     }
@@ -670,7 +683,8 @@ void renderOpenGLFrame(const std::shared_ptr<Session>& session)
         updateSessionError(
             session,
             std::string("Failed to render OpenGL frame: ") +
-                mpv_error_string(result)
+                mpv_error_string(result),
+            true
         );
         return;
     }
@@ -1035,11 +1049,16 @@ void updateSubtitleTracksFromNode(SessionSnapshot& snapshot, const mpv_node& nod
     );
 }
 
-void updateSessionError(const std::shared_ptr<Session>& session, const std::string& error)
+void updateSessionError(
+    const std::shared_ptr<Session>& session,
+    const std::string& error,
+    bool engineError
+)
 {
     std::lock_guard<std::mutex> lock(session->mutex);
     session->snapshot.status = SessionStatus::Error;
     session->snapshot.error = error;
+    session->snapshot.engineError = engineError;
 }
 
 uint64_t nextAsyncRequestId()
@@ -1154,6 +1173,7 @@ void runEventLoop(const std::shared_ptr<Session>& session)
             case MPV_EVENT_START_FILE:
                 session->snapshot.status = SessionStatus::Loading;
                 session->snapshot.error.clear();
+                session->snapshot.engineError = false;
                 session->snapshot.audioTracks.clear();
                 session->snapshot.selectedAudioTrackId = -1;
                 session->snapshot.subtitleTracks.clear();
@@ -1186,6 +1206,7 @@ void runEventLoop(const std::shared_ptr<Session>& session)
                     session->running.load()) {
                     session->snapshot.status = SessionStatus::Loading;
                     session->snapshot.error.clear();
+                    session->snapshot.engineError = false;
                     session->loadedPath = false;
                 } else if (session->running.load()) {
                     session->snapshot.status = SessionStatus::Idle;
@@ -1353,6 +1374,7 @@ void runEventLoop(const std::shared_ptr<Session>& session)
                 }
                 if (level == "fatal") {
                     session->snapshot.status = SessionStatus::Error;
+                    session->snapshot.engineError = true;
                 }
                 break;
             }
@@ -1657,6 +1679,25 @@ Napi::Value CreateSession(const Napi::CallbackInfo& info)
         std::to_string(session->snapshot.volumePercent);
     mpv_set_option_string(session->handle, "volume", initialVolume.c_str());
 
+    // Session options from Settings (network defaults first, then the
+    // user's lines). Applied last so a user value overrides a built-in one,
+    // and before mpv_initialize because most of them are init-only.
+    for (const auto& option : iptvnator::readEmbeddedMpvExtraOptions(info, 4)) {
+        const int optionResult = mpv_set_option_string(
+            session->handle,
+            option.first.c_str(),
+            option.second.c_str()
+        );
+        if (optionResult < 0) {
+            traceEmbeddedMpv(
+                session,
+                "rejected session option " + option.first + ": " +
+                    mpv_error_string(optionResult)
+            );
+            session->snapshot.rejectedOptionKeys.push_back(option.first);
+        }
+    }
+
     mpv_request_log_messages(session->handle, "warn");
 
     const int initializeResult = mpv_initialize(session->handle);
@@ -1920,6 +1961,7 @@ Napi::Value LoadPlayback(const Napi::CallbackInfo& info)
         std::lock_guard<std::mutex> lock(session->mutex);
         session->snapshot.streamUrl = streamUrl;
         session->snapshot.error.clear();
+        session->snapshot.engineError = false;
         session->snapshot.status = SessionStatus::Loading;
         session->snapshot.recordingActive = false;
         session->snapshot.recordingTargetPath.clear();
@@ -2000,9 +2042,13 @@ Napi::Value SetPaused(const Napi::CallbackInfo& info)
     {
         std::lock_guard<std::mutex> lock(session->mutex);
         session->paused = paused != 0;
+        // Optimistic only while playing/paused: a load in flight keeps
+        // `loading` until MPV_EVENT_FILE_LOADED, otherwise a reconnect's
+        // unpause right after loadfile would report the replacement stream
+        // as playing before it opened (and clear the attempt indicator).
         if (session->loadedPath &&
-            session->snapshot.status != SessionStatus::Ended &&
-            session->snapshot.status != SessionStatus::Error) {
+            (session->snapshot.status == SessionStatus::Playing ||
+             session->snapshot.status == SessionStatus::Paused)) {
             session->snapshot.status = session->paused
                 ? SessionStatus::Paused
                 : SessionStatus::Playing;
@@ -2547,6 +2593,20 @@ Napi::Value GetSessionSnapshot(const Napi::CallbackInfo& info)
 
     if (!snapshot.error.empty()) {
         result.Set("error", Napi::String::New(env, snapshot.error));
+        if (snapshot.engineError) {
+            result.Set("errorOrigin", Napi::String::New(env, "engine"));
+        }
+    }
+    if (!snapshot.rejectedOptionKeys.empty()) {
+        Napi::Array keys =
+            Napi::Array::New(env, snapshot.rejectedOptionKeys.size());
+        for (size_t i = 0; i < snapshot.rejectedOptionKeys.size(); ++i) {
+            keys.Set(
+                static_cast<uint32_t>(i),
+                Napi::String::New(env, snapshot.rejectedOptionKeys[i])
+            );
+        }
+        result.Set("rejectedOptionKeys", keys);
     }
 
     return result;
diff --git a/apps/electron-backend/native/src/embedded_mpv_extra_options.h b/apps/electron-backend/native/src/embedded_mpv_extra_options.h
new file mode 100644
index 000000000..789754f2a
--- /dev/null
+++ b/apps/electron-backend/native/src/embedded_mpv_extra_options.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <napi.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace iptvnator {
+
+/** One libmpv option name/value pair handed to a session at creation. */
+using EmbeddedMpvExtraOption = std::pair<std::string, std::string>;
+
+/**
+ * Reads the optional `key=value` string array `createSession()` receives at
+ * `index`. The Electron side already validated and ordered the lines
+ * (network defaults first, then the user's options minus the keys the embed
+ * depends on — see `resolveEmbeddedMpvSessionOptionArguments`), so this only
+ * splits on the first `=` and skips anything that is not a non-empty pair.
+ * No libmpv call lives here: each engine applies the pairs itself, because
+ * on Linux the libmpv symbols are macros over dynamically resolved pointers.
+ */
+inline std::vector<EmbeddedMpvExtraOption> readEmbeddedMpvExtraOptions(
+    const Napi::CallbackInfo& info,
+    size_t index
+)
+{
+    std::vector<EmbeddedMpvExtraOption> options;
+    if (info.Length() <= index || !info[index].IsArray()) {
+        return options;
+    }
+
+    const auto entries = info[index].As<Napi::Array>();
+    for (uint32_t i = 0; i < entries.Length(); ++i) {
+        const Napi::Value entry = entries.Get(i);
+        if (!entry.IsString()) {
+            continue;
+        }
+        const std::string line = entry.As<Napi::String>().Utf8Value();
+        const auto separator = line.find('=');
+        if (
+            separator == std::string::npos ||
+            separator == 0 ||
+            separator + 1 >= line.size()
+        ) {
+            continue;
+        }
+        options.emplace_back(
+            line.substr(0, separator),
+            line.substr(separator + 1)
+        );
+    }
+    return options;
+}
+
+} // namespace iptvnator
diff --git a/apps/electron-backend/native/src/embedded_mpv_wid_common.h b/apps/electron-backend/native/src/embedded_mpv_wid_common.h
index aae6ff1c2..bec76d7b1 100644
--- a/apps/electron-backend/native/src/embedded_mpv_wid_common.h
+++ b/apps/electron-backend/native/src/embedded_mpv_wid_common.h
@@ -5,6 +5,9 @@
 #include <napi.h>
 
 #include <mpv/client.h>
+#include <string>
+
+#include "embedded_mpv_extra_options.h"
 
 #ifdef IPTVNATOR_DYNAMIC_LIBMPV
 #ifndef IPTVNATOR_MPV_SELECTANY
@@ -116,6 +119,8 @@ struct SessionSnapshot {
     double volumePercent = 100.0;
     std::string streamUrl;
     std::string error;
+    /** Keys of session options libmpv refused at creation (names only). */
+    std::vector<std::string> rejectedOptionKeys;
     std::vector<AudioTrack> audioTracks;
     int64_t selectedAudioTrackId = -1;
     std::vector<AudioTrack> subtitleTracks;
@@ -142,6 +147,8 @@ struct Session {
     std::string pendingRecordingStartedAt;
     std::string pendingRecordingStopStartedAt;
     uint64_t pendingPlaybackLoadRequestId = 0;
+    /** Session options from Settings (network defaults + user lines). */
+    std::vector<iptvnator::EmbeddedMpvExtraOption> extraOptions;
 #ifdef __linux__
     pid_t mpvProcessId = -1;
     std::string mpvIpcSocketPath;
@@ -607,6 +614,12 @@ std::vector<std::string> buildLinuxMpvArguments(
         arguments.push_back("--really-quiet");
     }
 
+    // Session options come before the per-playback ones below, so a
+    // playlist's own user-agent/headers still win over a global line.
+    for (const auto& option : session->extraOptions) {
+        arguments.push_back("--" + option.first + "=" + option.second);
+    }
+
     appendLinuxMpvOption(arguments, "force-media-title", title);
     appendLinuxMpvOption(arguments, "user-agent", userAgent);
     appendLinuxMpvOption(arguments, "referrer", referer);
@@ -983,6 +996,7 @@ void refreshLinuxMpvSnapshot(const std::shared_ptr<Session>& session)
     const auto duration = queryLinuxMpvNumber(socketPath, "duration");
     const auto volume = queryLinuxMpvNumber(socketPath, "volume");
     const auto paused = queryLinuxMpvBoolean(socketPath, "pause");
+    const auto eofReached = queryLinuxMpvBoolean(socketPath, "eof-reached");
     const auto path = queryLinuxMpvString(socketPath, "path");
     const auto trackCount =
         queryLinuxMpvInteger(socketPath, "track-list/count");
@@ -1018,10 +1032,24 @@ void refreshLinuxMpvSnapshot(const std::shared_ptr<Session>& session)
             std::max(0.0, std::min(100.0, *volume));
     }
     if (paused) {
-        session->snapshot.status =
-            *paused ? SessionStatus::Paused : SessionStatus::Playing;
+        if (*paused) {
+            session->snapshot.status = SessionStatus::Paused;
+        } else if (
+            position ||
+            session->snapshot.status != SessionStatus::Loading
+        ) {
+            // `time-pos` only answers once the media is decoding; until then
+            // an unpaused freshly spawned process is still loading.
+            session->snapshot.status = SessionStatus::Playing;
+        }
         session->snapshot.error.clear();
     }
+    if (eofReached && *eofReached) {
+        // keep-open=yes parks mpv paused at the end of the stream. Report
+        // that as `ended` like the in-process engines do, so the reconnect
+        // policy can tell a finished live stream from a user pause.
+        session->snapshot.status = SessionStatus::Ended;
+    }
     if (path && !path->empty()) {
         session->snapshot.streamUrl = *path;
     }
@@ -1149,7 +1177,10 @@ void loadLinuxProcessPlayback(
         session->snapshot.durationSeconds = -1.0;
         session->snapshot.streamUrl = streamUrl;
         session->snapshot.error.clear();
-        session->snapshot.status = SessionStatus::Playing;
+        // A spawned process has not opened the URL yet: stay `loading` until
+        // the poller sees a decoded position, so a URL that never plays is
+        // never mistaken for one that did (the reconnect policy keys on it).
+        session->snapshot.status = SessionStatus::Loading;
         session->snapshot.audioTracks.clear();
         session->snapshot.selectedAudioTrackId = -1;
         session->snapshot.subtitleTracks.clear();
@@ -1654,6 +1685,7 @@ Napi::Value CreateSession(const Napi::CallbackInfo& info)
         throw Napi::Error::New(env, NativeVideoHost::lastError());
     }
     traceMpvCommon("native video host created");
+    session->extraOptions = iptvnator::readEmbeddedMpvExtraOptions(info, 4);
 
 #ifdef __linux__
     session->host.setBounds(bounds);
@@ -1705,6 +1737,24 @@ Napi::Value CreateSession(const Napi::CallbackInfo& info)
         session->snapshot.volumePercent
     );
     mpv_set_option_string(session->handle, "volume", initialVolume.c_str());
+
+    // Session options from Settings (network defaults first, then the
+    // user's lines). Applied last so a user value overrides a built-in one,
+    // and before mpv_initialize because most of them are init-only.
+    for (const auto& option : session->extraOptions) {
+        const int optionResult = mpv_set_option_string(
+            session->handle,
+            option.first.c_str(),
+            option.second.c_str()
+        );
+        if (optionResult < 0) {
+            traceMpvCommon(
+                "rejected session option " + option.first + ": " +
+                mpv_error_string(optionResult)
+            );
+            session->snapshot.rejectedOptionKeys.push_back(option.first);
+        }
+    }
     mpv_request_log_messages(session->handle, "warn");
 
     traceMpvCommon("initializing libmpv");
@@ -1936,8 +1986,16 @@ Napi::Value SetPaused(const Napi::CallbackInfo& info)
     {
         std::lock_guard<std::mutex> lock(session->mutex);
         socketPath = session->mpvIpcSocketPath;
-        session->snapshot.status =
-            paused ? SessionStatus::Paused : SessionStatus::Playing;
+        // Optimistic only while playing/paused: a load in flight or a
+        // finished/failed stream keeps its status until the poller says
+        // otherwise, like the in-process engines' pause handling.
+        if (
+            session->snapshot.status == SessionStatus::Playing ||
+            session->snapshot.status == SessionStatus::Paused
+        ) {
+            session->snapshot.status =
+                paused ? SessionStatus::Paused : SessionStatus::Playing;
+        }
     }
     if (!socketPath.empty()) {
         sendLinuxMpvCommand(
@@ -2376,6 +2434,17 @@ Napi::Value GetSessionSnapshot(const Napi::CallbackInfo& info)
     if (!snapshot.error.empty()) {
         result.Set("error", Napi::String::New(env, snapshot.error));
     }
+    if (!snapshot.rejectedOptionKeys.empty()) {
+        Napi::Array keys =
+            Napi::Array::New(env, snapshot.rejectedOptionKeys.size());
+        for (size_t i = 0; i < snapshot.rejectedOptionKeys.size(); ++i) {
+            keys.Set(
+                static_cast<uint32_t>(i),
+                Napi::String::New(env, snapshot.rejectedOptionKeys[i])
+            );
+        }
+        result.Set("rejectedOptionKeys", keys);
+    }
     return result;
 }
 
diff --git a/apps/electron-backend/src/app/api/main.preload.ts b/apps/electron-backend/src/app/api/main.preload.ts
index abd53454a..40baa5aa3 100644
--- a/apps/electron-backend/src/app/api/main.preload.ts
+++ b/apps/electron-backend/src/app/api/main.preload.ts
@@ -80,6 +80,7 @@ const DB_OPERATION_EVENT = 'DB_OPERATION_EVENT';
 const PLAYLIST_REFRESH_EVENT = 'PLAYLIST:REFRESH_EVENT';
 const WINDOW_MINIMIZE = 'WINDOW:MINIMIZE';
 const WINDOW_TOGGLE_MAXIMIZE = 'WINDOW:TOGGLE_MAXIMIZE';
+const WINDOW_TOGGLE_FULLSCREEN = 'WINDOW:TOGGLE_FULLSCREEN';
 const WINDOW_CLOSE = 'WINDOW:CLOSE';
 const WINDOW_GET_STATE = 'WINDOW:GET_STATE';
 const WINDOW_STATE_CHANGED = 'WINDOW:STATE_CHANGED';
@@ -414,6 +415,7 @@ const electronApi: ElectronBridgeApi = {
     },
     minimizeWindow: () => ipcRenderer.invoke(WINDOW_MINIMIZE),
     toggleMaximizeWindow: () => ipcRenderer.invoke(WINDOW_TOGGLE_MAXIMIZE),
+    toggleFullScreenWindow: () => ipcRenderer.invoke(WINDOW_TOGGLE_FULLSCREEN),
     closeWindow: () => ipcRenderer.invoke(WINDOW_CLOSE),
     getWindowState: () => ipcRenderer.invoke(WINDOW_GET_STATE),
     onWindowStateChange: (
diff --git a/apps/electron-backend/src/app/app-window-state.spec.ts b/apps/electron-backend/src/app/app-window-state.spec.ts
index f550142df..598931315 100644
--- a/apps/electron-backend/src/app/app-window-state.spec.ts
+++ b/apps/electron-backend/src/app/app-window-state.spec.ts
@@ -201,6 +201,69 @@ describe('window state change pushes', () => {
         );
     });
 
+    it('keeps isFullScreen=true when the player leaves HTML fullscreen inside a natively fullscreen window', () => {
+        const win = createMockStateWindow();
+        // A fullscreen launch (or F11 before attach) — the window is
+        // natively fullscreen when the events are wired up.
+        win.isFullScreen.mockReturnValue(true);
+        attachWindowStateEvents(win);
+
+        // Electron sees the window is already fullscreen, so entering HTML
+        // fullscreen only emits the html variant …
+        fireWindowEvent(win, 'enter-html-full-screen');
+        expect(win.webContents.send).toHaveBeenLastCalledWith(
+            WINDOW_STATE_CHANGED,
+            { isMaximized: false, isFullScreen: true }
+        );
+
+        // … and leaving it restores ONLY the HTML state: no
+        // 'leave-full-screen' fires and the window stays fullscreen. A
+        // single flag would un-hide the window controls here.
+        fireWindowEvent(win, 'leave-html-full-screen');
+        expect(win.webContents.send).toHaveBeenLastCalledWith(
+            WINDOW_STATE_CHANGED,
+            { isMaximized: false, isFullScreen: true }
+        );
+
+        // F11 afterwards is what actually leaves fullscreen.
+        fireWindowEvent(win, 'leave-full-screen');
+        expect(win.webContents.send).toHaveBeenLastCalledWith(
+            WINDOW_STATE_CHANGED,
+            { isMaximized: false, isFullScreen: false }
+        );
+    });
+
+    it('keeps a native fullscreen entered by event across a player HTML fullscreen round-trip', () => {
+        const win = createMockStateWindow();
+        attachWindowStateEvents(win);
+
+        fireWindowEvent(win, 'enter-full-screen');
+        fireWindowEvent(win, 'enter-html-full-screen');
+        fireWindowEvent(win, 'leave-html-full-screen');
+
+        expect(win.webContents.send).toHaveBeenLastCalledWith(
+            WINDOW_STATE_CHANGED,
+            { isMaximized: false, isFullScreen: true }
+        );
+    });
+
+    it('clears isFullScreen when both the native and the HTML state are left', () => {
+        const win = createMockStateWindow();
+        attachWindowStateEvents(win);
+
+        // Windows/Linux HTML fullscreen without prior native fullscreen:
+        // Electron toggles the native window too, so both pairs fire.
+        fireWindowEvent(win, 'enter-full-screen');
+        fireWindowEvent(win, 'enter-html-full-screen');
+        fireWindowEvent(win, 'leave-full-screen');
+        fireWindowEvent(win, 'leave-html-full-screen');
+
+        expect(win.webContents.send).toHaveBeenLastCalledWith(
+            WINDOW_STATE_CHANGED,
+            { isMaximized: false, isFullScreen: false }
+        );
+    });
+
     it('keeps the fullscreen flag when a maximize event arrives mid-transition', () => {
         const win = createMockStateWindow();
         win.isFullScreen.mockReturnValue(true);
diff --git a/apps/electron-backend/src/app/app.spec.ts b/apps/electron-backend/src/app/app.spec.ts
index 2a663d941..f7a94bdb6 100644
--- a/apps/electron-backend/src/app/app.spec.ts
+++ b/apps/electron-backend/src/app/app.spec.ts
@@ -1,9 +1,13 @@
 const mockClearStorageData = jest.fn();
 const mockIsFrameCopyRuntimeUsable = jest.fn<boolean, []>();
 const mockIsEmbeddedMpvFeatureEnabled = jest.fn<boolean, []>();
+const mockHasSwitch = jest.fn<boolean, [string]>();
 
 jest.mock('electron', () => ({
     app: {
+        commandLine: {
+            hasSwitch: mockHasSwitch,
+        },
         getPath: jest.fn(() => '/tmp'),
         isPackaged: false,
         isReady: jest.fn(() => false),
@@ -31,6 +35,7 @@ jest.mock('./services/store.service', () => ({
         get: jest.fn(),
         set: jest.fn(),
     },
+    STARTUP_WINDOW_MODE: 'startupWindowMode',
     WINDOW_BOUNDS: 'windowBounds',
 }));
 
@@ -53,6 +58,7 @@ import { app as electronApp, BrowserWindow, screen } from 'electron';
 import * as path from 'path';
 import { pathToFileURL } from 'url';
 import { store } from './services/store.service';
+import { getPendingFullScreenTarget } from './services/native-fullscreen-transitions';
 
 type MockMainWindow = {
     center: jest.Mock<void, []>;
@@ -64,8 +70,10 @@ type MockMainWindow = {
     isMaximized: jest.Mock<boolean, []>;
     loadFile: jest.Mock<Promise<void>, [string]>;
     loadURL: jest.Mock<Promise<void>, [string]>;
+    maximize: jest.Mock<void, []>;
     on: jest.Mock<void, [string, (...args: unknown[]) => void]>;
     once: jest.Mock<void, [string, (...args: unknown[]) => void]>;
+    setFullScreen: jest.Mock<void, [boolean]>;
     setMenu: jest.Mock<void, [unknown]>;
     show: jest.Mock<void, []>;
     webContents: {
@@ -83,9 +91,11 @@ function createMockMainWindow(): MockMainWindow {
         isMaximized: jest.fn<boolean, []>().mockReturnValue(false),
         loadFile: jest.fn<Promise<void>, [string]>().mockResolvedValue(),
         loadURL: jest.fn<Promise<void>, [string]>().mockResolvedValue(),
+        maximize: jest.fn<void, []>(),
         on: jest.fn<void, [string, (...args: unknown[]) => void]>(),
         once: jest.fn<void, [string, (...args: unknown[]) => void]>(),
         isDestroyed: jest.fn<boolean, []>().mockReturnValue(false),
+        setFullScreen: jest.fn<void, [boolean]>(),
         setMenu: jest.fn<void, [unknown]>(),
         show: jest.fn<void, []>(),
         webContents: {
@@ -97,6 +107,7 @@ function createMockMainWindow(): MockMainWindow {
 }
 
 type AppInternals = {
+    launchFullscreenSwitchConsumed: boolean;
     loadedMainWindow: MockMainWindow | null;
     mainWindow: MockMainWindow | null;
     mainWindowListeners: Array<(mainWindow: MockMainWindow) => void>;
@@ -119,6 +130,7 @@ describe('Electron app security helpers', () => {
         mockIsEmbeddedMpvFeatureEnabled.mockReturnValue(false);
         mockIsFrameCopyRuntimeUsable.mockReturnValue(false);
         const appInternals = getAppInternals();
+        appInternals.launchFullscreenSwitchConsumed = false;
         appInternals.loadedMainWindow = null;
         appInternals.mainWindow = null;
         appInternals.mainWindowLoadPromise = null;
@@ -129,6 +141,7 @@ describe('Electron app security helpers', () => {
             workAreaSize: { height: 720, width: 1280 },
         });
         (store.get as jest.Mock).mockReturnValue(undefined);
+        mockHasSwitch.mockReturnValue(false);
     });
 
     it('creates an explicitly hardened BrowserWindow webPreferences object', () => {
@@ -310,6 +323,170 @@ describe('Electron app security helpers', () => {
         );
     });
 
+    describe('startup window mode', () => {
+        function createWindowViaOnReady(): MockMainWindow {
+            const mainWindow = createMockMainWindow();
+            (BrowserWindow as unknown as jest.Mock).mockReturnValue(mainWindow);
+            getAppInternals().onReady();
+            return mainWindow;
+        }
+
+        function fireReadyToShow(mainWindow: MockMainWindow): void {
+            const handlers = mainWindow.once.mock.calls
+                .filter(([eventName]) => eventName === 'ready-to-show')
+                .map(([, handler]) => handler);
+
+            expect(handlers).toHaveLength(1);
+            handlers[0]();
+        }
+
+        function storeStartupWindowMode(mode: string): void {
+            (store.get as jest.Mock).mockImplementation((key: string) =>
+                key === 'startupWindowMode' ? mode : undefined
+            );
+        }
+
+        it('creates a plain window when nothing is stored', () => {
+            const mainWindow = createWindowViaOnReady();
+
+            expect(BrowserWindow).toHaveBeenCalledWith(
+                expect.not.objectContaining({ fullscreen: true })
+            );
+
+            fireReadyToShow(mainWindow);
+
+            expect(mainWindow.maximize).not.toHaveBeenCalled();
+            expect(mainWindow.setFullScreen).not.toHaveBeenCalled();
+            expect(mainWindow.show).toHaveBeenCalledTimes(1);
+        });
+
+        it('creates the window fullscreen when the stored mode says so', () => {
+            storeStartupWindowMode('fullscreen');
+
+            const mainWindow = createWindowViaOnReady();
+            // Windows/Linux honour the constructor option while the window
+            // is still hidden.
+            mainWindow.isFullScreen.mockReturnValue(true);
+
+            // Still created hidden: fullscreen is entered before the first
+            // paint, and ready-to-show reveals it like any other launch.
+            expect(BrowserWindow).toHaveBeenCalledWith(
+                expect.objectContaining({ fullscreen: true, show: false })
+            );
+            fireReadyToShow(mainWindow);
+            expect(mainWindow.maximize).not.toHaveBeenCalled();
+            expect(mainWindow.show).toHaveBeenCalledTimes(1);
+            // Already fullscreen: no second request, which would animate a
+            // toggle on top of the one that took.
+            expect(mainWindow.setFullScreen).not.toHaveBeenCalled();
+        });
+
+        it('repeats the fullscreen request after show() where the constructor option did not take', () => {
+            storeStartupWindowMode('fullscreen');
+
+            const mainWindow = createWindowViaOnReady();
+            // macOS: an NSWindow only toggles fullscreen once it is on
+            // screen, so a hidden window ignores the constructor option.
+            mainWindow.isFullScreen.mockReturnValue(false);
+
+            fireReadyToShow(mainWindow);
+
+            expect(mainWindow.setFullScreen).toHaveBeenCalledTimes(1);
+            expect(mainWindow.setFullScreen).toHaveBeenCalledWith(true);
+            // Registered with the transition tracker, so an F11 pressed
+            // during the animation is decided against this target and
+            // leaves fullscreen instead of requesting it again.
+            expect(
+                getPendingFullScreenTarget(
+                    mainWindow as unknown as Electron.BrowserWindow
+                )
+            ).toBe(true);
+            expect(mainWindow.show.mock.invocationCallOrder[0]).toBeLessThan(
+                mainWindow.setFullScreen.mock.invocationCallOrder[0]
+            );
+        });
+
+        it('maximizes only once the window is ready to show, before revealing it', () => {
+            storeStartupWindowMode('maximized');
+
+            const mainWindow = createWindowViaOnReady();
+
+            expect(BrowserWindow).toHaveBeenCalledWith(
+                expect.not.objectContaining({ fullscreen: true })
+            );
+            // maximize() on a hidden window shows it — a blank flash if it
+            // ran here.
+            expect(mainWindow.maximize).not.toHaveBeenCalled();
+
+            fireReadyToShow(mainWindow);
+
+            expect(mainWindow.maximize).toHaveBeenCalledTimes(1);
+            expect(mainWindow.show).toHaveBeenCalledTimes(1);
+            expect(
+                mainWindow.maximize.mock.invocationCallOrder[0]
+            ).toBeLessThan(mainWindow.show.mock.invocationCallOrder[0]);
+        });
+
+        it('lets --fullscreen override the stored mode for this launch without persisting it', () => {
+            storeStartupWindowMode('maximized');
+            mockHasSwitch.mockImplementation((name) => name === 'fullscreen');
+
+            const mainWindow = createWindowViaOnReady();
+
+            expect(BrowserWindow).toHaveBeenCalledWith(
+                expect.objectContaining({ fullscreen: true })
+            );
+            fireReadyToShow(mainWindow);
+            expect(mainWindow.maximize).not.toHaveBeenCalled();
+            expect(store.set).not.toHaveBeenCalledWith(
+                'startupWindowMode',
+                expect.anything()
+            );
+        });
+
+        it('consumes --fullscreen with the first window so a window re-created from the macOS Dock follows the stored setting', () => {
+            storeStartupWindowMode('maximized');
+            mockHasSwitch.mockImplementation((name) => name === 'fullscreen');
+
+            const firstWindow = createWindowViaOnReady();
+            expect(BrowserWindow).toHaveBeenLastCalledWith(
+                expect.objectContaining({ fullscreen: true })
+            );
+            fireReadyToShow(firstWindow);
+
+            // The user left fullscreen and closed the only window; the
+            // process survived and the Dock brings the window back.
+            const appInternals = getAppInternals();
+            appInternals.mainWindow = null;
+            const secondWindow = createMockMainWindow();
+            (BrowserWindow as unknown as jest.Mock).mockReturnValue(
+                secondWindow
+            );
+
+            App.ensureMainWindow();
+
+            expect(BrowserWindow).toHaveBeenCalledTimes(2);
+            expect(BrowserWindow).toHaveBeenLastCalledWith(
+                expect.not.objectContaining({ fullscreen: true })
+            );
+            fireReadyToShow(secondWindow);
+            expect(secondWindow.setFullScreen).not.toHaveBeenCalled();
+            expect(secondWindow.maximize).toHaveBeenCalledTimes(1);
+        });
+
+        it('treats a hand-edited unknown stored mode as a plain window', () => {
+            storeStartupWindowMode('kiosk');
+
+            const mainWindow = createWindowViaOnReady();
+
+            expect(BrowserWindow).toHaveBeenCalledWith(
+                expect.not.objectContaining({ fullscreen: true })
+            );
+            fireReadyToShow(mainWindow);
+            expect(mainWindow.maximize).not.toHaveBeenCalled();
+        });
+    });
+
     it('creates the main window immediately when Electron is already ready', () => {
         const mainWindow = createMockMainWindow();
         (BrowserWindow as unknown as jest.Mock).mockReturnValue(mainWindow);
diff --git a/apps/electron-backend/src/app/app.ts b/apps/electron-backend/src/app/app.ts
index 77a63d2d7..93b5a3169 100644
--- a/apps/electron-backend/src/app/app.ts
+++ b/apps/electron-backend/src/app/app.ts
@@ -12,9 +12,21 @@ import {
     isWindowTraceEnabled,
     trace,
 } from './services/debug-trace';
-import { store, WINDOW_BOUNDS } from './services/store.service';
+import {
+    STARTUP_WINDOW_MODE,
+    store,
+    WINDOW_BOUNDS,
+} from './services/store.service';
 import { isFrameCopyRuntimeUsable } from './services/embedded-mpv-frame-copy-platform.util';
 import { isEmbeddedMpvFeatureEnabled } from './services/embedded-mpv-runtime-policy.util';
+import {
+    FULLSCREEN_LAUNCH_SWITCH,
+    resolveStartupWindowMode,
+} from './services/startup-window-mode';
+import {
+    requestFullScreen,
+    trackNativeFullScreen,
+} from './services/native-fullscreen-transitions';
 
 const externalBrowserProtocols = new Set(['http:', 'https:']);
 const trustedDevRendererHosts = new Set([
@@ -223,6 +235,13 @@ export default class App {
     static BrowserWindow;
     private static loadedMainWindow: Electron.BrowserWindow | null = null;
     private static mainWindowLoadPromise: Promise<void> | null = null;
+    /**
+     * Whether the `--fullscreen` launch switch has already shaped a window.
+     * See initMainWindow: the switch is consumed by the first window so a
+     * window re-created later in the same process (macOS Dock) follows the
+     * stored setting instead.
+     */
+    private static launchFullscreenSwitchConsumed = false;
     private static rendererLoadingEnabled = false;
 
     private static shouldOpenDevTools() {
@@ -384,6 +403,16 @@ export default class App {
             isFullScreen: win.isFullScreen(),
         };
 
+        // Native (OS-level) and HTML-element fullscreen are tracked apart
+        // and OR-ed into the pushed flag. Electron remembers when the window
+        // was already natively fullscreen before the player entered HTML
+        // fullscreen and then leaves ONLY the HTML state on exit — no
+        // 'leave-full-screen' fires and the window stays fullscreen. A single
+        // flag cleared by 'leave-html-full-screen' would un-hide the window
+        // controls over a window that is still fullscreen, which a fullscreen
+        // launch or F11 followed by the player's F → Esc makes routine.
+        const fullscreen = { native: state.isFullScreen, html: false };
+
         const push = (patch: Partial<ElectronBridgeWindowState>) => {
             Object.assign(state, patch);
 
@@ -395,16 +424,30 @@ export default class App {
             // mutations of the tracked state.
             win.webContents.send(WINDOW_STATE_CHANGED, { ...state });
         };
+        const pushFullScreen = () =>
+            push({ isFullScreen: fullscreen.native || fullscreen.html });
 
         win.on('maximize', () => push({ isMaximized: true }));
         win.on('unmaximize', () => push({ isMaximized: false }));
         // The html variants cover HTML-element fullscreen; not every
         // platform/trigger emits both pairs, and duplicate pushes with the
         // same payload are harmless.
-        win.on('enter-full-screen', () => push({ isFullScreen: true }));
-        win.on('enter-html-full-screen', () => push({ isFullScreen: true }));
-        win.on('leave-full-screen', () => push({ isFullScreen: false }));
-        win.on('leave-html-full-screen', () => push({ isFullScreen: false }));
+        win.on('enter-full-screen', () => {
+            fullscreen.native = true;
+            pushFullScreen();
+        });
+        win.on('leave-full-screen', () => {
+            fullscreen.native = false;
+            pushFullScreen();
+        });
+        win.on('enter-html-full-screen', () => {
+            fullscreen.html = true;
+            pushFullScreen();
+        });
+        win.on('leave-html-full-screen', () => {
+            fullscreen.html = false;
+            pushFullScreen();
+        });
     }
 
     private static initMainWindow() {
@@ -413,6 +456,17 @@ export default class App {
         const height = Math.min(720, workAreaSize.height || 720);
 
         const savedWindowBounds = store.get(WINDOW_BOUNDS);
+        const startupWindowMode = resolveStartupWindowMode({
+            // One-shot: the switch describes the launch, not every window
+            // this process ever opens. On macOS the process outlives its
+            // last window and the Dock re-creates it through this same
+            // path, which must then follow the stored setting only.
+            cliHasFullscreenSwitch:
+                !App.launchFullscreenSwitchConsumed &&
+                app.commandLine.hasSwitch(FULLSCREEN_LAUNCH_SWITCH),
+            storedMode: store.get(STARTUP_WINDOW_MODE),
+        });
+        App.launchFullscreenSwitchConsumed = true;
 
         // Create the browser window.
         App.mainWindow = new BrowserWindow({
@@ -422,6 +476,12 @@ export default class App {
             show: false,
             webPreferences: getMainWindowWebPreferences(),
             ...savedWindowBounds,
+            // Fullscreen is a constructor option: the window is created
+            // hidden and enters fullscreen before its first paint. The saved
+            // bounds stay spread in above — they are the normal bounds the
+            // window returns to, and the close handler keeps persisting
+            // getNormalBounds(), so a fullscreen session never corrupts them.
+            ...(startupWindowMode === 'fullscreen' ? { fullscreen: true } : {}),
             minHeight: 600,
             minWidth: 900,
             ...App.getPlatformTitleBarOptions(),
@@ -429,6 +489,9 @@ export default class App {
         App.mainWindow.setMenu(null);
         attachWindowTrace(App.mainWindow);
         App.attachWindowStateEvents(App.mainWindow);
+        // Seeds the F11 tracker's fullscreen state now, while no transition
+        // can be in flight; from here on it follows the window's events.
+        trackNativeFullScreen(App.mainWindow);
         App.notifyMainWindowCreated(App.mainWindow);
         if (!savedWindowBounds) {
             App.mainWindow.center();
@@ -436,7 +499,27 @@ export default class App {
 
         // if main window is ready to show, close the splash window and show the main window
         App.mainWindow.once('ready-to-show', () => {
+            // maximize() on a hidden window shows it (Electron docs), so it
+            // has to wait for ready-to-show like show() does — any earlier
+            // and a blank window flashes before the renderer paints.
+            if (startupWindowMode === 'maximized') {
+                App.mainWindow.maximize();
+            }
             App.mainWindow.show();
+            // macOS ignores the constructor's `fullscreen` while the window
+            // is hidden — an NSWindow can only toggle fullscreen once it is
+            // on screen — so the request is repeated after show() wherever
+            // it has not taken yet. Windows/Linux honoured it at creation
+            // (before the first paint) and are left alone. It goes through
+            // the transition tracker so an F11 pressed during the animation
+            // reads the pending target and leaves fullscreen instead of
+            // asking for it again.
+            if (
+                startupWindowMode === 'fullscreen' &&
+                !App.mainWindow.isFullScreen()
+            ) {
+                requestFullScreen(App.mainWindow, true);
+            }
         });
 
         // Route target="_blank" / window.open() to the OS default browser
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 cd086ee7c..86bda42ff 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
@@ -5,17 +5,26 @@ jest.mock('electron', () => ({
 }));
 
 const mockEmbeddedMpvService = {
+    createSession: jest.fn(),
     getSupport: jest.fn(),
     setPaused: jest.fn(),
 };
+const mockSessionOptions = {
+    extraOptions: ['network-timeout=10', 'hwdec=no'],
+    autoReconnect: false,
+};
 
 jest.mock('../services/embedded-mpv-native.service', () => ({
     EmbeddedMpvNativeService: class {},
     embeddedMpvNativeService: mockEmbeddedMpvService,
 }));
+jest.mock('../services/embedded-mpv-session-options', () => ({
+    readEmbeddedMpvSessionOptions: () => mockSessionOptions,
+}));
 
 import { ipcMain } from 'electron';
 import {
+    EMBEDDED_MPV_CREATE_SESSION,
     EMBEDDED_MPV_SET_PAUSED,
     EMBEDDED_MPV_SUPPORT,
 } from '@iptvnator/shared/interfaces';
@@ -41,10 +50,29 @@ function getIpcMainHandler(
 
 describe('EmbeddedMpvEvents IPC handlers', () => {
     beforeEach(() => {
+        mockEmbeddedMpvService.createSession.mockReset();
         mockEmbeddedMpvService.getSupport.mockReset();
         mockEmbeddedMpvService.setPaused.mockReset();
     });
 
+    it('creates a session with the options read from the settings mirror', async () => {
+        const session = { id: 'session-1', status: 'idle' };
+        mockEmbeddedMpvService.createSession.mockReturnValue(session);
+        const bounds = { x: 0, y: 0, width: 640, height: 360 };
+
+        const handler = getIpcMainHandler(EMBEDDED_MPV_CREATE_SESSION);
+
+        await expect(handler({}, bounds, 'Title', 0.5)).resolves.toEqual(
+            session
+        );
+        expect(mockEmbeddedMpvService.createSession).toHaveBeenCalledWith(
+            bounds,
+            'Title',
+            0.5,
+            mockSessionOptions
+        );
+    });
+
     it('forwards arguments to the native service and returns its result', async () => {
         const session = { id: 'session-1', status: 'paused' };
         mockEmbeddedMpvService.setPaused.mockReturnValue(session);
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 8eaa0cc55..b863dd4f2 100644
--- a/apps/electron-backend/src/app/events/embedded-mpv.events.ts
+++ b/apps/electron-backend/src/app/events/embedded-mpv.events.ts
@@ -32,6 +32,7 @@ import {
     EmbeddedMpvNativeService,
     embeddedMpvNativeService,
 } from '../services/embedded-mpv-native.service';
+import { readEmbeddedMpvSessionOptions } from '../services/embedded-mpv-session-options';
 
 export default class EmbeddedMpvEvents {
     static bootstrapEmbeddedMpvEvents(): Electron.IpcMain {
@@ -57,10 +58,7 @@ function handleEmbeddedMpv<Args extends unknown[]>(
         try {
             return await handler(...(args as Args));
         } catch (error) {
-            console.error(
-                `[Embedded MPV] ${channel} handler failed:`,
-                error
-            );
+            console.error(`[Embedded MPV] ${channel} handler failed:`, error);
             throw error;
         }
     });
@@ -73,7 +71,14 @@ handleEmbeddedMpv(EMBEDDED_MPV_PREPARE, () => getService().prepareAddon());
 handleEmbeddedMpv(
     EMBEDDED_MPV_CREATE_SESSION,
     (bounds: EmbeddedMpvBounds, title?: string, initialVolume?: number) =>
-        getService().createSession(bounds, title, initialVolume)
+        // Settings are read here, per session, so the service itself never
+        // touches the config store (constructed at module load).
+        getService().createSession(
+            bounds,
+            title,
+            initialVolume,
+            readEmbeddedMpvSessionOptions()
+        )
 );
 
 handleEmbeddedMpv(
@@ -144,9 +149,8 @@ handleEmbeddedMpv(EMBEDDED_MPV_SELECT_SUBTITLE_FILE, () =>
     getService().selectSubtitleFile()
 );
 
-handleEmbeddedMpv(
-    EMBEDDED_MPV_SET_SPEED,
-    (sessionId: string, speed: number) => getService().setSpeed(sessionId, speed)
+handleEmbeddedMpv(EMBEDDED_MPV_SET_SPEED, (sessionId: string, speed: number) =>
+    getService().setSpeed(sessionId, speed)
 );
 
 handleEmbeddedMpv(
diff --git a/apps/electron-backend/src/app/events/settings.events.spec.ts b/apps/electron-backend/src/app/events/settings.events.spec.ts
index d115c0514..f9bae781c 100644
--- a/apps/electron-backend/src/app/events/settings.events.spec.ts
+++ b/apps/electron-backend/src/app/events/settings.events.spec.ts
@@ -6,11 +6,13 @@ type SettingsUpdatePayload = Omit<
     | 'embeddedMpvFrameCopy'
     | 'language'
     | 'mpvPlayerArguments'
+    | 'startupWindowMode'
     | 'vlcPlayerArguments'
 > & {
     embeddedMpvFrameCopy?: boolean | number;
     language?: string;
     mpvPlayerArguments?: ExternalPlayerArgumentsSetting;
+    startupWindowMode?: string;
     vlcPlayerArguments?: ExternalPlayerArgumentsSetting;
 };
 type SettingsUpdateHandler = (
@@ -20,9 +22,12 @@ type SettingsUpdateHandler = (
 
 const SETTINGS_UPDATE = 'SETTINGS_UPDATE';
 const STORE_KEYS = {
+    EMBEDDED_MPV_AUTO_RECONNECT: 'EMBEDDED_MPV_AUTO_RECONNECT',
+    EMBEDDED_MPV_EXTRA_OPTIONS: 'EMBEDDED_MPV_EXTRA_OPTIONS',
     EMBEDDED_MPV_FRAME_COPY: 'EMBEDDED_MPV_FRAME_COPY',
     MPV_PLAYER_ARGUMENTS: 'MPV_PLAYER_ARGUMENTS',
     MPV_REUSE_INSTANCE: 'MPV_REUSE_INSTANCE',
+    STARTUP_WINDOW_MODE: 'STARTUP_WINDOW_MODE',
     VLC_PLAYER_ARGUMENTS: 'VLC_PLAYER_ARGUMENTS',
     VLC_REUSE_INSTANCE: 'VLC_REUSE_INSTANCE',
 } as const;
@@ -44,9 +49,12 @@ jest.mock('electron', () => ({
 }));
 
 jest.mock('../services/store.service', () => ({
+    EMBEDDED_MPV_AUTO_RECONNECT: STORE_KEYS.EMBEDDED_MPV_AUTO_RECONNECT,
+    EMBEDDED_MPV_EXTRA_OPTIONS: STORE_KEYS.EMBEDDED_MPV_EXTRA_OPTIONS,
     EMBEDDED_MPV_FRAME_COPY: STORE_KEYS.EMBEDDED_MPV_FRAME_COPY,
     MPV_PLAYER_ARGUMENTS: STORE_KEYS.MPV_PLAYER_ARGUMENTS,
     MPV_REUSE_INSTANCE: STORE_KEYS.MPV_REUSE_INSTANCE,
+    STARTUP_WINDOW_MODE: STORE_KEYS.STARTUP_WINDOW_MODE,
     VLC_PLAYER_ARGUMENTS: STORE_KEYS.VLC_PLAYER_ARGUMENTS,
     VLC_REUSE_INSTANCE: STORE_KEYS.VLC_REUSE_INSTANCE,
     store: {
@@ -136,6 +144,48 @@ describe('SETTINGS_UPDATE', () => {
         expect(mockUpdateSettings).not.toHaveBeenCalled();
     });
 
+    it('mirrors the embedded MPV extra options in canonical form', () => {
+        settingsUpdateHandler(
+            {},
+            { embeddedMpvExtraOptions: ' --hwdec = auto \r\n\nvo=null\n' }
+        );
+
+        expect(mockStoreSet.mock.calls).toEqual([
+            [STORE_KEYS.EMBEDDED_MPV_EXTRA_OPTIONS, 'hwdec=auto\nvo=null'],
+        ]);
+        expect(mockUpdateSettings).not.toHaveBeenCalled();
+    });
+
+    it('mirrors the embedded MPV auto-reconnect toggle as a boolean', () => {
+        settingsUpdateHandler({}, { embeddedMpvAutoReconnect: false });
+        expect(mockStoreSet.mock.calls).toEqual([
+            [STORE_KEYS.EMBEDDED_MPV_AUTO_RECONNECT, false],
+        ]);
+
+        mockStoreSet.mockClear();
+        settingsUpdateHandler({}, { embeddedMpvAutoReconnect: true });
+        expect(mockStoreSet.mock.calls).toEqual([
+            [STORE_KEYS.EMBEDDED_MPV_AUTO_RECONNECT, true],
+        ]);
+    });
+
+    it('mirrors the startup window mode into the main-process store', () => {
+        settingsUpdateHandler({}, { startupWindowMode: 'fullscreen' });
+
+        expect(mockStoreSet.mock.calls).toEqual([
+            [STORE_KEYS.STARTUP_WINDOW_MODE, 'fullscreen'],
+        ]);
+        expect(mockUpdateSettings).not.toHaveBeenCalled();
+    });
+
+    it('normalizes an unknown startup window mode to normal instead of storing junk', () => {
+        settingsUpdateHandler({}, { startupWindowMode: 'kiosk' });
+
+        expect(mockStoreSet.mock.calls).toEqual([
+            [STORE_KEYS.STARTUP_WINDOW_MODE, 'normal'],
+        ]);
+    });
+
     it('reconciles an enabled remote-control update with the stored port', () => {
         mockStoreGet.mockImplementation(
             (key: string, fallbackValue: unknown): unknown =>
@@ -197,6 +247,26 @@ describe('SETTINGS_UPDATE', () => {
         expect(output).toContain('enabled');
     });
 
+    it('does not print credentials embedded in embedded MPV extra options', () => {
+        const headerSecret = 'embedded-mpv-header-secret';
+
+        settingsUpdateHandler(
+            {},
+            {
+                language: 'de',
+                embeddedMpvExtraOptions: `cache-secs=5\nhttp-header-fields=X-Playback-Key: ${headerSecret}`,
+            }
+        );
+
+        const output = JSON.stringify(consoleLogSpy.mock.calls);
+        expect(output).not.toContain(headerSecret);
+        expect(output).toContain('language');
+        expect(mockStoreSet).toHaveBeenCalledWith(
+            STORE_KEYS.EMBEDDED_MPV_EXTRA_OPTIONS,
+            `cache-secs=5\nhttp-header-fields=X-Playback-Key: ${headerSecret}`
+        );
+    });
+
     it('does not print credentials embedded in external player arguments', () => {
         const authorizationSecret = 'player-authorization-secret';
         const cookieSecret = 'player-cookie-secret';
diff --git a/apps/electron-backend/src/app/events/settings.events.ts b/apps/electron-backend/src/app/events/settings.events.ts
index d05ccdcf0..5770e4483 100644
--- a/apps/electron-backend/src/app/events/settings.events.ts
+++ b/apps/electron-backend/src/app/events/settings.events.ts
@@ -1,10 +1,17 @@
 import { ipcMain } from 'electron';
-import { normalizeExternalPlayerArguments } from '@iptvnator/shared/interfaces';
+import {
+    normalizeEmbeddedMpvExtraOptions,
+    normalizeExternalPlayerArguments,
+    normalizeStartupWindowMode,
+} from '@iptvnator/shared/interfaces';
 import { redactSensitiveData } from '@iptvnator/shared/logging';
 import {
+    EMBEDDED_MPV_AUTO_RECONNECT,
+    EMBEDDED_MPV_EXTRA_OPTIONS,
     EMBEDDED_MPV_FRAME_COPY,
     MPV_PLAYER_ARGUMENTS,
     MPV_REUSE_INSTANCE,
+    STARTUP_WINDOW_MODE,
     store,
     VLC_PLAYER_ARGUMENTS,
     VLC_REUSE_INSTANCE,
@@ -46,6 +53,28 @@ ipcMain.handle('SETTINGS_UPDATE', (_event, arg) => {
     if (arg.embeddedMpvFrameCopy !== undefined) {
         store.set(EMBEDDED_MPV_FRAME_COPY, !!arg.embeddedMpvFrameCopy);
     }
+    if (arg.embeddedMpvExtraOptions !== undefined) {
+        store.set(
+            EMBEDDED_MPV_EXTRA_OPTIONS,
+            normalizeEmbeddedMpvExtraOptions(arg.embeddedMpvExtraOptions)
+        );
+    }
+    if (arg.embeddedMpvAutoReconnect !== undefined) {
+        store.set(
+            EMBEDDED_MPV_AUTO_RECONNECT,
+            arg.embeddedMpvAutoReconnect !== false
+        );
+    }
+
+    // Read by initMainWindow before any renderer exists, so it applies on
+    // the next launch. Normalized here so a junk value never reaches the
+    // config file.
+    if (arg.startupWindowMode !== undefined) {
+        store.set(
+            STARTUP_WINDOW_MODE,
+            normalizeStartupWindowMode(arg.startupWindowMode)
+        );
+    }
 
     if (arg.vlcReuseInstance !== undefined) {
         store.set(VLC_REUSE_INSTANCE, arg.vlcReuseInstance);
diff --git a/apps/electron-backend/src/app/events/window.events.spec.ts b/apps/electron-backend/src/app/events/window.events.spec.ts
index c5195ef51..a144ebb11 100644
--- a/apps/electron-backend/src/app/events/window.events.spec.ts
+++ b/apps/electron-backend/src/app/events/window.events.spec.ts
@@ -1,3 +1,5 @@
+import { FULLSCREEN_TRANSITION_TIMEOUT_MS } from '../services/native-fullscreen-transitions';
+
 const mockHandlers = new Map<
     string,
     (event: unknown, ...args: unknown[]) => unknown
@@ -21,14 +23,25 @@ jest.mock('electron', () => ({
 }));
 
 function createFakeWindow(
-    initial: { maximized?: boolean; fullScreen?: boolean } = {}
+    initial: {
+        maximized?: boolean;
+        fullScreen?: boolean;
+        /**
+         * Windows/Linux flip isFullScreen() inside setFullScreen(); macOS
+         * animates and reports the old value until the transition lands,
+         * which the test then signals through `emit`.
+         */
+        asyncFullScreen?: boolean;
+    } = {}
 ) {
     const state = {
         maximized: initial.maximized ?? false,
         fullScreen: initial.fullScreen ?? false,
     };
+    const listeners = new Map<string, Set<() => void>>();
 
     return {
+        state,
         isDestroyed: jest.fn(() => false),
         isMaximized: jest.fn(() => state.maximized),
         isFullScreen: jest.fn(() => state.fullScreen),
@@ -39,6 +52,25 @@ function createFakeWindow(
         unmaximize: jest.fn(() => {
             state.maximized = false;
         }),
+        setFullScreen: jest.fn((fullScreen: boolean) => {
+            if (!initial.asyncFullScreen) {
+                state.fullScreen = fullScreen;
+            }
+        }),
+        on: jest.fn((event: string, listener: () => void) => {
+            listeners.set(
+                event,
+                (listeners.get(event) ?? new Set()).add(listener)
+            );
+        }),
+        off: jest.fn((event: string, listener: () => void) => {
+            listeners.get(event)?.delete(listener);
+        }),
+        emit(event: string): void {
+            for (const listener of [...(listeners.get(event) ?? [])]) {
+                listener();
+            }
+        },
         close: jest.fn(),
     };
 }
@@ -59,6 +91,7 @@ describe('WindowEvents', () => {
             'WINDOW:CLOSE',
             'WINDOW:GET_STATE',
             'WINDOW:MINIMIZE',
+            'WINDOW:TOGGLE_FULLSCREEN',
             'WINDOW:TOGGLE_MAXIMIZE',
         ]);
     });
@@ -94,6 +127,271 @@ describe('WindowEvents', () => {
         expect(result).toEqual({ isMaximized: false, isFullScreen: false });
     });
 
+    it('enters fullscreen from a windowed state and reports the requested state', () => {
+        const win = createFakeWindow({ maximized: true, fullScreen: false });
+        mockFromWebContents.mockReturnValue(win);
+
+        const result = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!(fakeEvent);
+
+        expect(win.setFullScreen).toHaveBeenCalledWith(true);
+        expect(result).toEqual({ isMaximized: true, isFullScreen: true });
+    });
+
+    it('leaves fullscreen and reports the requested state', () => {
+        const win = createFakeWindow({ fullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+
+        const result = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!(fakeEvent);
+
+        expect(win.setFullScreen).toHaveBeenCalledWith(false);
+        expect(result).toEqual({ isMaximized: false, isFullScreen: false });
+    });
+
+    it('keeps toggle parity when a second press arrives before the transition lands', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        // Still animating: the window reports the old state.
+        expect(win.isFullScreen()).toBe(false);
+
+        const second = toggle(fakeEvent);
+
+        // Decided against the pending target, not the stale getter.
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false]]);
+        expect(second).toEqual({ isMaximized: false, isFullScreen: false });
+
+        // The first transition lands on the other state: the exit is still
+        // queued on the platform, so the record stays and nothing is
+        // re-issued — the tracker never requests on its own.
+        win.state.fullScreen = true;
+        win.emit('enter-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(2);
+
+        win.state.fullScreen = false;
+        win.emit('leave-full-screen');
+
+        // Back to deciding from the tracked state.
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(true);
+    });
+
+    it('stops tracking once the transition reports the requested state', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        win.state.fullScreen = true;
+        win.emit('enter-full-screen');
+        // Reported the requested state: nothing re-issued.
+        expect(win.setFullScreen).toHaveBeenCalledTimes(1);
+
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(false);
+    });
+
+    it('settles against the state the event conveys, not a stale getter', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        // Windows: the enter event fires while isFullScreen() still reports
+        // the pre-transition false. Read the getter here and the landed
+        // enter would not match the requested enter, leaving the record in
+        // place to misdirect the next press.
+        expect(win.isFullScreen()).toBe(false);
+        win.emit('enter-full-screen');
+
+        toggle(fakeEvent);
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false]]);
+    });
+
+    it('decides a press that lands between the event and the getter update from the tracked state', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        // The enter event landed and settled the pending target …
+        win.emit('enter-full-screen');
+        // … but the getter has not caught up yet (Windows).
+        expect(win.isFullScreen()).toBe(false);
+
+        toggle(fakeEvent);
+
+        // Decided against the event-fed state: this press is the exit.
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false]]);
+    });
+
+    it('follows fullscreen changes the app did not request', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        // Green button / Ctrl+Cmd+F: only the event tells the tracker.
+        toggle(fakeEvent);
+        win.state.fullScreen = true;
+        win.emit('enter-full-screen');
+        win.emit('leave-full-screen');
+
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(true);
+    });
+
+    it('leaves no debt behind when a platform coalesces a burst into one event', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        toggle(fakeEvent);
+        toggle(fakeEvent);
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false], [true]]);
+
+        // A single enter is all the platform reports for the whole burst.
+        // It lands on the final target, so the record is done — events
+        // cannot say which request they belong to, and counting them would
+        // leave phantom debt that reverses the user's next action.
+        win.emit('enter-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(3);
+
+        // Green button right after: an unrelated action, honoured as is.
+        win.emit('leave-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(3);
+
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(true);
+    });
+
+    it('self-heals through the timeout if a platform ever drops a queued request', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+        const now = jest.spyOn(Date, 'now');
+
+        try {
+            now.mockReturnValue(1_000);
+            toggle(fakeEvent);
+            toggle(fakeEvent);
+            win.emit('enter-full-screen');
+            // The queued exit never happens and nothing is re-issued …
+            expect(win.setFullScreen).toHaveBeenCalledTimes(2);
+
+            // … so once the record expires, the event-fed state governs and
+            // the next press is the exit the user still wants.
+            now.mockReturnValue(1_000 + FULLSCREEN_TRANSITION_TIMEOUT_MS + 1);
+            toggle(fakeEvent);
+            expect(win.setFullScreen).toHaveBeenLastCalledWith(false);
+        } finally {
+            now.mockRestore();
+        }
+    });
+
+    it('honours a native action opposite to a pending target instead of reversing it', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        toggle(fakeEvent);
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false]]);
+
+        // Whatever produced this enter — the first press's transition or
+        // the user's own green button — the tracker must not answer it
+        // with a request of its own.
+        win.emit('enter-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(2);
+
+        // The exit lands: the record is done, later native actions are
+        // simply followed.
+        win.emit('leave-full-screen');
+        win.emit('enter-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(2);
+
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(false);
+    });
+
+    it('forgets a request that never reports back after the transition timeout', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+        const now = jest.spyOn(Date, 'now');
+
+        try {
+            now.mockReturnValue(1_000);
+            toggle(fakeEvent);
+            expect(win.setFullScreen).toHaveBeenLastCalledWith(true);
+
+            // No event ever arrived: the window really is still windowed,
+            // so the stale target must not flip this press into an exit.
+            now.mockReturnValue(1_000 + FULLSCREEN_TRANSITION_TIMEOUT_MS + 1);
+            toggle(fakeEvent);
+            expect(win.setFullScreen).toHaveBeenLastCalledWith(true);
+        } finally {
+            now.mockRestore();
+        }
+    });
+
+    it('does not revive an expired target when its transition event arrives late', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+        const now = jest.spyOn(Date, 'now');
+
+        try {
+            now.mockReturnValue(1_000);
+            toggle(fakeEvent);
+            toggle(fakeEvent);
+            expect(win.setFullScreen.mock.calls).toEqual([[true], [false]]);
+
+            // The enter lands long after the timeout, on the other state
+            // than the expired "windowed" target. Re-issuing it here would
+            // resurrect intent the user has long moved past.
+            now.mockReturnValue(1_000 + FULLSCREEN_TRANSITION_TIMEOUT_MS + 1);
+            win.state.fullScreen = true;
+            win.emit('enter-full-screen');
+            expect(win.setFullScreen).toHaveBeenCalledTimes(2);
+
+            // The next press is decided from the live state.
+            toggle(fakeEvent);
+            expect(win.setFullScreen).toHaveBeenLastCalledWith(false);
+        } finally {
+            now.mockRestore();
+        }
+    });
+
+    it('keeps deciding against the latest intent through a burst whose events lag behind', () => {
+        const win = createFakeWindow({ asyncFullScreen: true });
+        mockFromWebContents.mockReturnValue(win);
+        const toggle = mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!;
+
+        toggle(fakeEvent);
+        toggle(fakeEvent);
+        // The first enter lands while the exit is still queued.
+        win.state.fullScreen = true;
+        win.emit('enter-full-screen');
+
+        // A press now is decided against the still-pending exit, so the
+        // window is asked back into fullscreen — the user's third intent.
+        toggle(fakeEvent);
+        expect(win.setFullScreen.mock.calls).toEqual([[true], [false], [true]]);
+
+        // The queued exit lands: not the latest target, record kept.
+        win.state.fullScreen = false;
+        win.emit('leave-full-screen');
+        expect(win.setFullScreen).toHaveBeenCalledTimes(3);
+
+        // The third request lands: record cleared, the next press exits.
+        win.state.fullScreen = true;
+        win.emit('enter-full-screen');
+        toggle(fakeEvent);
+        expect(win.setFullScreen).toHaveBeenLastCalledWith(false);
+    });
+
     it('closes the sender window', () => {
         const win = createFakeWindow();
         mockFromWebContents.mockReturnValue(win);
@@ -122,6 +420,12 @@ describe('WindowEvents', () => {
             isMaximized: false,
             isFullScreen: false,
         });
+        expect(
+            mockHandlers.get('WINDOW:TOGGLE_FULLSCREEN')!(fakeEvent)
+        ).toEqual({
+            isMaximized: false,
+            isFullScreen: false,
+        });
         expect(mockHandlers.get('WINDOW:GET_STATE')!(fakeEvent)).toEqual({
             isMaximized: false,
             isFullScreen: false,
diff --git a/apps/electron-backend/src/app/events/window.events.ts b/apps/electron-backend/src/app/events/window.events.ts
index a5e01ae2a..5ce0d79c4 100644
--- a/apps/electron-backend/src/app/events/window.events.ts
+++ b/apps/electron-backend/src/app/events/window.events.ts
@@ -10,8 +10,10 @@ import {
     WINDOW_CLOSE,
     WINDOW_GET_STATE,
     WINDOW_MINIMIZE,
+    WINDOW_TOGGLE_FULLSCREEN,
     WINDOW_TOGGLE_MAXIMIZE,
 } from '@iptvnator/shared/interfaces';
+import { toggleFullScreen } from '../services/native-fullscreen-transitions';
 
 interface WindowState {
     isMaximized: boolean;
@@ -67,6 +69,26 @@ ipcMain.handle(WINDOW_TOGGLE_MAXIMIZE, (event): WindowState => {
     };
 });
 
+// F11. This is the exit path from a fullscreen launch on Windows/Linux,
+// where the title bar is hidden and the custom controls hide themselves
+// while fullscreen. The transition tracker decides against the pending
+// target while a transition (including the startup fullscreen) is still in
+// flight, so two quick presses stay an enter-then-exit. Like the maximize
+// toggle it reports the requested state and leaves WINDOW:STATE_CHANGED
+// authoritative.
+ipcMain.handle(WINDOW_TOGGLE_FULLSCREEN, (event): WindowState => {
+    const win = getSenderWindow(event);
+
+    if (!win) {
+        return getWindowState(win);
+    }
+
+    return {
+        isMaximized: win.isMaximized(),
+        isFullScreen: toggleFullScreen(win),
+    };
+});
+
 // win.close() (instead of app.quit()) so the window's 'close' handler still
 // persists the window bounds before shutdown.
 ipcMain.handle(WINDOW_CLOSE, (event) => {
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-protocol.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-protocol.ts
index d5fecefbb..3f5a56429 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-protocol.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-protocol.ts
@@ -25,6 +25,23 @@ export function encodeProtocolValue(value: string): string {
         .replace(/\r/g, '%0D');
 }
 
+/**
+ * The first line the adapter writes to a helper started with
+ * `--mpv-options-stdin`: the session's libmpv options in application order.
+ * They travel over stdin rather than argv so a credential-bearing option is
+ * never visible to `ps`; zero-padded keys keep the order through the
+ * helper's unordered field map.
+ */
+export function buildMpvOptionsPreamble(options: readonly string[]): string {
+    return [
+        'mpv-options',
+        ...options.map(
+            (option, index) =>
+                `o${String(index).padStart(3, '0')}=${encodeProtocolValue(option)}`
+        ),
+    ].join('\t');
+}
+
 export function createInitialSnapshot(): NativeEmbeddedMpvSessionSnapshot {
     return {
         status: 'loading',
@@ -53,7 +70,9 @@ export function buildLoadPlaybackCommand(
         );
     }
     if (playback.userAgent) {
-        fields.push(`opt.user-agent=${encodeProtocolValue(playback.userAgent)}`);
+        fields.push(
+            `opt.user-agent=${encodeProtocolValue(playback.userAgent)}`
+        );
     }
     if (playback.referer) {
         fields.push(`opt.referrer=${encodeProtocolValue(playback.referer)}`);
@@ -128,6 +147,7 @@ export function applyHelperEvent(
             session.snapshot.error = String(
                 event.error ?? 'Embedded MPV helper failed.'
             );
+            session.snapshot.errorOrigin = 'engine';
             break;
         case 'log':
             if (event.level === 'error' || event.level === 'fatal') {
@@ -136,6 +156,16 @@ export function applyHelperEvent(
                         event.prefix ?? ''
                     )}] ${String(event.text ?? '').trim()}`
                 );
+            } else if (event.level === 'warn' && event.prefix === 'iptvnator') {
+                // The helper's own warnings (a session option libmpv
+                // rejected) must reach the main-process log like the
+                // native-view trace does; mpv's warn-level chatter stays
+                // filtered.
+                console.warn(
+                    `[embedded-mpv-fc][${session.id}] ${String(
+                        event.text ?? ''
+                    ).trim()}`
+                );
             }
             break;
         default:
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-spawn.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-spawn.ts
index d0480626f..a282cdd59 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-spawn.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy-spawn.ts
@@ -61,6 +61,9 @@ export function resolveFrameCopyHelperSpawn(
         ...(process.env.IPTVNATOR_EMBEDDED_MPV_AUDIO_DELAY
             ? ['--audio-delay', process.env.IPTVNATOR_EMBEDDED_MPV_AUDIO_DELAY]
             : []),
+        // Session options follow as the first stdin line (see
+        // buildMpvOptionsPreamble), never as arguments `ps` could read.
+        '--mpv-options-stdin',
     ];
 
     if (process.platform !== 'linux') {
@@ -81,7 +84,9 @@ export function resolveFrameCopyHelperSpawn(
         fileSystem: helperLaunchFileSystem,
     });
     if (!launch.usable) {
-        throw new Error('The connected Snap graphics provider is not available.');
+        throw new Error(
+            'The connected Snap graphics provider is not available.'
+        );
     }
 
     return {
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.linux-env.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.linux-env.spec.ts
index b2b542a7f..e14c43b9f 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.linux-env.spec.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.linux-env.spec.ts
@@ -1,6 +1,17 @@
 import type { Stats } from 'fs';
 import path from 'path';
 
+// The adapter reaches `electron` through the platform util for packaged
+// paths only; mocking it keeps this suite independent of the Electron binary
+// being present (a CI runner can restore node_modules without it).
+jest.mock('electron', () => ({
+    app: {
+        isPackaged: false,
+        getAppPath: () => '/mock/app',
+        getPath: () => '/mock/user-data',
+    },
+}));
+
 const spawnMock = jest.fn();
 jest.mock('child_process', () => ({
     spawn: (...args: unknown[]) => spawnMock(...args),
@@ -98,7 +109,8 @@ describe('EmbeddedMpvFrameCopyAdapter Linux loader environment', () => {
                 GBM_BACKENDS_PATH: '/tmp/hostile-gbm',
                 LIBGL_DRIVERS_PATH: '/tmp/hostile-dri',
                 LIBVA_DRIVERS_PATH: '/tmp/hostile-va',
-                __EGL_EXTERNAL_PLATFORM_CONFIG_DIRS: '/tmp/hostile-egl-platform',
+                __EGL_EXTERNAL_PLATFORM_CONFIG_DIRS:
+                    '/tmp/hostile-egl-platform',
                 __EGL_VENDOR_LIBRARY_DIRS: '/tmp/hostile-egl-vendor',
                 VK_LAYER_PATH: '/tmp/hostile-vulkan',
                 XDG_CONFIG_HOME: '/tmp/hostile-xdg-config-home',
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.spec.ts
index f7c87c863..6b3d12f07 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.spec.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.spec.ts
@@ -1,11 +1,23 @@
 import path from 'path';
 
+// The adapter reaches `electron` through the platform util for packaged
+// paths only; mocking it keeps this suite independent of the Electron binary
+// being present (a CI runner can restore node_modules without it).
+jest.mock('electron', () => ({
+    app: {
+        isPackaged: false,
+        getAppPath: () => '/mock/app',
+        getPath: () => '/mock/user-data',
+    },
+}));
+
 const spawnMock = jest.fn();
 jest.mock('child_process', () => ({
     spawn: (...args: unknown[]) => spawnMock(...args),
 }));
 
 import type { EmbeddedMpvFrameCopyAdapter } from './embedded-mpv-frame-copy.adapter';
+import { EmbeddedMpvSessionGoneError } from './embedded-mpv-session-errors';
 import {
     createFrameCopyAdapter,
     createFrameCopySession,
@@ -48,7 +60,9 @@ describe('EmbeddedMpvFrameCopyAdapter', () => {
             '720',
             '--volume',
             '0.8',
+            '--mpv-options-stdin',
         ]);
+        expect(child.stdin.written[0]).toBe('mpv-options\n');
     });
 
     it('caches helper snapshot events for getSessionSnapshot', () => {
@@ -93,6 +107,116 @@ describe('EmbeddedMpvFrameCopyAdapter', () => {
         );
     });
 
+    it('sends the session options as the first stdin line, never on argv', () => {
+        adapter.createSession(
+            Buffer.alloc(0),
+            { x: 0, y: 0, width: 640, height: 360 },
+            'Title',
+            0.8,
+            ['network-timeout=10', 'http-header-fields=X-Key: s%cr\tet']
+        );
+        const [, args] = spawnMock.mock.calls[0];
+        expect(args).toContain('--mpv-options-stdin');
+        expect(args.join(' ')).not.toContain('network-timeout');
+        expect(args.join(' ')).not.toContain('X-Key');
+        expect(child.stdin.written[0]).toBe(
+            'mpv-options\to000=network-timeout=10\to001=http-header-fields=X-Key: s%25cr%09et\n'
+        );
+    });
+
+    it('flips the cached snapshot to loading as soon as a load is sent', () => {
+        const sessionId = createSession();
+        child.emitStdout({
+            event: 'snapshot',
+            status: 'error',
+            error: 'connection reset',
+            positionSeconds: 0,
+            durationSeconds: null,
+            volume: 0.8,
+            streamUrl: 'http://stream',
+            audioTracks: [],
+            selectedAudioTrackId: null,
+            subtitleTracks: [],
+            selectedSubtitleTrackId: null,
+            playbackSpeed: 1,
+            aspectOverride: 'no',
+            recording: { active: false },
+        });
+        expect(adapter.getSessionSnapshot(sessionId)?.status).toBe('error');
+
+        adapter.loadPlayback(sessionId, {
+            streamUrl: 'http://stream',
+            title: 'Live',
+        });
+
+        const snapshot = adapter.getSessionSnapshot(sessionId);
+        expect(snapshot?.status).toBe('loading');
+        expect(snapshot?.error).toBeUndefined();
+        expect(snapshot?.streamUrl).toBe('http://stream');
+    });
+
+    it('refuses a load once the helper process has exited', () => {
+        const sessionId = createSession();
+        child.exitCode = 1;
+        child.emit('exit', 1, null);
+        expect(adapter.getSessionSnapshot(sessionId)?.status).toBe('error');
+
+        expect(() =>
+            adapter.loadPlayback(sessionId, {
+                streamUrl: 'http://stream',
+                title: 'Live',
+            })
+        ).toThrow(EmbeddedMpvSessionGoneError);
+        expect(adapter.getSessionSnapshot(sessionId)?.status).toBe('error');
+        expect(
+            child.stdin.written.some((line) => line.startsWith('load\t'))
+        ).toBe(false);
+    });
+
+    it('refuses a load once the helper died from a signal', () => {
+        const sessionId = createSession();
+        child.signalCode = 'SIGKILL';
+        child.emit('exit', null, 'SIGKILL');
+        expect(adapter.getSessionSnapshot(sessionId)?.status).toBe('error');
+
+        expect(() =>
+            adapter.loadPlayback(sessionId, {
+                streamUrl: 'http://stream',
+                title: 'Live',
+            })
+        ).toThrow(EmbeddedMpvSessionGoneError);
+        expect(adapter.getSessionSnapshot(sessionId)?.status).toBe('error');
+    });
+
+    it('surfaces the helper warning for a session option libmpv rejected', () => {
+        const sessionId = createSession();
+        const warn = jest
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+        try {
+            child.emitStdout({
+                event: 'log',
+                level: 'warn',
+                prefix: 'iptvnator',
+                text: 'rejected session option nonexistent-option: option not found',
+            });
+            child.emitStdout({
+                event: 'log',
+                level: 'warn',
+                prefix: 'ffmpeg/demuxer',
+                text: 'mpegts: PES packet size mismatch',
+            });
+
+            expect(warn).toHaveBeenCalledTimes(1);
+            expect(warn.mock.calls[0][0]).toContain(sessionId);
+            expect(warn.mock.calls[0][0]).toContain(
+                'rejected session option nonexistent-option'
+            );
+        } finally {
+            warn.mockRestore();
+        }
+    });
+
     it('encodes loadfile options with percent-escaping', () => {
         const sessionId = createSession();
         adapter.loadPlayback(sessionId, {
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.test-helpers.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.test-helpers.ts
index 128a612d3..2f8caf484 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.test-helpers.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.test-helpers.ts
@@ -65,6 +65,7 @@ export function fakeStat(
 
 export class FakeHelperProcess extends EventEmitter {
     exitCode: number | null = null;
+    signalCode: string | null = null;
     readonly stdout = new EventEmitter();
     readonly stderr = new EventEmitter();
     readonly stdin = {
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.ts b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.ts
index 89a7b9197..949926a84 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-frame-copy.adapter.ts
@@ -9,11 +9,13 @@ import {
 import { isFrameCopyPlatformSupported } from './embedded-mpv-frame-copy-platform.util';
 import {
     applyHelperEvent,
+    buildMpvOptionsPreamble,
     buildLoadPlaybackCommand,
     createInitialSnapshot,
     encodeProtocolValue,
 } from './embedded-mpv-frame-copy-protocol';
 import { resolveFrameCopyHelperSpawn } from './embedded-mpv-frame-copy-spawn';
+import { EmbeddedMpvSessionGoneError } from './embedded-mpv-session-errors';
 import type {
     EmbeddedMpvFrameCopyRuntimeMode,
     LinuxFrameCopyHelperLaunchFileSystem,
@@ -83,7 +85,8 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
         _windowHandle: Buffer,
         bounds: EmbeddedMpvBounds,
         _title?: string,
-        initialVolume?: number
+        initialVolume?: number,
+        extraOptions?: string[]
     ): string {
         const helperPath = this.options.resolveHelperPath();
         if (!helperPath) {
@@ -122,6 +125,13 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
             killTimers: [],
         };
         this.sessions.set(sessionId, session);
+        // The helper blocks on this line before initialising libmpv; it is
+        // the private channel for options that may carry credentials.
+        if (child.stdin.writable) {
+            child.stdin.write(
+                `${buildMpvOptionsPreamble(extraOptions ?? [])}\n`
+            );
+        }
 
         child.stdout.on('data', (chunk: Buffer) =>
             this.consumeStdout(session, chunk)
@@ -134,6 +144,7 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
         child.on('error', (error) => {
             session.snapshot.status = 'error';
             session.snapshot.error = `Helper process failed: ${error.message}`;
+            session.snapshot.errorOrigin = 'engine';
         });
         child.on('exit', (code, signal) => {
             console.log(
@@ -151,12 +162,41 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
             session.snapshot.error = `The embedded MPV helper exited unexpectedly (${
                 signal ?? code ?? 'unknown'
             }).`;
+            session.snapshot.errorOrigin = 'engine';
         });
 
         return sessionId;
     }
 
     loadPlayback(sessionId: string, playback: ResolvedPortalPlayback): void {
+        const session = this.sessions.get(sessionId);
+        if (session && !session.disposed) {
+            if (
+                session.child.exitCode !== null ||
+                session.child.signalCode !== null ||
+                !session.child.stdin.writable
+            ) {
+                // A dead helper (exit code, signal death, or a closed stdin)
+                // cannot take a load: `send()` would drop the command
+                // silently and a reconnect would wait forever on a
+                // `loading` that nothing can ever advance.
+                throw new EmbeddedMpvSessionGoneError(
+                    sessionId,
+                    'the frame-copy helper process has exited'
+                );
+            }
+            // The native addons flip to `loading` synchronously; mirror that
+            // so the reconnect coordinator always observes loading → loss
+            // for a failed attempt, even when the helper folds START_FILE
+            // and the END_FILE error into one snapshot.
+            const snapshot = {
+                ...session.snapshot,
+                status: 'loading' as const,
+            };
+            delete snapshot.error;
+            delete snapshot.errorOrigin;
+            session.snapshot = snapshot;
+        }
         this.send(sessionId, buildLoadPlaybackCommand(playback));
     }
 
@@ -197,10 +237,7 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
     }
 
     addSubtitle(sessionId: string, filePath: string): void {
-        this.send(
-            sessionId,
-            `sub-add\tpath=${encodeProtocolValue(filePath)}`
-        );
+        this.send(sessionId, `sub-add\tpath=${encodeProtocolValue(filePath)}`);
     }
 
     setSubtitleDelay(sessionId: string, seconds: number): void {
@@ -281,7 +318,11 @@ export class EmbeddedMpvFrameCopyAdapter implements NativeEmbeddedMpvAddon {
                 `Embedded MPV frame-copy session "${sessionId}" was not found.`
             );
         }
-        if (session.child.exitCode !== null || !session.child.stdin.writable) {
+        if (
+            session.child.exitCode !== null ||
+            session.child.signalCode !== null ||
+            !session.child.stdin.writable
+        ) {
             return;
         }
         session.child.stdin.write(`${line}\n`);
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-native.service.reconnect.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-native.service.reconnect.spec.ts
new file mode 100644
index 000000000..d682ff2ce
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-native.service.reconnect.spec.ts
@@ -0,0 +1,711 @@
+/**
+ * Reconnect and session-option behaviour of EmbeddedMpvNativeService. Kept
+ * apart from embedded-mpv-native.service.spec.ts, which is close to the
+ * 1200-line spec limit; the mocks mirror that file.
+ */
+import type {
+    EmbeddedMpvBounds,
+    EmbeddedMpvSession,
+    EmbeddedMpvSessionStatus,
+    ResolvedPortalPlayback,
+} from '@iptvnator/shared/interfaces';
+import {
+    existsSync,
+    mkdirSync,
+    mkdtempSync,
+    readFileSync,
+    rmSync,
+    statSync,
+    writeFileSync,
+} from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import type { EmbeddedMpvNativeService as EmbeddedMpvNativeServiceType } from './embedded-mpv-native.service';
+
+const mockSpawnSync = jest.fn();
+const mockIsFrameCopyRuntimeUsable = jest.fn<boolean, []>();
+const mockGetFrameCopyRuntimeAvailability = jest.fn();
+
+jest.mock('child_process', () => ({
+    spawnSync: mockSpawnSync,
+}));
+
+const recordingTrackerMock = {
+    onRecordingStarted: jest.fn(),
+    onRecordingStopped: jest.fn(),
+    onRecordingInterrupted: jest.fn(),
+    observeSnapshot: jest.fn(),
+};
+jest.mock('./embedded-mpv-recording-tracker', () => ({
+    embeddedMpvRecordingTracker: recordingTrackerMock,
+}));
+
+jest.mock('./embedded-mpv-frame-copy-platform.util', () => {
+    const actual = jest.requireActual(
+        './embedded-mpv-frame-copy-platform.util'
+    );
+    return {
+        ...actual,
+        getFrameCopyRuntimeAvailability: mockGetFrameCopyRuntimeAvailability,
+        isFrameCopyRuntimeUsable: mockIsFrameCopyRuntimeUsable,
+    };
+});
+
+const powerSaveBlockerMock = {
+    start: jest.fn<number, [string]>(() => 1),
+    stop: jest.fn<void, [number]>(),
+    isStarted: jest.fn<boolean, [number]>(() => true),
+};
+let userDataDir = '';
+const appMock = {
+    isPackaged: true,
+    getAppPath: () => '/mock/app.asar',
+    getPath: () => userDataDir,
+    commandLine: { getSwitchValue: jest.fn<string, [string]>(() => '') },
+};
+
+jest.mock('electron', () => ({
+    app: appMock,
+    powerSaveBlocker: powerSaveBlockerMock,
+    screen: { getDisplayMatching: jest.fn(() => ({ scaleFactor: 1 })) },
+}));
+
+const mainWindowSendMock = jest.fn();
+const mainWindowMock = {
+    isDestroyed: () => false,
+    getNativeWindowHandle: () => Buffer.alloc(8),
+    getBounds: () => ({ x: 0, y: 0, width: 1280, height: 720 }),
+    webContents: {
+        send: mainWindowSendMock,
+        on: jest.fn(),
+        getZoomFactor: () => 1,
+    },
+};
+
+jest.mock('../app', () => ({
+    __esModule: true,
+    default: {
+        get mainWindow() {
+            return mainWindowMock;
+        },
+    },
+}));
+
+interface MockSnapshot {
+    status: EmbeddedMpvSessionStatus;
+    positionSeconds: number;
+    durationSeconds: number | null;
+    volume: number;
+    streamUrl: string;
+    recording?: { active: boolean; targetPath?: string };
+    error?: string;
+    errorOrigin?: 'playback' | 'engine';
+    rejectedOptionKeys?: string[];
+}
+
+const BOUNDS: EmbeddedMpvBounds = { x: 0, y: 0, width: 100, height: 100 };
+const LIVE: ResolvedPortalPlayback = {
+    streamUrl: 'http://host/live.ts',
+    title: 'Live channel',
+    isLive: true,
+};
+const VOD: ResolvedPortalPlayback = {
+    streamUrl: 'http://host/movie.mkv',
+    title: 'Movie',
+    isLive: false,
+    startTime: 30,
+    contentInfo: {
+        playlistId: 'playlist-1',
+        contentXtreamId: 7,
+        contentType: 'vod',
+    },
+};
+
+describe('EmbeddedMpvNativeService reconnect', () => {
+    let EmbeddedMpvNativeService: typeof EmbeddedMpvNativeServiceType;
+    let service: EmbeddedMpvNativeServiceType;
+    let addon: {
+        isSupported: jest.Mock<boolean, []>;
+        createSession: jest.Mock<string, unknown[]>;
+        loadPlayback: jest.Mock<void, [string, ResolvedPortalPlayback]>;
+        getSessionSnapshot: jest.Mock<MockSnapshot | null, [string]>;
+        disposeSession: jest.Mock<void, [string]>;
+        setBounds: jest.Mock;
+        setPaused: jest.Mock;
+        seek: jest.Mock;
+        setVolume: jest.Mock;
+        setAudioTrack: jest.Mock;
+        startRecording: jest.Mock;
+        stopRecording: jest.Mock;
+        setSubtitleTrack: jest.Mock;
+        addSubtitle: jest.Mock;
+    };
+    let status: EmbeddedMpvSessionStatus;
+    let positionSeconds: number;
+    let recordingActive: boolean;
+    let errorOrigin: 'playback' | 'engine' | undefined;
+    let rejectedOptionKeys: string[] | undefined;
+    let originalPlatform: NodeJS.Platform;
+    let originalArch: string;
+    let originalExperiment: string | undefined;
+
+    beforeEach(async () => {
+        jest.resetModules();
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2026-09-03T10:00:00Z'));
+        mainWindowSendMock.mockReset();
+        mockSpawnSync.mockReset();
+        mockSpawnSync.mockReturnValue({ status: 0 });
+        mockIsFrameCopyRuntimeUsable.mockReset();
+        mockIsFrameCopyRuntimeUsable.mockReturnValue(false);
+        mockGetFrameCopyRuntimeAvailability.mockReset();
+        mockGetFrameCopyRuntimeAvailability.mockReturnValue({
+            usable: false,
+            reason: 'helper-probe-failed',
+        });
+        originalPlatform = process.platform;
+        originalArch = process.arch;
+        Object.defineProperty(process, 'platform', { value: 'darwin' });
+        Object.defineProperty(process, 'arch', { value: 'arm64' });
+        originalExperiment =
+            process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_EXPERIMENT;
+        process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_EXPERIMENT = '1';
+        userDataDir = mkdtempSync(
+            path.join(tmpdir(), 'iptvnator-mpv-options-')
+        );
+
+        ({ EmbeddedMpvNativeService } =
+            await import('./embedded-mpv-native.service'));
+        service = new EmbeddedMpvNativeService();
+        status = 'idle';
+        positionSeconds = 0;
+        recordingActive = false;
+        errorOrigin = undefined;
+        rejectedOptionKeys = undefined;
+        recordingTrackerMock.onRecordingStarted.mockReset();
+        recordingTrackerMock.onRecordingStopped.mockReset();
+        recordingTrackerMock.onRecordingInterrupted.mockReset();
+        recordingTrackerMock.observeSnapshot.mockReset();
+        addon = {
+            isSupported: jest.fn<boolean, []>(() => true),
+            createSession: jest.fn<string, unknown[]>(() => 'session-1'),
+            loadPlayback: jest.fn(),
+            getSessionSnapshot: jest.fn<MockSnapshot | null, [string]>(() => ({
+                status,
+                positionSeconds,
+                durationSeconds: null,
+                volume: 1,
+                streamUrl: LIVE.streamUrl,
+                recording: { active: recordingActive },
+                ...(errorOrigin ? { errorOrigin } : {}),
+                ...(rejectedOptionKeys ? { rejectedOptionKeys } : {}),
+            })),
+            disposeSession: jest.fn(),
+            setBounds: jest.fn(),
+            setPaused: jest.fn(),
+            seek: jest.fn(),
+            setVolume: jest.fn(),
+            setAudioTrack: jest.fn(),
+            startRecording: jest.fn(),
+            stopRecording: jest.fn(),
+            setSubtitleTrack: jest.fn(),
+            addSubtitle: jest.fn(),
+        };
+        (service as unknown as { addon: typeof addon }).addon = addon;
+    });
+
+    afterEach(() => {
+        service.shutdown();
+        jest.useRealTimers();
+        rmSync(userDataDir, { recursive: true, force: true });
+        Object.defineProperty(process, 'platform', { value: originalPlatform });
+        Object.defineProperty(process, 'arch', { value: originalArch });
+        if (originalExperiment === undefined) {
+            delete process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_EXPERIMENT;
+        } else {
+            process.env.IPTVNATOR_ENABLE_EMBEDDED_MPV_EXPERIMENT =
+                originalExperiment;
+        }
+    });
+
+    /** Lets the 500 ms poll observe the addon status once. */
+    const poll = (next: EmbeddedMpvSessionStatus) => {
+        status = next;
+        jest.advanceTimersByTime(500);
+    };
+
+    const lastUpdate = (): EmbeddedMpvSession | undefined =>
+        mainWindowSendMock.mock.calls.at(-1)?.[1] as
+            EmbeddedMpvSession | undefined;
+
+    const startPlayingLive = (autoReconnect = true) => {
+        service.createSession(BOUNDS, 'Title', 0.5, {
+            extraOptions: ['network-timeout=10'],
+            autoReconnect,
+        });
+        service.loadPlayback('session-1', LIVE);
+        poll('loading');
+        poll('playing');
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+    };
+
+    it('hands the session options to the addon', () => {
+        service.createSession(BOUNDS, 'Title', 0.5, {
+            extraOptions: ['network-timeout=10', 'hwdec=no'],
+            autoReconnect: true,
+        });
+
+        expect(addon.createSession).toHaveBeenCalledWith(
+            expect.any(Buffer),
+            expect.objectContaining({ width: 100, height: 100 }),
+            'Title',
+            0.5,
+            ['network-timeout=10', 'hwdec=no']
+        );
+    });
+
+    it('hands Linux native-view its options through a user-only include file', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        Object.defineProperty(process, 'arch', { value: 'x64' });
+
+        service.createSession(BOUNDS, 'Title', 0.5, {
+            extraOptions: [
+                'network-timeout=10',
+                'http-header-fields=X-Key: secret',
+            ],
+            autoReconnect: true,
+        });
+
+        const addonOptions = addon.createSession.mock.calls[0][4] as string[];
+        expect(addonOptions).toHaveLength(1);
+        expect(addonOptions[0]).toMatch(/^include=.*session-options-.*\.conf$/);
+        const file = addonOptions[0].slice('include='.length);
+        expect(path.dirname(file)).toBe(
+            path.join(userDataDir, 'embedded-mpv', `options-${process.pid}`)
+        );
+        expect(readFileSync(file, 'utf8')).toBe(
+            'network-timeout=10\nhttp-header-fields=X-Key: secret\n'
+        );
+        expect(statSync(file).mode & 0o777).toBe(0o600);
+
+        service.disposeSession('session-1');
+        expect(existsSync(file)).toBe(false);
+    });
+
+    it('sweeps only option directories whose owning process is gone', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        Object.defineProperty(process, 'arch', { value: 'x64' });
+        const root = path.join(userDataDir, 'embedded-mpv');
+        const staleDir = path.join(root, 'options-2147483646');
+        const liveDir = path.join(root, `options-${process.ppid}`);
+        mkdirSync(staleDir, { recursive: true });
+        mkdirSync(liveDir, { recursive: true });
+        writeFileSync(path.join(staleDir, 'session-options-old.conf'), 'x=1\n');
+        writeFileSync(path.join(liveDir, 'session-options-live.conf'), 'y=1\n');
+
+        service.createSession(BOUNDS, 'Title', 0.5, {
+            extraOptions: ['network-timeout=10'],
+            autoReconnect: true,
+        });
+
+        expect(existsSync(staleDir)).toBe(false);
+        expect(
+            existsSync(path.join(liveDir, 'session-options-live.conf'))
+        ).toBe(true);
+        const ownDir = path.join(root, `options-${process.pid}`);
+        expect(existsSync(ownDir)).toBe(true);
+
+        service.shutdown();
+        expect(existsSync(ownDir)).toBe(false);
+    });
+
+    it('restarts a recording that was running when the stream dropped', () => {
+        startPlayingLive();
+        service.startRecording('session-1', { title: 'Live channel' });
+        expect(addon.startRecording).toHaveBeenCalledTimes(1);
+        const firstTarget = addon.startRecording.mock.calls[0][1] as string;
+        recordingActive = true;
+        poll('playing');
+
+        recordingActive = false;
+        poll('error');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).not.toHaveBeenCalled();
+
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).toHaveBeenCalledWith('session-1');
+        poll('playing');
+        // The restart is deferred with a 0 ms timer scheduled from inside
+        // the poll tick, which the fake clock parks one millisecond out.
+        jest.advanceTimersByTime(1);
+
+        expect(addon.startRecording).toHaveBeenCalledTimes(2);
+        const secondTarget = addon.startRecording.mock.calls[1][1] as string;
+        expect(secondTarget).not.toBe(firstTarget);
+        expect(path.dirname(secondTarget)).toBe(path.dirname(firstTarget));
+        expect(recordingTrackerMock.onRecordingStarted).toHaveBeenCalledTimes(
+            2
+        );
+    });
+
+    it('sees a recording that became active only in the loss snapshot', () => {
+        startPlayingLive();
+        // Recording starts asynchronously: the immediate refresh after
+        // startRecording() still reports it inactive.
+        service.startRecording('session-1', { title: 'Live channel' });
+        expect(lastUpdate()?.recording?.active).toBeFalsy();
+
+        // The next poll carries the activated recording and the drop together.
+        recordingActive = true;
+        poll('error');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+
+        status = 'loading';
+        recordingActive = false;
+        jest.advanceTimersByTime(2_000);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).toHaveBeenCalledWith('session-1');
+        poll('playing');
+        jest.advanceTimersByTime(1);
+
+        expect(addon.startRecording).toHaveBeenCalledTimes(2);
+    });
+
+    it('captures a recording acknowledged one poll after the drop', () => {
+        startPlayingLive();
+        service.startRecording('session-1', { title: 'Live channel' });
+
+        // First loss poll: the drop arrives before the recording is
+        // acknowledged; the next poll still reports the error, now with
+        // the recording active.
+        poll('error');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+        recordingActive = true;
+        poll('error');
+
+        status = 'loading';
+        recordingActive = false;
+        jest.advanceTimersByTime(2_000);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).toHaveBeenCalledWith('session-1');
+        poll('playing');
+        jest.advanceTimersByTime(1);
+
+        expect(addon.startRecording).toHaveBeenCalledTimes(2);
+    });
+
+    it('warns once, by key only, when libmpv rejected a session option', () => {
+        const warn = jest
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+        try {
+            rejectedOptionKeys = ['http-header-fields', 'no-such-option'];
+            startPlayingLive();
+            poll('playing');
+            poll('playing');
+
+            const rejectedWarnings = warn.mock.calls.filter((call) =>
+                String(call[0]).includes('rejected extra option')
+            );
+            expect(rejectedWarnings).toHaveLength(1);
+            expect(rejectedWarnings[0][0]).toContain(
+                'http-header-fields, no-such-option'
+            );
+            expect(rejectedWarnings[0][0]).toContain('session-1');
+        } finally {
+            warn.mockRestore();
+        }
+    });
+
+    describe('external subtitles', () => {
+        let subtitleFile: string;
+
+        beforeEach(() => {
+            subtitleFile = path.join(userDataDir, 'movie.srt');
+            writeFileSync(
+                subtitleFile,
+                '1\n00:00:01,000 --> 00:00:02,000\nHi\n'
+            );
+        });
+
+        function dropAndReload(): void {
+            poll('error');
+            expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+            status = 'loading';
+            jest.advanceTimersByTime(2_000);
+            poll('playing');
+            jest.advanceTimersByTime(1);
+        }
+
+        it('re-adds the external subtitle file once the automatic reload plays', () => {
+            startPlayingLive();
+            service.addSubtitle('session-1', subtitleFile);
+            poll('playing');
+
+            dropAndReload();
+
+            expect(addon.addSubtitle).toHaveBeenCalledTimes(2);
+            expect(addon.addSubtitle).toHaveBeenLastCalledWith(
+                'session-1',
+                subtitleFile
+            );
+        });
+
+        it('does not re-select a file the user had switched away from', () => {
+            startPlayingLive();
+            service.addSubtitle('session-1', subtitleFile);
+            service.setSubtitleTrack('session-1', 1);
+            poll('playing');
+
+            dropAndReload();
+
+            expect(addon.addSubtitle).toHaveBeenCalledTimes(1);
+        });
+
+        it('forgets the file after a user-driven load', () => {
+            startPlayingLive();
+            service.addSubtitle('session-1', subtitleFile);
+            service.loadPlayback('session-1', LIVE);
+            poll('playing');
+
+            dropAndReload();
+
+            expect(addon.addSubtitle).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    it('files the interruption once even when the first reload attempt fails', () => {
+        startPlayingLive();
+        service.startRecording('session-1', { title: 'Live channel' });
+        recordingActive = true;
+        poll('playing');
+
+        recordingActive = false;
+        poll('error');
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+        poll('error');
+        jest.advanceTimersByTime(4_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(3);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).toHaveBeenCalledTimes(1);
+    });
+
+    it('leaves a recording alone when the stream recovers before the reload fires', () => {
+        startPlayingLive();
+        service.startRecording('session-1', { title: 'Live channel' });
+        recordingActive = true;
+        poll('playing');
+
+        poll('error');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+        // ffmpeg's own reconnect brings the stream back within the backoff;
+        // mpv never stopped recording.
+        poll('playing');
+        jest.advanceTimersByTime(60_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+        expect(addon.startRecording).toHaveBeenCalledTimes(1);
+        expect(
+            recordingTrackerMock.onRecordingInterrupted
+        ).not.toHaveBeenCalled();
+    });
+
+    it('does not restart a recording the user had stopped or replaced', () => {
+        startPlayingLive();
+        service.startRecording('session-1', { title: 'Live channel' });
+        recordingActive = true;
+        poll('playing');
+        service.stopRecording('session-1');
+        recordingActive = false;
+        poll('playing');
+
+        poll('error');
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+        poll('playing');
+        // The restart is deferred with a 0 ms timer scheduled from inside
+        // the poll tick, which the fake clock parks one millisecond out.
+        jest.advanceTimersByTime(1);
+
+        expect(addon.startRecording).toHaveBeenCalledTimes(1);
+    });
+
+    it('sends an empty option list when no options were captured', () => {
+        service.createSession(BOUNDS);
+
+        expect(addon.createSession.mock.calls[0][4]).toEqual([]);
+    });
+
+    it('reloads a dropped live stream, tells the renderer, and clears once it plays again', () => {
+        startPlayingLive();
+
+        poll('error');
+
+        expect(lastUpdate()?.status).toBe('error');
+        expect(lastUpdate()?.reconnect).toEqual({
+            attempt: 1,
+            maxAttempts: 6,
+            nextAttemptAt: new Date(Date.now() + 2_000).toISOString(),
+        });
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(2);
+        expect(addon.loadPlayback).toHaveBeenLastCalledWith('session-1', LIVE);
+        // keep-open leaves mpv paused after EOF; the reload must clear it.
+        expect(addon.setPaused).toHaveBeenCalledWith('session-1', false);
+        expect(lastUpdate()?.status).toBe('loading');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+
+        poll('playing');
+
+        expect(lastUpdate()?.status).toBe('playing');
+        expect(lastUpdate()?.reconnect).toBeUndefined();
+    });
+
+    it('reloads a dropped movie from the position it reached', () => {
+        service.createSession(BOUNDS, 'Title', 0.5, {
+            extraOptions: [],
+            autoReconnect: true,
+        });
+        service.loadPlayback('session-1', VOD);
+        poll('loading');
+        positionSeconds = 640;
+        poll('playing');
+        poll('playing');
+
+        poll('error');
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+
+        expect(addon.loadPlayback).toHaveBeenLastCalledWith('session-1', {
+            ...VOD,
+            startTime: 640,
+        });
+    });
+
+    it('treats EOF on a live stream as a drop', () => {
+        startPlayingLive();
+
+        poll('ended');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+
+        status = 'loading';
+        jest.advanceTimersByTime(2_000);
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(2);
+    });
+
+    it('leaves an error the engine attributes to itself alone', () => {
+        startPlayingLive();
+
+        errorOrigin = 'engine';
+        poll('error');
+        jest.advanceTimersByTime(120_000);
+
+        expect(lastUpdate()?.status).toBe('error');
+        expect(lastUpdate()?.reconnect).toBeUndefined();
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+    });
+
+    it('stays quiet when the setting is off', () => {
+        startPlayingLive(false);
+
+        poll('error');
+        jest.advanceTimersByTime(120_000);
+
+        expect(lastUpdate()?.reconnect).toBeUndefined();
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+    });
+
+    it('drops the pending reload when the user loads something else', () => {
+        startPlayingLive();
+        poll('error');
+
+        const next: ResolvedPortalPlayback = {
+            ...LIVE,
+            streamUrl: 'http://host/other.ts',
+        };
+        status = 'loading';
+        service.loadPlayback('session-1', next);
+        jest.advanceTimersByTime(60_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(2);
+        expect(addon.loadPlayback).toHaveBeenLastCalledWith('session-1', next);
+    });
+
+    it('drops the pending reload when the user pauses from the error state', () => {
+        startPlayingLive();
+        poll('error');
+        expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+
+        service.setPaused('session-1', true);
+        expect(addon.setPaused).toHaveBeenCalledWith('session-1', true);
+        expect(lastUpdate()?.reconnect).toBeUndefined();
+        jest.advanceTimersByTime(60_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+    });
+
+    it('drops the pending reload when the session is disposed', () => {
+        startPlayingLive();
+        poll('error');
+
+        service.disposeSession('session-1');
+        jest.advanceTimersByTime(60_000);
+
+        expect(addon.loadPlayback).toHaveBeenCalledTimes(1);
+    });
+
+    it('still counts the attempt when only the unpause fails', () => {
+        startPlayingLive();
+        poll('error');
+        addon.setPaused.mockImplementationOnce(() => {
+            throw new Error('socket not ready');
+        });
+        const warn = jest
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+
+        try {
+            status = 'loading';
+            jest.advanceTimersByTime(2_000);
+
+            expect(addon.loadPlayback).toHaveBeenCalledTimes(2);
+            expect(lastUpdate()?.reconnect?.attempt).toBe(1);
+            poll('playing');
+            expect(lastUpdate()?.reconnect).toBeUndefined();
+        } finally {
+            warn.mockRestore();
+        }
+    });
+
+    it('keeps the main process alive when a reload attempt throws', () => {
+        startPlayingLive();
+        poll('error');
+        addon.loadPlayback.mockImplementationOnce(() => {
+            throw new Error('addon exploded');
+        });
+        const warn = jest
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+
+        try {
+            expect(() => jest.advanceTimersByTime(2_000)).not.toThrow();
+            expect(lastUpdate()?.reconnect?.attempt).toBe(2);
+        } finally {
+            warn.mockRestore();
+        }
+    });
+});
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 e4ff507d4..386246dbd 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
@@ -444,7 +444,8 @@ describe('EmbeddedMpvNativeService power blocker', () => {
                 Buffer.alloc(0),
                 BOUNDS,
                 '',
-                1
+                1,
+                []
             );
 
             // Dispose while the frame-copy env is still set so teardown
@@ -478,7 +479,8 @@ describe('EmbeddedMpvNativeService power blocker', () => {
                 expect.any(Buffer),
                 physicalBounds,
                 '',
-                1
+                1,
+                []
             );
             expect(addon.setBounds).toHaveBeenCalledWith(
                 's-scaled',
@@ -495,13 +497,18 @@ describe('EmbeddedMpvNativeService power blocker', () => {
             addon.createSession.mockReturnValueOnce('s-zoom');
             addon.getSessionSnapshot.mockReturnValue(snapshot('loading'));
 
-            service.createSession({ x: 0, y: 0, width: 100, height: 100 }, '', 1);
+            service.createSession(
+                { x: 0, y: 0, width: 100, height: 100 },
+                '',
+                1
+            );
 
             expect(addon.createSession).toHaveBeenCalledWith(
                 expect.any(Buffer),
                 { x: 0, y: 0, width: 125, height: 125 },
                 '',
-                1
+                1,
+                []
             );
         });
 
@@ -532,7 +539,8 @@ describe('EmbeddedMpvNativeService power blocker', () => {
                 Buffer.alloc(0),
                 BOUNDS,
                 '',
-                1
+                1,
+                []
             );
             expect(frameCopyAddon.setBounds).toHaveBeenCalledWith(
                 's-fc-bounds',
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 3618ebd55..4f39ba1a2 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
@@ -30,8 +30,23 @@ import {
     clampSubtitleDelay,
     normalizeSubtitleStyle,
 } from '@iptvnator/shared/interfaces';
+import { isExternalPlayerTraceEnabled, trace } from './debug-trace';
 import { toNativeViewBounds } from './embedded-mpv-bounds.util';
 import { embeddedMpvRecordingTracker } from './embedded-mpv-recording-tracker';
+import {
+    createEmbeddedMpvReconnectState,
+    EmbeddedMpvReconnectCoordinator,
+    EmbeddedMpvReconnectState,
+} from './embedded-mpv-reconnect';
+import type { EmbeddedMpvSessionOptions } from './embedded-mpv-session-options';
+import {
+    removeSessionOptionsDirectory,
+    removeSessionOptionsFile,
+    resolveSessionOptionsDirectory,
+    resolveSessionOptionsRoot,
+    sweepSessionOptionsFiles,
+    writeSessionOptionsFile,
+} from './embedded-mpv-session-options-file';
 import { EmbeddedMpvFrameCopyAdapter } from './embedded-mpv-frame-copy.adapter';
 import {
     getFrameCopyRuntimeAvailability,
@@ -61,6 +76,17 @@ export interface NativeEmbeddedMpvSessionSnapshot {
     videoHeight?: number;
     recording?: EmbeddedMpvRecordingState;
     error?: string;
+    /**
+     * `engine` when the error is the engine's own failure (a render context
+     * or a fatal libmpv log) rather than the stream's; absent means the
+     * stream failed and a reload can help.
+     */
+    errorOrigin?: 'playback' | 'engine';
+    /**
+     * Session option keys libmpv refused at creation (macOS/Windows
+     * native-view). Names only; the service warns once per session.
+     */
+    rejectedOptionKeys?: string[];
 }
 
 export interface NativeEmbeddedMpvAddon {
@@ -69,7 +95,9 @@ export interface NativeEmbeddedMpvAddon {
         windowHandle: Buffer,
         bounds: EmbeddedMpvBounds,
         title?: string,
-        initialVolume?: number
+        initialVolume?: number,
+        /** `key=value` libmpv options applied after the engine's built-ins. */
+        extraOptions?: string[]
     ): string;
     loadPlayback(sessionId: string, playback: ResolvedPortalPlayback): void;
     setBounds(sessionId: string, bounds: EmbeddedMpvBounds): void;
@@ -105,6 +133,27 @@ interface EmbeddedMpvRuntimeSession {
     updatedAt: string;
     lastPayloadKey: string;
     lastStatus: EmbeddedMpvSessionStatus | null;
+    reconnect: EmbeddedMpvReconnectState;
+    /** Linux native-view only: the `--include` file carrying the options. */
+    optionsFile: string | null;
+    /** What `startRecording` was last asked for, until an explicit stop. */
+    lastRecordingStart: EmbeddedMpvRecordingStartOptions | null;
+    /** Whether the previous refresh reported an active recording. */
+    lastRecordingActive: boolean;
+    /** A recording was running when the outage began. */
+    recordingRunningAtLoss: boolean;
+    /** The reload replaced the recorded stream; restart the recording once it plays. */
+    restartRecordingAfterReconnect: boolean;
+    /** The rejected-options warning was logged for this session. */
+    rejectedOptionsReported: boolean;
+    /**
+     * External subtitle file added through `addSubtitle` and still the
+     * track that add selected: an explicit track pick or a user-driven load
+     * hands selection back to the user and clears it.
+     */
+    externalSubtitlePath: string | null;
+    /** The automatic reload dropped the external subtitle; re-add it once the reload plays. */
+    restoreSubtitleAfterReconnect: boolean;
 }
 
 const EMBEDDED_MPV_FRAME_COPY_ENV = 'IPTVNATOR_ENABLE_EMBEDDED_MPV_FRAME_COPY';
@@ -124,6 +173,59 @@ export class EmbeddedMpvNativeService {
     private readonly loadAddonModule = createRequire(__filename);
     private cachedLinuxMpvExecutableReason: string | null | undefined;
     private frameCopyAdapter: EmbeddedMpvFrameCopyAdapter | null = null;
+    private sessionOptionsDirectory: string | null = null;
+    /**
+     * Reloads a dropped stream (see embedded-mpv-reconnect.ts). `publish`
+     * runs from a timer, outside the polling try/catch, so it must swallow
+     * addon failures itself instead of surfacing an uncaughtException.
+     */
+    private readonly reconnect = new EmbeddedMpvReconnectCoordinator({
+        reload: (sessionId, playback) => {
+            const addon = this.getAddon();
+            const session = this.sessions.get(sessionId);
+            if (session?.recordingRunningAtLoss && session.lastRecordingStart) {
+                // This reload replaces the recorded stream: the file mpv was
+                // writing is over (file it as interrupted, not completed),
+                // and the recording is started again once the reload plays.
+                // A stream that recovers by itself before this fires keeps
+                // its recording running and never reaches this branch.
+                embeddedMpvRecordingTracker.onRecordingInterrupted(sessionId);
+                session.restartRecordingAfterReconnect = true;
+                // Consumed: a failed attempt's next reload must not re-arm
+                // the tracker's flush window and postpone the verdict.
+                session.recordingRunningAtLoss = false;
+            }
+            if (session?.externalSubtitlePath) {
+                // The engines drop external subtitle tracks with the file
+                // they were added to (START_FILE clears them); re-add the
+                // user's file once the reload plays.
+                session.restoreSubtitleAfterReconnect = true;
+            }
+            addon.loadPlayback(sessionId, playback);
+            // Sessions run with keep-open=yes, so EOF on a live stream leaves
+            // mpv paused at the end of the old file and a plain loadfile
+            // inherits that pause: the reload then buffers, reports
+            // `paused` and never plays. Unpausing is part of the reload.
+            try {
+                addon.setPaused(sessionId, false);
+            } catch (error) {
+                console.warn(
+                    `[Embedded MPV][reconnect] session ${sessionId}: could not clear the keep-open pause after the reload:`,
+                    error
+                );
+            }
+        },
+        publish: (sessionId) => {
+            try {
+                this.refreshSession(sessionId);
+            } catch (error) {
+                console.error(
+                    `[Embedded MPV][reconnect] Refreshing session "${sessionId}" failed:`,
+                    error
+                );
+            }
+        },
+    });
 
     /**
      * Frame-copy engine: helper process + shm ring + renderer canvas.
@@ -459,7 +561,8 @@ export class EmbeddedMpvNativeService {
     createSession(
         bounds: EmbeddedMpvBounds,
         title = '',
-        initialVolume = 1
+        initialVolume = 1,
+        options?: EmbeddedMpvSessionOptions
     ): EmbeddedMpvSession {
         this.assertEmbeddedMpvEnabled();
         const addon = this.getAddon();
@@ -475,12 +578,25 @@ export class EmbeddedMpvNativeService {
             ? Buffer.alloc(0)
             : this.getMainWindowHandle();
         const startedAt = new Date().toISOString();
-        const sessionId = addon.createSession(
-            windowHandle,
-            usesFrameCopyAddon ? bounds : this.scaleBoundsForNativeView(bounds),
-            title,
-            initialVolume
+        const { addonOptions, optionsFile } = this.prepareSessionOptions(
+            options?.extraOptions ?? [],
+            usesFrameCopyAddon
         );
+        let sessionId: string;
+        try {
+            sessionId = addon.createSession(
+                windowHandle,
+                usesFrameCopyAddon
+                    ? bounds
+                    : this.scaleBoundsForNativeView(bounds),
+                title,
+                initialVolume,
+                addonOptions
+            );
+        } catch (error) {
+            removeSessionOptionsFile(optionsFile);
+            throw error;
+        }
 
         this.sessions.set(sessionId, {
             id: sessionId,
@@ -490,6 +606,17 @@ export class EmbeddedMpvNativeService {
             updatedAt: startedAt,
             lastPayloadKey: '',
             lastStatus: null,
+            reconnect: createEmbeddedMpvReconnectState(
+                options?.autoReconnect ?? true
+            ),
+            optionsFile,
+            lastRecordingStart: null,
+            lastRecordingActive: false,
+            recordingRunningAtLoss: false,
+            restartRecordingAfterReconnect: false,
+            rejectedOptionsReported: false,
+            externalSubtitlePath: null,
+            restoreSubtitleAfterReconnect: false,
         });
 
         this.ensurePolling();
@@ -523,6 +650,15 @@ export class EmbeddedMpvNativeService {
         session.title = playback.title ?? session.title;
         session.streamUrl = playback.streamUrl ?? session.streamUrl;
         session.updatedAt = new Date().toISOString();
+        this.reconnect.onUserLoad(session.reconnect, playback);
+        // A user-driven replacement stops an active recording by design
+        // (see "Live Stream Recording"); only an automatic reload restarts it.
+        session.lastRecordingStart = null;
+        session.recordingRunningAtLoss = false;
+        session.restartRecordingAfterReconnect = false;
+        // External subtitles are source-scoped: a user-driven load drops them.
+        session.externalSubtitlePath = null;
+        session.restoreSubtitleAfterReconnect = false;
         addon.loadPlayback(sessionId, playback);
         this.refreshSession(sessionId);
     }
@@ -540,6 +676,15 @@ export class EmbeddedMpvNativeService {
 
     setPaused(sessionId: string, paused: boolean): EmbeddedMpvSession | null {
         this.assertEmbeddedMpvEnabled();
+        if (paused) {
+            // A pause sent while the session sits in a loss state never
+            // surfaces as a `paused` status, so the command itself has to
+            // call off a scheduled reload (see embedded-mpv-reconnect.ts).
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                this.reconnect.onUserPause(session.reconnect);
+            }
+        }
         this.getAddon().setPaused(sessionId, paused);
         return this.refreshSession(sessionId);
     }
@@ -602,10 +747,20 @@ export class EmbeddedMpvNativeService {
             );
         }
         addon.setSubtitleTrack(sessionId, trackId);
+        // An explicit pick after an external file was added hands the
+        // selection back to the user: nothing is re-selected for them later.
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.externalSubtitlePath = null;
+            session.restoreSubtitleAfterReconnect = false;
+        }
         return this.refreshSession(sessionId);
     }
 
-    addSubtitle(sessionId: string, filePath: string): EmbeddedMpvSession | null {
+    addSubtitle(
+        sessionId: string,
+        filePath: string
+    ): EmbeddedMpvSession | null {
         this.assertEmbeddedMpvEnabled();
         const addon = this.getAddon();
         if (typeof addon.addSubtitle !== 'function') {
@@ -618,6 +773,10 @@ export class EmbeddedMpvNativeService {
             throw new Error('The selected subtitle file was not found.');
         }
         addon.addSubtitle(sessionId, normalized);
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.externalSubtitlePath = normalized;
+        }
         return this.refreshSession(sessionId);
     }
 
@@ -738,6 +897,7 @@ export class EmbeddedMpvNativeService {
             fallbackChannelName,
             metadata: options.metadata,
         });
+        session.lastRecordingStart = { ...options };
         return this.refreshSession(sessionId);
     }
 
@@ -751,9 +911,39 @@ export class EmbeddedMpvNativeService {
         }
         addon.stopRecording(sessionId);
         embeddedMpvRecordingTracker.onRecordingStopped(sessionId);
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastRecordingStart = null;
+            session.recordingRunningAtLoss = false;
+            session.restartRecordingAfterReconnect = false;
+        }
         return this.refreshSession(sessionId);
     }
 
+    /**
+     * An automatic reload replaces the stream, which stops mpv's
+     * `stream-record` and lets the tracker finalize that file as an
+     * interrupted partial. Once the reload plays, the recording the user had
+     * running is started again into a fresh file with the same folder,
+     * title and metadata, so a transient outage costs seconds, not the rest
+     * of the programme. Deferred out of `refreshSession`, which must not
+     * re-enter itself.
+     */
+    private restartRecordingAfterReconnect(sessionId: string): void {
+        const session = this.sessions.get(sessionId);
+        if (!session?.lastRecordingStart) {
+            return;
+        }
+        try {
+            this.startRecording(sessionId, session.lastRecordingStart);
+        } catch (error) {
+            console.warn(
+                `[Embedded MPV][reconnect] session ${sessionId}: could not restart the recording after the reload:`,
+                error
+            );
+        }
+    }
+
     getDefaultRecordingFolder(): string {
         return app.getPath('downloads');
     }
@@ -772,11 +962,49 @@ export class EmbeddedMpvNativeService {
         return result.filePaths[0];
     }
 
+    /**
+     * How the session options reach the engine. In-process engines take the
+     * list directly; the frame-copy adapter sends it over the helper's
+     * stdin; Linux native-view runs a separate `mpv --wid` process whose
+     * argv is world-readable, so there the list goes into a user-only
+     * config file referenced with `--include`.
+     */
+    private prepareSessionOptions(
+        extraOptions: string[],
+        usesFrameCopyAddon: boolean
+    ): { addonOptions: string[]; optionsFile: string | null } {
+        if (
+            process.platform !== 'linux' ||
+            usesFrameCopyAddon ||
+            extraOptions.length === 0
+        ) {
+            return { addonOptions: extraOptions, optionsFile: null };
+        }
+        if (this.sessionOptionsDirectory === null) {
+            const root = resolveSessionOptionsRoot(app.getPath('userData'));
+            sweepSessionOptionsFiles(root);
+            this.sessionOptionsDirectory = resolveSessionOptionsDirectory(root);
+        }
+        const optionsFile = writeSessionOptionsFile(
+            this.sessionOptionsDirectory,
+            extraOptions
+        );
+        return { addonOptions: [`include=${optionsFile}`], optionsFile };
+    }
+
     disposeSession(sessionId: string): EmbeddedMpvSession | null {
         const session = this.sessions.get(sessionId);
         if (!session) {
             return null;
         }
+        this.reconnect.cancel(session.reconnect);
+        session.lastRecordingStart = null;
+        session.recordingRunningAtLoss = false;
+        session.restartRecordingAfterReconnect = false;
+        session.externalSubtitlePath = null;
+        session.restoreSubtitleAfterReconnect = false;
+        removeSessionOptionsFile(session.optionsFile);
+        session.optionsFile = null;
 
         let lastRecording: EmbeddedMpvRecordingState | undefined;
         try {
@@ -821,6 +1049,8 @@ export class EmbeddedMpvNativeService {
     shutdown(): void {
         const sessionIds = [...this.sessions.keys()];
         sessionIds.forEach((sessionId) => this.disposeSession(sessionId));
+        removeSessionOptionsDirectory(this.sessionOptionsDirectory);
+        this.sessionOptionsDirectory = null;
         if (this.pollingTimer) {
             clearInterval(this.pollingTimer);
             this.pollingTimer = null;
@@ -911,6 +1141,62 @@ export class EmbeddedMpvNativeService {
         this.pollingTimer = null;
     }
 
+    /**
+     * Re-adds the external subtitle file an automatic reload dropped. The
+     * helper's `sub-add` selects the added track, which restores what the
+     * user saw before the drop; `sub-delay` is an mpv-global property and
+     * survives the reload on its own.
+     */
+    private restoreSubtitleAfterReconnect(sessionId: string): void {
+        const session = this.sessions.get(sessionId);
+        const filePath = session?.externalSubtitlePath;
+        if (!session || !filePath) {
+            return;
+        }
+        try {
+            const addon = this.getAddon();
+            if (typeof addon.addSubtitle !== 'function') {
+                return;
+            }
+            if (!existsSync(filePath)) {
+                session.externalSubtitlePath = null;
+                console.warn(
+                    `[Embedded MPV][reconnect] session ${sessionId}: the external subtitle file is gone; not restoring it after the reload`
+                );
+                return;
+            }
+            addon.addSubtitle(sessionId, filePath);
+        } catch (error) {
+            console.warn(
+                `[Embedded MPV][reconnect] session ${sessionId}: could not restore the external subtitle after the reload:`,
+                error
+            );
+        }
+    }
+
+    /**
+     * A syntactically valid option libmpv still refused (unknown name, bad
+     * value) is otherwise invisible outside a trace run; log the key once so
+     * the user learns the line did not apply. Keys only — a value may carry
+     * credentials (`http-header-fields`, proxies).
+     */
+    private reportRejectedOptions(
+        session: EmbeddedMpvRuntimeSession,
+        snapshot: NativeEmbeddedMpvSessionSnapshot
+    ): void {
+        if (
+            session.rejectedOptionsReported ||
+            !Array.isArray(snapshot.rejectedOptionKeys) ||
+            snapshot.rejectedOptionKeys.length === 0
+        ) {
+            return;
+        }
+        session.rejectedOptionsReported = true;
+        console.warn(
+            `[Embedded MPV] session ${session.id}: libmpv rejected extra option(s) ${snapshot.rejectedOptionKeys.join(', ')} (Settings > Playback > Embedded MPV)`
+        );
+    }
+
     private refreshSession(sessionId: string): EmbeddedMpvSession | null {
         const addon = this.getAddon();
         const session = this.sessions.get(sessionId);
@@ -922,6 +1208,7 @@ export class EmbeddedMpvNativeService {
         if (!snapshot) {
             return null;
         }
+        this.reportRejectedOptions(session, snapshot);
 
         const payload: EmbeddedMpvSession = {
             id: session.id,
@@ -969,9 +1256,78 @@ export class EmbeddedMpvNativeService {
             ...(snapshot.error ? { error: snapshot.error } : {}),
         };
 
+        const previousStatus = session.lastStatus;
         session.streamUrl = payload.streamUrl;
         session.updatedAt = payload.updatedAt;
         session.lastStatus = payload.status;
+        if (
+            previousStatus !== payload.status &&
+            isExternalPlayerTraceEnabled()
+        ) {
+            // Status transitions are the whole input of the reconnect policy;
+            // tracing them (never the URL) is what makes a "why did it not
+            // reconnect" report answerable.
+            trace(
+                'embedded-mpv',
+                `session ${sessionId} status ${previousStatus ?? 'none'} -> ${payload.status}`,
+                payload.error ? { error: payload.error } : undefined
+            );
+        }
+        const reconnect = this.reconnect.observe(
+            sessionId,
+            session.reconnect,
+            payload.status,
+            previousStatus,
+            payload.positionSeconds,
+            snapshot.errorOrigin
+        );
+        if (reconnect) {
+            payload.reconnect = reconnect;
+        }
+        if (
+            reconnect &&
+            session.lastRecordingStart &&
+            !session.restartRecordingAfterReconnect &&
+            (payload.recording?.active === true ||
+                (session.lastRecordingActive &&
+                    (previousStatus === 'playing' ||
+                        previousStatus === 'paused')))
+        ) {
+            // The outage began while a recording was running. Whether that
+            // recording is over is decided by the reload hook: only an
+            // actual reload replaces the stream and stops it. Recording
+            // starts asynchronously on Windows native-view and frame-copy,
+            // so a recording started shortly before the drop is acknowledged
+            // as active only in a later poll of the pending outage — accept
+            // it whenever the engine reports it, not just on the transition.
+            session.recordingRunningAtLoss = true;
+        } else if (
+            reconnect === null &&
+            payload.status === 'playing' &&
+            previousStatus !== 'playing'
+        ) {
+            // Back to playing: either our reload succeeded (restart the
+            // recording it stopped) or the stream recovered on its own
+            // (the recording never stopped; nothing to do).
+            const restart = session.restartRecordingAfterReconnect;
+            session.recordingRunningAtLoss = false;
+            session.restartRecordingAfterReconnect = false;
+            if (restart) {
+                setTimeout(
+                    () => this.restartRecordingAfterReconnect(sessionId),
+                    0
+                );
+            }
+            const restoreSubtitle = session.restoreSubtitleAfterReconnect;
+            session.restoreSubtitleAfterReconnect = false;
+            if (restoreSubtitle) {
+                setTimeout(
+                    () => this.restoreSubtitleAfterReconnect(sessionId),
+                    0
+                );
+            }
+        }
+        session.lastRecordingActive = payload.recording?.active === true;
         // The refresh timestamp must not participate in the diff key,
         // otherwise every poll tick looks like a change and the renderer
         // receives an IPC update every 500 ms even while paused.
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-reconnect.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-reconnect.spec.ts
new file mode 100644
index 000000000..249d65a11
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-reconnect.spec.ts
@@ -0,0 +1,414 @@
+import type { ResolvedPortalPlayback } from '@iptvnator/shared/interfaces';
+import { EmbeddedMpvSessionGoneError } from './embedded-mpv-session-errors';
+import {
+    createEmbeddedMpvReconnectState,
+    EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS,
+    EMBEDDED_MPV_RECONNECT_STABLE_PLAYBACK_MS,
+    EmbeddedMpvReconnectCoordinator,
+    EmbeddedMpvReconnectState,
+    isLiveEmbeddedMpvPlayback,
+    resolveEmbeddedMpvReconnectDelayMs,
+} from './embedded-mpv-reconnect';
+
+const LIVE: ResolvedPortalPlayback = {
+    streamUrl: 'http://host/live.ts',
+    title: 'Live channel',
+    isLive: true,
+};
+const VOD: ResolvedPortalPlayback = {
+    streamUrl: 'http://host/movie.mkv',
+    title: 'Movie',
+    isLive: false,
+    contentInfo: {
+        playlistId: 'playlist-1',
+        contentXtreamId: 7,
+        contentType: 'vod',
+    },
+};
+const SESSION = 'session-1';
+
+describe('embedded MPV reconnect policy helpers', () => {
+    it('backs off 2 s → 30 s and caps there', () => {
+        expect(
+            [0, 1, 2, 3, 4, 5].map(resolveEmbeddedMpvReconnectDelayMs)
+        ).toEqual([2_000, 4_000, 8_000, 16_000, 30_000, 30_000]);
+    });
+
+    it('treats an explicit flag, else missing content info, as live', () => {
+        expect(isLiveEmbeddedMpvPlayback(LIVE)).toBe(true);
+        expect(isLiveEmbeddedMpvPlayback(VOD)).toBe(false);
+        expect(
+            isLiveEmbeddedMpvPlayback({ streamUrl: 'http://h/x', title: 'x' })
+        ).toBe(true);
+        expect(isLiveEmbeddedMpvPlayback({ ...VOD, isLive: undefined })).toBe(
+            false
+        );
+    });
+});
+
+describe('EmbeddedMpvReconnectCoordinator', () => {
+    let reload: jest.Mock<void, [string, ResolvedPortalPlayback]>;
+    let publish: jest.Mock<void, [string]>;
+    let log: { log: jest.Mock; warn: jest.Mock };
+    let coordinator: EmbeddedMpvReconnectCoordinator;
+    let state: EmbeddedMpvReconnectState;
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2026-09-03T10:00:00Z'));
+        reload = jest.fn();
+        publish = jest.fn();
+        log = { log: jest.fn(), warn: jest.fn() };
+        coordinator = new EmbeddedMpvReconnectCoordinator({
+            reload,
+            publish,
+            log,
+        });
+        state = createEmbeddedMpvReconnectState(true);
+    });
+
+    afterEach(() => {
+        coordinator.cancel(state);
+        jest.useRealTimers();
+    });
+
+    /** A user load that reached `playing`. */
+    const startPlaying = (playback: ResolvedPortalPlayback = LIVE) => {
+        coordinator.onUserLoad(state, playback);
+        expect(coordinator.observe(SESSION, state, 'loading', null)).toBeNull();
+        expect(
+            coordinator.observe(SESSION, state, 'playing', 'loading')
+        ).toBeNull();
+    };
+
+    it('never retries a load that has not played yet', () => {
+        coordinator.onUserLoad(state, LIVE);
+        coordinator.observe(SESSION, state, 'loading', null);
+
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'loading')
+        ).toBeNull();
+        jest.advanceTimersByTime(120_000);
+
+        expect(reload).not.toHaveBeenCalled();
+        expect(state.timer).toBeNull();
+    });
+
+    it('reloads the last playback after a drop and reports the attempt', () => {
+        startPlaying();
+
+        const info = coordinator.observe(SESSION, state, 'error', 'playing');
+
+        expect(info).toEqual({
+            attempt: 1,
+            maxAttempts: EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS,
+            nextAttemptAt: new Date(Date.now() + 2_000).toISOString(),
+        });
+        expect(reload).not.toHaveBeenCalled();
+        // The poll sees the same error again: no second schedule.
+        expect(coordinator.observe(SESSION, state, 'error', 'error')).toBe(
+            info
+        );
+
+        jest.advanceTimersByTime(1_999);
+        expect(reload).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(1);
+        expect(reload).toHaveBeenCalledWith(SESSION, LIVE);
+        expect(publish).toHaveBeenCalledWith(SESSION);
+        // Still pending while the attempt is loading.
+        expect(coordinator.observe(SESSION, state, 'loading', 'error')).toEqual(
+            info
+        );
+    });
+
+    it('doubles the delay per failed attempt and gives up after the sixth', () => {
+        startPlaying();
+        const delays: number[] = [];
+        let previous: 'playing' | 'loading' = 'playing';
+
+        for (
+            let attempt = 1;
+            attempt <= EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS;
+            attempt++
+        ) {
+            const before = Date.now();
+            const info = coordinator.observe(SESSION, state, 'error', previous);
+            expect(info?.attempt).toBe(attempt);
+            delays.push(Date.parse(info?.nextAttemptAt ?? '') - before);
+            jest.advanceTimersByTime(delays[delays.length - 1]);
+            expect(reload).toHaveBeenCalledTimes(attempt);
+            coordinator.observe(SESSION, state, 'loading', 'error');
+            previous = 'loading';
+        }
+
+        expect(delays).toEqual([2_000, 4_000, 8_000, 16_000, 30_000, 30_000]);
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'loading')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+        expect(reload).toHaveBeenCalledTimes(
+            EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS
+        );
+        expect(log.warn).toHaveBeenCalledWith(
+            expect.stringContaining('giving up')
+        );
+    });
+
+    it('spends the budget across short-lived recoveries and resets it after stable playback', () => {
+        startPlaying();
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        jest.advanceTimersByTime(2_000);
+        coordinator.observe(SESSION, state, 'loading', 'error');
+        coordinator.observe(SESSION, state, 'playing', 'loading');
+
+        // Drops again after 10 s of playing: still the same outage.
+        jest.advanceTimersByTime(10_000);
+        coordinator.observe(SESSION, state, 'playing', 'playing');
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'playing')?.attempt
+        ).toBe(2);
+        jest.advanceTimersByTime(4_000);
+        coordinator.observe(SESSION, state, 'loading', 'error');
+        coordinator.observe(SESSION, state, 'playing', 'loading');
+
+        // Plays for the stable window: the next drop starts a fresh outage.
+        jest.advanceTimersByTime(EMBEDDED_MPV_RECONNECT_STABLE_PLAYBACK_MS);
+        coordinator.observe(SESSION, state, 'playing', 'playing');
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'playing')?.attempt
+        ).toBe(1);
+    });
+
+    it('treats EOF as a loss for live playback only', () => {
+        startPlaying(LIVE);
+        expect(
+            coordinator.observe(SESSION, state, 'ended', 'playing')?.attempt
+        ).toBe(1);
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenCalledWith(SESSION, LIVE);
+
+        reload.mockClear();
+        state = createEmbeddedMpvReconnectState(true);
+        startPlaying(VOD);
+        expect(
+            coordinator.observe(SESSION, state, 'ended', 'playing')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+        expect(reload).not.toHaveBeenCalled();
+    });
+
+    it('resumes a VOD reload where it dropped but keeps live at the live edge', () => {
+        startPlaying(VOD);
+        coordinator.observe(SESSION, state, 'playing', 'playing', 95);
+        coordinator.observe(SESSION, state, 'playing', 'playing', 120);
+        coordinator.observe(SESSION, state, 'error', 'playing', 0);
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenLastCalledWith(SESSION, {
+            ...VOD,
+            startTime: 120,
+        });
+
+        // A seek back to the very start is a valid resume point as well.
+        reload.mockClear();
+        state = createEmbeddedMpvReconnectState(true);
+        startPlaying(VOD);
+        coordinator.observe(SESSION, state, 'playing', 'playing', 120);
+        coordinator.observe(SESSION, state, 'playing', 'playing', 0);
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenLastCalledWith(SESSION, {
+            ...VOD,
+            startTime: 0,
+        });
+
+        // The snapshot's placeholder zero before the first time-pos must not
+        // beat the playback's own resume offset.
+        reload.mockClear();
+        state = createEmbeddedMpvReconnectState(true);
+        startPlaying({ ...VOD, startTime: 30 });
+        coordinator.observe(SESSION, state, 'playing', 'playing', 0);
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenLastCalledWith(SESSION, {
+            ...VOD,
+            startTime: 30,
+        });
+
+        reload.mockClear();
+        state = createEmbeddedMpvReconnectState(true);
+        startPlaying(LIVE);
+        coordinator.observe(SESSION, state, 'playing', 'playing', 3_600);
+        coordinator.observe(SESSION, state, 'error', 'playing', 3_600);
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenLastCalledWith(SESSION, LIVE);
+        expect(reload.mock.calls[0][1]).not.toHaveProperty('startTime');
+    });
+
+    it('counts a reload that fails before the poll ever sees it loading', () => {
+        startPlaying();
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        jest.advanceTimersByTime(2_000);
+        expect(reload).toHaveBeenCalledTimes(1);
+
+        // The engine failed the reload so fast that the poll still reads
+        // `error` on both sides of the transition.
+        const info = coordinator.observe(SESSION, state, 'error', 'error');
+
+        expect(info?.attempt).toBe(2);
+        jest.advanceTimersByTime(4_000);
+        expect(reload).toHaveBeenCalledTimes(2);
+    });
+
+    it('cancels and disarms on an explicit pause command sent from a loss state', () => {
+        startPlaying();
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'playing')?.attempt
+        ).toBe(1);
+
+        coordinator.onUserPause(state);
+
+        expect(state.pending).toBeNull();
+        expect(state.timer).toBeNull();
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'error')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+        expect(reload).not.toHaveBeenCalled();
+    });
+
+    it('leaves an error the engine attributes to itself alone', () => {
+        startPlaying();
+
+        expect(
+            coordinator.observe(
+                SESSION,
+                state,
+                'error',
+                'playing',
+                42,
+                'engine'
+            )
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+
+        expect(reload).not.toHaveBeenCalled();
+        expect(state.pending).toBeNull();
+    });
+
+    it('does not resume a stream the user paused when it drops', () => {
+        startPlaying();
+        expect(
+            coordinator.observe(SESSION, state, 'paused', 'playing')
+        ).toBeNull();
+
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'paused')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+        expect(reload).not.toHaveBeenCalled();
+
+        // Playing again re-arms the policy.
+        coordinator.observe(SESSION, state, 'loading', 'error');
+        coordinator.observe(SESSION, state, 'playing', 'loading');
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'playing')?.attempt
+        ).toBe(1);
+    });
+
+    it('drops a pending attempt when the stream recovers on its own', () => {
+        startPlaying();
+        coordinator.observe(SESSION, state, 'error', 'playing');
+
+        expect(
+            coordinator.observe(SESSION, state, 'playing', 'error')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+
+        expect(reload).not.toHaveBeenCalled();
+        expect(state.pending).toBeNull();
+    });
+
+    it('is cancelled by a new user load, a pause, and an explicit cancel', () => {
+        startPlaying();
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        coordinator.onUserLoad(state, VOD);
+        expect(state.pending).toBeNull();
+        expect(state.hadPlayed).toBe(false);
+
+        startPlaying();
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        expect(
+            coordinator.observe(SESSION, state, 'paused', 'error')
+        ).toBeNull();
+        expect(state.timer).toBeNull();
+
+        coordinator.observe(SESSION, state, 'playing', 'paused');
+        coordinator.observe(SESSION, state, 'error', 'playing');
+        coordinator.cancel(state);
+        jest.advanceTimersByTime(60_000);
+
+        expect(reload).not.toHaveBeenCalled();
+    });
+
+    it('does nothing when the setting is off', () => {
+        state = createEmbeddedMpvReconnectState(false);
+        startPlaying();
+
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'playing')
+        ).toBeNull();
+        jest.advanceTimersByTime(60_000);
+
+        expect(reload).not.toHaveBeenCalled();
+    });
+
+    it('gives up at once when the engine behind the session is gone', () => {
+        startPlaying();
+        reload.mockImplementationOnce(() => {
+            throw new EmbeddedMpvSessionGoneError(SESSION, 'helper exited');
+        });
+        coordinator.observe(SESSION, state, 'error', 'playing');
+
+        jest.advanceTimersByTime(2_000);
+
+        expect(reload).toHaveBeenCalledTimes(1);
+        expect(publish).toHaveBeenCalledTimes(1);
+        expect(state.pending).toBeNull();
+        expect(state.timer).toBeNull();
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'error')
+        ).toBeNull();
+        expect(log.warn).toHaveBeenCalledWith(
+            expect.stringContaining('engine gone'),
+            expect.any(Error)
+        );
+
+        jest.advanceTimersByTime(120_000);
+        expect(reload).toHaveBeenCalledTimes(1);
+    });
+
+    it('continues the backoff when the addon refuses the reload outright', () => {
+        startPlaying();
+        reload.mockImplementationOnce(() => {
+            throw new Error('addon exploded');
+        });
+        coordinator.observe(SESSION, state, 'error', 'playing');
+
+        jest.advanceTimersByTime(2_000);
+
+        expect(reload).toHaveBeenCalledTimes(1);
+        expect(publish).toHaveBeenCalledTimes(1);
+        expect(log.warn).toHaveBeenCalledWith(
+            expect.stringContaining('could not start'),
+            expect.any(Error)
+        );
+        expect(state.pending?.attempt).toBe(2);
+        // No status transition ever arrives for a refused load.
+        expect(
+            coordinator.observe(SESSION, state, 'error', 'error')?.attempt
+        ).toBe(2);
+
+        jest.advanceTimersByTime(4_000);
+        expect(reload).toHaveBeenCalledTimes(2);
+    });
+});
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-reconnect.ts b/apps/electron-backend/src/app/services/embedded-mpv-reconnect.ts
new file mode 100644
index 000000000..2dc888792
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-reconnect.ts
@@ -0,0 +1,352 @@
+import type {
+    EmbeddedMpvReconnectInfo,
+    EmbeddedMpvSessionStatus,
+    ResolvedPortalPlayback,
+} from '@iptvnator/shared/interfaces';
+import { isEmbeddedMpvSessionGoneError } from './embedded-mpv-session-errors';
+
+/**
+ * Automatic reconnect for embedded MPV sessions.
+ *
+ * The native engines report a dropped IPTV connection as an mpv error, or as
+ * EOF when the server simply closed the socket. Either leaves the viewer on a
+ * dead player, so the main process reloads the last user-requested playback
+ * with capped exponential backoff. The policy is deliberately narrow:
+ *
+ * - Only a load that already reached `playing` is retried. A URL that never
+ *   worked (404, refused credentials, unsupported container) keeps the manual
+ *   Retry; hammering a panel six times with the same bad request helps nobody.
+ * - EOF counts as a loss only for live playback — a broadcast never ends on
+ *   its own, a movie does.
+ * - The attempt budget belongs to one outage: it resets after
+ *   {@link EMBEDDED_MPV_RECONNECT_STABLE_PLAYBACK_MS} of uninterrupted playing,
+ *   not on the first `playing`, so a stream that flaps every few seconds runs
+ *   out of attempts instead of being retried forever.
+ * - A user-driven load, a pause, or teardown cancels everything. A pause
+ *   also disarms the policy until the stream plays again: a drop while the
+ *   user has the stream paused must not resume playback behind their back.
+ * - An attempt is tracked explicitly from the moment its reload is issued,
+ *   so a reload that fails before the poll ever sees it `loading` is still
+ *   counted as a failed attempt rather than mistaken for the original loss.
+ * - A VOD reload resumes at the last position observed while playing; a live
+ *   reload goes back to the live edge.
+ * - An `error` the engine attributes to itself (a macOS render failure, a
+ *   fatal libmpv log in the helper) is not a stream loss: reloading media
+ *   cannot repair a broken render context, so it stays a terminal error.
+ * - A reload the engine cannot take at all (a crashed frame-copy helper,
+ *   reported as `EmbeddedMpvSessionGoneError`) ends the reconnect: only a
+ *   new session can recover, and the renderer's Retry creates one.
+ *
+ * Status transitions arrive from `EmbeddedMpvNativeService.refreshSession()`
+ * (polled every 500 ms); every engine flips to `loading` synchronously on a
+ * load, so a failed attempt is always observed as `loading` → loss and never
+ * as loss → loss. The coordinator publishes {@link EmbeddedMpvReconnectInfo}
+ * for the renderer, which displays it and never schedules anything itself.
+ */
+
+export const EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS = 6;
+export const EMBEDDED_MPV_RECONNECT_BASE_DELAY_MS = 2_000;
+export const EMBEDDED_MPV_RECONNECT_MAX_DELAY_MS = 30_000;
+export const EMBEDDED_MPV_RECONNECT_STABLE_PLAYBACK_MS = 30_000;
+
+export interface EmbeddedMpvReconnectState {
+    /** `Settings.embeddedMpvAutoReconnect`, captured at session creation. */
+    enabled: boolean;
+    /** The last playback the user asked for; what every attempt reloads. */
+    playback: ResolvedPortalPlayback | null;
+    /** Whether that playback reached `playing` at least once. */
+    hadPlayed: boolean;
+    /** Attempts spent on the current outage. */
+    attempts: number;
+    /** Start of the current uninterrupted `playing` stretch. */
+    playingSince: number | null;
+    /** A reload was issued and neither `playing` nor a loss has answered it yet. */
+    attemptInFlight: boolean;
+    /**
+     * Last position reported while the stream played, seeded from the
+     * playback's own `startTime`. Non-live reloads carry it as `startTime`,
+     * otherwise mpv would restart at the playback's original resume offset.
+     */
+    lastPositionSeconds: number | null;
+    /**
+     * Whether a positive position has been reported for this load. Engine
+     * snapshots start at zero before the first `time-pos` update, so a zero
+     * is trusted as a real seek-to-start only once that has happened.
+     */
+    positionReported: boolean;
+    timer: NodeJS.Timeout | null;
+    /** What the renderer is shown while an attempt is scheduled or in flight. */
+    pending: EmbeddedMpvReconnectInfo | null;
+}
+
+export interface EmbeddedMpvReconnectHooks {
+    /** Issue the reload against the addon; may throw. */
+    reload(sessionId: string, playback: ResolvedPortalPlayback): void;
+    /** Re-read the session so the renderer sees the attempt; must not throw. */
+    publish(sessionId: string): void;
+    now?(): number;
+    log?: Pick<Console, 'log' | 'warn'>;
+}
+
+export function createEmbeddedMpvReconnectState(
+    enabled: boolean
+): EmbeddedMpvReconnectState {
+    return {
+        enabled,
+        playback: null,
+        hadPlayed: false,
+        attempts: 0,
+        playingSince: null,
+        attemptInFlight: false,
+        lastPositionSeconds: null,
+        positionReported: false,
+        timer: null,
+        pending: null,
+    };
+}
+
+/** Same rule as the renderer's `isLivePlayback`: explicit flag, else "no content info". */
+export function isLiveEmbeddedMpvPlayback(
+    playback: ResolvedPortalPlayback
+): boolean {
+    return typeof playback.isLive === 'boolean'
+        ? playback.isLive
+        : !playback.contentInfo;
+}
+
+/** 2 s, 4 s, 8 s, 16 s, 30 s, 30 s for attempts 1–6. */
+export function resolveEmbeddedMpvReconnectDelayMs(
+    completedAttempts: number
+): number {
+    return Math.min(
+        EMBEDDED_MPV_RECONNECT_BASE_DELAY_MS * 2 ** completedAttempts,
+        EMBEDDED_MPV_RECONNECT_MAX_DELAY_MS
+    );
+}
+
+export function isEmbeddedMpvStreamLoss(
+    status: EmbeddedMpvSessionStatus,
+    isLive: boolean
+): boolean {
+    return status === 'error' || (status === 'ended' && isLive);
+}
+
+export class EmbeddedMpvReconnectCoordinator {
+    private readonly now: () => number;
+    private readonly log: Pick<Console, 'log' | 'warn'>;
+
+    constructor(private readonly hooks: EmbeddedMpvReconnectHooks) {
+        this.now = hooks.now ?? (() => Date.now());
+        this.log = hooks.log ?? console;
+    }
+
+    /** The user (or the renderer on their behalf) asked for a playback. */
+    onUserLoad(
+        state: EmbeddedMpvReconnectState,
+        playback: ResolvedPortalPlayback
+    ): void {
+        this.clearTimer(state);
+        state.playback = playback;
+        state.hadPlayed = false;
+        state.attempts = 0;
+        state.playingSince = null;
+        state.attemptInFlight = false;
+        state.lastPositionSeconds =
+            typeof playback.startTime === 'number' &&
+            Number.isFinite(playback.startTime) &&
+            playback.startTime >= 0
+                ? playback.startTime
+                : null;
+        state.positionReported = false;
+        state.pending = null;
+    }
+
+    cancel(state: EmbeddedMpvReconnectState): void {
+        this.clearTimer(state);
+        state.attemptInFlight = false;
+        state.pending = null;
+    }
+
+    /**
+     * The user asked to pause. Observing `paused` cannot cover a pause sent
+     * while the session already sits in a loss state (the engines keep
+     * `error`/`ended` rather than flipping to `paused`), so the command
+     * itself cancels and disarms: a reload would resume playback unasked.
+     */
+    onUserPause(state: EmbeddedMpvReconnectState): void {
+        this.cancel(state);
+        state.hadPlayed = false;
+    }
+
+    /**
+     * Feed one observed status (and the position that came with it). Returns
+     * what the renderer should be shown (`null` when nothing is pending).
+     */
+    observe(
+        sessionId: string,
+        state: EmbeddedMpvReconnectState,
+        status: EmbeddedMpvSessionStatus,
+        previousStatus: EmbeddedMpvSessionStatus | null,
+        positionSeconds?: number,
+        errorOrigin?: 'playback' | 'engine'
+    ): EmbeddedMpvReconnectInfo | null {
+        const now = this.now();
+
+        if (status === 'error' && errorOrigin === 'engine') {
+            this.cancel(state);
+            return null;
+        }
+
+        if (
+            (status === 'playing' || status === 'paused') &&
+            typeof positionSeconds === 'number' &&
+            Number.isFinite(positionSeconds)
+        ) {
+            if (positionSeconds > 0) {
+                state.lastPositionSeconds = positionSeconds;
+                state.positionReported = true;
+            } else if (positionSeconds === 0 && state.positionReported) {
+                // A real seek back to the start. Before any positive
+                // position the zero is only the snapshot's placeholder and
+                // the seeded `startTime` stays the better resume point.
+                state.lastPositionSeconds = 0;
+            }
+        }
+
+        if (status === 'playing') {
+            state.hadPlayed = true;
+            if (state.playingSince === null) {
+                state.playingSince = now;
+            } else if (
+                state.attempts > 0 &&
+                now - state.playingSince >=
+                    EMBEDDED_MPV_RECONNECT_STABLE_PLAYBACK_MS
+            ) {
+                state.attempts = 0;
+            }
+            // Either our attempt succeeded or the stream recovered on its
+            // own (ffmpeg-level reconnect) while a retry was still pending.
+            this.cancel(state);
+            return null;
+        }
+
+        state.playingSince = null;
+
+        if (status === 'loading') {
+            // A fresh user load, or our own attempt in flight.
+            return state.pending;
+        }
+
+        const isLive =
+            state.playback !== null &&
+            isLiveEmbeddedMpvPlayback(state.playback);
+        if (!isEmbeddedMpvStreamLoss(status, isLive)) {
+            // paused/idle are user actions, closed is teardown, ended on
+            // VOD is the movie finishing — none of them is an outage.
+            if (status === 'paused') {
+                // Disarmed until the stream plays again: reloading a stream
+                // the user paused would resume it without them asking.
+                state.hadPlayed = false;
+            }
+            this.cancel(state);
+            return null;
+        }
+
+        const answersAttempt = state.attemptInFlight;
+        if (
+            (status === previousStatus && !answersAttempt) ||
+            state.timer !== null
+        ) {
+            // Same loss observed again by the poll, or already scheduled.
+            return state.pending;
+        }
+
+        state.attemptInFlight = false;
+        return this.schedule(sessionId, state, now);
+    }
+
+    private schedule(
+        sessionId: string,
+        state: EmbeddedMpvReconnectState,
+        now: number
+    ): EmbeddedMpvReconnectInfo | null {
+        if (!state.enabled || state.playback === null || !state.hadPlayed) {
+            state.pending = null;
+            return null;
+        }
+        if (state.attempts >= EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS) {
+            this.log.warn(
+                `[Embedded MPV][reconnect] session ${sessionId}: giving up after ${state.attempts} attempts`
+            );
+            state.pending = null;
+            return null;
+        }
+
+        const delay = resolveEmbeddedMpvReconnectDelayMs(state.attempts);
+        const attempt = state.attempts + 1;
+        const playback = this.playbackForReload(state.playback, state);
+        state.pending = {
+            attempt,
+            maxAttempts: EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS,
+            nextAttemptAt: new Date(now + delay).toISOString(),
+        };
+        this.log.log(
+            `[Embedded MPV][reconnect] session ${sessionId}: stream lost, attempt ${attempt}/${EMBEDDED_MPV_RECONNECT_MAX_ATTEMPTS} in ${delay} ms`
+        );
+        state.timer = setTimeout(() => {
+            state.timer = null;
+            state.attempts = attempt;
+            state.attemptInFlight = true;
+            try {
+                this.hooks.reload(sessionId, playback);
+            } catch (error) {
+                state.attemptInFlight = false;
+                if (isEmbeddedMpvSessionGoneError(error)) {
+                    // Nothing behind the session can take a load any more;
+                    // stop so the renderer shows the actionable error
+                    // instead of a reconnect spinner that never resolves.
+                    this.log.warn(
+                        `[Embedded MPV][reconnect] session ${sessionId}: engine gone, giving up`,
+                        error
+                    );
+                    state.pending = null;
+                } else {
+                    this.log.warn(
+                        `[Embedded MPV][reconnect] session ${sessionId}: attempt ${attempt} could not start`,
+                        error
+                    );
+                    // The addon refused the load outright, so no loading→loss
+                    // transition will ever arrive: continue the backoff here.
+                    this.schedule(sessionId, state, this.now());
+                }
+            }
+            this.hooks.publish(sessionId);
+        }, delay);
+        return state.pending;
+    }
+
+    /**
+     * Live streams reload at the live edge. Anything else resumes where the
+     * connection dropped: the stored playback still carries the offset the
+     * user originally resumed from, and reloading it would rewind the movie.
+     */
+    private playbackForReload(
+        playback: ResolvedPortalPlayback,
+        state: EmbeddedMpvReconnectState
+    ): ResolvedPortalPlayback {
+        if (
+            isLiveEmbeddedMpvPlayback(playback) ||
+            state.lastPositionSeconds === null
+        ) {
+            return playback;
+        }
+        return { ...playback, startTime: state.lastPositionSeconds };
+    }
+
+    private clearTimer(state: EmbeddedMpvReconnectState): void {
+        if (state.timer !== null) {
+            clearTimeout(state.timer);
+            state.timer = null;
+        }
+    }
+}
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.spec.ts b/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.spec.ts
index 253aff74f..ab02d6dcf 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.spec.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.spec.ts
@@ -511,6 +511,65 @@ describe('EmbeddedMpvRecordingTracker', () => {
         expect(db.updateSet.mock.calls[0][0].status).toBe('completed');
     });
 
+    it('finalizes a recording as interrupted when the stream drops and a reload replaces it', async () => {
+        started(tracker);
+        tracker.observeSnapshot(activeSnapshot());
+
+        jest.useFakeTimers();
+        try {
+            tracker.onRecordingInterrupted('session-1');
+            tracker.onRecordingStarted({
+                sessionId: 'session-1',
+                targetPath: '/rec/News-20260815-213500.ts',
+                fallbackChannelName: 'Channel One',
+            });
+            await jest.advanceTimersByTimeAsync(1_600);
+        } finally {
+            jest.useRealTimers();
+        }
+        await flush();
+
+        expect(db.updateSet).toHaveBeenCalledTimes(1);
+        expect(db.updateSet.mock.calls[0][0].status).toBe('interrupted');
+    });
+
+    it('keeps the interruption when the engine still shows the old recording active for a tick', async () => {
+        started(tracker);
+        tracker.observeSnapshot(activeSnapshot());
+
+        jest.useFakeTimers();
+        try {
+            tracker.onRecordingInterrupted('session-1');
+            // A clean live EOF can carry the old recording as active once more.
+            tracker.observeSnapshot(activeSnapshot());
+            tracker.observeSnapshot(inactiveSnapshot());
+            await jest.advanceTimersByTimeAsync(2_600);
+        } finally {
+            jest.useRealTimers();
+        }
+        await flush();
+
+        expect(db.updateSet).toHaveBeenCalledTimes(1);
+        expect(db.updateSet.mock.calls[0][0].status).toBe('interrupted');
+    });
+
+    it('finalizes an interrupted recording on its own when no reload follows', async () => {
+        started(tracker);
+        tracker.observeSnapshot(activeSnapshot());
+
+        jest.useFakeTimers();
+        try {
+            tracker.onRecordingInterrupted('session-1');
+            await jest.advanceTimersByTimeAsync(2_600);
+        } finally {
+            jest.useRealTimers();
+        }
+        await flush();
+
+        expect(db.updateSet).toHaveBeenCalledTimes(1);
+        expect(db.updateSet.mock.calls[0][0].status).toBe('interrupted');
+    });
+
     it('keeps a finalizing row in the ledger until its update commits', async () => {
         // finalize() removes the entry from the open map immediately, but
         // the row stays persisted as 'recording' until the queued terminal
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.ts b/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.ts
index 685654846..ea7a90a36 100644
--- a/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.ts
+++ b/apps/electron-backend/src/app/services/embedded-mpv-recording-tracker.ts
@@ -31,6 +31,8 @@ interface OpenRecordingEntry {
     stopFallbackTimer?: ReturnType<typeof setTimeout>;
     /** Armed by an inactive snapshot; finalizes once the stop looks settled. */
     settleTimer?: ReturnType<typeof setTimeout>;
+    /** The stream dropped under this recording; it must not end as `completed`. */
+    interrupted: boolean;
     /**
      * Set by the first finalize. Timers hold the entry itself, so an entry
      * replaced in the map (stop → immediate restart on the same session) can
@@ -86,9 +88,7 @@ const TEARDOWN_FLUSH_WINDOW_MS = 2_500;
 const FINALIZE_STAT_TIMEOUT_MS = 3_000;
 
 type FinalizeFileProbe =
-    | { kind: 'size'; size: number }
-    | { kind: 'missing' }
-    | { kind: 'unknown' };
+    { kind: 'size'; size: number } | { kind: 'missing' } | { kind: 'unknown' };
 
 /**
  * Persists the lifecycle of embedded-MPV live recordings into the
@@ -129,7 +129,10 @@ export class EmbeddedMpvRecordingTracker {
                 clearTimeout(replaced.settleTimer);
             }
             replaced.settleTimer = setTimeout(() => {
-                this.finalize(replaced, 'completed');
+                this.finalize(
+                    replaced,
+                    replaced.interrupted ? 'interrupted' : 'completed'
+                );
             }, STOP_SETTLE_WINDOW_MS);
         }
 
@@ -165,6 +168,7 @@ export class EmbeddedMpvRecordingTracker {
             targetPath: event.targetPath,
             startedAt,
             sawActive: false,
+            interrupted: false,
             stopRequested: false,
             finalized: false,
             rowId,
@@ -182,6 +186,27 @@ export class EmbeddedMpvRecordingTracker {
      * statting (or unlinking) the file before mpv flushed it would report a
      * short recording as failed and could delete bytes still being written.
      */
+    /**
+     * The stream carrying this recording dropped and an automatic reload is
+     * about to replace it (see embedded-mpv-reconnect.ts). The file mpv was
+     * writing is over: finalize it as `interrupted`. Without this, a clean
+     * EOF never reaches the error path above and the reload's own
+     * `onRecordingStarted` would file the partial as `completed`.
+     */
+    onRecordingInterrupted(sessionId: string): void {
+        const entry = this.open.get(sessionId);
+        if (!entry || entry.finalized) {
+            return;
+        }
+        entry.interrupted = true;
+        if (entry.settleTimer !== undefined) {
+            clearTimeout(entry.settleTimer);
+        }
+        entry.settleTimer = setTimeout(() => {
+            this.finalize(entry, 'interrupted');
+        }, TEARDOWN_FLUSH_WINDOW_MS);
+    }
+
     onRecordingStopped(sessionId: string): void {
         const entry = this.open.get(sessionId);
         if (!entry || entry.stopRequested) {
@@ -228,7 +253,10 @@ export class EmbeddedMpvRecordingTracker {
             entry.sawActive = true;
             // A rejected stop puts the recording back: abandon the pending
             // finalization instead of ending a row that is still recording.
-            if (entry.settleTimer !== undefined) {
+            // Not after an interruption, though: the engine may still show
+            // the old recording as active for a tick after a clean live EOF,
+            // and the reload replacing it is already on its way.
+            if (entry.settleTimer !== undefined && !entry.interrupted) {
                 clearTimeout(entry.settleTimer);
                 entry.settleTimer = undefined;
             }
@@ -244,7 +272,10 @@ export class EmbeddedMpvRecordingTracker {
             // Finalize only once it survived the settle window.
             if (entry.settleTimer === undefined) {
                 entry.settleTimer = setTimeout(() => {
-                    this.finalize(entry, 'completed');
+                    this.finalize(
+                        entry,
+                        entry.interrupted ? 'interrupted' : 'completed'
+                    );
                 }, STOP_SETTLE_WINDOW_MS);
             }
         } else if (recording.error) {
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-session-errors.ts b/apps/electron-backend/src/app/services/embedded-mpv-session-errors.ts
new file mode 100644
index 000000000..c2bcbb848
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-session-errors.ts
@@ -0,0 +1,20 @@
+/**
+ * Thrown by an engine adapter when a session can no longer take commands
+ * because the process behind it is gone (a crashed frame-copy helper). The
+ * reconnect coordinator treats it as terminal: only a new session can
+ * recover, so retrying the same session would just spin.
+ */
+export class EmbeddedMpvSessionGoneError extends Error {
+    constructor(sessionId: string, reason: string) {
+        super(
+            `Embedded MPV session "${sessionId}" cannot be reused: ${reason}.`
+        );
+        this.name = 'EmbeddedMpvSessionGoneError';
+    }
+}
+
+export function isEmbeddedMpvSessionGoneError(error: unknown): boolean {
+    return (
+        error instanceof Error && error.name === 'EmbeddedMpvSessionGoneError'
+    );
+}
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-session-options-file.ts b/apps/electron-backend/src/app/services/embedded-mpv-session-options-file.ts
new file mode 100644
index 000000000..f113d7ac3
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-session-options-file.ts
@@ -0,0 +1,96 @@
+import { randomUUID } from 'crypto';
+import { mkdirSync, readdirSync, rmSync, unlinkSync, writeFileSync } from 'fs';
+import path from 'path';
+
+const OPTIONS_ROOT = 'embedded-mpv';
+const INSTANCE_DIRECTORY_PREFIX = 'options-';
+const OPTIONS_FILE_PREFIX = 'session-options-';
+
+/**
+ * Linux native-view runs mpv as a separate process whose command line is
+ * readable by every local user through /proc/<pid>/cmdline, so the session
+ * options (which may carry request headers with credentials) are handed
+ * over as an mpv config file readable by the owner only and referenced with
+ * `--include=<path>`. Files live under a per-instance directory named by the
+ * owning process id: a session removes its file on dispose, the instance
+ * removes its directory on shutdown, and a crashed instance's leftovers are
+ * swept by the next one — but only once its process is gone, because two
+ * instances may share one `userData` (IPTVNATOR_ALLOW_MULTIPLE_INSTANCES=1).
+ */
+export function resolveSessionOptionsRoot(userDataPath: string): string {
+    return path.join(userDataPath, OPTIONS_ROOT);
+}
+
+export function resolveSessionOptionsDirectory(
+    root: string,
+    pid: number = process.pid
+): string {
+    return path.join(root, `${INSTANCE_DIRECTORY_PREFIX}${pid}`);
+}
+
+export function isProcessAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        // EPERM: the process exists but belongs to someone else.
+        return (error as NodeJS.ErrnoException).code === 'EPERM';
+    }
+}
+
+export function sweepSessionOptionsFiles(
+    root: string,
+    options: { ownPid?: number; isAlive?: (pid: number) => boolean } = {}
+): void {
+    const ownPid = options.ownPid ?? process.pid;
+    const isAlive = options.isAlive ?? isProcessAlive;
+    let names: string[];
+    try {
+        names = readdirSync(root);
+    } catch {
+        return;
+    }
+    for (const name of names) {
+        if (!name.startsWith(INSTANCE_DIRECTORY_PREFIX)) {
+            continue;
+        }
+        const pid = Number(name.slice(INSTANCE_DIRECTORY_PREFIX.length));
+        if (!Number.isInteger(pid) || pid === ownPid || isAlive(pid)) {
+            continue;
+        }
+        rmSync(path.join(root, name), { recursive: true, force: true });
+    }
+}
+
+export function writeSessionOptionsFile(
+    directory: string,
+    options: readonly string[]
+): string {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const file = path.join(
+        directory,
+        `${OPTIONS_FILE_PREFIX}${randomUUID()}.conf`
+    );
+    writeFileSync(file, options.map((option) => `${option}\n`).join(''), {
+        mode: 0o600,
+    });
+    return file;
+}
+
+export function removeSessionOptionsFile(file: string | null): void {
+    if (!file) {
+        return;
+    }
+    try {
+        unlinkSync(file);
+    } catch {
+        // Already gone (a swept or never-written file); nothing to keep.
+    }
+}
+
+export function removeSessionOptionsDirectory(directory: string | null): void {
+    if (!directory) {
+        return;
+    }
+    rmSync(directory, { recursive: true, force: true });
+}
diff --git a/apps/electron-backend/src/app/services/embedded-mpv-session-options.ts b/apps/electron-backend/src/app/services/embedded-mpv-session-options.ts
new file mode 100644
index 000000000..82c6fb881
--- /dev/null
+++ b/apps/electron-backend/src/app/services/embedded-mpv-session-options.ts
@@ -0,0 +1,34 @@
+import { resolveEmbeddedMpvSessionOptionArguments } from '@iptvnator/shared/interfaces';
+import {
+    EMBEDDED_MPV_AUTO_RECONNECT,
+    EMBEDDED_MPV_EXTRA_OPTIONS,
+    store,
+} from './store.service';
+
+/**
+ * Per-session knobs captured when an embedded MPV session is created. They
+ * come from the main-process settings mirror (see `store.service.ts`), so a
+ * settings change applies to the next session, never to a running one.
+ *
+ * Read here rather than inside `EmbeddedMpvNativeService`: the config store
+ * is constructed at module load and would drag electron-conf into every
+ * consumer of the service, including its unit tests.
+ */
+export interface EmbeddedMpvSessionOptions {
+    /**
+     * `key=value` lines the addon applies after its built-in options: the
+     * network defaults first, then the user's allowed lines.
+     */
+    extraOptions: string[];
+    /** Reload a dropped stream automatically (see `embedded-mpv-reconnect.ts`). */
+    autoReconnect: boolean;
+}
+
+export function readEmbeddedMpvSessionOptions(): EmbeddedMpvSessionOptions {
+    return {
+        extraOptions: resolveEmbeddedMpvSessionOptionArguments(
+            store.get(EMBEDDED_MPV_EXTRA_OPTIONS, '')
+        ),
+        autoReconnect: store.get(EMBEDDED_MPV_AUTO_RECONNECT, true) !== false,
+    };
+}
diff --git a/apps/electron-backend/src/app/services/native-fullscreen-transitions.ts b/apps/electron-backend/src/app/services/native-fullscreen-transitions.ts
new file mode 100644
index 000000000..14ffe1de7
--- /dev/null
+++ b/apps/electron-backend/src/app/services/native-fullscreen-transitions.ts
@@ -0,0 +1,139 @@
+/**
+ * Native fullscreen state and in-flight transitions, per window.
+ *
+ * `BrowserWindow.isFullScreen()` cannot drive a toggle: setFullScreen()
+ * completes asynchronously (the macOS animation, Linux window managers),
+ * and on Windows the getter can still report the pre-transition value even
+ * while the matching event fires (see attachWindowStateEvents). A toggle
+ * decided against the getter would request the same target twice — two
+ * quick F11 presses would land fullscreen instead of returning to the
+ * window, and F11 during the startup fullscreen animation would ask for
+ * fullscreen again instead of leaving it.
+ *
+ * So the tracker keeps its own notion of the window's fullscreen state: it
+ * is seeded once from the getter when tracking starts — at window creation,
+ * while no transition is in flight — and afterwards fed only by the
+ * `enter-full-screen` / `leave-full-screen` events, which also cover
+ * transitions the app did not request (macOS green button, Ctrl+Cmd+F,
+ * HTML fullscreen on Windows). Every native fullscreen request goes through
+ * `requestFullScreen`, and a toggle is decided against the pending target
+ * if one is in flight, else against that tracked state — never the getter.
+ *
+ * The tracker observes; it never issues a request on its own. The pending
+ * record is the LATEST requested target: an event landing on it clears it,
+ * an event landing on the other state (an earlier request of a burst
+ * landed first; ours is still queued) leaves it in place so the next press
+ * is still decided against the user's latest intent, and a record older
+ * than the transition timeout is ignored outright, since no native
+ * transition takes that long. Events cannot say which request they belong
+ * to, so any automatic "repeat the target" on a mismatch is
+ * indistinguishable from reversing the user's own green-button or
+ * Ctrl+Cmd+F action, and is deliberately not done: should a platform ever
+ * drop a queued request, the record expires within the timeout, the
+ * event-fed state takes over and the next press corrects the window.
+ * Electron queues such requests on macOS and applies them synchronously
+ * elsewhere, so that case is theoretical.
+ */
+interface PendingFullScreenTransition {
+    target: boolean;
+    requestedAt: number;
+}
+
+interface TrackedFullScreenState {
+    /** Event-fed fullscreen state; seeded from the getter once. */
+    fullScreen: boolean;
+    pending?: PendingFullScreenTransition;
+}
+
+/** Longest a native transition is trusted to still be in flight. */
+export const FULLSCREEN_TRANSITION_TIMEOUT_MS = 2000;
+
+const trackedWindows = new WeakMap<
+    Electron.BrowserWindow,
+    TrackedFullScreenState
+>();
+
+function getFreshPending(
+    state: TrackedFullScreenState,
+    now: number
+): PendingFullScreenTransition | undefined {
+    const pending = state.pending;
+
+    if (!pending) {
+        return undefined;
+    }
+
+    if (now - pending.requestedAt > FULLSCREEN_TRANSITION_TIMEOUT_MS) {
+        state.pending = undefined;
+        return undefined;
+    }
+
+    return pending;
+}
+
+/**
+ * Starts following the window's native fullscreen events. Call it right
+ * after the window is created, when no transition can be in flight, so the
+ * seed read is the one time the getter is trusted; later callers get the
+ * existing record.
+ */
+export function trackNativeFullScreen(
+    win: Electron.BrowserWindow
+): TrackedFullScreenState {
+    const existing = trackedWindows.get(win);
+    if (existing) {
+        return existing;
+    }
+
+    const state: TrackedFullScreenState = { fullScreen: win.isFullScreen() };
+    trackedWindows.set(win, state);
+
+    // `landed` is the state the event itself conveys, never a re-read of
+    // the getter.
+    const settle = (landed: boolean) => {
+        state.fullScreen = landed;
+
+        // Through the expiry check so a late event cannot be matched
+        // against a request the user has long moved past.
+        const pending = getFreshPending(state, Date.now());
+        if (pending && landed === pending.target) {
+            state.pending = undefined;
+        }
+    };
+    win.on('enter-full-screen', () => settle(true));
+    win.on('leave-full-screen', () => settle(false));
+
+    return state;
+}
+
+export function getPendingFullScreenTarget(
+    win: Electron.BrowserWindow,
+    now: number = Date.now()
+): boolean | undefined {
+    const state = trackedWindows.get(win);
+    return state ? getFreshPending(state, now)?.target : undefined;
+}
+
+export function requestFullScreen(
+    win: Electron.BrowserWindow,
+    target: boolean,
+    now: number = Date.now()
+): void {
+    const state = trackNativeFullScreen(win);
+    state.pending = { target, requestedAt: now };
+    win.setFullScreen(target);
+}
+
+/**
+ * Requests the opposite of the pending target, or of the tracked state when
+ * no transition is in flight, and returns the requested state.
+ */
+export function toggleFullScreen(
+    win: Electron.BrowserWindow,
+    now: number = Date.now()
+): boolean {
+    const state = trackNativeFullScreen(win);
+    const target = !(getPendingFullScreenTarget(win, now) ?? state.fullScreen);
+    requestFullScreen(win, target, now);
+    return target;
+}
diff --git a/apps/electron-backend/src/app/services/startup-window-mode.spec.ts b/apps/electron-backend/src/app/services/startup-window-mode.spec.ts
new file mode 100644
index 000000000..ba214ce27
--- /dev/null
+++ b/apps/electron-backend/src/app/services/startup-window-mode.spec.ts
@@ -0,0 +1,53 @@
+import {
+    FULLSCREEN_LAUNCH_SWITCH,
+    resolveStartupWindowMode,
+} from './startup-window-mode';
+
+describe('resolveStartupWindowMode', () => {
+    it('is exposed as the bare switch name Electron parses from argv', () => {
+        // app.commandLine.hasSwitch() takes the name without dashes.
+        expect(FULLSCREEN_LAUNCH_SWITCH).toBe('fullscreen');
+    });
+
+    it('defaults to a normal window on a fresh profile', () => {
+        expect(
+            resolveStartupWindowMode({
+                cliHasFullscreenSwitch: false,
+                storedMode: undefined,
+            })
+        ).toBe('normal');
+    });
+
+    it.each(['normal', 'maximized', 'fullscreen'] as const)(
+        'honours the stored %s mode',
+        (storedMode) => {
+            expect(
+                resolveStartupWindowMode({
+                    cliHasFullscreenSwitch: false,
+                    storedMode,
+                })
+            ).toBe(storedMode);
+        }
+    );
+
+    it.each(['kiosk', '', 1, true, null, {}])(
+        'collapses a hand-edited config value %p to normal',
+        (storedMode) => {
+            expect(
+                resolveStartupWindowMode({
+                    cliHasFullscreenSwitch: false,
+                    storedMode,
+                })
+            ).toBe('normal');
+        }
+    );
+
+    it('lets the --fullscreen switch win over any stored mode', () => {
+        expect(
+            resolveStartupWindowMode({
+                cliHasFullscreenSwitch: true,
+                storedMode: 'maximized',
+            })
+        ).toBe('fullscreen');
+    });
+});
diff --git a/apps/electron-backend/src/app/services/startup-window-mode.ts b/apps/electron-backend/src/app/services/startup-window-mode.ts
new file mode 100644
index 000000000..401adfee0
--- /dev/null
+++ b/apps/electron-backend/src/app/services/startup-window-mode.ts
@@ -0,0 +1,32 @@
+import {
+    normalizeStartupWindowMode,
+    StartupWindowMode,
+} from '@iptvnator/shared/interfaces';
+
+/**
+ * Command-line switch that forces one fullscreen launch:
+ * `iptvnator --fullscreen`. Meant for HTPC autostart scripts. It is read
+ * through Electron's parsed command line, so it can sit anywhere in argv;
+ * the playlist-path extractor already skips every `-`-prefixed argument.
+ */
+export const FULLSCREEN_LAUNCH_SWITCH = 'fullscreen';
+
+/**
+ * Decides how the main window is presented at launch.
+ *
+ * The switch wins over the stored setting but is never persisted — the next
+ * launch without it falls back to whatever Settings say. The stored value is
+ * whatever the SETTINGS_UPDATE mirror wrote (or nothing on a fresh profile)
+ * and is normalized again here, so a hand-edited config file cannot pass an
+ * unknown mode into the window options.
+ */
+export function resolveStartupWindowMode(input: {
+    cliHasFullscreenSwitch: boolean;
+    storedMode: unknown;
+}): StartupWindowMode {
+    if (input.cliHasFullscreenSwitch) {
+        return 'fullscreen';
+    }
+
+    return normalizeStartupWindowMode(input.storedMode);
+}
diff --git a/apps/electron-backend/src/app/services/store.service.ts b/apps/electron-backend/src/app/services/store.service.ts
index 7bd61ae7c..5600c4f86 100644
--- a/apps/electron-backend/src/app/services/store.service.ts
+++ b/apps/electron-backend/src/app/services/store.service.ts
@@ -1,5 +1,6 @@
 import { Conf } from 'electron-conf/main';
 import { getElectronConfigDirectory } from '@iptvnator/shared/database';
+import type { StartupWindowMode } from '@iptvnator/shared/interfaces';
 
 export const WINDOW_BOUNDS = 'WINDOW_BOUNDS';
 export const MPV_PLAYER_PATH = 'MPV_PLAYER_PATH';
@@ -8,6 +9,7 @@ export const VLC_PLAYER_PATH = 'VLC_PLAYER_PATH';
 export const VLC_PLAYER_ARGUMENTS = 'VLC_PLAYER_ARGUMENTS';
 export const MPV_REUSE_INSTANCE = 'MPV_REUSE_INSTANCE';
 export const VLC_REUSE_INSTANCE = 'VLC_REUSE_INSTANCE';
+
 /**
  * Embedded MPV frame-copy engine opt-in (macOS arm64, Linux x64). Lives in the
  * main process config file because it must be readable synchronously before
@@ -15,6 +17,28 @@ export const VLC_REUSE_INSTANCE = 'VLC_REUSE_INSTANCE';
  * its preload frame pump, which cannot change after window creation.
  */
 export const EMBEDDED_MPV_FRAME_COPY = 'EMBEDDED_MPV_FRAME_COPY';
+/**
+ * Window presentation at launch (`normal` / `maximized` / `fullscreen`).
+ * Mirrored here from the renderer's settings by the SETTINGS_UPDATE handler
+ * for the same reason as the frame-copy flag: `initMainWindow` needs it
+ * synchronously, before any renderer exists to ask.
+ */
+export const STARTUP_WINDOW_MODE = 'STARTUP_WINDOW_MODE';
+
+/**
+ * Extra libmpv options for embedded sessions, one "key=value" per line, as
+ * typed in Settings > Playback. Mirrored here by the SETTINGS_UPDATE handler
+ * because sessions are created in the main process, where the renderer's
+ * IndexedDB settings are unreachable. Turned into addon arguments by
+ * `readEmbeddedMpvSessionOptions()`.
+ */
+export const EMBEDDED_MPV_EXTRA_OPTIONS = 'EMBEDDED_MPV_EXTRA_OPTIONS';
+
+/**
+ * Whether a dropped embedded MPV stream is reloaded automatically. Same
+ * mirror as above; absent means enabled.
+ */
+export const EMBEDDED_MPV_AUTO_RECONNECT = 'EMBEDDED_MPV_AUTO_RECONNECT';
 
 export type StoreType = {
     [WINDOW_BOUNDS]: Electron.Rectangle;
@@ -25,6 +49,9 @@ export type StoreType = {
     [MPV_REUSE_INSTANCE]: boolean;
     [VLC_REUSE_INSTANCE]: boolean;
     [EMBEDDED_MPV_FRAME_COPY]: boolean;
+    [EMBEDDED_MPV_EXTRA_OPTIONS]: string;
+    [EMBEDDED_MPV_AUTO_RECONNECT]: boolean;
+    [STARTUP_WINDOW_MODE]: StartupWindowMode;
 };
 
 // Export singleton store instance
diff --git a/apps/stalker-mock-server/README.md b/apps/stalker-mock-server/README.md
index b77100e1e..f67cf38ff 100644
--- a/apps/stalker-mock-server/README.md
+++ b/apps/stalker-mock-server/README.md
@@ -84,7 +84,7 @@ actually get wrong:
 | `00:1A:79:00:00:04` | **is-series** | 60% of VOD items have `is_series=1` — tests the Ministra lazy-season flow |
 | `00:1A:79:00:00:05` | **embedded-series** | 50% of VOD items have embedded `series[]` arrays — tests the embedded series flow |
 | `00:1A:79:00:00:06` | **legacy-pagination** | No `get_all_channels` support — tests the paginated `get_ordered_list` crawl fallback for the full ITV channel list |
-| `00:1A:79:00:00:07` | **marketing-demo** | 35 original poster movies with the newest 20 first — safe for screenshots and marketing |
+| `00:1A:79:00:00:07` | **marketing-demo** | 35 original poster movies with the newest 20 first, plus the fictional live channels shared with the Xtream mock (logos served from `/assets/marketing/logo/<slug>.svg`, no censored category) — safe for screenshots and marketing |
 | `00:1A:79:00:00:08` | **login-required** | `get_profile` answers `status: 2` until the client completes `do_auth` with non-empty credentials. The app drives this end to end: enter a username and password in the Stalker import dialog and it runs `do_auth`, then retries `get_profile` with `auth_second_step=1`. Covered by `stalker.e2e.ts` (`@stalker full portal authentication`) |
 | `00:1A:79:AE:<slot>:02` | **login-required** | Parallel-slot-scoped alias range used by concurrent auth E2E runs; it has the same login contract as `00:1A:79:00:00:08` but independent per-MAC state |
 | `00:1A:79:00:00:09` | **gated-stream** | `create_link` returns a local `/stream/gated/…` URL that answers 403 without the mac cookie and the MAC's current Bearer token — proves a player's media requests really carry the portal credentials |
@@ -114,6 +114,7 @@ Besides the portal paths above, `src/main.ts` mounts:
 | `/stalker?url=<portal_url>&macAddress=<mac>&action=<action>&…` | `GET` | CORS-proxy mirror of the IPTVnator web-backend `/stalker` endpoint, used by PWA/Playwright runs. `macAddress`, `token` and `serialNumber` are control params turned into headers and stripped from the portal query (except `handshake`'s candidate token); the response is wrapped as `{ payload }`. Strictness follows the proxied `url`'s shape |
 | `/stream/gated/:file` | `GET` | `video.mp4` / `audio.mp4` fixtures for the `gated-stream` scenario — 403 without the mac cookie **and** the MAC's current Bearer token |
 | `/assets/marketing/poster/<slug>.png` | `GET` | The committed screenshot-safe poster catalog shared with the Xtream mock, served from this process so `marketing-demo` needs no second server |
+| `/assets/marketing/logo/<slug>.svg[?size=WxH]` | `GET` | Generated channel logo (initials on a gradient) for the `marketing-demo` live channels and radio stations, rendered by `@iptvnator/shared/marketing-fixtures` |
 | `/health` | `GET` | Health check — returns `{ status: "ok" }` |
 | `/reset[?macAddress=<mac>&macAddress=…]` | `POST` | Clear generated data, favorites, session/auth state (including pinned device IDs) and watchdog counters. **Pass the MACs you own**: state is per-MAC and parallel spec files share this process, so a bare `/reset` wipes their state mid-test. Repeated params clear several MACs in one request |
 | `/invalidate-session?macAddress=<mac>` | `POST` | Drop that MAC's tokens so the next portal call fails with `Authorization failed.` — lets tests assert the client re-handshakes and retries. Pinned device identity survives, as on a real portal |
diff --git a/apps/stalker-mock-server/src/app/data-generator.ts b/apps/stalker-mock-server/src/app/data-generator.ts
index 29d8a73b0..c9311b096 100644
--- a/apps/stalker-mock-server/src/app/data-generator.ts
+++ b/apps/stalker-mock-server/src/app/data-generator.ts
@@ -3,6 +3,13 @@ import {
     MarketingMovieCategoryKey,
     POSTER_SHOWCASE_MOVIES,
 } from '@iptvnator/shared/marketing-fixtures';
+import {
+    generateMarketingChannels,
+    generateMarketingEpg,
+    generateMarketingItvCategories,
+    marketingEpgTitlesFor,
+    marketingLogoPath,
+} from './marketing-live.generator.js';
 import { ScenarioConfig } from './scenarios.js';
 
 // ---------------------------------------------------------------------------
@@ -235,30 +242,53 @@ export function generatePortalData(config: ScenarioConfig): GeneratedPortalData
     };
 
     // ------ ITV categories + channels ------
-    data.itvCategories = generateCategories('itv', config.categoryCount.itv);
-    // Real Ministra portals mark adult genres as censored and EXCLUDE their
-    // channels from get_all_channels / the "*" listing; the channels are only
-    // served by paging the specific genre. Mirror that with one extra
-    // censored category so clients can exercise the fallback path.
-    data.itvCategories.push({
-        id: '1099',
-        title: 'For adults',
-        alias: 'for_adults',
-        censored: '1',
-    });
-    let channelIndex = 0;
-    for (const cat of data.itvCategories) {
-        const channels = generateChannels(
-            cat.id,
-            config.itemsPerCategory,
-            channelIndex,
-            config.staticChannelCmd === true
-        );
-        data.channels.set(cat.id, channels);
-        for (const ch of channels) {
-            data.epg.set(ch.id, generateEpg(ch.name));
+    if (config.marketingFixture) {
+        // Screenshot-safe: shared fictional channels, logos served by this
+        // process, no censored category to keep out of a published frame.
+        data.itvCategories = generateMarketingItvCategories();
+        const marketingChannels = generateMarketingChannels();
+        for (const cat of data.itvCategories) {
+            const channels = marketingChannels.filter(
+                (channel) => channel.category_id === cat.id
+            );
+            data.channels.set(cat.id, channels);
+            for (const ch of channels) {
+                data.epg.set(
+                    ch.id,
+                    generateMarketingEpg(ch.name, marketingEpgTitlesFor(ch.name))
+                );
+            }
+        }
+    } else {
+        data.itvCategories = generateCategories(
+            'itv',
+            config.categoryCount.itv
+        );
+        // Real Ministra portals mark adult genres as censored and EXCLUDE
+        // their channels from get_all_channels / the "*" listing; the
+        // channels are only served by paging the specific genre. Mirror that
+        // with one extra censored category so clients can exercise the
+        // fallback path.
+        data.itvCategories.push({
+            id: '1099',
+            title: 'For adults',
+            alias: 'for_adults',
+            censored: '1',
+        });
+        let channelIndex = 0;
+        for (const cat of data.itvCategories) {
+            const channels = generateChannels(
+                cat.id,
+                config.itemsPerCategory,
+                channelIndex,
+                config.staticChannelCmd === true
+            );
+            data.channels.set(cat.id, channels);
+            for (const ch of channels) {
+                data.epg.set(ch.id, generateEpg(ch.name));
+            }
+            channelIndex += config.itemsPerCategory;
         }
-        channelIndex += config.itemsPerCategory;
     }
 
     // ------ Radio categories + stations ------
@@ -271,7 +301,8 @@ export function generatePortalData(config: ScenarioConfig): GeneratedPortalData
         const stations = generateRadioStations(
             cat.id,
             config.itemsPerCategory,
-            radioIndex
+            radioIndex,
+            config.marketingFixture === true
         );
         data.radio.set(cat.id, stations);
         radioIndex += config.itemsPerCategory;
@@ -426,7 +457,8 @@ function generateChannels(
 function generateRadioStations(
     categoryId: string,
     count: number,
-    startIndex: number
+    startIndex: number,
+    localLogos = false
 ): RawRadioStation[] {
     return Array.from({ length: count }, (_, i) => {
         const globalIndex = startIndex + i;
@@ -437,7 +469,7 @@ function generateRadioStations(
             name,
             o_name: name,
             cmd: `ffrt4://radio/${id}/index.mp3`,
-            logo: logoUrl(`radio-${id}`),
+            logo: localLogos ? marketingLogoPath(name) : logoUrl(`radio-${id}`),
             category_id: categoryId,
             tv_genre_id: categoryId,
             number: String(globalIndex + 1),
diff --git a/apps/stalker-mock-server/src/app/marketing-live.generator.ts b/apps/stalker-mock-server/src/app/marketing-live.generator.ts
new file mode 100644
index 000000000..232c54c61
--- /dev/null
+++ b/apps/stalker-mock-server/src/app/marketing-live.generator.ts
@@ -0,0 +1,96 @@
+import {
+    MARKETING_LIVE_CATEGORIES,
+    MARKETING_LIVE_CHANNELS,
+    MARKETING_LOGO_ASSET_PATH,
+    MarketingLiveCategoryKey,
+    marketingSlug,
+} from '@iptvnator/shared/marketing-fixtures';
+import type { RawCategory, RawChannel, RawEpgProgram } from './data-generator.js';
+
+/**
+ * ITV side of the `marketing-demo` scenario: the provider-neutral channel
+ * list shared with the Xtream mock, logos served by this process from
+ * `/assets/marketing/logo/<slug>.svg`, and a schedule built from the
+ * channels' own fictional programme titles. Nothing here reaches a
+ * third-party host, which is what lets the release screenshot guards accept
+ * a Stalker live-TV frame.
+ */
+
+const STALKER_MARKETING_ITV_CATEGORY_IDS: Record<
+    MarketingLiveCategoryKey,
+    string
+> = {
+    newsroom: '1101',
+    sports: '1102',
+    family: '1103',
+    culture: '1104',
+};
+
+const MARKETING_CHANNEL_ID_BASE = 11_000;
+const SLOT_MINUTES = 60;
+const TOTAL_DAYS = 7;
+
+export function marketingLogoPath(name: string): string {
+    return `${MARKETING_LOGO_ASSET_PATH}/${marketingSlug(name)}.svg?size=256x256`;
+}
+
+export function generateMarketingItvCategories(): RawCategory[] {
+    return MARKETING_LIVE_CATEGORIES.map((category) => ({
+        id: STALKER_MARKETING_ITV_CATEGORY_IDS[category.key],
+        title: category.name,
+        alias: marketingSlug(category.name).replace(/-/g, '_'),
+    }));
+}
+
+export function generateMarketingChannels(): RawChannel[] {
+    return MARKETING_LIVE_CHANNELS.map((channel, index) => {
+        const id = String(MARKETING_CHANNEL_ID_BASE + index);
+
+        return {
+            id,
+            name: channel.name,
+            o_name: channel.name,
+            cmd: `ffrt4://ch/live/${id}/index.m3u8`,
+            logo: marketingLogoPath(channel.name),
+            category_id: STALKER_MARKETING_ITV_CATEGORY_IDS[channel.categoryKey],
+            tv_genre_id: STALKER_MARKETING_ITV_CATEGORY_IDS[channel.categoryKey],
+            xmltv_id: `${marketingSlug(channel.name)}.fictional`,
+            use_http_tmp_link: '1',
+            use_load_balancing: '0',
+        };
+    });
+}
+
+/** Hourly slots for a week, cycling the channel's fixture titles. */
+export function generateMarketingEpg(
+    channelName: string,
+    titles: readonly string[]
+): RawEpgProgram[] {
+    const dayStart = new Date();
+    dayStart.setUTCHours(0, 0, 0, 0);
+    const slotsPerDay = (24 * 60) / SLOT_MINUTES;
+
+    return Array.from({ length: slotsPerDay * TOTAL_DAYS }, (_, index) => {
+        const start = new Date(dayStart.getTime() + index * SLOT_MINUTES * 60_000);
+        const stop = new Date(start.getTime() + SLOT_MINUTES * 60_000);
+        const title = titles[index % titles.length] ?? channelName;
+
+        return {
+            id: String(index + 1),
+            name: title,
+            start: start.toISOString(),
+            stop: stop.toISOString(),
+            start_timestamp: Math.floor(start.getTime() / 1000),
+            stop_timestamp: Math.floor(stop.getTime() / 1000),
+            descr: `${title} on ${channelName}, part of the fictional IPTVnator demo schedule.`,
+            category: 'Fictional',
+        };
+    });
+}
+
+export function marketingEpgTitlesFor(channelName: string): readonly string[] {
+    return (
+        MARKETING_LIVE_CHANNELS.find((channel) => channel.name === channelName)
+            ?.epgTitles ?? [channelName]
+    );
+}
diff --git a/apps/stalker-mock-server/src/app/marketing-poster-url.spec.ts b/apps/stalker-mock-server/src/app/marketing-poster-url.spec.ts
index e8055efc9..01d462978 100644
--- a/apps/stalker-mock-server/src/app/marketing-poster-url.spec.ts
+++ b/apps/stalker-mock-server/src/app/marketing-poster-url.spec.ts
@@ -49,6 +49,19 @@ describe('marketing poster URLs', () => {
         });
     });
 
+    it('resolves channel logo paths the same way as posters', () => {
+        const req = request('http', { host: 'localhost:3210' });
+
+        expect(
+            resolveMarketingPosterUrls(
+                { logo: '/assets/marketing/logo/aurora-news.svg?size=256x256' },
+                buildRequestOrigin(req)
+            )
+        ).toEqual({
+            logo: 'http://localhost:3210/assets/marketing/logo/aurora-news.svg?size=256x256',
+        });
+    });
+
     it('preserves unrelated URLs and values', () => {
         const payload = {
             cover: 'https://picsum.photos/seed/movie/300/450',
diff --git a/apps/stalker-mock-server/src/app/marketing-poster-url.ts b/apps/stalker-mock-server/src/app/marketing-poster-url.ts
index 5ef73e4a9..5cf0de781 100644
--- a/apps/stalker-mock-server/src/app/marketing-poster-url.ts
+++ b/apps/stalker-mock-server/src/app/marketing-poster-url.ts
@@ -3,7 +3,8 @@ type RequestOriginSource = {
     get(name: string): string | undefined;
 };
 
-const MARKETING_POSTER_PATH_PREFIX = '/assets/marketing/poster/';
+/** Posters and channel logos alike: every asset this process serves itself. */
+const MARKETING_POSTER_PATH_PREFIX = '/assets/marketing/';
 
 export function buildRequestOrigin(request: RequestOriginSource): string {
     const protocol =
diff --git a/apps/stalker-mock-server/src/main.ts b/apps/stalker-mock-server/src/main.ts
index 738d94039..0ff74a987 100644
--- a/apps/stalker-mock-server/src/main.ts
+++ b/apps/stalker-mock-server/src/main.ts
@@ -12,6 +12,7 @@ import {
 } from './app/auth-store.js';
 import { resetWatchdogPings } from './app/handlers/get-events.handler.js';
 import { resetAll, resetMac } from './app/data-store.js';
+import { renderMarketingLogoSvg } from '@iptvnator/shared/marketing-fixtures';
 import { SCENARIOS } from './app/scenarios.js';
 import {
     buildRequestOrigin,
@@ -53,9 +54,11 @@ app.use((req, _res, next) => {
 
 // Marketing fixtures store deployment-neutral asset paths. Resolve them
 // against the public origin of each request, including reverse-proxy headers.
+// `get_all_channels` is the full ITV list the app caches per session, so the
+// live-TV channel logos of the marketing scenario ride on it as well.
 app.use((req, res, next) => {
     if (
-        !['get_ordered_list', 'favorites'].includes(
+        !['get_ordered_list', 'get_all_channels', 'favorites'].includes(
             String(req.query['action'])
         )
     ) {
@@ -87,6 +90,17 @@ app.use(
     })
 );
 
+// Channel logos of the marketing-demo scenario, rendered on the fly with the
+// same generator the Xtream mock uses, so a live-TV frame never fetches a
+// third-party image.
+app.get('/assets/marketing/logo/:slug', (req: Request, res: Response) => {
+    const size =
+        typeof req.query['size'] === 'string' ? req.query['size'] : undefined;
+    res.type('image/svg+xml')
+        .set('Cache-Control', 'public, max-age=3600')
+        .send(renderMarketingLogoSvg(String(req.params['slug'] ?? ''), size));
+});
+
 // Stalker portal.php endpoint (reseller-panel alias — tolerant, no token check)
 app.use('/portal.php', portalRouter);
 
diff --git a/apps/web-e2e/src/stalker.e2e.ts b/apps/web-e2e/src/stalker.e2e.ts
index 9b186181c..88a1b81ff 100644
--- a/apps/web-e2e/src/stalker.e2e.ts
+++ b/apps/web-e2e/src/stalker.e2e.ts
@@ -462,6 +462,44 @@ test('@stalker PWA hides EPG for ITV channel', async ({ page }) => {
     expect(shortEpgRequests).toHaveLength(0);
 });
 
+test('@stalker ITV playback survives a category switch', async ({ page }) => {
+    // Regression: the shell context panel used to clear the selected Stalker
+    // item on every category click, tearing down the player for a channel the
+    // user never switched away from. Xtream live (#936) and M3U groups keep
+    // playing across a category/group switch; Stalker must too.
+    await addStalkerPortal(page);
+
+    await page.getByRole('link', { name: /live|itv/i }).click();
+    await page.waitForURL(/stalker.*itv/);
+
+    const categories = page.locator('.category-item');
+    await expect(categories.nth(1)).toBeVisible({ timeout: 10_000 });
+    await categories.nth(1).click();
+
+    const sidebar = page.locator('app-stalker-live-stream-layout .sidebar');
+    const sidebarTitle = sidebar.locator('.category-title');
+    const channels = page.locator('[data-test-id="channel-item"]');
+    await expect(channels.first()).toBeVisible({ timeout: 20_000 });
+    const firstCategoryTitle = (await sidebarTitle.textContent())?.trim() ?? '';
+    expect(firstCategoryTitle).not.toBe('');
+
+    await channels.first().click();
+    await expect(channels.first()).toHaveClass(/active/, { timeout: 20_000 });
+    const player = page.locator('app-web-player-view');
+    await expect(player).toBeVisible({ timeout: 20_000 });
+
+    await categories.nth(2).click();
+
+    // The sidebar re-filters to the new category (proves the click landed and
+    // change detection ran)…
+    await expect(sidebarTitle).not.toHaveText(firstCategoryTitle, {
+        timeout: 20_000,
+    });
+    await expect(channels.first()).toBeVisible({ timeout: 20_000 });
+    // …while the channel picked from the previous category keeps playing.
+    await expect(player).toBeVisible();
+});
+
 test('@stalker radio — stations use the inline audio player without EPG', async ({
     page,
 }) => {
@@ -514,6 +552,44 @@ test('@stalker radio — stations use the inline audio player without EPG', asyn
     expect(epgRequests).toHaveLength(0);
 });
 
+test('@stalker radio playback survives a category switch', async ({ page }) => {
+    // Radio shares the ITV layout and the same context-panel handler that
+    // used to clear the selected item on every category click (#1517). The
+    // inline audio player is gated on that selection, so a category switch
+    // silenced the station the user never switched away from.
+    await addStalkerPortal(page);
+
+    await page.getByRole('link', { name: /radio/i }).click();
+    await page.waitForURL(/stalker.*radio/);
+
+    const categories = page.locator('.category-item');
+    await expect(categories.nth(2)).toBeVisible({ timeout: 10_000 });
+    await categories.nth(1).click();
+
+    const sidebar = page.locator('app-stalker-live-stream-layout .sidebar');
+    const sidebarTitle = sidebar.locator('.category-title');
+    const stations = page.locator('[data-test-id="channel-item"]');
+    await expect(stations.first()).toBeVisible({ timeout: 20_000 });
+    const firstCategoryTitle = (await sidebarTitle.textContent())?.trim() ?? '';
+    expect(firstCategoryTitle).not.toBe('');
+
+    await stations.first().click();
+    await expect(stations.first()).toHaveClass(/active/, { timeout: 20_000 });
+    const audioPlayer = page.locator('app-audio-player');
+    await expect(audioPlayer).toBeVisible({ timeout: 20_000 });
+
+    await categories.nth(2).click();
+
+    // The sidebar re-filters to the new category (proves the click landed and
+    // change detection ran)…
+    await expect(sidebarTitle).not.toHaveText(firstCategoryTitle, {
+        timeout: 20_000,
+    });
+    await expect(stations.first()).toBeVisible({ timeout: 20_000 });
+    // …while the station picked from the previous category keeps playing.
+    await expect(audioPlayer).toBeVisible();
+});
+
 test('@stalker PWA skips bulk EPG across channel switches', async ({
     page,
 }) => {
diff --git a/apps/web-e2e/src/xtream.e2e.ts b/apps/web-e2e/src/xtream.e2e.ts
index 9a549e4bf..a4ae9282c 100644
--- a/apps/web-e2e/src/xtream.e2e.ts
+++ b/apps/web-e2e/src/xtream.e2e.ts
@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import type { APIRequestContext, Page } from '@playwright/test';
+import type { APIRequestContext, Locator, Page } from '@playwright/test';
 import { expect, test } from './fixtures';
 import { setInputValue } from './e2e-helpers';
 import {
@@ -929,6 +929,159 @@ function formatXtreamDateTime(timestampSeconds: number): string {
 // now the app-web-player-view host, which spans all applications of one mount.
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// Inline series playback helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Serve a tiny VP8 clip for every episode stream. Chromium ships no
+ * proprietary codecs, so the clip stands in for the mock's external HLS
+ * redirect; the browser sniffs the WebM container from the bytes. Registered
+ * after the beforeEach proxy route, so it runs first and fetches from the
+ * mock itself (the mock ignores the url parameter).
+ */
+async function routeEpisodeClip(page: Page): Promise<void> {
+    const episodeClip = readFileSync(
+        join(__dirname, 'fixtures/playback/episode.webm')
+    );
+    await page.route(
+        (url) =>
+            url.origin === MOCK_SERVER && url.pathname.startsWith('/series/'),
+        async (route) => {
+            // Chromium's media pipeline seeks through byte ranges; a plain
+            // 200 to a Range request clamps every seek to the start, which
+            // would defeat end-of-episode steps.
+            const range = /^bytes=(\d*)-(\d*)$/.exec(
+                route.request().headers()['range'] ?? ''
+            );
+            const last = episodeClip.length - 1;
+            const start = range?.[1]
+                ? Number(range[1])
+                : range?.[2]
+                  ? Math.max(0, episodeClip.length - Number(range[2]))
+                  : 0;
+            const end =
+                range?.[1] && range[2]
+                    ? Math.min(Number(range[2]), last)
+                    : last;
+            await route.fulfill({
+                status: range ? 206 : 200,
+                headers: {
+                    'accept-ranges': 'bytes',
+                    'content-length': String(end - start + 1),
+                    'content-type': 'video/webm',
+                    ...(range
+                        ? {
+                              'content-range': `bytes ${start}-${end}/${episodeClip.length}`,
+                          }
+                        : {}),
+                },
+                body: episodeClip.subarray(start, end + 1),
+            });
+        }
+    );
+}
+
+/**
+ * The mock's episodes are .mkv, which the HTML5 player would hand to hls.js;
+ * get_series_info is rewritten to .mp4 — the extension the player gives to
+ * the native source path.
+ */
+async function rewriteSeriesEpisodesToMp4(page: Page): Promise<void> {
+    await page.route('**/localhost:3000/xtream**', async (route) => {
+        const original = new URL(route.request().url());
+        if (original.searchParams.get('action') !== 'get_series_info') {
+            await route.fallback();
+            return;
+        }
+        const mockUrl = new URL(`${MOCK_SERVER}/xtream`);
+        original.searchParams.forEach((value, key) => {
+            if (key !== 'targetId') {
+                mockUrl.searchParams.set(key, value);
+            }
+        });
+        const response = await route.fetch({ url: mockUrl.toString() });
+        const body = (await response.json()) as {
+            payload: {
+                episodes?: Record<
+                    string,
+                    Array<{ container_extension: string }>
+                >;
+            };
+        };
+        for (const episodes of Object.values(body.payload.episodes ?? {})) {
+            for (const episode of episodes) {
+                episode.container_extension = 'mp4';
+            }
+        }
+        await route.fulfill({ response, json: body });
+    });
+}
+
+/** Persist the web player engine and the shared-controls preference. */
+async function selectWebPlayer(
+    page: Page,
+    engine: string,
+    sharedControls = true
+): Promise<void> {
+    await page.goto('/workspace/settings/playback');
+    await page.locator('[data-test-id="select-video-player"]').click();
+    await page.getByRole('option', { name: engine, exact: true }).click();
+    const toggle = page.locator(
+        '[data-test-id="web-player-shared-controls-toggle"]'
+    );
+    if ((await toggle.locator('input').isChecked()) !== sharedControls) {
+        await toggle.click();
+    }
+    const saveButton = page.getByRole('button', { name: 'Save changes' });
+    await saveButton.click();
+    await expect(saveButton).toBeHidden();
+}
+
+/** Add the mock portal and start the first episode of the first series. */
+async function playFirstSeriesEpisode(
+    page: Page,
+    request: APIRequestContext
+): Promise<{ playerView: Locator; video: Locator }> {
+    const categories = (await (
+        await request.get(
+            `${MOCK_SERVER}/player_api.php?username=${DEFAULT_USERNAME}&password=${DEFAULT_PASSWORD}&action=get_series_categories`
+        )
+    ).json()) as Array<{ category_id: string; category_name: string }>;
+    const category = categories[0];
+    const seriesItems = (await (
+        await request.get(
+            `${MOCK_SERVER}/player_api.php?username=${DEFAULT_USERNAME}&password=${DEFAULT_PASSWORD}&action=get_series&category_id=${category.category_id}`
+        )
+    ).json()) as Array<{ name: string; series_id: number }>;
+    const targetSeries = seriesItems[0];
+
+    await page.goto('/');
+    await addXtreamPortal(page);
+    await page.goto(page.url().replace(/\/vod.*$/, '/series'));
+    const categoryItem = page
+        .locator('.context-panel .category-item')
+        .filter({ hasText: category.category_name })
+        .first();
+    await expect(categoryItem).toBeVisible({ timeout: 10_000 });
+    await categoryItem.click();
+    const seriesCard = page
+        .locator('app-grid-list mat-card')
+        .filter({ hasText: targetSeries.name })
+        .first();
+    await expect(seriesCard).toBeVisible({ timeout: 10_000 });
+    await seriesCard.click();
+
+    const episodeCards = page.locator('.episode-card');
+    await expect(episodeCards).toHaveCount(8, { timeout: 15_000 });
+    await episodeCards.first().click();
+
+    const playerView = page.locator(
+        'app-portal-inline-player app-web-player-view'
+    );
+    return { playerView, video: playerView.locator('video') };
+}
+
 test.describe('@xtream inline series fullscreen', () => {
     // No autoplay-policy flag is needed: the episode click is a user
     // activation and the fixture clip carries no audio track.
@@ -941,133 +1094,19 @@ test.describe('@xtream inline series fullscreen', () => {
         page,
         request,
     }) => {
-        // Chromium ships no proprietary codecs, so a tiny VP8 clip stands in
-        // for the mock's external HLS redirect; the browser sniffs the WebM
-        // container from the bytes. The mock's episodes are .mkv, which the
-        // HTML5 player would hand to hls.js, so get_series_info is rewritten
-        // to .mp4 — the extension the player gives to the native source path.
-        // Registered after the beforeEach proxy route, so it runs first and
-        // fetches from the mock itself (the mock ignores the url parameter).
-        const episodeClip = readFileSync(
-            join(__dirname, 'fixtures/playback/episode.webm')
-        );
-        await page.route(
-            (url) =>
-                url.origin === MOCK_SERVER &&
-                url.pathname.startsWith('/series/'),
-            async (route) => {
-                // Chromium's media pipeline seeks through byte ranges; a
-                // plain 200 to a Range request clamps every seek to the
-                // start, which would defeat the end-of-episode step below.
-                const range = /^bytes=(\d*)-(\d*)$/.exec(
-                    route.request().headers()['range'] ?? ''
-                );
-                const last = episodeClip.length - 1;
-                const start = range?.[1]
-                    ? Number(range[1])
-                    : range?.[2]
-                      ? Math.max(0, episodeClip.length - Number(range[2]))
-                      : 0;
-                const end =
-                    range?.[1] && range[2]
-                        ? Math.min(Number(range[2]), last)
-                        : last;
-                await route.fulfill({
-                    status: range ? 206 : 200,
-                    headers: {
-                        'accept-ranges': 'bytes',
-                        'content-length': String(end - start + 1),
-                        'content-type': 'video/webm',
-                        ...(range
-                            ? {
-                                  'content-range': `bytes ${start}-${end}/${episodeClip.length}`,
-                              }
-                            : {}),
-                    },
-                    body: episodeClip.subarray(start, end + 1),
-                });
-            }
-        );
-        await page.route('**/localhost:3000/xtream**', async (route) => {
-            const original = new URL(route.request().url());
-            if (original.searchParams.get('action') !== 'get_series_info') {
-                await route.fallback();
-                return;
-            }
-            const mockUrl = new URL(`${MOCK_SERVER}/xtream`);
-            original.searchParams.forEach((value, key) => {
-                if (key !== 'targetId') {
-                    mockUrl.searchParams.set(key, value);
-                }
-            });
-            const response = await route.fetch({ url: mockUrl.toString() });
-            const body = (await response.json()) as {
-                payload: {
-                    episodes?: Record<
-                        string,
-                        Array<{ container_extension: string }>
-                    >;
-                };
-            };
-            for (const episodes of Object.values(body.payload.episodes ?? {})) {
-                for (const episode of episodes) {
-                    episode.container_extension = 'mp4';
-                }
-            }
-            await route.fulfill({ response, json: body });
-        });
+        await routeEpisodeClip(page);
+        await rewriteSeriesEpisodesToMp4(page);
 
         // Persist the HTML5 engine first: Video.js rejects the mock's
         // video/matroska source type before any bytes are sniffed.
-        await page.goto('/workspace/settings/playback');
-        await page.locator('[data-test-id="select-video-player"]').click();
-        await page
-            .getByRole('option', { name: 'HTML5 video player', exact: true })
-            .click();
-        const saveButton = page.getByRole('button', { name: 'Save changes' });
-        await saveButton.click();
-        await expect(saveButton).toBeHidden();
-
-        const categories = (await (
-            await request.get(
-                `${MOCK_SERVER}/player_api.php?username=${DEFAULT_USERNAME}&password=${DEFAULT_PASSWORD}&action=get_series_categories`
-            )
-        ).json()) as Array<{ category_id: string; category_name: string }>;
-        const category = categories[0];
-        const seriesItems = (await (
-            await request.get(
-                `${MOCK_SERVER}/player_api.php?username=${DEFAULT_USERNAME}&password=${DEFAULT_PASSWORD}&action=get_series&category_id=${category.category_id}`
-            )
-        ).json()) as Array<{ name: string; series_id: number }>;
-        const targetSeries = seriesItems[0];
-
-        await page.goto('/');
-        await addXtreamPortal(page);
-        await page.goto(page.url().replace(/\/vod.*$/, '/series'));
-        const categoryItem = page
-            .locator('.context-panel .category-item')
-            .filter({ hasText: category.category_name })
-            .first();
-        await expect(categoryItem).toBeVisible({ timeout: 10_000 });
-        await categoryItem.click();
-        const seriesCard = page
-            .locator('app-grid-list mat-card')
-            .filter({ hasText: targetSeries.name })
-            .first();
-        await expect(seriesCard).toBeVisible({ timeout: 10_000 });
-        await seriesCard.click();
-
-        const episodeCards = page.locator('.episode-card');
-        await expect(episodeCards).toHaveCount(8, { timeout: 15_000 });
-        await episodeCards.first().click();
-
-        const playerView = page.locator(
-            'app-portal-inline-player app-web-player-view'
+        await selectWebPlayer(page, 'HTML5 video player');
+        const { playerView, video } = await playFirstSeriesEpisode(
+            page,
+            request
         );
         await expect(playerView.locator('app-html-video-player')).toBeVisible({
             timeout: 15_000,
         });
-        const video = playerView.locator('video');
         const waitForMetadata = () =>
             expect
                 .poll(() =>
@@ -1093,6 +1132,19 @@ test.describe('@xtream inline series fullscreen', () => {
         await expect.poll(fullscreenOwner).not.toBeNull();
         await expect(overlayTitle).toContainText('S01E01');
 
+        // Chromium leaves the clicked button focused; the shared controls
+        // release that focus so Space reaches the playback shortcut instead
+        // of activating the button again (which left fullscreen while the
+        // video kept playing).
+        const paused = () =>
+            video.evaluate((el) => (el as HTMLVideoElement).paused);
+        await expect.poll(paused).toBe(false);
+        await page.keyboard.press('Space');
+        await expect.poll(paused).toBe(true);
+        expect(await fullscreenOwner()).not.toBeNull();
+        await page.keyboard.press('Space');
+        await expect.poll(paused).toBe(false);
+
         // Manual switch from the shared controls' own next-episode button.
         await playerView.hover();
         await playerView
@@ -1119,3 +1171,51 @@ test.describe('@xtream inline series fullscreen', () => {
         expect(await fullscreenOwner()).not.toBeNull();
     });
 });
+
+test.describe('@xtream vendor-chrome Video.js shortcuts', () => {
+    test.skip(
+        ({ browserName }) => browserName !== 'chromium',
+        'DOM fullscreen assertions target Chromium'
+    );
+
+    test('keep working after a mouse click on a control-bar button', async ({
+        page,
+        request,
+    }) => {
+        await routeEpisodeClip(page);
+        await rewriteSeriesEpisodesToMp4(page);
+        // Video.js with the shared controls opted out: the vendor control bar.
+        await selectWebPlayer(page, 'Video.js player', false);
+        const { playerView, video } = await playFirstSeriesEpisode(
+            page,
+            request
+        );
+        await expect(playerView.locator('app-vjs-player')).toBeVisible({
+            timeout: 15_000,
+        });
+        await expect(playerView.locator('app-player-controls')).toHaveCount(0);
+        const paused = () =>
+            video.evaluate((el) => (el as HTMLVideoElement).paused);
+        const fullscreenOwner = () =>
+            page.evaluate(() => document.fullscreenElement?.tagName ?? null);
+        await expect.poll(paused).toBe(false);
+
+        // Chromium leaves the clicked Video.js button focused, and a focused
+        // Video.js component swallows every key; the legacy chrome releases
+        // that focus so Space and M reach the playback shortcuts instead of
+        // Space activating the button again (which left fullscreen while the
+        // video kept playing).
+        await playerView.hover();
+        await playerView.locator('.vjs-fullscreen-control').click();
+        await expect.poll(fullscreenOwner).not.toBeNull();
+        await page.keyboard.press('Space');
+        await expect.poll(paused).toBe(true);
+        expect(await fullscreenOwner()).not.toBeNull();
+        await page.keyboard.press('Space');
+        await expect.poll(paused).toBe(false);
+        await page.keyboard.press('m');
+        await expect
+            .poll(() => video.evaluate((el) => (el as HTMLVideoElement).muted))
+            .toBe(true);
+    });
+});
diff --git a/apps/web/src/app/settings/settings-form.utils.spec.ts b/apps/web/src/app/settings/settings-form.utils.spec.ts
index 68b741725..e3e8a187a 100644
--- a/apps/web/src/app/settings/settings-form.utils.spec.ts
+++ b/apps/web/src/app/settings/settings-form.utils.spec.ts
@@ -1,5 +1,5 @@
 import { FormBuilder } from '@angular/forms';
-import { Settings } from '@iptvnator/shared/interfaces';
+import { Settings, VideoPlayer } from '@iptvnator/shared/interfaces';
 import {
     createSettingsForm,
     createSettingsFromFormValue,
@@ -34,3 +34,113 @@ describe('settings form utils — strip country prefix', () => {
         expect(settings.stripCountryPrefix).toBe(false);
     });
 });
+
+describe('settings form utils — startup window mode', () => {
+    const formBuilder = new FormBuilder();
+
+    it('defaults the form control to a normal window', () => {
+        const form = createSettingsForm(formBuilder, true);
+
+        expect(form.getRawValue().startupWindowMode).toBe('normal');
+    });
+
+    it('carries the chosen mode into the settings object', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({ startupWindowMode: 'fullscreen' });
+
+        const settings = createSettingsFromFormValue(form, {} as Settings);
+
+        expect(settings.startupWindowMode).toBe('fullscreen');
+    });
+
+    it('collapses a missing or unknown form value to normal', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({
+            startupWindowMode: null as unknown as 'normal',
+        });
+        expect(
+            createSettingsFromFormValue(form, {} as Settings).startupWindowMode
+        ).toBe('normal');
+
+        form.patchValue({
+            startupWindowMode: 'kiosk' as unknown as 'normal',
+        });
+        expect(
+            createSettingsFromFormValue(form, {} as Settings).startupWindowMode
+        ).toBe('normal');
+    });
+});
+
+describe('settings form utils — embedded MPV session options', () => {
+    const formBuilder = new FormBuilder();
+
+    it('defaults to no extra options and auto-reconnect on', () => {
+        const form = createSettingsForm(formBuilder, true);
+
+        expect(form.getRawValue().embeddedMpvExtraOptions).toBe('');
+        expect(form.getRawValue().embeddedMpvAutoReconnect).toBe(true);
+        expect(form.valid).toBe(true);
+    });
+
+    it('rejects forbidden keys and malformed lines in the options field', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({ player: VideoPlayer.EmbeddedMpv });
+        const control = form.get('embeddedMpvExtraOptions');
+
+        control?.setValue('hwdec=auto\nvo=null\nnot an option');
+
+        expect(control?.errors).toEqual({
+            invalidLines: ['not an option'],
+            forbiddenKeys: ['vo'],
+        });
+        expect(form.valid).toBe(false);
+
+        control?.setValue('hwdec=auto\ncache-secs=30');
+
+        expect(control?.errors).toBeNull();
+    });
+
+    it('ignores extra-option errors while another player is selected', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({ player: VideoPlayer.EmbeddedMpv });
+        const control = form.get('embeddedMpvExtraOptions');
+        control?.setValue('vo=null');
+        expect(form.valid).toBe(false);
+
+        form.patchValue({ player: VideoPlayer.VideoJs });
+
+        expect(control?.errors).toBeNull();
+        expect(form.valid).toBe(true);
+
+        form.patchValue({ player: VideoPlayer.EmbeddedMpv });
+
+        expect(control?.errors).toEqual({ forbiddenKeys: ['vo'] });
+        expect(form.valid).toBe(false);
+    });
+
+    it('carries canonical options and the reconnect opt-out into the settings object', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({
+            embeddedMpvExtraOptions: ' --hwdec = auto \r\n\ncache-secs=30 ',
+            embeddedMpvAutoReconnect: false,
+        });
+
+        const settings = createSettingsFromFormValue(form, {} as Settings);
+
+        expect(settings.embeddedMpvExtraOptions).toBe(
+            'hwdec=auto\ncache-secs=30'
+        );
+        expect(settings.embeddedMpvAutoReconnect).toBe(false);
+    });
+
+    it('falls back to auto-reconnect on when the form value is missing', () => {
+        const form = createSettingsForm(formBuilder, true);
+        form.patchValue({
+            embeddedMpvAutoReconnect: null as unknown as boolean,
+        });
+
+        const settings = createSettingsFromFormValue(form, {} as Settings);
+
+        expect(settings.embeddedMpvAutoReconnect).toBe(true);
+    });
+});
diff --git a/apps/web/src/app/settings/settings-form.utils.ts b/apps/web/src/app/settings/settings-form.utils.ts
index 60ab76fed..f8610a2e6 100644
--- a/apps/web/src/app/settings/settings-form.utils.ts
+++ b/apps/web/src/app/settings/settings-form.utils.ts
@@ -1,7 +1,9 @@
 import {
+    AbstractControl,
     FormArray,
     FormBuilder,
     FormControl,
+    ValidationErrors,
     Validators,
 } from '@angular/forms';
 import {
@@ -11,16 +13,36 @@ import {
     EpgViewMode,
     Language,
     normalizeDashboardRailsSettings,
+    normalizeEmbeddedMpvExtraOptions,
     normalizeExternalPlayerArguments,
+    normalizeStartupWindowMode,
     Settings,
     StartupBehavior,
+    StartupWindowMode,
     StreamFormat,
     Theme,
+    validateEmbeddedMpvExtraOptions,
     VideoPlayer,
 } from '@iptvnator/shared/interfaces';
 
 export const EPG_URL_PATTERN = /^(http|https|file):\/\/[^ "]+$/;
 
+/**
+ * Rejects malformed lines and the option keys the embed depends on, so a
+ * value that the main process would have to drop never gets saved.
+ */
+export function embeddedMpvExtraOptionsValidator(
+    control: AbstractControl
+): ValidationErrors | null {
+    // Only the embedded MPV player consumes these lines. While another player
+    // is selected the field is hidden, and a stale error must not keep the
+    // whole settings form unsaveable.
+    if (control.parent?.get('player')?.value !== VideoPlayer.EmbeddedMpv) {
+        return null;
+    }
+    return validateEmbeddedMpvExtraOptions(control.value);
+}
+
 export function createEpgUrlControl(value = ''): FormControl<string | null> {
     return new FormControl(value, [Validators.pattern(EPG_URL_PATTERN)]);
 }
@@ -29,7 +51,7 @@ export function createSettingsForm(
     formBuilder: FormBuilder,
     supportsEpg: boolean
 ) {
-    return formBuilder.group({
+    const form = formBuilder.group({
         player: [VideoPlayer.VideoJs],
         webPlayerSharedControls: true,
         playerAmbientMode: false,
@@ -60,6 +82,7 @@ export function createSettingsForm(
                 DEFAULT_DASHBOARD_RAILS_SETTINGS.tmdbRecommendations,
         }),
         startupBehavior: StartupBehavior.FirstView,
+        startupWindowMode: 'normal' as StartupWindowMode,
         showExternalPlaybackBar: true,
         stripCountryPrefix: false,
         theme: Theme.SystemTheme,
@@ -81,6 +104,8 @@ export function createSettingsForm(
         ],
         recordingFolder: '',
         embeddedMpvFrameCopy: false,
+        embeddedMpvExtraOptions: ['', [embeddedMpvExtraOptionsValidator]],
+        embeddedMpvAutoReconnect: true,
         coverSize: 'medium' as CoverSize,
         ...(supportsEpg
             ? {
@@ -93,6 +118,13 @@ export function createSettingsForm(
             apiKey: DEFAULT_TMDB_SETTINGS.apiKey ?? '',
         }),
     });
+    // The extra-options validator reads the sibling `player` control, which
+    // Angular does not track as a dependency: re-validate on player changes
+    // so a hidden field's stale error cannot block Save.
+    form.get('player')?.valueChanges.subscribe(() =>
+        form.get('embeddedMpvExtraOptions')?.updateValueAndValidity()
+    );
+    return form;
 }
 
 export type SettingsForm = ReturnType<typeof createSettingsForm>;
@@ -134,6 +166,7 @@ export function createSettingsFromFormValue(
         showDashboard: value.showDashboard ?? true,
         dashboardRails: normalizeDashboardRailsSettings(value.dashboardRails),
         startupBehavior: value.startupBehavior ?? StartupBehavior.FirstView,
+        startupWindowMode: normalizeStartupWindowMode(value.startupWindowMode),
         showExternalPlaybackBar: value.showExternalPlaybackBar ?? true,
         stripCountryPrefix: value.stripCountryPrefix ?? false,
         theme: value.theme ?? Theme.SystemTheme,
@@ -151,6 +184,10 @@ export function createSettingsFromFormValue(
         remoteControlPort: Number(value.remoteControlPort ?? 8765),
         recordingFolder: value.recordingFolder ?? '',
         embeddedMpvFrameCopy: value.embeddedMpvFrameCopy ?? false,
+        embeddedMpvExtraOptions: normalizeEmbeddedMpvExtraOptions(
+            value.embeddedMpvExtraOptions
+        ),
+        embeddedMpvAutoReconnect: value.embeddedMpvAutoReconnect ?? true,
         coverSize: value.coverSize ?? 'medium',
         epgUrl,
         preferUploadedEpgOverXtream:
diff --git a/apps/web/src/app/settings/settings-general-section.component.html b/apps/web/src/app/settings/settings-general-section.component.html
index 84d8ba2f5..897fe7451 100644
--- a/apps/web/src/app/settings/settings-general-section.component.html
+++ b/apps/web/src/app/settings/settings-general-section.component.html
@@ -144,6 +144,42 @@
         </div>
     </div>
 
+    @if (supportsStartupWindowMode()) {
+        <div class="setting-item" data-test-id="startup-window-mode-setting">
+            <div class="setting-item__meta">
+                <h4>{{ 'SETTINGS.STARTUP_WINDOW_MODE' | translate }}</h4>
+                <p>
+                    {{ 'SETTINGS.STARTUP_WINDOW_MODE_DESCRIPTION' | translate }}
+                </p>
+            </div>
+            <div class="setting-item__control">
+                <mat-form-field appearance="outline" subscriptSizing="dynamic">
+                    <mat-label>{{
+                        'SETTINGS.STARTUP_WINDOW_MODE' | translate
+                    }}</mat-label>
+                    <mat-select
+                        formControlName="startupWindowMode"
+                        data-test-id="select-startup-window-mode"
+                    >
+                        @for (
+                            option of startupWindowModeOptions();
+                            track option.value
+                        ) {
+                            <mat-option
+                                [value]="option.value"
+                                [attr.data-test-id]="
+                                    'startup-window-mode-' + option.value
+                                "
+                            >
+                                {{ option.labelKey | translate }}
+                            </mat-option>
+                        }
+                    </mat-select>
+                </mat-form-field>
+            </div>
+        </div>
+    }
+
     <div class="setting-item">
         <div class="setting-item__meta">
             <h4>{{ 'SETTINGS.SHOW_CAPTIONS' | translate }}</h4>
diff --git a/apps/web/src/app/settings/settings-general-section.component.ts b/apps/web/src/app/settings/settings-general-section.component.ts
index 86dace21f..f03f1dbca 100644
--- a/apps/web/src/app/settings/settings-general-section.component.ts
+++ b/apps/web/src/app/settings/settings-general-section.component.ts
@@ -10,6 +10,7 @@ import { CoverSize, Language, Theme } from '@iptvnator/shared/interfaces';
 import {
     CoverSizeOption,
     StartupBehaviorOption,
+    StartupWindowModeOption,
     ThemeOption,
 } from './settings.models';
 
@@ -34,6 +35,10 @@ export class SettingsGeneralSectionComponent {
     readonly themeOptions = input.required<ThemeOption[]>();
     readonly coverSizeOptions = input.required<CoverSizeOption[]>();
     readonly startupBehaviorOptions = input.required<StartupBehaviorOption[]>();
+    readonly startupWindowModeOptions =
+        input.required<StartupWindowModeOption[]>();
+    /** Desktop only: the window-mode select needs the main-process mirror and F11 */
+    readonly supportsStartupWindowMode = input(false);
 
     readonly selectTheme = output<Theme>();
     readonly selectCoverSize = output<CoverSize>();
diff --git a/apps/web/src/app/settings/settings-options.ts b/apps/web/src/app/settings/settings-options.ts
index 8df774bc1..81f6758c3 100644
--- a/apps/web/src/app/settings/settings-options.ts
+++ b/apps/web/src/app/settings/settings-options.ts
@@ -11,6 +11,7 @@ import {
     SettingsPlayerOption,
     SettingsSection,
     StartupBehaviorOption,
+    StartupWindowModeOption,
     ThemeOption,
 } from './settings.models';
 
@@ -74,6 +75,21 @@ export const SETTINGS_STARTUP_BEHAVIOR_OPTIONS: StartupBehaviorOption[] = [
     },
 ];
 
+export const SETTINGS_STARTUP_WINDOW_MODE_OPTIONS: StartupWindowModeOption[] = [
+    {
+        value: 'normal',
+        labelKey: 'SETTINGS.STARTUP_WINDOW_MODE_NORMAL',
+    },
+    {
+        value: 'maximized',
+        labelKey: 'SETTINGS.STARTUP_WINDOW_MODE_MAXIMIZED',
+    },
+    {
+        value: 'fullscreen',
+        labelKey: 'SETTINGS.STARTUP_WINDOW_MODE_FULLSCREEN',
+    },
+];
+
 export const SETTINGS_OS_PLAYER_OPTIONS: SettingsPlayerOption[] = [
     {
         id: VideoPlayer.MPV,
diff --git a/apps/web/src/app/settings/settings-playback-section.component.html b/apps/web/src/app/settings/settings-playback-section.component.html
index 243ebc1bf..aa668c064 100644
--- a/apps/web/src/app/settings/settings-playback-section.component.html
+++ b/apps/web/src/app/settings/settings-playback-section.component.html
@@ -1,8 +1,4 @@
-<section
-    class="settings-group"
-    id="playback"
-    [formGroup]="form()"
->
+<section class="settings-group" id="playback" [formGroup]="form()">
     <header class="settings-group__header">
         <div class="settings-group__header-icon">
             <mat-icon>play_circle</mat-icon>
@@ -235,6 +231,101 @@
             </div>
         }
 
+        @if (form().value.player === 'embedded-mpv') {
+            <div
+                class="setting-item"
+                data-test-id="embedded-mpv-extra-options-setting"
+            >
+                <div class="setting-item__meta">
+                    <h4>
+                        {{ 'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS' | translate }}
+                    </h4>
+                    <p>
+                        {{
+                            'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION'
+                                | translate
+                        }}
+                    </p>
+                </div>
+                <div class="setting-item__control">
+                    <mat-form-field
+                        appearance="outline"
+                        subscriptSizing="dynamic"
+                    >
+                        <mat-label for="embeddedMpvExtraOptions">{{
+                            'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS' | translate
+                        }}</mat-label>
+                        <textarea
+                            matInput
+                            id="embeddedMpvExtraOptions"
+                            formControlName="embeddedMpvExtraOptions"
+                            placeholder="hwdec=auto-safe"
+                            rows="3"
+                            spellcheck="false"
+                            autocomplete="off"
+                        ></textarea>
+                        <mat-hint>{{
+                            'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS_HINT'
+                                | translate
+                        }}</mat-hint>
+                        @if (
+                            form().get('embeddedMpvExtraOptions')?.errors;
+                            as errors
+                        ) {
+                            <mat-error
+                                data-test-id="embedded-mpv-extra-options-error"
+                            >
+                                @if (errors['forbiddenKeys']) {
+                                    {{
+                                        'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS'
+                                            | translate
+                                                : {
+                                                      keys: errors[
+                                                          'forbiddenKeys'
+                                                      ].join(', '),
+                                                  }
+                                    }}
+                                } @else if (errors['invalidLines']) {
+                                    {{
+                                        'SETTINGS.EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES'
+                                            | translate
+                                                : {
+                                                      lines: errors[
+                                                          'invalidLines'
+                                                      ].join(', '),
+                                                  }
+                                    }}
+                                }
+                            </mat-error>
+                        }
+                    </mat-form-field>
+                </div>
+            </div>
+
+            <div
+                class="setting-item"
+                data-test-id="embedded-mpv-auto-reconnect-setting"
+            >
+                <div class="setting-item__meta">
+                    <h4>
+                        {{ 'SETTINGS.EMBEDDED_MPV_AUTO_RECONNECT' | translate }}
+                    </h4>
+                    <p>
+                        {{
+                            'SETTINGS.EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION'
+                                | translate
+                        }}
+                    </p>
+                </div>
+                <div class="setting-item__control setting-item__toggle">
+                    <mat-checkbox
+                        formControlName="embeddedMpvAutoReconnect"
+                        data-test-id="embedded-mpv-auto-reconnect-toggle"
+                    ></mat-checkbox>
+                </div>
+            </div>
+        }
+
         <div class="setting-item" data-test-id="recording-folder-setting">
             <div class="setting-item__meta">
                 <h4>{{ 'SETTINGS.RECORDING_FOLDER_LABEL' | translate }}</h4>
diff --git a/apps/web/src/app/settings/settings.component.form.spec.ts b/apps/web/src/app/settings/settings.component.form.spec.ts
index a34179325..110c575b9 100644
--- a/apps/web/src/app/settings/settings.component.form.spec.ts
+++ b/apps/web/src/app/settings/settings.component.form.spec.ts
@@ -186,6 +186,9 @@ describe('SettingsComponent form', () => {
             expect(component.settingsForm.value.startupBehavior).toBe(
                 StartupBehavior.FirstView
             );
+            expect(component.settingsForm.value.startupWindowMode).toBe(
+                'normal'
+            );
         });
 
         it('disables dashboard surface controls when the dashboard is off', async () => {
diff --git a/apps/web/src/app/settings/settings.component.html b/apps/web/src/app/settings/settings.component.html
index fc4b3843f..60e62513f 100644
--- a/apps/web/src/app/settings/settings.component.html
+++ b/apps/web/src/app/settings/settings.component.html
@@ -110,6 +110,8 @@
                         [themeOptions]="themeOptions"
                         [coverSizeOptions]="coverSizeOptions"
                         [startupBehaviorOptions]="startupBehaviorOptions"
+                        [startupWindowModeOptions]="startupWindowModeOptions"
+                        [supportsStartupWindowMode]="supportsStartupWindowMode"
                         (selectTheme)="form.selectTheme($event)"
                         (selectCoverSize)="form.selectCoverSize($event)"
                     />
diff --git a/apps/web/src/app/settings/settings.component.ts b/apps/web/src/app/settings/settings.component.ts
index 56a07510c..babf5c56f 100644
--- a/apps/web/src/app/settings/settings.component.ts
+++ b/apps/web/src/app/settings/settings.component.ts
@@ -37,6 +37,7 @@ import {
     SETTINGS_COVER_SIZE_OPTIONS,
     SETTINGS_EPG_VIEW_MODE_OPTIONS,
     SETTINGS_STARTUP_BEHAVIOR_OPTIONS,
+    SETTINGS_STARTUP_WINDOW_MODE_OPTIONS,
     SETTINGS_THEME_OPTIONS,
 } from './settings-options';
 import { SettingsPlaybackSectionComponent } from './settings-playback-section.component';
@@ -140,6 +141,7 @@ export class SettingsComponent
         this.runtime.supportsExternalPlayerPathSettings;
     readonly supportsVodMultiSource = this.vodSourceDiscovery.isAvailable;
     readonly supportsRemoteControl = this.runtime.supportsRemoteControl;
+    readonly supportsStartupWindowMode = this.runtime.supportsStartupWindowMode;
 
     /** Settings form object */
     readonly settingsForm = this.form.form;
@@ -158,6 +160,7 @@ export class SettingsComponent
     readonly themeOptions = SETTINGS_THEME_OPTIONS;
     readonly coverSizeOptions = SETTINGS_COVER_SIZE_OPTIONS;
     readonly startupBehaviorOptions = SETTINGS_STARTUP_BEHAVIOR_OPTIONS;
+    readonly startupWindowModeOptions = SETTINGS_STARTUP_WINDOW_MODE_OPTIONS;
     readonly epgViewModeOptions = SETTINGS_EPG_VIEW_MODE_OPTIONS;
 
     readonly sectionNavItems: SettingsSection[] = buildSettingsSectionNavItems({
diff --git a/apps/web/src/app/settings/settings.models.ts b/apps/web/src/app/settings/settings.models.ts
index 2bfc8db82..8eef5b1d1 100644
--- a/apps/web/src/app/settings/settings.models.ts
+++ b/apps/web/src/app/settings/settings.models.ts
@@ -2,6 +2,7 @@ import {
     CoverSize,
     EpgViewMode,
     StartupBehavior,
+    StartupWindowMode,
     Theme,
     VideoPlayer,
 } from '@iptvnator/shared/interfaces';
@@ -24,6 +25,11 @@ export interface StartupBehaviorOption {
     labelKey: string;
 }
 
+export interface StartupWindowModeOption {
+    value: StartupWindowMode;
+    labelKey: string;
+}
+
 export interface CoverSizeOption {
     value: CoverSize;
     icon: string;
diff --git a/apps/web/src/app/settings/test-stubs/settings-test-harness.stub.ts b/apps/web/src/app/settings/test-stubs/settings-test-harness.stub.ts
index 47cea5679..fd300c748 100644
--- a/apps/web/src/app/settings/test-stubs/settings-test-harness.stub.ts
+++ b/apps/web/src/app/settings/test-stubs/settings-test-harness.stub.ts
@@ -95,6 +95,7 @@ export const DEFAULT_SETTINGS = {
     showCaptions: false,
     showDashboard: true,
     startupBehavior: StartupBehavior.FirstView,
+    startupWindowMode: 'normal',
     showExternalPlaybackBar: true,
     stripCountryPrefix: false,
     theme: Theme.SystemTheme,
@@ -109,6 +110,8 @@ export const DEFAULT_SETTINGS = {
     epgUrl: [],
     recordingFolder: '',
     embeddedMpvFrameCopy: false,
+    embeddedMpvExtraOptions: '',
+    embeddedMpvAutoReconnect: true,
     coverSize: 'medium',
     dashboardRails: DEFAULT_DASHBOARD_RAILS,
     preferUploadedEpgOverXtream: false,
diff --git a/apps/web/src/assets/i18n/ar.json b/apps/web/src/assets/i18n/ar.json
index fbd4203d2..e5a2750b9 100644
--- a/apps/web/src/assets/i18n/ar.json
+++ b/apps/web/src/assets/i18n/ar.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "اختر ما إذا كان IPTVnator يفتح أول عرض متاح في مساحة العمل أو يستعيد آخر عرض على مستوى القسم. العرض الأول يعني لوحة التحكم عند تفعيلها، وإلا فالمصادر.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "أول عرض متاح",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "استعادة آخر عرض",
+        "STARTUP_WINDOW_MODE": "نافذة التطبيق عند البدء",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "اختر كيف تُفتح نافذة سطح المكتب: بآخر حجم لها، أو مكبّرة، أو بملء الشاشة. يُطبَّق عند التشغيل التالي. اضغط F11 في أي وقت للدخول إلى وضع ملء الشاشة أو الخروج منه.",
+        "STARTUP_WINDOW_MODE_NORMAL": "آخر حجم للنافذة",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "مكبّرة",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "ملء الشاشة",
         "SHOW_CAPTIONS_DESCRIPTION": "عرض أو إخفاء الترجمات افتراضيًا",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "عرض شريط التشغيل الحالي",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "إبقاء شريط حالة المشغل الخارجي مرئيًا في أسفل مساحة العمل على سطح المكتب.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "MPV المدمج: محرك نسخ الإطارات (تجريبي)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "يُرسم الفيديو على لوحة التطبيق بحيث تظهر القوائم ومربعات الحوار فوقه.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "يسري المفعول بعد إعادة تشغيل التطبيق.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "خيارات إضافية لـ MPV المدمج",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "خيارات libmpv متقدمة للمشغّل المدمج، زوج key=value واحد في كل سطر (بدون -- في البداية). تُطبَّق في كل محرك بعد الخيارات المضمّنة، وتسري عند بدء جلسة MPV المدمج التالية.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "مثال: hwdec=auto-safe. تُرفض الخيارات التي يعتمد عليها التضمين نفسه (wid، vo، input-ipc-server، …).",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "ليس سطرًا بصيغة key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "لا يمكن تغيير هذه الخيارات للمشغّل المدمج: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "إعادة الاتصال بالبث المنقطع تلقائيًا",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "عند انقطاع بث قيد التشغيل، يعيد المشغّل المدمج تحميله بفواصل زمنية متزايدة، حتى 6 محاولات، قبل أن يتوقف. أما البث الذي لم يبدأ أصلًا فلا يزال يحتاج إلى إعادة المحاولة يدويًا.",
         "VOD_AUTO_FAILOVER": "التبديل التلقائي للمصدر عند فشل التشغيل",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "عند فشل تشغيل فيلم وتوفّر الفيلم نفسه في قائمة تشغيل أخرى، يتم التبديل إليها تلقائيًا مع الاحتفاظ بموضع التشغيل. الخيار معطّل افتراضيًا، ويُعلَن عن التبديل دائمًا لأن المصدر الآخر قد يحمل دبلجة مختلفة."
     },
@@ -515,6 +527,8 @@
             "RETRY": "إعادة المحاولة",
             "STALLED": "يستغرق بدء هذا البث وقتًا أطول من المتوقع.",
             "PLAYBACK_FAILED": "فشل التشغيل عبر MPV المضمّن.",
+            "RECONNECTING": "انقطع الاتصال. جارٍ إعادة الاتصال… المحاولة {{attempt}} من {{maxAttempts}}",
+            "STREAM_ENDED": "انتهى البث المباشر.",
             "CHECKING_SUPPORT": "جارٍ التحقق من دعم MPV المضمّن...",
             "NOT_AVAILABLE": "MPV المضمّن غير متاح في هذه البيئة.",
             "LOADING_STREAM": "جارٍ تحميل البث…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "فتح البحث العام",
                 "OPEN_RECENTLY_VIEWED": "فتح العناصر المشاهدة مؤخرًا",
                 "SUBMIT_SHELL_SEARCH": "إرسال بحث مساحة العمل",
+                "TOGGLE_WINDOW_FULLSCREEN": "تبديل ملء الشاشة لنافذة التطبيق",
                 "TOGGLE_SIDEBAR": "تبديل الشريط الجانبي",
                 "M3U_CHANNEL_NUMBER": "اختيار قناة M3U حسب الرقم",
                 "PLAY_PAUSE": "تشغيل أو إيقاف تشغيل Embedded MPV مؤقتًا",
diff --git a/apps/web/src/assets/i18n/ary.json b/apps/web/src/assets/i18n/ary.json
index 4dcce5c5c..3e7cff115 100644
--- a/apps/web/src/assets/i18n/ary.json
+++ b/apps/web/src/assets/i18n/ary.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "اختار واش IPTVnator يحل أول عرض متوفر في مساحة العمل ولا يسترجع آخر عرض على مستوى القسم. أول عرض كيعني لوحة التحكم إلى كانت مفعلة، إلا فالا فهي Sources.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "أول عرض متوفر",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "استرجع آخر عرض",
+        "STARTUP_WINDOW_MODE": "النافذة عند البدء",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "اختار كيفاش تتحل نافذة سطح المكتب: بآخر حجم ديالها، ولا مكبّرة، ولا بملء الشاشة. كيتطبق فالتشغيل الجاي. ضغط على F11 فأي وقت باش تدخل ولا تخرج من ملء الشاشة.",
+        "STARTUP_WINDOW_MODE_NORMAL": "آخر حجم ديال النافذة",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "مكبّرة",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "ملء الشاشة",
         "SHOW_CAPTIONS_DESCRIPTION": "وري ولا خفي الترجمة افتراضياً",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "وري شريط التشغيل الحالي",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "خلي شريط حالة المشغل الخارجي ظاهر في الأسفل ديال مساحة العمل على سطح المكتب.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "MPV المدمج: محرك نسخ الإطارات (تجريبي)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "الفيديو كيترسم على لوحة التطبيق باش القوائم والحوارات يبانو فوقو.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "غادي يخدم من بعد ما تعاود تشغل التطبيق.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "خيارات زايدة لـ MPV المدمج",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "خيارات libmpv متقدمة للمشغل المدمج، زوج key=value واحد فكل سطر (بلا -- فالبداية). كيتطبقو فكل محرك من بعد الخيارات المدمجة، وكيبداو يخدمو ملي تبدا جلسة MPV المدمج الجاية.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "مثال: hwdec=auto-safe. الخيارات اللي كيعتمد عليها التضمين بنفسو (wid، vo، input-ipc-server، …) كيتّرفضو.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "ماشي سطر بصيغة key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "هاد الخيارات ما يمكنش تتبدل فالمشغل المدمج: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "عاود الاتصال أوتوماتيكياً بالبث اللي تقطع",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "ملي شي بث خدام كيتقطع، المشغل المدمج كيعاود يشرجو بفواصل كتزيد شوية بشوية، حتى 6 محاولات، قبل ما يوقف. البث اللي عمرو ما بدا كيبقى محتاج تحاول مرة أخرى يدوياً.",
         "VOD_AUTO_FAILOVER": "بدل المصدر أوتوماتيكياً عند خطأ فالتشغيل",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "ملي شي فيلم ما يتشغلش وكان نفس الفيلم كاين ف قائمة تشغيل أخرى، التطبيق كيبدل ليها أوتوماتيكياً وكيحافظ على التوقيت. معطل افتراضياً؛ التبديل ديما كيتعلن حيت مصدر آخر يمكن يكون فيه دوبلاج مختلف."
     },
@@ -515,6 +527,8 @@
             "RETRY": "حاول مرة أخرى",
             "STALLED": "هاد البث كياخد وقت كثر من المتوقع باش يبدا.",
             "PLAYBACK_FAILED": "فشل التشغيل بـ MPV المدمج.",
+            "RECONNECTING": "تقطع الاتصال. كنعاودو الاتصال… المحاولة {{attempt}} من {{maxAttempts}}",
+            "STREAM_ENDED": "البث المباشر سالا.",
             "CHECKING_SUPPORT": "جاري التحقق من دعم MPV المدمج...",
             "NOT_AVAILABLE": "MPV المدمج ما متوفرش فهاد البيئة.",
             "LOADING_STREAM": "جاري تشريج البث…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "حل البحث العام",
                 "OPEN_RECENTLY_VIEWED": "حل المتشافين مؤخراً",
                 "SUBMIT_SHELL_SEARCH": "رسل بحث مساحة العمل",
+                "TOGGLE_WINDOW_FULLSCREEN": "بدل ملء الشاشة ديال نافذة التطبيق",
                 "TOGGLE_SIDEBAR": "بدل عرض الشريط الجانبي",
                 "M3U_CHANNEL_NUMBER": "اختار قناة M3U بالرقم",
                 "PLAY_PAUSE": "شغل ولا وقف مؤقتاً تشغيل MPV المدمج",
diff --git a/apps/web/src/assets/i18n/by.json b/apps/web/src/assets/i18n/by.json
index 4337ae612..98f0243f8 100644
--- a/apps/web/src/assets/i18n/by.json
+++ b/apps/web/src/assets/i18n/by.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Выберыце, ці адкрывае IPTVnator першы даступны выгляд працоўнай прасторы, ці аднаўляе ваш апошні выгляд на ўзроўні раздзела. Першы выгляд азначае «Панэль», калі ўключана, інакш «Крыніцы».",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Першы даступны выгляд",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Аднавіць апошні выгляд",
+        "STARTUP_WINDOW_MODE": "Акно пры запуску",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Выберыце, як адкрываецца акно праграмы: у апошнім памеры, разгорнутым ці на ўвесь экран. Ужываецца пры наступным запуску. Націсніце F11 у любы момант, каб увайсці ў поўнаэкранны рэжым або выйсці з яго.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Апошні памер акна",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Разгорнутае",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "На ўвесь экран",
         "SHOW_CAPTIONS_DESCRIPTION": "Паказаць або схаваць субтытры па змаўчанні.",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Паказаць ніжнюю панэль прайгравання",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Пакідаць панэль стану знешняга прайгравальніка бачнай унізе працоўнай прасторы на дэсктопе.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: рухавік frame-copy (эксперыментальна)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Відэа малюецца на канвасе праграмы, таму меню і дыялогі паказваюцца па-над ім.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Пачне дзейнічаць пасля перазапуску праграмы.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Дадатковыя параметры ўбудаванага MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Пашыраныя параметры libmpv для ўбудаванага прайгравальніка, адна пара key=value на радок (без -- у пачатку). Яны прымяняюцца ў кожным рухавіку пасля ўбудаваных параметраў і пачынаюць дзейнічаць пры запуску наступнага сеанса ўбудаванага MPV.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Прыклад: hwdec=auto-safe. Параметры, ад якіх залежыць само ўбудаванне (wid, vo, input-ipc-server, …), адхіляюцца.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Не радок выгляду key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Гэтыя параметры нельга змяніць для ўбудаванага прайгравальніка: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Аўтаматычна перападключацца да абарваных патокаў",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Калі паток, які прайграецца, абрываецца, убудаваны прайгравальнік перазагружае яго з усё большымі паўзамі, да 6 спроб, перш чым спыніцца. Паток, які так і не запусціўся, па-ранейшаму патрабуе ручнога «Паўтарыць».",
         "VOD_AUTO_FAILOVER": "Аўтапераключэнне крыніцы пры памылцы прайгравання",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Калі фільм не прайграецца, а той жа фільм ёсць у іншым плэйлісце, аўтаматычна пераключацца на яго, захоўваючы пазіцыю прайгравання. Па змаўчанні выключана; пра пераключэнне заўсёды паведамляецца, бо ў іншай крыніцы можа быць іншая агучка."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Паўтарыць",
             "STALLED": "Гэты паток запускаецца даўжэй, чым чакалася.",
             "PLAYBACK_FAILED": "Не ўдалося прайграць праз убудаваны MPV.",
+            "RECONNECTING": "Злучэнне страчана. Перападключэнне… спроба {{attempt}} з {{maxAttempts}}",
+            "STREAM_ENDED": "Прамая трансляцыя скончылася.",
             "CHECKING_SUPPORT": "Праверка падтрымкі ўбудаванага MPV...",
             "NOT_AVAILABLE": "Убудаваны MPV недаступны ў гэтым асяроддзі.",
             "LOADING_STREAM": "Загрузка патоку…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Адкрыць глабальны пошук",
                 "OPEN_RECENTLY_VIEWED": "Адкрыць нядаўна прагледжанае",
                 "SUBMIT_SHELL_SEARCH": "Выканаць пошук у працоўнай вобласці",
+                "TOGGLE_WINDOW_FULLSCREEN": "Пераключыць поўнаэкранны рэжым акна праграмы",
                 "TOGGLE_SIDEBAR": "Пераключыць бакавую панэль",
                 "M3U_CHANNEL_NUMBER": "Выбраць M3U-канал па нумары",
                 "PLAY_PAUSE": "Прайграць або прыпыніць Embedded MPV",
diff --git a/apps/web/src/assets/i18n/de.json b/apps/web/src/assets/i18n/de.json
index 7a8b4e445..f9d0f2981 100644
--- a/apps/web/src/assets/i18n/de.json
+++ b/apps/web/src/assets/i18n/de.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Legen Sie fest, ob IPTVnator die erste verfügbare Workspace-Ansicht oder Ihre zuletzt geöffnete Abschnittsansicht startet. Erste Ansicht bedeutet Dashboard, wenn aktiviert, sonst Quellen.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Erste verfügbare Ansicht",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Letzte Ansicht wiederherstellen",
+        "STARTUP_WINDOW_MODE": "Fenster beim Start",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Legen Sie fest, wie das Desktop-Fenster geöffnet wird: in der letzten Größe, maximiert oder im Vollbild. Gilt ab dem nächsten Start. Mit F11 können Sie das Vollbild jederzeit aktivieren oder verlassen.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Letzte Fenstergröße",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Maximiert",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Vollbild",
         "SHOW_CAPTIONS_DESCRIPTION": "Untertitel standardmäßig ein- oder ausblenden",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Now-Playing-Fußleiste anzeigen",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Zeigt die Statusleiste für externe Player unten im Arbeitsbereich auf dem Desktop an.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: Frame-Copy-Engine (experimentell)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Das Video wird auf die App-Leinwand gerendert, sodass Menüs und Dialoge darüber liegen.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Wird nach einem Neustart der App wirksam.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Zusätzliche Optionen für eingebettetes MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Erweiterte libmpv-Optionen für den eingebetteten Player, ein key=value-Paar pro Zeile (ohne vorangestelltes --). Sie gelten für jede Engine, werden nach den integrierten Optionen angewendet und werden wirksam, sobald die nächste Sitzung mit eingebettetem MPV startet.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Beispiel: hwdec=auto-safe. Optionen, auf die der eingebettete Player selbst angewiesen ist (wid, vo, input-ipc-server, …), werden abgelehnt.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Keine key=value-Zeile: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Diese Optionen können für den eingebetteten Player nicht geändert werden: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Unterbrochene Streams automatisch neu verbinden",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Wenn ein laufender Stream unterbrochen wird, lädt der eingebettete Player ihn in bis zu 6 Versuchen mit immer längeren Wartezeiten neu, bevor er aufgibt. Ein Stream, der gar nicht erst gestartet ist, erfordert weiterhin ein manuelles „Erneut versuchen“.",
         "VOD_AUTO_FAILOVER": "Quelle bei Wiedergabefehler automatisch wechseln",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Wenn sich ein Film nicht abspielen lässt und derselbe Film in einer anderen Playlist vorhanden ist, wird automatisch dorthin gewechselt und die Wiedergabeposition beibehalten. Standardmäßig deaktiviert; der Wechsel wird immer angekündigt, da eine andere Quelle eine andere Synchronfassung enthalten kann."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Erneut versuchen",
             "STALLED": "Der Start dieses Streams dauert länger als erwartet.",
             "PLAYBACK_FAILED": "Die Wiedergabe mit eingebettetem MPV ist fehlgeschlagen.",
+            "RECONNECTING": "Verbindung unterbrochen. Verbindung wird wiederhergestellt… Versuch {{attempt}} von {{maxAttempts}}",
+            "STREAM_ENDED": "Der Live-Stream ist beendet.",
             "CHECKING_SUPPORT": "Unterstützung für eingebettetes MPV wird geprüft...",
             "NOT_AVAILABLE": "Eingebettetes MPV ist in dieser Umgebung nicht verfügbar.",
             "LOADING_STREAM": "Stream wird geladen…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Globale Suche öffnen",
                 "OPEN_RECENTLY_VIEWED": "Kürzlich angesehene Elemente öffnen",
                 "SUBMIT_SHELL_SEARCH": "Arbeitsbereichssuche absenden",
+                "TOGGLE_WINDOW_FULLSCREEN": "Vollbild für das App-Fenster umschalten",
                 "TOGGLE_SIDEBAR": "Seitenleiste umschalten",
                 "M3U_CHANNEL_NUMBER": "M3U-Kanal per Nummer auswählen",
                 "PLAY_PAUSE": "Eingebettete MPV-Wiedergabe starten oder pausieren",
diff --git a/apps/web/src/assets/i18n/el.json b/apps/web/src/assets/i18n/el.json
index e0b91103a..80a7a2d22 100644
--- a/apps/web/src/assets/i18n/el.json
+++ b/apps/web/src/assets/i18n/el.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Επιλέξτε αν το IPTVnator ανοίγει την πρώτη διαθέσιμη προβολή του χώρου εργασίας ή επαναφέρει την τελευταία προβολή σας. Πρώτη προβολή σημαίνει ο πίνακας ελέγχου, όταν είναι ενεργοποιημένος, διαφορετικά οι Πηγές.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Πρώτη διαθέσιμη προβολή",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Επαναφορά τελευταίας προβολής",
+        "STARTUP_WINDOW_MODE": "Παράθυρο κατά την εκκίνηση",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Επιλέξτε πώς ανοίγει το παράθυρο της εφαρμογής: στο τελευταίο του μέγεθος, μεγιστοποιημένο ή σε πλήρη οθόνη. Ισχύει από την επόμενη εκκίνηση. Πατήστε F11 οποιαδήποτε στιγμή για είσοδο ή έξοδο από την πλήρη οθόνη.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Τελευταίο μέγεθος παραθύρου",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Μεγιστοποιημένο",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Πλήρης οθόνη",
         "SHOW_CAPTIONS_DESCRIPTION": "Εμφάνιση ή απόκρυψη υποτίτλων από προεπιλογή",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Εμφάνιση υποσέλιδου αναπαραγωγής",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Διατηρήστε ορατή τη γραμμή κατάστασης του εξωτερικού προγράμματος αναπαραγωγής στο κάτω μέρος του χώρου εργασίας στον υπολογιστή.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: μηχανή frame-copy (πειραματικό)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Το βίντεο σχεδιάζεται στον καμβά της εφαρμογής, ώστε τα μενού και τα παράθυρα διαλόγου να εμφανίζονται από πάνω του.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Ισχύει μετά την επανεκκίνηση της εφαρμογής.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Πρόσθετες επιλογές ενσωματωμένου MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Προηγμένες επιλογές libmpv για το ενσωματωμένο πρόγραμμα αναπαραγωγής, ένα ζεύγος key=value ανά γραμμή (χωρίς -- στην αρχή). Εφαρμόζονται σε κάθε μηχανή μετά τις ενσωματωμένες επιλογές και ισχύουν από την επόμενη συνεδρία του ενσωματωμένου MPV.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Παράδειγμα: hwdec=auto-safe. Οι επιλογές από τις οποίες εξαρτάται η ίδια η ενσωμάτωση (wid, vo, input-ipc-server, …) απορρίπτονται.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Δεν είναι γραμμή key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Αυτές οι επιλογές δεν μπορούν να αλλάξουν για το ενσωματωμένο πρόγραμμα αναπαραγωγής: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Αυτόματη επανασύνδεση σε ροές που διακόπηκαν",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Όταν μια ροή που αναπαράγεται διακοπεί, το ενσωματωμένο πρόγραμμα αναπαραγωγής τη φορτώνει ξανά με αυξανόμενες καθυστερήσεις, έως 6 προσπάθειες, πριν τα παρατήσει. Μια ροή που δεν ξεκίνησε ποτέ εξακολουθεί να χρειάζεται χειροκίνητη Επανάληψη.",
         "VOD_AUTO_FAILOVER": "Αυτόματη αλλαγή πηγής σε σφάλμα αναπαραγωγής",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Όταν μια ταινία δεν μπορεί να αναπαραχθεί και η ίδια ταινία υπάρχει σε άλλη λίστα αναπαραγωγής, γίνεται αυτόματη μετάβαση σε αυτήν με διατήρηση της θέσης αναπαραγωγής. Απενεργοποιημένο από προεπιλογή· η αλλαγή ανακοινώνεται πάντα, επειδή μια άλλη πηγή μπορεί να έχει διαφορετική μεταγλώττιση."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Επανάληψη",
             "STALLED": "Η έναρξη αυτής της ροής καθυστερεί περισσότερο από το αναμενόμενο.",
             "PLAYBACK_FAILED": "Η αναπαραγωγή με το ενσωματωμένο MPV απέτυχε.",
+            "RECONNECTING": "Η σύνδεση χάθηκε. Επανασύνδεση… προσπάθεια {{attempt}} από {{maxAttempts}}",
+            "STREAM_ENDED": "Η ζωντανή ροή τερματίστηκε.",
             "CHECKING_SUPPORT": "Έλεγχος υποστήριξης ενσωματωμένου MPV...",
             "NOT_AVAILABLE": "Το ενσωματωμένο MPV δεν είναι διαθέσιμο σε αυτό το περιβάλλον.",
             "LOADING_STREAM": "Φόρτωση ροής…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Άνοιγμα καθολικής αναζήτησης",
                 "OPEN_RECENTLY_VIEWED": "Άνοιγμα πρόσφατων προβολών",
                 "SUBMIT_SHELL_SEARCH": "Υποβολή αναζήτησης χώρου εργασίας",
+                "TOGGLE_WINDOW_FULLSCREEN": "Εναλλαγή πλήρους οθόνης παραθύρου εφαρμογής",
                 "TOGGLE_SIDEBAR": "Εναλλαγή πλαϊνής μπάρας",
                 "M3U_CHANNEL_NUMBER": "Επιλογή καναλιού M3U με αριθμό",
                 "PLAY_PAUSE": "Αναπαραγωγή ή παύση ενσωματωμένου MPV",
diff --git a/apps/web/src/assets/i18n/en.json b/apps/web/src/assets/i18n/en.json
index f871c1abf..999f63abc 100644
--- a/apps/web/src/assets/i18n/en.json
+++ b/apps/web/src/assets/i18n/en.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Choose whether IPTVnator opens the first available workspace view or restores your last section-level view. First view means Dashboard when enabled, otherwise Sources.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "First available view",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Restore last view",
+        "STARTUP_WINDOW_MODE": "Window on startup",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Choose how the desktop window opens: at its last size, maximized, or fullscreen. Applies on the next launch. Press F11 at any time to enter or leave fullscreen.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Last window size",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Maximized",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Fullscreen",
         "SHOW_CAPTIONS_DESCRIPTION": "Show or hide subtitles by default",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Show now playing footer",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Keep the external-player status bar visible at the bottom of the workspace on desktop.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: frame-copy engine (experimental)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Render video onto the app canvas so menus and dialogs stack above it.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Takes effect after restarting the app.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Extra embedded MPV options",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Advanced libmpv options for the embedded player, one key=value pair per line (no leading --). They apply on every engine after the built-in options and take effect when the next embedded MPV session starts.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Example: hwdec=auto-safe. Options the embed itself depends on (wid, vo, input-ipc-server, …) are refused.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Not a key=value line: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "These options cannot be changed for the embedded player: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Reconnect dropped streams automatically",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "When a playing stream drops, the embedded player reloads it with increasing delays, up to 6 attempts, before giving up. A stream that never started still needs a manual Retry.",
         "VOD_AUTO_FAILOVER": "Auto-switch source on playback error",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "When a movie fails to play and the same film exists in another playlist, switch to it automatically and keep the timecode. Off by default; the switch is always announced because another source can carry a different dub."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Retry",
             "STALLED": "This stream is taking longer than expected to start.",
             "PLAYBACK_FAILED": "Embedded MPV playback failed.",
+            "RECONNECTING": "Connection lost. Reconnecting… attempt {{attempt}} of {{maxAttempts}}",
+            "STREAM_ENDED": "The live stream ended.",
             "CHECKING_SUPPORT": "Checking embedded MPV support...",
             "NOT_AVAILABLE": "Embedded MPV is not available in this environment.",
             "LOADING_STREAM": "Loading stream…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Open global search",
                 "OPEN_RECENTLY_VIEWED": "Open recently viewed",
                 "SUBMIT_SHELL_SEARCH": "Submit workspace search",
+                "TOGGLE_WINDOW_FULLSCREEN": "Toggle app window fullscreen",
                 "TOGGLE_SIDEBAR": "Toggle sidebar",
                 "M3U_CHANNEL_NUMBER": "Select M3U channel by number",
                 "PLAY_PAUSE": "Play or pause embedded MPV playback",
diff --git a/apps/web/src/assets/i18n/es.json b/apps/web/src/assets/i18n/es.json
index 6d8c3673b..f33fb9fd1 100644
--- a/apps/web/src/assets/i18n/es.json
+++ b/apps/web/src/assets/i18n/es.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Elige si IPTVnator abre la primera vista disponible del espacio de trabajo o restaura la última vista a nivel de sección. Primera vista significa Panel cuando está activado, de lo contrario Fuentes.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Primera vista disponible",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Restaurar última vista",
+        "STARTUP_WINDOW_MODE": "Ventana al iniciar",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Elige cómo se abre la ventana de escritorio: con su último tamaño, maximizada o a pantalla completa. Se aplica en el próximo inicio. Pulsa F11 en cualquier momento para entrar o salir de la pantalla completa.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Último tamaño de ventana",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Maximizada",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Pantalla completa",
         "SHOW_CAPTIONS_DESCRIPTION": "Mostrar u ocultar subtítulos por defecto",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Mostrar pie de reproducción actual",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Mantén visible la barra de estado del reproductor externo en la parte inferior del espacio de trabajo en escritorio.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: motor frame-copy (experimental)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "El vídeo se dibuja en el lienzo de la aplicación, de modo que los menús y diálogos quedan encima.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Se aplica tras reiniciar la aplicación.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Opciones adicionales de MPV integrado",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Opciones avanzadas de libmpv para el reproductor integrado, un par key=value por línea (sin -- al inicio). Se aplican en todos los motores después de las opciones integradas y surten efecto al iniciarse la siguiente sesión de MPV integrado.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Ejemplo: hwdec=auto-safe. Las opciones de las que depende el propio reproductor integrado (wid, vo, input-ipc-server, …) se rechazan.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Sin formato key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Estas opciones no se pueden cambiar para el reproductor integrado: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Reconectar automáticamente los streams interrumpidos",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Cuando un stream en reproducción se interrumpe, el reproductor integrado lo vuelve a cargar con intervalos cada vez más largos, hasta 6 intentos, antes de desistir. Un stream que nunca llegó a iniciarse sigue necesitando un Reintentar manual.",
         "VOD_AUTO_FAILOVER": "Cambiar de fuente automáticamente al fallar la reproducción",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Cuando una película no se puede reproducir y la misma película está en otra lista, cambia a ella automáticamente y conserva la posición de reproducción. Desactivado de forma predeterminada; el cambio siempre se avisa, porque otra fuente puede tener un doblaje distinto."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Reintentar",
             "STALLED": "Este stream está tardando más de lo esperado en iniciarse.",
             "PLAYBACK_FAILED": "Falló la reproducción de MPV integrado.",
+            "RECONNECTING": "Conexión perdida. Reconectando… intento {{attempt}} de {{maxAttempts}}",
+            "STREAM_ENDED": "La transmisión en vivo terminó.",
             "CHECKING_SUPPORT": "Comprobando compatibilidad con MPV integrado...",
             "NOT_AVAILABLE": "MPV integrado no está disponible en este entorno.",
             "LOADING_STREAM": "Cargando stream…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Abrir búsqueda global",
                 "OPEN_RECENTLY_VIEWED": "Abrir vistos recientemente",
                 "SUBMIT_SHELL_SEARCH": "Enviar búsqueda del espacio de trabajo",
+                "TOGGLE_WINDOW_FULLSCREEN": "Alternar pantalla completa de la ventana de la aplicación",
                 "TOGGLE_SIDEBAR": "Mostrar u ocultar barra lateral",
                 "M3U_CHANNEL_NUMBER": "Seleccionar canal M3U por número",
                 "PLAY_PAUSE": "Reproducir o pausar MPV integrado",
diff --git a/apps/web/src/assets/i18n/fr.json b/apps/web/src/assets/i18n/fr.json
index 1758dbd1d..ef39020bf 100644
--- a/apps/web/src/assets/i18n/fr.json
+++ b/apps/web/src/assets/i18n/fr.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Choisissez si IPTVnator ouvre la première vue disponible de l'espace de travail ou restaure votre dernière vue de section. Première vue signifie Tableau de bord lorsqu'il est activé, sinon Sources.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Première vue disponible",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Restaurer la dernière vue",
+        "STARTUP_WINDOW_MODE": "Fenêtre au démarrage",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Choisissez comment la fenêtre de bureau s'ouvre : à sa dernière taille, agrandie ou en plein écran. S'applique au prochain démarrage. Appuyez sur F11 à tout moment pour passer en plein écran ou le quitter.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Dernière taille de fenêtre",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Agrandie",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Plein écran",
         "SHOW_CAPTIONS_DESCRIPTION": "Afficher ou masquer les sous-titres par défaut",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Afficher le pied de page de lecture en cours",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Garde la barre d'état du lecteur externe visible en bas de l'espace de travail sur ordinateur.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV : moteur frame-copy (expérimental)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "La vidéo est rendue sur le canevas de l'application, les menus et boîtes de dialogue s'affichent donc au-dessus.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Prend effet après le redémarrage de l'application.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Options MPV intégré supplémentaires",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Options libmpv avancées pour le lecteur intégré, une paire key=value par ligne (sans -- au début). Elles s'appliquent sur tous les moteurs après les options intégrées et prennent effet au démarrage de la prochaine session MPV intégrée.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Exemple : hwdec=auto-safe. Les options dont dépend l'intégration (wid, vo, input-ipc-server, …) sont refusées.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Format key=value non respecté : {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Ces options ne peuvent pas être modifiées pour le lecteur intégré : {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Reconnecter automatiquement les flux interrompus",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Lorsqu'un flux en cours de lecture est interrompu, le lecteur intégré le recharge avec des délais croissants, jusqu'à 6 tentatives, avant d'abandonner. Un flux qui n'a jamais démarré doit toujours être relancé manuellement avec « Réessayer ».",
         "VOD_AUTO_FAILOVER": "Changer de source automatiquement en cas d'erreur de lecture",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Lorsqu'un film ne parvient pas à démarrer et que le même film existe dans une autre liste de lecture, bascule automatiquement vers celle-ci en conservant la position de lecture. Désactivé par défaut ; le changement est toujours annoncé, car une autre source peut proposer un doublage différent."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Réessayer",
             "STALLED": "Ce flux met plus de temps que prévu à démarrer.",
             "PLAYBACK_FAILED": "Échec de la lecture avec MPV intégré.",
+            "RECONNECTING": "Connexion perdue. Reconnexion… tentative {{attempt}} sur {{maxAttempts}}",
+            "STREAM_ENDED": "La diffusion en direct est terminée.",
             "CHECKING_SUPPORT": "Vérification de la prise en charge de MPV intégré...",
             "NOT_AVAILABLE": "MPV intégré n'est pas disponible dans cet environnement.",
             "LOADING_STREAM": "Chargement du flux…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Ouvrir la recherche globale",
                 "OPEN_RECENTLY_VIEWED": "Ouvrir les éléments récemment consultés",
                 "SUBMIT_SHELL_SEARCH": "Lancer la recherche dans l’espace de travail",
+                "TOGGLE_WINDOW_FULLSCREEN": "Activer ou quitter le plein écran de la fenêtre",
                 "TOGGLE_SIDEBAR": "Afficher ou masquer la barre latérale",
                 "M3U_CHANNEL_NUMBER": "Sélectionner une chaîne M3U par numéro",
                 "PLAY_PAUSE": "Lire ou mettre en pause la lecture MPV intégrée",
diff --git a/apps/web/src/assets/i18n/hu.json b/apps/web/src/assets/i18n/hu.json
index f9ccebef7..5ef80aa78 100644
--- a/apps/web/src/assets/i18n/hu.json
+++ b/apps/web/src/assets/i18n/hu.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Válassza ki, hogy induláskor az első elérhető munkaterület-nézet nyíljon meg, vagy az IPTVnator állítsa vissza a legutóbb használt szakasznézetet. Az első nézet bekapcsolt Vezérlőpult esetén a Vezérlőpult, egyébként a Források.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Első elérhető nézet",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Legutóbbi nézet visszaállítása",
+        "STARTUP_WINDOW_MODE": "Ablak indításkor",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Válassza ki, hogyan nyíljon meg az asztali ablak: a legutóbbi méretben, maximalizálva vagy teljes képernyőn. A következő indítástól érvényes. Az F11 billentyűvel bármikor be- vagy kiléphet a teljes képernyős módból.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Legutóbbi ablakméret",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Maximalizált",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Teljes képernyő",
         "SHOW_CAPTIONS_DESCRIPTION": "Feliratok alapértelmezett megjelenítése vagy elrejtése",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Aktuális lejátszás sávjának megjelenítése",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Az asztali alkalmazásban maradjon látható a munkaterület alján a külső lejátszó állapotsávja.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Beágyazott MPV: képkocka-másolásos megjelenítés (kísérleti)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "A videó megjelenítése az alkalmazás rajzfelületén, hogy a menük és párbeszédpanelek fölötte jelenhessenek meg.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Az alkalmazás újraindítása után lép érvénybe.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "További beágyazott MPV-beállítások",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Speciális libmpv-beállítások a beágyazott lejátszóhoz, soronként egy key=value pár (kezdő -- nélkül). Minden megjelenítőmotorra érvényesek, a beépített beállítások után kerülnek alkalmazásra, és a következő beágyazott MPV-munkamenet indításakor lépnek érvénybe.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Példa: hwdec=auto-safe. A beágyazás működéséhez szükséges beállításokat (wid, vo, input-ipc-server, …) az alkalmazás elutasítja.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Nem key=value formátumú sor: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Ezek a beállítások nem módosíthatók a beágyazott lejátszónál: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Megszakadt adatfolyamok automatikus újracsatlakoztatása",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Ha egy lejátszás alatt álló adatfolyam megszakad, a beágyazott lejátszó egyre hosszabb várakozással, legfeljebb 6 próbálkozással tölti be újra, mielőtt feladná. Az el sem indult adatfolyamhoz továbbra is kézi újrapróbálkozás szükséges.",
         "VOD_AUTO_FAILOVER": "Automatikus forrásváltás lejátszási hiba esetén",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Ha egy film lejátszása meghiúsul, és ugyanaz a film egy másik lejátszási listában is megtalálható, az alkalmazás automatikusan átvált rá, és megőrzi a lejátszási pozíciót. Alapértelmezés szerint kikapcsolva; a váltásról mindig értesítés jelenik meg, mert egy másik forráson eltérő szinkron lehet."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Újrapróbálkozás",
             "STALLED": "Az adatfolyam indítása a vártnál hosszabb ideig tart.",
             "PLAYBACK_FAILED": "Nem sikerült lejátszani a tartalmat a beágyazott MPV-vel.",
+            "RECONNECTING": "A kapcsolat megszakadt. Újracsatlakozás… próbálkozás: {{attempt}}/{{maxAttempts}}",
+            "STREAM_ENDED": "Az élő adás véget ért.",
             "CHECKING_SUPPORT": "A beágyazott MPV támogatásának ellenőrzése…",
             "NOT_AVAILABLE": "A beágyazott MPV ebben a környezetben nem érhető el.",
             "LOADING_STREAM": "Adatfolyam betöltése…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Globális keresés megnyitása",
                 "OPEN_RECENTLY_VIEWED": "Legutóbbi megtekintések megnyitása",
                 "SUBMIT_SHELL_SEARCH": "Munkaterületi keresés indítása",
+                "TOGGLE_WINDOW_FULLSCREEN": "Az alkalmazásablak teljes képernyős módjának be- vagy kikapcsolása",
                 "TOGGLE_SIDEBAR": "Oldalsáv megjelenítése vagy elrejtése",
                 "M3U_CHANNEL_NUMBER": "M3U-csatorna kiválasztása a számának beírásával",
                 "PLAY_PAUSE": "A beágyazott MPV lejátszásának indítása vagy szüneteltetése",
diff --git a/apps/web/src/assets/i18n/it.json b/apps/web/src/assets/i18n/it.json
index c388169d5..47e81bdb9 100644
--- a/apps/web/src/assets/i18n/it.json
+++ b/apps/web/src/assets/i18n/it.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Scegli se IPTVnator apre la prima vista dell'area di lavoro disponibile o ripristina l'ultima vista a livello di sezione. La prima vista è la dashboard se attiva, altrimenti Sorgenti.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Prima vista disponibile",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Ripristina ultima vista",
+        "STARTUP_WINDOW_MODE": "Finestra all'avvio",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Scegli come si apre la finestra dell'app: con l'ultima dimensione, ingrandita o a schermo intero. Si applica al prossimo avvio. Premi F11 in qualsiasi momento per entrare o uscire dallo schermo intero.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Ultima dimensione della finestra",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Ingrandita",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Schermo intero",
         "SHOW_CAPTIONS_DESCRIPTION": "Visualizza/nascondi i sottotitoli per impostazione predefinita",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Mostra footer In riproduzione",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Mantieni visibile la barra di stato del lettore esterno in fondo all'area di lavoro su desktop.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: motore frame-copy (sperimentale)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Il video viene disegnato sul canvas dell'app, così menu e finestre di dialogo appaiono sopra di esso.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Ha effetto dopo il riavvio dell'app.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Opzioni aggiuntive per MPV integrato",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Opzioni avanzate di libmpv per il lettore integrato, una coppia key=value per riga (senza -- iniziale). Si applicano a tutti i motori dopo le opzioni integrate dell'app e hanno effetto all'avvio della prossima sessione di MPV integrato.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Esempio: hwdec=auto-safe. Le opzioni da cui dipende l'integrazione stessa (wid, vo, input-ipc-server, …) vengono rifiutate.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Non in formato key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Queste opzioni non possono essere modificate per il lettore integrato: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Riconnetti automaticamente gli stream interrotti",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Quando uno stream in riproduzione si interrompe, il lettore integrato lo ricarica a intervalli crescenti, fino a 6 tentativi, prima di rinunciare. Per uno stream che non è mai partito è comunque necessario premere Riprova manualmente.",
         "VOD_AUTO_FAILOVER": "Cambia sorgente automaticamente in caso di errore di riproduzione",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Quando la riproduzione di un film non riesce e lo stesso film è presente in un'altra playlist, l'app passa automaticamente a quella sorgente mantenendo la posizione di riproduzione. Disattivo per impostazione predefinita; il cambio viene sempre segnalato perché un'altra sorgente può avere un doppiaggio diverso."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Riprova",
             "STALLED": "L'avvio di questo stream sta richiedendo più tempo del previsto.",
             "PLAYBACK_FAILED": "Riproduzione con MPV integrato non riuscita.",
+            "RECONNECTING": "Connessione persa. Riconnessione in corso… tentativo {{attempt}} di {{maxAttempts}}",
+            "STREAM_ENDED": "Lo stream in diretta è terminato.",
             "CHECKING_SUPPORT": "Verifica del supporto per MPV integrato...",
             "NOT_AVAILABLE": "MPV integrato non è disponibile in questo ambiente.",
             "LOADING_STREAM": "Caricamento stream…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Apri ricerca globale",
                 "OPEN_RECENTLY_VIEWED": "Apri visti di recente",
                 "SUBMIT_SHELL_SEARCH": "Invia ricerca nell’area di lavoro",
+                "TOGGLE_WINDOW_FULLSCREEN": "Attiva/disattiva schermo intero della finestra",
                 "TOGGLE_SIDEBAR": "Mostra/nascondi barra laterale",
                 "M3U_CHANNEL_NUMBER": "Seleziona canale M3U per numero",
                 "PLAY_PAUSE": "Riproduci o metti in pausa MPV integrato",
diff --git a/apps/web/src/assets/i18n/ja.json b/apps/web/src/assets/i18n/ja.json
index 4f928da30..38b623843 100644
--- a/apps/web/src/assets/i18n/ja.json
+++ b/apps/web/src/assets/i18n/ja.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "IPTVnatorを起動したときに最初に利用可能なワークスペースビューを開くか、最後に表示していたセクションを復元するかを選択します。「最初のビュー」は、ダッシュボードが有効な場合はダッシュボード、無効な場合はソースを意味します。",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "最初に利用可能なビュー",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "最後のビューを復元",
+        "STARTUP_WINDOW_MODE": "起動時のウィンドウ",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "デスクトップウィンドウの開き方を選択します：前回のサイズ、最大化、または全画面。次回の起動時に適用されます。F11キーでいつでも全画面表示を切り替えられます。",
+        "STARTUP_WINDOW_MODE_NORMAL": "前回のウィンドウサイズ",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "最大化",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "全画面",
         "SHOW_CAPTIONS_DESCRIPTION": "デフォルトで字幕を表示/非表示",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "再生中フッターを表示",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "デスクトップでワークスペース下部に外部プレーヤーのステータスバーを表示し続けます。",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "埋め込みMPV：フレームコピーエンジン（実験的）",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "映像をアプリのキャンバスに描画するため、メニューやダイアログをその上に表示できます。",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "アプリの再起動後に有効になります。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "埋め込みMPVの追加オプション",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "埋め込みプレーヤー向けの高度な libmpv オプションです。1 行に 1 つの key=value ペアを入力します（先頭の -- は不要）。すべてのエンジンで組み込みオプションの後に適用され、次に埋め込みMPVのセッションを開始したときに有効になります。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "例: hwdec=auto-safe。埋め込み自体が依存するオプション（wid、vo、input-ipc-server など）は拒否されます。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "key=value 形式の行ではありません: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "埋め込みプレーヤーでは次のオプションを変更できません: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "切断されたストリームに自動的に再接続",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "再生中のストリームが切断されると、埋め込みプレーヤーは間隔を延ばしながら最大 6 回まで再読み込みを試み、その後あきらめます。一度も開始しなかったストリームには、引き続き手動の再試行が必要です。",
         "VOD_AUTO_FAILOVER": "再生エラー時にソースを自動切り替え",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "映画の再生に失敗したとき、同じ作品が別のプレイリストにもある場合は自動的にそちらへ切り替え、再生位置を引き継ぎます。標準では無効です。別のソースでは吹き替えが異なる場合があるため、切り替え時は必ず通知されます。"
     },
@@ -515,6 +527,8 @@
             "RETRY": "再試行",
             "STALLED": "このストリームの開始に予想より時間がかかっています。",
             "PLAYBACK_FAILED": "組み込みMPVでの再生に失敗しました。",
+            "RECONNECTING": "接続が失われました。再接続中… 試行 {{attempt}} / {{maxAttempts}}",
+            "STREAM_ENDED": "ライブストリームが終了しました。",
             "CHECKING_SUPPORT": "組み込みMPVのサポートを確認中...",
             "NOT_AVAILABLE": "この環境では組み込みMPVは利用できません。",
             "LOADING_STREAM": "ストリームを読み込み中…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "グローバル検索を開く",
                 "OPEN_RECENTLY_VIEWED": "最近視聴した項目を開く",
                 "SUBMIT_SHELL_SEARCH": "ワークスペース検索を実行",
+                "TOGGLE_WINDOW_FULLSCREEN": "アプリウィンドウの全画面表示を切り替え",
                 "TOGGLE_SIDEBAR": "サイドバーを切り替え",
                 "M3U_CHANNEL_NUMBER": "番号で M3U チャンネルを選択",
                 "PLAY_PAUSE": "Embedded MPV の再生/一時停止",
diff --git a/apps/web/src/assets/i18n/ko.json b/apps/web/src/assets/i18n/ko.json
index 8225ffa64..58561539c 100644
--- a/apps/web/src/assets/i18n/ko.json
+++ b/apps/web/src/assets/i18n/ko.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "IPTVnator를 처음 시작할 때 첫 번째로 사용 가능한 작업 공간 화면을 열지, 마지막으로 본 섹션 화면을 복원할지 선택합니다. 첫 번째 화면은 활성화된 경우 대시보드, 그렇지 않으면 소스를 의미합니다.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "첫 번째로 사용 가능한 화면",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "마지막 화면 복원",
+        "STARTUP_WINDOW_MODE": "시작 시 창",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "데스크톱 창을 여는 방식을 선택합니다: 마지막 크기, 최대화 또는 전체 화면. 다음 실행부터 적용됩니다. 언제든지 F11 키를 눌러 전체 화면을 켜거나 끌 수 있습니다.",
+        "STARTUP_WINDOW_MODE_NORMAL": "마지막 창 크기",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "최대화",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "전체 화면",
         "SHOW_CAPTIONS_DESCRIPTION": "기본적으로 자막 표시 또는 숨기기",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "지금 재생 중 표시줄 표시",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "데스크톱의 작업 공간 하단에 외부 플레이어 상태 표시줄을 계속 표시합니다.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "내장 MPV: 프레임 복사 엔진(실험적)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "비디오를 앱 캔버스에 렌더링하여 메뉴와 대화 상자가 그 위에 표시됩니다.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "앱을 다시 시작한 후 적용됩니다.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "내장 MPV 추가 옵션",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "내장 플레이어용 고급 libmpv 옵션입니다. 한 줄에 key=value 쌍 하나씩 입력하세요(앞의 -- 없이). 모든 엔진에서 기본 제공 옵션 다음에 적용되며, 다음 내장 MPV 세션이 시작될 때 반영됩니다.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "예: hwdec=auto-safe. 내장 기능 자체가 의존하는 옵션(wid, vo, input-ipc-server 등)은 거부됩니다.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "key=value 형식의 줄이 아닙니다: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "내장 플레이어에서는 다음 옵션을 변경할 수 없습니다: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "끊긴 스트림 자동 재연결",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "재생 중인 스트림이 끊기면 내장 플레이어가 점점 길어지는 간격으로 최대 6회까지 다시 불러온 뒤 포기합니다. 한 번도 시작되지 않은 스트림은 여전히 수동으로 다시 시도해야 합니다.",
         "VOD_AUTO_FAILOVER": "재생 오류 시 소스 자동 전환",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "영화 재생에 실패했을 때 같은 작품이 다른 재생목록에 있으면 재생 위치를 유지한 채 자동으로 전환합니다. 기본값은 꺼짐이며, 다른 소스는 더빙이 다를 수 있으므로 전환 시 항상 알려 드립니다."
     },
@@ -515,6 +527,8 @@
             "RETRY": "다시 시도",
             "STALLED": "이 스트림의 시작이 예상보다 오래 걸리고 있습니다.",
             "PLAYBACK_FAILED": "내장 MPV 재생에 실패했습니다.",
+            "RECONNECTING": "연결이 끊어졌습니다. 다시 연결하는 중… 시도 {{attempt}}/{{maxAttempts}}",
+            "STREAM_ENDED": "라이브 스트림이 종료되었습니다.",
             "CHECKING_SUPPORT": "내장 MPV 지원을 확인하는 중...",
             "NOT_AVAILABLE": "이 환경에서는 내장 MPV를 사용할 수 없습니다.",
             "LOADING_STREAM": "스트림을 불러오는 중…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "전역 검색 열기",
                 "OPEN_RECENTLY_VIEWED": "최근 시청 항목 열기",
                 "SUBMIT_SHELL_SEARCH": "워크스페이스 검색 실행",
+                "TOGGLE_WINDOW_FULLSCREEN": "앱 창 전체 화면 전환",
                 "TOGGLE_SIDEBAR": "사이드바 전환",
                 "M3U_CHANNEL_NUMBER": "번호로 M3U 채널 선택",
                 "PLAY_PAUSE": "Embedded MPV 재생 또는 일시정지",
diff --git a/apps/web/src/assets/i18n/nl.json b/apps/web/src/assets/i18n/nl.json
index eb0ab4f14..175f49ef2 100644
--- a/apps/web/src/assets/i18n/nl.json
+++ b/apps/web/src/assets/i18n/nl.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Kies of IPTVnator de eerste beschikbare werkruimteweergave opent of je laatste sectieweergave herstelt. Eerste weergave betekent het dashboard wanneer ingeschakeld, anders Bronnen.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Eerste beschikbare weergave",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Laatste weergave herstellen",
+        "STARTUP_WINDOW_MODE": "Venster bij opstarten",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Kies hoe het desktopvenster opent: op de laatste grootte, gemaximaliseerd of op volledig scherm. Geldt vanaf de volgende start. Druk op elk moment op F11 om volledig scherm in of uit te schakelen.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Laatste venstergrootte",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Gemaximaliseerd",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Volledig scherm",
         "SHOW_CAPTIONS_DESCRIPTION": "Standaard ondertiteling weergeven of verbergen",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Voettekst 'nu spelend' tonen",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Houd de statusbalk van de externe speler zichtbaar onderaan de werkruimte op desktop.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: frame-copy-engine (experimenteel)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "De video wordt op het app-canvas getekend zodat menu's en dialoogvensters erboven verschijnen.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Wordt van kracht na het herstarten van de app.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Extra opties voor Embedded MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Geavanceerde libmpv-opties voor de ingebedde speler, één key=value-paar per regel (zonder -- ervoor). Ze worden bij elke engine toegepast na de ingebouwde opties en worden van kracht wanneer de volgende Embedded MPV-sessie start.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Voorbeeld: hwdec=auto-safe. Opties waarvan de ingebedde speler zelf afhankelijk is (wid, vo, input-ipc-server, …) worden geweigerd.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Geen key=value-regel: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Deze opties kunnen niet worden gewijzigd voor de ingebedde speler: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Weggevallen streams automatisch opnieuw verbinden",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Wanneer een stream tijdens het afspelen wegvalt, laadt de ingebedde speler deze opnieuw met steeds langere tussenpozen, tot maximaal 6 pogingen, voordat hij het opgeeft. Voor een stream die nooit is gestart, blijft handmatig Opnieuw proberen nodig.",
         "VOD_AUTO_FAILOVER": "Automatisch van bron wisselen bij een afspeelfout",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Als een film niet kan worden afgespeeld en dezelfde film in een andere afspeellijst staat, wordt daar automatisch naar overgeschakeld met behoud van de afspeelpositie. Standaard uitgeschakeld; de wissel wordt altijd gemeld, omdat een andere bron een andere nasynchronisatie kan hebben."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Opnieuw proberen",
             "STALLED": "Deze stream doet er langer over dan verwacht om te starten.",
             "PLAYBACK_FAILED": "Afspelen via Embedded MPV is mislukt.",
+            "RECONNECTING": "Verbinding verbroken. Opnieuw verbinden… poging {{attempt}} van {{maxAttempts}}",
+            "STREAM_ENDED": "De live stream is beëindigd.",
             "CHECKING_SUPPORT": "Ondersteuning voor Embedded MPV controleren...",
             "NOT_AVAILABLE": "Embedded MPV is niet beschikbaar in deze omgeving.",
             "LOADING_STREAM": "Stream laden…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Globaal zoeken openen",
                 "OPEN_RECENTLY_VIEWED": "Recent bekeken openen",
                 "SUBMIT_SHELL_SEARCH": "Werkruimtezoekopdracht uitvoeren",
+                "TOGGLE_WINDOW_FULLSCREEN": "Volledig scherm voor het app-venster in- of uitschakelen",
                 "TOGGLE_SIDEBAR": "Zijbalk in- of uitschakelen",
                 "M3U_CHANNEL_NUMBER": "M3U-kanaal selecteren op nummer",
                 "PLAY_PAUSE": "Ingebedde MPV-weergave afspelen of pauzeren",
diff --git a/apps/web/src/assets/i18n/pl.json b/apps/web/src/assets/i18n/pl.json
index 62679ee51..f72af9cc9 100644
--- a/apps/web/src/assets/i18n/pl.json
+++ b/apps/web/src/assets/i18n/pl.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Wybierz, czy IPTVnator otwiera pierwszy dostępny widok obszaru roboczego, czy przywraca ostatni widok na poziomie sekcji. Pierwszy widok oznacza pulpit, jeśli jest włączony, w przeciwnym razie Źródła.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Pierwszy dostępny widok",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Przywróć ostatni widok",
+        "STARTUP_WINDOW_MODE": "Okno przy uruchomieniu",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Wybierz, jak otwiera się okno aplikacji: w ostatnim rozmiarze, zmaksymalizowane lub na pełnym ekranie. Obowiązuje od następnego uruchomienia. Naciśnij F11 w dowolnym momencie, aby włączyć lub wyłączyć pełny ekran.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Ostatni rozmiar okna",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Zmaksymalizowane",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Pełny ekran",
         "SHOW_CAPTIONS_DESCRIPTION": "Domyślnie pokaż lub ukryj napisy",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Pokaż stopkę „teraz odtwarzane”",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Pozostaw pasek statusu zewnętrznego odtwarzacza widoczny u dołu obszaru roboczego na komputerze.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: silnik frame-copy (eksperymentalny)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Wideo jest rysowane na kanwie aplikacji, dzięki czemu menu i okna dialogowe wyświetlają się nad nim.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Zacznie działać po ponownym uruchomieniu aplikacji.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Dodatkowe opcje wbudowanego MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Zaawansowane opcje libmpv dla wbudowanego odtwarzacza, jedna para key=value w każdym wierszu (bez początkowego --). Są stosowane w każdym silniku po opcjach wbudowanych i zaczynają działać przy uruchomieniu następnej sesji wbudowanego MPV.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Przykład: hwdec=auto-safe. Opcje, od których zależy samo osadzenie (wid, vo, input-ipc-server, …), są odrzucane.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "To nie jest wiersz key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Tych opcji nie można zmienić dla wbudowanego odtwarzacza: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Automatycznie wznawiaj przerwane strumienie",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Gdy odtwarzany strumień zostanie przerwany, wbudowany odtwarzacz wczytuje go ponownie z rosnącymi odstępami, maksymalnie 6 prób, zanim się podda. Strumień, który w ogóle się nie uruchomił, nadal wymaga ręcznego użycia „Spróbuj ponownie”.",
         "VOD_AUTO_FAILOVER": "Automatyczna zmiana źródła przy błędzie odtwarzania",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Gdy filmu nie da się odtworzyć, a ten sam tytuł jest dostępny na innej liście odtwarzania, przełącz się na nią automatycznie i zachowaj pozycję odtwarzania. Domyślnie wyłączone; zmiana jest zawsze sygnalizowana, ponieważ inne źródło może mieć inną wersję językową."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Spróbuj ponownie",
             "STALLED": "Uruchamianie tego strumienia trwa dłużej niż zwykle.",
             "PLAYBACK_FAILED": "Odtwarzanie we wbudowanym MPV nie powiodło się.",
+            "RECONNECTING": "Utracono połączenie. Ponowne łączenie… próba {{attempt}} z {{maxAttempts}}",
+            "STREAM_ENDED": "Transmisja na żywo zakończyła się.",
             "CHECKING_SUPPORT": "Sprawdzanie obsługi wbudowanego MPV...",
             "NOT_AVAILABLE": "Wbudowane MPV nie jest dostępne w tym środowisku.",
             "LOADING_STREAM": "Ładowanie strumienia…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Otwórz wyszukiwanie globalne",
                 "OPEN_RECENTLY_VIEWED": "Otwórz ostatnio oglądane",
                 "SUBMIT_SHELL_SEARCH": "Uruchom wyszukiwanie w obszarze roboczym",
+                "TOGGLE_WINDOW_FULLSCREEN": "Przełącz pełny ekran okna aplikacji",
                 "TOGGLE_SIDEBAR": "Przełącz pasek boczny",
                 "M3U_CHANNEL_NUMBER": "Wybierz kanał M3U według numeru",
                 "PLAY_PAUSE": "Odtwórz lub wstrzymaj osadzony MPV",
diff --git a/apps/web/src/assets/i18n/pt.json b/apps/web/src/assets/i18n/pt.json
index 31e02cd30..67847470a 100644
--- a/apps/web/src/assets/i18n/pt.json
+++ b/apps/web/src/assets/i18n/pt.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Escolha se o IPTVnator abre a primeira visualização disponível do espaço de trabalho ou restaura sua última visualização. Primeira visualização significa Dashboard quando ativada, caso contrário, Fontes.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Primeira visualização disponível",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Restaurar última visualização",
+        "STARTUP_WINDOW_MODE": "Janela ao iniciar",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Escolha como a janela do aplicativo abre: no último tamanho, maximizada ou em tela cheia. Aplica-se na próxima inicialização. Pressione F11 a qualquer momento para entrar ou sair da tela cheia.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Último tamanho da janela",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Maximizada",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Tela cheia",
         "SHOW_CAPTIONS_DESCRIPTION": "Mostrar ou ocultar legendas por padrão",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Mostrar rodapé de reprodução atual",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Mantém a barra de status do reprodutor externo visível na parte inferior do espaço de trabalho no desktop.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: motor frame-copy (experimental)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "O vídeo é desenhado na tela da aplicação, para que menus e diálogos fiquem por cima.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Entra em vigor após reiniciar a aplicação.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Opções extras do MPV integrado",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Opções avançadas do libmpv para o reprodutor integrado, um par key=value por linha (sem -- no início). São aplicadas em todos os motores após as opções internas e entram em vigor quando a próxima sessão do MPV integrado iniciar.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Exemplo: hwdec=auto-safe. Opções das quais o próprio reprodutor integrado depende (wid, vo, input-ipc-server, …) são recusadas.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Não está no formato key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Estas opções não podem ser alteradas para o reprodutor integrado: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Reconectar streams interrompidos automaticamente",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Quando um stream em reprodução é interrompido, o reprodutor integrado o recarrega com intervalos crescentes, em até 6 tentativas, antes de desistir. Um stream que nunca chegou a iniciar ainda precisa de um \"Tentar novamente\" manual.",
         "VOD_AUTO_FAILOVER": "Trocar de fonte automaticamente ao falhar a reprodução",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Quando um filme não consegue ser reproduzido e o mesmo filme existe em outra playlist, troca para ela automaticamente e mantém a posição de reprodução. Desativado por padrão; a troca é sempre avisada, porque outra fonte pode ter uma dublagem diferente."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Tentar novamente",
             "STALLED": "Este stream está demorando mais do que o esperado para iniciar.",
             "PLAYBACK_FAILED": "Falha na reprodução do MPV integrado.",
+            "RECONNECTING": "Conexão perdida. Reconectando… tentativa {{attempt}} de {{maxAttempts}}",
+            "STREAM_ENDED": "A transmissão ao vivo terminou.",
             "CHECKING_SUPPORT": "Verificando suporte ao MPV integrado...",
             "NOT_AVAILABLE": "O MPV integrado não está disponível neste ambiente.",
             "LOADING_STREAM": "Carregando stream…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Abrir pesquisa global",
                 "OPEN_RECENTLY_VIEWED": "Abrir assistidos recentemente",
                 "SUBMIT_SHELL_SEARCH": "Enviar pesquisa da área de trabalho",
+                "TOGGLE_WINDOW_FULLSCREEN": "Alternar tela cheia da janela do aplicativo",
                 "TOGGLE_SIDEBAR": "Alternar barra lateral",
                 "M3U_CHANNEL_NUMBER": "Selecionar canal M3U por número",
                 "PLAY_PAUSE": "Reproduzir ou pausar reprodução do Embedded MPV",
diff --git a/apps/web/src/assets/i18n/ru.json b/apps/web/src/assets/i18n/ru.json
index 29ee84b02..96e69f8e5 100644
--- a/apps/web/src/assets/i18n/ru.json
+++ b/apps/web/src/assets/i18n/ru.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "Выберите, должен ли IPTVnator открывать первый доступный экран рабочего пространства или восстанавливать последний экран уровня раздела. Первый экран означает Dashboard, если он включён, иначе Источники.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "Первый доступный экран",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Восстановить последний экран",
+        "STARTUP_WINDOW_MODE": "Окно при запуске",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Выберите, как открывается окно приложения: в последнем размере, развёрнутым или на весь экран. Применяется при следующем запуске. Нажмите F11 в любой момент, чтобы войти в полноэкранный режим или выйти из него.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Последний размер окна",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Развёрнутое",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "На весь экран",
         "SHOW_CAPTIONS_DESCRIPTION": "Показать или скрыть субтитры по умолчанию.",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Показывать панель «Сейчас воспроизводится»",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Оставлять панель состояния внешнего проигрывателя видимой внизу рабочей области в настольном приложении.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: движок frame-copy (экспериментально)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Видео рисуется на канвасе приложения, поэтому меню и диалоги отображаются поверх него.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Вступит в силу после перезапуска приложения.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Дополнительные параметры встроенного MPV",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Расширенные параметры libmpv для встроенного плеера, по одной паре key=value на строку (без -- в начале). Они применяются на любом движке после встроенных параметров и вступают в силу при следующем запуске воспроизведения во встроенном MPV.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Пример: hwdec=auto-safe. Параметры, от которых зависит сам встроенный плеер (wid, vo, input-ipc-server, …), отклоняются.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "Не в формате key=value: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Эти параметры нельзя изменять для встроенного плеера: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Автоматически переподключаться при обрыве потока",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Если поток обрывается во время воспроизведения, встроенный плеер перезагружает его с возрастающими задержками (до 6 попыток), после чего прекращает переподключение. Для потока, который так и не запустился, по-прежнему нужно нажать «Повторить» вручную.",
         "VOD_AUTO_FAILOVER": "Авто-переключение источника при ошибке воспроизведения",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Если фильм не воспроизводится, а тот же фильм есть в другом плейлисте, автоматически переключаться на него, сохраняя таймкод. По умолчанию выключено; о переключении всегда сообщается, так как в другом источнике может быть другая озвучка."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Повторить",
             "STALLED": "Запуск этого потока занимает больше времени, чем ожидалось.",
             "PLAYBACK_FAILED": "Не удалось воспроизвести через встроенный MPV.",
+            "RECONNECTING": "Подключение потеряно. Переподключение… попытка {{attempt}} из {{maxAttempts}}",
+            "STREAM_ENDED": "Прямой эфир завершился.",
             "CHECKING_SUPPORT": "Проверка поддержки встроенного MPV...",
             "NOT_AVAILABLE": "Встроенный MPV недоступен в этой среде.",
             "LOADING_STREAM": "Загрузка потока…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Открыть глобальный поиск",
                 "OPEN_RECENTLY_VIEWED": "Открыть недавно просмотренное",
                 "SUBMIT_SHELL_SEARCH": "Отправить поиск в рабочей области",
+                "TOGGLE_WINDOW_FULLSCREEN": "Переключить полноэкранный режим окна приложения",
                 "TOGGLE_SIDEBAR": "Показать или скрыть боковую панель",
                 "M3U_CHANNEL_NUMBER": "Выбрать канал M3U по номеру",
                 "PLAY_PAUSE": "Запустить или приостановить воспроизведение во встроенном MPV",
diff --git a/apps/web/src/assets/i18n/tr.json b/apps/web/src/assets/i18n/tr.json
index 52c54a950..02a8d7475 100644
--- a/apps/web/src/assets/i18n/tr.json
+++ b/apps/web/src/assets/i18n/tr.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "IPTVnator'un ilk kullanılabilir çalışma alanı görünümünü mü açacağını yoksa bölüm düzeyindeki son görünümünüzü mü geri yükleyeceğini seçin. İlk görünüm, Pano etkinleştirildiğinde Pano, aksi takdirde Kaynaklar anlamına gelir.",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "İlk kullanılabilir görünüm",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "Son görünümü geri yükle",
+        "STARTUP_WINDOW_MODE": "Başlangıçta pencere",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "Masaüstü penceresinin nasıl açılacağını seçin: son boyutunda, ekranı kaplamış veya tam ekran. Bir sonraki başlatmada uygulanır. Tam ekrana girmek veya çıkmak için istediğiniz zaman F11 tuşuna basın.",
+        "STARTUP_WINDOW_MODE_NORMAL": "Son pencere boyutu",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "Ekranı kaplamış",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "Tam ekran",
         "SHOW_CAPTIONS_DESCRIPTION": "Varsayılan olarak altyazıları göster veya gizle",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "Şu an oynatılıyor altbilgisini göster",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "Masaüstünde harici oynatıcı durum çubuğunu çalışma alanının altında görünür tutun.",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "Embedded MPV: frame-copy motoru (deneysel)",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "Video uygulama tuvaline çizilir, böylece menüler ve iletişim kutuları üzerinde görüntülenir.",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "Uygulama yeniden başlatıldıktan sonra geçerli olur.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "Gömülü MPV ek seçenekleri",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "Gömülü oynatıcı için gelişmiş libmpv seçenekleri; her satıra bir key=value çifti girin (başında -- olmadan). Tüm motorlarda yerleşik seçeneklerden sonra uygulanır ve bir sonraki gömülü MPV oturumu başladığında geçerli olur.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "Örnek: hwdec=auto-safe. Gömülü oynatıcının kendisinin bağlı olduğu seçenekler (wid, vo, input-ipc-server, …) reddedilir.",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "key=value biçiminde olmayan satır: {{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "Bu seçenekler gömülü oynatıcı için değiştirilemez: {{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "Kesilen yayınlara otomatik yeniden bağlan",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "Oynatılan bir yayın kesildiğinde gömülü oynatıcı, vazgeçmeden önce yayını giderek artan gecikmelerle en fazla 6 kez yeniden yüklemeyi dener. Hiç başlamamış bir yayın için yine de Tekrar dene’ye el ile basmanız gerekir.",
         "VOD_AUTO_FAILOVER": "Oynatma hatasında kaynağı otomatik değiştir",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "Bir film oynatılamadığında ve aynı film başka bir oynatma listesinde de varsa, otomatik olarak o listeye geçilir ve oynatma konumu korunur. Varsayılan olarak kapalıdır; başka bir kaynakta dublaj farklı olabileceği için geçiş her zaman bildirilir."
     },
@@ -515,6 +527,8 @@
             "RETRY": "Tekrar dene",
             "STALLED": "Bu yayının başlaması beklenenden uzun sürüyor.",
             "PLAYBACK_FAILED": "Gömülü MPV oynatması başarısız oldu.",
+            "RECONNECTING": "Bağlantı kesildi. Yeniden bağlanılıyor… deneme {{attempt}}/{{maxAttempts}}",
+            "STREAM_ENDED": "Canlı yayın sona erdi.",
             "CHECKING_SUPPORT": "Gömülü MPV desteği denetleniyor...",
             "NOT_AVAILABLE": "Gömülü MPV bu ortamda kullanılamıyor.",
             "LOADING_STREAM": "Yayın yükleniyor…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "Genel aramayı aç",
                 "OPEN_RECENTLY_VIEWED": "Son görüntülenenleri aç",
                 "SUBMIT_SHELL_SEARCH": "Çalışma alanı aramasını gönder",
+                "TOGGLE_WINDOW_FULLSCREEN": "Uygulama penceresi tam ekranını aç/kapat",
                 "TOGGLE_SIDEBAR": "Kenar çubuğunu aç/kapat",
                 "M3U_CHANNEL_NUMBER": "M3U kanalını numarayla seç",
                 "PLAY_PAUSE": "Gömülü MPV oynatmasını oynat veya duraklat",
diff --git a/apps/web/src/assets/i18n/zh.json b/apps/web/src/assets/i18n/zh.json
index 5a58877db..532bf6550 100644
--- a/apps/web/src/assets/i18n/zh.json
+++ b/apps/web/src/assets/i18n/zh.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "选择 IPTVnator 启动时是打开第一个可用的工作区视图，还是恢复您上次的章节级视图。第一个视图在启用时为仪表盘，否则为「源」。",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "首个可用视图",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "恢复上次视图",
+        "STARTUP_WINDOW_MODE": "启动时的窗口",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "选择桌面窗口的打开方式：上次的大小、最大化或全屏。下次启动时生效。随时按 F11 进入或退出全屏。",
+        "STARTUP_WINDOW_MODE_NORMAL": "上次窗口大小",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "最大化",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "全屏",
         "SHOW_CAPTIONS_DESCRIPTION": "默认显示或隐藏字幕",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "显示「正在播放」底栏",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "在桌面端工作区底部保持外部播放器状态栏可见。",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "嵌入式 MPV：帧拷贝引擎（实验性）",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "视频渲染到应用画布上，菜单和对话框可以显示在其上方。",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "重启应用后生效。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "嵌入式 MPV 附加选项",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "嵌入式播放器的高级 libmpv 选项，每行一个 key=value 键值对（开头不加 --）。这些选项会在所有引擎中于内置选项之后应用，并在下一次嵌入式 MPV 会话启动时生效。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "示例：hwdec=auto-safe。嵌入本身依赖的选项（wid、vo、input-ipc-server 等）会被拒绝。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "不是 key=value 格式的行：{{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "嵌入式播放器无法更改这些选项：{{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "自动重连中断的流",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "正在播放的流中断时，嵌入式播放器会以逐渐增加的间隔重新加载，最多尝试 6 次后放弃。从未成功启动的流仍需手动重试。",
         "VOD_AUTO_FAILOVER": "播放出错时自动切换播放源",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "当某部电影无法播放，而其他播放列表中也有同一部影片时，自动切换过去并保留播放进度。默认关闭；由于其他播放源的配音可能不同，每次切换都会给出提示。"
     },
@@ -515,6 +527,8 @@
             "RETRY": "重试",
             "STALLED": "该流的启动时间超出预期。",
             "PLAYBACK_FAILED": "嵌入式 MPV 播放失败。",
+            "RECONNECTING": "连接已丢失。正在重新连接… 第 {{attempt}} 次尝试，共 {{maxAttempts}} 次",
+            "STREAM_ENDED": "直播已结束。",
             "CHECKING_SUPPORT": "正在检查嵌入式 MPV 支持…",
             "NOT_AVAILABLE": "嵌入式 MPV 在当前环境中不可用。",
             "LOADING_STREAM": "正在加载流…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "打开全局搜索",
                 "OPEN_RECENTLY_VIEWED": "打开最近观看",
                 "SUBMIT_SHELL_SEARCH": "提交工作区搜索",
+                "TOGGLE_WINDOW_FULLSCREEN": "切换应用窗口全屏",
                 "TOGGLE_SIDEBAR": "切换侧边栏",
                 "M3U_CHANNEL_NUMBER": "按数字选择 M3U 频道",
                 "PLAY_PAUSE": "播放或暂停嵌入式 MPV 播放",
diff --git a/apps/web/src/assets/i18n/zhtw.json b/apps/web/src/assets/i18n/zhtw.json
index dc57eea2c..9108a629e 100644
--- a/apps/web/src/assets/i18n/zhtw.json
+++ b/apps/web/src/assets/i18n/zhtw.json
@@ -368,6 +368,11 @@
         "STARTUP_BEHAVIOR_DESCRIPTION": "選擇 IPTVnator 啟動時要開啟第一個可用的工作區畫面，或還原您上次瀏覽的區段層級畫面。第一個畫面在啟用儀表板時為儀表板，否則為「來源」。",
         "STARTUP_BEHAVIOR_FIRST_VIEW": "第一個可用畫面",
         "STARTUP_BEHAVIOR_RESTORE_LAST_VIEW": "還原上次畫面",
+        "STARTUP_WINDOW_MODE": "啟動時的視窗",
+        "STARTUP_WINDOW_MODE_DESCRIPTION": "選擇桌面視窗的開啟方式：上次的大小、最大化或全螢幕。下次啟動時生效。隨時按 F11 進入或離開全螢幕。",
+        "STARTUP_WINDOW_MODE_NORMAL": "上次視窗大小",
+        "STARTUP_WINDOW_MODE_MAXIMIZED": "最大化",
+        "STARTUP_WINDOW_MODE_FULLSCREEN": "全螢幕",
         "SHOW_CAPTIONS_DESCRIPTION": "預設顯示或隱藏字幕",
         "SHOW_EXTERNAL_PLAYBACK_BAR": "顯示「正在播放」列",
         "SHOW_EXTERNAL_PLAYBACK_BAR_DESCRIPTION": "在桌面工作區底部保留外部播放器狀態列可見。",
@@ -492,6 +497,13 @@
         "EMBEDDED_MPV_FRAME_COPY": "內嵌 MPV：幀複製引擎（實驗性）",
         "EMBEDDED_MPV_FRAME_COPY_DESCRIPTION": "影片會繪製到應用程式畫布上，選單和對話框可顯示在其上方。",
         "EMBEDDED_MPV_FRAME_COPY_RESTART": "重新啟動應用程式後生效。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS": "內嵌 MPV 額外選項",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_DESCRIPTION": "內嵌播放器的進階 libmpv 選項，每行一組 key=value（開頭不加 --）。這些選項會在所有引擎中於內建選項之後套用，並在下一次內嵌 MPV 工作階段啟動時生效。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_HINT": "範例：hwdec=auto-safe。內嵌本身所依賴的選項（wid、vo、input-ipc-server 等）會被拒絕。",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_INVALID_LINES": "不是 key=value 格式的行：{{lines}}",
+        "EMBEDDED_MPV_EXTRA_OPTIONS_FORBIDDEN_KEYS": "內嵌播放器無法變更這些選項：{{keys}}",
+        "EMBEDDED_MPV_AUTO_RECONNECT": "自動重新連線中斷的串流",
+        "EMBEDDED_MPV_AUTO_RECONNECT_DESCRIPTION": "播放中的串流中斷時，內嵌播放器會以逐漸拉長的間隔重新載入，最多嘗試 6 次後放棄。從未成功啟動的串流仍需手動重試。",
         "VOD_AUTO_FAILOVER": "播放發生錯誤時自動切換來源",
         "VOD_AUTO_FAILOVER_DESCRIPTION": "當電影無法播放，且其他播放清單中也有同一部影片時，會自動切換過去並保留播放進度。預設為關閉；由於其他來源可能使用不同的配音，每次切換都會提示您。"
     },
@@ -515,6 +527,8 @@
             "RETRY": "重試",
             "STALLED": "此串流的啟動時間比預期長。",
             "PLAYBACK_FAILED": "內嵌 MPV 播放失敗。",
+            "RECONNECTING": "連線中斷。正在重新連線… 第 {{attempt}} 次嘗試，共 {{maxAttempts}} 次",
+            "STREAM_ENDED": "現場直播已結束。",
             "CHECKING_SUPPORT": "正在檢查內嵌 MPV 支援…",
             "NOT_AVAILABLE": "內嵌 MPV 在此環境中無法使用。",
             "LOADING_STREAM": "正在載入串流…",
@@ -1574,6 +1588,7 @@
                 "OPEN_GLOBAL_SEARCH": "開啟全域搜尋",
                 "OPEN_RECENTLY_VIEWED": "開啟最近觀看",
                 "SUBMIT_SHELL_SEARCH": "提交工作區搜尋",
+                "TOGGLE_WINDOW_FULLSCREEN": "切換應用程式視窗全螢幕",
                 "TOGGLE_SIDEBAR": "切換側邊欄",
                 "M3U_CHANNEL_NUMBER": "按數字選擇 M3U 頻道",
                 "PLAY_PAUSE": "播放或暫停嵌入式 MPV 播放",
diff --git a/apps/website/README.md b/apps/website/README.md
index a9f39cba8..b19341cc2 100644
--- a/apps/website/README.md
+++ b/apps/website/README.md
@@ -62,3 +62,23 @@ resolved version.
 `tools/testing/website-download-pages.test.mjs`, which checks titles,
 canonicals, direct asset links, JSON-LD, cross-links and sitemap entries
 without depending on a specific version.
+
+## Guides
+
+Evergreen how-to posts live in the blog collection next to release notes
+(`xtream-codes-setup-guide.mdx` and `stalker-portal-setup-guide.mdx` in
+`apps/website/src/content/blog/`).
+Two conventions set them apart:
+
+- **`faq` frontmatter.** An optional list of `{ q, a }` entries. `BlogPost.astro`
+  renders it as an accordion after the body and emits a `FAQPage` JSON-LD block
+  next to the `BlogPosting` one, so the answers can surface as rich results.
+- **Screenshots from the capture script.** Guide frames are captured by
+  `pnpm release:screenshots --group guides` into
+  `apps/website/public/blog/guides/screenshots/<slug>-<theme>.png`; the shots are
+  declared in `tools/release/screenshots.manifest.json` with `"group": "guides"`
+  and never appear in a release run.
+
+`tools/testing/website-guides.test.mjs` (part of `pnpm nx test website`) checks
+each guide for the FAQPage schema, a link to the download hub and the presence
+of every referenced screenshot in the build output.
diff --git a/apps/website/astro.config.mjs b/apps/website/astro.config.mjs
index 5e746c928..c89e7d4cc 100644
--- a/apps/website/astro.config.mjs
+++ b/apps/website/astro.config.mjs
@@ -1,8 +1,21 @@
 // @ts-check
+import { readFileSync } from 'node:fs';
 import { defineConfig } from 'astro/config';
 import sitemap from '@astrojs/sitemap';
 import mdx from '@astrojs/mdx';
 
+/**
+ * Repository version for the download pages' offline fallback
+ * (`src/lib/downloads.ts`). Read from the workspace root through the file
+ * system and injected as a build-time constant: importing the root
+ * `package.json` from inside the project trips the Nx module-boundaries rule
+ * ("external resources cannot be imported using a relative path"), and a
+ * value fixed at build time is what the fallback needs anyway.
+ */
+const { version } = JSON.parse(
+  readFileSync(new URL('../../package.json', import.meta.url), 'utf8'),
+);
+
 // Tailwind (v3) is applied via apps/website/postcss.config.mjs — the
 // @astrojs/tailwind integration only supports Astro <= 5.
 // https://astro.build/config
@@ -11,4 +24,9 @@ export default defineConfig({
   base: '/iptvnator',
   outDir: '../../dist/apps/website',
   integrations: [sitemap(), mdx()],
+  vite: {
+    define: {
+      __IPTVNATOR_VERSION__: JSON.stringify(version),
+    },
+  },
 });
diff --git a/apps/website/project.json b/apps/website/project.json
index 08e54dc19..06820b077 100644
--- a/apps/website/project.json
+++ b/apps/website/project.json
@@ -18,7 +18,7 @@
             "executor": "nx:run-commands",
             "dependsOn": ["build"],
             "options": {
-                "command": "node --test tools/testing/website-giscus-comments.test.mjs tools/testing/website-download-pages.test.mjs"
+                "command": "node --test tools/testing/website-giscus-comments.test.mjs tools/testing/website-download-pages.test.mjs tools/testing/website-guides.test.mjs"
             }
         },
         "serve": {
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
new file mode 100644
index 000000000..99c16e3d3
Binary files /dev/null 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
new file mode 100644
index 000000000..2f6935e15
Binary files /dev/null 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-stalker-live-dark.png b/apps/website/public/blog/guides/screenshots/guide-stalker-live-dark.png
new file mode 100644
index 000000000..bf28e61c0
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-stalker-live-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-stalker-live-light.png b/apps/website/public/blog/guides/screenshots/guide-stalker-live-light.png
new file mode 100644
index 000000000..e099e4964
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-stalker-live-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
new file mode 100644
index 000000000..8883662e4
Binary files /dev/null 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
new file mode 100644
index 000000000..d17c79e59
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-xtream-add-playlist-light.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-dark.png b/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-dark.png
new file mode 100644
index 000000000..4e0f30452
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-light.png b/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-light.png
new file mode 100644
index 000000000..642316854
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-xtream-auto-detect-light.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-live-dark.png b/apps/website/public/blog/guides/screenshots/guide-xtream-live-dark.png
new file mode 100644
index 000000000..40c7b520f
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-xtream-live-dark.png differ
diff --git a/apps/website/public/blog/guides/screenshots/guide-xtream-live-light.png b/apps/website/public/blog/guides/screenshots/guide-xtream-live-light.png
new file mode 100644
index 000000000..ddc69e229
Binary files /dev/null and b/apps/website/public/blog/guides/screenshots/guide-xtream-live-light.png differ
diff --git a/apps/website/public/llms.txt b/apps/website/public/llms.txt
index 9bbcca9ed..141ddf237 100644
--- a/apps/website/public/llms.txt
+++ b/apps/website/public/llms.txt
@@ -11,6 +11,8 @@
 - Download for Windows: https://4gray.github.io/iptvnator/download/windows/
 - Download for macOS: https://4gray.github.io/iptvnator/download/macos/
 - Download for Linux: https://4gray.github.io/iptvnator/download/linux/
+- Guide, Xtream Codes setup: https://4gray.github.io/iptvnator/blog/xtream-codes-setup-guide/
+- Guide, Stalker/Ministra portal setup: https://4gray.github.io/iptvnator/blog/stalker-portal-setup-guide/
 - Release Notes (v0.18): https://4gray.github.io/iptvnator/blog/v0-18-release-notes/
 - Troubleshooting (macOS app damaged fix): https://4gray.github.io/iptvnator/blog/macos-arm-app-damaged-fix/
 - Source Code: https://github.com/4gray/iptvnator
diff --git a/apps/website/src/components/blog/LinkCards.astro b/apps/website/src/components/blog/LinkCards.astro
index 632e80f00..2cb50913c 100644
--- a/apps/website/src/components/blog/LinkCards.astro
+++ b/apps/website/src/components/blog/LinkCards.astro
@@ -29,8 +29,8 @@ const iconPaths = {
   {links.map((item) => (
     <a
       href={item.href}
-      target="_blank"
-      rel="noopener noreferrer"
+      target={item.href.startsWith('/') ? undefined : '_blank'}
+      rel={item.href.startsWith('/') ? undefined : 'noopener noreferrer'}
       class="group rounded-xl border border-dashed border-surface-700/70 bg-surface-900/50 p-4 transition-all duration-300 hover:border-accent-500/40 hover:bg-accent-500/[0.06]"
     >
       <div class="flex items-center gap-2.5">
diff --git a/apps/website/src/components/blog/PostButton.astro b/apps/website/src/components/blog/PostButton.astro
index 80fa35d90..71f73f010 100644
--- a/apps/website/src/components/blog/PostButton.astro
+++ b/apps/website/src/components/blog/PostButton.astro
@@ -15,7 +15,11 @@ const { href, label, external = true } = Astro.props;
   class="not-prose group my-6 inline-flex items-center gap-2 rounded-lg border border-dashed border-accent-500/35 bg-accent-500/[0.08] px-4 py-2.5 text-sm font-medium text-accent-200 transition-all duration-200 hover:border-accent-400/50 hover:bg-accent-500/[0.14] hover:text-accent-100"
 >
   <span>{label ?? 'Open link'}</span>
-  <svg class="h-4 w-4 transition-transform duration-200 group-hover:translate-x-0.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.8">
-    <path stroke-linecap="round" stroke-linejoin="round" d="M13.5 4.5H19.5m0 0v6m0-6L10.5 13.5M6 6h3.75M6 10.5V18a1.5 1.5 0 001.5 1.5H15" />
+  <svg class="h-4 w-4 transition-transform duration-200 group-hover:translate-x-0.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.8" aria-hidden="true">
+    {external ? (
+      <path stroke-linecap="round" stroke-linejoin="round" d="M13.5 4.5H19.5m0 0v6m0-6L10.5 13.5M6 6h3.75M6 10.5V18a1.5 1.5 0 001.5 1.5H15" />
+    ) : (
+      <path stroke-linecap="round" stroke-linejoin="round" d="M17 8l4 4m0 0l-4 4m4-4H3" />
+    )}
   </svg>
 </a>
diff --git a/apps/website/src/content.config.ts b/apps/website/src/content.config.ts
index d9e8b0817..e568909cf 100644
--- a/apps/website/src/content.config.ts
+++ b/apps/website/src/content.config.ts
@@ -13,6 +13,8 @@ const blog = defineCollection({
     heroImage: z.string().optional(),
     tags: z.array(z.string()).default([]),
     draft: z.boolean().default(false),
+    /** Rendered as an accordion after the post and emitted as FAQPage JSON-LD. */
+    faq: z.array(z.object({ q: z.string(), a: z.string() })).optional(),
   }),
 });
 
diff --git a/apps/website/src/content/blog/stalker-portal-setup-guide.mdx b/apps/website/src/content/blog/stalker-portal-setup-guide.mdx
new file mode 100644
index 000000000..b20698ac3
--- /dev/null
+++ b/apps/website/src/content/blog/stalker-portal-setup-guide.mdx
@@ -0,0 +1,191 @@
+---
+title: How to Connect a Stalker or Ministra Portal to IPTVnator
+description: Add a Stalker portal to IPTVnator step by step. Which URL shapes work, how the MAC address is normalized, what device IDs and serial numbers are for, how IPTVnator detects the portal type, and what the usual refusals mean.
+pubDate: 2026-09-03
+author: 4gray
+heroImage: /iptvnator/blog/guides/screenshots/guide-stalker-live-dark.png
+tags:
+- guide
+- stalker-portal
+- setup
+- tutorial
+draft: false
+faq:
+- q: What is the difference between a Stalker portal and an Xtream Codes account?
+  a: Both are ways a provider hands you access. Xtream Codes identifies you by username and password against an API. A Stalker or Ministra portal identifies a set-top box by its MAC address against a middleware server, the way MAG boxes and set-top-box emulators work. If your provider gave you a portal URL and a MAC address, you have a Stalker portal.
+- 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.
+- 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.
+- 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?
+  a: Open Account info from the playlist switcher in the header or from the source card on the dashboard. It shows status, login, tariff plan, expiry date with a days-left counter, and portal details, using the data saved at import when the portal cannot be reached.
+---
+
+import Alert from '../../components/blog/Alert.astro';
+import PostButton from '../../components/blog/PostButton.astro';
+import StepRail from '../../components/blog/StepRail.astro';
+import LinkCards from '../../components/blog/LinkCards.astro';
+
+Stalker portals, also sold as Ministra portals, are the middleware that MAG set-top boxes talk
+to. Instead of a username and password, the portal knows your device by its **MAC address**,
+and everything else, from the channel list to the movie catalog and the program guide, comes
+from that one identity. IPTVnator behaves like a MAG box towards the portal, so a subscription
+meant for a set-top box or a set-top-box emulator works on your desktop too.
+
+This guide covers what to enter, what IPTVnator does with it, and what the portal's usual
+refusals mean. It applies to the desktop app on Windows, macOS and Linux and to the
+self-hosted browser version.
+
+<Alert type="info" title="IPTVnator is a player, not a service">
+  It does not include portals, channels or accounts. The portal URL and MAC address in this
+  guide come from the provider you already have a contract with.
+</Alert>
+
+## What you need from your provider
+
+| Field | What it looks like | Notes |
+| --- | --- | --- |
+| Portal URL | `http://portal.example-provider.net/c` | A bare host, `/c`, `portal.php` or `server/load.php` all work. Must start with `http://` or `https://`. |
+| MAC address | `00:1A:79:12:34:56` | Twelve hex digits. Dashes, dots and lowercase are corrected for you. |
+| Username and password | optional | Only some Ministra portals ask for them. |
+| Serial number, device IDs, signatures | optional | Only if the provider registered a specific box and told you the values. |
+
+Most portals only accept MAC addresses from Infomir's `00:1A:79` range, the manufacturer of
+MAG boxes. IPTVnator shows a hint when an address is outside that range but does not refuse
+it, because some reseller panels are configured differently.
+
+## Add the portal
+
+<StepRail
+  title="In IPTVnator"
+  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.',
+  ]}
+/>
+
+![Add playlist dialog with the Stalker portal method selected, a portal URL and a MAC address filled in](/iptvnator/blog/guides/screenshots/guide-stalker-add-playlist-dark.png)
+
+<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.
+</Alert>
+
+## What happens when you click Add
+
+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
+setups, so IPTVnator no longer guesses:
+
+1. It tries the address you entered, then the usual endpoints behind it (`portal.php`,
+   `server/load.php`, `stalker_portal/server/load.php`) in order.
+2. For each one it observes how the portal behaves. A portal that hands out data without a
+   token is a **simple panel**; a portal that demands the handshake token is a **full
+   Ministra portal**, and IPTVnator completes the handshake and reads your profile to
+   confirm it.
+3. The endpoint and mode that worked are saved with the source. Later requests use exactly
+   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.
+
+## After the import
+
+![Live TV of a Stalker portal with categories, the channel list and the program guide](/iptvnator/blog/guides/screenshots/guide-stalker-live-dark.png)
+
+The source gets its own sidebar:
+
+- **Live TV**: categories on the left, channels with the current program and a progress
+  bar, the player and a timeline of the schedule. IPTVnator loads the complete channel list
+  once per session, so search covers every channel and not only the pages the portal has
+  served so far. Channels the portal marks as archived can be played from the timeline.
+- **Radio**: portal radio stations in a dedicated audio layout, always through the built-in
+  player.
+- **Movies** and **Series**: poster grids per category and a detail page with description,
+  cast, trailer and similar titles. Series come in the three shapes portals use, regular
+  series, movies with embedded episodes and Ministra's lazily loaded seasons, and all three
+  render as seasons and episodes with resume positions and watched markers. The desktop app
+  adds a download button for offline viewing.
+- **Search**, **Favorites** and **Recent** for the source. Global favorites, recent items
+  and search on the dashboard combine all your sources.
+- **Discover**, when TMDB metadata is enabled in the settings.
+
+<Alert type="info" title="Program guide">
+  IPTVnator asks the portal for a seven-day schedule once per session and shows it in the
+  channel list and in the timeline under the player. If a channel shows nothing, the portal
+  did not publish a schedule for it. The desktop app additionally uses XMLTV sources
+  configured under Settings › EPG as a fallback, and a right-click on a channel offers
+  "Map EPG channel" to link it to an XMLTV channel by hand.
+</Alert>
+
+## Check the subscription
+
+Open **Account info** from the playlist switcher in the header or from the source card on
+the dashboard. IPTVnator shows the data saved during the import immediately, marked as saved
+data, then refreshes it from the portal: status, login, tariff plan, expiry date with a
+days-left counter, the MAC address and the portal details. The source card on the dashboard
+carries a small expiry chip that turns amber during the last week of the subscription.
+
+## Device identity, explained
+
+A real MAG box reports more than its MAC address: a serial number, two device IDs and two
+signatures. IPTVnator sends only what you typed. Empty fields stay empty, nothing is invented
+behind your back, and that matters because of how portals treat device IDs:
+
+- The portal **pins the first device ID it receives** to the MAC address and refuses every
+  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.
+- 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.
+
+If your provider registered the box for you and sent a serial number or device IDs, enter
+exactly those values.
+
+## Troubleshooting
+
+- **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.
+- **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.
+- **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.
+- **The portal refused access for this device**: the account is blocked or expired, or the
+  MAC address is not registered. The portal's own message tells you which; contact the
+  provider.
+- **Failed to authenticate with the portal. Check the URL and MAC address**: the host did
+  not answer on any of the probed endpoints. Check the address, the network or the VPN, and
+  try again.
+- **Channels load but nothing plays**: the built-in web players cannot decode every codec.
+  Open the stream in MPV or VLC via Settings › Playback, or enable the experimental embedded
+  MPV engine. IPTVnator resolves a fresh temporary link from the portal for every playback,
+  so a stream that stopped working usually works again after re-selecting the channel.
+- **The catalog looks stale**: portals paginate their lists. Use the refresh action in the
+  live TV header to reload the complete channel list, and re-open a category to fetch its
+  content again.
+
+## Related
+
+<LinkCards
+  links={[
+    { label: 'Download IPTVnator', href: '/iptvnator/download/', hint: 'Windows, macOS and Linux builds, package managers and the browser version.', icon: 'download' },
+    { label: 'Add an Xtream Codes account', href: '/iptvnator/blog/xtream-codes-setup-guide/', hint: 'The username-and-password way of connecting a provider.', icon: 'docs' },
+    { label: 'Why some streams need an external player', href: '/iptvnator/blog/why-external-players-help/', hint: 'Codecs, containers and when MPV or VLC is the right tool.', icon: 'docs' },
+  ]}
+/>
+
+<PostButton href="/iptvnator/download/" label="Get IPTVnator for your platform" external={false} />
diff --git a/apps/website/src/content/blog/xtream-codes-setup-guide.mdx b/apps/website/src/content/blog/xtream-codes-setup-guide.mdx
new file mode 100644
index 000000000..a2c4351d3
--- /dev/null
+++ b/apps/website/src/content/blog/xtream-codes-setup-guide.mdx
@@ -0,0 +1,187 @@
+---
+title: How to Add an Xtream Codes Account to IPTVnator
+description: Connect an Xtream Codes API provider to IPTVnator step by step. What the server URL, username and password are, how to test the login, how to paste the message from your provider, and what to do when the portal refuses to connect.
+pubDate: 2026-09-03
+author: 4gray
+heroImage: /iptvnator/blog/guides/screenshots/guide-xtream-live-dark.png
+tags:
+- guide
+- xtream-codes
+- setup
+- tutorial
+draft: false
+faq:
+- q: Is an Xtream Codes login the same thing as an M3U link?
+  a: Usually both come from the same account. An M3U link that contains get.php with username and password in its query string is generated by an Xtream Codes panel, so you can add it as Xtream credentials instead. You get the same channels plus movies, series, provider metadata, EPG and catch-up, which the flat M3U file cannot carry.
+- q: Where do I find my Xtream server URL?
+  a: It is the host part of any link your provider gave you, including the scheme and the port, for example http followed by the hostname and a port number. If you only have a get.php or player_api.php link, paste it into the Server URL field. IPTVnator strips the endpoint and reads the username and password from the query string.
+- q: Can I use the same Xtream account on several devices?
+  a: Your provider decides that through the connection limit of the account. The Account info dialog in IPTVnator shows the active and maximum connections. Playing on more devices than allowed produces authentication errors or streams that stop after a few seconds.
+- q: Does IPTVnator show a program guide and catch-up for Xtream channels?
+  a: Yes. IPTVnator asks the portal for the schedule of each channel and shows the current program in the channel list and a timeline under the player. Channels that the portal marks as archived get a catch-up badge, and past programs can be played from the timeline. On the desktop app, XMLTV sources configured in the settings are used as a fallback.
+- q: Can I add more than one Xtream account?
+  a: Yes. Every account becomes its own source with separate favorites, history and cached catalog. The dashboard and the playlist switcher in the header list all of them, and global favorites, recent items and search work across sources.
+- q: Where are my credentials stored, and are they sent anywhere else?
+  a: Credentials stay on your device, in the local database of the desktop app or in browser storage of the web version, and are only sent to the server URL you entered. IPTVnator has no account system and no analytics. The self-hosted web version routes requests through your own backend container.
+- q: My provider only gave me a MAC address and a portal URL. Is that Xtream Codes?
+  a: No, that is a Stalker or Ministra portal. Choose the Stalker portal method in the same Add playlist dialog. The Auto-detect method recognizes a MAC address in the pasted message and pre-fills the Stalker form for you.
+---
+
+import Alert from '../../components/blog/Alert.astro';
+import PostButton from '../../components/blog/PostButton.astro';
+import StepRail from '../../components/blog/StepRail.astro';
+import LinkCards from '../../components/blog/LinkCards.astro';
+
+Most IPTV providers hand out three pieces of data: a **server URL**, a **username** and a
+**password**. That trio is an Xtream Codes account, and it is the richest way to connect a
+provider to IPTVnator. Instead of a flat channel list you get live TV, movies and series with
+posters and descriptions, a program guide, catch-up where the provider offers it, and an
+account page that tells you when the subscription ends.
+
+This guide walks through adding such an account in IPTVnator, checking that it works, and
+fixing the usual problems. It applies to the desktop app on Windows, macOS and Linux and to the
+self-hosted browser version.
+
+<Alert type="info" title="IPTVnator is a player, not a service">
+  It does not include channels, playlists or accounts. The credentials in this guide come from
+  the provider you already have a contract with.
+</Alert>
+
+## What you need from your provider
+
+| Field | What it looks like | Notes |
+| --- | --- | --- |
+| Server URL | `http://tv.example-provider.net:8080` | Scheme, host and port. Some panels live under a subpath such as `/panel`; keep it. |
+| Username | `janedoe` | Case-sensitive. |
+| Password | `s3cret` | Case-sensitive. |
+
+Providers rarely label the data this cleanly. Often you receive one long link that ends in
+`get.php` or `player_api.php` with the username and password inside the query string. That link
+is enough: the part before `/get.php` is the server URL, and the two query parameters are your
+credentials. IPTVnator can read them out of the link for you, as shown below.
+
+## Add the account
+
+<StepRail
+  title="In IPTVnator"
+  steps={[
+    '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.',
+  ]}
+/>
+
+![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.
+
+<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
+  username and password fields are still empty, IPTVnator cuts the link down to the server
+  URL and fills in the credentials from the query string. Trailing slashes and surrounding
+  whitespace are removed as well.
+</Alert>
+
+## Or paste the message from your provider
+
+Provider messages are messy: a link, a username and a password somewhere in a chat message
+or an email, sometimes dressed up in fancy Unicode letters to get past spam filters. The
+**Auto-detect** method in the same dialog takes the whole message and finds the source for
+you.
+
+![Auto-detect method with a pasted provider message and a recognized Xtream account](/iptvnator/blog/guides/screenshots/guide-xtream-auto-detect-dark.png)
+
+Paste everything, then click **Fill the form** on the candidate that looks right. IPTVnator
+switches to the matching method with the fields pre-filled, and you continue with the
+connection test as above. Detection runs inside the app; nothing you paste is sent anywhere.
+
+The detector ranks what it finds: a MAC address means a Stalker portal, a `get.php` or
+`player_api.php` link means Xtream Codes, a labeled username and password without a MAC
+address leans Xtream, and a link ending in `.m3u` or `.m3u8` is a plain playlist URL. It never
+invents or "fixes" a value, so a password that is almost right stays wrong, and the connection
+test remains the authority on whether the account works.
+
+## After the import
+
+Right after you click Add, IPTVnator syncs the catalog: the categories for live TV, movies and
+series, then their content. A progress panel shows what is being fetched. On the desktop app
+the result is stored in a local library, so the next time you open the source it appears
+instantly and only changed data is downloaded.
+
+![Live TV of an Xtream source with categories, the channel list and the program guide](/iptvnator/blog/guides/screenshots/guide-xtream-live-dark.png)
+
+The source gets its own sidebar with these sections:
+
+- **Live TV**: categories on the left, channels with the current program and a progress bar,
+  the player and a timeline of the schedule. Channels that the portal marks as archived carry
+  a **Catchup available** badge with the number of days, and past programs play straight from
+  the timeline.
+- **Movies** and **Series**: poster grids per category, a detail page with description, cast,
+  trailer and similar titles, resume positions, watched markers, and on the desktop app a
+  download button for offline viewing.
+- **Search**, **Favorites**, **Recent** and **Recently added** for the source. Global
+  favorites, recent items and search on the dashboard combine all your sources.
+- **Discover**, when TMDB metadata is enabled in the settings: browse the portal by year,
+  genre and country.
+
+<Alert type="info" title="Program guide">
+  Xtream portals ship their own schedule, so the guide works without any extra setup. If a
+  channel shows no program information, the portal did not provide any for it. The desktop
+  app additionally uses XMLTV sources configured under Settings › EPG as a fallback, and a
+  right-click on a channel offers "Map EPG channel" to link it to an XMLTV channel by hand.
+</Alert>
+
+## Check the subscription
+
+Open **Account info** from the playlist switcher in the header (the menu next to the source)
+or from the source card on the dashboard. The dialog shows the account status, the expiry
+date, active and maximum connections, whether the account is a trial, the stream formats the
+portal allows, and the server details. The source card on the dashboard also carries a small
+expiry chip that turns amber during the last week of the subscription.
+
+## Keep the catalog fresh
+
+Providers add and remove content all the time. **Refresh Xtream playlist from remote** in the
+source menu downloads the categories and content again while keeping your favorites,
+watch history, hidden categories and playback positions. To change the server URL or
+credentials after a provider migration, open the playlist details of the source and edit
+them there; the next request uses the new connection.
+
+## Troubleshooting
+
+- **Unauthorized, Account inactive or Account expired** after the import worked before:
+  the portal now rejects the credentials. Open Account info, then check the subscription with
+  your provider or correct the credentials in the playlist details.
+- **Portal not found**: the server URL is wrong. It must start with `http://` or `https://`,
+  carry the right port, and keep any subpath the provider uses. Try the exact host from the
+  link you were given.
+- **Portal unavailable**: the host did not answer. Check your network or VPN, then use
+  **Retry**. After two failed connection attempts IPTVnator pauses requests to that host for
+  30 seconds to keep the app responsive; a manual retry lifts the pause immediately.
+- **The catalog loads but streams do not play**: the built-in web players cannot decode every
+  codec. Open the stream in MPV or VLC via Settings › Playback, or enable the experimental
+  embedded MPV engine. Settings › Playback also has a **Stream Format** option for Xtream
+  live streams; `auto` picks HLS when the portal allows it and falls back to MPEG-TS.
+- **Streams stop after a few seconds or refuse to start on a second device**: the account's
+  connection limit is reached. Account info shows the active and maximum connections.
+- **The provider blocks the app**: some panels only answer clients with a specific
+  User-Agent. On the desktop app you can set one in the playlist details; otherwise IPTVnator
+  identifies itself with a common IPTV player signature.
+
+## Related
+
+<LinkCards
+  links={[
+    { label: 'Download IPTVnator', href: '/iptvnator/download/', hint: 'Windows, macOS and Linux builds, package managers and the browser version.', icon: 'download' },
+    { label: 'Why some streams need an external player', href: '/iptvnator/blog/why-external-players-help/', hint: 'Codecs, containers and when MPV or VLC is the right tool.', icon: 'docs' },
+    { label: 'Understanding the program guide', href: '/iptvnator/blog/epg-guide/', hint: 'How XMLTV data reaches your channels.', icon: 'docs' },
+  ]}
+/>
+
+<PostButton href="/iptvnator/download/" label="Get IPTVnator for your platform" external={false} />
diff --git a/apps/website/src/env.d.ts b/apps/website/src/env.d.ts
new file mode 100644
index 000000000..ee4d25b10
--- /dev/null
+++ b/apps/website/src/env.d.ts
@@ -0,0 +1,8 @@
+/// <reference types="astro/client" />
+
+/**
+ * Repository version from the workspace root `package.json`, injected at
+ * build time by `astro.config.mjs` through Vite `define`. Used by the download
+ * pages' offline fallback (`src/lib/downloads.ts`).
+ */
+declare const __IPTVNATOR_VERSION__: string;
diff --git a/apps/website/src/layouts/BlogPost.astro b/apps/website/src/layouts/BlogPost.astro
index 1a0dcbb45..63a82be8a 100644
--- a/apps/website/src/layouts/BlogPost.astro
+++ b/apps/website/src/layouts/BlogPost.astro
@@ -1,6 +1,12 @@
 ---
 import BaseLayout from './BaseLayout.astro';
 import GiscusComments from '../components/GiscusComments.astro';
+import FaqAccordion from '../components/blog/FaqAccordion.astro';
+
+interface FaqEntry {
+  q: string;
+  a: string;
+}
 
 interface Props {
   title: string;
@@ -10,9 +16,11 @@ interface Props {
   author: string;
   tags?: string[];
   heroImage?: string;
+  /** Optional FAQ from the post frontmatter: rendered after the body and emitted as FAQPage schema. */
+  faq?: FaqEntry[];
 }
 
-const { title, description, pubDate, updatedDate, author, tags = [], heroImage } = Astro.props;
+const { title, description, pubDate, updatedDate, author, tags = [], heroImage, faq = [] } = Astro.props;
 
 const formattedDate = pubDate.toLocaleDateString('en-US', {
   year: 'numeric',
@@ -52,6 +60,19 @@ const blogPostSchema = {
   mainEntityOfPage: canonicalURL,
   image: heroImage ? new URL(heroImage, Astro.site).toString() : undefined,
 };
+const faqSchema =
+  faq.length > 0
+    ? {
+        '@context': 'https://schema.org',
+        '@type': 'FAQPage',
+        mainEntity: faq.map((entry) => ({
+          '@type': 'Question',
+          name: entry.q,
+          acceptedAnswer: { '@type': 'Answer', text: entry.a },
+        })),
+      }
+    : null;
+const jsonLd = faqSchema ? [blogPostSchema, faqSchema] : blogPostSchema;
 ---
 
 <BaseLayout
@@ -62,7 +83,7 @@ const blogPostSchema = {
   publishedTime={pubDate.toISOString()}
   modifiedTime={(updatedDate ?? pubDate).toISOString()}
   keywords={tags}
-  jsonLd={blogPostSchema}
+  jsonLd={jsonLd}
 >
   <article class="pt-36 pb-24">
     <div class="relative mx-auto max-w-3xl px-6">
@@ -152,6 +173,17 @@ const blogPostSchema = {
         <slot />
       </div>
 
+      {faq.length > 0 && (
+        <section class="mt-16" aria-labelledby="post-faq-heading">
+          <hr class="section-divider" />
+          <span class="mt-12 block font-mono text-xs uppercase tracking-[0.2em] text-accent-500">FAQ</span>
+          <h2 id="post-faq-heading" class="mt-3 font-display text-2xl font-bold tracking-tight text-surface-50 sm:text-3xl">
+            Frequently asked questions
+          </h2>
+          <FaqAccordion items={faq} />
+        </section>
+      )}
+
       <GiscusComments />
     </div>
   </article>
diff --git a/apps/website/src/lib/downloads.ts b/apps/website/src/lib/downloads.ts
index d3607da59..09997587b 100644
--- a/apps/website/src/lib/downloads.ts
+++ b/apps/website/src/lib/downloads.ts
@@ -1,4 +1,3 @@
-import rootPackage from '../../../../package.json';
 import type { DownloadPlatform } from './platforms';
 
 /**
@@ -9,9 +8,13 @@ import type { DownloadPlatform } from './platforms';
  * exists, and so file sizes and the publish date can be shown. When the API
  * is unreachable (offline build, rate limit, `WEBSITE_SKIP_RELEASE_FETCH=1`)
  * the pages fall back to the repository version from the root `package.json`
+ * — injected as `__IPTVNATOR_VERSION__` by `astro.config.mjs`, since a
+ * relative import of the root manifest violates the Nx module boundaries —
  * and the known asset naming pattern from `electron-builder.json`.
  */
 
+const FALLBACK_VERSION = __IPTVNATOR_VERSION__;
+
 export const GITHUB_REPO = '4gray/iptvnator';
 export const REPO_URL = `https://github.com/${GITHUB_REPO}`;
 export const RELEASES_URL = `${REPO_URL}/releases`;
@@ -304,7 +307,7 @@ function normalizeAsset(value: unknown): ReleaseAsset[] {
 }
 
 function fallbackRelease(): ResolvedRelease {
-  const version = rootPackage.version;
+  const version = FALLBACK_VERSION;
   const tag = `v${version}`;
   const assets = Object.values(DOWNLOAD_OPTIONS)
     .flat()
@@ -323,5 +326,5 @@ function fallbackRelease(): ResolvedRelease {
 }
 
 function warnFallback(reason: string): void {
-  console.warn(`[website] Latest release lookup failed (${reason}); using package.json version ${rootPackage.version}.`);
+  console.warn(`[website] Latest release lookup failed (${reason}); using package.json version ${FALLBACK_VERSION}.`);
 }
diff --git a/apps/website/src/pages/blog/[...slug].astro b/apps/website/src/pages/blog/[...slug].astro
index 6e585a294..e1a94b27a 100644
--- a/apps/website/src/pages/blog/[...slug].astro
+++ b/apps/website/src/pages/blog/[...slug].astro
@@ -25,6 +25,7 @@ const { Content } = await render(post);
   author={post.data.author}
   tags={post.data.tags}
   heroImage={post.data.heroImage}
+  faq={post.data.faq}
 >
   <Content />
 </BlogPost>
diff --git a/apps/website/src/pages/download/linux.astro b/apps/website/src/pages/download/linux.astro
index c3c51d3ad..6e4a84604 100644
--- a/apps/website/src/pages/download/linux.astro
+++ b/apps/website/src/pages/download/linux.astro
@@ -298,7 +298,7 @@ sudo emerge iptvnator-bin</TerminalBlock>
   </DownloadSection>
 
   <DownloadSection id="guides" eyebrow="Keep reading" title="Guides and" accent="background">
-    <RelatedPosts slugs={['why-external-players-help', 'epg-guide', 'beware-unofficial-iptvnator-websites']} />
+    <RelatedPosts slugs={['xtream-codes-setup-guide', 'stalker-portal-setup-guide', 'beware-unofficial-iptvnator-websites']} />
     <div class="mt-10">
       <OfficialSourcesNote />
     </div>
diff --git a/apps/website/src/pages/download/macos.astro b/apps/website/src/pages/download/macos.astro
index 922a1a1d2..6408dab70 100644
--- a/apps/website/src/pages/download/macos.astro
+++ b/apps/website/src/pages/download/macos.astro
@@ -207,7 +207,7 @@ const jsonLd = buildDownloadPageSchema({
   </DownloadSection>
 
   <DownloadSection id="guides" eyebrow="Keep reading" title="Guides and" accent="background">
-    <RelatedPosts slugs={['macos-arm-app-damaged-fix', 'embedded-mpv-macos-experiment', 'why-external-players-help']} />
+    <RelatedPosts slugs={['xtream-codes-setup-guide', 'stalker-portal-setup-guide', 'macos-arm-app-damaged-fix']} />
     <div class="mt-10">
       <OfficialSourcesNote />
     </div>
diff --git a/apps/website/src/pages/download/windows.astro b/apps/website/src/pages/download/windows.astro
index c3a2353ee..fb59486e3 100644
--- a/apps/website/src/pages/download/windows.astro
+++ b/apps/website/src/pages/download/windows.astro
@@ -228,7 +228,7 @@ const jsonLd = buildDownloadPageSchema({
   </DownloadSection>
 
   <DownloadSection id="guides" eyebrow="Keep reading" title="Guides and" accent="background">
-    <RelatedPosts slugs={['why-external-players-help', 'epg-guide', 'beware-unofficial-iptvnator-websites']} />
+    <RelatedPosts slugs={['xtream-codes-setup-guide', 'stalker-portal-setup-guide', 'beware-unofficial-iptvnator-websites']} />
     <div class="mt-10">
       <OfficialSourcesNote />
     </div>
diff --git a/apps/xtream-mock-server/src/app/generators/marketing.generator.ts b/apps/xtream-mock-server/src/app/generators/marketing.generator.ts
index 855983dc1..bf8aee164 100644
--- a/apps/xtream-mock-server/src/app/generators/marketing.generator.ts
+++ b/apps/xtream-mock-server/src/app/generators/marketing.generator.ts
@@ -1,7 +1,18 @@
 import {
+    MARKETING_LIVE_CATEGORIES,
+    MARKETING_LIVE_CHANNELS,
+    MarketingLiveCategoryKey,
+    MarketingLiveChannelFixture,
     MarketingMovieCategoryKey,
     MarketingMovieFixture,
     POSTER_SHOWCASE_MOVIES as SHARED_POSTER_SHOWCASE_MOVIES,
+    escapeMarketingSvg,
+    marketingHash,
+    marketingPalette,
+    marketingSlug,
+    marketingSvgDocument,
+    marketingTitleFromSlug,
+    renderMarketingLogoSvg,
 } from '@iptvnator/shared/marketing-fixtures';
 import { RawCategory } from './categories.generator.js';
 import {
@@ -38,12 +49,6 @@ type MarketingSeries = {
     year: number;
 };
 
-type MarketingLiveChannel = {
-    categoryId: string;
-    epgTitles: string[];
-    name: string;
-};
-
 export type MarketingArtworkFixture = {
     contentType: 'movie' | 'series';
     description: string;
@@ -70,12 +75,20 @@ const MARKETING_SERIES_ID_BASE = 72_000;
 const MARKETING_EPISODE_ID_BASE = 82_000;
 const ADDED_BASE = 1_777_000_000;
 
-const LIVE_CATEGORIES: RawCategory[] = [
-    { category_id: '5101', category_name: 'Newsroom', parent_id: 0 },
-    { category_id: '5102', category_name: 'Sports & Motion', parent_id: 0 },
-    { category_id: '5103', category_name: 'Family Channels', parent_id: 0 },
-    { category_id: '5104', category_name: 'Culture & Docs', parent_id: 0 },
-];
+const XTREAM_LIVE_CATEGORY_IDS: Record<MarketingLiveCategoryKey, string> = {
+    newsroom: '5101',
+    sports: '5102',
+    family: '5103',
+    culture: '5104',
+};
+
+const LIVE_CATEGORIES: RawCategory[] = MARKETING_LIVE_CATEGORIES.map(
+    (category) => ({
+        category_id: XTREAM_LIVE_CATEGORY_IDS[category.key],
+        category_name: category.name,
+        parent_id: 0,
+    })
+);
 
 const VOD_CATEGORIES: RawCategory[] = [
     { category_id: '5201', category_name: 'Action & Mystery', parent_id: 0 },
@@ -116,48 +129,8 @@ const SERIES_CATEGORIES: RawCategory[] = [
     { category_id: '5304', category_name: 'Creative Docs', parent_id: 0 },
 ];
 
-const LIVE_CHANNELS: MarketingLiveChannel[] = [
-    {
-        categoryId: '5101',
-        name: 'Aurora News',
-        epgTitles: ['Morning Briefing', 'City Desk', 'Global Window'],
-    },
-    {
-        categoryId: '5101',
-        name: 'Civic One',
-        epgTitles: ['Town Hall Live', 'Policy Today', 'Open Forum'],
-    },
-    {
-        categoryId: '5102',
-        name: 'Fieldside Sports',
-        epgTitles: ['Training Ground', 'Matchday Studio', 'Final Whistle'],
-    },
-    {
-        categoryId: '5102',
-        name: 'Motion Arena',
-        epgTitles: ['Court Vision', 'Trackside', 'Night Highlights'],
-    },
-    {
-        categoryId: '5103',
-        name: 'Horizon Kids',
-        epgTitles: ['Rocket Workshop', 'Tiny Explorers', 'Story Lantern'],
-    },
-    {
-        categoryId: '5103',
-        name: 'Kitchen Lab',
-        epgTitles: ['Breakfast Builders', 'Family Table', 'Sweet Science'],
-    },
-    {
-        categoryId: '5104',
-        name: 'Atlas Docs',
-        epgTitles: ['Ocean Notes', 'Museum Hour', 'Wide Angle'],
-    },
-    {
-        categoryId: '5104',
-        name: 'Night Music',
-        epgTitles: ['Studio Session', 'Late Set', 'Ambient City'],
-    },
-];
+const LIVE_CHANNELS: readonly MarketingLiveChannelFixture[] =
+    MARKETING_LIVE_CHANNELS;
 
 const GENERATED_ARTWORK_MOVIES: MarketingMovie[] = [
     {
@@ -570,7 +543,7 @@ export function listMarketingArtworkFixtures(): MarketingArtworkFixture[] {
             description: movie.description,
             genre: movie.genre,
             name: movie.name,
-            slug: slugify(movie.name),
+            slug: marketingSlug(movie.name),
             tagline: movie.tagline,
             year: movie.year,
         })),
@@ -579,7 +552,7 @@ export function listMarketingArtworkFixtures(): MarketingArtworkFixture[] {
             description: series.description,
             genre: series.genre,
             name: series.name,
-            slug: slugify(series.name),
+            slug: marketingSlug(series.name),
             tagline: series.tagline,
             year: series.year,
         })),
@@ -741,7 +714,7 @@ export function marketingAssetUrl(
     title: string,
     size: string
 ): string {
-    return `${marketingAssetOrigin()}/assets/marketing/${kind}/${slugify(
+    return `${marketingAssetOrigin()}/assets/marketing/${kind}/${marketingSlug(
         title
     )}.svg?size=${encodeURIComponent(size)}`;
 }
@@ -752,41 +725,19 @@ export function renderMarketingAssetSvg(
     size: string | undefined
 ): string {
     const { width, height } = parseSize(size, kind);
-    const title = titleFromSlug(slug);
-    const palette = paletteFor(`${kind}:${slug}`);
-    const initials = title
-        .split(/\s+/)
-        .filter(Boolean)
-        .slice(0, 2)
-        .map((part) => part[0]?.toUpperCase() ?? '')
-        .join('');
-
+    const title = marketingTitleFromSlug(slug);
+    const palette = marketingPalette(`${kind}:${slug}`);
     if (kind === 'logo') {
-        return svgDocument(
-            width,
-            height,
-            `
-            <defs>
-                <linearGradient id="bg" x1="0" x2="1" y1="0" y2="1">
-                    <stop offset="0%" stop-color="${palette[0]}" />
-                    <stop offset="100%" stop-color="${palette[1]}" />
-                </linearGradient>
-            </defs>
-            <rect width="100%" height="100%" rx="${width * 0.22}" fill="url(#bg)" />
-            <circle cx="${width * 0.72}" cy="${height * 0.25}" r="${width * 0.2}" fill="${palette[2]}" opacity="0.35" />
-            <path d="M ${width * 0.16} ${height * 0.72} C ${width * 0.35} ${height * 0.48}, ${width * 0.58} ${height * 0.92}, ${width * 0.84} ${height * 0.58}" fill="none" stroke="#fff" stroke-width="${Math.max(8, width * 0.05)}" stroke-linecap="round" opacity="0.42" />
-            <text x="50%" y="54%" dominant-baseline="middle" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="${width * 0.3}" font-weight="800" fill="#fff">${escapeSvg(initials)}</text>
-            `
-        );
+        return renderMarketingLogoSvg(slug, size);
     }
 
     if (kind === 'backdrop' || kind === 'episode') {
         const skylineY = height * 0.7;
-        const heroX = width * (0.34 + (hash(slug) % 20) / 100);
+        const heroX = width * (0.34 + (marketingHash(slug) % 20) / 100);
         const heroY = height * 0.38;
-        const accentX = width * (0.68 + (hash(`${slug}:light`) % 16) / 100);
+        const accentX = width * (0.68 + (marketingHash(`${slug}:light`) % 16) / 100);
 
-        return svgDocument(
+        return marketingSvgDocument(
             width,
             height,
             `
@@ -846,7 +797,7 @@ export function renderMarketingAssetSvg(
         }, [])
         .slice(0, 3);
 
-    return svgDocument(
+    return marketingSvgDocument(
         width,
         height,
         `
@@ -876,17 +827,17 @@ export function renderMarketingAssetSvg(
         ${titleLines
             .map(
                 (line, index) =>
-                    `<text x="${width * 0.08}" y="${height * 0.58 + index * titleFontSize * 1.05}" font-family="Arial, Helvetica, sans-serif" font-size="${titleFontSize}" font-weight="900" fill="#ffffff">${escapeSvg(line.toUpperCase())}</text>`
+                    `<text x="${width * 0.08}" y="${height * 0.58 + index * titleFontSize * 1.05}" font-family="Arial, Helvetica, sans-serif" font-size="${titleFontSize}" font-weight="900" fill="#ffffff">${escapeMarketingSvg(line.toUpperCase())}</text>`
             )
             .join('')}
-        <text x="${width * 0.08}" y="${height * 0.84}" font-family="Arial, Helvetica, sans-serif" font-size="${Math.max(11, height * 0.024)}" font-weight="800" fill="#ffffff" opacity="0.76">${escapeSvg(creditLine)}</text>
+        <text x="${width * 0.08}" y="${height * 0.84}" font-family="Arial, Helvetica, sans-serif" font-size="${Math.max(11, height * 0.024)}" font-weight="800" fill="#ffffff" opacity="0.76">${escapeMarketingSvg(creditLine)}</text>
         <text x="${width * 0.08}" y="${height * 0.9}" font-family="Arial, Helvetica, sans-serif" font-size="${Math.max(12, height * 0.028)}" font-weight="700" fill="#ffffff" opacity="0.72">IPTVnator fictional demo artwork</text>
         `
     );
 }
 
 function buildMarketingLiveStream(
-    channel: MarketingLiveChannel,
+    channel: MarketingLiveChannelFixture,
     index: number
 ): RawLiveStream {
     const streamId = MARKETING_LIVE_STREAM_ID_BASE + index;
@@ -898,7 +849,7 @@ function buildMarketingLiveStream(
         stream_icon: marketingAssetUrl('logo', channel.name, '256x256'),
         epg_channel_id: `marketing-channel-${streamId}`,
         added: String(ADDED_BASE - index * 4_000),
-        category_id: channel.categoryId,
+        category_id: XTREAM_LIVE_CATEGORY_IDS[channel.categoryKey],
         custom_sid: '',
         direct_source: '',
         tv_archive: 1,
@@ -957,7 +908,7 @@ function buildMarketingSeriesItem(
 
 function buildMarketingEpgListings(
     stream: RawLiveStream,
-    titles: string[]
+    titles: readonly string[]
 ): RawEpgListing[] {
     const now = Math.floor(Date.now() / 1000);
     const slotSeconds = 30 * 60;
@@ -984,22 +935,6 @@ function marketingAssetOrigin(): string {
     return `http://localhost:${port}`;
 }
 
-function slugify(value: string): string {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-
-function titleFromSlug(slug: string): string {
-    return slug
-        .replace(/\.svg$/i, '')
-        .split('-')
-        .filter(Boolean)
-        .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
-        .join(' ');
-}
-
 function parseSize(
     size: string | undefined,
     kind: MarketingAssetKind
@@ -1022,19 +957,6 @@ function parseSize(
     };
 }
 
-function paletteFor(seed: string): [string, string, string] {
-    const palettes: Array<[string, string, string]> = [
-        ['#0b1026', '#1b6b77', '#f2a65a'],
-        ['#15111f', '#6b3fa0', '#20c7b5'],
-        ['#071b2c', '#2457a6', '#f05d5e'],
-        ['#1b1b24', '#8d4f2a', '#e9c46a'],
-        ['#10251d', '#2a9d8f', '#e76f51'],
-        ['#18151f', '#b23a48', '#f4a261'],
-    ];
-    const index = hash(seed) % palettes.length;
-    return palettes[index];
-}
-
 function creditLineFor(seed: string): string {
     const credits = [
         'STARRING MARA SOL / THEO QUILL / IRIS VALE',
@@ -1044,23 +966,6 @@ function creditLineFor(seed: string): string {
         'STARRING NICO REED / TESSA MOON / BRAM COLE',
         'STARRING ELLE FENN / RAFI NORTH / MIRA STONE',
     ];
-    return credits[hash(seed) % credits.length];
+    return credits[marketingHash(seed) % credits.length];
 }
 
-function hash(value: string): number {
-    return value.split('').reduce((acc, char) => {
-        return (acc * 31 + char.charCodeAt(0)) >>> 0;
-    }, 0);
-}
-
-function svgDocument(width: number, height: number, body: string): string {
-    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img">${body}</svg>`;
-}
-
-function escapeSvg(value: string): string {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
diff --git a/docs/architecture/embedded-mpv-native.md b/docs/architecture/embedded-mpv-native.md
index e26770d91..df7135415 100644
--- a/docs/architecture/embedded-mpv-native.md
+++ b/docs/architecture/embedded-mpv-native.md
@@ -513,6 +513,143 @@ button disabled state at current-season boundaries.
 
 Autoplay is enabled by default for series playback in embedded MPV. On `ended`, Xtream and Stalker series detail views start the next episode only when the current episode has a next item in the same season. Playback stops on the last episode of the current season. Previous always switches to the previous episode in the current season; it does not implement a restart-threshold behavior.
 
+## Session Options (Extra libmpv Options)
+
+`Settings > Playback > Extra embedded MPV options` is a free-form textarea,
+one `key=value` per line without the leading `--`. The renderer keeps the
+canonical text (`normalizeEmbeddedMpvExtraOptions`) and refuses to save
+malformed lines or the keys the embed depends on
+(`EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS`: `wid`, `vo`, `force-window`,
+`input-ipc-server`, `idle`, `keep-open`, `config`, `include`, `terminal`);
+the `SETTINGS_UPDATE` handler mirrors the text into the main-process config
+(`EMBEDDED_MPV_EXTRA_OPTIONS`), because sessions are created there.
+
+At session creation the IPC handler reads the mirror through
+`readEmbeddedMpvSessionOptions()` and passes
+`resolveEmbeddedMpvSessionOptionArguments()` to
+`EmbeddedMpvNativeService.createSession(..., options)`. That list is the
+network defaults followed by the user's allowed lines, and every engine
+applies it after its own built-in options and before `mpv_initialize`, so a
+user line overrides both:
+
+| Engine              | Transport                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Windows native-view | `createSession(..., string[])` → `mpv_set_option_string`                                                                                                                                                                                                                                                                                                                                                                 |
+| macOS native-view   | same, in `embedded_mpv.mm`                                                                                                                                                                                                                                                                                                                                                                                               |
+| Linux native-view   | written to a user-only (0600) config file under `userData/embedded-mpv/options-<pid>/` and referenced as `--include=<path>` on the `mpv --wid` command line (before the per-playback options, so a playlist's user-agent/headers still win); the file is removed on dispose, the instance directory on shutdown, and another instance's leftovers only once its process is gone (two instances may share one `userData`) |
+| Frame-copy helper   | the first stdin line (`mpv-options`, helper started with `--mpv-options-stdin`), applied after the helper's built-in block                                                                                                                                                                                                                                                                                               |
+
+The list never appears on a command line: an option such as
+`http-header-fields=Authorization: …` would otherwise be readable by every
+local user through `ps` / `/proc/<pid>/cmdline`.
+
+`EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS` (`network-timeout=10`,
+`demuxer-lavf-o=reconnect=1,reconnect_streamed=1,reconnect_delay_max=5`) are
+part of that list on purpose: a stalled IPTV connection then surfaces as an
+mpv error within seconds instead of libmpv's 60 s default, and ffmpeg
+re-requests a dropped HTTP stream on its own before the app-level reconnect
+has to. Options mpv rejects never fail session creation, and a rejection is
+reported without any trace flag, by key only (a value may carry credentials):
+the Windows and macOS native-view engines collect the refused keys into the
+snapshot's `rejectedOptionKeys`, which the service logs once per session as a
+main-process warning; the frame-copy helper emits a `log` warn event with
+prefix `iptvnator` that the adapter forwards unconditionally. The Linux
+native-view path is the exception: mpv skips a bad `--include` line and
+continues, but reports it only on its own stderr, which the addon discards
+(`--really-quiet`; `IPTVNATOR_TRACE_EMBEDDED_MPV` writes it to
+`/tmp/iptvnator-embedded-mpv.log`). The service itself never
+touches the config store — it is constructed at module load, and importing it
+would drag electron-conf into every consumer of the service, its unit tests
+included.
+
+## Network Auto-Reconnect
+
+`EmbeddedMpvReconnectCoordinator`
+(`apps/electron-backend/src/app/services/embedded-mpv-reconnect.ts`) reloads
+the last user-requested playback when a session reports a stream loss: an
+`error` status, or `ended` while the playback is live (`isLive`, else "no
+`contentInfo`", the same rule the renderer uses). It is driven by
+`refreshSession()` status transitions, so it covers every engine, and it is
+captured per session from `Settings.embeddedMpvAutoReconnect` (default on;
+mirrored as `EMBEDDED_MPV_AUTO_RECONNECT`). The policy is deliberately narrow:
+
+- Only a load that already reached `playing` is retried. A URL that never
+  worked (404, refused credentials, unsupported container) keeps the manual
+  Retry instead of hammering the panel six times with the same request. The
+  Linux `mpv --wid` path keeps a freshly spawned process at `loading` until
+  its poller sees a decoded `time-pos`, so a URL that never opens is never
+  counted as played there either; the poller also reads `eof-reached` over
+  the IPC socket so a stream that ended reports `ended` rather than the
+  `paused` that keep-open would otherwise look like, and an mpv process that
+  exits abnormally reports `error`.
+- Backoff is 2 s, 4 s, 8 s, 16 s, 30 s, 30 s, at most six attempts per
+  outage. The budget resets only after 30 s of uninterrupted `playing`, so a
+  stream that flaps every few seconds runs out of attempts instead of being
+  retried forever.
+- A user-driven `loadPlayback`, `paused`/`idle`, dispose, and shutdown cancel
+  a pending attempt; a stream that recovers on its own (ffmpeg-level
+  reconnect) while a retry is pending drops the retry. A pause also disarms
+  the policy until the stream plays again, so a drop while the user has the
+  stream paused shows the error instead of resuming playback unasked.
+- Each attempt is tracked from the moment its reload is issued, so a reload
+  that fails before the 500 ms poll ever observes it `loading` still counts
+  as a failed attempt and schedules the next one.
+- An `error` the engine attributes to itself — `errorOrigin: 'engine'` in
+  the native snapshot: a fatal libmpv log in the frame-copy helper, a dead
+  helper, a macOS render-context failure — is not a stream loss. Reloading
+  media cannot repair a broken engine, so it stays the terminal error with
+  Retry; only stream-side errors (load and `END_FILE` failures, the Linux
+  process exiting) are retried.
+- A reload the engine cannot take at all — a frame-copy helper that has
+  exited (exit code, signal death, or a closed stdin), reported by the
+  adapter as `EmbeddedMpvSessionGoneError` — ends the
+  reconnect immediately: only a new session can recover, and the renderer's
+  Retry creates one, so the actionable error is shown instead of a reconnect
+  spinner that nothing could ever advance.
+- Any other refused reload (the addon throws) continues the backoff itself,
+  because no status transition will ever arrive for it.
+- A non-live reload carries the last position observed while playing as
+  `startTime` (seeded from the playback's own `startTime`), so a movie or
+  episode resumes where the connection dropped instead of at the offset the
+  user originally resumed from; a reported zero counts only after a positive
+  position was seen, because engine snapshots start at zero before the first
+  `time-pos`. Live reloads go back to the live edge.
+- Every reload is followed by `setPaused(false)`: sessions run with
+  `keep-open=yes`, so EOF leaves mpv paused at the end of the old file and a
+  plain `loadfile` inherits that pause — the reloaded live stream would
+  buffer, report `paused` and never play. The engines apply that pause
+  toggle optimistically only while already `playing`/`paused`, so the
+  reload stays `loading` until the media actually opens and the attempt
+  indicator is not cleared early.
+
+Every engine flips to `loading` synchronously on a load (the frame-copy
+adapter does so optimistically before the helper confirms), which is what
+lets a failed attempt always be observed as `loading` → loss and never as
+loss → loss. While an attempt is scheduled or in flight the session carries
+`EmbeddedMpvSession.reconnect` (`attempt`, `maxAttempts`, `nextAttemptAt`);
+the renderer shows "Reconnecting… attempt N of M" in the error overlay and,
+for shared controls, as a `loading` status message, keeps Retry available
+(it disposes the session, which cancels the timer), and never schedules
+anything itself. A live stream that sits at `ended` with no reconnect in
+progress (the budget is spent, or the setting is off) is shown as "The live
+stream ended." with Retry — for shared controls as an `error` status — since
+the plain `ended` state otherwise looks like a paused player. A recording that
+was running when the stream dropped is finalized by the recording tracker as
+an interrupted partial at the moment the reload replaces the stream (which
+stops `stream-record`; the tracker's `onRecordingInterrupted` keeps that
+verdict even if the engine shows the old recording as active for one more
+tick), and once the reload plays the service starts it again into a fresh
+file with the same folder, title and metadata, so the manager lists both
+parts. A stream that recovers by itself before the reload fires keeps its
+recording running untouched; an explicit stop or a user-driven load never
+restarts anything. An external subtitle file added through `sub-add` is
+dropped by the reload as well (the engines clear their tracks on
+`START_FILE`), so the service remembers the last added file and re-adds it
+once the reload plays — the helper's `sub-add` selects the added track, and
+`sub-delay` is an mpv-global property that survives on its own. An explicit
+subtitle-track pick after the add, a user-driven load or a missing file hand
+the selection back to the user and restore nothing.
+
 ## Live Stream Recording
 
 Embedded MPV can record live streams through mpv's `stream-record` option. IPTVnator exposes this only for playback classified as live (`ResolvedPortalPlayback.isLive` when present, otherwise no `contentInfo`); VOD, episodes, catchup playback, radio audio playback, and non-embedded players do not show the recording control.
diff --git a/docs/architecture/player-controls-contract.md b/docs/architecture/player-controls-contract.md
index d2476569b..7af2cb2b2 100644
--- a/docs/architecture/player-controls-contract.md
+++ b/docs/architecture/player-controls-contract.md
@@ -358,6 +358,28 @@ focus) or only a transfer inside the bar, which `focusout` ignores by design,
 so the pin cannot be cleared from focus events alone. Without
 this distinction the fullscreen button kept the controls on screen until a
 click on the viewport took focus away — and that click also paused playback.
+
+The focus a pointer click leaves on a control is released once the click
+completes (`onBarClick` → `ControlsSurface.releasePointerFocus`). A focused
+control captures the keyboard: Space and Enter activate it again, and
+`ControlsShortcuts` yields to any interactive element in the key's path, so
+after a click on the fullscreen button Space left fullscreen instead of
+pausing and the seek, volume, and mute keys did nothing.
+`ControlsSurface.wasPointerClick` attributes the click by its `pointerType`
+(non-empty for a pointer; empty for Enter/Space activation and
+`element.click()`), and a legacy `MouseEvent` click by a recent press inside
+the clicked element, answered once per press and discarded on any key press.
+Keyboard activation therefore keeps focus where Tab put it. Only buttons and
+range sliders are released; text entry would keep its focus, and the bar
+holds none. Chromium keeps its sequential focus navigation starting point at
+the blurred control, so a later Tab continues from it exactly as if it were
+still focused; the clicked button's tooltip hides with the focus. The release
+dispatches a `focusout` while the pointer still rests on the control, so the
+volume anchor's `focusout` handler skips its popover close for it
+(`wasPointerFocusRelease`), while focus leaving by keyboard still closes the
+popover. A press that never completes into a click (released off the
+control) is the one case that still leaves pointer-originated focus behind,
+which is why the key-press re-pin above remains.
 In fullscreen playback, hiding the controls also hides the pointer
 over both the controls host and the supplied player surface; revealing controls
 or destroying the component restores the surface's previous inline cursor.
@@ -409,7 +431,41 @@ straight to the engine:
 - **Video.js** (`vjs-legacy-shortcuts.ts`) goes through the player API so the
   vendor control bar stays in sync; F uses the player's
   `requestFullscreen`/`exitFullscreen`. The legacy configuration still never
-  enables `userActions.hotkeys`.
+  enables `userActions.hotkeys`. The chrome also releases the focus a pointer
+  interaction leaves on a control (`vjs-pointer-focus-release.ts`, the vendor
+  counterpart of `ControlsSurface.releasePointerFocus`, sharing
+  `pointer-focus-release.ts`'s `blurFocusedControl`): Chromium focuses a
+  clicked control-bar `<button>` or slider, and a focused Video.js component
+  captures the keyboard entirely — `Component.handleKeyDown` stops the
+  propagation of every key and `ClickableComponent` turns Space and Enter into
+  a click — so after a click on the fullscreen button Space left fullscreen
+  instead of pausing and the document-level shortcuts never saw a key. The
+  release is driven mainly by the focus landing, not the click: choosing a
+  menu item moves focus to the menu button a tick after the click
+  (`MenuItem.handleTapClick`) and that selection click never bubbles to the
+  shell, so a click handler alone would be both too early and unreached. A
+  `focusin` on an eligible control (a `<button>`, `role="button"` clickable, or
+  slider; never a `role="menuitem*"`) is released when it is attributable to a
+  recent `pointerdown` inside the shell not yet ended by a document `keydown`,
+  so keyboard `Tab` focus is preserved. A `click` runs the same release,
+  because clicking a control that was already focused (Tab, then a mouse click
+  on it) moves no focus and fires no `focusin`; a keyboard-activation click
+  carries no `pointerdown`, so attribution keeps that focus. The release is
+  scoped to the `.vjs-control-bar`, the persistent chrome that hands keys back
+  to the document; the player's other focusable surfaces manage their own
+  focus and keep it — in particular the caption-settings dialog
+  (`.vjs-text-track-settings`, a modal sibling of the control bar under
+  `.video-js`) traps focus for its Escape/Tab handling, so its Reset button is
+  left alone. Menu buttons live in the control bar and are not exempt: a
+  Video.js popup is navigated through its focused item, not its button, so
+  releasing the button never disturbs an open menu — opening focuses the item,
+  and the button focus a pointer moves through (the transient press on open,
+  item selection, and toggling an open menu shut) is released, which is what
+  lets Space work again after a menu is dismissed by clicking its button a
+  second time. ArtPlayer needs no
+  counterpart (its controls are non-focusable divs), nor do the native HTML5
+  controls (a click focuses the `<video>`, which the shortcuts do not treat as
+  interactive).
 - **ArtPlayer** (`art-player-legacy-shortcuts.ts`) uses the vendor setters its
   own hotkeys used (`toggle`, `forward`/`backward`, `volume`, `muted`,
   `fullscreen`), so ArtPlayer's notices and UI stay in sync. The legacy chrome
@@ -465,7 +521,8 @@ the last second (`wasTouchInteraction`). Three behaviors diverge from mouse:
   the hover-open path is suppressed and the first tap on the volume button
   opens the popover instead of muting; a tap while it is open toggles mute as
   the button's label says. Touch-attributed `focusout` does not schedule the
-  popover close (outside taps and other menu buttons dismiss it).
+  popover close (outside taps and other menu buttons dismiss it), and neither
+  does the `focusout` of a pointer focus release.
 - **Coarse-pointer scrub sizing.** Under `@media (pointer: coarse)` the
   timeline/volume sliders grow their input hit strip to 28px and the thumb to
   18px; the 4px visual track is unchanged.
diff --git a/docs/architecture/release-pipeline.md b/docs/architecture/release-pipeline.md
index ddf11e0fe..190662226 100644
--- a/docs/architecture/release-pipeline.md
+++ b/docs/architecture/release-pipeline.md
@@ -91,8 +91,9 @@ Highlights drive three behaviors:
   dropping from the tail of the grouped list, which is ordered breaking →
   feature → fix → perf so the least consequential go first. A breaking change
   is never dropped there either.
-- **The blog scaffold** uses the highlight as a ready `###` heading instead of
-  emitting `TODO headline (<area>)`.
+- **The blog scaffold** gives each highlight a row in the opening "What
+  changed" table and its own `##` section ahead of everything else, instead of
+  emitting `TODO headline (<area>)`. Shape below.
 
 Prose fields keep `#`. `parseFrontmatterLine` strips trailing `# comment` text
 only from closed-vocabulary fields (`type`, `area`, `issues`, `screenshot`),
@@ -106,6 +107,33 @@ Both announcement formats then print an explanation on stderr, leave stdout
 empty, and exit 0 — the same shape `extract-changelog-section.mjs --public`
 already uses for its empty public body.
 
+## Blog scaffold shape
+
+`renderBlogScaffold` (`tools/release/release-notes-blog.mjs`) emits the shape
+the published posts end up in, so the editor starts from the form rather than
+from the inventory — the v0.23 post shipped as the raw type-grouped list with
+area prefixes and had to be restructured after publication. In order:
+narrative intro (TODO) → `ReleaseMeta` → `## What changed` (a `ChangeTable`
+with one row per highlight; the theme is the default area label, the impact a
+TODO) → the "About the screenshots" alert when any note names a screenshot →
+one `##` section per highlight or screenshot note, with a `StatusPill`
+matching the note type → `## Breaking changes` → the remaining features folded
+into themed `##` sections → `## Performance` → `## Everything else`, holding
+every remaining fix under a `Spoiler` grouped by theme → the before-updating
+alert → `## Thanks` → `## Download` link cards (release tag, full notes, the
+compare link when a previous version is known, all releases).
+
+Themes come from `BLOG_THEMES`: a conventional-commit `area` says nothing to a
+reader ("matching", "window-controls", "electron-backend"), so notes fold into
+reader-facing headings ("Stalker portals", "Live TV, EPG and M3U"). An unmapped
+area lands in "Other changes" rather than failing; add it to the map when it
+recurs. Two defaults are deliberately dumb: every non-highlighted fix goes into
+the spoiler, and every bullet keeps its full note body. Promoting the fixes
+users will notice, compressing bullets to one line and writing the bold
+lead-ins is the editorial pass, and the scaffold marks where with `TODO`. Only
+the components the post actually uses are imported, so an MDX build never
+fails on an unused import.
+
 ## Highlight cards
 
 `tools/release/highlight-cards.mjs` plans and lays out;
@@ -127,6 +155,23 @@ Screenshots come only from the capture script running against the mock servers.
 Never publish one taken from a real playlist or account — streams, logos and
 metadata are copyrighted, and credentials must never reach a published image.
 
+The same script also produces the evergreen screenshots of the website guides.
+Manifest shots that carry `"group": "guides"` are skipped by a release run and
+captured only with `pnpm release:screenshots --group guides`, which publishes
+into `apps/website/public/blog/guides/screenshots/` instead of a release folder
+(`outputDirectoryFor` in `screenshot-guards.mjs`). Guide shots go through every
+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
+(`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
+one MAC-shaped string G4 accepts (`FICTIONAL_STALKER_MAC`); every other MAC
+still fails the frame. The scenario's live channels and logos come from
+`@iptvnator/shared/marketing-fixtures`, served by the mock itself, so no
+third-party image is ever requested.
+
 Output lands in `dist/release-highlight-cards/v<version>/`, outside version
 control — keyed by the exact version, because 0.24.0 and 0.24.1 share a blog
 post but not a card set. A run first removes the cards a previous run left in
diff --git a/docs/architecture/stalker-epg.md b/docs/architecture/stalker-epg.md
index cec340428..32f321bfc 100644
--- a/docs/architecture/stalker-epg.md
+++ b/docs/architecture/stalker-epg.md
@@ -310,6 +310,12 @@ therefore falls back to `get_short_epg` when:
 
 The fallback is merged with the bulk list rather than replacing it, so the
 panel shows "now" from the short EPG and the days ahead from the bulk guide.
+
+The fallback is keyed to the selected channel, not to the category: a category
+switch in the sidebar leaves the channel playing and keeps its fallback (and a
+fallback load still in flight) intact. It is dropped when the selection moves
+to another channel or when the view leaves ITV for radio, where the route
+session clears the selection.
 The stored fallback is tagged with the channel it was fetched for and the
 merge only applies while that channel is still selected — a channel switch
 moves the selection synchronously, while the old fallback is replaced only
diff --git a/docs/architecture/stalker-portal.md b/docs/architecture/stalker-portal.md
index 2eee0188c..9e077c038 100644
--- a/docs/architecture/stalker-portal.md
+++ b/docs/architecture/stalker-portal.md
@@ -1251,6 +1251,20 @@ The Stalker live route and radio route intentionally share
 - Some Stalker portals do not expose radio categories. Radio category loading
   falls back to a synthetic `PORTALS.ALL_RADIO` category with
   `category_id: '*'` so the station list can still be loaded.
+- A category click in the shell context panel only re-filters the channel
+  sidebar; the selected channel or station keeps playing (Xtream live #936 and
+  M3U group parity). `onStalkerCategoryClicked` therefore must NOT
+  `clearSelectedItem()` for `itv`/`radio` — the layout gates its player on
+  `selectedItem` — while VOD/series clicks still drop the open detail before
+  navigating to the list route. The layout's category-change reset effect
+  clears only list state (channels on the legacy paged flow, page, row EPG
+  previews); the active channel's short-EPG fallback and a fallback load still
+  in flight belong to the selection and survive the switch. Only a section
+  change (`itv` ↔ `radio`, where the route session clears the selection)
+  invalidates that request and drops the fallback. A playing channel outside
+  the newly selected category simply has no highlighted row, and remote
+  channel up/down finds no neighbour until a channel from the visible list is
+  played.
 
 ## Full ITV Channel List Cache
 
diff --git a/docs/architecture/workspace-shell.md b/docs/architecture/workspace-shell.md
index 8f2e8d168..63cc17262 100644
--- a/docs/architecture/workspace-shell.md
+++ b/docs/architecture/workspace-shell.md
@@ -146,6 +146,14 @@ default. The panel header exposes a sort menu next to category search with
 synthetic "all categories" entries stay pinned before sorted provider
 categories.
 
+A category click in a LIVE section (Xtream `live`, Stalker `itv` and `radio`)
+changes only the selected category: the live layouts gate their player on the
+store's selected item, so the handler must not clear it — the channel the user
+is watching keeps playing while the sidebar re-filters (Xtream: #936; Stalker:
+`onStalkerCategoryClicked` returns before `clearSelectedItem()`). VOD and
+series category clicks do drop the open detail (`setSelectedItem(null)` /
+`clearSelectedItem()`) because they navigate to a list route.
+
 ## Search And Navigation Rules
 
 Search is shell-owned and route-aware:
@@ -298,6 +306,96 @@ handlers in `apps/electron-backend/src/app/events/window.events.ts`):
    stuck the maximize/restore glyph on the wrong icon. Regression coverage:
    `app-window-state.spec.ts` and `window-controls.e2e.ts`.
 
+   The pushed `isFullScreen` is the OR of two flags tracked apart: native
+   (OS-level, fed by `enter/leave-full-screen`) and HTML-element (fed by
+   the `*-html-*` pair). Electron remembers when the window was already
+   natively fullscreen before the player entered HTML fullscreen and then
+   leaves ONLY the HTML state on exit — no `leave-full-screen` fires and the
+   window stays fullscreen — so a single flag cleared by
+   `leave-html-full-screen` would un-hide the controls over a window that
+   is still fullscreen. A fullscreen launch (below) or F11 followed by the
+   player's `F` → `Esc` makes that path routine on Windows/Linux.
+3. `WINDOW:TOGGLE_FULLSCREEN` toggles OS-level fullscreen (`setFullScreen`)
+   and, like the maximize toggle, reports the requested state and leaves
+   the `WINDOW:STATE_CHANGED` push authoritative. Because the transition is
+   asynchronous — `isFullScreen()` reports the old value until it lands,
+   and on Windows even while the matching event fires — a toggle must
+   never be decided against the getter. Every native fullscreen request
+   goes through the tracker in
+   `apps/electron-backend/src/app/services/native-fullscreen-transitions.ts`
+   (the F11 toggle AND the startup fallback below). Like the state pushes
+   above it keeps its own per-window fullscreen state, seeded from the
+   getter once at window creation (`trackNativeFullScreen` in
+   `initMainWindow`, while no transition can be in flight) and fed
+   afterwards only by the `enter`/`leave-full-screen` events, which also
+   cover transitions the app did not request. A toggle is decided against
+   the pending target while a transition is in flight, else against that
+   tracked state: two quick presses are an enter-then-exit, not two enters,
+   and F11 during the startup animation leaves fullscreen instead of asking
+   for it again. The tracker observes and never issues a request on its
+   own. The pending record is the LATEST requested target: an event landing
+   on it clears it, an event landing on the other state (an earlier request
+   of a burst landed first; ours is still queued) leaves it in place so the
+   next press still follows the user's latest intent, and a record older
+   than `FULLSCREEN_TRANSITION_TIMEOUT_MS` (2 s) is ignored. Events cannot
+   say which request they belong to, so any automatic "repeat the target"
+   on a mismatch is indistinguishable from reversing the user's own
+   green-button/Ctrl+Cmd+F action and is deliberately not done: should a
+   platform ever drop a queued request (Electron queues them on macOS and
+   applies them synchronously elsewhere), the record expires, the event-fed
+   state takes over and the next press corrects the window. The renderer
+   binds it to
+   **F11** in `WorkspaceKeyboardShortcutsService` (deliberately not gated
+   by `isTypingInInput` — it must work from any focus, because it is the
+   only exit from a fullscreen launch on Windows/Linux, where the title bar
+   is hidden and the controls hide themselves) and skips the key while
+   `document.fullscreenElement` is set, since the player's own `F` / `Esc`
+   own HTML fullscreen and F11 must not yank OS fullscreen out from under
+   it. Without a bridge (PWA) F11 is left to the browser.
+
+Startup window mode (`Settings.startupWindowMode`, issue #1455):
+
+1. `normal` (default) / `maximized` / `fullscreen`, chosen in Settings →
+   General ("Window on startup"). Electron only — the select renders only
+   when `RuntimeCapabilitiesService.supportsStartupWindowMode` sees both
+   `updateSettings` and `toggleFullScreenWindow` on the bridge, so the mode
+   is never offered without its F11 exit.
+2. Settings live in the renderer's IndexedDB, which the main process cannot
+   read at window creation, so the `SETTINGS_UPDATE` handler mirrors the
+   value into electron-conf (`STARTUP_WINDOW_MODE`, the same pattern as the
+   frame-copy flag) and `initMainWindow` reads it synchronously. A change
+   therefore applies on the next launch. Both sides normalize through
+   `normalizeStartupWindowMode`, so junk never reaches the config file or
+   the window options.
+3. `fullscreen` is the `BrowserWindow` constructor option: on Windows/Linux
+   the window is created hidden and enters fullscreen before its first
+   paint. macOS ignores the option while the window is hidden (an NSWindow
+   only toggles fullscreen once it is on screen), so `ready-to-show` repeats
+   the request with `setFullScreen(true)` right after `show()` wherever
+   `isFullScreen()` is still false — never unconditionally, or the
+   platforms that honoured the option would animate a second toggle. The
+   saved bounds stay spread into the options — they are the normal bounds
+   the window returns to, and the close handler keeps persisting
+   `getNormalBounds()`. `maximized` calls `maximize()` inside
+   `ready-to-show` right before `show()`, never earlier: `maximize()` on a
+   hidden window shows it, and a blank window would flash.
+4. `iptvnator --fullscreen` (read via `app.commandLine.hasSwitch`, so it can
+   sit anywhere in argv; the playlist-path extractor already skips every
+   `-`-prefixed argument) forces `fullscreen` for that launch only and is
+   never persisted. Resolution lives in
+   `apps/electron-backend/src/app/services/startup-window-mode.ts`. The
+   switch is consumed by the first window (`launchFullscreenSwitchConsumed`
+   in `App`): on macOS the process outlives its last window and the Dock
+   re-creates it through the same `initMainWindow`, which must then follow
+   the stored setting only. A second-instance launch carrying the switch is
+   ignored — the window already exists.
+5. Deliberately not offered: kiosk mode (removes the exit path) and
+   "remember last state" (bounds persistence stores normal bounds only; an
+   explicit choice is clearer). Regression coverage: `app.spec.ts`
+   ("startup window mode"), `settings.events.spec.ts`,
+   `window.events.spec.ts`, and the startup-window-mode cases in
+   `settings.e2e.ts`.
+
 Layout integration:
 
 1. `document.body` gets a `frameless-platform` class (set in
diff --git a/libs/portal/shared/util/src/lib/keyboard-shortcut-definitions.ts b/libs/portal/shared/util/src/lib/keyboard-shortcut-definitions.ts
index 8f5761aa3..5a1bab2cc 100644
--- a/libs/portal/shared/util/src/lib/keyboard-shortcut-definitions.ts
+++ b/libs/portal/shared/util/src/lib/keyboard-shortcut-definitions.ts
@@ -99,6 +99,18 @@ export const APP_KEYBOARD_SHORTCUTS: readonly KeyboardShortcutDefinition[] = [
         keys: ['Enter'],
         order: 40,
     },
+    {
+        // OS-level window fullscreen, distinct from the player's `F`
+        // (HTML-element fullscreen). Desktop only: the PWA leaves F11 to
+        // the browser.
+        id: 'toggle-window-fullscreen',
+        group: 'global',
+        labelKey: 'WORKSPACE.SHORTCUTS.ITEMS.TOGGLE_WINDOW_FULLSCREEN',
+        icon: 'fullscreen',
+        keys: ['F11'],
+        order: 50,
+        electronOnly: true,
+    },
     {
         id: 'toggle-sidebar',
         group: 'navigation',
diff --git a/libs/portal/shared/util/src/lib/keyboard-shortcuts.spec.ts b/libs/portal/shared/util/src/lib/keyboard-shortcuts.spec.ts
index 4eaac6390..d3e99c003 100644
--- a/libs/portal/shared/util/src/lib/keyboard-shortcuts.spec.ts
+++ b/libs/portal/shared/util/src/lib/keyboard-shortcuts.spec.ts
@@ -23,6 +23,8 @@ describe('keyboard shortcuts registry', () => {
         expect(ids).not.toContain('open-global-search');
         expect(ids).not.toContain('open-recently-viewed');
         expect(ids).not.toContain('close-player-popovers');
+        // The browser owns F11 in the PWA.
+        expect(ids).not.toContain('toggle-window-fullscreen');
         expect(ids).toContain('open-command-palette');
         // Playback shortcuts run in every runtime: the built-in web players
         // attach them through the legacy shortcut wiring in the PWA too.
@@ -33,6 +35,21 @@ describe('keyboard shortcuts registry', () => {
         expect(ids).toContain('mute-audio');
     });
 
+    it('lists the F11 window fullscreen toggle in the global group for Electron', () => {
+        const groups = getKeyboardShortcutGroups({
+            isMac: false,
+            isElectron: true,
+        });
+        const globalGroup = groups.find((group) => group.id === 'global');
+
+        expect(globalGroup?.items.map((item) => item.id)).toContain(
+            'toggle-window-fullscreen'
+        );
+        expect(findChordLabels(groups, 'toggle-window-fullscreen')).toEqual([
+            ['F11'],
+        ]);
+    });
+
     it('uses platform-specific modifier labels', () => {
         const macGroups = getKeyboardShortcutGroups({
             isMac: true,
diff --git a/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.spec.ts b/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.spec.ts
index 8574eb544..cf7f5ab51 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.spec.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.spec.ts
@@ -838,6 +838,104 @@ describe('StalkerLiveStreamLayoutComponent', () => {
         expect(stalkerStore.setItvChannels).toHaveBeenCalledWith([]);
     });
 
+    it('keeps the player and the playing channel EPG fallback when the category changes', async () => {
+        // A category click in the shell sidebar only re-filters the channel
+        // list — the selected channel keeps playing (Xtream live / M3U group
+        // parity). The category-change reset effect used to wipe the short-EPG
+        // fallback of that unchanged channel too, so on portals whose bulk
+        // guide lacks the current programme the panel lost "now" until the
+        // next channel switch.
+        mockFutureOnlyBulkEpg();
+
+        fixture.detectChanges();
+        await component.playChannel(itvChannels()[0]);
+        await fixture.whenStable();
+        fixture.detectChanges();
+
+        expect(component.currentProgram()?.title).toBe('Now 10001');
+
+        selectedCategoryId.set('42');
+        fixture.detectChanges();
+        await fixture.whenStable();
+        fixture.detectChanges();
+
+        expect(component.streamUrl()).toBe('https://example.com/alpha.m3u8');
+        expect(
+            fixture.nativeElement.querySelector('app-web-player-view')
+        ).not.toBeNull();
+        expect(component.currentProgram()?.title).toBe('Now 10001');
+        expect(
+            component.activeEpgPrograms().map((program) => program.title)
+        ).toEqual(['Now 10001', 'Future Show']);
+        expect(component.isLoadingFallbackEpg()).toBe(false);
+    });
+
+    it('lets an in-flight EPG fallback load of the playing channel finish across a category switch', async () => {
+        // The played channel is deliberately absent from the rendered list and
+        // the listed channel has a current programme, so the row preview queue
+        // never calls fetchChannelEpg — the single call below is the panel's.
+        itvChannels.set([defaultItvChannels()[1]]);
+        mockBulkEpg({
+            '10001': [buildFutureProgram('10001', 'Future Show')],
+            '10002': [buildProgram('10002', 'Beta Now')],
+        });
+        let resolvePanelFallback: ((items: EpgItem[]) => void) | undefined;
+        fetchChannelEpg.mockImplementation(
+            () =>
+                new Promise<EpgItem[]>((resolve) => {
+                    resolvePanelFallback = resolve;
+                })
+        );
+
+        fixture.detectChanges();
+        await component.playChannel(defaultItvChannels()[0]);
+        await fixture.whenStable();
+
+        expect(fetchChannelEpg).toHaveBeenCalledTimes(1);
+        expect(fetchChannelEpg).toHaveBeenCalledWith('10001');
+        expect(component.isLoadingFallbackEpg()).toBe(true);
+
+        // Category switch while the short-EPG request is still on the wire.
+        selectedCategoryId.set('42');
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        resolvePanelFallback?.([buildEpgItem('10001', 'Now 10001')]);
+        await fixture.whenStable();
+        fixture.detectChanges();
+
+        expect(component.currentProgram()?.title).toBe('Now 10001');
+        expect(component.isLoadingFallbackEpg()).toBe(false);
+    });
+
+    it('drops the EPG fallback and its loading state when the view leaves ITV', async () => {
+        // The route session clears the selection on itv → radio; the layout
+        // must not carry an ITV fallback or a stuck loading flag into radio.
+        itvChannels.set([defaultItvChannels()[1]]);
+        mockBulkEpg({
+            '10001': [buildFutureProgram('10001', 'Future Show')],
+            '10002': [buildProgram('10002', 'Beta Now')],
+        });
+        // A short-EPG request that never answers — the view leaves ITV first.
+        fetchChannelEpg.mockImplementation(
+            () => new Promise<EpgItem[]>(() => undefined)
+        );
+
+        fixture.detectChanges();
+        await component.playChannel(defaultItvChannels()[0]);
+        await fixture.whenStable();
+
+        expect(component.isLoadingFallbackEpg()).toBe(true);
+
+        stalkerStore.selectedContentType.set('radio');
+        selectedCategoryId.set('radio-all');
+        fixture.detectChanges();
+        await fixture.whenStable();
+
+        expect(component.fallbackEpgPrograms()).toBeNull();
+        expect(component.isLoadingFallbackEpg()).toBe(false);
+    });
+
     it('shows an empty state (not a skeleton) for a loaded but empty category', () => {
         // Full list is loaded, nothing is loading, and the selected category
         // filters down to zero channels — this must read as "empty", not "stuck".
diff --git a/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.ts b/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.ts
index 8d6c6ac8c..cf59687c5 100644
--- a/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.ts
+++ b/libs/portal/stalker/feature/src/lib/stalker-live-stream-layout/stalker-live-stream-layout.component.ts
@@ -557,6 +557,20 @@ export class StalkerLiveStreamLayoutComponent implements OnDestroy {
                 }
                 this.stalkerStore.setPage(0);
                 this.clearEpgPreviewMaps();
+            });
+        });
+
+        // The panel's short-EPG fallback belongs to the SELECTED channel, not
+        // to the category: a category switch only re-filters the sidebar while
+        // the selected channel keeps playing (Xtream parity), so its panel
+        // programmes — and a fallback load still in flight — must survive it.
+        // Leaving the section (itv ↔ radio) is different: the route session
+        // clears the selection there, and an abandoned request must not settle
+        // its loading flag into the next view, so that transition still
+        // invalidates the request and drops the fallback.
+        effect(() => {
+            this.stalkerStore.selectedContentType();
+            untracked(() => {
                 this.epgLoadRequestId += 1;
                 this.fallbackEpgPrograms.set(null);
                 this.isLoadingFallbackEpg.set(false);
diff --git a/libs/services/src/lib/runtime-capabilities.service.spec.ts b/libs/services/src/lib/runtime-capabilities.service.spec.ts
index a53a3e210..88e2a0fb2 100644
--- a/libs/services/src/lib/runtime-capabilities.service.spec.ts
+++ b/libs/services/src/lib/runtime-capabilities.service.spec.ts
@@ -270,6 +270,27 @@ describe('RuntimeCapabilitiesService', () => {
         expect(service.supportsXtreamSqliteDataSource).toBe(false);
     });
 
+    it('offers the startup window mode only with both the settings mirror and the F11 toggle', () => {
+        testWindow.electron = undefined;
+        const service = new RuntimeCapabilitiesService();
+
+        expect(service.supportsStartupWindowMode).toBe(false);
+
+        // The mirror alone would let a user pick fullscreen with no way out
+        // on Windows/Linux, where the title bar is hidden.
+        testWindow.electron = { updateSettings: jest.fn() };
+        expect(service.supportsStartupWindowMode).toBe(false);
+
+        testWindow.electron = { toggleFullScreenWindow: jest.fn() };
+        expect(service.supportsStartupWindowMode).toBe(false);
+
+        testWindow.electron = {
+            updateSettings: jest.fn(),
+            toggleFullScreenWindow: jest.fn(),
+        };
+        expect(service.supportsStartupWindowMode).toBe(true);
+    });
+
     it('decouples external player launch support from path-setting support', () => {
         testWindow.electron = {
             openInMpv: jest.fn(),
diff --git a/libs/services/src/lib/runtime-capabilities.service.ts b/libs/services/src/lib/runtime-capabilities.service.ts
index 0299e466b..939227817 100644
--- a/libs/services/src/lib/runtime-capabilities.service.ts
+++ b/libs/services/src/lib/runtime-capabilities.service.ts
@@ -69,6 +69,20 @@ export class RuntimeCapabilitiesService {
         );
     }
 
+    /**
+     * Desktop window mode at launch (normal / maximized / fullscreen) plus
+     * the F11 toggle. The mode reaches the main process through
+     * `updateSettings`, and the toggle is what makes a fullscreen launch
+     * escapable on Windows/Linux, where the title bar is hidden — so the
+     * setting is offered only when both halves exist.
+     */
+    get supportsStartupWindowMode(): boolean {
+        return (
+            this.hasElectronMethod('updateSettings') &&
+            this.hasElectronMethod('toggleFullScreenWindow')
+        );
+    }
+
     get supportsEpg(): boolean {
         return (
             this.supportsEpgImport &&
diff --git a/libs/services/src/lib/settings-store.service.spec.ts b/libs/services/src/lib/settings-store.service.spec.ts
index 849ca5a2f..e5f281c2e 100644
--- a/libs/services/src/lib/settings-store.service.spec.ts
+++ b/libs/services/src/lib/settings-store.service.spec.ts
@@ -137,6 +137,24 @@ describe('SettingsStore dashboard rail settings', () => {
         expect(store.getSettings().webPlayerSharedControls).toBe(false);
     });
 
+    it('defaults embedded MPV auto-reconnect to true when the stored field is missing', async () => {
+        storedSettings = {};
+        const store = injector.get(SettingsStore);
+
+        await store.loadSettings();
+
+        expect(store.getSettings().embeddedMpvAutoReconnect).toBe(true);
+    });
+
+    it('restores a persisted false embedded MPV auto-reconnect opt-out', async () => {
+        storedSettings = { embeddedMpvAutoReconnect: false };
+        const store = injector.get(SettingsStore);
+
+        await store.loadSettings();
+
+        expect(store.getSettings().embeddedMpvAutoReconnect).toBe(false);
+    });
+
     it('defaults strip country prefix to false when the stored field is missing', async () => {
         storedSettings = {};
         const store = injector.get(SettingsStore);
@@ -146,6 +164,36 @@ describe('SettingsStore dashboard rail settings', () => {
         expect(store.getSettings().stripCountryPrefix).toBe(false);
     });
 
+    it('defaults the startup window mode to normal when the stored field is missing', async () => {
+        storedSettings = {};
+        const store = injector.get(SettingsStore);
+
+        await store.loadSettings();
+
+        expect(store.getSettings().startupWindowMode).toBe('normal');
+    });
+
+    it('restores a persisted fullscreen startup window mode', async () => {
+        storedSettings = { startupWindowMode: 'fullscreen' };
+        const store = injector.get(SettingsStore);
+
+        await store.loadSettings();
+
+        expect(store.getSettings().startupWindowMode).toBe('fullscreen');
+    });
+
+    it('normalizes a persisted unknown startup window mode to normal', async () => {
+        storedSettings = {
+            startupWindowMode:
+                'kiosk' as unknown as Settings['startupWindowMode'],
+        };
+        const store = injector.get(SettingsStore);
+
+        await store.loadSettings();
+
+        expect(store.getSettings().startupWindowMode).toBe('normal');
+    });
+
     it('defaults ambient player mode to false when the stored field is missing', async () => {
         storedSettings = {};
         const store = injector.get(SettingsStore);
diff --git a/libs/services/src/lib/settings-store.service.ts b/libs/services/src/lib/settings-store.service.ts
index 395dcb3a0..32f791e4a 100644
--- a/libs/services/src/lib/settings-store.service.ts
+++ b/libs/services/src/lib/settings-store.service.ts
@@ -22,6 +22,7 @@ import {
     Theme,
     VideoPlayer,
     normalizeDashboardRailsSettings,
+    normalizeStartupWindowMode,
 } from '@iptvnator/shared/interfaces';
 
 const DEFAULT_SETTINGS: Settings = {
@@ -37,6 +38,7 @@ const DEFAULT_SETTINGS: Settings = {
     showCaptions: false,
     showDashboard: true,
     startupBehavior: StartupBehavior.FirstView,
+    startupWindowMode: 'normal',
     showExternalPlaybackBar: true,
     stripCountryPrefix: false,
     theme: Theme.SystemTheme,
@@ -52,6 +54,8 @@ const DEFAULT_SETTINGS: Settings = {
     downloadFolder: '',
     recordingFolder: '',
     embeddedMpvFrameCopy: false,
+    embeddedMpvExtraOptions: '',
+    embeddedMpvAutoReconnect: true,
     coverSize: 'medium',
     epgViewMode: 'timeline',
     dashboardRails: DEFAULT_DASHBOARD_RAILS_SETTINGS,
@@ -156,6 +160,9 @@ export const SettingsStore = signalStore(
                             webPlayerSharedControls:
                                 storedSettings.webPlayerSharedControls !==
                                 false,
+                            embeddedMpvAutoReconnect:
+                                storedSettings.embeddedMpvAutoReconnect !==
+                                false,
                             dashboardRails: normalizeDashboardRailsSettings(
                                 storedSettings.dashboardRails
                             ),
@@ -190,6 +197,12 @@ export const SettingsStore = signalStore(
                                   settings.webPlayerSharedControls !== false,
                           }
                         : {}),
+                    ...(settings.embeddedMpvAutoReconnect !== undefined
+                        ? {
+                              embeddedMpvAutoReconnect:
+                                  settings.embeddedMpvAutoReconnect !== false,
+                          }
+                        : {}),
                     ...(settings.dashboardRails !== undefined
                         ? {
                               dashboardRails: normalizeDashboardRailsSettings(
@@ -240,6 +253,9 @@ export const SettingsStore = signalStore(
                     showCaptions: store.showCaptions(),
                     showDashboard: store.showDashboard(),
                     startupBehavior: store.startupBehavior(),
+                    startupWindowMode: normalizeStartupWindowMode(
+                        store.startupWindowMode?.()
+                    ),
                     showExternalPlaybackBar:
                         store.showExternalPlaybackBar?.() ??
                         DEFAULT_SETTINGS.showExternalPlaybackBar,
@@ -264,6 +280,10 @@ export const SettingsStore = signalStore(
                         DEFAULT_SETTINGS.recordingFolder,
                     embeddedMpvFrameCopy:
                         store.embeddedMpvFrameCopy?.() ?? false,
+                    embeddedMpvExtraOptions:
+                        store.embeddedMpvExtraOptions?.() ?? '',
+                    embeddedMpvAutoReconnect:
+                        store.embeddedMpvAutoReconnect?.() !== false,
                     coverSize:
                         store.coverSize?.() ?? DEFAULT_SETTINGS.coverSize,
                     epgViewMode:
diff --git a/libs/shared/interfaces/src/index.ts b/libs/shared/interfaces/src/index.ts
index 331ebb2e3..f34091e0a 100644
--- a/libs/shared/interfaces/src/index.ts
+++ b/libs/shared/interfaces/src/index.ts
@@ -14,6 +14,7 @@ export * from './lib/epg-item.interface';
 export * from './lib/epg-mapping-key.util';
 export * from './lib/epg-program.model';
 export * from './lib/external-player-arguments.utils';
+export * from './lib/embedded-mpv-extra-options.util';
 export * from './lib/external-player-session.interface';
 export * from './lib/global-search-result.interface';
 export * from './lib/host-connectivity.util';
diff --git a/libs/shared/interfaces/src/lib/electron-api.interface.ts b/libs/shared/interfaces/src/lib/electron-api.interface.ts
index f94c2fdde..78e0c6d7b 100644
--- a/libs/shared/interfaces/src/lib/electron-api.interface.ts
+++ b/libs/shared/interfaces/src/lib/electron-api.interface.ts
@@ -662,6 +662,12 @@ export interface ElectronBridgeApi {
     ) => () => void;
     minimizeWindow: () => Promise<void>;
     toggleMaximizeWindow: () => Promise<ElectronBridgeWindowState>;
+    /**
+     * Toggles OS-level window fullscreen (F11). Reports the requested state;
+     * the `onWindowStateChange` push stays authoritative once the window
+     * manager has acted.
+     */
+    toggleFullScreenWindow: () => Promise<ElectronBridgeWindowState>;
     closeWindow: () => Promise<void>;
     getWindowState: () => Promise<ElectronBridgeWindowState>;
     onWindowStateChange: (
diff --git a/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.spec.ts b/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.spec.ts
new file mode 100644
index 000000000..6390d36df
--- /dev/null
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.spec.ts
@@ -0,0 +1,83 @@
+import {
+    EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS,
+    normalizeEmbeddedMpvExtraOptions,
+    parseEmbeddedMpvExtraOptions,
+    resolveEmbeddedMpvSessionOptionArguments,
+    validateEmbeddedMpvExtraOptions,
+} from './embedded-mpv-extra-options.util';
+
+describe('embedded MPV extra options', () => {
+    it('parses one key=value pair per line and tolerates CRLF, spaces and a -- prefix', () => {
+        expect(
+            parseEmbeddedMpvExtraOptions(
+                'hwdec = auto-safe\r\n\n  --cache-secs=30  \ndemuxer-lavf-o=reconnect=1,reconnect_delay_max=5'
+            )
+        ).toEqual([
+            { key: 'hwdec', value: 'auto-safe' },
+            { key: 'cache-secs', value: '30' },
+            {
+                key: 'demuxer-lavf-o',
+                value: 'reconnect=1,reconnect_delay_max=5',
+            },
+        ]);
+    });
+
+    it('skips lines without a value or with a malformed key', () => {
+        expect(
+            parseEmbeddedMpvExtraOptions(
+                'hwdec=\nno-border\n=auto\n bad key=1\nvolume=50'
+            )
+        ).toEqual([{ key: 'volume', value: '50' }]);
+    });
+
+    it('normalizes to canonical lines but keeps malformed lines for the user to fix', () => {
+        expect(
+            normalizeEmbeddedMpvExtraOptions(
+                ' --hwdec = auto \n\nnot an option\n'
+            )
+        ).toBe('hwdec=auto\nnot an option');
+        expect(normalizeEmbeddedMpvExtraOptions(undefined)).toBe('');
+        expect(normalizeEmbeddedMpvExtraOptions(['a=1', '', 'b=2'])).toBe(
+            'a=1\nb=2'
+        );
+    });
+
+    it('reports malformed lines and forbidden keys separately', () => {
+        expect(validateEmbeddedMpvExtraOptions('')).toBeNull();
+        expect(validateEmbeddedMpvExtraOptions(undefined)).toBeNull();
+        expect(validateEmbeddedMpvExtraOptions('hwdec=auto')).toBeNull();
+        expect(
+            validateEmbeddedMpvExtraOptions(
+                'hwdec=auto\noops\nvo=null\nwid=1\nvo=gpu'
+            )
+        ).toEqual({ invalidLines: ['oops'], forbiddenKeys: ['vo', 'wid'] });
+        expect(
+            validateEmbeddedMpvExtraOptions('input-ipc-server=/tmp/s')
+        ).toEqual({
+            forbiddenKeys: ['input-ipc-server'],
+        });
+    });
+
+    it('prepends the network defaults and drops forbidden keys for the addon', () => {
+        expect(resolveEmbeddedMpvSessionOptionArguments('')).toEqual([
+            ...EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS,
+        ]);
+        expect(
+            resolveEmbeddedMpvSessionOptionArguments(
+                'wid=42\nhwdec=no\nnetwork-timeout=3\nbroken line'
+            )
+        ).toEqual([
+            ...EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS,
+            'hwdec=no',
+            'network-timeout=3',
+        ]);
+    });
+
+    it('keeps the user override after the default it replaces', () => {
+        const options =
+            resolveEmbeddedMpvSessionOptionArguments('network-timeout=3');
+        expect(options.indexOf('network-timeout=10')).toBeLessThan(
+            options.indexOf('network-timeout=3')
+        );
+    });
+});
diff --git a/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.ts b/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.ts
new file mode 100644
index 000000000..cae5e9f7b
--- /dev/null
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-extra-options.util.ts
@@ -0,0 +1,155 @@
+import {
+    ExternalPlayerArgumentsInput,
+    parseExternalPlayerArguments,
+} from './external-player-arguments.utils';
+
+/**
+ * One libmpv option destined for an embedded MPV session, as entered in
+ * Settings > Playback: `key=value`, one per line, without the leading `--`.
+ */
+export interface EmbeddedMpvExtraOption {
+    key: string;
+    value: string;
+}
+
+/**
+ * Options the embed itself depends on. A user value for any of these would
+ * detach the video from the app window (`wid`, `vo`, `force-window`), break
+ * the Linux IPC control channel (`input-ipc-server`), or defeat the session
+ * lifecycle the addon relies on (`idle`, `keep-open`). `config`, `include`
+ * and `terminal` are refused because the embedded player deliberately runs
+ * with an isolated configuration and no terminal.
+ */
+export const EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS: readonly string[] = [
+    'wid',
+    'vo',
+    'force-window',
+    'input-ipc-server',
+    'idle',
+    'keep-open',
+    'config',
+    'include',
+    'terminal',
+];
+
+/**
+ * Applied to every embedded session ahead of the user's options, on every
+ * engine: a stalled IPTV connection then surfaces as an mpv error within
+ * seconds instead of the 60 s libmpv default, and ffmpeg re-requests a
+ * dropped HTTP stream on its own before the app-level reconnect has to. A
+ * user line with the same key wins because it is applied later.
+ */
+export const EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS: readonly string[] = [
+    'network-timeout=10',
+    'demuxer-lavf-o=reconnect=1,reconnect_streamed=1,reconnect_delay_max=5',
+];
+
+export interface EmbeddedMpvExtraOptionsValidationErrors {
+    /** Lines that are not `key=value` with a non-empty value. */
+    invalidLines?: string[];
+    /** Keys from {@link EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS} present in the text. */
+    forbiddenKeys?: string[];
+}
+
+const OPTION_KEY_PATTERN = /^[a-z0-9][a-z0-9_-]*$/i;
+
+interface ParsedOptionLine {
+    line: string;
+    option: EmbeddedMpvExtraOption | null;
+}
+
+function parseOptionLine(line: string): ParsedOptionLine {
+    const separator = line.indexOf('=');
+    if (separator === -1) {
+        return { line, option: null };
+    }
+    const key = line.slice(0, separator).trim().replace(/^--/, '');
+    const value = line.slice(separator + 1).trim();
+    if (!OPTION_KEY_PATTERN.test(key) || value.length === 0) {
+        return { line, option: null };
+    }
+    return { line, option: { key, value } };
+}
+
+function parseOptionLines(
+    value: ExternalPlayerArgumentsInput
+): ParsedOptionLine[] {
+    return parseExternalPlayerArguments(value).map(parseOptionLine);
+}
+
+/** The well-formed `key=value` pairs in the text; malformed lines are skipped. */
+export function parseEmbeddedMpvExtraOptions(
+    value: ExternalPlayerArgumentsInput
+): EmbeddedMpvExtraOption[] {
+    return parseOptionLines(value)
+        .map((parsed) => parsed.option)
+        .filter((option): option is EmbeddedMpvExtraOption => option !== null);
+}
+
+/**
+ * Canonical text for storage: one trimmed line per option, `key=value`
+ * without the `--` prefix. Malformed lines are kept verbatim rather than
+ * dropped, so the user can still see and fix what the validator flagged.
+ */
+export function normalizeEmbeddedMpvExtraOptions(
+    value: ExternalPlayerArgumentsInput
+): string {
+    return parseOptionLines(value)
+        .map((parsed) =>
+            parsed.option
+                ? `${parsed.option.key}=${parsed.option.value}`
+                : parsed.line
+        )
+        .join('\n');
+}
+
+/**
+ * Validation for the Settings textarea: malformed lines and forbidden keys.
+ * Returns `null` when the text is acceptable, so it plugs into an Angular
+ * validator without this library depending on Angular.
+ */
+export function validateEmbeddedMpvExtraOptions(
+    value: unknown
+): EmbeddedMpvExtraOptionsValidationErrors | null {
+    const parsedLines = parseOptionLines(
+        typeof value === 'string' ? value : undefined
+    );
+    const invalidLines = parsedLines
+        .filter((parsed) => parsed.option === null)
+        .map((parsed) => parsed.line);
+    const forbiddenKeys = [
+        ...new Set(
+            parsedLines
+                .map((parsed) => parsed.option?.key)
+                .filter(
+                    (key): key is string =>
+                        key !== undefined &&
+                        EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS.includes(key)
+                )
+        ),
+    ];
+    if (invalidLines.length === 0 && forbiddenKeys.length === 0) {
+        return null;
+    }
+    return {
+        ...(invalidLines.length > 0 ? { invalidLines } : {}),
+        ...(forbiddenKeys.length > 0 ? { forbiddenKeys } : {}),
+    };
+}
+
+/**
+ * The `key=value` lines a session addon receives: the network defaults
+ * first, then the user's options with forbidden keys removed. Every engine
+ * (Windows/Linux/macOS native-view and the frame-copy helper) applies them
+ * in this order after its own built-in options.
+ */
+export function resolveEmbeddedMpvSessionOptionArguments(
+    value: ExternalPlayerArgumentsInput
+): string[] {
+    const userOptions = parseEmbeddedMpvExtraOptions(value)
+        .filter(
+            (option) => !EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS.includes(option.key)
+        )
+        .map((option) => `${option.key}=${option.value}`);
+    return [...EMBEDDED_MPV_NETWORK_DEFAULT_OPTIONS, ...userOptions];
+}
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 3ae0926ac..99bacb047 100644
--- a/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts
+++ b/libs/shared/interfaces/src/lib/embedded-mpv-session.interface.ts
@@ -2,13 +2,7 @@ import type { PlayerSubtitleStyle } from './subtitle-style.util';
 import type { RecordingStartMetadata } from './recording-metadata.interface';
 
 export type EmbeddedMpvSessionStatus =
-    | 'idle'
-    | 'loading'
-    | 'playing'
-    | 'paused'
-    | 'ended'
-    | 'error'
-    | 'closed';
+    'idle' | 'loading' | 'playing' | 'paused' | 'ended' | 'error' | 'closed';
 
 export interface EmbeddedMpvBounds {
     x: number;
@@ -129,4 +123,19 @@ export interface EmbeddedMpvSession {
     startedAt: string;
     updatedAt: string;
     error?: string;
+    /**
+     * Present while the main process is waiting to reload a dropped stream
+     * or has such a reload in flight; absent once playback is back or the
+     * attempts are exhausted. Display only — the renderer never schedules.
+     */
+    reconnect?: EmbeddedMpvReconnectInfo;
+}
+
+/** Progress of the main-process automatic reconnect for one session. */
+export interface EmbeddedMpvReconnectInfo {
+    /** 1-based number of the attempt that is scheduled or in flight. */
+    attempt: number;
+    maxAttempts: number;
+    /** ISO timestamp at which the scheduled attempt fires. */
+    nextAttemptAt: string;
 }
diff --git a/libs/shared/interfaces/src/lib/external-player-arguments.utils.ts b/libs/shared/interfaces/src/lib/external-player-arguments.utils.ts
index 8c48ab5ae..c10260235 100644
--- a/libs/shared/interfaces/src/lib/external-player-arguments.utils.ts
+++ b/libs/shared/interfaces/src/lib/external-player-arguments.utils.ts
@@ -1,8 +1,5 @@
 export type ExternalPlayerArgumentsInput =
-    | string
-    | readonly unknown[]
-    | null
-    | undefined;
+    string | readonly unknown[] | null | undefined;
 
 export function parseExternalPlayerArguments(
     value: ExternalPlayerArgumentsInput
diff --git a/libs/shared/interfaces/src/lib/ipc-commands.ts b/libs/shared/interfaces/src/lib/ipc-commands.ts
index 3d8b5f492..56b47dd30 100644
--- a/libs/shared/interfaces/src/lib/ipc-commands.ts
+++ b/libs/shared/interfaces/src/lib/ipc-commands.ts
@@ -130,6 +130,10 @@ export const PLAYBACK_SET_KEEP_AWAKE = 'PLAYBACK:SET_KEEP_AWAKE';
 // Window controls (custom title bar on Windows/Linux)
 export const WINDOW_MINIMIZE = 'WINDOW:MINIMIZE';
 export const WINDOW_TOGGLE_MAXIMIZE = 'WINDOW:TOGGLE_MAXIMIZE';
+// OS-level window fullscreen toggle (F11). The exit path from a fullscreen
+// launch on Windows/Linux, where the title bar is hidden and the custom
+// window controls hide themselves while fullscreen.
+export const WINDOW_TOGGLE_FULLSCREEN = 'WINDOW:TOGGLE_FULLSCREEN';
 export const WINDOW_CLOSE = 'WINDOW:CLOSE';
 export const WINDOW_GET_STATE = 'WINDOW:GET_STATE';
 export const WINDOW_STATE_CHANGED = 'WINDOW:STATE_CHANGED';
diff --git a/libs/shared/interfaces/src/lib/settings.interface.ts b/libs/shared/interfaces/src/lib/settings.interface.ts
index 2b4c67f0b..fabe21052 100644
--- a/libs/shared/interfaces/src/lib/settings.interface.ts
+++ b/libs/shared/interfaces/src/lib/settings.interface.ts
@@ -39,6 +39,34 @@ export enum StartupBehavior {
     RestoreLastView = 'restore-last-view',
 }
 
+/**
+ * How the desktop window is presented when the app launches. Electron only.
+ *
+ * Persisted like every other setting in the renderer and mirrored into the
+ * main-process config file by the `SETTINGS_UPDATE` handler, because the
+ * window is created before the renderer exists — so a change applies on the
+ * next launch. `--fullscreen` on the command line forces `'fullscreen'` for
+ * that launch only, and F11 toggles fullscreen at any time.
+ */
+export type StartupWindowMode = 'normal' | 'maximized' | 'fullscreen';
+
+export const STARTUP_WINDOW_MODES: readonly StartupWindowMode[] = [
+    'normal',
+    'maximized',
+    'fullscreen',
+];
+
+/**
+ * Collapses anything that is not a known mode to `'normal'`. Shared by the
+ * renderer form and the main-process mirror so junk never reaches the
+ * config file or the window options.
+ */
+export function normalizeStartupWindowMode(value: unknown): StartupWindowMode {
+    return STARTUP_WINDOW_MODES.includes(value as StartupWindowMode)
+        ? (value as StartupWindowMode)
+        : 'normal';
+}
+
 export type CoverSize = 'small' | 'medium' | 'large';
 
 /** Rendering of the live EPG panel under the player. */
@@ -147,6 +175,12 @@ export interface Settings {
     showCaptions: boolean;
     showDashboard: boolean;
     startupBehavior: StartupBehavior;
+    /**
+     * Desktop window presentation at launch: normal (last size), maximized,
+     * or fullscreen. Electron only and applied on the next launch; a missing
+     * value means `'normal'`. F11 leaves or re-enters fullscreen.
+     */
+    startupWindowMode?: StartupWindowMode;
     /** Show the desktop footer bar for external playback status */
     showExternalPlaybackBar?: boolean;
     /** Strip country/group prefixes like "US | " or "UK - " from channel names */
@@ -178,6 +212,23 @@ export interface Settings {
      * for its preload frame pump, which is fixed at window creation.
      */
     embeddedMpvFrameCopy?: boolean;
+    /**
+     * Extra libmpv options for the embedded engine, one `key=value` per line
+     * (no leading `--`), applied on every engine after the built-in options
+     * and the network defaults, so a line here overrides them. Keys the
+     * embed depends on (`EMBEDDED_MPV_FORBIDDEN_OPTION_KEYS`) are refused by
+     * the form and skipped at session creation. Mirrored into the
+     * main-process config like `embeddedMpvFrameCopy`; a change applies to
+     * the next embedded session.
+     */
+    embeddedMpvExtraOptions?: string;
+    /**
+     * Reload a dropped embedded MPV stream automatically (mpv error, or EOF
+     * on a live stream) with capped backoff. Default on; only a stream that
+     * already played is retried, so a dead URL stays on the manual Retry.
+     * Captured per session, so a change applies to the next session.
+     */
+    embeddedMpvAutoReconnect?: boolean;
     /** Cover/poster sizing preset applied across grids and rails */
     coverSize?: CoverSize;
     /** Live EPG panel layout: horizontal timeline (default) or vertical list */
diff --git a/libs/shared/logging/src/lib/redact-sensitive-data.spec.ts b/libs/shared/logging/src/lib/redact-sensitive-data.spec.ts
index 75d6efcb6..2ca48e7e5 100644
--- a/libs/shared/logging/src/lib/redact-sensitive-data.spec.ts
+++ b/libs/shared/logging/src/lib/redact-sensitive-data.spec.ts
@@ -355,3 +355,17 @@ describe('redactSensitiveData', () => {
         });
     });
 });
+
+describe('redactSensitiveData embedded MPV options', () => {
+    it('redacts the whole extra-options text, which can carry request headers', () => {
+        const secret = 'embedded-mpv-header-secret';
+
+        const redacted = redactSensitiveData({
+            player: 'embedded-mpv',
+            embeddedMpvExtraOptions: `cache-secs=5\nhttp-header-fields=X-Playback-Key: ${secret}`,
+        }) as Record<string, unknown>;
+
+        expect(JSON.stringify(redacted)).not.toContain(secret);
+        expect(redacted['player']).toBe('embedded-mpv');
+    });
+});
diff --git a/libs/shared/logging/src/lib/redact-sensitive-data.ts b/libs/shared/logging/src/lib/redact-sensitive-data.ts
index cc42a4db2..b20256120 100644
--- a/libs/shared/logging/src/lib/redact-sensitive-data.ts
+++ b/libs/shared/logging/src/lib/redact-sensitive-data.ts
@@ -15,6 +15,8 @@ const SENSITIVE_KEY_NAMES = new Set([
     'credentials',
     'deviceid',
     'deviceid2',
+    // Free-form libmpv lines can carry request headers with credentials.
+    'embeddedmpvextraoptions',
     'login',
     'mac',
     'macaddress',
@@ -33,11 +35,23 @@ const SENSITIVE_KEY_NAMES = new Set([
 ]);
 
 const SENSITIVE_KEY_SUFFIXES = [
-    'apikey', 'authorization', 'cookie',
-    'deviceid', 'deviceid1', 'deviceid2',
-    'macaddress', 'passwd', 'password', 'prehash',
-    'serialnumber', 'signature', 'signature1', 'signature2',
-    'secret', 'token', 'username',
+    'apikey',
+    'authorization',
+    'cookie',
+    'deviceid',
+    'deviceid1',
+    'deviceid2',
+    'macaddress',
+    'passwd',
+    'password',
+    'prehash',
+    'serialnumber',
+    'signature',
+    'signature1',
+    'signature2',
+    'secret',
+    'token',
+    'username',
 ];
 
 const XTREAM_CREDENTIAL_PATH_SEGMENTS = new Set([
@@ -160,25 +174,20 @@ function redactUrlStrings(
     value: string,
     sanitizeValue: (value: string) => string
 ): string {
-    return value.replace(
-        /[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/giu,
-        (candidate) => {
-            try {
-                return redactUrl(new URL(candidate), sanitizeValue);
-            } catch {
-                return candidate;
-            }
+    return value.replace(/[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/giu, (candidate) => {
+        try {
+            return redactUrl(new URL(candidate), sanitizeValue);
+        } catch {
+            return candidate;
         }
-    );
+    });
 }
 
 function redactEmbeddedSensitivePairs(value: string): string {
     const redactedAssignments = value.replace(
         /\b([a-z][a-z0-9_.-]*)(\s*=\s*)((?:Bearer\s+)?[^&\s,;]+)/giu,
         (match, key: string, separator: string) =>
-            isSensitiveKey(key)
-                ? `${key}${separator}${REDACTED_VALUE}`
-                : match
+            isSensitiveKey(key) ? `${key}${separator}${REDACTED_VALUE}` : match
     );
     return redactedAssignments.replace(
         /\b([a-z0-9_.-]*(?:api[-_.]?key|auth(?:orization)?|cookie|credentials|device[-_.]?id[12]?|login|mac(?:[-_.]?address)?|passwd|password|prehash|pwd|secret|serial[-_.]?number|set[-_.]?cookie|signature[12]?|sn|token|username))(\s*:\s*)(?:Bearer\s+)?[^;,\r\n]+/giu,
@@ -286,9 +295,10 @@ export function redactSensitiveData(
         if (error.stack) {
             const [, ...stackFrames] = error.stack.split('\n');
             output['stack'] = visitString(
-                [`${output['name']}: ${output['message']}`, ...stackFrames].join(
-                    '\n'
-                ),
+                [
+                    `${output['name']}: ${output['message']}`,
+                    ...stackFrames,
+                ].join('\n'),
                 depth + 1
             );
         }
@@ -370,8 +380,7 @@ export function redactSensitiveData(
                     const stringKey = String(key);
                     const redactedKey = visitString(stringKey, depth + 1);
                     entries[redactedKey] =
-                        isSensitiveKey(stringKey) &&
-                        !/[/:?=&]/u.test(stringKey)
+                        isSensitiveKey(stringKey) && !/[/:?=&]/u.test(stringKey)
                             ? REDACTED_VALUE
                             : visit(entry, depth + 1);
                 }
diff --git a/libs/shared/marketing-fixtures/src/index.ts b/libs/shared/marketing-fixtures/src/index.ts
index 7446381e4..585dfef54 100644
--- a/libs/shared/marketing-fixtures/src/index.ts
+++ b/libs/shared/marketing-fixtures/src/index.ts
@@ -1 +1,2 @@
 export * from './lib/shared-marketing-fixtures';
+export * from './lib/marketing-live-fixtures';
diff --git a/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.spec.ts b/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.spec.ts
new file mode 100644
index 000000000..f00339626
--- /dev/null
+++ b/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.spec.ts
@@ -0,0 +1,41 @@
+import {
+    MARKETING_LIVE_CATEGORIES,
+    MARKETING_LIVE_CHANNELS,
+    marketingSlug,
+    marketingTitleFromSlug,
+    renderMarketingLogoSvg,
+} from './marketing-live-fixtures';
+
+describe('marketing live fixtures', () => {
+    it('places every channel in a declared category with a schedule', () => {
+        const keys = new Set(MARKETING_LIVE_CATEGORIES.map((c) => c.key));
+
+        for (const channel of MARKETING_LIVE_CHANNELS) {
+            expect(keys.has(channel.categoryKey)).toBe(true);
+            expect(channel.epgTitles.length).toBeGreaterThan(0);
+        }
+        expect(new Set(MARKETING_LIVE_CHANNELS.map((c) => c.name)).size).toBe(
+            MARKETING_LIVE_CHANNELS.length
+        );
+    });
+
+    it('round-trips a channel name through the slug used in asset URLs', () => {
+        expect(marketingSlug('Aurora News')).toBe('aurora-news');
+        expect(marketingTitleFromSlug('aurora-news.svg')).toBe('Aurora News');
+    });
+
+    it('renders a self-contained SVG logo with the channel initials', () => {
+        const svg = renderMarketingLogoSvg('aurora-news.svg', '128x128');
+
+        expect(svg.startsWith('<svg xmlns="http://www.w3.org/2000/svg"')).toBe(
+            true
+        );
+        expect(svg).toContain('width="128"');
+        expect(svg).toContain('>AN</text>');
+        expect(svg).not.toContain('http://localhost');
+    });
+
+    it('escapes markup that leaks into a slug', () => {
+        expect(renderMarketingLogoSvg('<b>x', undefined)).not.toContain('<b>');
+    });
+});
diff --git a/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.ts b/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.ts
new file mode 100644
index 000000000..73278cdae
--- /dev/null
+++ b/libs/shared/marketing-fixtures/src/lib/marketing-live-fixtures.ts
@@ -0,0 +1,178 @@
+/**
+ * Provider-neutral fictional live TV fixtures shared by the Xtream and
+ * Stalker marketing mocks, plus the generated logo artwork both serve from
+ * `/assets/marketing/logo/<slug>.svg`. Everything here is invented: no real
+ * broadcaster, programme, or logo is referenced, which is what makes the
+ * screenshots built on top of it publishable.
+ */
+
+export type MarketingLiveCategoryKey =
+    | 'newsroom'
+    | 'sports'
+    | 'family'
+    | 'culture';
+
+export interface MarketingLiveCategoryFixture {
+    key: MarketingLiveCategoryKey;
+    name: string;
+}
+
+export interface MarketingLiveChannelFixture {
+    categoryKey: MarketingLiveCategoryKey;
+    name: string;
+    /** Cycled through the generated schedule, so the guide always has titles. */
+    epgTitles: readonly string[];
+}
+
+export const MARKETING_LIVE_CATEGORIES: readonly MarketingLiveCategoryFixture[] =
+    [
+        { key: 'newsroom', name: 'Newsroom' },
+        { key: 'sports', name: 'Sports & Motion' },
+        { key: 'family', name: 'Family Channels' },
+        { key: 'culture', name: 'Culture & Docs' },
+    ];
+
+export const MARKETING_LIVE_CHANNELS: readonly MarketingLiveChannelFixture[] = [
+    {
+        categoryKey: 'newsroom',
+        name: 'Aurora News',
+        epgTitles: ['Morning Briefing', 'City Desk', 'Global Window'],
+    },
+    {
+        categoryKey: 'newsroom',
+        name: 'Civic One',
+        epgTitles: ['Town Hall Live', 'Policy Today', 'Open Forum'],
+    },
+    {
+        categoryKey: 'sports',
+        name: 'Fieldside Sports',
+        epgTitles: ['Training Ground', 'Matchday Studio', 'Final Whistle'],
+    },
+    {
+        categoryKey: 'sports',
+        name: 'Motion Arena',
+        epgTitles: ['Court Vision', 'Trackside', 'Night Highlights'],
+    },
+    {
+        categoryKey: 'family',
+        name: 'Horizon Kids',
+        epgTitles: ['Rocket Workshop', 'Tiny Explorers', 'Story Lantern'],
+    },
+    {
+        categoryKey: 'family',
+        name: 'Kitchen Lab',
+        epgTitles: ['Breakfast Builders', 'Family Table', 'Sweet Science'],
+    },
+    {
+        categoryKey: 'culture',
+        name: 'Atlas Docs',
+        epgTitles: ['Ocean Notes', 'Museum Hour', 'Wide Angle'],
+    },
+    {
+        categoryKey: 'culture',
+        name: 'Night Music',
+        epgTitles: ['Studio Session', 'Late Set', 'Ambient City'],
+    },
+];
+
+export const MARKETING_LOGO_ASSET_PATH = '/assets/marketing/logo';
+
+/** URL-safe slug shared by asset URLs and the renderer that answers them. */
+export function marketingSlug(value: string): string {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+
+/** Inverse of `marketingSlug` for rendering initials back out of a URL. */
+export function marketingTitleFromSlug(slug: string): string {
+    return slug
+        .replace(/\.svg$/i, '')
+        .split('-')
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
+        .join(' ');
+}
+
+export function marketingHash(value: string): number {
+    return value.split('').reduce((acc, char) => {
+        return (acc * 31 + char.charCodeAt(0)) >>> 0;
+    }, 0);
+}
+
+export function marketingPalette(seed: string): [string, string, string] {
+    const palettes: Array<[string, string, string]> = [
+        ['#0b1026', '#1b6b77', '#f2a65a'],
+        ['#15111f', '#6b3fa0', '#20c7b5'],
+        ['#071b2c', '#2457a6', '#f05d5e'],
+        ['#1b1b24', '#8d4f2a', '#e9c46a'],
+        ['#10251d', '#2a9d8f', '#e76f51'],
+        ['#18151f', '#b23a48', '#f4a261'],
+    ];
+    return palettes[marketingHash(seed) % palettes.length];
+}
+
+export function marketingSvgDocument(
+    width: number,
+    height: number,
+    body: string
+): string {
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img">${body}</svg>`;
+}
+
+export function escapeMarketingSvg(value: string): string {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+
+/** `WIDTHxHEIGHT` query value; falls back to a square 256 px logo. */
+export function parseMarketingLogoSize(size: string | undefined): {
+    width: number;
+    height: number;
+} {
+    const match = size?.match(/^(\d+)x(\d+)$/);
+    if (!match) {
+        return { width: 256, height: 256 };
+    }
+    return { width: Number(match[1]), height: Number(match[2]) };
+}
+
+/**
+ * Channel logo: gradient tile with the channel initials. Identical output for
+ * both mocks so a screenshot looks the same whichever portal type it shows.
+ */
+export function renderMarketingLogoSvg(
+    slug: string,
+    size: string | undefined
+): string {
+    const { width, height } = parseMarketingLogoSize(size);
+    const title = marketingTitleFromSlug(slug);
+    const palette = marketingPalette(`logo:${slug}`);
+    const initials = title
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, 2)
+        .map((part) => part[0]?.toUpperCase() ?? '')
+        .join('');
+
+    return marketingSvgDocument(
+        width,
+        height,
+        `
+        <defs>
+            <linearGradient id="bg" x1="0" x2="1" y1="0" y2="1">
+                <stop offset="0%" stop-color="${palette[0]}" />
+                <stop offset="100%" stop-color="${palette[1]}" />
+            </linearGradient>
+        </defs>
+        <rect width="100%" height="100%" rx="${width * 0.22}" fill="url(#bg)" />
+        <circle cx="${width * 0.72}" cy="${height * 0.25}" r="${width * 0.2}" fill="${palette[2]}" opacity="0.35" />
+        <path d="M ${width * 0.16} ${height * 0.72} C ${width * 0.35} ${height * 0.48}, ${width * 0.58} ${height * 0.92}, ${width * 0.84} ${height * 0.58}" fill="none" stroke="#fff" stroke-width="${Math.max(8, width * 0.05)}" stroke-linecap="round" opacity="0.42" />
+        <text x="50%" y="54%" dominant-baseline="middle" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="${width * 0.3}" font-weight="800" fill="#fff">${escapeMarketingSvg(initials)}</text>
+        `
+    );
+}
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.spec.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.spec.ts
index cf8df65bf..8908e69dd 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.spec.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.spec.ts
@@ -127,6 +127,8 @@ function translations(prefix = ''): object {
         EMBEDDED_MPV: {
             PLAYER: {
                 PLAYBACK_FAILED: `${prefix}Playback failed`,
+                RECONNECTING: `${prefix}Reconnecting {{attempt}}/{{maxAttempts}}`,
+                STREAM_ENDED: `${prefix}Live stream ended`,
                 CHECKING_SUPPORT: `${prefix}Checking support`,
                 NOT_AVAILABLE: `${prefix}Not available`,
                 LOADING_STREAM: `${prefix}Loading stream`,
@@ -384,6 +386,30 @@ describe('EmbeddedMpvControlsAdapter', () => {
 
         controller.session.set(session({ status: 'error', error: undefined }));
         expect(adapter.state().statusMessage).toBe('Playback failed');
+
+        playback.set({ ...LIVE_PLAYBACK, isLive: true });
+        controller.session.set(session({ status: 'ended' }));
+        expect(adapter.state()).toMatchObject({
+            status: 'error',
+            statusMessage: 'Live stream ended',
+        });
+        playback.set({ ...VOD_PLAYBACK, isLive: false });
+
+        controller.session.set(
+            session({
+                status: 'error',
+                error: 'Decoder exploded',
+                reconnect: {
+                    attempt: 3,
+                    maxAttempts: 6,
+                    nextAttemptAt: '2026-09-03T10:00:08Z',
+                },
+            })
+        );
+        expect(adapter.state()).toMatchObject({
+            status: 'loading',
+            statusMessage: 'Reconnecting 3/6',
+        });
     });
 
     it('delegates every non-recording shared-controls command', () => {
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.ts
index 1a13f4c83..5ece75c1b 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-controls.adapter.ts
@@ -119,8 +119,7 @@ export class EmbeddedMpvControlsAdapter implements PlayerController {
             volume: true,
             audioTracks: true,
             subtitles: optionalCapabilities?.subtitles ?? false,
-            externalSubtitles:
-                optionalCapabilities?.externalSubtitles ?? false,
+            externalSubtitles: optionalCapabilities?.externalSubtitles ?? false,
             subtitleDelay: optionalCapabilities?.subtitleDelay ?? false,
             subtitleStyle: optionalCapabilities?.subtitleStyle ?? false,
             playbackSpeed: optionalCapabilities?.playbackSpeed ?? false,
@@ -307,6 +306,21 @@ export class EmbeddedMpvControlsAdapter implements PlayerController {
             };
         }
 
+        if (session?.reconnect) {
+            // A dropped stream the main process is reloading: a spinner with
+            // the attempt count reads better than the underlying mpv error.
+            return {
+                status: 'loading',
+                statusMessage: this.translate.instant(
+                    'EMBEDDED_MPV.PLAYER.RECONNECTING',
+                    {
+                        attempt: session.reconnect.attempt,
+                        maxAttempts: session.reconnect.maxAttempts,
+                    }
+                ),
+            };
+        }
+
         if (!session || session.status === 'loading') {
             return {
                 status: 'loading',
@@ -316,6 +330,12 @@ export class EmbeddedMpvControlsAdapter implements PlayerController {
             };
         }
 
+        const statusPlayback = this.configuredContext()?.playback();
+        const liveEnded =
+            session.status === 'ended' &&
+            statusPlayback !== undefined &&
+            this.isLivePlayback(statusPlayback);
+
         switch (session.status) {
             case 'playing':
             case 'paused':
@@ -323,6 +343,16 @@ export class EmbeddedMpvControlsAdapter implements PlayerController {
                 return { status: session.status, statusMessage: '' };
             case 'ended':
             case 'closed':
+                if (liveEnded) {
+                    // A broadcast never ends on its own: surface it like an
+                    // error so the shared controls offer a way back.
+                    return {
+                        status: 'error',
+                        statusMessage: this.translate.instant(
+                            'EMBEDDED_MPV.PLAYER.STREAM_ENDED'
+                        ),
+                    };
+                }
                 return { status: 'ended', statusMessage: '' };
             case 'error':
                 return {
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.html b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.html
index 9737a9372..376fce965 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.html
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.html
@@ -31,13 +31,16 @@
                 data-embedded-mpv-frame
             ></canvas>
         }
-        @if (isErrored()) {
+        @if (isErrored() || isReconnecting() || isLiveEnded()) {
             <div
                 class="embedded-mpv-player__stalled"
                 role="alert"
                 aria-live="assertive"
+                [attr.data-reconnecting]="isReconnecting() ? '' : null"
             >
-                <mat-icon>error_outline</mat-icon>
+                <mat-icon>{{
+                    isReconnecting() ? 'sync' : 'error_outline'
+                }}</mat-icon>
                 <p>{{ statusLabel() }}</p>
                 <button mat-stroked-button type="button" (click)="retry()">
                     <mat-icon>refresh</mat-icon>
@@ -215,12 +218,10 @@
                         [disabled]="!canSeek()"
                         (click)="seekBy(10)"
                         [attr.aria-label]="
-                            'EMBEDDED_MPV.PLAYER.FORWARD_10_SECONDS'
-                                | translate
+                            'EMBEDDED_MPV.PLAYER.FORWARD_10_SECONDS' | translate
                         "
                         [matTooltip]="
-                            'EMBEDDED_MPV.PLAYER.FORWARD_10_SECONDS'
-                                | translate
+                            'EMBEDDED_MPV.PLAYER.FORWARD_10_SECONDS' | translate
                         "
                         matTooltipPosition="above"
                     >
@@ -330,9 +331,7 @@
                             >
                                 <input
                                     class="embedded-mpv-player__slider embedded-mpv-player__slider--volume"
-                                    [style.--slider-progress.%]="
-                                        volume() * 100
-                                    "
+                                    [style.--slider-progress.%]="volume() * 100"
                                     type="range"
                                     min="0"
                                     max="1"
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.spec.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.spec.ts
index 4116af872..20cd0609b 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.spec.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.spec.ts
@@ -367,4 +367,67 @@ describe('EmbeddedMpvPlayerComponent series navigation', () => {
         ).toBeNull();
         expect(fixture.nativeElement.textContent).toContain('--:--');
     });
+
+    it('offers Retry when a live stream ends without a reconnect in progress', () => {
+        fixture.componentInstance.playback = {
+            ...fixture.componentInstance.playback,
+            contentInfo: undefined,
+            isLive: true,
+        };
+        fixture.detectChanges();
+        controller.session.update((session) =>
+            session ? { ...session, status: 'ended' } : session
+        );
+        fixture.detectChanges();
+
+        const overlay = fixture.debugElement.query(
+            By.css('.embedded-mpv-player__stalled')
+        );
+        expect(overlay).not.toBeNull();
+        expect(overlay.nativeElement.textContent).toContain(
+            'EMBEDDED_MPV.PLAYER.STREAM_ENDED'
+        );
+        expect(overlay.query(By.css('button'))).not.toBeNull();
+    });
+
+    it('shows the reconnect attempt instead of the mpv error while the main process retries', () => {
+        controller.session.update((session) =>
+            session
+                ? {
+                      ...session,
+                      status: 'error',
+                      error: 'Connection reset by peer',
+                      reconnect: {
+                          attempt: 2,
+                          maxAttempts: 6,
+                          nextAttemptAt: '2026-06-06T12:00:04Z',
+                      },
+                  }
+                : session
+        );
+        fixture.detectChanges();
+
+        const overlay = fixture.debugElement.query(
+            By.css('.embedded-mpv-player__stalled[data-reconnecting]')
+        );
+        expect(overlay).not.toBeNull();
+        expect(overlay.nativeElement.textContent).toContain(
+            'EMBEDDED_MPV.PLAYER.RECONNECTING'
+        );
+        expect(overlay.nativeElement.textContent).not.toContain(
+            'Connection reset by peer'
+        );
+        expect(overlay.query(By.css('button'))).not.toBeNull();
+
+        controller.session.update((session) =>
+            session
+                ? { ...session, status: 'playing', reconnect: undefined }
+                : session
+        );
+        fixture.detectChanges();
+
+        expect(
+            fixture.debugElement.query(By.css('.embedded-mpv-player__stalled'))
+        ).toBeNull();
+    });
 });
diff --git a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.ts b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.ts
index 979a72b9a..ed2fef2da 100644
--- a/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.ts
+++ b/libs/ui/playback/src/lib/embedded-mpv-player/embedded-mpv-player.component.ts
@@ -173,6 +173,13 @@ export class EmbeddedMpvPlayerComponent implements OnDestroy {
     );
     readonly isPlaying = computed(() => this.session()?.status === 'playing');
     readonly isErrored = computed(() => this.session()?.status === 'error');
+    /**
+     * The main process is waiting to reload a dropped stream or has the
+     * reload in flight (see embedded-mpv-reconnect.ts); shown like an error
+     * with a countdown-free "attempt N of M" line, Retry still available.
+     */
+    readonly reconnectInfo = computed(() => this.session()?.reconnect ?? null);
+    readonly isReconnecting = computed(() => this.reconnectInfo() !== null);
     readonly isLivePlayback = computed(() => {
         const playback = this.playback();
         if (typeof playback.isLive === 'boolean') {
@@ -181,6 +188,14 @@ export class EmbeddedMpvPlayerComponent implements OnDestroy {
 
         return !playback.contentInfo;
     });
+    /**
+     * A live stream that ended and is not being reconnected: a broadcast
+     * never ends on its own, so this is a loss the viewer must be able to
+     * act on — the `ended` state otherwise looks like a paused player.
+     */
+    readonly isLiveEnded = computed(
+        () => this.isLivePlayback() && this.session()?.status === 'ended'
+    );
     readonly canSeek = computed(
         () =>
             !this.isLivePlayback() && (this.session()?.durationSeconds ?? 0) > 0
@@ -194,12 +209,21 @@ export class EmbeddedMpvPlayerComponent implements OnDestroy {
     readonly statusLabel = computed(() => {
         this.translationsTick();
         const session = this.session();
+        if (session?.reconnect) {
+            return this.translate.instant('EMBEDDED_MPV.PLAYER.RECONNECTING', {
+                attempt: session.reconnect.attempt,
+                maxAttempts: session.reconnect.maxAttempts,
+            });
+        }
         if (session?.status === 'error') {
             return (
                 session.error ??
                 this.translate.instant('EMBEDDED_MPV.PLAYER.PLAYBACK_FAILED')
             );
         }
+        if (session?.status === 'ended' && this.isLivePlayback()) {
+            return this.translate.instant('EMBEDDED_MPV.PLAYER.STREAM_ENDED');
+        }
         if (!this.support()) {
             return this.translate.instant(
                 'EMBEDDED_MPV.PLAYER.CHECKING_SUPPORT'
diff --git a/libs/ui/playback/src/lib/player-controls/controls-shortcuts.spec.ts b/libs/ui/playback/src/lib/player-controls/controls-shortcuts.spec.ts
index 74f4b6f2b..638b34c89 100644
--- a/libs/ui/playback/src/lib/player-controls/controls-shortcuts.spec.ts
+++ b/libs/ui/playback/src/lib/player-controls/controls-shortcuts.spec.ts
@@ -180,6 +180,37 @@ describe('ControlsShortcuts', () => {
         menuItem.remove();
     });
 
+    it('yields to a focused button only while it holds focus', () => {
+        const button = document.createElement('button');
+        document.body.append(button);
+        button.focus();
+
+        // The key reaches the focused button first: its activation owns
+        // Space, whatever the playback state.
+        button.dispatchEvent(
+            new KeyboardEvent('keydown', {
+                key: ' ',
+                bubbles: true,
+                cancelable: true,
+            })
+        );
+        expect(handlers.togglePaused).not.toHaveBeenCalled();
+
+        // Releasing the focus a pointer click left behind hands Space back
+        // to playback (the controls bar does this on a completed click).
+        button.blur();
+        const event = new KeyboardEvent('keydown', {
+            key: ' ',
+            bubbles: true,
+            cancelable: true,
+        });
+        document.body.dispatchEvent(event);
+
+        expect(event.defaultPrevented).toBe(true);
+        expect(handlers.togglePaused).toHaveBeenCalledTimes(1);
+        button.remove();
+    });
+
     it('ignores modified playback shortcuts without preventing their defaults', () => {
         expect(dispatchKey('k', { metaKey: true })).toBe(false);
         expect(dispatchKey('f', { ctrlKey: true })).toBe(false);
diff --git a/libs/ui/playback/src/lib/player-controls/controls-surface.spec.ts b/libs/ui/playback/src/lib/player-controls/controls-surface.spec.ts
index 12c06b5ba..ccb3ef294 100644
--- a/libs/ui/playback/src/lib/player-controls/controls-surface.spec.ts
+++ b/libs/ui/playback/src/lib/player-controls/controls-surface.spec.ts
@@ -352,4 +352,144 @@ describe('ControlsSurface', () => {
             expect(surface.wasPointerInteraction(focusOn(button))).toBe(false);
         });
     });
+
+    describe('pointer-originated click attribution', () => {
+        let button: HTMLButtonElement;
+        let icon: HTMLElement;
+
+        beforeEach(() => {
+            button = document.createElement('button');
+            icon = document.createElement('span');
+            button.appendChild(icon);
+            element.appendChild(button);
+        });
+
+        /** A click as an engine dispatches it; `pointerType` only when given. */
+        const clickOn = (target: EventTarget, pointerType?: string) => {
+            const event = new MouseEvent('click', { bubbles: true });
+            if (pointerType !== undefined) {
+                Object.defineProperty(event, 'pointerType', {
+                    value: pointerType,
+                });
+            }
+            Object.defineProperty(event, 'target', { value: target });
+            return event;
+        };
+
+        it('trusts a non-empty pointer type on the click', () => {
+            expect(surface.wasPointerClick(clickOn(button, 'mouse'))).toBe(
+                true
+            );
+            expect(surface.wasPointerClick(clickOn(button, 'touch'))).toBe(
+                true
+            );
+            expect(surface.wasPointerClick(clickOn(button, 'pen'))).toBe(true);
+        });
+
+        it('reads an empty pointer type as keyboard or script activation, even after a press', () => {
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            expect(surface.wasPointerClick(clickOn(button, ''))).toBe(false);
+        });
+
+        it('attributes a legacy click to a recent press inside the clicked element', () => {
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            expect(surface.wasPointerClick(clickOn(button))).toBe(true);
+        });
+
+        it('reports keyboard activation for a legacy click without a press', () => {
+            expect(surface.wasPointerClick(clickOn(button))).toBe(false);
+        });
+
+        it('reports keyboard activation when the press landed outside the clicked element', () => {
+            element.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            expect(surface.wasPointerClick(clickOn(button))).toBe(false);
+        });
+
+        it('consumes the press on the first legacy click it is asked about', () => {
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            expect(surface.wasPointerClick(clickOn(button))).toBe(true);
+            expect(surface.wasPointerClick(clickOn(button))).toBe(false);
+        });
+
+        it('answers the focus and the click of one press independently', () => {
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            const focus = new FocusEvent('focusin');
+            Object.defineProperty(focus, 'target', { value: button });
+            expect(surface.wasPointerInteraction(focus)).toBe(true);
+            expect(surface.wasPointerClick(clickOn(button))).toBe(true);
+        });
+
+        it('discards the press on any key press', () => {
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            document.dispatchEvent(
+                new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })
+            );
+            expect(surface.wasPointerClick(clickOn(button))).toBe(false);
+        });
+
+        it('forgets a press after the attribution window', () => {
+            jest.useFakeTimers();
+            jest.setSystemTime(new Date('2026-01-01T00:00:00Z'));
+            icon.dispatchEvent(pointerTypedEvent('pointerdown', 'mouse'));
+            jest.setSystemTime(new Date('2026-01-01T00:00:01.500Z'));
+            expect(surface.wasPointerClick(clickOn(button))).toBe(false);
+        });
+    });
+
+    describe('pointer focus release', () => {
+        let button: HTMLButtonElement;
+
+        beforeEach(() => {
+            button = document.createElement('button');
+            element.appendChild(button);
+        });
+
+        it('blurs the focused control inside the root and flags its focusout', () => {
+            button.focus();
+            let flagged: boolean | null = null;
+            element.addEventListener('focusout', () => {
+                flagged = surface.wasPointerFocusRelease();
+            });
+
+            expect(surface.releasePointerFocus(element)).toBe(true);
+
+            expect(document.activeElement).not.toBe(button);
+            expect(flagged).toBe(true);
+            expect(surface.wasPointerFocusRelease()).toBe(false);
+        });
+
+        it('releases a focused range slider', () => {
+            const slider = document.createElement('input');
+            slider.type = 'range';
+            element.appendChild(slider);
+            slider.focus();
+
+            expect(surface.releasePointerFocus(element)).toBe(true);
+            expect(document.activeElement).not.toBe(slider);
+        });
+
+        it('leaves focus outside the root alone', () => {
+            const outside = document.createElement('button');
+            document.body.appendChild(outside);
+            outside.focus();
+
+            expect(surface.releasePointerFocus(element)).toBe(false);
+            expect(document.activeElement).toBe(outside);
+            outside.remove();
+        });
+
+        it('does nothing when nothing is focused', () => {
+            expect(surface.releasePointerFocus(element)).toBe(false);
+        });
+
+        it('keeps focus in text entry', () => {
+            const field = document.createElement('input');
+            field.type = 'text';
+            element.appendChild(field);
+            field.focus();
+
+            expect(surface.releasePointerFocus(element)).toBe(false);
+            expect(document.activeElement).toBe(field);
+        });
+    });
 });
diff --git a/libs/ui/playback/src/lib/player-controls/controls-surface.ts b/libs/ui/playback/src/lib/player-controls/controls-surface.ts
index df00cee71..d70170fb7 100644
--- a/libs/ui/playback/src/lib/player-controls/controls-surface.ts
+++ b/libs/ui/playback/src/lib/player-controls/controls-surface.ts
@@ -1,3 +1,8 @@
+import {
+    blurFocusedControl,
+    clickPointerOrigin,
+} from './pointer-focus-release';
+
 export interface ControlsSurfaceHandlers {
     /** Reveal the controls (pointer move / enter / click on the surface). */
     reveal: () => void;
@@ -36,6 +41,11 @@ const POINTER_ATTRIBUTION_WINDOW_MS = 1000;
 
 const INTERACTIVE_SELECTOR = 'button, input, [role="slider"]';
 
+interface PointerPress {
+    at: number;
+    target: EventTarget | null;
+}
+
 /**
  * Owns the surface + document interaction wiring for the controls: reveal on
  * pointer activity, click-to-pause on the viewport, fullscreen on double-click,
@@ -48,14 +58,20 @@ export class ControlsSurface {
     private surfaceCleanup: (() => void) | null = null;
     private clickPauseTimer: ReturnType<typeof setTimeout> | null = null;
     private lastTouchPointerDownAt: number | null = null;
-    private lastPointerDown: { at: number; target: EventTarget | null } | null =
-        null;
+    /** The most recent press, answered once by the focus event it moved. */
+    private lastPointerDown: PointerPress | null = null;
+    /** The same press, answered once by the click it completes into. */
+    private lastPointerDownClick: PointerPress | null = null;
+    /** Set while {@link releasePointerFocus} dispatches its `focusout`. */
+    private pointerFocusRelease = false;
 
     private readonly onDocumentPointerDown = (event: PointerEvent) => {
         const now = Date.now();
         this.lastTouchPointerDownAt =
             event.pointerType === 'touch' ? now : null;
-        this.lastPointerDown = { at: now, target: event.target };
+        const press: PointerPress = { at: now, target: event.target };
+        this.lastPointerDown = press;
+        this.lastPointerDownClick = press;
         const path = event.composedPath();
         if (
             !this.surface ||
@@ -68,11 +84,13 @@ export class ControlsSurface {
     };
 
     /**
-     * Keyboard input ends pointer attribution: focus that moves after a key
-     * press was moved by the keyboard, whatever the last press hit.
+     * Keyboard input ends pointer attribution: focus that moves, or a click
+     * that fires, after a key press was produced by the keyboard, whatever
+     * the last press hit.
      */
     private readonly onDocumentKeyDown = () => {
         this.lastPointerDown = null;
+        this.lastPointerDownClick = null;
     };
 
     constructor(
@@ -189,6 +207,70 @@ export class ControlsSurface {
         );
     }
 
+    /**
+     * Whether a click completes a pointer press rather than keyboard
+     * activation or script. Click events are PointerEvents in current
+     * engines and carry an empty `pointerType` when nothing pointed
+     * (Enter/Space on a focused button, `element.click()`); a legacy
+     * MouseEvent click is attributed to a recent press that landed inside
+     * the clicked element. A press completes into at most one click, so the
+     * record is discarded on the first click it is asked about and on any
+     * key press (`onDocumentKeyDown`).
+     */
+    wasPointerClick(event: MouseEvent): boolean {
+        const origin = clickPointerOrigin(event);
+        if (origin !== null) {
+            return origin;
+        }
+        const press = this.lastPointerDownClick;
+        this.lastPointerDownClick = null;
+        if (
+            press === null ||
+            Date.now() - press.at > POINTER_ATTRIBUTION_WINDOW_MS
+        ) {
+            return false;
+        }
+        const clicked = event.target;
+        return (
+            clicked instanceof Node &&
+            press.target instanceof Node &&
+            clicked.contains(press.target)
+        );
+    }
+
+    /**
+     * Release the focus a pointer click left on a control inside `root`.
+     * Chromium focuses a clicked `<button>`, and a focused control captures
+     * the keyboard: Space and Enter activate it again and the playback
+     * shortcuts yield to it (`ControlsShortcuts` ignores keys whose path
+     * holds an interactive element). That focus was never the keyboard's,
+     * so it is dropped once the click completes. Chromium keeps its
+     * sequential focus navigation starting point at the blurred control, so
+     * a later Tab continues from it exactly as if it were still focused.
+     * Handlers of the resulting `focusout` can recognize the release through
+     * {@link wasPointerFocusRelease}. Returns whether focus was released.
+     * The eligibility rules live in `pointer-focus-release.ts`, shared with
+     * the vendor-chrome Video.js player.
+     */
+    releasePointerFocus(root: HTMLElement): boolean {
+        this.pointerFocusRelease = true;
+        try {
+            return blurFocusedControl(root);
+        } finally {
+            this.pointerFocusRelease = false;
+        }
+    }
+
+    /**
+     * Whether the `focusout` being dispatched right now comes from
+     * {@link releasePointerFocus}: the pointer is still where it clicked, so
+     * hover-scoped state (the volume popover) must not read it as focus
+     * leaving by keyboard.
+     */
+    wasPointerFocusRelease(): boolean {
+        return this.pointerFocusRelease;
+    }
+
     private onClick(event: MouseEvent): void {
         const touch = this.wasTouchInteraction(event);
         // Capture before revealing: a touch tap's semantics depend on whether
diff --git a/libs/ui/playback/src/lib/player-controls/controls-volume-interactions.ts b/libs/ui/playback/src/lib/player-controls/controls-volume-interactions.ts
index 6a96a5296..7c3dd81fc 100644
--- a/libs/ui/playback/src/lib/player-controls/controls-volume-interactions.ts
+++ b/libs/ui/playback/src/lib/player-controls/controls-volume-interactions.ts
@@ -6,6 +6,12 @@ export interface ControlsVolumeInteractionsDeps {
     menus: ControlsMenuState;
     /** Pointer-type attribution, provided by the surface. */
     wasTouchInteraction: (event?: Event) => boolean;
+    /**
+     * Whether the `focusout` being dispatched is the surface releasing the
+     * focus a pointer click left on a control. The pointer is still over the
+     * anchor, so the popover must not schedule its close on it.
+     */
+    wasPointerFocusRelease: () => boolean;
     /** Whether the controller advertises the volume capability. */
     canAdjustVolume: () => boolean;
     reveal: (options?: { scheduleHide?: boolean }) => void;
@@ -30,7 +36,10 @@ export class ControlsVolumeInteractions {
     }
 
     hoverLeave(event?: Event): void {
-        if (this.deps.wasTouchInteraction(event)) {
+        if (
+            this.deps.wasTouchInteraction(event) ||
+            this.deps.wasPointerFocusRelease()
+        ) {
             return;
         }
         this.deps.volume.hoverLeave();
diff --git a/libs/ui/playback/src/lib/player-controls/index.ts b/libs/ui/playback/src/lib/player-controls/index.ts
index f900833e9..9d88c35f6 100644
--- a/libs/ui/playback/src/lib/player-controls/index.ts
+++ b/libs/ui/playback/src/lib/player-controls/index.ts
@@ -9,6 +9,7 @@ export * from './controls-fullscreen';
 export * from './controls-shortcuts';
 export * from './legacy-player-shortcuts';
 export * from './controls-surface';
+export * from './pointer-focus-release';
 export * from './controls-timeline';
 export * from './controls-view-model';
 export * from './controls-visibility';
diff --git a/libs/ui/playback/src/lib/player-controls/player-controls.component.html b/libs/ui/playback/src/lib/player-controls/player-controls.component.html
index 23e350342..a1e08a875 100644
--- a/libs/ui/playback/src/lib/player-controls/player-controls.component.html
+++ b/libs/ui/playback/src/lib/player-controls/player-controls.component.html
@@ -34,6 +34,7 @@
         (pointerenter)="onBarPointerEnter()"
         (pointerleave)="onBarPointerLeave()"
         (pointerdown)="onBarPointerDown()"
+        (click)="onBarClick($event)"
         (keydown)="onBarKeyDown()"
         (focusin)="onBarFocusIn($event)"
         (focusout)="onBarFocusOut($event)"
diff --git a/libs/ui/playback/src/lib/player-controls/player-controls.component.spec.ts b/libs/ui/playback/src/lib/player-controls/player-controls.component.spec.ts
index 23048ba2d..f4b0caf88 100644
--- a/libs/ui/playback/src/lib/player-controls/player-controls.component.spec.ts
+++ b/libs/ui/playback/src/lib/player-controls/player-controls.component.spec.ts
@@ -319,7 +319,7 @@ describe('PlayerControlsComponent', () => {
             outside.remove();
         });
 
-        it('does not pin the bar on the focus a mouse click on a control produces', () => {
+        it('does not pin the bar on the focus a mouse press on a control produces', () => {
             setCapabilities({ fullscreen: true });
             setState({ status: 'playing' });
             const surface = document.createElement('div');
@@ -337,14 +337,14 @@ describe('PlayerControlsComponent', () => {
                 '[aria-label="Enter fullscreen"]'
             ) as HTMLButtonElement;
             const icon = button.querySelector('mat-icon') as HTMLElement;
-            // Chromium: pointerdown on the icon, focus moves to the button
-            // (focusin on the bar), then click — all from one mouse press.
+            // Chromium: pointerdown on the icon moves focus to the button
+            // (focusin on the bar). The press is released off the control,
+            // so no click completes it and nothing releases that focus.
             bar()?.dispatchEvent(new MouseEvent('pointerenter'));
             icon.dispatchEvent(
                 new MouseEvent('pointerdown', { bubbles: true })
             );
             button.focus();
-            button.click();
             fixture.detectChanges();
             expect(document.activeElement).toBe(button);
             expect(fixture.componentInstance.controlsAreVisible()).toBe(true);
@@ -419,7 +419,7 @@ describe('PlayerControlsComponent', () => {
             expect(fixture.componentInstance.controlsAreVisible()).toBe(false);
         });
 
-        it('releases a keyboard pin when the mouse clicks the focused control itself', () => {
+        it('releases a keyboard pin when the mouse presses the focused control itself', () => {
             const buttons = Array.from(
                 bar()?.querySelectorAll('button') ?? []
             ) as HTMLButtonElement[];
@@ -428,12 +428,13 @@ describe('PlayerControlsComponent', () => {
             jest.advanceTimersByTime(10000);
             expect(fixture.componentInstance.controlsAreVisible()).toBe(true);
 
-            // Clicking the already focused button produces no focus event.
+            // A press on the already focused button produces no focus event;
+            // released off the control it produces no click either, so the
+            // pointerdown alone must release the pin.
             bar()?.dispatchEvent(new MouseEvent('pointerenter'));
             buttons[0].dispatchEvent(
                 new MouseEvent('pointerdown', { bubbles: true })
             );
-            buttons[0].click();
             fixture.detectChanges();
             expect(document.activeElement).toBe(buttons[0]);
             bar()?.dispatchEvent(new MouseEvent('pointerleave'));
@@ -462,7 +463,8 @@ describe('PlayerControlsComponent', () => {
             buttons[1].focus();
             buttons[1].click();
             fixture.detectChanges();
-            // ...then Shift+Tab away and Tab back before the press expires.
+            // ...which releases its focus. Tab back into the bar and on to
+            // the clicked control before the press expires.
             buttons[0].focus();
             buttons[1].focus();
             fixture.detectChanges();
@@ -518,7 +520,7 @@ describe('PlayerControlsComponent', () => {
             expect(fixture.componentInstance.controlsAreVisible()).toBe(true);
         });
 
-        it('pins the bar when the keyboard operates a mouse-focused control', () => {
+        it('pins the bar when the keyboard operates a control a press left focused', () => {
             setCapabilities({ seek: true });
             setState({
                 status: 'playing',
@@ -530,13 +532,13 @@ describe('PlayerControlsComponent', () => {
                 bar()?.querySelectorAll('button') ?? []
             ) as HTMLButtonElement[];
 
-            // Mouse click leaves the control focused but not pinned...
+            // A press released off the control leaves it focused but not
+            // pinned (no click completed, so nothing released the focus)...
             bar()?.dispatchEvent(new MouseEvent('pointerenter'));
             buttons[1].dispatchEvent(
                 new MouseEvent('pointerdown', { bubbles: true })
             );
             buttons[1].focus();
-            buttons[1].click();
             fixture.detectChanges();
             bar()?.dispatchEvent(new MouseEvent('pointerleave'));
             fixture.detectChanges();
@@ -563,6 +565,177 @@ describe('PlayerControlsComponent', () => {
         });
     });
 
+    describe('pointer focus release', () => {
+        const bar = () => query('.player-controls__bar') as HTMLElement | null;
+
+        beforeEach(() => {
+            jest.useFakeTimers();
+            setState({ status: 'playing' });
+            fixture.detectChanges();
+        });
+
+        afterEach(() => {
+            jest.runOnlyPendingTimers();
+            jest.useRealTimers();
+        });
+
+        /** A click as Chromium dispatches it: a PointerEvent whose
+         * `pointerType` names the device, or is empty for Enter/Space. */
+        const click = (target: HTMLElement, pointerType: string) => {
+            const event = new MouseEvent('click', {
+                bubbles: true,
+                cancelable: true,
+            });
+            Object.defineProperty(event, 'pointerType', {
+                value: pointerType,
+            });
+            target.dispatchEvent(event);
+        };
+
+        const space = (target: EventTarget) => {
+            const event = new KeyboardEvent('keydown', {
+                key: ' ',
+                bubbles: true,
+                cancelable: true,
+            });
+            target.dispatchEvent(event);
+            return event.defaultPrevented;
+        };
+
+        const mountFullscreenSurface = () => {
+            const surface = document.createElement('div');
+            document.body.appendChild(surface);
+            const requestFullscreen = jest.fn(() => Promise.resolve());
+            (
+                surface as unknown as { requestFullscreen: unknown }
+            ).requestFullscreen = requestFullscreen;
+            (
+                document as unknown as { exitFullscreen: unknown }
+            ).exitFullscreen = jest.fn(() => Promise.resolve());
+            setCapabilities({ fullscreen: true });
+            fixture.componentRef.setInput('playerSurface', surface);
+            fixture.detectChanges();
+            const button = query(
+                '[aria-label="Enter fullscreen"]'
+            ) as HTMLButtonElement;
+            return {
+                button,
+                requestFullscreen,
+                dispose: () => {
+                    surface.remove();
+                    delete (document as unknown as { exitFullscreen?: unknown })
+                        .exitFullscreen;
+                },
+            };
+        };
+
+        it('releases the focus a mouse click leaves on a button so Space toggles playback again', () => {
+            const { button, requestFullscreen, dispose } =
+                mountFullscreenSurface();
+            const icon = button.querySelector('mat-icon') as HTMLElement;
+
+            // Chromium: pointerdown focuses the button, then the click.
+            icon.dispatchEvent(
+                new MouseEvent('pointerdown', { bubbles: true })
+            );
+            button.focus();
+            expect(document.activeElement).toBe(button);
+            click(icon, 'mouse');
+            fixture.detectChanges();
+
+            expect(requestFullscreen).toHaveBeenCalledTimes(1);
+            expect(document.activeElement).not.toBe(button);
+            // Space now reaches the playback shortcut instead of activating
+            // the fullscreen button again.
+            expect(space(document.activeElement ?? document.body)).toBe(true);
+            expect(fake.commands.togglePlay).toHaveBeenCalledTimes(1);
+            dispose();
+        });
+
+        it('releases focus after a legacy MouseEvent click that completes a recorded press', () => {
+            const { button, dispose } = mountFullscreenSurface();
+            button.dispatchEvent(
+                new MouseEvent('pointerdown', { bubbles: true })
+            );
+            button.focus();
+
+            // jsdom dispatches a click without a pointerType.
+            button.click();
+            fixture.detectChanges();
+
+            expect(document.activeElement).not.toBe(button);
+            dispose();
+        });
+
+        it('keeps focus on a control the keyboard activates', () => {
+            const { button, requestFullscreen, dispose } =
+                mountFullscreenSurface();
+            button.focus();
+
+            // Enter/Space: a synthetic click with an empty pointer type...
+            click(button, '');
+            fixture.detectChanges();
+            expect(requestFullscreen).toHaveBeenCalledTimes(1);
+            expect(document.activeElement).toBe(button);
+
+            // ...and a legacy synthetic click with no press to attribute.
+            button.click();
+            fixture.detectChanges();
+            expect(requestFullscreen).toHaveBeenCalledTimes(2);
+            expect(document.activeElement).toBe(button);
+            dispose();
+        });
+
+        it('keeps the volume popover open when a mouse click on the mute button releases its focus', () => {
+            setCapabilities({ volume: true });
+            fixture.detectChanges();
+            const anchor = query(
+                '.player-controls__popover-anchor'
+            ) as HTMLElement;
+            const mute = anchor.querySelector('button') as HTMLButtonElement;
+
+            // Hovering the anchor opens the popover; the pointer stays there.
+            anchor.dispatchEvent(new MouseEvent('pointerenter'));
+            fixture.detectChanges();
+            expect(fixture.componentInstance.menus.volumeOpen()).toBe(true);
+
+            mute.dispatchEvent(
+                new MouseEvent('pointerdown', { bubbles: true })
+            );
+            mute.focus();
+            click(mute, 'mouse');
+            fixture.detectChanges();
+            expect(document.activeElement).not.toBe(mute);
+
+            jest.advanceTimersByTime(10000);
+            fixture.detectChanges();
+            expect(fixture.componentInstance.menus.volumeOpen()).toBe(true);
+            expect(bar()).not.toBeNull();
+        });
+
+        it('still closes the volume popover when keyboard focus leaves the anchor', () => {
+            setCapabilities({ volume: true });
+            fixture.detectChanges();
+            const anchor = query(
+                '.player-controls__popover-anchor'
+            ) as HTMLElement;
+            const mute = anchor.querySelector('button') as HTMLButtonElement;
+
+            mute.focus();
+            fixture.detectChanges();
+            expect(fixture.componentInstance.menus.volumeOpen()).toBe(true);
+
+            const outside = document.createElement('button');
+            document.body.appendChild(outside);
+            outside.focus();
+            fixture.detectChanges();
+            jest.advanceTimersByTime(10000);
+            fixture.detectChanges();
+            expect(fixture.componentInstance.menus.volumeOpen()).toBe(false);
+            outside.remove();
+        });
+    });
+
     describe('bar-hover state', () => {
         const bar = () => query('.player-controls__bar') as HTMLElement | null;
 
diff --git a/libs/ui/playback/src/lib/player-controls/player-controls.component.ts b/libs/ui/playback/src/lib/player-controls/player-controls.component.ts
index 714a95b65..4a9a933ba 100644
--- a/libs/ui/playback/src/lib/player-controls/player-controls.component.ts
+++ b/libs/ui/playback/src/lib/player-controls/player-controls.component.ts
@@ -114,6 +114,7 @@ export class PlayerControlsComponent implements OnDestroy {
         volume: this.volume,
         menus: this.menus,
         wasTouchInteraction: (event) => this.surface.wasTouchInteraction(event),
+        wasPointerFocusRelease: () => this.surface.wasPointerFocusRelease(),
         canAdjustVolume: () => this.capabilities().volume,
         reveal: (options) => this.reveal(options),
     });
@@ -387,21 +388,39 @@ export class PlayerControlsComponent implements OnDestroy {
      * A key press that bubbles out of a control inside the bar means the
      * keyboard is operating that control (Space/Enter on a button, arrows on
      * a slider): the bar is pinned exactly as if the control had been focused
-     * with Tab. A mouse click leaves its button focused without a pin, and
-     * the key press produces no new focus event, so this is the only place
-     * that hands ownership back to the keyboard.
+     * with Tab. A completed pointer click no longer leaves its control
+     * focused (`onBarClick`), but a press released off the control does,
+     * without a pin, and the key press then produces no new focus event, so
+     * this is the only place that hands ownership back to the keyboard.
      */
     onBarKeyDown(): void {
         this.barFocused.set(true);
         this.reveal({ scheduleHide: false });
     }
 
+    /**
+     * A pointer click leaves the clicked control focused (`onBarFocusIn`),
+     * and a focused control captures the keyboard: Space and Enter activate
+     * it again instead of toggling playback, and the playback shortcuts
+     * yield to any interactive element in the key's path — after a click on
+     * the fullscreen button, Space left fullscreen instead of pausing. The
+     * focus was never the keyboard's, so it is released once the click
+     * completes; keyboard activation (an empty click `pointerType`) keeps
+     * focus where Tab put it.
+     */
+    onBarClick(event: MouseEvent): void {
+        const bar = event.currentTarget;
+        if (bar instanceof HTMLElement && this.surface.wasPointerClick(event)) {
+            this.surface.releasePointerFocus(bar);
+        }
+    }
+
     onBarFocusIn(event: FocusEvent): void {
         // Chromium moves focus to a clicked <button>. That focus is a side
         // effect of the click, not keyboard navigation: it must reveal like
-        // any pointer activity, but never pin the bar open until the next
-        // click on the video takes focus away (issue: fullscreen button left
-        // the controls on screen until a click-to-pause on the viewport).
+        // any pointer activity, but never pin the bar open; `onBarClick`
+        // drops it again once the click completes (issue: fullscreen button
+        // left the controls on screen until a click-to-pause on the viewport).
         if (this.surface.wasPointerInteraction(event)) {
             this.barFocused.set(false);
             this.reveal();
diff --git a/libs/ui/playback/src/lib/player-controls/pointer-focus-release.spec.ts b/libs/ui/playback/src/lib/player-controls/pointer-focus-release.spec.ts
new file mode 100644
index 000000000..52bfdefc1
--- /dev/null
+++ b/libs/ui/playback/src/lib/player-controls/pointer-focus-release.spec.ts
@@ -0,0 +1,105 @@
+import {
+    blurFocusedControl,
+    clickPointerOrigin,
+} from './pointer-focus-release';
+
+/** A click as an engine dispatches it; `pointerType` only when given. */
+function click(pointerType?: string): MouseEvent {
+    const event = new MouseEvent('click', { bubbles: true });
+    if (pointerType !== undefined) {
+        Object.defineProperty(event, 'pointerType', { value: pointerType });
+    }
+    return event;
+}
+
+describe('clickPointerOrigin', () => {
+    it('reports a pointer for mouse, touch, and pen clicks', () => {
+        expect(clickPointerOrigin(click('mouse'))).toBe(true);
+        expect(clickPointerOrigin(click('touch'))).toBe(true);
+        expect(clickPointerOrigin(click('pen'))).toBe(true);
+    });
+
+    it('reports keyboard or script activation for an empty pointer type', () => {
+        expect(clickPointerOrigin(click(''))).toBe(false);
+    });
+
+    it('reports unknown for a legacy click without a pointer type', () => {
+        expect(clickPointerOrigin(click())).toBeNull();
+    });
+});
+
+describe('blurFocusedControl', () => {
+    let root: HTMLElement;
+
+    beforeEach(() => {
+        root = document.createElement('div');
+        document.body.appendChild(root);
+    });
+
+    afterEach(() => {
+        root.remove();
+    });
+
+    it('blurs a focused button inside the root', () => {
+        const button = document.createElement('button');
+        root.appendChild(button);
+        button.focus();
+
+        expect(blurFocusedControl(root)).toBe(true);
+        expect(document.activeElement).not.toBe(button);
+    });
+
+    it('blurs a focused range input and ARIA slider by default', () => {
+        const range = document.createElement('input');
+        range.type = 'range';
+        const slider = document.createElement('div');
+        slider.setAttribute('role', 'slider');
+        slider.tabIndex = 0;
+        root.append(range, slider);
+
+        range.focus();
+        expect(blurFocusedControl(root)).toBe(true);
+        slider.focus();
+        expect(blurFocusedControl(root)).toBe(true);
+        expect(document.activeElement).toBe(document.body);
+    });
+
+    it('leaves focus outside the root alone', () => {
+        const outside = document.createElement('button');
+        document.body.appendChild(outside);
+        outside.focus();
+
+        expect(blurFocusedControl(root)).toBe(false);
+        expect(document.activeElement).toBe(outside);
+        outside.remove();
+    });
+
+    it('does nothing when nothing is focused', () => {
+        expect(blurFocusedControl(root)).toBe(false);
+    });
+
+    it('keeps focus in text entry', () => {
+        const field = document.createElement('input');
+        field.type = 'text';
+        root.appendChild(field);
+        field.focus();
+
+        expect(blurFocusedControl(root)).toBe(false);
+        expect(document.activeElement).toBe(field);
+    });
+
+    it('honors a custom selector', () => {
+        const clickable = document.createElement('div');
+        clickable.setAttribute('role', 'button');
+        clickable.tabIndex = 0;
+        root.appendChild(clickable);
+        clickable.focus();
+
+        expect(blurFocusedControl(root)).toBe(false);
+        expect(document.activeElement).toBe(clickable);
+        expect(blurFocusedControl(root, { selector: '[role="button"]' })).toBe(
+            true
+        );
+        expect(document.activeElement).not.toBe(clickable);
+    });
+});
diff --git a/libs/ui/playback/src/lib/player-controls/pointer-focus-release.ts b/libs/ui/playback/src/lib/player-controls/pointer-focus-release.ts
new file mode 100644
index 000000000..9017a4c19
--- /dev/null
+++ b/libs/ui/playback/src/lib/player-controls/pointer-focus-release.ts
@@ -0,0 +1,52 @@
+/**
+ * Controls whose pointer-originated focus is released once the click that
+ * produced it completes. Text entry is deliberately absent: a click into a
+ * field must not end typing. Neither the shared controls bar nor the vendor
+ * chrome holds one today.
+ */
+export const POINTER_FOCUS_RELEASE_SELECTOR =
+    'button, input[type="range"], [role="slider"]';
+
+export interface BlurFocusedControlOptions {
+    /** Controls eligible for release; defaults to the shared selector. */
+    selector?: string;
+}
+
+/**
+ * What a click's own `pointerType` says about its origin: `true` for a
+ * pointer (mouse, touch, pen); `false` for keyboard activation or script,
+ * since current engines dispatch Enter/Space on a focused button and
+ * `element.click()` as a PointerEvent with an empty `pointerType`; `null`
+ * for a legacy MouseEvent click that carries no pointer type at all, which
+ * the caller must attribute some other way or leave alone.
+ */
+export function clickPointerOrigin(event: MouseEvent): boolean | null {
+    const pointerType = (event as Partial<PointerEvent>).pointerType;
+    return typeof pointerType === 'string' ? pointerType !== '' : null;
+}
+
+/**
+ * Blur the focused control inside `root` when it is eligible. Chromium
+ * focuses a clicked `<button>`, and a focused control captures the keyboard:
+ * Space and Enter activate it again and the playback shortcuts yield to it.
+ * Focus a pointer click left behind was never the keyboard's, so it is
+ * dropped once the click completes; Chromium keeps its sequential focus
+ * navigation starting point at the blurred control, so a later Tab
+ * continues from it exactly as if it were still focused. Returns whether
+ * focus was released.
+ */
+export function blurFocusedControl(
+    root: HTMLElement,
+    options: BlurFocusedControlOptions = {}
+): boolean {
+    const active = root.ownerDocument.activeElement;
+    if (
+        !(active instanceof HTMLElement) ||
+        !root.contains(active) ||
+        !active.matches(options.selector ?? POINTER_FOCUS_RELEASE_SELECTOR)
+    ) {
+        return false;
+    }
+    active.blur();
+    return true;
+}
diff --git a/libs/ui/playback/src/lib/vjs-player/vjs-player.component.pointer-focus.spec.ts b/libs/ui/playback/src/lib/vjs-player/vjs-player.component.pointer-focus.spec.ts
new file mode 100644
index 000000000..482338f13
--- /dev/null
+++ b/libs/ui/playback/src/lib/vjs-player/vjs-player.component.pointer-focus.spec.ts
@@ -0,0 +1,132 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TranslateModule } from '@ngx-translate/core';
+import { WEB_PLAYER_SHARED_CONTROLS } from '../player-controls/web-player-controls.flag';
+import type { VjsPlayerComponent as VjsPlayerComponentInstance } from './vjs-player.component';
+import type { VideoJsPlayer } from './vjs-player.types';
+
+const videoJsMock = jest.fn();
+
+jest.unstable_mockModule('video.js', () => ({ default: videoJsMock }));
+jest.unstable_mockModule('@yangkghjh/videojs-aspect-ratio-panel', () => ({}));
+jest.unstable_mockModule('videojs-contrib-quality-levels', () => ({}));
+jest.unstable_mockModule('videojs-quality-selector-hls', () => ({}));
+jest.unstable_mockModule('mpegts.js', () => ({
+    default: {
+        Events: { ERROR: 'error' },
+        createPlayer: jest.fn(),
+        isSupported: jest.fn(() => false),
+    },
+}));
+
+// Real `attachVjsPointerFocusRelease` is exercised through the shell so the
+// test proves both the ngAfterViewInit wiring (the view child must be
+// resolved) and that the shared-controls guard and teardown behave.
+describe('VjsPlayerComponent pointer focus release wiring', () => {
+    let VjsPlayerComponent: typeof import('./vjs-player.component').VjsPlayerComponent;
+    let fixture: ComponentFixture<VjsPlayerComponentInstance>;
+
+    beforeAll(async () => {
+        ({ VjsPlayerComponent } = await import('./vjs-player.component'));
+    });
+
+    beforeEach(() => {
+        videoJsMock.mockReset().mockImplementation(() => createPlayerMock());
+    });
+
+    afterEach(() => {
+        fixture?.destroy();
+    });
+
+    const mount = async (sharedControls: boolean) => {
+        await TestBed.configureTestingModule({
+            imports: [VjsPlayerComponent, TranslateModule.forRoot()],
+            providers: [
+                {
+                    provide: WEB_PLAYER_SHARED_CONTROLS,
+                    useValue: sharedControls,
+                },
+            ],
+        }).compileComponents();
+        fixture = TestBed.createComponent(VjsPlayerComponent);
+        fixture.componentRef.setInput('options', {
+            sources: [{ src: 'https://example.test/movie.mp4' }],
+        });
+        fixture.detectChanges();
+        return fixture.nativeElement.querySelector(
+            '.vjs-player-shell'
+        ) as HTMLElement;
+    };
+
+    /**
+     * A control bar with a button — the mocked player renders neither, and
+     * the release is scoped to `.vjs-control-bar`, so the test owns both.
+     */
+    const addControl = (shell: HTMLElement) => {
+        const bar = document.createElement('div');
+        bar.className = 'vjs-control-bar';
+        const button = document.createElement('button');
+        bar.appendChild(button);
+        shell.appendChild(bar);
+        return button;
+    };
+
+    const pressAndFocus = (shell: HTMLElement, control: HTMLElement) => {
+        shell.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true }));
+        control.focus();
+    };
+
+    it('releases the focus a pointer press leaves on a control (attach reached the resolved shell)', async () => {
+        const shell = await mount(false);
+        const control = addControl(shell);
+
+        pressAndFocus(shell, control);
+
+        expect(document.activeElement).not.toBe(control);
+    });
+
+    it('leaves the control focused after the component is destroyed', async () => {
+        const shell = await mount(false);
+        const control = addControl(shell);
+        fixture.destroy();
+
+        pressAndFocus(shell, control);
+
+        expect(document.activeElement).toBe(control);
+    });
+
+    it('does not attach when shared controls own the surface', async () => {
+        const shell = await mount(true);
+        const control = addControl(shell);
+
+        pressAndFocus(shell, control);
+
+        expect(document.activeElement).toBe(control);
+    });
+});
+
+function createPlayerMock(): VideoJsPlayer {
+    const player = {
+        on: jest.fn(),
+        off: jest.fn(),
+        ready: jest.fn(),
+        getChild: jest.fn(() => null),
+        audioTracks: jest.fn(() => null),
+        textTracks: jest.fn(() => null),
+        currentTime: jest.fn(() => 0),
+        duration: jest.fn(() => 0),
+        error: jest.fn(() => null),
+        paused: jest.fn(() => true),
+        play: jest.fn(() => Promise.resolve()),
+        pause: jest.fn(),
+        volume: jest.fn(() => 1),
+        muted: jest.fn(() => false),
+        src: jest.fn(),
+        reset: jest.fn(),
+        dispose: jest.fn(),
+        isFullscreen: jest.fn(() => false),
+        requestFullscreen: jest.fn(),
+        exitFullscreen: jest.fn(),
+        controlBar: { getChild: jest.fn(() => null) },
+    };
+    return player as unknown as VideoJsPlayer;
+}
diff --git a/libs/ui/playback/src/lib/vjs-player/vjs-player.component.ts b/libs/ui/playback/src/lib/vjs-player/vjs-player.component.ts
index a4b5cad18..7c7e12f4e 100644
--- a/libs/ui/playback/src/lib/vjs-player/vjs-player.component.ts
+++ b/libs/ui/playback/src/lib/vjs-player/vjs-player.component.ts
@@ -37,6 +37,7 @@ import { logVjsAudioTracks, setupVjsAudioTrackMenu } from './vjs-audio-tracks';
 import { VjsLegacyTracks } from './vjs-legacy-tracks';
 import { VjsMpegTsSession } from './vjs-mpegts-session';
 import { attachVjsLegacyShortcuts } from './vjs-legacy-shortcuts';
+import { attachVjsPointerFocusRelease } from './vjs-pointer-focus-release';
 import { VjsPlayerControlsBridge } from './vjs-player-controls.bridge';
 import {
     createVjsPlayerOptions,
@@ -119,6 +120,8 @@ export class VjsPlayerComponent implements OnInit, OnChanges, OnDestroy {
     private legacyTracks: VjsLegacyTracks | null = null;
     /** Keyboard shortcuts for the legacy chrome; null with shared controls. */
     private legacyShortcuts: LegacyPlayerShortcuts | null = null;
+    /** Pointer focus release for the legacy chrome; null with shared controls. */
+    private detachPointerFocusRelease: (() => void) | null = null;
     private desiredSource: VideoPlayerSource | null = null;
     private readyHandled = false;
     private destroyed = false;
@@ -151,6 +154,11 @@ export class VjsPlayerComponent implements OnInit, OnChanges, OnDestroy {
                 isAvailable: () => this.interactionEnabled(),
                 isLive: () => this.options().isLive !== false,
             });
+            const shell = this.playerRoot()?.nativeElement;
+            if (shell) {
+                this.detachPointerFocusRelease =
+                    attachVjsPointerFocusRelease(shell);
+            }
         }
     }
 
@@ -201,6 +209,8 @@ export class VjsPlayerComponent implements OnInit, OnChanges, OnDestroy {
         this.destroyed = true;
         this.legacyShortcuts?.detach();
         this.legacyShortcuts = null;
+        this.detachPointerFocusRelease?.();
+        this.detachPointerFocusRelease = null;
         this.resetCoordinator.destroy();
         this.controlsBridge?.destroy();
         this.controlsBridge = null;
diff --git a/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.spec.ts b/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.spec.ts
new file mode 100644
index 000000000..f6a56b8a7
--- /dev/null
+++ b/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.spec.ts
@@ -0,0 +1,196 @@
+import { attachVjsPointerFocusRelease } from './vjs-pointer-focus-release';
+
+describe('attachVjsPointerFocusRelease', () => {
+    let root: HTMLElement;
+    let fullscreen: HTMLButtonElement;
+    let seekBar: HTMLElement;
+    let menuButton: HTMLButtonElement;
+    let menuItem: HTMLElement;
+    let modalResetButton: HTMLButtonElement;
+    let detach: () => void;
+
+    beforeEach(() => {
+        root = document.createElement('div');
+        root.className = 'vjs-player-shell';
+        // The Video.js 8 layout that matters here: the control bar holds the
+        // focusable chrome (buttons, sliders, a menu button whose popup items
+        // are focused by `MenuButton.pressButton()`); the caption-settings
+        // dialog is a modal *sibling* of the control bar, under `.video-js`.
+        root.innerHTML = `
+            <div class="video-js">
+                <div class="vjs-control-bar">
+                    <div class="vjs-progress-control vjs-control">
+                        <div class="vjs-progress-holder vjs-slider" role="slider" tabindex="0"></div>
+                    </div>
+                    <div class="vjs-playback-rate vjs-menu-button-popup vjs-control">
+                        <button class="vjs-playback-rate vjs-menu-button" type="button" aria-expanded="false"></button>
+                        <div class="vjs-menu">
+                            <ul class="vjs-menu-content" role="menu">
+                                <li class="vjs-menu-item" role="menuitemradio" tabindex="-1"></li>
+                            </ul>
+                        </div>
+                    </div>
+                    <button class="vjs-fullscreen-control vjs-control vjs-button" type="button"></button>
+                </div>
+                <div class="vjs-text-track-settings vjs-modal-dialog" role="dialog">
+                    <button class="vjs-default-button" type="button"></button>
+                </div>
+            </div>`;
+        document.body.appendChild(root);
+        fullscreen = root.querySelector(
+            '.vjs-fullscreen-control'
+        ) as HTMLButtonElement;
+        seekBar = root.querySelector('.vjs-progress-holder') as HTMLElement;
+        menuButton = root.querySelector(
+            'button.vjs-menu-button'
+        ) as HTMLButtonElement;
+        menuItem = root.querySelector('.vjs-menu-item') as HTMLElement;
+        modalResetButton = root.querySelector(
+            '.vjs-text-track-settings .vjs-default-button'
+        ) as HTMLButtonElement;
+        detach = attachVjsPointerFocusRelease(root);
+    });
+
+    afterEach(() => {
+        detach();
+        root.remove();
+        jest.useRealTimers();
+    });
+
+    /** A pointer press as the pane sees it (jsdom lacks PointerEvent). */
+    const pointerDown = (target: EventTarget = root) => {
+        target.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true }));
+    };
+
+    const keyDown = (target: EventTarget = document.body) => {
+        target.dispatchEvent(
+            new KeyboardEvent('keydown', { key: 'Tab', bubbles: true })
+        );
+    };
+
+    const click = (target: EventTarget) => {
+        target.dispatchEvent(
+            new MouseEvent('click', { bubbles: true, cancelable: true })
+        );
+    };
+
+    it('releases the focus that lands on a control-bar button after a pointer press', () => {
+        pointerDown();
+        fullscreen.focus();
+
+        expect(document.activeElement).not.toBe(fullscreen);
+    });
+
+    it('releases a control-bar control clicked while it was already focused', () => {
+        // Tab focuses it (kept — no pointer press yet), then a mouse click on
+        // the same control moves no focus and fires no focusin, so the click
+        // is the only signal.
+        fullscreen.focus();
+        expect(document.activeElement).toBe(fullscreen);
+
+        pointerDown();
+        click(fullscreen);
+
+        expect(document.activeElement).not.toBe(fullscreen);
+    });
+
+    it('keeps an already-focused control the keyboard activates', () => {
+        // Space/Enter on a focused button fires a click with no preceding
+        // pointerdown, so the focus is kept.
+        fullscreen.focus();
+
+        click(fullscreen);
+
+        expect(document.activeElement).toBe(fullscreen);
+    });
+
+    it('leaves a modal dialog button focused when it is clicked', () => {
+        pointerDown(modalResetButton);
+        modalResetButton.focus();
+        // Even the click path is scoped to the control bar.
+        click(modalResetButton);
+
+        expect(document.activeElement).toBe(modalResetButton);
+    });
+
+    it('releases a control-bar slider', () => {
+        pointerDown();
+        seekBar.focus();
+
+        expect(document.activeElement).not.toBe(seekBar);
+    });
+
+    it('leaves a modal dialog button focused so its focus trap survives', () => {
+        // The caption-settings dialog keeps its own Escape/Tab handling; its
+        // Reset button sits outside the control bar and must not be released.
+        pointerDown(modalResetButton);
+        modalResetButton.focus();
+
+        expect(document.activeElement).toBe(modalResetButton);
+    });
+
+    it('keeps focus that no pointer press preceded (keyboard navigation)', () => {
+        fullscreen.focus();
+
+        expect(document.activeElement).toBe(fullscreen);
+    });
+
+    it('keeps focus once a key press has ended the pointer attribution', () => {
+        // The key that follows a release is pressed while focus rests on
+        // body, outside the shell, so the clear must not depend on the shell.
+        pointerDown();
+        keyDown(document);
+        fullscreen.focus();
+
+        expect(document.activeElement).toBe(fullscreen);
+    });
+
+    it('releases the menu button Video.js focuses after an item is chosen', () => {
+        // Choosing an item: the press lands on the item, which is not
+        // eligible, then Video.js moves focus to the now-collapsed button.
+        pointerDown(menuItem);
+        menuItem.focus();
+        expect(document.activeElement).toBe(menuItem);
+
+        menuButton.setAttribute('aria-expanded', 'false');
+        menuButton.focus();
+        expect(document.activeElement).not.toBe(menuButton);
+    });
+
+    it('releases an expanded menu button so Space works after a click closes it', () => {
+        // Toggling an open menu shut with a pointer moves focus item -> button
+        // while the button is still expanded; the button then swallows keys
+        // until released. It is not exempt: the popup is navigated through its
+        // item, so dropping the button focus never disturbs an open menu.
+        menuButton.setAttribute('aria-expanded', 'true');
+        pointerDown();
+        menuButton.focus();
+
+        expect(document.activeElement).not.toBe(menuButton);
+    });
+
+    it('keeps a focused menu item so arrow navigation survives', () => {
+        pointerDown();
+        menuItem.focus();
+
+        expect(document.activeElement).toBe(menuItem);
+    });
+
+    it('forgets a pointer press after the attribution window', () => {
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2026-01-01T00:00:00Z'));
+        pointerDown();
+        jest.setSystemTime(new Date('2026-01-01T00:00:01.500Z'));
+        fullscreen.focus();
+
+        expect(document.activeElement).toBe(fullscreen);
+    });
+
+    it('stops releasing after detach', () => {
+        detach();
+        pointerDown();
+        fullscreen.focus();
+
+        expect(document.activeElement).toBe(fullscreen);
+    });
+});
diff --git a/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.ts b/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.ts
new file mode 100644
index 000000000..7788531f4
--- /dev/null
+++ b/libs/ui/playback/src/lib/vjs-player/vjs-pointer-focus-release.ts
@@ -0,0 +1,120 @@
+import { blurFocusedControl } from '../player-controls';
+
+/**
+ * How long after a pointer press a focus that lands on a control is still
+ * attributed to that press. A menu selection moves focus to the menu button
+ * a tick or two after the click, so the window covers that gap while a later
+ * keydown ends it (Tab focus must not be attributed to a stale press).
+ */
+const POINTER_ATTRIBUTION_WINDOW_MS = 1000;
+
+/** The persistent chrome the release is scoped to (see the doc comment). */
+const VJS_CONTROL_BAR_SELECTOR = '.vjs-control-bar';
+
+/**
+ * Control-bar focusables that capture the keyboard: `<button>`s (including
+ * menu buttons), `ClickableComponent` divs (`role="button"`) and sliders
+ * (`role="slider"`). Menu items are `role="menuitem*"` and are deliberately
+ * absent — while a menu is open its item, not its button, owns arrow-key
+ * navigation, so releasing the button never disturbs it.
+ */
+const VJS_RELEASE_SELECTOR = 'button, [role="button"], [role="slider"]';
+
+/**
+ * Vendor-chrome counterpart of the shared controls' pointer focus release
+ * (`ControlsSurface.releasePointerFocus`), attached to the player shell of
+ * the preference-off Video.js player. Chromium focuses a clicked control, and
+ * a focused Video.js component captures the keyboard entirely:
+ * `Component.handleKeyDown` stops the propagation of every key and
+ * `ClickableComponent` turns Space and Enter into a click, so after a mouse
+ * click on the fullscreen button Space left fullscreen instead of pausing and
+ * `LegacyPlayerShortcuts` on the document never saw a key.
+ *
+ * The release is driven mainly by the focus landing, not the click: choosing
+ * a menu item moves focus to the menu button a tick after the click (Video.js
+ * `MenuItem.handleTapClick`), and the selection click never bubbles to this
+ * root, so a click handler alone would be both too early and unreached.
+ * A `focusin` on an eligible control is released when it is attributable to a
+ * recent pointer press inside the shell — a `pointerdown` within the window,
+ * not yet ended by a keydown anywhere — so keyboard `Tab` focus is preserved
+ * (the keydown listener is on the document because the key that follows a
+ * release is pressed while focus sits on `body`, outside the shell). A
+ * `click` runs the same release, because clicking a control that was already
+ * focused (Tab, then a mouse click on it) moves no focus and fires no
+ * `focusin`; a keyboard-activation click carries no `pointerdown`, so
+ * attribution keeps that focus.
+ *
+ * The release is scoped to the `.vjs-control-bar`: that persistent chrome is
+ * what hands keys back to the document, while the player's other focusable
+ * surfaces manage their own focus and must keep it. In particular the
+ * caption-settings dialog (`.vjs-text-track-settings`, a modal sibling of the
+ * control bar) traps focus for its Escape/Tab handling — blurring its Reset
+ * button would let keys leak to the document behind the open dialog. Menu
+ * buttons live in the control bar and are not exempt: a Video.js popup is
+ * navigated through its focused item, not its button, so releasing the button
+ * never breaks it. Opening a menu focuses the item (not eligible), and the
+ * button focus a pointer press moves through — the transient press on open,
+ * item selection, and toggling an open menu shut — is released, which is what
+ * lets Space work again after a menu is dismissed by clicking its button a
+ * second time. Returns the detach function.
+ */
+export function attachVjsPointerFocusRelease(root: HTMLElement): () => void {
+    const doc = root.ownerDocument;
+    let lastPointerDownAt: number | null = null;
+
+    // Only presses inside the shell count: a click elsewhere on the page must
+    // not attribute a later `Tab` into the controls.
+    const onPointerDown = () => {
+        lastPointerDownAt = Date.now();
+    };
+    // A key press ends pointer attribution: focus that moves after it was
+    // moved by the keyboard, whatever the last press hit (mirrors
+    // `ControlsSurface`). It is on the document because the key that follows
+    // a release is pressed while focus rests on `body`, outside the shell.
+    const onKeyDown = () => {
+        lastPointerDownAt = null;
+    };
+
+    const attributed = () =>
+        lastPointerDownAt !== null &&
+        Date.now() - lastPointerDownAt <= POINTER_ATTRIBUTION_WINDOW_MS;
+
+    // Passing the control bar (not the shell) as the root scopes the release
+    // to it, so focus inside a modal dialog is left alone.
+    const releaseControlBarFocus = () => {
+        const controlBar = root.querySelector(VJS_CONTROL_BAR_SELECTOR);
+        if (controlBar instanceof HTMLElement) {
+            blurFocusedControl(controlBar, { selector: VJS_RELEASE_SELECTOR });
+        }
+    };
+
+    // Focus that moves onto a control (a pointer focusing it, or a menu
+    // handing focus to its button) is the common path.
+    const onFocusIn = () => {
+        if (attributed()) {
+            releaseControlBarFocus();
+        }
+    };
+    // Clicking a control that was already focused (Tab, then a mouse click on
+    // the same control) moves no focus and fires no `focusin`, so the click
+    // is the only signal; a keyboard-activation click carries no preceding
+    // `pointerdown`, so `attributed()` keeps that focus.
+    const onClick = () => {
+        if (attributed()) {
+            releaseControlBarFocus();
+        }
+    };
+
+    root.addEventListener('pointerdown', onPointerDown, { capture: true });
+    doc.addEventListener('keydown', onKeyDown, { capture: true });
+    root.addEventListener('focusin', onFocusIn);
+    root.addEventListener('click', onClick);
+    return () => {
+        root.removeEventListener('pointerdown', onPointerDown, {
+            capture: true,
+        });
+        doc.removeEventListener('keydown', onKeyDown, { capture: true });
+        root.removeEventListener('focusin', onFocusIn);
+        root.removeEventListener('click', onClick);
+    };
+}
diff --git a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.spec.ts
index ae170ef4a..799ebdeb0 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.spec.ts
@@ -534,7 +534,7 @@ describe('WorkspaceContextPanelComponent', () => {
         );
     });
 
-    it('labels Stalker radio categories and keeps category selection in the radio layout', () => {
+    it('labels Stalker radio categories and keeps the playing station on a category click', () => {
         fixture.componentRef.setInput('context', {
             provider: 'stalker',
             playlistId: 'stalker-1',
@@ -558,10 +558,72 @@ describe('WorkspaceContextPanelComponent', () => {
 
         expect(stalkerStore.setSelectedCategory).toHaveBeenCalledWith('*');
         expect(stalkerStore.setPage).toHaveBeenCalledWith(0);
-        expect(stalkerStore.clearSelectedItem).toHaveBeenCalled();
+        // The radio layout renders its audio player only while the store has
+        // a selected item — clearing it here would silence the station.
+        expect(stalkerStore.clearSelectedItem).not.toHaveBeenCalled();
         expect(router.navigate).not.toHaveBeenCalled();
     });
 
+    it('preserves the playing Stalker ITV channel when switching live categories', () => {
+        // Regression: the click handler used to clearSelectedItem() for every
+        // Stalker section. The live layout gates its player on selectedItem,
+        // so a category switch in the sidebar stopped a channel the user never
+        // switched away from — unlike Xtream live (#936) and M3U groups.
+        fixture.componentRef.setInput('context', {
+            provider: 'stalker',
+            playlistId: 'stalker-1',
+        });
+        fixture.componentRef.setInput('section', 'itv');
+        stalkerStore.getCategoryResource.set([
+            { category_id: '*', category_name: 'All channels' },
+            { category_id: '7', category_name: 'Sports' },
+        ]);
+        fixture.detectChanges();
+
+        const categoryButtons = Array.from(
+            fixture.nativeElement.querySelectorAll('.category-item')
+        ) as HTMLButtonElement[];
+
+        categoryButtons[1]?.click();
+
+        expect(stalkerStore.setSelectedCategory).toHaveBeenCalledWith('7');
+        expect(stalkerStore.setPage).toHaveBeenCalledWith(0);
+        expect(stalkerStore.clearSelectedItem).not.toHaveBeenCalled();
+        expect(router.navigate).not.toHaveBeenCalled();
+    });
+
+    it('still closes the open Stalker detail when switching VOD categories', () => {
+        // VOD/series category clicks navigate to a list route, so the open
+        // detail must be dropped there — the live exemption is deliberate and
+        // narrow.
+        fixture.componentRef.setInput('context', {
+            provider: 'stalker',
+            playlistId: 'stalker-1',
+        });
+        fixture.componentRef.setInput('section', 'vod');
+        stalkerStore.getCategoryResource.set([
+            { category_id: '*', category_name: 'All movies' },
+            { category_id: '7', category_name: 'Action' },
+        ]);
+        fixture.detectChanges();
+
+        const categoryButtons = Array.from(
+            fixture.nativeElement.querySelectorAll('.category-item')
+        ) as HTMLButtonElement[];
+
+        categoryButtons[1]?.click();
+
+        expect(stalkerStore.setSelectedCategory).toHaveBeenCalledWith('7');
+        expect(stalkerStore.clearSelectedItem).toHaveBeenCalled();
+        expect(router.navigate).toHaveBeenCalledWith([
+            '/workspace',
+            'stalker',
+            'stalker-1',
+            'vod',
+            '7',
+        ]);
+    });
+
     describe('Stalker category error description', () => {
         afterEach(() => {
             stalkerStore.isCategoryResourceFailed.set(false as never);
diff --git a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.ts b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.ts
index 8f7c9acbd..1bd237fee 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-context-panel/workspace-context-panel.component.ts
@@ -458,12 +458,18 @@ export class WorkspaceContextPanelComponent {
         this.contextDrawer?.close();
         this.stalkerStore.setSelectedCategory(categoryId);
         this.stalkerStore.setPage(0);
-        this.stalkerStore.clearSelectedItem();
 
         if (section === 'itv' || section === 'radio') {
+            // Live TV / radio: the category only re-filters the channel
+            // sidebar, the selected channel keeps playing (Xtream parity,
+            // #936). The live layout gates its player on `selectedItem`, so
+            // clearing it here would tear the player down for a channel the
+            // user never switched away from.
             return;
         }
 
+        this.stalkerStore.clearSelectedItem();
+
         if (categoryId === '*') {
             this.router.navigate([
                 '/workspace',
diff --git a/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.spec.ts b/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.spec.ts
index 90792c34f..371c43616 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.spec.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.spec.ts
@@ -92,6 +92,93 @@ describe('WorkspaceKeyboardShortcutsService', () => {
         input.remove();
     });
 
+    describe('F11 window fullscreen toggle', () => {
+        const testWindow = window as unknown as {
+            electron?: Record<string, unknown>;
+        };
+        let toggleFullScreenWindow: jest.Mock;
+
+        function pressF11(
+            init: KeyboardEventInit = {},
+            target: EventTarget = document
+        ): KeyboardEvent {
+            const event = new KeyboardEvent('keydown', {
+                key: 'F11',
+                bubbles: true,
+                cancelable: true,
+                ...init,
+            });
+            target.dispatchEvent(event);
+            return event;
+        }
+
+        function setHtmlFullscreenElement(element: Element | null): void {
+            Object.defineProperty(document, 'fullscreenElement', {
+                configurable: true,
+                value: element,
+            });
+        }
+
+        beforeEach(() => {
+            toggleFullScreenWindow = jest.fn().mockResolvedValue({
+                isMaximized: false,
+                isFullScreen: true,
+            });
+            testWindow.electron = { toggleFullScreenWindow };
+            setHtmlFullscreenElement(null);
+        });
+
+        afterEach(() => {
+            delete testWindow.electron;
+            setHtmlFullscreenElement(null);
+        });
+
+        it('toggles window fullscreen through the bridge and swallows the key', () => {
+            const event = pressF11();
+
+            expect(toggleFullScreenWindow).toHaveBeenCalledTimes(1);
+            expect(event.defaultPrevented).toBe(true);
+            expect(dialog.open).not.toHaveBeenCalled();
+        });
+
+        it('works while typing in an input — it is the exit from a fullscreen launch', () => {
+            const input = document.createElement('input');
+            document.body.appendChild(input);
+
+            pressF11({}, input);
+
+            expect(toggleFullScreenWindow).toHaveBeenCalledTimes(1);
+            input.remove();
+        });
+
+        it('leaves the key alone while the player owns HTML fullscreen', () => {
+            setHtmlFullscreenElement(document.createElement('div'));
+
+            const event = pressF11();
+
+            expect(toggleFullScreenWindow).not.toHaveBeenCalled();
+            expect(event.defaultPrevented).toBe(false);
+        });
+
+        it('ignores modified and auto-repeated F11 presses', () => {
+            pressF11({ ctrlKey: true });
+            pressF11({ metaKey: true });
+            pressF11({ altKey: true });
+            pressF11({ shiftKey: true });
+            pressF11({ repeat: true });
+
+            expect(toggleFullScreenWindow).not.toHaveBeenCalled();
+        });
+
+        it('leaves F11 to the browser without a bridge', () => {
+            delete testWindow.electron;
+
+            const event = pressF11();
+
+            expect(event.defaultPrevented).toBe(false);
+        });
+    });
+
     it('does not open duplicate dialogs while one is active', () => {
         service.openShortcutsDialog();
         service.openShortcutsDialog();
diff --git a/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.ts b/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.ts
index 63f6f1f2c..31007a6df 100644
--- a/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.ts
+++ b/libs/workspace/shell/feature/src/lib/workspace-keyboard-shortcuts/workspace-keyboard-shortcuts.service.ts
@@ -78,6 +78,10 @@ export class WorkspaceKeyboardShortcutsService {
     }
 
     private handleKeydown(event: KeyboardEvent): void {
+        if (this.handleWindowFullscreenToggle(event)) {
+            return;
+        }
+
         if (
             isTypingInInput(event) ||
             !isKeyboardShortcutHelpTrigger(event) ||
@@ -90,6 +94,41 @@ export class WorkspaceKeyboardShortcutsService {
         this.openShortcutsDialog();
     }
 
+    /**
+     * F11 toggles OS-level window fullscreen in the desktop app. It is the
+     * way out of a fullscreen launch on Windows/Linux, where the title bar is
+     * hidden and the window controls hide themselves while fullscreen, so it
+     * is deliberately not gated by `isTypingInInput` — F11 is expected to
+     * work from any focus. While the player owns HTML-element fullscreen
+     * (`document.fullscreenElement`) its own F / Esc are in charge and F11
+     * must not yank OS fullscreen out from under it. Without a bridge (PWA)
+     * the browser keeps its own F11.
+     */
+    private handleWindowFullscreenToggle(event: KeyboardEvent): boolean {
+        if (
+            event.key !== 'F11' ||
+            event.repeat ||
+            event.ctrlKey ||
+            event.metaKey ||
+            event.altKey ||
+            event.shiftKey
+        ) {
+            return false;
+        }
+
+        const bridge = window.electron;
+        if (
+            typeof bridge?.toggleFullScreenWindow !== 'function' ||
+            document.fullscreenElement
+        ) {
+            return false;
+        }
+
+        event.preventDefault();
+        void bridge.toggleFullScreenWindow().catch(() => undefined);
+        return true;
+    }
+
     private getShortcutPlatform(): 'mac' | 'other' {
         if (typeof navigator === 'undefined') {
             return 'other';
diff --git a/tools/release/build-release-notes.mjs b/tools/release/build-release-notes.mjs
index 648a29bdb..521a5c6ff 100644
--- a/tools/release/build-release-notes.mjs
+++ b/tools/release/build-release-notes.mjs
@@ -26,9 +26,9 @@ import {
 } from './release-announcements.mjs';
 import { loadNotes } from './release-notes.mjs';
 import { manifestSlugs } from './screenshot-guards.mjs';
+import { renderBlogScaffold } from './release-notes-blog.mjs';
 import {
     releaseSlug,
-    renderBlogScaffold,
     renderChangelogSection,
     renderGithubBody,
     upsertChangelogSection,
@@ -347,6 +347,7 @@ function main() {
             const content = renderBlogScaffold(notes, {
                 version,
                 date: options.date,
+                previousVersion: options.previous ?? detectPreviousVersion(),
                 links,
             });
             const target = writeBlogScaffold(content, version, options.force);
diff --git a/tools/release/capture-app-driver.ts b/tools/release/capture-app-driver.ts
index 59fe2436f..0ac08fbe7 100644
--- a/tools/release/capture-app-driver.ts
+++ b/tools/release/capture-app-driver.ts
@@ -14,14 +14,39 @@ import {
     type Page,
 } from '@playwright/test';
 
-import { registerPlaylistId, requirePlaylistId } from './capture-navigation';
+import {
+    M3U_FIXTURE_TITLE,
+    STALKER_FIXTURE_MAC,
+    STALKER_FIXTURE_PORTAL_URL,
+    STALKER_FIXTURE_TITLE,
+    STALKER_MOCK_ORIGIN,
+    XTREAM_FIXTURE_CREDENTIALS,
+    XTREAM_FIXTURE_TITLE,
+    XTREAM_MOCK_ORIGIN,
+} from './capture-fixtures';
+import {
+    clickDialogOption,
+    openAddPlaylistDialog,
+    registerPlaylistId,
+    requirePlaylistId,
+} from './capture-navigation';
+import type { PlaylistProvider } from './capture-navigation';
 
-export const XTREAM_MOCK_ORIGIN = 'http://localhost:3211';
-export const XTREAM_FIXTURE_TITLE = 'Fictional Xtream Demo';
-export const M3U_FIXTURE_TITLE = 'release-demo';
+export {
+    M3U_FIXTURE_TITLE,
+    XTREAM_FIXTURE_TITLE,
+    XTREAM_MOCK_ORIGIN,
+} from './capture-fixtures';
 
 /** Synthetic categories that only the marketing fixture generator produces. */
 const MOCK_FIXTURE_CATEGORIES = ['Action & Mystery', 'Urban Drama'];
+/**
+ * Live categories of the Stalker mock's marketing-demo scenario, from
+ * `MARKETING_LIVE_CATEGORIES` in `@iptvnator/shared/marketing-fixtures`.
+ * Spelled out here because `pnpm release:screenshots` runs tsx without the
+ * base tsconfig, so workspace path aliases do not resolve in this file.
+ */
+const STALKER_MOCK_FIXTURE_CATEGORIES = ['Newsroom', 'Culture & Docs'];
 
 
 /* ------------------------------------------------------------------ */
@@ -104,6 +129,73 @@ export async function ensureXtreamMockServer(
     throw new Error(`xtream-mock-server did not become healthy at ${healthUrl}`);
 }
 
+export async function ensureStalkerMockServer(
+    workspaceRoot: string
+): Promise<ChildProcess | undefined> {
+    const healthUrl = `${STALKER_MOCK_ORIGIN}/health`;
+
+    if (await isHealthy(healthUrl)) {
+        await assertStalkerMockServerIdentity();
+        return undefined;
+    }
+
+    const child = spawn(
+        path.join(workspaceRoot, 'node_modules/.bin/tsx'),
+        ['--tsconfig', 'tsconfig.base.json', 'apps/stalker-mock-server/src/main.ts'],
+        {
+            cwd: workspaceRoot,
+            env: { ...process.env, NODE_ENV: 'development', PORT: '3210' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }
+    );
+
+    child.stderr?.on('data', (chunk) =>
+        process.stderr.write(`[stalker-mock] ${chunk}`)
+    );
+
+    const deadline = Date.now() + 20_000;
+
+    while (Date.now() < deadline) {
+        if (await isHealthy(healthUrl)) {
+            return child;
+        }
+        await sleep(500);
+    }
+
+    child.kill('SIGTERM');
+    throw new Error(`stalker-mock-server did not become healthy at ${healthUrl}`);
+}
+
+/**
+ * Same trust boundary as the Xtream check: whatever answers on the Stalker
+ * port must serve the marketing-demo scenario's fictional live categories.
+ */
+async function assertStalkerMockServerIdentity(): Promise<void> {
+    const response = await fetch(
+        `${STALKER_MOCK_ORIGIN}/portal.php?type=itv&action=get_genres&JsHttpRequest=1-xml`,
+        { headers: { Cookie: `mac=${STALKER_FIXTURE_MAC}; stb_lang=en; timezone=UTC` } }
+    ).catch(() => null);
+
+    if (!response?.ok) {
+        throw new Error(
+            `Something is listening on ${STALKER_MOCK_ORIGIN} but does not answer the Stalker portal API — stop it and let this script start the mock server itself.`
+        );
+    }
+
+    const payload = (await response.json().catch(() => null)) as
+        | { js?: { title?: string }[] }
+        | null;
+    const titles = new Set((payload?.js ?? []).map((entry) => entry.title));
+
+    for (const expected of STALKER_MOCK_FIXTURE_CATEGORIES) {
+        if (!titles.has(expected)) {
+            throw new Error(
+                `The server on ${STALKER_MOCK_ORIGIN} is not the IPTVnator marketing mock (missing live category "${expected}"). Refusing to capture screenshots from unknown data.`
+            );
+        }
+    }
+}
+
 /**
  * Confirms the service on the mock port is our fixture server: it must serve
  * the marketing catalog with the exact synthetic titles the shots rely on.
@@ -207,9 +299,21 @@ export async function waitForAppReady(page: Page): Promise<void> {
 /* Seeding                                                             */
 /* ------------------------------------------------------------------ */
 
-export async function seedDemoData(page: Page, m3uPath: string): Promise<void> {
+export interface SeedOptions {
+    /** Also add the Stalker marketing portal (guide shots only: it changes the dashboard). */
+    stalker?: boolean;
+}
+
+export async function seedDemoData(
+    page: Page,
+    m3uPath: string,
+    options: SeedOptions = {}
+): Promise<void> {
     await addXtreamPortal(page);
     await addM3uPlaylist(page, m3uPath);
+    if (options.stalker) {
+        await addStalkerPortal(page);
+    }
     await seedDashboardActivity(page);
 }
 
@@ -288,8 +392,8 @@ async function addXtreamPortal(page: Page): Promise<void> {
     await clickDialogOption(dialog, /xtream credentials/i);
     await dialog.locator('#title').fill(XTREAM_FIXTURE_TITLE);
     await dialog.locator('#serverUrl').fill(XTREAM_MOCK_ORIGIN);
-    await dialog.locator('#username').fill('marketing');
-    await dialog.locator('#password').fill('marketing');
+    await dialog.locator('#username').fill(XTREAM_FIXTURE_CREDENTIALS.username);
+    await dialog.locator('#password').fill(XTREAM_FIXTURE_CREDENTIALS.password);
     await dialog
         .getByRole('button', { name: /^(add|add playlist)$/i })
         .last()
@@ -305,6 +409,27 @@ async function addXtreamPortal(page: Page): Promise<void> {
         .waitFor({ state: 'visible', timeout: 45_000 });
 }
 
+async function addStalkerPortal(page: Page): Promise<void> {
+    await openAddPlaylistDialog(page);
+    const dialog = page.locator('mat-dialog-container').last();
+
+    await clickDialogOption(dialog, /stalker portal/i);
+    await dialog.locator('#title').fill(STALKER_FIXTURE_TITLE);
+    await dialog.locator('#portalUrl').fill(STALKER_FIXTURE_PORTAL_URL);
+    await dialog.locator('#macAddress').fill(STALKER_FIXTURE_MAC);
+    // Endpoint discovery probes the mock before the row is written.
+    await dialog.getByRole('button', { name: /^add$/i }).last().click();
+    await dialog.waitFor({ state: 'detached', timeout: 60_000 });
+    await page.waitForURL(/\/workspace\/stalker\/[^/]+\/vod/, {
+        timeout: 60_000,
+    });
+    registerPlaylistId('stalker', idFromUrl(page.url(), 'stalker'));
+    await page
+        .locator('.category-content-layout, app-content-card')
+        .first()
+        .waitFor({ state: 'visible', timeout: 45_000 });
+}
+
 async function addM3uPlaylist(page: Page, m3uPath: string): Promise<void> {
     await openAddPlaylistDialog(page);
     const dialog = page.locator('mat-dialog-container').last();
@@ -329,40 +454,15 @@ async function addM3uPlaylist(page: Page, m3uPath: string): Promise<void> {
         .waitFor({ state: 'visible', timeout: 60_000 });
 }
 
-async function openAddPlaylistDialog(page: Page): Promise<void> {
-    await page.getByRole('button', { name: /add playlist/i }).first().click();
-    await page
-        .locator('mat-dialog-container')
-        .last()
-        .waitFor({ state: 'visible', timeout: 15_000 });
-}
-
-async function clickDialogOption(
-    dialog: ReturnType<Page['locator']>,
-    label: RegExp
-): Promise<void> {
-    // The add-playlist dialog has changed shape across releases: source
-    // methods were tabs, then plain buttons, now a radio group.
-    for (const role of ['radio', 'tab', 'button'] as const) {
-        const option = dialog.getByRole(role, { name: label }).first();
-
-        if ((await option.count()) > 0) {
-            await option.click();
-            return;
-        }
-    }
-
-    throw new Error(`Dialog option matching ${label} not found`);
-}
-
-
-function idFromUrl(url: string, provider: 'playlists' | 'xtreams'): string {
+function idFromUrl(url: string, provider: PlaylistProvider): string {
     // `provider` is a closed union, but build the pattern from a literal
     // anyway so no future caller can inject regex syntax through it.
     const pattern =
         provider === 'playlists'
             ? /\/workspace\/playlists\/([^/]+)\//
-            : /\/workspace\/xtreams\/([^/]+)\//;
+            : provider === 'xtreams'
+              ? /\/workspace\/xtreams\/([^/]+)\//
+              : /\/workspace\/stalker\/([^/]+)\//;
     const match = url.match(pattern);
 
     if (!match) {
diff --git a/tools/release/capture-fixtures.ts b/tools/release/capture-fixtures.ts
new file mode 100644
index 000000000..817625a82
--- /dev/null
+++ b/tools/release/capture-fixtures.ts
@@ -0,0 +1,41 @@
+/**
+ * Fixture identities shared by the capture driver (seeding) and the named
+ * setup actions (guide shots that re-enter the add-playlist dialog). Kept in
+ * a leaf module so capture-navigation.ts can import them without pulling in
+ * the driver, which itself imports the navigation module.
+ *
+ * Everything here is fictional and resolves only against the local Xtream
+ * mock server; the G4 frame guard still rejects any URL carrying query
+ * credentials, so the auto-detect hand-out deliberately uses labeled lines
+ * instead of a `get.php?username=…` link.
+ */
+
+import { FICTIONAL_STALKER_MAC } from './screenshot-guards.mjs';
+
+export const XTREAM_MOCK_ORIGIN = 'http://localhost:3211';
+export const XTREAM_FIXTURE_TITLE = 'Fictional Xtream Demo';
+export const M3U_FIXTURE_TITLE = 'release-demo';
+
+export const STALKER_MOCK_ORIGIN = 'http://localhost:3210';
+export const STALKER_FIXTURE_TITLE = 'Fictional Stalker Demo';
+/** Reseller-panel shape most hand-outs use; discovery classifies the mock's answer itself. */
+export const STALKER_FIXTURE_PORTAL_URL = `${STALKER_MOCK_ORIGIN}/portal.php`;
+/** The mock's `marketing-demo` scenario; the only MAC the frame guard lets through. */
+export const STALKER_FIXTURE_MAC = FICTIONAL_STALKER_MAC;
+
+/** Credential pair of the mock server's curated `marketing` scenario. */
+export const XTREAM_FIXTURE_CREDENTIALS = {
+    username: 'marketing',
+    password: 'marketing',
+} as const;
+
+/** A fictional "your subscription is ready" message for the Auto-detect shot. */
+export const AUTO_DETECT_FIXTURE_MESSAGE = [
+    'Welcome to Fictional TV! Your account is ready.',
+    '',
+    `Host: ${XTREAM_MOCK_ORIGIN}`,
+    `Username: ${XTREAM_FIXTURE_CREDENTIALS.username}`,
+    `Password: ${XTREAM_FIXTURE_CREDENTIALS.password}`,
+    '',
+    'Use these details in any Xtream Codes compatible player.',
+].join('\n');
diff --git a/tools/release/capture-navigation.ts b/tools/release/capture-navigation.ts
index 9a8f033ed..d65a5ed07 100644
--- a/tools/release/capture-navigation.ts
+++ b/tools/release/capture-navigation.ts
@@ -6,28 +6,34 @@
 
 import type { Page } from '@playwright/test';
 
-let m3uPlaylistId: string | undefined;
-let xtreamPlaylistId: string | undefined;
+import {
+    AUTO_DETECT_FIXTURE_MESSAGE,
+    STALKER_FIXTURE_MAC,
+    STALKER_FIXTURE_PORTAL_URL,
+    STALKER_FIXTURE_TITLE,
+    XTREAM_FIXTURE_CREDENTIALS,
+    XTREAM_FIXTURE_TITLE,
+    XTREAM_MOCK_ORIGIN,
+} from './capture-fixtures';
+
+/** Route segment of each seeded source, as it appears in `/workspace/<provider>/<id>`. */
+export type PlaylistProvider = 'playlists' | 'xtreams' | 'stalker';
+
+const playlistIds = new Map<PlaylistProvider, string>();
 
 export function registerPlaylistId(
-    provider: 'playlists' | 'xtreams',
+    provider: PlaylistProvider,
     id: string
 ): void {
-    if (provider === 'playlists') {
-        m3uPlaylistId = id;
-    } else {
-        xtreamPlaylistId = id;
-    }
+    playlistIds.set(provider, id);
 }
 
-export function requirePlaylistId(
-    provider: 'playlists' | 'xtreams'
-): string {
+export function requirePlaylistId(provider: PlaylistProvider): string {
     return requireId(provider);
 }
 
-function requireId(provider: 'playlists' | 'xtreams'): string {
-    const id = provider === 'playlists' ? m3uPlaylistId : xtreamPlaylistId;
+function requireId(provider: PlaylistProvider): string {
+    const id = playlistIds.get(provider);
 
     if (!id) {
         throw new Error(`No captured ${provider} playlist id — seeding failed?`);
@@ -76,6 +82,11 @@ export async function runAction(
     action: string,
     param: string | null
 ): Promise<void> {
+    // Manifest steps are order-independent, and two of them end with a modal
+    // dialog open. Close whatever the previous step left behind before this
+    // one starts navigating, or the dialog backdrop swallows every click.
+    await dismissDialogs(page);
+
     switch (action) {
         case 'open-settings': {
             await page.locator('a[href$="/workspace/settings"]').first().click();
@@ -167,11 +178,179 @@ export async function runAction(
             await page.waitForTimeout(500);
             return;
         }
+        case 'open-add-playlist-xtream': {
+            await goHome(page);
+            await openAddPlaylistDialog(page);
+            const dialog = page.locator('mat-dialog-container').last();
+
+            await clickDialogOption(dialog, /xtream credentials/i);
+            await dialog.locator('#title').fill(XTREAM_FIXTURE_TITLE);
+            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.
+            await dialog
+                .getByRole('button', { name: /test connection/i })
+                .first()
+                .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();
+            await page.waitForTimeout(500);
+            return;
+        }
+        case 'open-add-playlist-auto': {
+            await goHome(page);
+            await openAddPlaylistDialog(page);
+            const dialog = page.locator('mat-dialog-container').last();
+
+            await clickDialogOption(dialog, /auto-detect/i);
+            await dialog
+                .locator('[data-test-id="auto-detect-textarea"]')
+                .fill(AUTO_DETECT_FIXTURE_MESSAGE);
+            const candidate = dialog
+                .locator('[data-test-id="auto-detect-candidate"]')
+                .first();
+            await candidate.waitFor({ state: 'visible', timeout: 15_000 });
+            await candidate.scrollIntoViewIfNeeded();
+            await page.waitForTimeout(500);
+            return;
+        }
+        case 'open-xtream-live': {
+            await goHome(page);
+            await clickHrefSuffix(
+                page,
+                `/workspace/xtreams/${requireId('xtreams')}/vod`
+            );
+            await clickHrefSuffix(
+                page,
+                `/workspace/xtreams/${requireId('xtreams')}/live`
+            );
+
+            const categories = page.locator(
+                'app-workspace-context-panel .category-item'
+            );
+            const category = param
+                ? categories.filter({ hasText: param }).first()
+                : categories.first();
+
+            await category.waitFor({ state: 'visible', timeout: 30_000 });
+            await category.click();
+            // Deliberately no channel click: playback would pull the mock's
+            // redirect to a public demo stream, and third-party video frames
+            // must never enter a published shot.
+            await page
+                .locator('app-channel-list-item')
+                .first()
+                .waitFor({ state: 'visible', timeout: 30_000 });
+            await page.waitForTimeout(700);
+            return;
+        }
+        case 'open-add-playlist-stalker': {
+            await goHome(page);
+            await openAddPlaylistDialog(page);
+            const dialog = page.locator('mat-dialog-container').last();
+
+            await clickDialogOption(dialog, /stalker portal/i);
+            await dialog.locator('#title').fill(STALKER_FIXTURE_TITLE);
+            await dialog.locator('#portalUrl').fill(STALKER_FIXTURE_PORTAL_URL);
+            await dialog.locator('#macAddress').fill(STALKER_FIXTURE_MAC);
+            // Blur runs the MAC normalization the guide describes.
+            await dialog.locator('#serialNumber').focus();
+            // The form is long; frame the identity fields and the derive
+            // toggle rather than the signature fields at the bottom.
+            await dialog.locator('.derive-device-ids').scrollIntoViewIfNeeded();
+            await page.waitForTimeout(500);
+            return;
+        }
+        case 'open-stalker-live': {
+            await goHome(page);
+            await clickHrefSuffix(
+                page,
+                `/workspace/stalker/${requireId('stalker')}/vod`
+            );
+            await clickHrefSuffix(
+                page,
+                `/workspace/stalker/${requireId('stalker')}/itv`
+            );
+
+            const categories = page.locator(
+                'app-workspace-context-panel .category-item'
+            );
+            const category = param
+                ? categories.filter({ hasText: param }).first()
+                : categories.first();
+
+            await category.waitFor({ state: 'visible', timeout: 30_000 });
+            await category.click();
+            // No channel click: playback would resolve a create_link to a
+            // public demo stream, and third-party video never enters a shot.
+            await page
+                .locator('app-channel-list-item')
+                .first()
+                .waitFor({ state: 'visible', timeout: 30_000 });
+            await page.waitForTimeout(700);
+            return;
+        }
         default:
             throw new Error(`Unknown setup action: ${action}`);
     }
 }
 
+/* ------------------------------------------------------------------ */
+/* Dialog helpers (shared with the seeding driver)                     */
+/* ------------------------------------------------------------------ */
+
+export async function openAddPlaylistDialog(page: Page): Promise<void> {
+    await page.getByRole('button', { name: /add playlist/i }).first().click();
+    await page
+        .locator('mat-dialog-container')
+        .last()
+        .waitFor({ state: 'visible', timeout: 15_000 });
+}
+
+export async function clickDialogOption(
+    dialog: ReturnType<Page['locator']>,
+    label: RegExp
+): Promise<void> {
+    // The add-playlist dialog has changed shape across releases: source
+    // methods were tabs, then plain buttons, now a radio group.
+    for (const role of ['radio', 'tab', 'button'] as const) {
+        const option = dialog.getByRole(role, { name: label }).first();
+
+        if ((await option.count()) > 0) {
+            await option.click();
+            return;
+        }
+    }
+
+    throw new Error(`Dialog option matching ${label} not found`);
+}
+
+async function dismissDialogs(page: Page): Promise<void> {
+    const dialogs = page.locator('mat-dialog-container');
+
+    if ((await dialogs.count()) === 0) {
+        return;
+    }
+
+    await page.keyboard.press('Escape');
+    await dialogs
+        .first()
+        .waitFor({ state: 'detached', timeout: 10_000 })
+        .catch(async () => {
+            await page.getByRole('button', { name: /^cancel$/i }).last().click();
+            await dialogs.first().waitFor({ state: 'detached', timeout: 10_000 });
+        });
+}
+
 /** Returns to the dashboard via the always-visible brand link. */
 async function goHome(page: Page): Promise<void> {
     if (/\/workspace\/dashboard/.test(page.url())) {
diff --git a/tools/release/capture-release-screenshots.ts b/tools/release/capture-release-screenshots.ts
index 83f7d6a6a..4a6b80c07 100644
--- a/tools/release/capture-release-screenshots.ts
+++ b/tools/release/capture-release-screenshots.ts
@@ -4,10 +4,14 @@
  *   pnpm release:screenshots                      # release slug from package.json
  *   pnpm release:screenshots --release v0-24      # explicit
  *   pnpm release:screenshots --only dashboard --theme dark
+ *   pnpm release:screenshots --group guides       # evergreen guide shots
  *
  * Reads tools/release/screenshots.manifest.json and writes
  * apps/website/public/blog/<release>/screenshots/<slug>-<theme>.png against
- * dist builds + the xtream mock server. Guards (screenshot-guards.mjs):
+ * dist builds + the xtream mock server. Shots carrying a `group` (for
+ * example `guides`) are skipped by a release run and land in
+ * apps/website/public/blog/<group>/screenshots/ when that group is selected.
+ * Guards (screenshot-guards.mjs):
  *
  *   G1  the real ~/.iptvnator/databases directory — including the SQLite WAL
  *       sidecars, compared after Electron exits and checkpoints — is proven
@@ -30,6 +34,7 @@ import process from 'node:process';
 import type { Page } from '@playwright/test';
 
 import {
+    DEFAULT_SHOT_GROUP,
     buildCaptureEnv,
     compareDatabaseStates,
     evaluateFrameReport,
@@ -37,8 +42,10 @@ import {
     HOST_RESOLVER_RULES,
     isAllowedRequestUrl,
     networkPolicy,
+    outputDirectoryFor,
     parseSetupStep,
     publishDirectory,
+    shotGroup,
     snapshotDatabaseState,
     stubbedResponseFor,
     validateManifest,
@@ -90,14 +97,26 @@ async function main(): Promise<void> {
         throw new Error(`--release rejected: ${releaseError}`);
     }
 
+    const group = flag('group') ?? DEFAULT_SHOT_GROUP;
+    const groupError = validateReleaseSlug(group);
+
+    if (groupError) {
+        throw new Error(`--group rejected: ${groupError}`);
+    }
+
     const only = flag('only');
     const themeFilter = flag('theme');
     const shots = manifest.shots.filter(
-        (shot: { slug: string }) => !only || shot.slug === only
+        (shot: { slug: string; group?: string }) =>
+            shotGroup(shot) === group && (!only || shot.slug === only)
     );
 
     if (shots.length === 0) {
-        throw new Error(`--only ${only} matches no manifest slug`);
+        throw new Error(
+            only
+                ? `--only ${only} matches no manifest slug in group ${group}`
+                : `--group ${group} matches no manifest shots`
+        );
     }
 
     // Without this an erased cast would accept `--theme --only`, and every
@@ -112,7 +131,7 @@ async function main(): Promise<void> {
         ? [themeFilter as Theme]
         : manifest.themes;
     const blogRoot = path.join(workspaceRoot, 'apps/website/public/blog');
-    const outputRoot = path.join(blogRoot, release, 'screenshots');
+    const outputRoot = outputDirectoryFor({ blogRoot, group, release });
 
     // Belt and braces: the slug is validated above, but assert the resolved
     // path really lands inside the blog tree before anything deletes there.
@@ -131,6 +150,16 @@ async function main(): Promise<void> {
     // release assets an earlier run already committed.
     const stagingDir = mkdtempSync(path.join(tmpdir(), 'iptvnator-shots-'));
     const mockServer = await driver.ensureXtreamMockServer(workspaceRoot);
+    // The Stalker portal is seeded only for shots that walk into it: it adds
+    // a third source card to the dashboard, which release shots must not show.
+    const needsStalker = shots.some((shot: { setup: string[] }) =>
+        shot.setup.some(
+            (step) => parseSetupStep(String(step)).action === 'open-stalker-live'
+        )
+    );
+    const stalkerMockServer = needsStalker
+        ? await driver.ensureStalkerMockServer(workspaceRoot)
+        : undefined;
     const dataDir = mkdtempSync(path.join(tmpdir(), 'iptvnator-release-shots-'));
     let app: Awaited<ReturnType<typeof driver.launchApp>> | undefined;
     let recordedRequests: string[] = [];
@@ -185,7 +214,9 @@ async function main(): Promise<void> {
         await driver.sizeWindow(app, manifest.viewport);
         await driver.waitForAppReady(page);
         await assertTmdbDisabled(page); // G5
-        await driver.seedDemoData(page, driver.writeM3uFixture(dataDir));
+        await driver.seedDemoData(page, driver.writeM3uFixture(dataDir), {
+            stalker: needsStalker,
+        });
 
         for (const theme of themes) {
             await applyTheme(page, theme);
@@ -241,6 +272,7 @@ async function main(): Promise<void> {
         // may sit in -wal until the worker shuts down and checkpoints.
         await app?.close().catch(() => undefined);
         mockServer?.kill('SIGTERM');
+        stalkerMockServer?.kill('SIGTERM');
         rmSync(dataDir, { recursive: true, force: true });
     }
 
diff --git a/tools/release/project.json b/tools/release/project.json
index 8c3518d36..28a2f2fc8 100644
--- a/tools/release/project.json
+++ b/tools/release/project.json
@@ -10,6 +10,7 @@
             "inputs": [
                 "{workspaceRoot}/tools/release/release-notes.mjs",
                 "{workspaceRoot}/tools/release/release-notes-render.mjs",
+                "{workspaceRoot}/tools/release/release-notes-blog.mjs",
                 "{workspaceRoot}/tools/release/release-announcements.mjs",
                 "{workspaceRoot}/tools/release/verify-draft-release.mjs",
                 "{workspaceRoot}/tools/release/highlight-cards.mjs",
diff --git a/tools/release/release-notes-blog.mjs b/tools/release/release-notes-blog.mjs
new file mode 100644
index 000000000..9e8c9f420
--- /dev/null
+++ b/tools/release/release-notes-blog.mjs
@@ -0,0 +1,397 @@
+/**
+ * Website blog scaffold for
+ * `apps/website/src/content/blog/<vX-Y>-release-notes.mdx`.
+ *
+ * The scaffold ships in the shape the published posts end up in, so a release
+ * starts from the form instead of from an inventory the editor has to
+ * rebuild (the v0.23 post went out as the raw type-grouped list and had to be
+ * restructured afterwards):
+ *
+ *   intro → ReleaseMeta → "What changed" table (one row per `highlight:`)
+ *   → one `##` section per highlight, first → breaking changes → themed
+ *   "improved" sections for the remaining features → Performance → every
+ *   remaining fix under a Spoiler, grouped by theme → Before-updating alert
+ *   → Thanks → Download cards.
+ *
+ * Deliberately incomplete: `draft: true`, TODO markers wherever a human has
+ * to write. The prose is editorial work, only the inventory is mechanical —
+ * including which fixes deserve promotion out of the spoiler.
+ */
+
+import { NOTE_TYPES, REPO_URL } from './release-notes.mjs';
+import {
+    escapeMdx,
+    formatLongDate,
+    formatReferences,
+    oneLine,
+    releaseSlug,
+    truncate,
+} from './release-notes-render.mjs';
+
+/**
+ * Reader-facing sections, in post order. `area` is the conventional-commit
+ * scope of the PR, which says nothing to a user ("matching",
+ * "window-controls", "electron-backend"), so notes are folded into these
+ * themes instead. An area not listed here lands in {@link BLOG_FALLBACK_THEME}
+ * rather than failing — the editor merges it where it belongs.
+ */
+export const BLOG_THEMES = [
+    { heading: 'Downloads and recordings', areas: ['downloads', 'recordings'] },
+    {
+        heading: 'Playback',
+        areas: ['playback', 'player', 'embedded-mpv', 'mpv', 'vlc', 'subtitles'],
+    },
+    {
+        heading: 'Movies, series and the dashboard',
+        areas: [
+            'portals',
+            'portal',
+            'vod',
+            'series',
+            'tmdb',
+            'dashboard',
+            'matching',
+            'favorites',
+            'recent',
+        ],
+    },
+    { heading: 'Xtream', areas: ['xtream'] },
+    { heading: 'Stalker portals', areas: ['stalker'] },
+    {
+        heading: 'Live TV, EPG and M3U',
+        areas: ['m3u', 'epg', 'live', 'radio', 'catchup', 'remote-control'],
+    },
+    { heading: 'Search', areas: ['search'] },
+    {
+        heading: 'Settings, import and the desktop app',
+        areas: [
+            'settings',
+            'playlist',
+            'playlists',
+            'import',
+            'backup',
+            'ui',
+            'components',
+            'workspace',
+            'i18n',
+            'electron',
+            'electron-backend',
+            'window-controls',
+            'updater',
+            'deps',
+            'packaging',
+            'database',
+        ],
+    },
+    { heading: 'Self-hosted web version', areas: ['pwa', 'web-backend', 'docker'] },
+];
+
+export const BLOG_FALLBACK_THEME = 'Other changes';
+
+const STATUS_PILL_BY_TYPE = {
+    breaking: 'breaking',
+    feature: 'new',
+    fix: 'fixed',
+    perf: 'improved',
+};
+
+const COMPONENT_IMPORTS = {
+    Alert: "import Alert from '../../components/blog/Alert.astro';",
+    BlogImageSlider:
+        "import BlogImageSlider from '../../components/blog/BlogImageSlider.astro';",
+    ChangeTable:
+        "import ChangeTable from '../../components/blog/ChangeTable.astro';",
+    LinkCards: "import LinkCards from '../../components/blog/LinkCards.astro';",
+    ReleaseMeta:
+        "import ReleaseMeta from '../../components/blog/ReleaseMeta.astro';",
+    Spoiler: "import Spoiler from '../../components/blog/Spoiler.astro';",
+    StatusPill:
+        "import StatusPill from '../../components/blog/StatusPill.astro';",
+};
+
+const SCREENSHOT_ALERT = [
+    '<Alert type="info" title="About the screenshots">',
+    "The screenshots and posters shown here come from the project's own mock servers with fictional catalog data. IPTVnator is a pure media player — it does not provide, host, bundle, or distribute any streams, playlists, or media content. You bring your own sources; the app just plays them.",
+    '</Alert>',
+].join('\n');
+
+/**
+ * Embedded in a single-quoted JS string inside MDX. Backslashes must be
+ * escaped before apostrophes, or a body ending in `\` produces an unterminated
+ * string and breaks the website build.
+ */
+function jsString(text) {
+    return text.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function themeHeadingOf(area) {
+    return (
+        BLOG_THEMES.find((theme) => theme.areas.includes(area))?.heading ??
+        BLOG_FALLBACK_THEME
+    );
+}
+
+/**
+ * @returns {{ heading: string, notes: object[] }[]} non-empty theme groups in
+ * {@link BLOG_THEMES} order, the fallback theme last
+ */
+export function groupNotesByTheme(notes) {
+    const headings = [
+        ...BLOG_THEMES.map((theme) => theme.heading),
+        BLOG_FALLBACK_THEME,
+    ];
+
+    return headings
+        .map((heading) => ({
+            heading,
+            notes: notes.filter((note) => themeHeadingOf(note.area) === heading),
+        }))
+        .filter((group) => group.notes.length > 0);
+}
+
+/** A note that carries a headline or a screenshot gets its own section. */
+function isFeatured(note) {
+    return Boolean(note.highlight || note.screenshot);
+}
+
+function statusPill(type) {
+    return `<StatusPill type="${STATUS_PILL_BY_TYPE[type]}" />`;
+}
+
+function bullet(note, links) {
+    return `- ${escapeMdx(oneLine(note.body))}${formatReferences(note, links)}`;
+}
+
+function renderSlider(note, slug) {
+    const alt = jsString(truncate(oneLine(note.body), 120));
+    const images = ['dark', 'light']
+        .map(
+            (theme) =>
+                `        {\n            src: '/iptvnator/blog/${slug}/screenshots/${note.screenshot}-${theme}.png',\n            alt: '${alt}',\n        },`
+        )
+        .join('\n');
+
+    return `<BlogImageSlider\n    images={[\n${images}\n    ]}\n/>`;
+}
+
+/**
+ * A `highlight:` headline is the editorial headline; a screenshot note
+ * without one still deserves its own section, but the heading is editorial
+ * work a note body cannot stand in for — leave a visible TODO instead of
+ * pretending otherwise.
+ */
+function renderFeaturedSection(note, { slug, links }) {
+    const blocks = [
+        note.highlight
+            ? `## ${escapeMdx(note.highlight)}`
+            : `## TODO headline (${note.area})`,
+        statusPill(note.type),
+        `${escapeMdx(oneLine(note.body))}${formatReferences(note, links)}`,
+    ];
+
+    if (note.screenshot) {
+        blocks.push(renderSlider(note, slug));
+    }
+
+    return blocks.join('\n\n');
+}
+
+function renderChangeTable(highlights) {
+    const rows = highlights
+        .map((note) =>
+            [
+                '        {',
+                `            area: '${jsString(themeHeadingOf(note.area))}',`,
+                `            change: '${jsString(oneLine(note.body))}',`,
+                "            impact: 'TODO — one short phrase',",
+                '        },',
+            ].join('\n')
+        )
+        .join('\n');
+
+    return `## What changed\n\n<ChangeTable\n    rows={[\n${rows}\n    ]}\n/>`;
+}
+
+/**
+ * @param {string} pill a `StatusPill` type — the published posts label every
+ * bullet section `improved` (its items are not the release's headline
+ * features, those have sections of their own) except breaking changes
+ */
+function renderBulletSection(heading, pill, notes, links) {
+    return [
+        `## ${heading}`,
+        `<StatusPill type="${pill}" />`,
+        notes.map((note) => bullet(note, links)).join('\n'),
+    ].join('\n\n');
+}
+
+function renderThemedSections(notes, links) {
+    return groupNotesByTheme(notes).map((group) =>
+        renderBulletSection(group.heading, 'improved', group.notes, links)
+    );
+}
+
+/**
+ * Fixes without a headline collapse under a Spoiler, grouped by theme. That
+ * is a default, not a verdict: the editor promotes the fixes worth a
+ * paragraph into the open sections above.
+ */
+function renderFixesSpoiler(fixes, links) {
+    const count = fixes.length;
+    const groups = groupNotesByTheme(fixes)
+        .map((group) =>
+            [
+                `**${group.heading}**`,
+                group.notes.map((note) => bullet(note, links)).join('\n'),
+            ].join('\n\n')
+        )
+        .join('\n\n');
+
+    return [
+        '## Everything else',
+        `That is the part worth reading in one sitting. The remaining ${count} ${count === 1 ? 'fix is' : 'fixes are'} below, one line each. {/* TODO: promote the fixes users will notice into the sections above. */}`,
+        `<Spoiler title="Show the remaining fixes">\n\n${groups}\n\n</Spoiler>`,
+    ].join('\n\n');
+}
+
+function renderLinkCards(version, previousVersion) {
+    const tag = `v${version}`;
+    const cards = [
+        {
+            label: `Download ${tag}`,
+            href: `${REPO_URL}/releases/tag/${tag}`,
+            hint: 'Official binaries for macOS, Windows and Linux.',
+            icon: 'download',
+        },
+        {
+            label: 'Full release notes',
+            href: `${REPO_URL}/releases/tag/${tag}`,
+            hint: 'Every entry in full, on GitHub.',
+            icon: 'github',
+        },
+    ];
+
+    if (previousVersion) {
+        cards.push({
+            label: 'Full Changelog',
+            href: `${REPO_URL}/compare/v${previousVersion}...${tag}`,
+            hint: `Every commit between v${previousVersion} and ${tag}.`,
+            icon: 'github',
+        });
+    }
+
+    cards.push({
+        label: 'All Releases',
+        href: `${REPO_URL}/releases`,
+        hint: 'Browse every IPTVnator release.',
+        icon: 'github',
+    });
+
+    const links = cards
+        .map((card) =>
+            [
+                '        {',
+                `            label: '${jsString(card.label)}',`,
+                `            href: '${card.href}',`,
+                `            hint: '${jsString(card.hint)}',`,
+                `            icon: '${card.icon}',`,
+                '        },',
+            ].join('\n')
+        )
+        .join('\n');
+
+    return `<LinkCards\n    links={[\n${links}\n    ]}\n/>`;
+}
+
+function renderClosing(version, previousVersion) {
+    return [
+        '<Alert type="warning" title="Before updating">\nPlease back up your playlists, credentials, URLs, and other important data before installing a new release. {/* TODO: say whether this release changes the database schema or carries breaking changes. */}\n</Alert>',
+        '## Thanks',
+        '{/* TODO: thank the testers, reporters, translators and sponsors behind this release. */}',
+        '## Download',
+        renderLinkCards(version, previousVersion),
+    ];
+}
+
+function renderFrontmatter(shortVersion, slug, date) {
+    return [
+        '---',
+        `title: ${shortVersion} - Release Notes`,
+        'description: TODO — one sentence naming the two or three headline changes.',
+        'featured: true',
+        `pubDate: ${date}`,
+        'author: 4gray',
+        `heroImage: /iptvnator/blog/${slug}/hero.jpg`,
+        'tags:',
+        '    - release',
+        '    - release-notes',
+        `    - ${shortVersion}`,
+        'draft: true',
+        '---',
+    ].join('\n');
+}
+
+/**
+ * @param {object[]} notes
+ * @param {{ version: string, date: string, previousVersion?: string | null, links?: Map<string, object> }} options
+ * @returns {string}
+ */
+export function renderBlogScaffold(
+    notes,
+    { version, date, previousVersion = null, links = new Map() }
+) {
+    const slug = releaseSlug(version);
+    const shortVersion = slug.replace('-', '.');
+    const publicNotes = notes.filter((note) => note.type !== 'internal');
+    const byType = (type) => publicNotes.filter((note) => note.type === type);
+
+    const featured = NOTE_TYPES.flatMap((type) => byType(type).filter(isFeatured));
+    const highlights = featured.filter((note) => note.highlight);
+    const rest = (type) => byType(type).filter((note) => !isFeatured(note));
+    const breaking = rest('breaking');
+    const features = rest('feature');
+    const fixes = rest('fix');
+    const perf = rest('perf');
+    const hasScreenshot = featured.some((note) => note.screenshot);
+
+    const used = new Set(['Alert', 'LinkCards', 'ReleaseMeta']);
+    if (publicNotes.length > 0) used.add('StatusPill');
+    if (highlights.length > 0) used.add('ChangeTable');
+    if (hasScreenshot) used.add('BlogImageSlider');
+    if (fixes.length > 0) used.add('Spoiler');
+
+    const imports = Object.keys(COMPONENT_IMPORTS)
+        .filter((name) => used.has(name))
+        .map((name) => COMPONENT_IMPORTS[name])
+        .join('\n');
+
+    const meta = [
+        '<ReleaseMeta',
+        `    version="v${version}"`,
+        `    releaseDate="${formatLongDate(date)}"`,
+        "    channels={['Desktop', 'PWA']}",
+        '/>',
+    ].join('\n');
+
+    const body = [
+        renderFrontmatter(shortVersion, slug, date),
+        imports,
+        '{/* TODO: narrative intro — what this release is about, not what it contains. */}',
+        meta,
+    ];
+
+    if (highlights.length > 0) body.push(renderChangeTable(highlights));
+    if (hasScreenshot) body.push(SCREENSHOT_ALERT);
+    body.push(...featured.map((note) => renderFeaturedSection(note, { slug, links })));
+    if (breaking.length > 0) {
+        body.push(renderBulletSection('Breaking changes', 'breaking', breaking, links));
+    }
+    body.push(...renderThemedSections(features, links));
+    if (perf.length > 0) {
+        body.push(renderBulletSection('Performance', 'improved', perf, links));
+    }
+    if (fixes.length > 0) body.push(renderFixesSpoiler(fixes, links));
+    body.push(...renderClosing(version, previousVersion), '');
+
+    return body.join('\n\n');
+}
diff --git a/tools/release/release-notes-render.mjs b/tools/release/release-notes-render.mjs
index f18fbc0e8..1eb8a6a7e 100644
--- a/tools/release/release-notes-render.mjs
+++ b/tools/release/release-notes-render.mjs
@@ -1,7 +1,7 @@
 /**
- * Renderers turning grouped `.changes/*.md` notes into the three release
- * surfaces: the GitHub release body, the CHANGELOG.md section, and the
- * website blog scaffold.
+ * Renderers turning grouped `.changes/*.md` notes into the GitHub release
+ * body and the CHANGELOG.md section, plus the text helpers shared with the
+ * website blog scaffold in `release-notes-blog.mjs`.
  */
 
 import { extractSection } from './extract-changelog-section.mjs';
@@ -48,12 +48,12 @@ export function releaseSlug(version) {
 }
 
 /** Collapses a note body to a single line for list entries. */
-function oneLine(body) {
+export function oneLine(body) {
     return body.replace(/\s+/g, ' ').trim();
 }
 
 /** Trims to a word boundary; used for image alt text, never for prose. */
-function truncate(text, max) {
+export function truncate(text, max) {
     if (text.length <= max) {
         return text;
     }
@@ -70,7 +70,7 @@ function truncate(text, max) {
  * break the website build. The closing counterparts are escaped too, so a
  * body like `<live>` renders as written instead of half-escaped.
  */
-function escapeMdx(text) {
+export function escapeMdx(text) {
     return text
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;')
@@ -83,7 +83,7 @@ function escapeMdx(text) {
  * @param {Map<string, { pr?: number, commit?: string }>} links
  * @returns {string} trailing `([#123](url), closes [#45](url))` or ''
  */
-function formatReferences(note, links) {
+export function formatReferences(note, links) {
     const parts = [];
     const link = links.get(note.sourcePath);
 
@@ -221,119 +221,3 @@ export function upsertChangelogSection(changelog, section, version, marker) {
     };
 }
 
-/**
- * Blog entries carrying a `screenshot:` slug or a `highlight:` headline become
- * their own subsection (with an image slider when a screenshot exists); the
- * rest stay bullets.
- */
-function renderBlogGroup(group, { slug, links }) {
-    const bullets = group.notes.filter(
-        (note) => !note.screenshot && !note.highlight
-    );
-    const featured = group.notes.filter(
-        (note) => note.screenshot || note.highlight
-    );
-    const blocks = [`## ${group.heading}`];
-
-    if (bullets.length > 0) {
-        blocks.push(
-            bullets
-                .map(
-                    (note) =>
-                        `- **${note.area}** — ${escapeMdx(oneLine(note.body))}${formatReferences(note, links)}`
-                )
-                .join('\n')
-        );
-    }
-
-    for (const note of featured) {
-        // A `highlight:` headline is the editorial headline; without one the
-        // heading is editorial work a note body cannot stand in for — leave a
-        // visible TODO instead of pretending otherwise; the whole scaffold
-        // ships as `draft: true` anyway.
-        blocks.push(
-            note.highlight
-                ? `### ${escapeMdx(note.highlight)}`
-                : `### TODO headline (${note.area})`
-        );
-        blocks.push(
-            `${escapeMdx(oneLine(note.body))}${formatReferences(note, links)}`
-        );
-
-        if (!note.screenshot) {
-            continue;
-        }
-
-        // Embedded in a single-quoted JS string inside MDX. Backslashes must
-        // be escaped before apostrophes, or a body ending in `\` produces an
-        // unterminated string and breaks the website build.
-        const alt = truncate(oneLine(note.body), 120)
-            .replace(/\\/g, '\\\\')
-            .replace(/'/g, "\\'");
-        const images = ['dark', 'light']
-            .map(
-                (theme) =>
-                    `        {\n            src: '/iptvnator/blog/${slug}/screenshots/${note.screenshot}-${theme}.png',\n            alt: '${alt}',\n        },`
-            )
-            .join('\n');
-
-        blocks.push(`<BlogImageSlider\n    images={[\n${images}\n    ]}\n/>`);
-    }
-
-    return blocks.join('\n\n');
-}
-
-/**
- * Scaffold for `apps/website/src/content/blog/v0-24-release-notes.mdx`.
- * Deliberately incomplete: `draft: true`, TODO markers for the narrative and
- * description. The prose is editorial work, only the inventory is mechanical.
- *
- * @param {object[]} notes
- * @param {{ version: string, date: string, links?: Map<string, object> }} options
- * @returns {string}
- */
-export function renderBlogScaffold(notes, { version, date, links = new Map() }) {
-    const slug = releaseSlug(version);
-    const shortVersion = slug.replace('-', '.');
-    const sections = groupNotes(notes)
-        .filter((group) => group.type !== 'internal')
-        .map((group) => renderBlogGroup(group, { slug, links }));
-
-    const frontmatter = [
-        '---',
-        `title: ${shortVersion} - Release Notes`,
-        'description: TODO — one sentence naming the two or three headline changes.',
-        'featured: true',
-        `pubDate: ${date}`,
-        'author: 4gray',
-        `heroImage: /iptvnator/blog/${slug}/hero.jpg`,
-        'tags:',
-        '    - release',
-        '    - release-notes',
-        `    - ${shortVersion}`,
-        'draft: true',
-        '---',
-    ].join('\n');
-
-    const imports = [
-        "import BlogImageSlider from '../../components/blog/BlogImageSlider.astro';",
-        "import ReleaseMeta from '../../components/blog/ReleaseMeta.astro';",
-    ].join('\n');
-
-    const meta = [
-        '<ReleaseMeta',
-        `    version="v${version}"`,
-        `    releaseDate="${formatLongDate(date)}"`,
-        "    channels={['Desktop', 'PWA']}",
-        '/>',
-    ].join('\n');
-
-    return [
-        frontmatter,
-        imports,
-        '{/* TODO: narrative intro — what this release is about, not what it contains. */}',
-        meta,
-        ...sections,
-        '',
-    ].join('\n\n');
-}
diff --git a/tools/release/release-notes.test.mjs b/tools/release/release-notes.test.mjs
index 61d30915c..86d17f8d8 100644
--- a/tools/release/release-notes.test.mjs
+++ b/tools/release/release-notes.test.mjs
@@ -10,10 +10,14 @@ import {
     parseNote,
     validateNote,
 } from './release-notes.mjs';
+import {
+    BLOG_FALLBACK_THEME,
+    groupNotesByTheme,
+    renderBlogScaffold,
+} from './release-notes-blog.mjs';
 import {
     formatLongDate,
     releaseSlug,
-    renderBlogScaffold,
     renderChangelogSection,
     renderGithubBody,
     upsertChangelogSection,
@@ -396,12 +400,34 @@ describe('renderChangelogSection', () => {
     });
 });
 
+describe('groupNotesByTheme', () => {
+    it('folds areas into reader-facing themes in post order, unknown areas last', () => {
+        const groups = groupNotesByTheme([
+            note({ area: 'quantum', body: 'Odd.' }),
+            note({ area: 'stalker', body: 'Stalker.' }),
+            note({ area: 'xtream', body: 'Xtream.' }),
+            note({ area: 'window-controls', body: 'Windows.' }),
+        ]);
+
+        assert.deepEqual(
+            groups.map((group) => group.heading),
+            [
+                'Xtream',
+                'Stalker portals',
+                'Settings, import and the desktop app',
+                BLOG_FALLBACK_THEME,
+            ]
+        );
+        assert.equal(groups.at(-1).notes[0].body, 'Odd.');
+    });
+});
+
 describe('renderBlogScaffold', () => {
+    const options = { version: '0.24.0', date: '2026-08-01' };
+    const spoilerOf = (content) => content.match(/<Spoiler[\s\S]*<\/Spoiler>/)?.[0] ?? '';
+
     it('emits a draft with TODO markers and a release meta block', () => {
-        const content = renderBlogScaffold([note()], {
-            version: '0.24.0',
-            date: '2026-08-01',
-        });
+        const content = renderBlogScaffold([note()], options);
 
         assert.match(content, /^---\ntitle: v0\.24 - Release Notes/);
         assert.match(content, /draft: true/);
@@ -409,13 +435,66 @@ describe('renderBlogScaffold', () => {
         assert.match(content, /releaseDate="August 1, 2026"/);
     });
 
-    it('gives screenshot notes their own section with a dark/light slider', () => {
+    it('opens with a What changed table holding one row per highlight', () => {
         const content = renderBlogScaffold(
-            [note({ screenshot: 'up-next-rail' })],
-            { version: '0.24.0', date: '2026-08-01' }
+            [
+                note({ highlight: 'Up Next rail' }),
+                note({
+                    area: 'stalker',
+                    highlight: 'Portal login',
+                    body: "Portals that ask for a login work; the app's do_auth step completes.",
+                    sourcePath: '.changes/stalker-login.md',
+                }),
+                note({ type: 'fix', body: 'A plain fix.', sourcePath: '.changes/playback-fix.md' }),
+            ],
+            options
         );
 
-        assert.match(content, /### TODO headline \(playback\)/);
+        assert.match(content, /## What changed\n\n<ChangeTable\n {4}rows=\{\[/);
+        assert.match(
+            content,
+            /area: 'Playback',\n\s+change: 'Series now show an Up Next rail beside the player\.',\n\s+impact: 'TODO/
+        );
+        // The theme is the default area label; apostrophes are JS-escaped.
+        assert.match(
+            content,
+            /area: 'Stalker portals',\n\s+change: 'Portals that ask for a login work; the app\\'s do_auth step completes\.'/
+        );
+        assert.equal((content.match(/^\s+change: /gm) ?? []).length, 2);
+        assert.match(content, /import ChangeTable from/);
+    });
+
+    it('omits the table and its import when nothing is highlighted', () => {
+        const content = renderBlogScaffold([note()], options);
+
+        assert.doesNotMatch(content, /## What changed/);
+        assert.doesNotMatch(content, /import ChangeTable/);
+    });
+
+    it('puts highlight sections first, as h2 with a status pill, ahead of the themed sections', () => {
+        const content = renderBlogScaffold(
+            [
+                note({ body: 'Plain feature.' }),
+                note({ highlight: 'Up Next rail', sourcePath: '.changes/playback-rail.md' }),
+            ],
+            options
+        );
+
+        assert.match(
+            content,
+            /## Up Next rail\n\n<StatusPill type="new" \/>\n\nSeries now show an Up Next rail/
+        );
+        assert.ok(content.indexOf('## Up Next rail') < content.indexOf('## Playback'));
+        assert.doesNotMatch(content, /^### /m);
+    });
+
+    it('gives screenshot notes their own section with a dark/light slider and the screenshot alert', () => {
+        const content = renderBlogScaffold(
+            [note({ screenshot: 'up-next-rail' })],
+            options
+        );
+
+        assert.match(content, /## TODO headline \(playback\)/);
         assert.match(
             content,
             /\/iptvnator\/blog\/v0-24\/screenshots\/up-next-rail-dark\.png/
@@ -424,34 +503,149 @@ describe('renderBlogScaffold', () => {
             content,
             /\/iptvnator\/blog\/v0-24\/screenshots\/up-next-rail-light\.png/
         );
-    });
-
-    it('uses the highlight as the section headline instead of a TODO', () => {
-        const content = renderBlogScaffold(
-            [note({ highlight: 'Up Next rail', screenshot: 'up-next-rail' })],
-            { version: '0.24.0', date: '2026-08-01' }
-        );
-
-        assert.match(content, /### Up Next rail/);
-        assert.doesNotMatch(content, /### TODO headline/);
+        assert.match(content, /<Alert type="info" title="About the screenshots">/);
+        assert.match(content, /import BlogImageSlider from/);
     });
 
     it('gives a highlight note without a screenshot its own section, no slider', () => {
         const content = renderBlogScaffold(
             [note({ highlight: 'Up Next rail' })],
-            { version: '0.24.0', date: '2026-08-01' }
+            options
         );
 
-        assert.match(content, /### Up Next rail/);
-        assert.doesNotMatch(content, /BlogImageSlider\n {4}images/);
+        assert.match(content, /## Up Next rail/);
         assert.doesNotMatch(content, /<BlogImageSlider/);
+        assert.doesNotMatch(content, /import BlogImageSlider/);
+        assert.doesNotMatch(content, /About the screenshots/);
+    });
+
+    it('folds the remaining features into themed sections without the area prefix', () => {
+        const content = renderBlogScaffold(
+            [
+                note({ area: 'stalker', body: 'Stalker thing.', sourcePath: '.changes/stalker-a.md' }),
+                note({ area: 'xtream', body: 'Xtream thing.', sourcePath: '.changes/xtream-a.md' }),
+                note({ area: 'quantum', body: 'Odd thing.', sourcePath: '.changes/quantum-a.md' }),
+            ],
+            options
+        );
+
+        assert.match(content, /## Xtream\n\n<StatusPill type="improved" \/>\n\n- Xtream thing\./);
+        assert.match(content, /## Stalker portals\n\n<StatusPill type="improved" \/>\n\n- Stalker thing\./);
+        assert.match(content, /## Other changes\n\n<StatusPill type="improved" \/>\n\n- Odd thing\./);
+        assert.doesNotMatch(content, /\*\*stalker\*\* —/);
+        assert.ok(content.indexOf('## Xtream') < content.indexOf('## Stalker portals'));
+        assert.ok(content.indexOf('## Stalker portals') < content.indexOf('## Other changes'));
+    });
+
+    it('collapses fixes without a headline under a spoiler grouped by theme', () => {
+        const content = renderBlogScaffold(
+            [
+                note({ type: 'fix', area: 'search', body: 'Search fix.', sourcePath: '.changes/search-a.md' }),
+                note({ type: 'fix', area: 'stalker', body: 'Stalker fix.', sourcePath: '.changes/stalker-b.md' }),
+                note({ type: 'fix', body: 'Player fix.', highlight: 'Big fix', sourcePath: '.changes/playback-b.md' }),
+            ],
+            options
+        );
+        const spoiler = spoilerOf(content);
+
+        assert.match(content, /## Everything else\n\nThat is the part worth reading in one sitting\. The remaining 2 fixes are below/);
+        assert.match(spoiler, /^<Spoiler title="Show the remaining fixes">\n\n\*\*Stalker portals\*\*\n\n- Stalker fix\./);
+        assert.match(spoiler, /\*\*Search\*\*\n\n- Search fix\./);
+        assert.match(spoiler, /\n\n<\/Spoiler>$/);
+        assert.match(content, /import Spoiler from/);
+        // A highlighted fix is a section of its own, never a spoiler line.
+        assert.match(content, /## Big fix\n\n<StatusPill type="fixed" \/>\n\nPlayer fix\./);
+        assert.doesNotMatch(spoiler, /Player fix/);
+    });
+
+    it('phrases a single remaining fix in the singular and skips the spoiler without fixes', () => {
+        const single = renderBlogScaffold([note({ type: 'fix' })], options);
+        const none = renderBlogScaffold([note()], options);
+
+        assert.match(single, /The remaining 1 fix is below/);
+        assert.doesNotMatch(none, /## Everything else/);
+        assert.doesNotMatch(none, /import Spoiler/);
+    });
+
+    it('keeps breaking changes out of the spoiler and ahead of the themed sections', () => {
+        const content = renderBlogScaffold(
+            [
+                note({ body: 'Feature.' }),
+                note({ type: 'breaking', area: 'settings', body: 'Breaking.', sourcePath: '.changes/settings-b.md' }),
+                note({ type: 'fix', area: 'settings', body: 'Fix.', sourcePath: '.changes/settings-f.md' }),
+            ],
+            options
+        );
+
+        assert.match(content, /## Breaking changes\n\n<StatusPill type="breaking" \/>\n\n- Breaking\./);
+        assert.ok(content.indexOf('## Breaking changes') < content.indexOf('## Playback'));
+        assert.doesNotMatch(spoilerOf(content), /Breaking\./);
+    });
+
+    it('renders performance notes in their own section after the themes', () => {
+        const content = renderBlogScaffold(
+            [note({ body: 'Feature.' }), note({ type: 'perf', body: 'Perf.', sourcePath: '.changes/playback-p.md' })],
+            options
+        );
+
+        assert.match(content, /## Performance\n\n<StatusPill type="improved" \/>\n\n- Perf\./);
+        assert.ok(content.indexOf('## Playback') < content.indexOf('## Performance'));
+    });
+
+    it('orders the post: table, highlights, breaking, themes, performance, spoiler, closing', () => {
+        const content = renderBlogScaffold(
+            [
+                note({ highlight: 'Headline', sourcePath: '.changes/a.md' }),
+                note({ type: 'breaking', body: 'Breaking.', sourcePath: '.changes/b.md' }),
+                note({ body: 'Feature.', sourcePath: '.changes/c.md' }),
+                note({ type: 'perf', body: 'Perf.', sourcePath: '.changes/d.md' }),
+                note({ type: 'fix', body: 'Fix.', sourcePath: '.changes/e.md' }),
+            ],
+            options
+        );
+        const order = [
+            '## What changed',
+            '## Headline',
+            '## Breaking changes',
+            '## Playback',
+            '## Performance',
+            '## Everything else',
+            'title="Before updating"',
+            '## Thanks',
+            '## Download',
+        ].map((marker) => content.indexOf(marker));
+
+        assert.ok(order.every((index) => index >= 0), `missing marker in ${order}`);
+        assert.deepEqual(order, [...order].sort((a, b) => a - b));
+    });
+
+    it('closes with the before-updating alert, thanks and download cards', () => {
+        const content = renderBlogScaffold([note()], options);
+
+        assert.match(content, /<Alert type="warning" title="Before updating">\nPlease back up/);
+        assert.match(content, /## Thanks\n\n\{\/\* TODO/);
+        assert.match(content, /## Download\n\n<LinkCards/);
+        assert.match(content, /label: 'Download v0\.24\.0',\n\s+href: 'https:\/\/github\.com\/4gray\/iptvnator\/releases\/tag\/v0\.24\.0'/);
+        assert.match(content, /label: 'All Releases'/);
+        assert.doesNotMatch(content, /Full Changelog/);
+    });
+
+    it('adds the compare card only when the previous version is known', () => {
+        const content = renderBlogScaffold([note()], {
+            ...options,
+            previousVersion: '0.23.0',
+        });
+
+        assert.match(content, /label: 'Full Changelog'/);
+        assert.match(content, /compare\/v0\.23\.0\.\.\.v0\.24\.0/);
+        assert.match(content, /hint: 'Every commit between v0\.23\.0 and v0\.24\.0\.'/);
     });
 
     it('truncates a long body for image alt text without cutting mid-word', () => {
         const body = `${'Series show the rest of the season beside the player '.repeat(4)}now.`;
         const content = renderBlogScaffold(
             [note({ body, screenshot: 'up-next-rail' })],
-            { version: '0.24.0', date: '2026-08-01' }
+            options
         );
         const alt = content.match(/alt: '([^']*)'/)[1];
 
@@ -468,7 +662,7 @@ describe('renderBlogScaffold', () => {
                     screenshot: 'windows-import',
                 }),
             ],
-            { version: '0.24.0', date: '2026-08-01' }
+            options
         );
         const alt = content.match(/alt: '(.*)',/)[1];
 
@@ -478,10 +672,24 @@ describe('renderBlogScaffold', () => {
         assert.doesNotMatch(alt, /(^|[^\\])(\\\\)*\\$/);
     });
 
+    it('escapes backslashes and apostrophes inside table cells', () => {
+        const content = renderBlogScaffold(
+            [
+                note({
+                    highlight: 'Windows import',
+                    body: "Windows paths like C:\\Users no longer break the app's import.",
+                }),
+            ],
+            options
+        );
+
+        assert.match(content, /change: 'Windows paths like C:\\\\Users no longer break the app\\'s import\.'/);
+    });
+
     it('escapes characters MDX would parse as markup', () => {
         const content = renderBlogScaffold(
             [note({ body: 'Channels named <live> and {vod} now sort correctly.' })],
-            { version: '0.24.0', date: '2026-08-01' }
+            options
         );
 
         assert.doesNotMatch(content, /<live>/);
@@ -490,14 +698,25 @@ describe('renderBlogScaffold', () => {
         assert.match(content, /&#123;vod&#125;/);
     });
 
-    it('imports only the components it emits', () => {
-        const content = renderBlogScaffold([note()], {
-            version: '0.24.0',
-            date: '2026-08-01',
-        });
+    it('imports only the components it emits, alphabetically', () => {
+        const content = renderBlogScaffold([note()], options);
+        const imports = content.match(/^import \w+ from/gm);
 
-        assert.match(content, /import ReleaseMeta from/);
-        assert.match(content, /import BlogImageSlider from/);
+        assert.deepEqual(imports, [
+            'import Alert from',
+            'import LinkCards from',
+            'import ReleaseMeta from',
+            'import StatusPill from',
+        ]);
+    });
+
+    it('omits internal notes entirely', () => {
+        const content = renderBlogScaffold(
+            [note(), note({ type: 'internal', body: 'Internal plumbing.', sourcePath: '.changes/deps-x.md' })],
+            options
+        );
+
+        assert.doesNotMatch(content, /Internal plumbing/);
     });
 });
 
diff --git a/tools/release/screenshot-guards.mjs b/tools/release/screenshot-guards.mjs
index ae29b4950..bbb9bdbc4 100644
--- a/tools/release/screenshot-guards.mjs
+++ b/tools/release/screenshot-guards.mjs
@@ -45,8 +45,37 @@ export const KNOWN_ACTIONS = [
     'open-xtream-vod',
     'open-xtream-series',
     'open-m3u-groups',
+    'open-add-playlist-xtream',
+    'open-add-playlist-auto',
+    'open-xtream-live',
+    'open-add-playlist-stalker',
+    'open-stalker-live',
 ];
 
+/**
+ * Shots without a `group` belong to the release post and land in
+ * `blog/<release>/screenshots/`. Any other group (for example `guides`) is
+ * captured only when asked for with `--group` and lands in its own
+ * `blog/<group>/screenshots/` directory, so a release run can never publish
+ * guide frames into a release folder or the other way round.
+ */
+export const DEFAULT_SHOT_GROUP = 'release';
+
+/** @param {{ group?: unknown }} shot */
+export function shotGroup(shot) {
+    return typeof shot?.group === 'string' ? shot.group : DEFAULT_SHOT_GROUP;
+}
+
+/**
+ * @param {{ blogRoot: string, group: string, release: string }} input
+ * @returns {string} the directory a run of `group` publishes into
+ */
+export function outputDirectoryFor({ blogRoot, group, release }) {
+    const folder = group === DEFAULT_SHOT_GROUP ? release : group;
+
+    return path.join(blogRoot, folder, 'screenshots');
+}
+
 /** @param {string} step e.g. `open-xtream-vod=Hero Premieres` */
 export function parseSetupStep(step) {
     const separator = step.indexOf('=');
@@ -104,6 +133,10 @@ export function validateManifest(manifest) {
 
         seen.add(shot?.slug);
 
+        if (shot?.group !== undefined && !SLUG_PATTERN.test(String(shot.group))) {
+            errors.push(`shot "${label}": group must be a lowercase slug`);
+        }
+
         if (!Array.isArray(shot?.setup) || shot.setup.length === 0) {
             errors.push(`shot "${label}": setup must be a non-empty array`);
             continue;
@@ -376,6 +409,15 @@ const CREDENTIAL_TEXT_PATTERNS = [
     /https?:\/\/(?!localhost|127\.0\.0\.1)[^\s"']+\.m3u8?\b/i,
 ];
 
+/**
+ * The one MAC address a published frame may show: the stalker-mock-server's
+ * `marketing-demo` scenario. It exists only in the mock's scenario table, so
+ * it identifies no real subscriber. Any other MAC-shaped text still fails the
+ * shot, which is what keeps the Stalker guide screenshots from ever carrying
+ * a real box identity.
+ */
+export const FICTIONAL_STALKER_MAC = '00:1A:79:00:00:07';
+
 /**
  * Evaluated against a DOM report collected right before each screenshot:
  * every image/background URL and the visible text. External resources or
@@ -393,8 +435,12 @@ export function evaluateFrameReport(report) {
         }
     }
 
+    const bodyText = report.bodyText
+        .split(FICTIONAL_STALKER_MAC)
+        .join('[fictional-mac]');
+
     for (const pattern of CREDENTIAL_TEXT_PATTERNS) {
-        const match = report.bodyText.match(pattern);
+        const match = bodyText.match(pattern);
 
         if (match) {
             violations.push(
diff --git a/tools/release/screenshot-guards.test.mjs b/tools/release/screenshot-guards.test.mjs
index 6b80f852c..de59fe697 100644
--- a/tools/release/screenshot-guards.test.mjs
+++ b/tools/release/screenshot-guards.test.mjs
@@ -25,6 +25,10 @@ import {
     parseSetupStep,
     snapshotDatabaseState,
     stubbedResponseFor,
+    DEFAULT_SHOT_GROUP,
+    FICTIONAL_STALKER_MAC,
+    outputDirectoryFor,
+    shotGroup,
     validateManifest,
     validateReleaseSlug,
 } from './screenshot-guards.mjs';
@@ -53,6 +57,25 @@ function validManifest() {
     };
 }
 
+describe('frame guard MAC allowlist', () => {
+    it('lets the fictional marketing-demo MAC through but no other MAC', () => {
+        const clean = evaluateFrameReport({
+            resourceUrls: [],
+            bodyText: `Mac Address ${FICTIONAL_STALKER_MAC} Serial Number`,
+        });
+        assert.deepEqual(clean, []);
+
+        const leaked = evaluateFrameReport({
+            resourceUrls: [],
+            bodyText: `Mac Address ${FICTIONAL_STALKER_MAC} and 00:1A:79:12:34:56`,
+        });
+        assert.ok(
+            leaked.some((violation) => /00:1A:79:12:34:56/.test(violation)),
+            'a second MAC must still fail the frame'
+        );
+    });
+});
+
 describe('manifest validation', () => {
     it('accepts the committed manifest shape', () => {
         assert.deepEqual(validateManifest(validManifest()), []);
@@ -103,6 +126,81 @@ describe('manifest validation', () => {
         );
     });
 
+    it('accepts guide shots that name a group and the actions they use', () => {
+        const manifest = validManifest();
+        manifest.shots.push(
+            {
+                slug: 'guide-xtream-add-playlist',
+                title: 'Add playlist',
+                group: 'guides',
+                setup: ['open-add-playlist-xtream'],
+            },
+            {
+                slug: 'guide-xtream-auto-detect',
+                title: 'Auto-detect',
+                group: 'guides',
+                setup: ['open-add-playlist-auto'],
+            },
+            {
+                slug: 'guide-xtream-live',
+                title: 'Live TV',
+                group: 'guides',
+                setup: ['open-xtream-live=News'],
+            }
+        );
+
+        assert.deepEqual(validateManifest(manifest), []);
+    });
+
+    it('rejects a group that is not a lowercase slug', () => {
+        const manifest = validManifest();
+        manifest.shots.push({
+            slug: 'guide',
+            title: 'x',
+            group: '../v0-24',
+            setup: ['open-dashboard'],
+        });
+
+        assert.ok(
+            validateManifest(manifest).some((error) =>
+                /group must be a lowercase slug/.test(error)
+            )
+        );
+    });
+
+    it('routes release shots by release and grouped shots by group', () => {
+        assert.equal(shotGroup({ slug: 'dashboard' }), DEFAULT_SHOT_GROUP);
+        assert.equal(shotGroup({ slug: 'guide', group: 'guides' }), 'guides');
+        assert.equal(
+            outputDirectoryFor({ blogRoot: '/blog', group: DEFAULT_SHOT_GROUP, release: 'v0-24' }),
+            path.join('/blog', 'v0-24', 'screenshots')
+        );
+        assert.equal(
+            outputDirectoryFor({ blogRoot: '/blog', group: 'guides', release: 'v0-24' }),
+            path.join('/blog', 'guides', 'screenshots')
+        );
+    });
+
+    it('accepts the Stalker guide actions', () => {
+        const manifest = validManifest();
+        manifest.shots.push(
+            {
+                slug: 'guide-stalker-add-playlist',
+                title: 'Stalker form',
+                group: 'guides',
+                setup: ['open-add-playlist-stalker'],
+            },
+            {
+                slug: 'guide-stalker-live',
+                title: 'Stalker live',
+                group: 'guides',
+                setup: ['open-stalker-live'],
+            }
+        );
+
+        assert.deepEqual(validateManifest(manifest), []);
+    });
+
     it('parses setup steps with and without a parameter', () => {
         assert.deepEqual(parseSetupStep('open-dashboard'), {
             action: 'open-dashboard',
diff --git a/tools/release/screenshots.manifest.json b/tools/release/screenshots.manifest.json
index 31cef378c..2b356c932 100644
--- a/tools/release/screenshots.manifest.json
+++ b/tools/release/screenshots.manifest.json
@@ -1,32 +1,88 @@
 {
     "version": 1,
-    "viewport": { "width": 1280, "height": 720 },
-    "themes": ["dark", "light"],
+    "viewport": {
+        "width": 1280,
+        "height": 720
+    },
+    "themes": [
+        "dark",
+        "light"
+    ],
     "shots": [
         {
             "slug": "dashboard",
             "title": "Dashboard",
-            "setup": ["open-dashboard"]
+            "setup": [
+                "open-dashboard"
+            ]
         },
         {
             "slug": "settings",
             "title": "Settings",
-            "setup": ["open-settings"]
+            "setup": [
+                "open-settings"
+            ]
         },
         {
             "slug": "xtream-vod-details",
             "title": "Movie details",
-            "setup": ["open-xtream-vod=Action & Mystery"]
+            "setup": [
+                "open-xtream-vod=Action & Mystery"
+            ]
         },
         {
             "slug": "xtream-series-season-open",
             "title": "Series season view",
-            "setup": ["open-xtream-series=Urban Drama"]
+            "setup": [
+                "open-xtream-series=Urban Drama"
+            ]
         },
         {
             "slug": "m3u-live-groups-two-column",
             "title": "Live TV groups",
-            "setup": ["open-m3u-groups"]
+            "setup": [
+                "open-m3u-groups"
+            ]
+        },
+        {
+            "slug": "guide-xtream-add-playlist",
+            "title": "Add playlist: Xtream credentials",
+            "group": "guides",
+            "setup": [
+                "open-add-playlist-xtream"
+            ]
+        },
+        {
+            "slug": "guide-xtream-auto-detect",
+            "title": "Add playlist: Auto-detect",
+            "group": "guides",
+            "setup": [
+                "open-add-playlist-auto"
+            ]
+        },
+        {
+            "slug": "guide-xtream-live",
+            "title": "Xtream Live TV",
+            "group": "guides",
+            "setup": [
+                "open-xtream-live"
+            ]
+        },
+        {
+            "slug": "guide-stalker-add-playlist",
+            "title": "Add playlist: Stalker portal",
+            "group": "guides",
+            "setup": [
+                "open-add-playlist-stalker"
+            ]
+        },
+        {
+            "slug": "guide-stalker-live",
+            "title": "Stalker Live TV",
+            "group": "guides",
+            "setup": [
+                "open-stalker-live"
+            ]
         }
     ]
 }
diff --git a/tools/testing/website-guides.test.mjs b/tools/testing/website-guides.test.mjs
new file mode 100644
index 000000000..668f98a65
--- /dev/null
+++ b/tools/testing/website-guides.test.mjs
@@ -0,0 +1,63 @@
+import { access, readFile } from 'node:fs/promises';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+/**
+ * Structural checks for guide posts: they must carry FAQPage structured data
+ * next to the BlogPosting entry, link to the download hub, and reference only
+ * screenshots that the build actually shipped.
+ */
+
+const distRoot = new URL('../../dist/apps/website/', import.meta.url);
+const SITE = 'https://4gray.github.io/iptvnator';
+
+const GUIDES = [
+  {
+    slug: 'xtream-codes-setup-guide',
+    screenshots: [
+      'blog/guides/screenshots/guide-xtream-add-playlist-dark.png',
+      'blog/guides/screenshots/guide-xtream-auto-detect-dark.png',
+      'blog/guides/screenshots/guide-xtream-live-dark.png',
+    ],
+  },
+  {
+    slug: 'stalker-portal-setup-guide',
+    screenshots: [
+      'blog/guides/screenshots/guide-stalker-add-playlist-dark.png',
+      'blog/guides/screenshots/guide-stalker-live-dark.png',
+    ],
+  },
+];
+
+const readDist = (relativePath) => readFile(new URL(relativePath, distRoot), 'utf8');
+
+function extractJsonLd(html) {
+  const blocks = [...html.matchAll(/<script type="application\/ld\+json">([\s\S]*?)<\/script>/g)];
+  assert.ok(blocks.length > 0, 'Expected at least one JSON-LD script block.');
+  return blocks.flatMap((match) => JSON.parse(match[1]));
+}
+
+for (const guide of GUIDES) {
+  test(`${guide.slug}: BlogPosting and FAQPage structured data`, async () => {
+    const html = await readDist(`blog/${guide.slug}/index.html`);
+    const schema = extractJsonLd(html);
+
+    assert.ok(schema.some((entry) => entry['@type'] === 'BlogPosting'), 'Expected a BlogPosting entry.');
+
+    const faq = schema.find((entry) => entry['@type'] === 'FAQPage');
+    assert.ok(faq, 'Expected a FAQPage entry.');
+    assert.ok(faq.mainEntity.length >= 5, 'Expected at least five FAQ questions.');
+    assert.match(html, /Frequently asked questions/);
+    assert.match(html, new RegExp(`<link rel="canonical" href="${SITE}/blog/${guide.slug}/"`));
+  });
+
+  test(`${guide.slug}: links to the download hub and ships its screenshots`, async () => {
+    const html = await readDist(`blog/${guide.slug}/index.html`);
+    assert.match(html, /href="\/iptvnator\/download\/"/);
+
+    for (const screenshot of guide.screenshots) {
+      assert.match(html, new RegExp(`src="/iptvnator/${screenshot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`));
+      await access(new URL(screenshot, distRoot));
+    }
+  });
+}