diff --git a/tools/devlab/README.md b/tools/devlab/README.md
index c6e29dfb..7ed77683 100644
--- a/tools/devlab/README.md
+++ b/tools/devlab/README.md
@@ -4,15 +4,18 @@
 rtp2httpd can proxy, so you can develop the web player against the scenarios it
 needs to support:
 
-| Scenario           | Delivery                  | rtp2httpd proxy | Codecs                              |
-| ------------------ | ------------------------- | --------------- | ----------------------------------- |
-| HLS-TS live        | HTTP `.m3u8` + `.ts`      | `/http`         | `h264-mp2`, `hevc-aac`              |
-| HLS-fMP4 live      | HTTP `.m3u8` + `.m4s`     | `/http`         | `h264-aac`, `hevc-aac`              |
-| HLS catchup        | HTTP HLS VOD (`playseek`) | `/http`         | all of the above                    |
-| mpegts (RTSP)      | RTSP TS live + catchup    | `/rtsp`         | `h264-mp2`, `hevc-aac`              |
-| mpegts (multicast) | RTP multicast live        | `/rtp`          | `h264-mp2`, `hevc-ac3`, `hevc-eac3` |
-| mpegts (scan)      | RTP multicast live        | `/rtp`          | 1080i / 1080p / 2160p (see below)   |
-| external file      | RTP multicast (looped)    | `/rtp`          | whatever the `.ts` file contains    |
+| Scenario                 | Delivery                          | rtp2httpd proxy | Codecs                              |
+| ------------------------ | --------------------------------- | --------------- | ----------------------------------- |
+| HLS-TS live              | HTTP `.m3u8` + `.ts`              | `/http`         | `h264-mp2`, `hevc-aac`              |
+| HLS-fMP4 live            | HTTP `.m3u8` + `.m4s`             | `/http`         | `h264-aac`, `hevc-aac`              |
+| HLS alternate audio      | HTTP master + split A/V playlists | `/http`         | AAC / MP2 / AC-3 (TS), AAC (fMP4)   |
+| HLS internal multi-audio | HTTP `.m3u8` + multi-PID `.ts`    | `/http`         | H.264 + AAC / MP2 / AC-3            |
+| HTTP internal multi-audio | continuous multi-PID MPEG-TS     | `/http`         | H.264 + AAC / MP2 / AC-3            |
+| HLS catchup              | HTTP HLS VOD (`playseek`)         | `/http`         | all of the above                    |
+| mpegts (RTSP)            | RTSP TS live + catchup            | `/rtsp`         | `h264-mp2`, `hevc-aac`              |
+| mpegts (multicast)       | RTP multicast live                | `/rtp`          | `h264-mp2`, `hevc-ac3`, `hevc-eac3` |
+| mpegts (scan)            | RTP multicast live                | `/rtp`          | 1080i / 1080p / 2160p (see below)   |
+| external file            | RTP multicast (looped)            | `/rtp`          | whatever the `.ts` file contains    |
 
 - `h264-mp2`  = H.264 video + MPEG-1/2 Layer II audio
 - `hevc-aac`  = H.265/HEVC video + AAC audio
@@ -23,6 +26,18 @@ HLS live is offered in both segment specs: **HLS-TS** (MPEG-TS `.ts` segments)
 and **HLS-fMP4** (an `init.mp4` referenced via `#EXT-X-MAP` + `.m4s` fragments).
 fMP4 carries AAC audio (MP2-in-MP4 is unsupported), so fMP4 channels use AAC.
 
+The two **alternate audio** channels use a video-only playlist plus English
+(440 Hz), Chinese (880 Hz), and Spanish (1320 Hz) renditions declared with
+`EXT-X-MEDIA`. The TS channel combines AAC, MP2, and AC-3; the fMP4 channel uses
+AAC for all three renditions. They exercise default-track selection, the player
+controls selector, audible track switching, codec changes, and per-channel
+selection persistence.
+
+The **internal multi-audio** channels carry those same three languages and
+tones as separate PIDs in one MPEG-TS program. One is segmented as HLS-TS and
+the other is a continuous HTTP TS response, covering both inputs accepted by
+the custom demux/transmux pipeline.
+
 **HLS catchup** is a real HLS VOD: each `playseek` window returns an
 `index.m3u8` (`#EXT-X-PLAYLIST-TYPE:VOD`) listing fixed-duration `.ts` slices.
 The playlist is produced instantly; each slice is encoded lazily on first
@@ -65,7 +80,7 @@ exact codecs/bitstream are relayed) — useful for reproducing a stream attached
 to a bug report:
 
 ```bash
-uv run python tools/devlab/devlab.py --ts-file /path/to/user-report.ts
+uv run tools/devlab/devlab.py --ts-file /path/to/user-report.ts
 # adds a "file <name>" channel proxied through rtp2httpd
 ```
 
@@ -80,7 +95,7 @@ UTC` — proving the time → picture mapping end to end.
 
 ```bash
 # 1. start the upstreams (writes /tmp/r2h-devlab.conf)
-uv run python tools/devlab/devlab.py
+uv run tools/devlab/devlab.py
 # The script prints the rtp2httpd command.
 
 # 2. in another shell, run rtp2httpd against the generated config
@@ -104,7 +119,7 @@ ffmpeg -hide_banner -filters | grep drawtext
 ```
 
 Defaults: HTTP origin `127.0.0.1:8881`, RTSP origin `127.0.0.1:8554`,
-rtp2httpd port `5140`. Run `uv run python tools/devlab/devlab.py --help` for
+rtp2httpd port `5140`. Run `uv run tools/devlab/devlab.py --help` for
 options.
 
 ## Verifying a scenario without the browser
diff --git a/tools/devlab/devlab.py b/tools/devlab/devlab.py
index df1b8930..6dbb926e 100644
--- a/tools/devlab/devlab.py
+++ b/tools/devlab/devlab.py
@@ -46,6 +46,7 @@
 import time
 from datetime import datetime, timezone
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import NamedTuple
 from urllib.parse import parse_qs, urlparse
 
 FONT: str | None = None
@@ -91,6 +92,35 @@
     ("HLS-fMP4 (hevc-aac)", "hevc-aac", "fmp4", "hevc-aac-fmp4"),
 )
 
+# Alternate-audio HLS masters: video-only rendition plus three independently
+# segmented audio renditions. The tones make track switching audible.
+# Tuple: (channel_label, seg_type, live_key).
+ALT_AUDIO_HLS_CHANNELS = (
+    ("HLS-TS alternate audio", "mpegts", "h264-aac-ts-alt-audio"),
+    ("HLS-fMP4 alternate audio", "fmp4", "h264-aac-fmp4-alt-audio"),
+)
+
+# One MPEG-TS program containing AAC, MP2 and AC-3 elementary audio streams.
+INTERNAL_AUDIO_HLS_CHANNELS = (("HLS-TS internal multi audio", "h264-internal-multi-audio"),)
+
+
+class AudioRendition(NamedTuple):
+    directory: str
+    name: str
+    hls_language: str
+    ts_language: str
+    tone: int
+    ts_profile: str
+    codec: str
+    bitrate: str
+
+
+AUDIO_RENDITIONS = (
+    AudioRendition("audio-en", "English", "en", "eng", 440, "h264-aac", "aac", "128k"),
+    AudioRendition("audio-zh", "中文", "zh", "zho", 880, "h264-mp2", "mp2", "192k"),
+    AudioRendition("audio-es", "Español", "es", "spa", 1320, "h264-ac3", "ac3", "192k"),
+)
+
 # ---------------------------------------------------------------------------
 # ffmpeg argument helpers
 # ---------------------------------------------------------------------------
@@ -243,6 +273,31 @@ def lavfi_inputs(size: str = "1280x720", rate: int = 25) -> list[str]:
     ]
 
 
+def multi_audio_media_args() -> list[str]:
+    """H.264 plus three distinctly pitched/language-tagged audio PIDs."""
+    args = [
+        "-f",
+        "lavfi",
+        "-i",
+        "testsrc2=size=1280x720:rate=25",
+    ]
+    for rendition in AUDIO_RENDITIONS:
+        args += ["-f", "lavfi", "-i", f"sine=frequency={rendition.tone}:sample_rate=48000"]
+    args += ["-map", "0:v"]
+    for index, rendition in enumerate(AUDIO_RENDITIONS):
+        args += [
+            "-map",
+            f"{index + 1}:a",
+            f"-metadata:s:a:{index}",
+            f"language={rendition.ts_language}",
+            f"-c:a:{index}",
+            rendition.codec,
+            f"-b:a:{index}",
+            rendition.bitrate,
+        ]
+    return [*args, "-vf", live_filter("h264 multi-audio"), *video_args("h264-aac"), "-ar:a", "48000", "-ac:a", "2"]
+
+
 # ---------------------------------------------------------------------------
 # Time parsing for playseek
 # ---------------------------------------------------------------------------
@@ -293,11 +348,21 @@ class LiveHLS:
     or ``fmp4`` (HLS-fMP4, an init.mp4 + .m4s fragments referenced via EXT-X-MAP).
     """
 
-    def __init__(self, ffmpeg: str, profile: str, outdir: str, seg_type: str = "mpegts"):
+    def __init__(
+        self,
+        ffmpeg: str,
+        profile: str,
+        outdir: str,
+        seg_type: str = "mpegts",
+        media: str = "muxed",
+        tone: int = 440,
+    ):
         self.ffmpeg = ffmpeg
         self.profile = profile
         self.outdir = outdir
         self.seg_type = seg_type
+        self.media = media
+        self.tone = tone
         self.log_path = os.path.join(outdir, "ffmpeg.log")
         self.proc: subprocess.Popen[bytes] | None = None
         self._stderr = None
@@ -330,20 +395,38 @@ def start(self) -> None:
                 "-hls_segment_filename",
                 os.path.join(self.outdir, "seg_%05d.ts"),
             ]
-        cmd = [
-            self.ffmpeg,
-            "-hide_banner",
-            "-loglevel",
-            "error",
-            "-re",
-            *lavfi_inputs(),
-            "-vf",
-            live_filter(self.profile),
-            *video_args(self.profile),
-            *audio_args(self.profile),
-            *hls_opts,
-            os.path.join(self.outdir, "index.m3u8"),
-        ]
+        common = [self.ffmpeg, "-hide_banner", "-loglevel", "error", "-re"]
+        if self.media == "video":
+            media_args = [
+                "-f",
+                "lavfi",
+                "-i",
+                "testsrc2=size=1280x720:rate=25",
+                "-vf",
+                live_filter(self.profile),
+                *video_args(self.profile),
+                "-an",
+            ]
+        elif self.media == "audio":
+            media_args = [
+                "-f",
+                "lavfi",
+                "-i",
+                f"sine=frequency={self.tone}:sample_rate=48000",
+                "-vn",
+                *audio_args(self.profile),
+            ]
+        elif self.media == "multi-audio":
+            media_args = multi_audio_media_args()
+        else:
+            media_args = [
+                *lavfi_inputs(),
+                "-vf",
+                live_filter(self.profile),
+                *video_args(self.profile),
+                *audio_args(self.profile),
+            ]
+        cmd = [*common, *media_args, *hls_opts, os.path.join(self.outdir, "index.m3u8")]
         self._stderr = open(self.log_path, "ab")
         self.proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=self._stderr)
 
@@ -362,7 +445,74 @@ def stop(self) -> None:
             self._stderr.close()
 
 
-def wait_for_live_hls(gens: list[LiveHLS], timeout: float) -> None:
+class AlternateAudioHLS:
+    """Builds a master playlist from one video-only and multiple audio-only HLS generators."""
+
+    def __init__(self, ffmpeg: str, outdir: str, seg_type: str):
+        self.profile = "h264-aac-alt-audio"
+        self.seg_type = seg_type
+        self.outdir = outdir
+        self.log_path = os.path.join(outdir, "ffmpeg.log")
+        self.proc: subprocess.Popen[bytes] | None = None
+        self.generators = [
+            LiveHLS(ffmpeg, "h264-aac", os.path.join(outdir, "video"), seg_type, media="video"),
+            *(
+                LiveHLS(
+                    ffmpeg,
+                    rendition.ts_profile if seg_type == "mpegts" else "h264-aac",
+                    os.path.join(outdir, rendition.directory),
+                    seg_type,
+                    media="audio",
+                    tone=rendition.tone,
+                )
+                for rendition in AUDIO_RENDITIONS
+            ),
+        ]
+
+    def start(self) -> None:
+        os.makedirs(self.outdir, exist_ok=True)
+        for generator in self.generators:
+            generator.start()
+
+    def ready(self) -> bool:
+        if not all(generator.ready() for generator in self.generators):
+            return False
+        master = os.path.join(self.outdir, "index.m3u8")
+        if not os.path.isfile(master):
+            audio_lines = [
+                '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",'
+                f'NAME="{rendition.name}",DEFAULT={"YES" if index == 0 else "NO"},'
+                f'AUTOSELECT=YES,LANGUAGE="{rendition.hls_language}",URI="{rendition.directory}/index.m3u8"'
+                for index, rendition in enumerate(AUDIO_RENDITIONS)
+            ]
+            content = "\n".join(
+                [
+                    "#EXTM3U",
+                    "#EXT-X-VERSION:3",
+                    *audio_lines,
+                    '#EXT-X-STREAM-INF:BANDWIDTH=2400000,CODECS="avc1.64001f,mp4a.40.2",'
+                    'RESOLUTION=1280x720,FRAME-RATE=25.000,AUDIO="audio"',
+                    "video/index.m3u8",
+                ]
+            )
+            with open(master, "w", encoding="utf-8") as fh:
+                fh.write(f"{content}\n")
+        return True
+
+    def failure_message(self) -> str:
+        failures = [
+            generator.failure_message()
+            for generator in self.generators
+            if generator.proc is not None and generator.proc.poll() is not None
+        ]
+        return "\n".join(failures) if failures else f"alternate-audio HLS generator failed; root: {self.outdir}"
+
+    def stop(self) -> None:
+        for generator in self.generators:
+            generator.stop()
+
+
+def wait_for_live_hls(gens: list[LiveHLS | AlternateAudioHLS], timeout: float) -> None:
     if timeout <= 0:
         return
 
@@ -474,9 +624,9 @@ def _serve_file(self, path: str) -> None:
                 self._send(200, ctype, fh.read())
 
         def _live(self, parts: list[str]) -> None:
-            # /live/<profile>/<file>
-            profile, fname = parts[1], parts[2]
-            self._serve_file(os.path.join(live_root, profile, fname))
+            # /live/<profile>/<path...>
+            profile = parts[1]
+            self._serve_file(os.path.join(live_root, profile, *parts[2:]))
 
         def _catchup_playlist(self, profile: str, qs: dict[str, list[str]]) -> None:
             playseek = (qs.get("playseek") or qs.get("tvdr") or [""])[0]
@@ -507,18 +657,53 @@ def _catchup_seg(self, profile: str, begin: int, idx: int) -> None:
                 if proc.poll() is None:
                     proc.terminate()
 
+        def _multi_ts(self) -> None:
+            self.send_response(200)
+            self.send_header("Content-Type", "video/mp2t")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            proc = subprocess.Popen(
+                [
+                    catchup.ffmpeg,
+                    "-hide_banner",
+                    "-loglevel",
+                    "error",
+                    "-re",
+                    *multi_audio_media_args(),
+                    "-f",
+                    "mpegts",
+                    "-",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+            )
+            assert proc.stdout is not None
+            try:
+                while True:
+                    chunk = proc.stdout.read(65536)
+                    if not chunk:
+                        break
+                    self.wfile.write(chunk)
+            except BrokenPipeError, ConnectionError:
+                pass
+            finally:
+                if proc.poll() is None:
+                    proc.terminate()
+
         def do_GET(self) -> None:  # noqa: N802 (http.server API)
             parsed = urlparse(self.path)
             qs = parse_qs(parsed.query)
             parts = [p for p in parsed.path.split("/") if p]
             try:
-                if len(parts) == 3 and parts[0] == "live":
+                if len(parts) >= 3 and parts[0] == "live":
                     self._live(parts)
                 elif len(parts) >= 2 and parts[0] == "catchup" and parts[-1] == "index.m3u8":
                     self._catchup_playlist(parts[1], qs)
                 elif len(parts) == 4 and parts[0] == "catchup-seg":
                     # /catchup-seg/<profile>/<begin>/<idx>.ts
                     self._catchup_seg(parts[1], int(parts[2]), int(parts[3].removesuffix(".ts")))
+                elif parts == ["multi-audio.ts"]:
+                    self._multi_ts()
                 else:
                     self._send(404, "text/plain", b"not found")
             except BrokenPipeError, ConnectionError:
@@ -791,6 +976,20 @@ def build_services_m3u(http_hostport: str, rtsp_hostport: str, mcast_channels: l
             f'#EXTINF:-1 group-title="HLS" catchup="default" catchup-source="{src}",{label}',
             f"http://{http_hostport}/live/{key}/index.m3u8",
         ]
+    for label, _seg_type, key in ALT_AUDIO_HLS_CHANNELS:
+        lines += [
+            f'#EXTINF:-1 group-title="HLS",{label}',
+            f"http://{http_hostport}/live/{key}/index.m3u8",
+        ]
+    for label, key in INTERNAL_AUDIO_HLS_CHANNELS:
+        lines += [
+            f'#EXTINF:-1 group-title="HLS",{label}',
+            f"http://{http_hostport}/live/{key}/index.m3u8",
+        ]
+    lines += [
+        '#EXTINF:-1 group-title="mpegts (HTTP)",HTTP TS internal multi audio',
+        f"http://{http_hostport}/multi-audio.ts",
+    ]
     for prof in RTSP_PROFILES:
         # mpegts-over-RTSP live + RTSP TS catchup window: covers mpegts 回看
         src = f"rtsp://{rtsp_hostport}/catchup/{prof}?{tpl}"
@@ -865,10 +1064,24 @@ def main() -> int:
 
     live_root = os.path.join(args.workdir, "live")
 
-    live = [
+    live: list[LiveHLS | AlternateAudioHLS] = [
         LiveHLS(args.ffmpeg, prof, os.path.join(live_root, key), seg_type)
         for _label, prof, seg_type, key in HLS_CHANNELS
     ]
+    live += [
+        AlternateAudioHLS(args.ffmpeg, os.path.join(live_root, key), seg_type)
+        for _label, seg_type, key in ALT_AUDIO_HLS_CHANNELS
+    ]
+    live += [
+        LiveHLS(
+            args.ffmpeg,
+            "h264-multi-audio",
+            os.path.join(live_root, key),
+            "mpegts",
+            media="multi-audio",
+        )
+        for _label, key in INTERNAL_AUDIO_HLS_CHANNELS
+    ]
     for gen in live:
         gen.start()
     try:
diff --git a/web-ui/src/components/player/player-controls.tsx b/web-ui/src/components/player/player-controls.tsx
index d9466bda..560a0908 100644
--- a/web-ui/src/components/player/player-controls.tsx
+++ b/web-ui/src/components/player/player-controls.tsx
@@ -17,7 +17,7 @@ import { memo, useCallback, useMemo, useRef, useState } from "react";
 import { usePlayerTranslation } from "../../hooks/use-player-translation";
 import type { Locale } from "../../lib/locale";
 import { createProgramTimeline, programProgressToWallClock } from "../../lib/program-timeline";
-import type { PlayerMediaInfo, PlayerRenderState } from "../../playback-engine";
+import type { PlayerAudioTrackState, PlayerMediaInfo, PlayerRenderState } from "../../playback-engine";
 import { isNearLiveWallClock, type LiveSessionAnchor, mseToWallClock } from "../../playback-engine/timeline/wall-clock";
 import type { Channel, EPGProgram } from "../../types/player";
 import { PLAYER_CONTROL_BUTTON_CLASS, PLAYER_OVERLAY_SURFACE_CLASS } from "./classnames";
@@ -40,6 +40,8 @@ interface PlayerControlsProps {
   locale: Locale;
   // Technical information for the currently visible player slot
   mediaInfo: PlayerMediaInfo | null;
+  audioTrackState: PlayerAudioTrackState;
+  onAudioTrackChange: (trackId: string) => void;
   renderState: PlayerRenderState;
   autoDeinterlace: boolean;
   // The absolute time of the last seek position (null for live mode)
@@ -383,6 +385,8 @@ function PlayerControlsComponent({
   onScrubbingChange,
   locale,
   mediaInfo,
+  audioTrackState,
+  onAudioTrackChange,
   renderState,
   autoDeinterlace,
   seekStartTime,
@@ -408,6 +412,9 @@ function PlayerControlsComponent({
   const isEffectivelyMuted = isMuted || volume <= 0;
   const isCatchupSupported = channel.sources.some((s) => s.catchup && s.catchupSource);
   const hasTimeline = isCatchupSupported || Boolean(currentProgram);
+  const selectedAudioTrack = audioTrackState.tracks.find(
+    (track) => track.id === (audioTrackState.pendingTrackId ?? audioTrackState.selectedTrackId),
+  );
 
   return (
     <div
@@ -575,6 +582,58 @@ function PlayerControlsComponent({
             </div>
           )}
 
+          {/* Audio Track Selector */}
+          {audioTrackState.tracks.length > 1 && (
+            <div className="group/audio relative flex items-center focus-within:z-10" tabIndex={-1}>
+              <button
+                type="button"
+                className={clsx(
+                  PLAYER_CONTROL_BUTTON_CLASS,
+                  "flex max-w-16 cursor-pointer items-center gap-1 truncate px-1.5 py-0.5 text-[11px] font-medium min-[420px]:max-w-24 md:max-w-40 md:px-2.5 md:py-1.5 md:text-sm",
+                )}
+                title={audioTrackState.pendingTrackId ? t("switchingAudioTrack") : t("audioTrack")}
+                aria-label={t("audioTrack")}
+                aria-busy={audioTrackState.pendingTrackId !== undefined}
+                onClick={(event) => event.currentTarget.focus()}
+              >
+                <span className="truncate">
+                  {selectedAudioTrack?.label || t("audioTrack")}
+                  {audioTrackState.pendingTrackId ? "…" : ""}
+                </span>
+              </button>
+              <div
+                className={clsx(
+                  PLAYER_OVERLAY_SURFACE_CLASS,
+                  "player-performance-motion invisible absolute bottom-full left-1/2 -translate-x-1/2 overflow-hidden rounded-xl py-1 opacity-0 transition-[opacity,visibility] duration-150 group-hover/audio:visible group-hover/audio:opacity-100 group-focus-within/audio:visible group-focus-within/audio:opacity-100",
+                )}
+              >
+                <PlayerSelectedGlassLayers />
+                {audioTrackState.tracks.map((track) => (
+                  <button
+                    type="button"
+                    key={track.id}
+                    onClick={(event) => {
+                      onAudioTrackChange(track.id);
+                      event.currentTarget.blur();
+                    }}
+                    aria-pressed={track.id === audioTrackState.selectedTrackId}
+                    className={clsx(
+                      "player-performance-motion relative z-10 block w-full cursor-pointer whitespace-nowrap px-3 py-1.5 text-left text-xs transition-colors md:text-sm",
+                      track.id === (audioTrackState.pendingTrackId ?? audioTrackState.selectedTrackId)
+                        ? "bg-blue-300/10 font-medium text-blue-200"
+                        : "text-white/75 hover:bg-blue-200/10 hover:text-blue-50",
+                    )}
+                  >
+                    <span className="flex items-center justify-between gap-4">
+                      <span>{track.label}</span>
+                      {track.language && <span className="text-blue-50/45">{track.language}</span>}
+                    </span>
+                  </button>
+                ))}
+              </div>
+            </div>
+          )}
+
           {/* Fullscreen */}
           <button
             type="button"
diff --git a/web-ui/src/components/player/video-player.tsx b/web-ui/src/components/player/video-player.tsx
index 7c753e9e..5a0aee59 100644
--- a/web-ui/src/components/player/video-player.tsx
+++ b/web-ui/src/components/player/video-player.tsx
@@ -22,7 +22,14 @@ import {
 } from "../../lib/document-picture-in-picture";
 import type { Locale } from "../../lib/locale";
 import { buildCatchupSegments } from "../../lib/m3u-parser";
-import { getMuted, getVolume, saveMuted, saveVolume } from "../../lib/player-storage";
+import {
+  getLastAudioTrackKey,
+  getMuted,
+  getVolume,
+  saveLastAudioTrackKey,
+  saveMuted,
+  saveVolume,
+} from "../../lib/player-storage";
 import { createProgramTimeline, programPositionToWallClock } from "../../lib/program-timeline";
 import {
   createPlaybackBackend,
@@ -30,6 +37,7 @@ import {
   getPlaybackBackendKind,
   isMSEPlaybackSupported,
   type PlaybackBackend,
+  type PlayerAudioTrackState,
   type PlayerError,
   PlayerErrors,
   type PlayerMediaInfo,
@@ -88,6 +96,7 @@ interface PlaybackErrorDisplay {
 
 const MAX_RETRIES = 3;
 const INACTIVE_RENDER_STATE: PlayerRenderState = { active: false, deinterlacing: false };
+const EMPTY_AUDIO_TRACK_STATE: PlayerAudioTrackState = { tracks: [] };
 
 type SlotId = "a" | "b";
 
@@ -304,6 +313,15 @@ function VideoPlayerComponent({
     a: null,
     b: null,
   });
+  const [slotAudioTrackStates, setSlotAudioTrackStates] = useState<Record<SlotId, PlayerAudioTrackState>>({
+    a: EMPTY_AUDIO_TRACK_STATE,
+    b: EMPTY_AUDIO_TRACK_STATE,
+  });
+  const pendingAudioPreferenceRef = useRef<{
+    channelId: string;
+    trackId: string;
+    preferenceKey: string;
+  } | null>(null);
   const transitionGenRef = useRef(0);
   const pendingTransitionRef = useRef<PendingTransition | null>(null);
   const hasStartedPlaybackRef = useRef(false);
@@ -806,10 +824,10 @@ function VideoPlayerComponent({
   });
 
   const handlePlayerError = useEffectEvent((playerError: PlayerError, slotId: SlotId) => {
-    if (playerError.detail === PlayerErrors.CODEC_UNSUPPORTED && playerError.track === "audio") {
+    if (playerError.track === "audio") {
       console.error("Player audio warning:", playerError);
       setWarning({
-        message: t("audioCodecError"),
+        message: playerError.detail === PlayerErrors.CODEC_UNSUPPORTED ? t("audioCodecError") : t("audioTrackError"),
         description: formatTechnicalPlayerError(playerError),
       });
       return;
@@ -899,6 +917,18 @@ function VideoPlayerComponent({
         setSlotMediaInfo((previousMediaInfo) => ({ ...previousMediaInfo, [slotId]: mediaInfo }));
       }
     });
+    p.on("audio-tracks-change", (state) => {
+      if (slotPlayerRef(slotId).current === p) {
+        setSlotAudioTrackStates((previous) => ({ ...previous, [slotId]: state }));
+        const pendingPreference = pendingAudioPreferenceRef.current;
+        if (!state.pendingTrackId && pendingPreference) {
+          if (state.selectedTrackId === pendingPreference.trackId) {
+            saveLastAudioTrackKey(pendingPreference.channelId, pendingPreference.preferenceKey);
+          }
+          pendingAudioPreferenceRef.current = null;
+        }
+      }
+    });
     p.on("time-update", (time) => {
       if (slotPlayerRef(slotId).current !== p || slotId !== getActiveSlotId()) return;
       currentVideoTimeRef.current = time;
@@ -955,10 +985,19 @@ function VideoPlayerComponent({
     },
   );
 
+  const loadSegmentsIntoSlot = useEffectEvent(
+    (player: PlaybackBackend, slotId: SlotId, newSegments: PlayerSegment[]) => {
+      setSlotMediaInfo((previous) => ({ ...previous, [slotId]: null }));
+      setSlotAudioTrackStates((previous) => ({ ...previous, [slotId]: EMPTY_AUDIO_TRACK_STATE }));
+      player.loadSegments(newSegments, {
+        preferredAudioTrackKey: channel ? getLastAudioTrackKey(channel.id) : undefined,
+      });
+    },
+  );
+
   const loadActiveSlotSegments = useEffectEvent(
     (player: PlaybackBackend, slotId: SlotId, newSegments: PlayerSegment[]) => {
-      setSlotMediaInfo((previousMediaInfo) => ({ ...previousMediaInfo, [slotId]: null }));
-      player.loadSegments(newSegments);
+      loadSegmentsIntoSlot(player, slotId, newSegments);
 
       if (shouldAutoPlayRef.current) {
         playVideoWithAutoplayFallback();
@@ -968,6 +1007,15 @@ function VideoPlayerComponent({
     },
   );
 
+  const handleAudioTrackChange = useEffectEvent((trackId: string) => {
+    const state = slotAudioTrackStates[getActiveSlotId()];
+    const track = state.tracks.find((candidate) => candidate.id === trackId);
+    const activePlayer = getActivePlayer();
+    if (!track || !channel || !activePlayer || trackId === state.selectedTrackId) return;
+    pendingAudioPreferenceRef.current = { channelId: channel.id, trackId, preferenceKey: track.preferenceKey };
+    activePlayer.selectAudioTrack(trackId);
+  });
+
   const updateMediaSessionPosition = useEffectEvent((force = false) => {
     if (!("mediaSession" in navigator) || !navigator.mediaSession.setPositionState) return;
 
@@ -1147,8 +1195,7 @@ function VideoPlayerComponent({
     // The pending slot's player resets its interlace verdict on loadSegments and
     // starts detecting while hidden, so an interlaced verdict can be ready the
     // moment the switch completes (no combing flash on channel change)
-    setSlotMediaInfo((previousMediaInfo) => ({ ...previousMediaInfo, [pendingId]: null }));
-    pendingPlayer.loadSegments(newSegments);
+    loadSegmentsIntoSlot(pendingPlayer, pendingId, newSegments);
 
     if (shouldAutoPlayRef.current) {
       playVideoWithAutoplayFallback(pendingId, pendingTransition);
@@ -1964,6 +2011,8 @@ function VideoPlayerComponent({
             onScrubbingChange={handleScrubbingChange}
             locale={locale}
             mediaInfo={slotMediaInfo[visibleSlotId]}
+            audioTrackState={slotAudioTrackStates[visibleSlotId]}
+            onAudioTrackChange={handleAudioTrackChange}
             renderState={slotRenderStates[visibleSlotId]}
             autoDeinterlace={autoDeinterlace}
             seekStartTime={streamStartTime}
diff --git a/web-ui/src/i18n/player.ts b/web-ui/src/i18n/player.ts
index 22aee271..6d066b9c 100644
--- a/web-ui/src/i18n/player.ts
+++ b/web-ui/src/i18n/player.ts
@@ -55,6 +55,7 @@ const base: TranslationDict = {
   noRewindSupport: "This channel does not support rewind",
   codecError: "Unsupported video/audio codec. Your browser cannot decode this stream.",
   audioCodecError: "This browser does not support the audio codec. Video will continue without sound.",
+  audioTrackError: "The selected audio track could not be loaded. Video and the previous track will continue.",
   dismiss: "Dismiss",
   mseNotSupported: "Your browser does not support MSE (Media Source Extensions)",
   failedToPlay: "Failed to play",
@@ -87,6 +88,8 @@ const base: TranslationDict = {
   fullscreen: "Fullscreen",
   exitFullscreen: "Exit Fullscreen",
   pictureInPicture: "Picture in Picture",
+  audioTrack: "Audio track",
+  switchingAudioTrack: "Switching audio track",
   mediaInfoLabel: "Media information",
   mediaInfoVideoCodec: "Video codec",
   mediaInfoResolution: "Resolution",
@@ -182,6 +185,7 @@ const zhHans: TranslationDict = {
   noRewindSupport: "此频道不支持时移功能",
   codecError: "不支持的视频/音频编码。您的浏览器无法解码此流。",
   audioCodecError: "浏览器不支持此音频编码，视频将继续无声播放。",
+  audioTrackError: "无法加载所选音轨，视频和原音轨将继续播放。",
   dismiss: "关闭",
   mseNotSupported: "您的浏览器不支持 MSE (媒体源扩展)",
   failedToPlay: "播放失败",
@@ -213,6 +217,8 @@ const zhHans: TranslationDict = {
   fullscreen: "全屏",
   exitFullscreen: "退出全屏",
   pictureInPicture: "画中画",
+  audioTrack: "音轨",
+  switchingAudioTrack: "正在切换音轨",
   mediaInfoLabel: "媒体信息",
   mediaInfoVideoCodec: "视频编码",
   mediaInfoResolution: "分辨率",
@@ -309,6 +315,7 @@ const zhHant: TranslationDict = {
   noRewindSupport: "此頻道不支援時移功能",
   codecError: "不支援的視頻/音頻編碼。您的瀏覽器無法解碼此串流。",
   audioCodecError: "瀏覽器不支援此音頻編碼，視頻將繼續無聲播放。",
+  audioTrackError: "無法載入所選音軌，影片和原音軌將繼續播放。",
   dismiss: "關閉",
   mseNotSupported: "您的瀏覽器不支援 MSE (媒體來源擴展)",
   failedToPlay: "播放失敗",
@@ -340,6 +347,8 @@ const zhHant: TranslationDict = {
   fullscreen: "全屏",
   exitFullscreen: "退出全屏",
   pictureInPicture: "畫中畫",
+  audioTrack: "音軌",
+  switchingAudioTrack: "正在切換音軌",
   mediaInfoLabel: "媒體資訊",
   mediaInfoVideoCodec: "視訊編碼",
   mediaInfoResolution: "解像度",
diff --git a/web-ui/src/lib/player-storage.ts b/web-ui/src/lib/player-storage.ts
index 0483bd7e..2ecaf754 100644
--- a/web-ui/src/lib/player-storage.ts
+++ b/web-ui/src/lib/player-storage.ts
@@ -76,3 +76,13 @@ export function saveLastSourceIndex(channelId: string, sourceIndex: number): voi
   }
   saveSourceIndexMap(map);
 }
+
+const [getAudioTrackMap, saveAudioTrackMap] = createStore<Record<string, string>>("rtp2httpd-player-audio-track", {});
+
+export function getLastAudioTrackKey(channelId: string): string | undefined {
+  return getAudioTrackMap()[channelId];
+}
+
+export function saveLastAudioTrackKey(channelId: string, preferenceKey: string): void {
+  saveAudioTrackMap({ ...getAudioTrackMap(), [channelId]: preferenceKey });
+}
diff --git a/web-ui/src/playback-engine/audio/pcm-audio-player.ts b/web-ui/src/playback-engine/audio/pcm-audio-player.ts
index e9e72d03..b2540ac2 100644
--- a/web-ui/src/playback-engine/audio/pcm-audio-player.ts
+++ b/web-ui/src/playback-engine/audio/pcm-audio-player.ts
@@ -429,6 +429,66 @@ export class PCMAudioPlayer {
     }
   }
 
+  /**
+   * Drop software-decoded audio at and after a track-switch boundary while
+   * allowing already scheduled audio before the boundary to finish. The new
+   * track may use either Web Audio or MSE, so this must be applied even when no
+   * new PCM chunks are expected.
+   */
+  replaceFrom(time: number): void {
+    const trimChunks = (chunks: AudioChunk[]): AudioChunk[] => {
+      const kept: AudioChunk[] = [];
+      for (const chunk of chunks) {
+        if (chunk.time >= time) break;
+        if (chunk.endTime <= time) {
+          kept.push(chunk);
+          continue;
+        }
+
+        const frames = Math.max(0, Math.floor((time - chunk.time) * chunk.sampleRate));
+        if (frames > 0) {
+          const endTime = chunk.time + frames / chunk.sampleRate;
+          kept.push({
+            ...chunk,
+            samples: chunk.samples.subarray(0, frames * chunk.channels),
+            duration: endTime - chunk.time,
+            endTime,
+          });
+        }
+        break;
+      }
+      return kept;
+    };
+
+    this.audioBuffer = trimChunks(this.audioBuffer);
+    this.pendingChunks = trimChunks(this.pendingChunks);
+
+    const ctx = this.context;
+    const now = ctx?.currentTime ?? 0;
+    const remaining: ScheduledSpan[] = [];
+    for (const span of this.scheduledSpans) {
+      if (span.streamEnd <= time) {
+        remaining.push(span);
+        continue;
+      }
+
+      const stopAt =
+        span.streamStart < time
+          ? span.ctxStart +
+            ((time - span.streamStart) / (span.streamEnd - span.streamStart)) * (span.ctxEnd - span.ctxStart)
+          : now;
+      try {
+        span.source.stop(Math.max(now, stopAt));
+      } catch (_e) {}
+    }
+
+    this.scheduledSpans = remaining;
+    this.nextStartTime = remaining.length > 0 ? remaining[remaining.length - 1].ctxEnd : 0;
+    this.inputCursor = time;
+    this.stretcher?.reset();
+    this.resetDriftState();
+  }
+
   // ==================== Stretcher ====================
 
   /** Returns the stretcher if ready for this chunk's format, else kicks off (re)creation. */
diff --git a/web-ui/src/playback-engine/backends/mse-playback-backend.ts b/web-ui/src/playback-engine/backends/mse-playback-backend.ts
index 819b304c..c80ac9c7 100644
--- a/web-ui/src/playback-engine/backends/mse-playback-backend.ts
+++ b/web-ui/src/playback-engine/backends/mse-playback-backend.ts
@@ -66,6 +66,7 @@ export function createMSEPlaybackBackend(video: HTMLVideoElement, config?: Parti
       controller.onLiveStateChange = (isLive) => events.emit("live-state-change", isLive);
       controller.onAudioSuspended = () => events.emit("audio-suspended");
       controller.onMediaInfo = (info) => events.emit("media-info", info);
+      controller.onAudioTracksChange = (state) => events.emit("audio-tracks-change", state);
     }
     return controller;
   }
@@ -74,12 +75,14 @@ export function createMSEPlaybackBackend(video: HTMLVideoElement, config?: Parti
     kind: "mse",
     mediaElement: video,
 
-    loadSegments(segments) {
+    loadSegments(segments, options) {
       if (destroyed || !segments.length) return;
       renderPipeline?.reset();
-      getController().loadSegments(resolveSegmentUrls(segments));
+      getController().loadSegments(resolveSegmentUrls(segments), options);
     },
 
+    selectAudioTrack: (trackId) => controller?.selectAudioTrack(trackId),
+
     play: () => video.play(),
     pause: () => video.pause(),
     setVolume: (volume) => {
diff --git a/web-ui/src/playback-engine/backends/native-playback-backend.ts b/web-ui/src/playback-engine/backends/native-playback-backend.ts
index 4c42f639..4d528335 100644
--- a/web-ui/src/playback-engine/backends/native-playback-backend.ts
+++ b/web-ui/src/playback-engine/backends/native-playback-backend.ts
@@ -1,11 +1,35 @@
 import { isLGWebOS } from "../../lib/platform";
 import { defaultConfig, type PlayerConfig } from "../config";
 import { PlayerErrors } from "../errors";
-import type { LiveSessionAnchor, PlaybackBackend, PlayerMediaInfo, PlayerSegment } from "../types";
+import {
+  buildAudioTrackPreferenceKey,
+  type LiveSessionAnchor,
+  type PlaybackBackend,
+  type PlayerMediaInfo,
+  type PlayerSegment,
+} from "../types";
 import { createPlaybackEventEmitter, resolveMediaUrl } from "./backend-utils";
 
 type SegmentEntry = PlayerSegment & { start: number };
 
+interface NativeAudioTrack {
+  id: string;
+  label: string;
+  language: string;
+  enabled: boolean;
+}
+
+interface NativeAudioTrackList extends EventTarget {
+  readonly length: number;
+  [index: number]: NativeAudioTrack;
+}
+
+const NATIVE_AUDIO_TRACK_EVENTS = ["addtrack", "change", "removetrack"] as const;
+
+function nativeTrackId(track: NativeAudioTrack, index: number): string {
+  return `native:${track.id || index}`;
+}
+
 function mediaErrorMessage(error: MediaError | null): string {
   if (!error) return "Native media element playback failed";
   return error.message || `HTMLMediaElement.error code=${error.code}`;
@@ -33,6 +57,36 @@ export function createNativePlaybackBackend(video: HTMLVideoElement, config?: Pa
   let shouldPlay = false;
   let loadGeneration = 0;
   let detachLoadListeners: (() => void) | null = null;
+  let preferredAudioTrackKey: string | undefined;
+  const nativeAudioTracks = (video as HTMLVideoElement & { audioTracks?: NativeAudioTrackList }).audioTracks;
+
+  const audioPreferenceKey = (track: NativeAudioTrack, index: number) =>
+    buildAudioTrackPreferenceKey("native", track.id || String(index), track.label, track.language);
+
+  const emitAudioTracks = () => {
+    if (!nativeAudioTracks) return;
+    const entries = Array.from({ length: nativeAudioTracks.length }, (_, index) => ({
+      index,
+      track: nativeAudioTracks[index],
+    }));
+    const preferred = entries.find(({ track, index }) => audioPreferenceKey(track, index) === preferredAudioTrackKey);
+    const selected = preferred ?? entries.find(({ track }) => track.enabled);
+    if (preferred) {
+      preferredAudioTrackKey = undefined;
+      for (const entry of entries) entry.track.enabled = entry === preferred;
+    }
+    const tracks = entries.map(({ track, index }) => ({
+      id: nativeTrackId(track, index),
+      label: track.label || track.language || `Audio ${index + 1}`,
+      language: track.language || undefined,
+      isDefault: track.enabled,
+      preferenceKey: audioPreferenceKey(track, index),
+    }));
+    events.emit("audio-tracks-change", {
+      tracks,
+      selectedTrackId: selected ? nativeTrackId(selected.track, selected.index) : undefined,
+    });
+  };
 
   const currentEntry = () => entries[segmentIndex];
   const isLiveSource = () => entries.length === 1 && (entries[0]?.duration ?? 0) === 0;
@@ -59,6 +113,7 @@ export function createNativePlaybackBackend(video: HTMLVideoElement, config?: Pa
       if (!isCurrentLoad()) return;
       mediaOrigin = Number.isFinite(video.currentTime) ? video.currentTime : 0;
       updateMediaInfo();
+      emitAudioTracks();
       updateLogicalTime(generation);
     };
     const onDurationChange = () => {
@@ -147,13 +202,16 @@ export function createNativePlaybackBackend(video: HTMLVideoElement, config?: Pa
 
   const onVolumeChange = () => events.emit("volume-change", video.volume, video.muted);
   video.addEventListener("volumechange", onVolumeChange);
+  for (const event of NATIVE_AUDIO_TRACK_EVENTS) nativeAudioTracks?.addEventListener(event, emitAudioTracks);
 
   return {
     kind: "native",
     mediaElement: video,
 
-    loadSegments(segments) {
+    loadSegments(segments, options) {
       if (destroyed || !segments.length) return;
+      preferredAudioTrackKey = options?.preferredAudioTrackKey;
+      events.emit("audio-tracks-change", { tracks: [] });
       let start = 0;
       entries = segments.map((segment) => {
         const entry = { ...segment, url: resolveMediaUrl(segment.url), start };
@@ -166,6 +224,15 @@ export function createNativePlaybackBackend(video: HTMLVideoElement, config?: Pa
       loadCurrentEntry(shouldPlay);
     },
 
+    selectAudioTrack(trackId) {
+      if (!nativeAudioTracks) return;
+      preferredAudioTrackKey = undefined;
+      for (let index = 0; index < nativeAudioTracks.length; index++) {
+        nativeAudioTracks[index].enabled = nativeTrackId(nativeAudioTracks[index], index) === trackId;
+      }
+      emitAudioTracks();
+    },
+
     async play() {
       shouldPlay = true;
       const generation = loadGeneration;
@@ -256,6 +323,7 @@ export function createNativePlaybackBackend(video: HTMLVideoElement, config?: Pa
       detachLoadListeners?.();
       detachLoadListeners = null;
       video.removeEventListener("volumechange", onVolumeChange);
+      for (const event of NATIVE_AUDIO_TRACK_EVENTS) nativeAudioTracks?.removeEventListener(event, emitAudioTracks);
       entries = [];
       video.pause();
       video.removeAttribute("src");
diff --git a/web-ui/src/playback-engine/demux/pat-pmt-pes.ts b/web-ui/src/playback-engine/demux/pat-pmt-pes.ts
index e54d5809..1b16c0eb 100644
--- a/web-ui/src/playback-engine/demux/pat-pmt-pes.ts
+++ b/web-ui/src/playback-engine/demux/pat-pmt-pes.ts
@@ -25,12 +25,24 @@ interface PIDToStreamTypeMap {
   [pid: number]: StreamType;
 }
 
+export type PMTAudioCodec = "aac" | "ac3" | "eac3" | "mpeg";
+
+export interface PMTAudioStream {
+  pid: number;
+  streamType: StreamType;
+  codec: PMTAudioCodec;
+  language?: string;
+  /** common_pids slot used by the existing PES parser. */
+  pidKey: "adts_aac" | "loas_aac" | "ac3" | "eac3" | "mp3";
+}
+
 export class PMT {
   program_number!: number;
   version_number!: number;
   pcr_pid!: number;
   // pid -> stream_type
   pid_stream_type: PIDToStreamTypeMap = {};
+  audio_streams: PMTAudioStream[] = [];
 
   common_pids: {
     h264: number | undefined;
diff --git a/web-ui/src/playback-engine/demux/ts-demuxer.ts b/web-ui/src/playback-engine/demux/ts-demuxer.ts
index 1767b784..cee7725e 100644
--- a/web-ui/src/playback-engine/demux/ts-demuxer.ts
+++ b/web-ui/src/playback-engine/demux/ts-demuxer.ts
@@ -25,6 +25,7 @@ import {
   PESData,
   type PIDToSliceQueues,
   PMT,
+  type PMTAudioStream,
   type ProgramToPMTMap,
   SectionData,
   SliceQueue,
@@ -57,6 +58,7 @@ type AdaptationFieldInfo = {
 type CommonPidKey = keyof PMT["common_pids"];
 type TSDemuxerOptions = {
   waitForInitialVideoKeyframe?: boolean;
+  selectedAudioPid?: number;
 };
 type TSSegmentBoundaryOptions = {
   resetAudioParserState?: boolean;
@@ -108,9 +110,65 @@ type AudioData =
       data: MP3Data;
     };
 
+function createEmptyAudioMetadata(): AACAudioMetadata {
+  return {
+    codec: undefined as unknown as "aac",
+    audio_object_type: undefined as unknown as MPEG4AudioObjectTypes,
+    sampling_freq_index: undefined as unknown as MPEG4SamplingFrequencyIndex,
+    sampling_frequency: undefined as unknown as number,
+    channel_config: undefined as unknown as number,
+  };
+}
+
 const VIDEO_PID_KEYS: readonly CommonPidKey[] = ["h264", "h265"];
 const AUDIO_PID_KEYS: readonly CommonPidKey[] = ["adts_aac", "loas_aac", "ac3", "eac3", "mp3"];
 
+function descriptorLanguage(data: Uint8Array, start: number, length: number): string | undefined {
+  for (let offset = start; offset + 1 < start + length; ) {
+    const tag = data[offset];
+    const descriptorLength = data[offset + 1];
+    if (tag === 0x0a && descriptorLength >= 3 && offset + 5 <= data.length) {
+      return String.fromCharCode(data[offset + 2], data[offset + 3], data[offset + 4]).trim() || undefined;
+    }
+    offset += 2 + descriptorLength;
+  }
+  return undefined;
+}
+
+function classifyAudioStream(
+  streamType: StreamType,
+  pid: number,
+  data: Uint8Array,
+  descriptorStart: number,
+  descriptorLength: number,
+): PMTAudioStream | undefined {
+  const language = descriptorLanguage(data, descriptorStart, descriptorLength);
+  if (streamType === StreamType.kADTSAAC) return { pid, streamType, codec: "aac", language, pidKey: "adts_aac" };
+  if (streamType === StreamType.kLOASAAC) return { pid, streamType, codec: "aac", language, pidKey: "loas_aac" };
+  if (streamType === StreamType.kAC3) return { pid, streamType, codec: "ac3", language, pidKey: "ac3" };
+  if (streamType === StreamType.kEAC3) return { pid, streamType, codec: "eac3", language, pidKey: "eac3" };
+  if (streamType === StreamType.kMPEG1Audio || streamType === StreamType.kMPEG2Audio) {
+    return { pid, streamType, codec: "mpeg", language, pidKey: "mp3" };
+  }
+  if (streamType !== StreamType.kPESPrivateData) return undefined;
+
+  for (let offset = descriptorStart; offset + 1 < descriptorStart + descriptorLength; ) {
+    const tag = data[offset];
+    const length = data[offset + 1];
+    if (tag === 0x05 && length >= 4) {
+      const registration = String.fromCharCode(...data.subarray(offset + 2, offset + 6));
+      if (registration === "AC-3") return { pid, streamType, codec: "ac3", language, pidKey: "ac3" };
+      if (registration === "EC-3") return { pid, streamType, codec: "eac3", language, pidKey: "eac3" };
+    } else if (tag === 0x6a || tag === 0x81 || tag === 0x82) {
+      return { pid, streamType, codec: "ac3", language, pidKey: "ac3" };
+    } else if (tag === 0x7a) {
+      return { pid, streamType, codec: "eac3", language, pidKey: "eac3" };
+    }
+    offset += 2 + length;
+  }
+  return undefined;
+}
+
 export type OnErrorCallback = (type: DemuxErrorDetail, info: string) => void;
 export type OnTrackMetadataCallback = (type: string, metadata: unknown) => void;
 export type OnDataAvailableCallback = (audioTrack: unknown, videoTrack: unknown, force?: boolean) => void;
@@ -118,6 +176,14 @@ export type OnTrackDiscontinuityCallback = (track: "audio" | "video") => void;
 /** Reports the 90 kHz PCR base and byte position from the PMT-declared PCR PID. */
 export type OnPcrCallback = (pcrBase: number, bytePosition: number, discontinuity: boolean) => void;
 
+export interface TSAudioTrackInfo {
+  pid: number;
+  codec: "aac" | "ac3" | "eac3" | "mpeg";
+  language?: string;
+}
+
+export type OnAudioTracksCallback = (tracks: TSAudioTrackInfo[], selectedPid: number | undefined) => void;
+
 class TSDemuxer {
   private readonly TAG: string = "TSDemuxer";
 
@@ -126,6 +192,7 @@ class TSDemuxer {
   public onDataAvailable: OnDataAvailableCallback | null = null;
   public onTrackDiscontinuity: OnTrackDiscontinuityCallback | null = null;
   public onPcr: OnPcrCallback | null = null;
+  public onAudioTracks: OnAudioTracksCallback | null = null;
   /** Software audio decode support (MP2) */
   public onRawAudioData: ((frame: { codec: "mp2"; data: Uint8Array; pts: number }) => void) | null = null;
 
@@ -157,13 +224,8 @@ class TSDemuxer {
     details: {} as Record<string, unknown>,
   };
 
-  private audio_metadata_: AACAudioMetadata | AC3AudioMetadata | EAC3AudioMetadata | MP3AudioMetadata = {
-    codec: undefined as unknown as "aac",
-    audio_object_type: undefined as unknown as MPEG4AudioObjectTypes,
-    sampling_freq_index: undefined as unknown as MPEG4SamplingFrequencyIndex,
-    sampling_frequency: undefined as unknown as number,
-    channel_config: undefined as unknown as number,
-  };
+  private audio_metadata_: AACAudioMetadata | AC3AudioMetadata | EAC3AudioMetadata | MP3AudioMetadata =
+    createEmptyAudioMetadata();
 
   private last_pcr_base_: number = NaN;
   private timestamp_offset_: number = 0;
@@ -185,6 +247,8 @@ class TSDemuxer {
   private soft_decode_audio_codec_: "mp2" | null = null;
   private audio_drop_until_sync_ = false;
   private drop_video_until_keyframe_ = true;
+  private selected_audio_pid_: number | undefined;
+  private audio_tracks_signature_ = "";
 
   private video_track_ = {
     type: "video",
@@ -205,9 +269,14 @@ class TSDemuxer {
     this.timestamp_offset_ = value;
   }
 
+  public get hasVideo(): boolean {
+    return this.has_video_;
+  }
+
   public constructor(probe_data: TSProbeResult, options: TSDemuxerOptions = {}) {
     this.ts_packet_size_ = probe_data.ts_packet_size as number;
     this.sync_offset_ = probe_data.sync_offset as number;
+    this.selected_audio_pid_ = options.selectedAudioPid;
     if (options.waitForInitialVideoKeyframe === false) {
       this.drop_video_until_keyframe_ = false;
       this.video_output_started_ = true;
@@ -232,6 +301,7 @@ class TSDemuxer {
     this.onDataAvailable = null;
     this.onTrackDiscontinuity = null;
     this.onPcr = null;
+    this.onAudioTracks = null;
     this.onRawAudioData = null;
     this.soft_decode_audio_codec_ = null;
   }
@@ -251,12 +321,25 @@ class TSDemuxer {
   }
 
   public flushSegmentBoundary(): void {
-    if (this.shouldWaitForVideoKeyframe() || !this.isInitSegmentDispatched()) {
-      return;
-    }
-    if (this.audio_track_.length || this.video_track_.length) {
-      this.onDataAvailable?.(this.audio_track_, this.video_track_, true);
+    this.flushPendingMedia();
+  }
+
+  /** Switch the selected elementary audio PID without resetting video parsing or its timestamp base. */
+  public selectAudioPid(pid: number): boolean {
+    const pmt = this.pmt_;
+    if (!pmt || pid === this.selected_audio_pid_ || !pmt.audio_streams.some((track) => track.pid === pid)) {
+      return false;
     }
+
+    this.clearAudioTrack();
+    this.clearAudioPESQueues();
+    this.resetAudioCodecState();
+    this.selected_audio_pid_ = pid;
+    this.applySelectedAudioStream(pmt);
+    delete this.continuity_counters_[pid];
+    this.onTrackDiscontinuity?.("audio");
+    this.emitAudioTracks(pmt);
+    return true;
   }
 
   public static probe(data: Uint8Array): TSProbeResult {
@@ -332,6 +415,21 @@ class TSDemuxer {
     return this.isVideoPid(pid) || this.isAudioPid(pid);
   }
 
+  private applySelectedAudioStream(pmt: PMT): void {
+    for (const key of AUDIO_PID_KEYS) pmt.common_pids[key] = undefined;
+    const selected = pmt.audio_streams.find((track) => track.pid === this.selected_audio_pid_) ?? pmt.audio_streams[0];
+    this.selected_audio_pid_ = selected?.pid;
+    if (selected) pmt.common_pids[selected.pidKey] = selected.pid;
+  }
+
+  private emitAudioTracks(pmt: PMT): void {
+    const tracks = pmt.audio_streams.map(({ pid, codec, language }) => ({ pid, codec, language }));
+    const signature = JSON.stringify([tracks, this.selected_audio_pid_]);
+    if (signature === this.audio_tracks_signature_) return;
+    this.audio_tracks_signature_ = signature;
+    this.onAudioTracks?.(tracks, this.selected_audio_pid_);
+  }
+
   private resetAudioParserState(): void {
     this.audio_last_sample_pts_ = undefined;
     this.aac_last_incomplete_data_ = null;
@@ -341,6 +439,13 @@ class TSDemuxer {
     this.audio_drop_until_sync_ = true;
   }
 
+  private resetAudioCodecState(): void {
+    this.resetAudioParserState();
+    this.audio_init_segment_dispatched_ = false;
+    this.soft_decode_audio_codec_ = null;
+    this.audio_metadata_ = createEmptyAudioMetadata();
+  }
+
   private clearAudioTrack(): void {
     this.audio_track_.samples = [];
     this.audio_track_.length = 0;
@@ -352,16 +457,13 @@ class TSDemuxer {
   }
 
   private clearAudioPESQueues(): void {
-    const commonPids = this.pmt_?.common_pids;
-    if (!commonPids) {
+    const pmt = this.pmt_;
+    if (!pmt) {
       return;
     }
 
-    for (const key of AUDIO_PID_KEYS) {
-      const pid = commonPids[key];
-      if (pid !== undefined) {
-        delete this.pes_slice_queues_[pid];
-      }
+    for (const track of pmt.audio_streams) {
+      delete this.pes_slice_queues_[track.pid];
     }
   }
 
@@ -369,7 +471,7 @@ class TSDemuxer {
     return this.has_video_ && !this.video_output_started_;
   }
 
-  private flushMediaBeforeTrackDiscontinuity(): void {
+  private flushPendingMedia(): void {
     if (this.shouldWaitForVideoKeyframe() || !this.isInitSegmentDispatched()) {
       return;
     }
@@ -392,7 +494,7 @@ class TSDemuxer {
     delete this.pes_slice_queues_[pid];
 
     if (this.isVideoPid(pid)) {
-      this.flushMediaBeforeTrackDiscontinuity();
+      this.flushPendingMedia();
       this.clearVideoTrack();
       this.drop_video_until_keyframe_ = true;
       this.video_output_started_ = false;
@@ -406,7 +508,7 @@ class TSDemuxer {
     }
 
     if (this.isAudioPid(pid)) {
-      this.flushMediaBeforeTrackDiscontinuity();
+      this.flushPendingMedia();
       this.resetAudioParserState();
       Log.w(this.TAG, `Audio TS discontinuity on pid ${pid}: ${reason}; resetting audio parser state`);
       this.onTrackDiscontinuity?.("audio");
@@ -922,52 +1024,17 @@ class TSDemuxer {
       pmt.pid_stream_type[elementary_PID] = stream_type;
 
       const already_has_video = pmt.common_pids.h264 || pmt.common_pids.h265;
-      const already_has_audio =
-        pmt.common_pids.adts_aac ||
-        pmt.common_pids.loas_aac ||
-        pmt.common_pids.ac3 ||
-        pmt.common_pids.eac3 ||
-        pmt.common_pids.mp3;
-
       if (stream_type === StreamType.kH264 && !already_has_video) {
         pmt.common_pids.h264 = elementary_PID;
       } else if (stream_type === StreamType.kH265 && !already_has_video) {
         pmt.common_pids.h265 = elementary_PID;
-      } else if (stream_type === StreamType.kADTSAAC && !already_has_audio) {
-        pmt.common_pids.adts_aac = elementary_PID;
-      } else if (stream_type === StreamType.kLOASAAC && !already_has_audio) {
-        pmt.common_pids.loas_aac = elementary_PID;
-      } else if (stream_type === StreamType.kAC3 && !already_has_audio) {
-        pmt.common_pids.ac3 = elementary_PID; // ATSC AC-3
-      } else if (stream_type === StreamType.kEAC3 && !already_has_audio) {
-        pmt.common_pids.eac3 = elementary_PID; // ATSC EAC-3
-      } else if (
-        (stream_type === StreamType.kMPEG1Audio || stream_type === StreamType.kMPEG2Audio) &&
-        !already_has_audio
-      ) {
-        pmt.common_pids.mp3 = elementary_PID;
-      } else if (stream_type === StreamType.kPESPrivateData && ES_info_length > 0) {
-        // parse descriptors to detect DVB AC-3 / E-AC-3 in private PES
-        for (let offset = i + 5; offset < i + 5 + ES_info_length; ) {
-          const tag = data[offset + 0];
-          const length = data[offset + 1];
-          if (tag === 0x05) {
-            // Registration Descriptor
-            const registration = String.fromCharCode(...Array.from(data.subarray(offset + 2, offset + 2 + length)));
-            if (registration === "AC-3" && !already_has_audio) {
-              pmt.common_pids.ac3 = elementary_PID; // DVB AC-3
-            } else if (registration === "EC-3" && !already_has_audio) {
-              pmt.common_pids.eac3 = elementary_PID; // DVB EAC-3
-            }
-          } else if (tag === 0x82) {
-            pmt.common_pids.ac3 = elementary_PID;
-          } else if (tag === 0x7a) {
-            pmt.common_pids.eac3 = elementary_PID;
-          }
-          offset += 2 + length;
-        }
       }
 
+      // Collect every audio entry first; applySelectedAudioStream() maps only
+      // the selected PID into common_pids after the complete PMT is known.
+      const audioStream = classifyAudioStream(stream_type, elementary_PID, data, i + 5, ES_info_length);
+      if (audioStream) pmt.audio_streams.push(audioStream);
+
       i += 5 + ES_info_length;
     }
 
@@ -976,18 +1043,12 @@ class TSDemuxer {
         Log.v(this.TAG, `Parsed first PMT: ${JSON.stringify(pmt)}`);
       }
       this.pmt_ = pmt;
+      this.applySelectedAudioStream(pmt);
       if (pmt.common_pids.h264 || pmt.common_pids.h265) {
         this.has_video_ = true;
       }
-      if (
-        pmt.common_pids.adts_aac ||
-        pmt.common_pids.loas_aac ||
-        pmt.common_pids.ac3 ||
-        pmt.common_pids.eac3 ||
-        pmt.common_pids.mp3
-      ) {
-        this.has_audio_ = true;
-      }
+      this.has_audio_ = pmt.audio_streams.length > 0;
+      this.emitAudioTracks(pmt);
     }
   }
 
diff --git a/web-ui/src/playback-engine/hls/hls-source.ts b/web-ui/src/playback-engine/hls/hls-source.ts
index 5947ba15..1804e394 100644
--- a/web-ui/src/playback-engine/hls/hls-source.ts
+++ b/web-ui/src/playback-engine/hls/hls-source.ts
@@ -1,7 +1,16 @@
 import type { PlayerConfig } from "../config";
+import type { PlayerAudioTrack } from "../types";
 import Log from "../utils/logger";
 import type { SegmentMeta, SegmentSource } from "../worker/segment-source";
-import { type HlsMediaPlaylist, type HlsVariant, parseM3U8 } from "./m3u8";
+import {
+  type HlsAudioRendition,
+  type HlsMediaPlaylist,
+  type HlsVariant,
+  mediaTimeSegmentIndex,
+  parseM3U8,
+  programDateTimeSegmentIndex,
+  selectAudioRendition,
+} from "./m3u8";
 
 export interface HlsInfo {
   live: boolean;
@@ -14,11 +23,38 @@ export interface HlsInfo {
   resolution?: { width: number; height: number };
   frameRate?: number;
   videoRange?: string;
+  audioTracks?: PlayerAudioTrack[];
+  /** Whether the selected variant references an EXT-X-MEDIA audio group. */
+  hasAudioGroup?: boolean;
+  selectedAudioTrackId?: string;
+  selectedAudioTrackUrl?: string;
+  /** Worker-internal runtime lookup; URLs are intentionally absent from public track state. */
+  audioTrackUrls?: Record<string, string>;
+  /** Wall-clock time corresponding to MSE timeline zero, when supplied by the playlist. */
+  timelineProgramDateTime?: number;
+  /** First segment boundary selected by this source on the MSE timeline. */
+  playbackStartTime?: number;
+  /** Distance from the selected live position to the playlist edge, in seconds. */
+  liveEdgeDistance?: number;
+}
+
+export interface HlsSourceOptions {
+  preferredAudioTrackKey?: string;
+  /** Position assigned to the first selected live segment (used by rendition switches). */
+  liveTimelineOffset?: number;
+  /** For VOD rendition switches, start with the segment covering this position. */
+  startTime?: number;
+  /** Prefer the segment covering this wall-clock time when aligning renditions. */
+  programDateTimeAnchor?: number;
+  /** Match another rendition's distance from the live edge when wall-clock time is unavailable. */
+  liveEdgeDistance?: number;
 }
 
 const TAG = "HlsSource";
 /** Start playback this many segments away from the live edge. */
 const LIVE_EDGE_SEGMENTS = 3;
+/** Fetch earlier alternate-rendition segments so raw timestamps can resolve playlist-window skew. */
+const LIVE_RENDITION_PREROLL_SEGMENTS = 2;
 const MAX_REFRESH_FAILURES = 5;
 
 export class HlsRequestError extends Error {
@@ -47,6 +83,13 @@ export class HlsSource implements SegmentSource {
   private targetDuration = 6;
   private totalDuration = 0;
   private selectedVariant: Omit<HlsVariant, "url"> | undefined;
+  private hasAudioGroup = false;
+  private audioTracks: PlayerAudioTrack[] = [];
+  private audioRenditionUrls = new Map<string, string>();
+  private selectedAudioTrack: HlsAudioRendition | undefined;
+  private timelineProgramDateTime: number | undefined;
+  private playbackStartTime = 0;
+  private liveEdgeDistance: number | undefined;
 
   private segments: SegmentMeta[] = [];
   private nextIndex = 0;
@@ -61,11 +104,18 @@ export class HlsSource implements SegmentSource {
   private lastPlaylistHadNews = true;
   /** Playlist content already fetched during HLS detection, consumed on the first load. */
   private preloaded: { text: string; url: string } | null;
+  private readonly options: HlsSourceOptions;
 
-  constructor(url: string, config: PlayerConfig, preloaded?: { text: string; url: string }) {
+  constructor(
+    url: string,
+    config: PlayerConfig,
+    preloaded?: { text: string; url: string },
+    options: HlsSourceOptions = {},
+  ) {
     this.url = preloaded?.url ?? url;
     this.config = config;
     this.preloaded = preloaded ?? null;
+    this.options = options;
   }
 
   get info(): HlsInfo {
@@ -74,6 +124,14 @@ export class HlsSource implements SegmentSource {
       targetDuration: this.targetDuration,
       totalDuration: this.totalDuration,
       ...this.selectedVariant,
+      audioTracks: this.audioTracks,
+      hasAudioGroup: this.hasAudioGroup,
+      selectedAudioTrackId: this.selectedAudioTrack?.id,
+      selectedAudioTrackUrl: this.selectedAudioTrack?.url,
+      audioTrackUrls: Object.fromEntries(this.audioRenditionUrls),
+      timelineProgramDateTime: this.timelineProgramDateTime,
+      playbackStartTime: this.playbackStartTime,
+      liveEdgeDistance: this.liveEdgeDistance,
     };
   }
 
@@ -114,12 +172,54 @@ export class HlsSource implements SegmentSource {
 
     if (this.live) {
       // Start near the live edge and rebase the timeline so playback starts at 0
-      this.nextIndex = Math.max(0, this.segments.length - LIVE_EDGE_SEGMENTS);
+      const programDateTimeAnchor = this.options.programDateTimeAnchor;
+      const programDateTimeIndex =
+        programDateTimeAnchor === undefined
+          ? -1
+          : programDateTimeSegmentIndex(playlist.segments, programDateTimeAnchor);
+      const liveEdgeTarget =
+        this.options.liveEdgeDistance === undefined
+          ? undefined
+          : Math.max(0, playlist.totalDuration - this.options.liveEdgeDistance);
+      const matchedLiveEdgeIndex =
+        liveEdgeTarget === undefined ? -1 : mediaTimeSegmentIndex(this.segments, liveEdgeTarget);
+      const liveEdgeIndex =
+        matchedLiveEdgeIndex < 0 ? -1 : Math.max(0, matchedLiveEdgeIndex - LIVE_RENDITION_PREROLL_SEGMENTS);
+      this.nextIndex =
+        programDateTimeIndex >= 0
+          ? programDateTimeIndex
+          : liveEdgeIndex >= 0
+            ? liveEdgeIndex
+            : Math.max(0, this.segments.length - LIVE_EDGE_SEGMENTS);
       const base = this.segments[this.nextIndex]?.start ?? 0;
-      if (base > 0) {
-        this.segments = this.segments.map((s) => ({ ...s, start: s.start - base }));
-        this.timelinePos -= base;
+      const selectedProgramDateTime = playlist.segments[this.nextIndex]?.programDateTime;
+      const selectedLead = liveEdgeTarget === undefined || programDateTimeIndex >= 0 ? 0 : liveEdgeTarget - base;
+      const offset =
+        (this.options.liveTimelineOffset ?? 0) -
+        selectedLead +
+        (programDateTimeAnchor !== undefined && selectedProgramDateTime !== undefined
+          ? Math.max(0, (selectedProgramDateTime - programDateTimeAnchor) / 1000)
+          : 0);
+      const timelineAdjustment = offset - base;
+      if (timelineAdjustment !== 0) {
+        this.segments = this.segments.map((segment) => ({
+          ...segment,
+          start: segment.start + timelineAdjustment,
+        }));
+        this.timelinePos += timelineAdjustment;
       }
+      this.timelineProgramDateTime =
+        selectedProgramDateTime === undefined ? undefined : selectedProgramDateTime - offset * 1000;
+      this.playbackStartTime = this.segments[this.nextIndex]?.start ?? offset;
+      this.liveEdgeDistance = Math.max(0, playlist.totalDuration - (liveEdgeTarget ?? base));
+      Log.v(
+        TAG,
+        `Live selection index=${this.nextIndex} start=${this.playbackStartTime.toFixed(3)}s edgeDistance=${this.liveEdgeDistance.toFixed(3)}s`,
+      );
+    } else if (this.options.startTime !== undefined) {
+      const startTime = this.options.startTime;
+      this.nextIndex = Math.max(0, mediaTimeSegmentIndex(this.segments, startTime));
+      this.playbackStartTime = this.segments[this.nextIndex]?.start ?? startTime;
     }
 
     this.initialized = true;
@@ -191,6 +291,33 @@ export class HlsSource implements SegmentSource {
           }
           const { url: _url, ...selectedVariant } = best;
           this.selectedVariant = selectedVariant;
+          const renditions = best.audioGroupId
+            ? playlist.audioRenditions.filter((rendition) => rendition.groupId === best.audioGroupId)
+            : [];
+          this.hasAudioGroup = renditions.length > 0;
+
+          // A URI-less rendition represents the audio carried by the variant itself. If the
+          // same group also contains external renditions, expose that in-band option through
+          // an audio-only pipeline reading the variant playlist. This keeps every switch on
+          // the existing audio-pipeline replacement path and avoids rebuilding video.
+          const hasExternalRendition = renditions.some((rendition) => rendition.url !== undefined);
+          const playableRenditions = hasExternalRendition
+            ? renditions.map((rendition) => (rendition.url ? rendition : { ...rendition, url: best.url }))
+            : renditions;
+          const selectedAudioTrack = selectAudioRendition(playableRenditions, this.options.preferredAudioTrackKey);
+          this.audioTracks = renditions.map((rendition) => ({
+            id: rendition.id,
+            label: rendition.name,
+            language: rendition.language,
+            isDefault: rendition.isDefault,
+            preferenceKey: rendition.preferenceKey,
+          }));
+          this.audioRenditionUrls = new Map(
+            playableRenditions.flatMap((rendition) =>
+              rendition.url === undefined ? [] : [[rendition.id, rendition.url] as const],
+            ),
+          );
+          this.selectedAudioTrack = selectedAudioTrack;
           this.url = best.url;
           continue; // fetch the selected media playlist
         }
diff --git a/web-ui/src/playback-engine/hls/m3u8.ts b/web-ui/src/playback-engine/hls/m3u8.ts
index eaa88be9..7ef544e8 100644
--- a/web-ui/src/playback-engine/hls/m3u8.ts
+++ b/web-ui/src/playback-engine/hls/m3u8.ts
@@ -2,20 +2,23 @@
  * Minimal m3u8 playlist parser. Supports only what the player needs:
  * - Media playlist: EXTINF, EXT-X-TARGETDURATION, EXT-X-MEDIA-SEQUENCE,
  *   EXT-X-DISCONTINUITY, EXT-X-ENDLIST, EXT-X-MAP
- * - Multivariant playlist: EXT-X-STREAM-INF media hints
+ * - Multivariant playlist: EXT-X-STREAM-INF media hints and EXT-X-MEDIA audio renditions
  *
  * EXT-X-PLAYLIST-TYPE is ignored: any playlist without EXT-X-ENDLIST (including
  * EVENT) is treated as live and keeps refreshing.
  *
- * Explicitly unsupported: LL-HLS, EXT-X-MEDIA renditions, encryption, byteranges.
+ * Explicitly unsupported: LL-HLS, encryption, byteranges.
  */
 
+import { buildAudioTrackPreferenceKey } from "../types";
+
 export interface HlsPlaylistSegment {
   url: string;
   duration: number;
   mediaSequence: number;
   discontinuity: boolean;
   initUrl?: string;
+  programDateTime?: number;
 }
 
 export interface HlsMediaPlaylist {
@@ -36,11 +39,24 @@ export interface HlsVariant {
   resolution?: { width: number; height: number };
   frameRate?: number;
   videoRange?: string;
+  audioGroupId?: string;
+}
+
+export interface HlsAudioRendition {
+  id: string;
+  groupId: string;
+  name: string;
+  language?: string;
+  isDefault: boolean;
+  autoselect: boolean;
+  url?: string;
+  preferenceKey: string;
 }
 
 export interface HlsMultivariantPlaylist {
   kind: "multivariant";
   variants: HlsVariant[];
+  audioRenditions: HlsAudioRendition[];
 }
 
 export type HlsPlaylist = HlsMediaPlaylist | HlsMultivariantPlaylist;
@@ -61,6 +77,72 @@ function parseAttributes(input: string): Record<string, string> {
   return attrs;
 }
 
+function yes(value: string | undefined): boolean {
+  return value?.toUpperCase() === "YES";
+}
+
+export function audioRenditionPreferenceKey(groupId: string, name: string, language?: string): string {
+  return buildAudioTrackPreferenceKey(groupId, name, language);
+}
+
+export function selectAudioRendition(
+  renditions: HlsAudioRendition[],
+  preferredAudioTrackKey?: string,
+): HlsAudioRendition | undefined {
+  return (
+    renditions.find((rendition) => rendition.preferenceKey === preferredAudioTrackKey) ??
+    renditions.find((rendition) => rendition.isDefault) ??
+    renditions.find((rendition) => rendition.autoselect) ??
+    renditions[0]
+  );
+}
+
+/** Select the first segment boundary at or after a media-time target, falling back to the last available segment. */
+export function mediaTimeBoundaryIndex(segments: readonly { start: number }[], targetSeconds: number): number {
+  const index = segments.findIndex((segment) => segment.start >= targetSeconds);
+  return index >= 0 ? index : segments.length - 1;
+}
+
+/** Select the segment containing a media-time target, or the nearest available segment. */
+export function mediaTimeSegmentIndex(
+  segments: readonly { start: number; duration: number }[],
+  targetSeconds: number,
+): number {
+  if (segments.length === 0) return -1;
+  const index = segments.findIndex((segment) => targetSeconds < segment.start + segment.duration);
+  return index >= 0 ? index : segments.length - 1;
+}
+
+/** Select the first absolute-time boundary at or after a target, without relying on matching media sequences. */
+export function programDateTimeBoundaryIndex(
+  segments: readonly { programDateTime?: number }[],
+  targetMilliseconds: number,
+): number {
+  let lastDatedIndex = -1;
+  for (let index = 0; index < segments.length; index++) {
+    const programDateTime = segments[index].programDateTime;
+    if (programDateTime === undefined) continue;
+    lastDatedIndex = index;
+    if (programDateTime >= targetMilliseconds) return index;
+  }
+  return lastDatedIndex;
+}
+
+/** Select the segment covering an absolute-time target, without assuming equal rendition boundaries. */
+export function programDateTimeSegmentIndex(
+  segments: readonly { programDateTime?: number; duration: number }[],
+  targetMilliseconds: number,
+): number {
+  let lastDatedIndex = -1;
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index];
+    if (segment.programDateTime === undefined) continue;
+    lastDatedIndex = index;
+    if (targetMilliseconds < segment.programDateTime + segment.duration * 1000) return index;
+  }
+  return lastDatedIndex;
+}
+
 export function parseM3U8(text: string, baseUrl: string): HlsPlaylist {
   const lines = text.split(/\r?\n/).map((l) => l.trim());
   if (!lines.some((l) => l.startsWith("#EXTM3U"))) {
@@ -75,10 +157,27 @@ export function parseM3U8(text: string, baseUrl: string): HlsPlaylist {
 
 function parseMultivariant(lines: string[], baseUrl: string): HlsMultivariantPlaylist {
   const variants: HlsVariant[] = [];
+  const audioRenditions: HlsAudioRendition[] = [];
   let pending: Omit<HlsVariant, "url"> | null = null;
 
   for (const line of lines) {
-    if (line.startsWith("#EXT-X-STREAM-INF:")) {
+    if (line.startsWith("#EXT-X-MEDIA:")) {
+      const attrs = parseAttributes(line.slice("#EXT-X-MEDIA:".length));
+      if (attrs.TYPE !== "AUDIO" || !attrs["GROUP-ID"]) continue;
+      const groupId = attrs["GROUP-ID"];
+      const name = attrs.NAME || attrs.LANGUAGE || `Audio ${audioRenditions.length + 1}`;
+      const preferenceKey = audioRenditionPreferenceKey(groupId, name, attrs.LANGUAGE);
+      audioRenditions.push({
+        id: `${preferenceKey}\u001f${audioRenditions.length}`,
+        groupId,
+        name,
+        language: attrs.LANGUAGE,
+        isDefault: yes(attrs.DEFAULT),
+        autoselect: yes(attrs.AUTOSELECT),
+        url: attrs.URI ? new URL(attrs.URI, baseUrl).href : undefined,
+        preferenceKey,
+      });
+    } else if (line.startsWith("#EXT-X-STREAM-INF:")) {
       const attrs = parseAttributes(line.slice("#EXT-X-STREAM-INF:".length));
       const resolutionMatch = /^(\d+)x(\d+)$/i.exec(attrs.RESOLUTION ?? "");
       const averageBandwidth = Number.parseInt(attrs["AVERAGE-BANDWIDTH"] ?? "", 10);
@@ -92,6 +191,7 @@ function parseMultivariant(lines: string[], baseUrl: string): HlsMultivariantPla
           : undefined,
         frameRate: Number.isFinite(frameRate) && frameRate > 0 ? frameRate : undefined,
         videoRange: attrs["VIDEO-RANGE"],
+        audioGroupId: attrs.AUDIO,
       };
     } else if (pending && line.length > 0 && !line.startsWith("#")) {
       variants.push({ url: new URL(line, baseUrl).href, ...pending });
@@ -99,7 +199,7 @@ function parseMultivariant(lines: string[], baseUrl: string): HlsMultivariantPla
     }
   }
 
-  return { kind: "multivariant", variants };
+  return { kind: "multivariant", variants, audioRenditions };
 }
 
 function parseMedia(lines: string[], baseUrl: string): HlsMediaPlaylist {
@@ -110,6 +210,7 @@ function parseMedia(lines: string[], baseUrl: string): HlsMediaPlaylist {
   let pendingDuration: number | null = null;
   let pendingDiscontinuity = false;
   let currentInitUrl: string | undefined;
+  let pendingProgramDateTime: number | undefined;
   let totalDuration = 0;
 
   for (const line of lines) {
@@ -129,19 +230,27 @@ function parseMedia(lines: string[], baseUrl: string): HlsMediaPlaylist {
       if (attrs.URI) {
         currentInitUrl = new URL(attrs.URI, baseUrl).href;
       }
+    } else if (line.startsWith("#EXT-X-PROGRAM-DATE-TIME:")) {
+      const parsed = Date.parse(line.slice("#EXT-X-PROGRAM-DATE-TIME:".length));
+      pendingProgramDateTime = Number.isFinite(parsed) ? parsed : undefined;
     } else if (line.startsWith("#EXT-X-ENDLIST")) {
       ended = true;
     } else if (line.length > 0 && !line.startsWith("#") && pendingDuration !== null) {
+      const duration = pendingDuration;
       segments.push({
         url: new URL(line, baseUrl).href,
-        duration: pendingDuration,
+        duration,
         mediaSequence: mediaSequence + segments.length,
         discontinuity: pendingDiscontinuity,
         initUrl: currentInitUrl,
+        programDateTime: pendingProgramDateTime,
       });
-      totalDuration += pendingDuration;
+      totalDuration += duration;
       pendingDuration = null;
       pendingDiscontinuity = false;
+      if (pendingProgramDateTime !== undefined) {
+        pendingProgramDateTime += duration * 1000;
+      }
     }
   }
 
diff --git a/web-ui/src/playback-engine/index.ts b/web-ui/src/playback-engine/index.ts
index 7f3d8073..584bca25 100644
--- a/web-ui/src/playback-engine/index.ts
+++ b/web-ui/src/playback-engine/index.ts
@@ -15,6 +15,9 @@ export type {
   PlaybackBackend,
   PlaybackBackendKind,
   PlaybackBackendState,
+  PlaybackLoadOptions,
+  PlayerAudioTrack,
+  PlayerAudioTrackState,
   PlayerDynamicRange,
   PlayerError,
   PlayerEventMap,
diff --git a/web-ui/src/playback-engine/mse/media-source.ts b/web-ui/src/playback-engine/mse/media-source.ts
index 81571bd8..31df2f69 100644
--- a/web-ui/src/playback-engine/mse/media-source.ts
+++ b/web-ui/src/playback-engine/mse/media-source.ts
@@ -11,6 +11,8 @@ interface RemoveRange {
 interface PendingSegment {
   data: ArrayBuffer;
   timestampOffset?: number;
+  /** Keeps a prepared track-switch init while older queued media is discarded. */
+  isInit?: boolean;
 }
 
 interface InitSegmentRecord {
@@ -19,6 +21,12 @@ interface InitSegmentRecord {
   container: string;
 }
 
+interface PendingSourceBufferInit extends InitSegmentRecord {
+  track: Track;
+  preserveExisting: boolean;
+  resolve: (success: boolean) => void;
+}
+
 interface MSEMediaSource {
   readyState: string;
   duration: number;
@@ -33,8 +41,16 @@ interface MSEMediaSource {
 
 export interface MediaSourceController {
   open(onOpen: () => void): void;
-  appendInit(track: Track, data: ArrayBuffer, codec: string, container: string): void;
+  appendInit(
+    track: Track,
+    data: ArrayBuffer,
+    codec: string,
+    container: string,
+    preserveExisting?: boolean,
+  ): Promise<boolean>;
   appendMedia(track: Track, data: ArrayBuffer, timestampOffset?: number): void;
+  /** Drop queued/future audio so a prepared alternate rendition can take over. */
+  replaceAudioFrom(seconds: number): void;
   /** Set the MediaSource duration (e.g. from an HLS VOD playlist) so seeks beyond buffered data are not clamped. */
   setDuration(seconds: number): void;
   endOfStream(): void;
@@ -76,7 +92,7 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
   let pendingDuration: number | null = null;
 
   // Deferred init segments: queued before sourceopen fires
-  let pendingSourceBufferInit: { track: Track; data: ArrayBuffer; codec: string; container: string }[] = [];
+  let pendingSourceBufferInit: PendingSourceBufferInit[] = [];
 
   let sourceOpenCallback: (() => void) | null = null;
 
@@ -102,11 +118,20 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
     return pendingRemoveRanges.video.length > 0 || pendingRemoveRanges.audio.length > 0;
   }
 
+  function discardPendingSourceBufferInits(track?: Track): void {
+    const retained: PendingSourceBufferInit[] = [];
+    for (const pending of pendingSourceBufferInit) {
+      if (track === undefined || pending.track === track) pending.resolve(false);
+      else retained.push(pending);
+    }
+    pendingSourceBufferInit = retained;
+  }
+
   function disableTrack(track: Track): void {
     disabledTracks.add(track);
     pendingSegments[track] = [];
     pendingRemoveRanges[track] = [];
-    pendingSourceBufferInit = pendingSourceBufferInit.filter((pending) => pending.track !== track);
+    discardPendingSourceBufferInits(track);
     lastInitSegments[track] = null;
   }
 
@@ -154,14 +179,21 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
   }
 
   function flushPendingSourceBufferInit(): void {
-    if (pendingSourceBufferInit.length === 0 || mediaSource?.readyState !== "open") {
+    if (
+      pendingSourceBufferInit.length === 0 ||
+      mediaSource?.readyState !== "open" ||
+      hasPendingRemoveRanges() ||
+      sourceBuffers.audio?.updating ||
+      sourceBuffers.video?.updating
+    ) {
       return;
     }
     const pendings = pendingSourceBufferInit;
     pendingSourceBufferInit = [];
     for (const pending of pendings) {
-      createSourceBuffer(pending.track, pending.codec, pending.container);
-      if (disabledTracks.has(pending.track)) {
+      if (!createSourceBuffer(pending.track, pending.codec, pending.container, pending.preserveExisting)) {
+        pendingSegments[pending.track] = pendingSegments[pending.track].filter((entry) => entry.data !== pending.data);
+        pending.resolve(false);
         continue;
       }
       lastInitSegments[pending.track] = {
@@ -169,6 +201,7 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
         codec: pending.codec,
         container: pending.container,
       };
+      pending.resolve(true);
     }
   }
 
@@ -307,6 +340,9 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
     tryApplyDuration();
     if (hasPendingRemoveRanges()) {
       doRemoveRanges();
+    } else if (pendingSourceBufferInit.length > 0) {
+      flushPendingSourceBufferInit();
+      tryAppendPending();
     } else if (hasPendingSegments()) {
       tryAppendPending();
     } else if (hasPendingEos) {
@@ -322,19 +358,41 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
     Log.e(TAG, `SourceBuffer Error:`, e);
   }
 
-  function createSourceBuffer(track: Track, codec: string, container: string): void {
+  function mimeTypeFor(codec: string, container: string): string {
+    return codec && codec.length > 0 ? `${container};codecs="${codec}"` : container;
+  }
+
+  function isMimeTypeSupported(mimeType: string): boolean {
+    const mediaSourceClass = (useManagedMediaSource ? selfRecord.ManagedMediaSource : selfRecord.MediaSource) as
+      | { isTypeSupported?: (type: string) => boolean }
+      | undefined;
+    return mediaSourceClass?.isTypeSupported?.(mimeType) !== false;
+  }
+
+  function reportSourceBufferSetupError(
+    action: string,
+    error: unknown,
+    track: Track,
+    codec: string,
+    preserveExisting: boolean,
+  ): false {
+    const exception = error as DOMException;
+    Log.e(TAG, `${action} failed: ${exception.message}`);
+    if (!preserveExisting && exception.name === "NotSupportedError") disableTrack(track);
+    mse.onError?.({ code: exception.code, msg: exception.message, name: exception.name, track, codec });
+    return false;
+  }
+
+  function createSourceBuffer(track: Track, codec: string, container: string, preserveExisting = false): boolean {
     if (disabledTracks.has(track)) {
-      return;
+      return false;
     }
     if (mediaSource?.readyState !== "open") {
-      return;
+      return false;
     }
 
-    let mimeType = container;
-    if (codec && codec.length > 0) {
-      // Quoting is required when the codec list contains commas (muxed fMP4 renditions)
-      mimeType += `;codecs="${codec}"`;
-    }
+    // Quoting is required when the codec list contains commas (muxed fMP4 renditions)
+    const mimeType = mimeTypeFor(codec, container);
 
     if (mimeType !== mimeTypes[track]) {
       const existing = sourceBuffers[track];
@@ -345,19 +403,9 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
           existing.changeType(mimeType);
           mimeTypes[track] = mimeType;
         } catch (error: unknown) {
-          Log.e(TAG, `changeType failed: ${(error as Error).message}`);
-          if ((error as DOMException).name === "NotSupportedError") {
-            disableTrack(track);
-          }
-          mse.onError?.({
-            code: (error as DOMException).code,
-            msg: (error as Error).message,
-            name: (error as DOMException).name,
-            track,
-            codec,
-          });
+          return reportSourceBufferSetupError("changeType", error, track, codec, preserveExisting);
         }
-        return;
+        return true;
       }
       try {
         const sb = mediaSource.addSourceBuffer(mimeType);
@@ -371,21 +419,11 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
         sb.addEventListener("error", errorHandler);
         sb.addEventListener("updateend", updateEndHandler);
       } catch (error: unknown) {
-        Log.e(TAG, (error as Error).message);
-        if ((error as DOMException).name === "NotSupportedError") {
-          disableTrack(track);
-        }
-        mse.onError?.({
-          code: (error as DOMException).code,
-          msg: (error as Error).message,
-          name: (error as DOMException).name,
-          track,
-          codec,
-        });
-        return;
+        return reportSourceBufferSetupError("addSourceBuffer", error, track, codec, preserveExisting);
       }
       mimeTypes[track] = mimeType;
     }
+    return true;
   }
 
   // --- The MSE object ---
@@ -492,26 +530,40 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
       video.src = objectURL;
     },
 
-    appendInit(track: Track, data: ArrayBuffer, codec: string, container: string): void {
+    appendInit(
+      track: Track,
+      data: ArrayBuffer,
+      codec: string,
+      container: string,
+      preserveExisting = false,
+    ): Promise<boolean> {
       if (disabledTracks.has(track)) {
-        return;
+        return Promise.resolve(false);
       }
-      if (mediaSource?.readyState !== "open" || mediaSource.streaming === false) {
-        pendingSourceBufferInit.push({ track, data, codec, container });
-        pendingSegments[track].push({ data });
-        return;
+      const mimeType = mimeTypeFor(codec, container);
+      if (!isMimeTypeSupported(mimeType)) {
+        if (!preserveExisting) disableTrack(track);
+        mse.onError?.({ code: 0, msg: `Unsupported MIME type: ${mimeType}`, name: "NotSupportedError", track, codec });
+        return Promise.resolve(false);
+      }
+      if (
+        mediaSource?.readyState !== "open" ||
+        mediaSource.streaming === false ||
+        hasPendingRemoveRanges() ||
+        sourceBuffers[track]?.updating
+      ) {
+        return new Promise((resolve) => {
+          pendingSourceBufferInit.push({ track, data, codec, container, preserveExisting, resolve });
+          pendingSegments[track].push({ data, isInit: true });
+        });
       }
 
-      const mimePreview = codec ? `${container};codecs="${codec}"` : container;
-      Log.v(TAG, `Received Initialization Segment, mimeType: ${mimePreview}`);
+      Log.v(TAG, `Received Initialization Segment, mimeType: ${mimeType}`);
+      if (!createSourceBuffer(track, codec, container, preserveExisting)) return Promise.resolve(false);
       lastInitSegments[track] = { data, codec, container };
-
-      createSourceBuffer(track, codec, container);
-      if (disabledTracks.has(track)) {
-        return;
-      }
-      pendingSegments[track].push({ data });
+      pendingSegments[track].push({ data, isInit: true });
       tryAppendPending();
+      return Promise.resolve(true);
     },
 
     appendMedia(track: Track, data: ArrayBuffer, timestampOffset?: number): void {
@@ -533,6 +585,20 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
       tryAppendPending();
     },
 
+    replaceAudioFrom(seconds: number): void {
+      const preparedInitIndex = pendingSegments.audio.findLastIndex((segment) => segment.isInit === true);
+      pendingSegments.audio = preparedInitIndex >= 0 ? pendingSegments.audio.slice(preparedInitIndex) : [];
+      const sb = sourceBuffers.audio;
+      if (!sb) return;
+      const start = Math.max(0, seconds);
+      for (let i = 0; i < sb.buffered.length; i++) {
+        const rangeStart = Math.max(start, sb.buffered.start(i));
+        const rangeEnd = sb.buffered.end(i);
+        if (rangeEnd > rangeStart) pendingRemoveRanges.audio.push({ start: rangeStart, end: rangeEnd });
+      }
+      if (!sb.updating) doRemoveRanges();
+    },
+
     setDuration(seconds: number): void {
       pendingDuration = seconds;
       tryApplyDuration();
@@ -557,6 +623,7 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
 
     destroy(): void {
       destroying = true;
+      discardPendingSourceBufferInits();
       if (mediaSource) {
         const ms = mediaSource;
         const tracks: Track[] = ["video", "audio"];
@@ -607,7 +674,6 @@ export function createMediaSourceController(video: HTMLVideoElement, config: Pla
         onEndStreamingHandler = null;
         onQualityChangeHandler = null;
 
-        pendingSourceBufferInit = [];
         disabledTracks.clear();
         isBufferFull = false;
         hasPendingEos = false;
diff --git a/web-ui/src/playback-engine/mse/playback-controller.ts b/web-ui/src/playback-engine/mse/playback-controller.ts
index 8ee1dbf0..240cd303 100644
--- a/web-ui/src/playback-engine/mse/playback-controller.ts
+++ b/web-ui/src/playback-engine/mse/playback-controller.ts
@@ -2,7 +2,7 @@ import { markPlaybackUnlocked, PCMAudioPlayer } from "../audio/pcm-audio-player"
 import type { PlayerConfig } from "../config";
 import { PlayerErrors } from "../errors";
 import { type LiveSessionAnchor, lagBehindLiveEdge } from "../timeline/wall-clock";
-import type { MSEPlaybackController, PlayerSegment } from "../types";
+import type { MSEPlaybackController, PlaybackLoadOptions, PlayerSegment } from "../types";
 import type { WorkerCommand, WorkerEvent } from "../worker/messages";
 import TransmuxWorker from "../worker/transmux-worker.ts?worker&inline";
 import { setupLiveSync } from "./live-sync";
@@ -35,7 +35,7 @@ export function createMSEPlaybackController(
   let mse: MediaSourceController | null = null;
   let worker: Worker | null = null;
   let workerInitialized = false;
-  let pendingSegments: PlayerSegment[] | null = null;
+  let pendingLoad: { segments: PlayerSegment[]; options?: PlaybackLoadOptions } | null = null;
   let destroyLiveSync: (() => void) | null = null;
   let mseGeneration = 0;
   let liveSyncEnabled = config.liveSync;
@@ -103,13 +103,23 @@ export function createMSEPlaybackController(
   // segment parse can complete (the append algorithm runs as a queued task).
   let pendingInits: { track: "video" | "audio"; data: ArrayBuffer; codec: string; container: string }[] = [];
 
-  function flushPendingInits(): void {
-    if (pendingInits.length === 0) return;
+  async function flushPendingInits(preserveExistingAudio = false): Promise<boolean> {
+    if (pendingInits.length === 0) return true;
     const inits = pendingInits;
     pendingInits = [];
-    for (const init of inits) {
-      mse?.appendInit(init.track, init.data, init.codec, init.container);
-    }
+    const results = await Promise.all(
+      inits.map(
+        (init) =>
+          mse?.appendInit(
+            init.track,
+            init.data,
+            init.codec,
+            init.container,
+            preserveExistingAudio && init.track === "audio",
+          ) ?? Promise.resolve(false),
+      ),
+    );
+    return results.every(Boolean);
   }
 
   function handleWorkerMessage(e: MessageEvent): void {
@@ -119,8 +129,8 @@ export function createMSEPlaybackController(
     if (msg.gen !== mseGeneration) return;
     // media-info can be posted right before an init-segment; flushing on it would
     // split the batched init appends (see comment above pendingInits)
-    if (msg.type !== "init-segment" && msg.type !== "media-info") {
-      flushPendingInits();
+    if (msg.type !== "init-segment" && msg.type !== "media-info" && msg.type !== "audio-track-switch") {
+      void flushPendingInits();
     }
     switch (msg.type) {
       case "init-segment":
@@ -139,6 +149,7 @@ export function createMSEPlaybackController(
           info: msg.info,
           code: msg.code,
           url: msg.url,
+          track: msg.track,
         });
         break;
       case "complete":
@@ -156,6 +167,27 @@ export function createMSEPlaybackController(
           updateFetchBackpressure();
         }
         break;
+      case "audio-tracks":
+        impl.onAudioTracksChange?.(msg.state);
+        break;
+      case "audio-track-switch": {
+        const switchGeneration = mseGeneration;
+        const switchWorker = worker;
+        void flushPendingInits(true).then((success) => {
+          if (switchGeneration !== mseGeneration || switchWorker !== worker) return;
+          if (success) {
+            mse?.replaceAudioFrom(msg.fromTime);
+            pcmPlayer?.replaceFrom(msg.pcmFromTime ?? msg.fromTime);
+          }
+          switchWorker?.postMessage({
+            type: "audio-track-switch-result",
+            trackId: msg.trackId,
+            success,
+            currentTime: video.currentTime,
+          } satisfies WorkerCommand);
+        });
+        break;
+      }
       case "pcm-audio-data": {
         const player = ensurePCMPlayer();
         const pcm = new Float32Array(msg.pcm);
@@ -355,16 +387,16 @@ export function createMSEPlaybackController(
     bufferFullPaused = false;
   }
 
-  function loadInWorker(segments: PlayerSegment[]): void {
+  function loadInWorker(segments: PlayerSegment[], options?: PlaybackLoadOptions): void {
     const w = ensureWorker();
     if (!workerInitialized) {
-      const initCmd: WorkerCommand = { type: "init", segments, config, gen: mseGeneration };
+      const initCmd: WorkerCommand = { type: "init", segments, options, config, gen: mseGeneration };
       w.postMessage(initCmd);
       const startCmd: WorkerCommand = { type: "start" };
       w.postMessage(startCmd);
       workerInitialized = true;
     } else {
-      const cmd: WorkerCommand = { type: "load-segments", segments, gen: mseGeneration };
+      const cmd: WorkerCommand = { type: "load-segments", segments, options, gen: mseGeneration };
       w.postMessage(cmd);
     }
   }
@@ -377,9 +409,9 @@ export function createMSEPlaybackController(
     }
 
     mse.open(() => {
-      if (pendingSegments) {
-        loadInWorker(pendingSegments);
-        pendingSegments = null;
+      if (pendingLoad) {
+        loadInWorker(pendingLoad.segments, pendingLoad.options);
+        pendingLoad = null;
       }
     });
 
@@ -464,10 +496,10 @@ export function createMSEPlaybackController(
   const impl: MSEPlaybackController = {
     onError: null,
 
-    loadSegments(segments: PlayerSegment[]) {
+    loadSegments(segments: PlayerSegment[], options?: PlaybackLoadOptions) {
       mseGeneration++;
       pendingInits = [];
-      pendingSegments = segments;
+      pendingLoad = { segments, options };
       sourceMode = inferSourceMode(segments);
       hlsLive = null;
       resetFetchBackpressure();
@@ -481,6 +513,14 @@ export function createMSEPlaybackController(
       initLiveHelpers();
     },
 
+    selectAudioTrack(trackId: string) {
+      worker?.postMessage({
+        type: "select-audio-track",
+        trackId,
+        currentTime: Math.max(0, video.currentTime),
+      } satisfies WorkerCommand);
+    },
+
     setLiveSync(enabled: boolean) {
       if (enabled && !destroyLiveSync) {
         liveSyncEnabled = true;
@@ -509,7 +549,7 @@ export function createMSEPlaybackController(
       mseGeneration++;
       resetFetchBackpressure();
       pendingInits = [];
-      pendingSegments = null;
+      pendingLoad = null;
       sourceMode = "static-ts-list";
       hlsLive = null;
       updateLiveState();
diff --git a/web-ui/src/playback-engine/remux/mp4-remuxer.ts b/web-ui/src/playback-engine/remux/mp4-remuxer.ts
index 19074420..06570dde 100644
--- a/web-ui/src/playback-engine/remux/mp4-remuxer.ts
+++ b/web-ui/src/playback-engine/remux/mp4-remuxer.ts
@@ -126,6 +126,7 @@ class MP4Remuxer {
   private _dtsBase: number;
   private _dtsBaseInited: boolean;
   private _dtsBaseOffset: number;
+  private _preserveInitialTimestamps: boolean;
   private _audioDtsBase: number;
   private _videoDtsBase: number;
   private _audioNextDts: number | undefined;
@@ -162,6 +163,7 @@ class MP4Remuxer {
     this._dtsBase = -1;
     this._dtsBaseInited = false;
     this._dtsBaseOffset = 0;
+    this._preserveInitialTimestamps = false;
     this._audioDtsBase = Infinity;
     this._videoDtsBase = Infinity;
     this._audioNextDts = undefined;
@@ -203,6 +205,7 @@ class MP4Remuxer {
   destroy(): void {
     this._dtsBase = -1;
     this._dtsBaseInited = false;
+    this._preserveInitialTimestamps = false;
     this._silentAudioMode = false;
     this._silentAudioLastDts = undefined;
     this._silentAudioDurationResidual = 0;
@@ -263,6 +266,44 @@ class MP4Remuxer {
     this._videoMediaSegmentEmitted = false;
   }
 
+  /** Reset only audio state when switching an elementary TS audio PID. */
+  resetAudioTrackForSwitch(nextDtsMs?: number): void {
+    this._audioNextDts = nextDtsMs;
+    this._audioStashedLastSample = null;
+    this._audioTiming = this._createTrackTimingState();
+    this._pcmTiming = this._createTrackTimingState();
+    this._audioMeta = null;
+    this._silentAudioMode = false;
+    this._silentAudioLastDts = undefined;
+    this._silentAudioDurationResidual = 0;
+    this._audioMediaSegmentEmitted = false;
+  }
+
+  /** Establish an audio-only MP2 PCM mapping while preserving the configured output offset. */
+  ensureAudioTimestampBase(originalPtsMs: number): void {
+    if (this._dtsBaseInited) return;
+    this._audioDtsBase = originalPtsMs;
+    this._dtsBase = originalPtsMs - this._dtsBaseOffset;
+    this._dtsBaseInited = true;
+  }
+
+  /** Emit silent AAC occupancy for software-decoded audio that has no colocated video samples. */
+  remuxSilentAudioRange(startMs: number, durationMs: number): void {
+    if (!this._silentAudioMode || durationMs <= 0) return;
+    this._generateSilentAudio([
+      {
+        dts: startMs,
+        pts: startMs,
+        cts: 0,
+        unit: new Uint8Array(),
+        size: 0,
+        duration: durationMs,
+        originalDts: startMs,
+        flags: { isLeading: 0, dependsOn: 1, isDependedOn: 0, hasRedundancy: 0 },
+      },
+    ]);
+  }
+
   setTsSegmentContinuityNormalization(enabled: boolean): void {
     this._tsSegmentContinuityNormalization = enabled;
   }
@@ -294,6 +335,7 @@ class MP4Remuxer {
     }
 
     if (timing.lastOriginalEndDts === undefined || timing.lastOutputEndDts === undefined) {
+      if (this._preserveInitialTimestamps) return 0;
       return firstSampleOriginalDts - this._dtsBaseOffset;
     }
 
@@ -359,6 +401,13 @@ class MP4Remuxer {
     this._dtsBaseOffset = offsetMs;
   }
 
+  /** Reuse another rendition's raw timestamp mapping instead of independently rebasing the first audio sample. */
+  setSharedTimestampBase(timestampBaseMs: number): void {
+    this._dtsBase = timestampBaseMs;
+    this._dtsBaseInited = true;
+    this._preserveInitialTimestamps = true;
+  }
+
   remux(audioTrack: DemuxTrack | null | undefined, videoTrack: DemuxTrack | null | undefined, force = false): void {
     if (!this._onMediaSegment) {
       throw new IllegalStateException("MP4Remuxer: onMediaSegment callback must be specificed!");
@@ -417,7 +466,12 @@ class MP4Remuxer {
     const videoEndDts = videoSamples[videoSamples.length - 1].dts + videoSamples[videoSamples.length - 1].duration;
 
     if (this._silentAudioLastDts === undefined) {
-      this._silentAudioLastDts = videoSamples[0].dts;
+      // During an internal PID switch, resetAudioTrackForSwitch() positions
+      // _audioNextDts at the requested splice point. Start the silent MSE
+      // occupancy there instead of at the next video batch, otherwise the
+      // audio SourceBuffer gets a hole and stalls video while MP2 is decoded
+      // through Web Audio.
+      this._silentAudioLastDts = this._audioNextDts ?? videoSamples[0].dts;
     }
 
     const samples: Array<{ unit: Uint8Array; dts: number; pts: number; duration: number }> = [];
@@ -754,6 +808,9 @@ class MP4Remuxer {
 
       if (originalDts < -0.001) {
         mdatBytes -= sample.length;
+        if (this._preserveInitialTimestamps) {
+          nextOutputDts += this._nextSampleDuration(this._audioTiming, refSampleDuration, 26);
+        }
         continue; //pass the first sample with the invalid dts
       }
 
@@ -841,6 +898,10 @@ class MP4Remuxer {
       segment.timestampOffset = firstDts;
     }
 
+    if (this._preserveInitialTimestamps && !this._audioMediaSegmentEmitted) {
+      Log.v(this.TAG, `Shared audio timeline begins at ${firstDts.toFixed(3)}ms`);
+    }
+
     this._onMediaSegment?.("audio", segment);
     this._audioMediaSegmentEmitted = true;
   }
diff --git a/web-ui/src/playback-engine/types.ts b/web-ui/src/playback-engine/types.ts
index 91e249d8..d1d1eb57 100644
--- a/web-ui/src/playback-engine/types.ts
+++ b/web-ui/src/playback-engine/types.ts
@@ -3,6 +3,31 @@ export interface PlayerSegment {
   duration?: number;
 }
 
+export interface PlayerAudioTrack {
+  /** Runtime identifier used when selecting this rendition. */
+  id: string;
+  /** Human-readable rendition name or a generated fallback. */
+  label: string;
+  language?: string;
+  isDefault: boolean;
+  /** Stable across signed/rotating rendition URLs; safe to persist per channel. */
+  preferenceKey: string;
+}
+
+export interface PlayerAudioTrackState {
+  tracks: PlayerAudioTrack[];
+  selectedTrackId?: string;
+  pendingTrackId?: string;
+}
+
+export interface PlaybackLoadOptions {
+  preferredAudioTrackKey?: string;
+}
+
+export function buildAudioTrackPreferenceKey(...parts: Array<string | undefined>): string {
+  return parts.map((part) => part?.trim().toLowerCase() ?? "").join("\u001f");
+}
+
 import type { PlayerErrorDetail } from "./errors";
 import type { LiveSessionAnchor } from "./timeline/wall-clock";
 
@@ -57,6 +82,8 @@ export interface PlayerEventMap {
   "audio-suspended": () => void;
   /** Fired when parsed or measured media metadata changes. */
   "media-info": (info: PlayerMediaInfo) => void;
+  /** Fired when HLS/native audio renditions or their selection state changes. */
+  "audio-tracks-change": (state: PlayerAudioTrackState) => void;
   /** Fired when WebGL activity or its confirmed deinterlacing state changes. */
   "render-state-change": (state: PlayerRenderState) => void;
   "playback-state-change": (state: "canplay" | "playing" | "paused" | "waiting", eventTimeStamp: number) => void;
@@ -81,7 +108,9 @@ export interface PlaybackBackendState {
 export interface PlaybackBackend {
   readonly kind: PlaybackBackendKind;
   readonly mediaElement: HTMLVideoElement;
-  loadSegments(segments: PlayerSegment[]): void;
+  loadSegments(segments: PlayerSegment[], options?: PlaybackLoadOptions): void;
+  /** Select an already-discovered audio rendition without rebuilding video playback. */
+  selectAudioTrack(trackId: string): void;
   play(): Promise<void>;
   pause(): void;
   setVolume(volume: number): void;
@@ -110,7 +139,9 @@ export interface MSEPlaybackController {
   onLiveStateChange?: ((isLive: boolean) => void) | null;
   onAudioSuspended?: (() => void) | null;
   onMediaInfo?: ((info: PlayerMediaInfo) => void) | null;
-  loadSegments(segments: PlayerSegment[]): void;
+  onAudioTracksChange?: ((state: PlayerAudioTrackState) => void) | null;
+  loadSegments(segments: PlayerSegment[], options?: PlaybackLoadOptions): void;
+  selectAudioTrack(trackId: string): void;
   seek(seconds: number): void;
   goLive(targetMseSeconds: number): void;
   setLiveSessionAnchor(anchor: LiveSessionAnchor): void;
diff --git a/web-ui/src/playback-engine/worker/messages.ts b/web-ui/src/playback-engine/worker/messages.ts
index 316f53f3..78c91d37 100644
--- a/web-ui/src/playback-engine/worker/messages.ts
+++ b/web-ui/src/playback-engine/worker/messages.ts
@@ -1,11 +1,13 @@
 import type { PlayerConfig } from "../config";
 import type { DemuxErrorDetail, LoaderErrorDetail } from "../errors";
-import type { PlayerMediaInfo, PlayerSegment } from "../types";
+import type { PlaybackLoadOptions, PlayerAudioTrackState, PlayerMediaInfo, PlayerSegment } from "../types";
 
 export type WorkerCommand =
-  | { type: "init"; segments: PlayerSegment[]; config: PlayerConfig; gen: number }
+  | { type: "init"; segments: PlayerSegment[]; options?: PlaybackLoadOptions; config: PlayerConfig; gen: number }
   | { type: "start" }
-  | { type: "load-segments"; segments: PlayerSegment[]; gen: number }
+  | { type: "load-segments"; segments: PlayerSegment[]; options?: PlaybackLoadOptions; gen: number }
+  | { type: "select-audio-track"; trackId: string; currentTime: number }
+  | { type: "audio-track-switch-result"; trackId: string; success: boolean; currentTime: number }
   | { type: "pause" }
   | { type: "resume" }
   | { type: "reset" }
@@ -23,9 +25,12 @@ export type WorkerEvent =
       info?: string;
       code?: number;
       url?: string;
+      track?: "video" | "audio";
       gen: number;
     }
   | { type: "hls-info"; live: boolean; totalDuration: number; gen: number }
+  | { type: "audio-tracks"; state: PlayerAudioTrackState; gen: number }
+  | { type: "audio-track-switch"; trackId: string; fromTime: number; pcmFromTime?: number; gen: number }
   | {
       type: "pcm-audio-data";
       pcm: ArrayBuffer;
diff --git a/web-ui/src/playback-engine/worker/pipeline.ts b/web-ui/src/playback-engine/worker/pipeline.ts
index 4761d0ce..b0d12268 100644
--- a/web-ui/src/playback-engine/worker/pipeline.ts
+++ b/web-ui/src/playback-engine/worker/pipeline.ts
@@ -1,7 +1,7 @@
 import type { PlayerConfig } from "../config";
 import { createDefaultConfig } from "../config";
 import { WorkerAudioDecoder } from "../decoder/worker-audio-decoder";
-import TSDemuxer from "../demux/ts-demuxer";
+import TSDemuxer, { type TSAudioTrackInfo } from "../demux/ts-demuxer";
 import { type DemuxErrorDetail, type LoaderErrorDetail, PlayerErrors } from "../errors";
 import {
   containsMoov,
@@ -11,7 +11,7 @@ import {
   probeFmp4,
   splitInitFromSegment,
 } from "../hls/fmp4";
-import { type HlsInfo, HlsRequestError, HlsSource } from "../hls/hls-source";
+import { type HlsInfo, HlsRequestError, HlsSource, type HlsSourceOptions } from "../hls/hls-source";
 import FetchLoader, { type LoaderErrorInfo } from "../io/fetch-loader";
 import { identifyAudioCodec, identifyVideoCodec } from "../media-codecs";
 import MP4Remuxer from "../remux/mp4-remuxer";
@@ -24,6 +24,12 @@ import {
   StaticSegmentSource,
 } from "./segment-source";
 
+export interface MediaTimelineAnchor {
+  kind: "mpegts" | "fmp4";
+  /** Raw media timestamp which maps to MSE timeline zero, in milliseconds. */
+  timestampBaseMs: number;
+}
+
 export interface PipelineCallbacks {
   onInitSegment: (
     type: string,
@@ -48,11 +54,24 @@ export interface PipelineCallbacks {
   onIOError: (type: LoaderErrorDetail, info: LoaderErrorInfo) => void;
   onDemuxError: (type: DemuxErrorDetail, info: string) => void;
   onHlsInfo: (info: HlsInfo) => void;
+  onTimelineAnchor: (anchor: MediaTimelineAnchor) => void;
+  onTsAudioTracks: (tracks: TSAudioTrackInfo[], selectedPid: number | undefined) => void;
+  /** Reports every selected TS audio PID's parsed source codec, even when unchanged from the previous PID. */
+  onTsAudioSourceCodec: (codec: string) => void;
   onMediaInfo: (info: PlayerMediaInfo) => void;
   /** `time` is normalized to the MSE timeline (seconds, same space as video.currentTime). */
   onPCMAudioData: (pcm: Float32Array, channels: number, sampleRate: number, time: number) => void;
 }
 
+export interface PipelineOptions extends HlsSourceOptions {
+  /** Restrict output to one track when consuming an alternate HLS rendition. */
+  forcedTrack?: "video" | "audio";
+  /** Select one elementary audio PID from an MPEG-TS program. */
+  selectedTsAudioPid?: number;
+  /** Preserve the primary rendition's raw timestamp mapping in an alternate audio pipeline. */
+  mediaTimelineAnchor?: MediaTimelineAnchor;
+}
+
 class LoadError extends Error {
   constructor(
     public errorType: LoaderErrorDetail,
@@ -122,7 +141,9 @@ class Pipeline {
   private _config: PlayerConfig;
   private _callbacks: PipelineCallbacks;
 
-  private _initialSegments: PlayerSegment[];
+  private readonly _initialSegments: PlayerSegment[];
+  private readonly _options: PipelineOptions;
+  private _forcedTrack: "video" | "audio" | undefined;
 
   /** Increments to invalidate the currently running load loop. */
   private _runId = 0;
@@ -149,6 +170,7 @@ class Pipeline {
   private _lastInitUrl: string | null = null;
   private _fmp4Timescales = new Map<number, number>();
   private _fmp4TimestampOffsetWarningLogged = false;
+  private _timelineAnchorSent = false;
 
   // --- player-facing media metadata ---
   private _mediaInfo: PlayerMediaInfo = {};
@@ -182,20 +204,23 @@ class Pipeline {
   /** Incremented on audio timing resets to invalidate decode callbacks queued before the reset. */
   private _audioGen = 0;
 
-  constructor(segments: PlayerSegment[], config: PlayerConfig, callbacks: PipelineCallbacks) {
+  constructor(
+    segments: PlayerSegment[],
+    config: PlayerConfig,
+    callbacks: PipelineCallbacks,
+    options: PipelineOptions = {},
+  ) {
     this._callbacks = callbacks;
     this._config = { ...createDefaultConfig(), ...config };
     this._initialSegments = segments;
+    this._options = options;
+    this._forcedTrack = options.forcedTrack;
   }
 
   start(): void {
     this._load(this._initialSegments);
   }
 
-  loadSegments(newSegments: PlayerSegment[]): void {
-    this._load(newSegments);
-  }
-
   pause(): void {
     this._paused = true;
     // Continuous live TS streams pause mid-fetch and resume with a fresh request.
@@ -213,6 +238,13 @@ class Pipeline {
     this._resumeGate = null;
   }
 
+  selectTsAudioPid(pid: number, switchTimeSeconds?: number): boolean {
+    if (!this._demuxer || !this._remuxer) return false;
+    this._remuxer.resetAudioTrackForSwitch(switchTimeSeconds === undefined ? undefined : switchTimeSeconds * 1000);
+    this._resetAudioDecodeState();
+    return this._demuxer.selectAudioPid(pid);
+  }
+
   destroy(): void {
     this._runId++;
     this._teardown();
@@ -470,8 +502,7 @@ class Pipeline {
     this._resetMediaInfo();
 
     // Reset WASM audio decoder state (clear stale mdct/qmf + carry from previous stream)
-    this._workerAudioDecoder?.reset();
-    this._resetAudioTiming();
+    this._resetAudioDecodeState();
 
     const firstSegment = segments[0];
     if (!firstSegment) return;
@@ -495,8 +526,9 @@ class Pipeline {
 
   private _startHls(url: string, preloaded?: { text: string; url: string }): void {
     this._sourceMode = "hls";
-    const hls = new HlsSource(url, this._config, preloaded);
+    const hls = new HlsSource(url, this._config, preloaded, this._options);
     hls.onInfo = (info) => {
+      if (!this._forcedTrack && info.selectedAudioTrackUrl) this._forcedTrack = "video";
       this._callbacks.onHlsInfo(info);
       this._handleHlsInfo(info);
     };
@@ -526,6 +558,7 @@ class Pipeline {
     this._lastInitUrl = null;
     this._fmp4Timescales = new Map();
     this._fmp4TimestampOffsetWarningLogged = false;
+    this._timelineAnchorSent = false;
     this._paused = false;
     this._sourceMode = "static-ts-list";
     this._resumeGate?.();
@@ -651,8 +684,7 @@ class Pipeline {
     }
     this._pendingDtsOffsetMs = startSeconds * 1000;
     // The output timeline restarts: stale carry bytes and the PTS anchor are invalid
-    this._workerAudioDecoder?.reset();
-    this._resetAudioTiming();
+    this._resetAudioDecodeState();
   }
 
   private _shouldAnchorSegment(meta: SegmentMeta): boolean {
@@ -664,8 +696,7 @@ class Pipeline {
     // remux batch is not mixed with the previous segment's tail.
     this._demuxer?.flushSegmentBoundary();
     this._remuxer?.flushStashedSamples();
-    this._workerAudioDecoder?.reset();
-    this._resetAudioTiming();
+    this._resetAudioDecodeState();
   }
 
   private _prepareContinuousLiveTsRestart(meta: SegmentMeta, ioctl: FetchLoader): void {
@@ -679,6 +710,11 @@ class Pipeline {
     ioctl.onDataArrival = (data, byteStart) => this._onInputChunk(meta, data, byteStart);
   }
 
+  private _resetAudioDecodeState(): void {
+    this._workerAudioDecoder?.reset();
+    this._resetAudioTiming();
+  }
+
   private _resetAudioTiming(): void {
     this._audioGen++;
     this._audioAnchorPtsMs = null;
@@ -687,6 +723,13 @@ class Pipeline {
     this._pendingPcm = [];
   }
 
+  private _emitTimelineAnchor(kind: MediaTimelineAnchor["kind"], timestampBaseMs: number): void {
+    if (this._timelineAnchorSent || !Number.isFinite(timestampBaseMs)) return;
+    this._timelineAnchorSent = true;
+    Log.v(this.TAG, `Timeline anchor kind=${kind} base=${timestampBaseMs.toFixed(3)}ms`);
+    this._callbacks.onTimelineAnchor({ kind, timestampBaseMs });
+  }
+
   private _loadSegment(meta: SegmentMeta): Promise<void> {
     const ioctl = new FetchLoader(
       {
@@ -789,15 +832,21 @@ class Pipeline {
     }
     const demuxer = new TSDemuxer(probeData as ConstructorParameters<typeof TSDemuxer>[0], {
       waitForInitialVideoKeyframe: shouldAnchor || !this._demuxer || !this._remuxer,
+      selectedAudioPid: this._options.selectedTsAudioPid,
     });
     this._demuxer = demuxer;
 
     if (!this._remuxer) {
       this._remuxer = new MP4Remuxer();
-      if (this._pendingDtsOffsetMs !== 0) {
-        this._remuxer.setDtsBaseOffset(this._pendingDtsOffsetMs);
-        this._pendingDtsOffsetMs = 0;
+      const sharedAnchor = this._options.mediaTimelineAnchor;
+      if (this._forcedTrack === "audio" && sharedAnchor?.kind === "mpegts") {
+        Log.v(this.TAG, `Applying shared MPEG-TS timestamp base ${sharedAnchor.timestampBaseMs.toFixed(3)}ms`);
+        this._remuxer.setSharedTimestampBase(sharedAnchor.timestampBaseMs);
+      } else {
+        const timelineOffsetMs = this._pendingDtsOffsetMs || meta.start * 1000;
+        if (timelineOffsetMs !== 0) this._remuxer.setDtsBaseOffset(timelineOffsetMs);
       }
+      this._pendingDtsOffsetMs = 0;
     }
     this._remuxer.setTsSegmentContinuityNormalization(false);
 
@@ -808,17 +857,17 @@ class Pipeline {
         this._remuxer?.flushStashedSamples();
         this._remuxer?.insertDiscontinuity();
       }
-      this._workerAudioDecoder?.reset();
-      this._resetAudioTiming();
+      this._resetAudioDecodeState();
     };
     demuxer.onPcr = (pcrBase, bytePosition, discontinuity) => {
       this._recordTsPcr(pcrBase, bytePosition, discontinuity);
     };
+    demuxer.onAudioTracks = (tracks, selectedPid) => this._callbacks.onTsAudioTracks(tracks, selectedPid);
 
     // Set up software audio decode callback when MP2 WASM URL is configured
-    if (this._config.wasmDecoders.mp2) {
+    if (this._config.wasmDecoders.mp2 && this._forcedTrack !== "video") {
       demuxer.onRawAudioData = (frame) => {
-        this._handleRawAudioFrame(frame);
+        this._handleRawAudioFrame(frame, this._forcedTrack === "audio" || !demuxer.hasVideo);
       };
     }
 
@@ -828,16 +877,36 @@ class Pipeline {
         onTrackMetadata: (...args: unknown[]) => void;
       },
     );
+    const remuxDataAvailable = demuxer.onDataAvailable;
+    if (this._forcedTrack && remuxDataAvailable) {
+      demuxer.onDataAvailable = (audioTrack, videoTrack, force) => {
+        if (this._forcedTrack === "audio") {
+          remuxDataAvailable(audioTrack, null, force);
+        } else {
+          remuxDataAvailable(null, videoTrack, force);
+        }
+      };
+    }
     const remuxTrackMetadata = demuxer.onTrackMetadata;
     demuxer.onTrackMetadata = (type, metadata) => {
+      if (this._forcedTrack && type !== this._forcedTrack) return;
+      if (type === "audio" && metadata && typeof metadata === "object") {
+        const audioMetadata = metadata as Record<string, unknown>;
+        const sourceCodec = audioMetadata.sourceCodec ?? audioMetadata.originalCodec ?? audioMetadata.codec;
+        if (typeof sourceCodec === "string") this._callbacks.onTsAudioSourceCodec(sourceCodec);
+      }
       this._handleTsTrackMetadata(type, metadata);
       remuxTrackMetadata?.(type, metadata);
     };
 
     this._remuxer.onInitSegment = (type, initSegment) => {
+      if (this._forcedTrack && type !== this._forcedTrack) return;
       this._callbacks.onInitSegment(type, initSegment as unknown as Parameters<PipelineCallbacks["onInitSegment"]>[1]);
     };
     this._remuxer.onMediaSegment = (type, mediaSegment) => {
+      if (this._forcedTrack && type !== this._forcedTrack) return;
+      const timestampBaseMs = this._remuxer?.getTimestampBase();
+      if (timestampBaseMs !== undefined) this._emitTimelineAnchor("mpegts", timestampBaseMs);
       this._callbacks.onMediaSegment(
         type,
         mediaSegment as unknown as Parameters<PipelineCallbacks["onMediaSegment"]>[1],
@@ -894,13 +963,17 @@ class Pipeline {
     const initInfo = parseInitSegment(data);
     this._fmp4Timescales = initInfo.timescales;
     this._fmp4TimestampOffsetWarningLogged = false;
-    for (const track of initInfo.tracks) {
+    const selectedTracks = this._forcedTrack
+      ? initInfo.tracks.filter((track) => track.type === this._forcedTrack)
+      : initInfo.tracks;
+    for (const track of selectedTracks) {
       this._handleFmp4TrackMetadata(track);
     }
-    const codec = initInfo.codecs.join(",") || this._hlsSource?.info.codecs || "";
-    this._callbacks.onInitSegment("video", {
-      type: "video",
-      container: "video/mp4",
+    const outputTrack = this._forcedTrack ?? "video";
+    const codec = selectedTracks.map((track) => track.codec).join(",") || this._hlsSource?.info.codecs || "";
+    this._callbacks.onInitSegment(outputTrack, {
+      type: outputTrack,
+      container: `${outputTrack}/mp4`,
       codec,
       data: toArrayBuffer(data),
     });
@@ -927,7 +1000,11 @@ class Pipeline {
       return undefined;
     }
 
-    const timestampOffset = (meta.start - segmentStart) * 1000;
+    const ownTimestampBaseMs = (segmentStart - meta.start) * 1000;
+    const sharedAnchor = this._options.mediaTimelineAnchor;
+    const timestampBaseMs = sharedAnchor?.kind === "fmp4" ? sharedAnchor.timestampBaseMs : ownTimestampBaseMs;
+    this._emitTimelineAnchor("fmp4", timestampBaseMs);
+    const timestampOffset = -timestampBaseMs;
     return Math.abs(timestampOffset) < 0.001 ? 0 : timestampOffset;
   }
 
@@ -963,8 +1040,9 @@ class Pipeline {
 
     if (media.byteLength > 0) {
       this._pendingDtsOffsetMs = 0;
-      this._callbacks.onMediaSegment("video", {
-        type: "video",
+      const outputTrack = this._forcedTrack ?? "video";
+      this._callbacks.onMediaSegment(outputTrack, {
+        type: outputTrack,
         data: toArrayBuffer(media),
         timestampOffset: this._getFmp4TimestampOffset(meta, media),
       });
@@ -973,7 +1051,10 @@ class Pipeline {
 
   // ---- MP2 software audio decode ----
 
-  private _handleRawAudioFrame(frame: { codec: "mp2"; data: Uint8Array; pts: number }): void {
+  private _handleRawAudioFrame(
+    frame: { codec: "mp2"; data: Uint8Array; pts: number },
+    needsOwnTimelineBase: boolean,
+  ): void {
     // Lazily create WorkerAudioDecoder on first raw audio frame
     if (!this._workerAudioDecoder) {
       const mp2Url = this._config.wasmDecoders.mp2;
@@ -1015,7 +1096,7 @@ class Pipeline {
       const ptsMs = this._audioAnchorPtsMs + (this._audioSamplesSinceAnchor / sr) * 1000;
       this._audioSamplesSinceAnchor += result.samplesPerChannel;
 
-      this._emitPcm(result.pcm, result.channels, sr, ptsMs);
+      this._emitPcm(result.pcm, result.channels, sr, ptsMs, needsOwnTimelineBase);
     });
   }
 
@@ -1024,8 +1105,15 @@ class Pipeline {
    * (the exact mapping used for video), then forward to the main thread.
    * PCM decoded before the first remux (dts base unknown) is queued.
    */
-  private _emitPcm(pcm: Float32Array, channels: number, sampleRate: number, ptsMs: number): void {
+  private _emitPcm(
+    pcm: Float32Array,
+    channels: number,
+    sampleRate: number,
+    ptsMs: number,
+    needsOwnTimelineBase: boolean,
+  ): void {
     const durationMs = (Math.floor(pcm.length / channels) / sampleRate) * 1000;
+    if (needsOwnTimelineBase) this._remuxer?.ensureAudioTimestampBase(ptsMs);
     this._pendingPcm.push({ pcm, channels, sampleRate, ptsMs, durationMs });
 
     if (this._remuxer?.getTimestampBase() === undefined) {
@@ -1064,6 +1152,12 @@ class Pipeline {
           pcm = pcm.slice(cutFrames * item.channels);
         }
       }
+      if (this._forcedTrack === "audio") {
+        this._remuxer?.remuxSilentAudioRange(
+          mapping.time * 1000,
+          (pcm.length / item.channels / item.sampleRate) * 1000,
+        );
+      }
       this._callbacks.onPCMAudioData(pcm, item.channels, item.sampleRate, mapping.time);
     }
   }
diff --git a/web-ui/src/playback-engine/worker/transmux-worker.ts b/web-ui/src/playback-engine/worker/transmux-worker.ts
index 2b8bd6a3..9d989587 100644
--- a/web-ui/src/playback-engine/worker/transmux-worker.ts
+++ b/web-ui/src/playback-engine/worker/transmux-worker.ts
@@ -1,11 +1,68 @@
 import type { PlayerConfig } from "../config";
-import type { PlayerSegment } from "../types";
+import type { TSAudioTrackInfo } from "../demux/ts-demuxer";
+import type { HlsInfo } from "../hls/hls-source";
+import type {
+  PlaybackLoadOptions,
+  PlayerAudioTrack,
+  PlayerAudioTrackState,
+  PlayerMediaInfo,
+  PlayerSegment,
+} from "../types";
+import { buildAudioTrackPreferenceKey } from "../types";
 import Log from "../utils/logger";
 import type { WorkerCommand, WorkerEvent } from "./messages";
-import Pipeline, { type PipelineCallbacks } from "./pipeline";
+import Pipeline, { type MediaTimelineAnchor, type PipelineCallbacks } from "./pipeline";
 
-let pipeline: Pipeline | null = null;
+type OutputEvent =
+  | { kind: "init"; track: "video" | "audio"; data: ArrayBuffer; codec: string; container: string }
+  | { kind: "media"; track: "video" | "audio"; data: ArrayBuffer; timestampOffset?: number };
+
+let primaryPipeline: Pipeline | null = null;
+let audioPipeline: Pipeline | null = null;
+let pendingAudioPipeline: Pipeline | null = null;
+let config: PlayerConfig | null = null;
 let gen = 0;
+let started = false;
+
+let audioTracks: PlayerAudioTrack[] = [];
+let audioTrackUrls = new Map<string, string>();
+let hasHlsAudioGroup = false;
+let tsAudioTrackPids = new Map<string, number>();
+let selectedAudioTrackId: string | undefined;
+let pendingAudioTrackId: string | undefined;
+let timelineProgramDateTime: number | undefined;
+let liveEdgeDistance: number | undefined;
+let mediaTimelineAnchor: MediaTimelineAnchor | undefined;
+let pendingInitialAudioInfo: HlsInfo | undefined;
+let completePendingAudioSwitch: ((trackId: string, success: boolean, currentTime: number) => void) | null = null;
+
+interface PendingInternalAudioSwitch {
+  trackId: string;
+  oldTrackId: string;
+  oldPid: number;
+  queued: OutputEvent[];
+  pcm: Array<{ pcm: Float32Array; channels: number; sampleRate: number; time: number }>;
+  audioMode: "pending" | "mse" | "pcm";
+  mediaReady: boolean;
+  prepared: boolean;
+  fromTime: number;
+}
+
+let pendingInternalAudioSwitch: PendingInternalAudioSwitch | null = null;
+
+let primaryMediaInfo: PlayerMediaInfo = {};
+let audioMediaInfo: PlayerMediaInfo = {};
+let primaryComplete = false;
+let audioComplete = true;
+
+// Some browsers must see both SourceBuffers before either init is parsed. When
+// an alternate audio rendition is present, hold initial output until its init
+// segment is ready, then post all init segments ahead of media segments.
+let initialOutputGated = false;
+let primaryInitSeen = false;
+let audioInitSeen = false;
+let primaryOutputQueue: OutputEvent[] = [];
+let audioOutputQueue: OutputEvent[] = [];
 
 function post(msg: WorkerEvent, transfer?: Transferable[]): void {
   if (transfer) {
@@ -15,92 +72,588 @@ function post(msg: WorkerEvent, transfer?: Transferable[]): void {
   }
 }
 
-function createPipeline(segments: PlayerSegment[], config: PlayerConfig): Pipeline {
+function forEachPipeline(action: (pipeline: Pipeline) => void): void {
+  for (const pipeline of [primaryPipeline, audioPipeline, pendingAudioPipeline]) {
+    if (pipeline) action(pipeline);
+  }
+}
+
+function postOutput(event: OutputEvent): void {
+  if (event.kind === "init") {
+    post(
+      {
+        type: "init-segment",
+        track: event.track,
+        data: event.data,
+        codec: event.codec,
+        container: event.container,
+        gen,
+      },
+      [event.data],
+    );
+    return;
+  }
+  post(
+    {
+      type: "media-segment",
+      track: event.track,
+      data: event.data,
+      timestampOffset: event.timestampOffset,
+      gen,
+    },
+    [event.data],
+  );
+}
+
+function postOutputEvents(events: readonly OutputEvent[], kind: OutputEvent["kind"]): void {
+  for (const event of events) {
+    if (event.kind === kind) postOutput(event);
+  }
+}
+
+function postPCMAudio(pcm: Float32Array, channels: number, sampleRate: number, time: number): void {
+  const buffer = pcm.buffer as ArrayBuffer;
+  post({ type: "pcm-audio-data", pcm: buffer, channels, sampleRate, time, gen }, [buffer]);
+}
+
+function flushInitialOutput(force = false): void {
+  if (!initialOutputGated) return;
+  if (!force && (!primaryInitSeen || !audioInitSeen)) return;
+  initialOutputGated = false;
+  const events = [...primaryOutputQueue, ...audioOutputQueue];
+  primaryOutputQueue = [];
+  audioOutputQueue = [];
+  postOutputEvents(events, "init");
+  postOutputEvents(events, "media");
+}
+
+function emitAudioTrackState(): void {
+  const state: PlayerAudioTrackState = {
+    tracks: audioTracks,
+    selectedTrackId: selectedAudioTrackId,
+    pendingTrackId: pendingAudioTrackId,
+  };
+  post({ type: "audio-tracks", state, gen });
+}
+
+function emitMergedMediaInfo(): void {
+  post({
+    type: "media-info",
+    info: {
+      ...primaryMediaInfo,
+      audio: audioMediaInfo.audio ?? primaryMediaInfo.audio,
+    },
+    gen,
+  });
+}
+
+function maybeComplete(): void {
+  if (primaryComplete && audioComplete) post({ type: "complete", gen });
+}
+
+function outputFromInit(type: string, initSegment: Parameters<PipelineCallbacks["onInitSegment"]>[1]): OutputEvent {
+  return {
+    kind: "init",
+    track: type as "video" | "audio",
+    data: initSegment.data as ArrayBuffer,
+    codec: initSegment.codec ?? "",
+    container: initSegment.container,
+  };
+}
+
+function outputFromMedia(type: string, mediaSegment: Parameters<PipelineCallbacks["onMediaSegment"]>[1]): OutputEvent {
+  return {
+    kind: "media",
+    track: type as "video" | "audio",
+    data: mediaSegment.data as ArrayBuffer,
+    timestampOffset: mediaSegment.timestampOffset,
+  };
+}
+
+function postPipelineError(
+  category: "io" | "demux",
+  detail: Parameters<PipelineCallbacks["onIOError"]>[0] | Parameters<PipelineCallbacks["onDemuxError"]>[0],
+  info: { msg?: string; code?: number; url?: string },
+  track?: "video" | "audio",
+): void {
+  post({
+    type: "error",
+    category,
+    detail,
+    info: info.msg,
+    code: info.code,
+    url: info.url,
+    track,
+    gen,
+  });
+}
+
+function createAudioPipeline(
+  url: string,
+  options: {
+    liveTimelineOffset?: number;
+    startTime?: number;
+    programDateTimeAnchor?: number;
+    liveEdgeDistance?: number;
+    mediaTimelineAnchor?: MediaTimelineAnchor;
+  },
+): Pipeline {
+  if (!config) throw new Error("Worker has not been initialized");
+  audioComplete = false;
   const callbacks: PipelineCallbacks = {
     onInitSegment(type, initSegment) {
-      const data = initSegment.data as ArrayBuffer;
-      post(
-        {
-          type: "init-segment",
-          track: type as "video" | "audio",
-          data,
-          codec: initSegment.codec ?? "",
-          container: initSegment.container,
-          gen,
-        },
-        [data],
-      );
+      const event = outputFromInit(type, initSegment);
+      if (initialOutputGated) {
+        audioOutputQueue.push(event);
+        audioInitSeen = true;
+        flushInitialOutput();
+      } else {
+        postOutput(event);
+      }
     },
     onMediaSegment(type, mediaSegment) {
-      const data = mediaSegment.data as ArrayBuffer;
-      post(
-        {
-          type: "media-segment",
-          track: type as "video" | "audio",
-          data,
-          timestampOffset: mediaSegment.timestampOffset,
-          gen,
-        },
-        [data],
-      );
+      const event = outputFromMedia(type, mediaSegment);
+      if (initialOutputGated) audioOutputQueue.push(event);
+      else postOutput(event);
     },
     onLoadingComplete() {
-      post({ type: "complete", gen });
+      audioComplete = true;
+      maybeComplete();
     },
     onIOError(type, info) {
-      post({ type: "error", category: "io", detail: type, info: info.msg, code: info.code, url: info.url, gen });
+      audioComplete = true;
+      flushInitialOutput(true);
+      postPipelineError("io", type, info, "audio");
+      maybeComplete();
     },
     onDemuxError(type, info) {
-      post({ type: "error", category: "demux", detail: type, info, gen });
+      audioComplete = true;
+      flushInitialOutput(true);
+      postPipelineError("demux", type, { msg: info }, "audio");
+      maybeComplete();
+    },
+    onHlsInfo() {},
+    onTimelineAnchor() {},
+    onTsAudioTracks() {},
+    onTsAudioSourceCodec() {},
+    onMediaInfo(info) {
+      audioMediaInfo = info;
+      emitMergedMediaInfo();
+    },
+    onPCMAudioData(pcm, channels, sampleRate, time) {
+      postPCMAudio(pcm, channels, sampleRate, time);
+    },
+  };
+  return new Pipeline([{ url, duration: 0 }], config, callbacks, { forcedTrack: "audio", ...options });
+}
+
+function startInitialAudio(info: HlsInfo, anchor: MediaTimelineAnchor): void {
+  const url = info.selectedAudioTrackUrl;
+  if (!url) return;
+  audioPipeline?.destroy();
+  audioPipeline = createAudioPipeline(url, {
+    programDateTimeAnchor: info.timelineProgramDateTime,
+    liveEdgeDistance: info.liveEdgeDistance,
+    mediaTimelineAnchor: anchor,
+  });
+  audioPipeline.start();
+  if (!started) audioPipeline.pause();
+}
+
+function maybeStartInitialAudio(): void {
+  if (!pendingInitialAudioInfo || !mediaTimelineAnchor) return;
+  const info = pendingInitialAudioInfo;
+  pendingInitialAudioInfo = undefined;
+  startInitialAudio(info, mediaTimelineAnchor);
+}
+
+function handlePrimaryTimelineAnchor(anchor: MediaTimelineAnchor): void {
+  mediaTimelineAnchor = anchor;
+  maybeStartInitialAudio();
+}
+
+function handlePrimaryHlsInfo(info: HlsInfo): void {
+  post({ type: "hls-info", live: info.live, totalDuration: info.totalDuration, gen });
+  audioTracks = info.audioTracks ?? [];
+  audioTrackUrls = new Map(Object.entries(info.audioTrackUrls ?? {}));
+  hasHlsAudioGroup = info.hasAudioGroup ?? false;
+  selectedAudioTrackId = info.selectedAudioTrackId;
+  timelineProgramDateTime = info.timelineProgramDateTime;
+  liveEdgeDistance = info.liveEdgeDistance;
+  pendingAudioTrackId = undefined;
+  emitAudioTrackState();
+  if (info.selectedAudioTrackUrl) {
+    initialOutputGated = true;
+    pendingInitialAudioInfo = info;
+    maybeStartInitialAudio();
+  }
+}
+
+function tsAudioTrackId(pid: number): string {
+  return `ts:${pid}`;
+}
+
+function tsAudioPreferenceKey(track: TSAudioTrackInfo): string {
+  return buildAudioTrackPreferenceKey(tsAudioTrackId(track.pid), track.language, track.codec);
+}
+
+function preferredTsAudioPid(preferenceKey: string | undefined): number | undefined {
+  if (!preferenceKey?.startsWith("ts:")) return undefined;
+  const pid = Number.parseInt(preferenceKey.slice(3).split("\u001f", 1)[0], 10);
+  return Number.isInteger(pid) && pid >= 0 ? pid : undefined;
+}
+
+function handlePrimaryTsAudioTracks(tracks: TSAudioTrackInfo[], selectedPid: number | undefined): void {
+  // An EXT-X-MEDIA group is authoritative; audio PIDs accidentally present in
+  // its video rendition must not leak into the user-facing track list.
+  if (hasHlsAudioGroup) return;
+
+  tsAudioTrackPids = new Map(tracks.map((track) => [tsAudioTrackId(track.pid), track.pid]));
+  audioTracks = tracks.map((track, index) => ({
+    id: tsAudioTrackId(track.pid),
+    label: track.language || `Audio ${index + 1}`,
+    language: track.language,
+    isDefault: index === 0,
+    preferenceKey: tsAudioPreferenceKey(track),
+  }));
+  if (!pendingInternalAudioSwitch)
+    selectedAudioTrackId = selectedPid === undefined ? undefined : tsAudioTrackId(selectedPid);
+  emitAudioTrackState();
+}
+
+function prepareInternalAudioSwitch(): void {
+  const pending = pendingInternalAudioSwitch;
+  if (
+    !pending ||
+    pending.prepared ||
+    !pending.mediaReady ||
+    pending.audioMode === "pending" ||
+    (pending.audioMode === "pcm" && pending.pcm.length === 0)
+  )
+    return;
+  pending.prepared = true;
+  postOutputEvents(pending.queued, "init");
+  post({
+    type: "audio-track-switch",
+    trackId: pending.trackId,
+    fromTime: pending.fromTime,
+    pcmFromTime: pending.audioMode === "pcm" ? pending.pcm[0].time : pending.fromTime,
+    gen,
+  });
+}
+
+function selectInternalAudioTrack(trackId: string, pid: number, currentTime: number): void {
+  if (!primaryPipeline || !selectedAudioTrackId) return;
+  const oldTrackId = selectedAudioTrackId;
+  const oldPid = tsAudioTrackPids.get(oldTrackId);
+  if (oldPid === undefined) return;
+
+  pendingAudioTrackId = trackId;
+  pendingInternalAudioSwitch = {
+    trackId,
+    oldTrackId,
+    oldPid,
+    queued: [],
+    pcm: [],
+    audioMode: "pending",
+    mediaReady: false,
+    prepared: false,
+    fromTime: currentTime,
+  };
+  emitAudioTrackState();
+
+  completePendingAudioSwitch = (resultTrackId, success, resultTime) => {
+    const pending = pendingInternalAudioSwitch;
+    if (!pending || resultTrackId !== pending.trackId) return;
+    completePendingAudioSwitch = null;
+    pendingInternalAudioSwitch = null;
+    pendingAudioTrackId = undefined;
+    if (!success) {
+      primaryPipeline?.selectTsAudioPid(pending.oldPid, resultTime);
+      selectedAudioTrackId = pending.oldTrackId;
+      emitAudioTrackState();
+      return;
+    }
+
+    selectedAudioTrackId = pending.trackId;
+    emitAudioTrackState();
+    postOutputEvents(pending.queued, "media");
+    for (const item of pending.pcm) {
+      postPCMAudio(item.pcm, item.channels, item.sampleRate, item.time);
+    }
+  };
+
+  if (!primaryPipeline.selectTsAudioPid(pid, currentTime)) {
+    completePendingAudioSwitch = null;
+    pendingInternalAudioSwitch = null;
+    pendingAudioTrackId = undefined;
+    emitAudioTrackState();
+  }
+}
+
+function createPrimaryPipeline(segments: PlayerSegment[], loadOptions: PlaybackLoadOptions | undefined): Pipeline {
+  if (!config) throw new Error("Worker has not been initialized");
+  const callbacks: PipelineCallbacks = {
+    onInitSegment(type, initSegment) {
+      const event = outputFromInit(type, initSegment);
+      if (type === "audio" && pendingInternalAudioSwitch) {
+        pendingInternalAudioSwitch.queued.push(event);
+        return;
+      }
+      if (initialOutputGated) {
+        primaryOutputQueue.push(event);
+        primaryInitSeen = true;
+        flushInitialOutput();
+      } else postOutput(event);
+    },
+    onMediaSegment(type, mediaSegment) {
+      const event = outputFromMedia(type, mediaSegment);
+      if (type === "audio" && pendingInternalAudioSwitch) {
+        pendingInternalAudioSwitch.queued.push(event);
+        pendingInternalAudioSwitch.mediaReady = true;
+        prepareInternalAudioSwitch();
+        return;
+      }
+      if (initialOutputGated) primaryOutputQueue.push(event);
+      else postOutput(event);
+    },
+    onLoadingComplete() {
+      primaryComplete = true;
+      maybeComplete();
+    },
+    onIOError(type, info) {
+      postPipelineError("io", type, info, "video");
+    },
+    onDemuxError(type, info) {
+      postPipelineError("demux", type, { msg: info }, "video");
+    },
+    onHlsInfo: handlePrimaryHlsInfo,
+    onTimelineAnchor: handlePrimaryTimelineAnchor,
+    onTsAudioTracks: handlePrimaryTsAudioTracks,
+    onTsAudioSourceCodec(codec) {
+      const pending = pendingInternalAudioSwitch;
+      if (!pending) return;
+      pending.audioMode = codec.toLowerCase() === "mp2" ? "pcm" : "mse";
+      prepareInternalAudioSwitch();
+    },
+    onMediaInfo(info) {
+      primaryMediaInfo = info;
+      emitMergedMediaInfo();
+    },
+    onPCMAudioData(pcm, channels, sampleRate, time) {
+      if (pendingInternalAudioSwitch) {
+        pendingInternalAudioSwitch.pcm.push({ pcm, channels, sampleRate, time });
+        prepareInternalAudioSwitch();
+        return;
+      }
+      postPCMAudio(pcm, channels, sampleRate, time);
+    },
+  };
+  return new Pipeline(segments, config, callbacks, {
+    preferredAudioTrackKey: loadOptions?.preferredAudioTrackKey,
+    selectedTsAudioPid: preferredTsAudioPid(loadOptions?.preferredAudioTrackKey),
+  });
+}
+
+function resetPipelines(): void {
+  forEachPipeline((pipeline) => pipeline.destroy());
+  primaryPipeline = null;
+  audioPipeline = null;
+  pendingAudioPipeline = null;
+  audioTracks = [];
+  audioTrackUrls.clear();
+  hasHlsAudioGroup = false;
+  tsAudioTrackPids.clear();
+  selectedAudioTrackId = undefined;
+  pendingAudioTrackId = undefined;
+  timelineProgramDateTime = undefined;
+  liveEdgeDistance = undefined;
+  mediaTimelineAnchor = undefined;
+  pendingInitialAudioInfo = undefined;
+  completePendingAudioSwitch = null;
+  pendingInternalAudioSwitch = null;
+  primaryMediaInfo = {};
+  audioMediaInfo = {};
+  primaryComplete = false;
+  audioComplete = true;
+  initialOutputGated = false;
+  primaryInitSeen = false;
+  audioInitSeen = false;
+  primaryOutputQueue = [];
+  audioOutputQueue = [];
+}
+
+function load(segments: PlayerSegment[], options?: PlaybackLoadOptions): void {
+  resetPipelines();
+  emitAudioTrackState();
+  primaryPipeline = createPrimaryPipeline(segments, options);
+  if (started) primaryPipeline.start();
+}
+
+function selectAudioTrack(trackId: string, currentTime: number): void {
+  if (!config || trackId === selectedAudioTrackId || trackId === pendingAudioTrackId) return;
+  const tsPid = tsAudioTrackPids.get(trackId);
+  if (tsPid !== undefined) {
+    selectInternalAudioTrack(trackId, tsPid, currentTime);
+    return;
+  }
+  const url = audioTrackUrls.get(trackId);
+  if (!url) return;
+
+  pendingAudioPipeline?.destroy();
+  pendingAudioTrackId = trackId;
+  emitAudioTrackState();
+
+  const queued: OutputEvent[] = [];
+  let candidate: Pipeline;
+  let committed = false;
+  let prepared = false;
+  let hasMedia = false;
+  let candidateComplete = false;
+  let switchBoundary = currentTime;
+  let candidateMediaInfo: PlayerMediaInfo = {};
+
+  const fail = (
+    category: "io" | "demux",
+    detail: Parameters<PipelineCallbacks["onIOError"]>[0] | Parameters<PipelineCallbacks["onDemuxError"]>[0],
+    info: { msg?: string; code?: number; url?: string },
+  ) => {
+    if (committed || pendingAudioPipeline !== candidate) return;
+    candidate.destroy();
+    pendingAudioPipeline = null;
+    pendingAudioTrackId = undefined;
+    completePendingAudioSwitch = null;
+    emitAudioTrackState();
+    postPipelineError(category, detail, info, "audio");
+  };
+
+  const prepare = () => {
+    if (prepared || pendingAudioPipeline !== candidate) return;
+    prepared = true;
+    postOutputEvents(queued, "init");
+    post({ type: "audio-track-switch", trackId, fromTime: switchBoundary, gen });
+  };
+
+  completePendingAudioSwitch = (resultTrackId, success) => {
+    if (resultTrackId !== trackId || committed || pendingAudioPipeline !== candidate) return;
+    completePendingAudioSwitch = null;
+    if (!success) {
+      candidate.destroy();
+      pendingAudioPipeline = null;
+      pendingAudioTrackId = undefined;
+      emitAudioTrackState();
+      return;
+    }
+    committed = true;
+    audioComplete = candidateComplete;
+    audioPipeline?.destroy();
+    audioPipeline = candidate;
+    pendingAudioPipeline = null;
+    selectedAudioTrackId = trackId;
+    pendingAudioTrackId = undefined;
+    audioMediaInfo = candidateMediaInfo;
+    emitMergedMediaInfo();
+    emitAudioTrackState();
+    postOutputEvents(queued, "media");
+    queued.length = 0;
+    maybeComplete();
+  };
+
+  const callbacks: PipelineCallbacks = {
+    onInitSegment(type, initSegment) {
+      if (committed) postOutput(outputFromInit(type, initSegment));
+      else queued.push(outputFromInit(type, initSegment));
+    },
+    onMediaSegment(type, mediaSegment) {
+      if (committed) postOutput(outputFromMedia(type, mediaSegment));
+      else {
+        hasMedia = true;
+        queued.push(outputFromMedia(type, mediaSegment));
+        prepare();
+      }
+    },
+    onLoadingComplete() {
+      candidateComplete = true;
+      if (!hasMedia) fail("demux", "FormatError", { msg: "Selected audio rendition contains no media" });
+      else if (committed) {
+        audioComplete = true;
+        maybeComplete();
+      }
+    },
+    onIOError(type, info) {
+      fail("io", type, info);
+    },
+    onDemuxError(type, info) {
+      fail("demux", type, { msg: info });
     },
     onHlsInfo(info) {
-      post({ type: "hls-info", live: info.live, totalDuration: info.totalDuration, gen });
+      switchBoundary = info.playbackStartTime ?? currentTime;
     },
+    onTimelineAnchor() {},
+    onTsAudioTracks() {},
+    onTsAudioSourceCodec() {},
     onMediaInfo(info) {
-      post({ type: "media-info", info, gen });
+      candidateMediaInfo = info;
+      if (committed) {
+        audioMediaInfo = info;
+        emitMergedMediaInfo();
+      }
     },
     onPCMAudioData(pcm, channels, sampleRate, time) {
-      const buffer = pcm.buffer as ArrayBuffer;
-      post({ type: "pcm-audio-data", pcm: buffer, channels, sampleRate, time, gen }, [buffer]);
+      if (!committed) return;
+      postPCMAudio(pcm, channels, sampleRate, time);
     },
   };
 
-  return new Pipeline(segments, config, callbacks);
+  candidate = new Pipeline([{ url, duration: 0 }], config, callbacks, {
+    forcedTrack: "audio",
+    liveTimelineOffset: currentTime,
+    startTime: currentTime,
+    programDateTimeAnchor:
+      timelineProgramDateTime === undefined ? undefined : timelineProgramDateTime + currentTime * 1000,
+    liveEdgeDistance,
+    mediaTimelineAnchor,
+  });
+  pendingAudioPipeline = candidate;
+  candidate.start();
 }
 
 self.addEventListener("message", (e: MessageEvent) => {
   const cmd = e.data as WorkerCommand;
-
   switch (cmd.type) {
     case "init":
       gen = cmd.gen;
+      config = cmd.config;
       Log.setLogLevel(cmd.config.logLevel);
-      pipeline = createPipeline(cmd.segments, cmd.config);
+      load(cmd.segments, cmd.options);
       break;
     case "start":
-      pipeline?.start();
+      started = true;
+      primaryPipeline?.start();
       break;
     case "load-segments":
       gen = cmd.gen;
-      pipeline?.loadSegments(cmd.segments);
+      load(cmd.segments, cmd.options);
+      break;
+    case "select-audio-track":
+      selectAudioTrack(cmd.trackId, cmd.currentTime);
+      break;
+    case "audio-track-switch-result":
+      completePendingAudioSwitch?.(cmd.trackId, cmd.success, cmd.currentTime);
       break;
     case "pause":
-      pipeline?.pause();
+      forEachPipeline((pipeline) => pipeline.pause());
       break;
     case "resume":
-      pipeline?.resume();
+      forEachPipeline((pipeline) => pipeline.resume());
       break;
     case "reset":
-      if (pipeline) {
-        pipeline.destroy();
-        pipeline = null;
-      }
+      resetPipelines();
+      started = false;
       break;
     case "destroy":
-      if (pipeline) {
-        pipeline.destroy();
-        pipeline = null;
-      }
+      resetPipelines();
+      started = false;
       (self as unknown as { postMessage(msg: unknown): void }).postMessage({ type: "destroyed" });
       break;
   }