diff --git a/.changeset/streaming-hbo-adapter.md b/.changeset/streaming-hbo-adapter.md
new file mode 100644
index 000000000..dac175958
--- /dev/null
+++ b/.changeset/streaming-hbo-adapter.md
@@ -0,0 +1,5 @@
+---
+"@read-frog/extension": patch
+---
+
+Add HBO Max / Max as a second streaming subtitle adapter on the shared framework. It captures HBO's official WebVTT subtitle requests (and DASH manifests listing segmented WebVTT tracks), then reuses the same source/target selection and bilingual alignment as the Netflix adapter — no new plumbing, just one more adapter in the registry.
diff --git a/src/entrypoints/interceptor.content/index.ts b/src/entrypoints/interceptor.content/index.ts
index 2c0bc8fc5..a3ac1de37 100644
--- a/src/entrypoints/interceptor.content/index.ts
+++ b/src/entrypoints/interceptor.content/index.ts
@@ -3,7 +3,7 @@ import { injectPlayerApi } from "./inject-player-api"
 import { injectStreamingSubtitlesInterceptor } from "./streaming-subtitles-interceptor"
 
 export default defineContentScript({
-  matches: ["*://*.youtube.com/*", "*://*.youtube-nocookie.com/*", "*://*.netflix.com/*"],
+  matches: ["*://*.youtube.com/*", "*://*.youtube-nocookie.com/*", "*://*.netflix.com/*", "*://*.max.com/*", "*://*.hbomax.com/*"],
   allFrames: true,
   world: "MAIN",
   runAt: "document_start",
diff --git a/src/entrypoints/interceptor.content/streaming-subtitles-interceptor.ts b/src/entrypoints/interceptor.content/streaming-subtitles-interceptor.ts
index 67b2b193b..32efa7170 100644
--- a/src/entrypoints/interceptor.content/streaming-subtitles-interceptor.ts
+++ b/src/entrypoints/interceptor.content/streaming-subtitles-interceptor.ts
@@ -1,12 +1,22 @@
-import { STREAMING_ENSURE_NATIVE_SUBTITLES_TYPE, STREAMING_SUBTITLE_TRACKS_TYPE } from "@/utils/constants/subtitles"
-
-// MAIN-world interceptor: watches Netflix's own network traffic for the subtitle
-// tracks it lists in manifest JSON (under `timedtexttracks`) and forwards their
-// download URLs to the content script. A new platform adds its own recogniser to
-// `inspectJson`; the shared StreamingSubtitlesFetcher does selection + alignment.
+import {
+  STREAMING_ENSURE_NATIVE_SUBTITLES_TYPE,
+  STREAMING_SUBTITLE_CAPTURED_TYPE,
+  STREAMING_SUBTITLE_TRACKS_TYPE,
+} from "@/utils/constants/subtitles"
+import { parseDashMpdTextTracks } from "@/utils/subtitles/fetchers/streaming/dash-mpd"
+
+// MAIN-world interceptor: watches a streaming site's own network traffic for its
+// official subtitle tracks and forwards them to the content script (track-store).
+// Two capture strategies, one per site family:
+//   - Netflix: subtitle download URLs live in manifest JSON under `timedtexttracks`.
+//   - HBO Max / Max: subtitles are fetched as .vtt files or listed in a DASH .mpd.
+// Adding a site = teach `inspect()` how to recognise its subtitle responses.
 
 interface InterceptedTrack {
-  url: string
+  id?: string
+  url?: string
+  urls?: string[]
+  segmentStartMs?: number[]
   language?: string
   label?: string
   kind?: string
@@ -20,7 +30,11 @@ declare global {
 }
 
 const NETFLIX_HOST = /(?:^|\.)netflix\.com$/i
+const WEBVTT_HOST = /(?:^|\.)(?:max|hbomax)\.com$/i
+const VTT_URL = /\.vtt(?:[?#]|$)/i
+const MPD_URL = /\.mpd(?:[?#]|$)/i
 const JSON_URL = /manifest|pathevaluator|metadata|timedtext|\.json/i
+
 const nativeParse = JSON.parse.bind(JSON)
 const tracksByUrl = new Map<string, InterceptedTrack>()
 const replayedUrls = new Set<string>()
@@ -28,6 +42,12 @@ const replayedUrls = new Set<string>()
 function pagePath(): string {
   return window.location.pathname
 }
+function isNetflix(): boolean {
+  return NETFLIX_HOST.test(window.location.hostname)
+}
+function isWebVttSite(): boolean {
+  return WEBVTT_HOST.test(window.location.hostname)
+}
 
 function normalizeUrl(value: unknown): string | null {
   if (typeof value !== "string" || !value)
@@ -44,9 +64,9 @@ function str(value: unknown): string | undefined {
   return typeof value === "string" && value.trim() ? value : undefined
 }
 
-// Netflix lists subtitle tracks under `timedtexttracks`; each track's download URLs
-// live in `ttDownloadables.<profile>.downloadUrls.*`. Audio/video URLs sit
-// elsewhere, so reading only ttDownloadables ignores non-subtitle media.
+// Netflix manifests list subtitle tracks under `timedtexttracks`; each track's
+// download URLs live in `ttDownloadables.<profile>.downloadUrls.*`. Media (audio /
+// video) URLs sit elsewhere, so reading only ttDownloadables ignores them.
 export function collectStreamingSubtitleTracks(json: unknown): InterceptedTrack[] {
   const tracks: InterceptedTrack[] = []
   const seen = new WeakSet<object>()
@@ -75,10 +95,10 @@ function ttDownloadableUrls(track: Record<string, unknown>): string[] {
   for (const profile of Object.values(downloadables)) {
     const downloadUrls = (profile as Record<string, unknown>)?.downloadUrls
     if (downloadUrls && typeof downloadUrls === "object") {
-      for (const value of Object.values(downloadUrls)) {
-        const url = normalizeUrl(value)
-        if (url)
-          urls.push(url)
+      for (const url of Object.values(downloadUrls)) {
+        const normalized = normalizeUrl(url)
+        if (normalized)
+          urls.push(normalized)
       }
     }
   }
@@ -86,14 +106,18 @@ function ttDownloadableUrls(track: Record<string, unknown>): string[] {
 }
 
 function postTracks(tracks: InterceptedTrack[]) {
-  const unique = [...new Map(tracks.map(track => [track.url, track])).values()]
+  const unique = [...new Map(tracks.map(track => [track.id ?? track.url ?? track.urls?.join("\n") ?? "", track])).values()]
   if (unique.length)
     window.postMessage({ type: STREAMING_SUBTITLE_TRACKS_TYPE, tracks: unique }, window.location.origin)
 }
 
 function publishTracks(tracks: InterceptedTrack[]) {
   const scoped = tracks.map(track => ({ ...track, pagePath: pagePath() }))
-  scoped.forEach(track => tracksByUrl.set(track.url, track))
+  for (const track of scoped) {
+    if (track.url)
+      tracksByUrl.set(track.url, track)
+    track.urls?.forEach(url => tracksByUrl.set(url, track))
+  }
   postTracks(scoped)
 }
 
@@ -108,8 +132,25 @@ function publishFromJson(text: string | null) {
   }
 }
 
-// The manifest may have been fetched before this script injected (extension reload
-// / late inject). Replay recent JSON resources so their tracks reappear.
+function guessLanguage(url: string): string | undefined {
+  try {
+    const parsed = new URL(url)
+    return parsed.searchParams.get("lang") ?? parsed.pathname.match(/[/_-]([a-z]{2}(?:-[a-z]{2,4})?)\.vtt/i)?.[1] ?? undefined
+  }
+  catch {
+    return undefined
+  }
+}
+
+function captureText(url: string, text: string | null) {
+  const track = tracksByUrl.get(url)
+  if (!text || !track || track.pagePath !== pagePath())
+    return
+  window.postMessage({ type: STREAMING_SUBTITLE_CAPTURED_TYPE, url, text, pagePath: track.pagePath }, window.location.origin)
+}
+
+// Netflix's manifest may have been fetched before this script injected (extension
+// reload / late inject). Replay recent JSON resources so their tracks reappear.
 function replayKnownResources() {
   const entries = typeof performance?.getEntriesByType === "function" ? performance.getEntriesByType("resource") : []
   entries
@@ -122,14 +163,24 @@ function replayKnownResources() {
     })
 }
 
-function inspectJson(rawUrl: string | null, text: string | null, contentType: string | null) {
+async function inspect(rawUrl: string | null, text: string | null, contentType: string | null) {
   const url = normalizeUrl(rawUrl)
-  if (url && (/\bjson\b/i.test(contentType ?? "") || JSON_URL.test(url)))
+  if (!url)
+    return
+  if (isWebVttSite() && MPD_URL.test(url)) {
+    publishTracks([{ id: `${url}#manifest`, url, kind: "dash-manifest" }])
+    if (text)
+      publishTracks(parseDashMpdTextTracks(text, url))
+  }
+  if (isWebVttSite() && VTT_URL.test(url))
+    publishTracks([{ url, language: guessLanguage(url), kind: "subtitles" }])
+  captureText(url, text)
+  if (/\bjson\b/i.test(contentType ?? "") || JSON_URL.test(url))
     publishFromJson(text)
 }
 
 export function injectStreamingSubtitlesInterceptor() {
-  if (window.__READ_FROG_STREAMING_SUBTITLES_INTERCEPTOR__ || !NETFLIX_HOST.test(window.location.hostname))
+  if (window.__READ_FROG_STREAMING_SUBTITLES_INTERCEPTOR__ || !(isNetflix() || isWebVttSite()))
     return
   window.__READ_FROG_STREAMING_SUBTITLES_INTERCEPTOR__ = true
 
@@ -142,7 +193,7 @@ export function injectStreamingSubtitlesInterceptor() {
       replayKnownResources()
   })
 
-  // Netflix parses manifests with JSON.parse and fetches them over fetch/XHR.
+  // Netflix parses manifests through JSON.parse; HBO fetches .vtt/.mpd over fetch/XHR.
   const originalParse = JSON.parse
   JSON.parse = function (text, reviver) {
     const result = originalParse.call(this, text, reviver)
@@ -155,7 +206,7 @@ export function injectStreamingSubtitlesInterceptor() {
   window.fetch = async function (input: RequestInfo | URL, init?: RequestInit) {
     const response = await originalFetch.call(this, input, init)
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
-    void response.clone().text().then(text => inspectJson(url, text, response.headers.get("content-type"))).catch(() => {})
+    void response.clone().text().then(text => inspect(url, text, response.headers.get("content-type"))).catch(() => {})
     return response
   }
 
@@ -169,7 +220,7 @@ export function injectStreamingSubtitlesInterceptor() {
     this.addEventListener("load", function () {
       const url = this.responseURL || (this as any).__readFrogUrl
       const text = this.responseType === "" || this.responseType === "text" ? this.responseText : null
-      inspectJson(url, text, this.getResponseHeader("content-type"))
+      void inspect(url, text, this.getResponseHeader("content-type"))
     })
     return originalSend.apply(this, args as any)
   }
diff --git a/src/entrypoints/subtitles.content/index.tsx b/src/entrypoints/subtitles.content/index.tsx
index b9d199a27..29f4edc2f 100644
--- a/src/entrypoints/subtitles.content/index.tsx
+++ b/src/entrypoints/subtitles.content/index.tsx
@@ -10,14 +10,26 @@ declare global {
 
 const NETFLIX_WATCH_PATH_PATTERN = /^\/watch\//
 const URL_CHANGE_EVENT = "extension:URLChange"
+// Streaming SPAs that route through the unified adapter registry (see platforms/streaming.ts).
+const STREAMING_HOST_PATTERN = /(?:^|\.)(?:netflix\.com|max\.com|hbomax\.com)$/i
+// ponytail: bounded poll for a late-mounting <video> on non-Netflix players; raise if some site mounts slower.
+const VIDEO_WAIT_MAX_ATTEMPTS = 20
+const VIDEO_WAIT_INTERVAL_MS = 1000
 
 function isNetflixPage(): boolean {
   return /(?:^|\.)netflix\.com$/i.test(window.location.hostname)
 }
 
-// Netflix browse pages have no player; only bootstrap once the SPA reaches /watch/.
+function isStreamingPage(): boolean {
+  return STREAMING_HOST_PATTERN.test(window.location.hostname)
+}
+
+// Netflix exposes a reliable /watch/ path; other streaming SPAs vary, so gate on
+// the presence of a <video> element instead.
 function isPlaybackReady(): boolean {
-  return NETFLIX_WATCH_PATH_PATTERN.test(window.location.pathname)
+  if (isNetflixPage())
+    return NETFLIX_WATCH_PATH_PATTERN.test(window.location.pathname)
+  return !!document.querySelector("video")
 }
 
 function watchStreamingUrlChanges(): () => void {
@@ -39,6 +51,8 @@ export default defineContentScript({
     "*://*.youtube.com/*",
     "*://*.youtube-nocookie.com/*",
     "*://*.netflix.com/*",
+    "*://*.max.com/*",
+    "*://*.hbomax.com/*",
   ],
   allFrames: true,
   cssInjectionMode: "manifest",
@@ -66,20 +80,38 @@ export default defineContentScript({
       await bootstrapSubtitlesRuntime()
     }
 
-    if (isNetflixPage()) {
+    if (isStreamingPage()) {
       cleanupHandlers.push(watchStreamingUrlChanges())
       if (!isPlaybackReady()) {
-        // Not on a /watch/ page yet. Netflix navigates SPA-only, so keep listening
-        // until the user reaches a title — no timeout, since they may browse for a
-        // while first — then bootstrap once.
-        const onNavigate = () => {
-          if (!isPlaybackReady())
-            return
+        // Wait for the player. The navigation listener is never removed on a timeout,
+        // so a slow title pick still bootstraps; only the optional <video> poll (for
+        // non-Netflix sites whose player can mount without a URL change) is bounded.
+        let pollId: ReturnType<typeof setInterval> | undefined
+        const onReady = () => {
           window.removeEventListener(URL_CHANGE_EVENT, onNavigate)
+          if (pollId)
+            clearInterval(pollId)
           void bootstrapRuntime()
         }
+        function onNavigate() {
+          if (isPlaybackReady())
+            onReady()
+        }
         window.addEventListener(URL_CHANGE_EVENT, onNavigate)
         cleanupHandlers.push(() => window.removeEventListener(URL_CHANGE_EVENT, onNavigate))
+
+        if (!isNetflixPage()) {
+          let attempts = 0
+          pollId = setInterval(() => {
+            if (isPlaybackReady())
+              onReady()
+            else if (++attempts >= VIDEO_WAIT_MAX_ATTEMPTS && pollId)
+              clearInterval(pollId)
+          }, VIDEO_WAIT_INTERVAL_MS)
+          const poll = pollId
+          cleanupHandlers.push(() => clearInterval(poll))
+        }
+
         window.__READ_FROG_SUBTITLES_INJECTED__ = false
         return
       }
diff --git a/src/entrypoints/subtitles.content/platforms/streaming.ts b/src/entrypoints/subtitles.content/platforms/streaming.ts
index 9d04746e2..9ad49a283 100644
--- a/src/entrypoints/subtitles.content/platforms/streaming.ts
+++ b/src/entrypoints/subtitles.content/platforms/streaming.ts
@@ -1,17 +1,37 @@
-import type { UniversalVideoAdapter } from "../universal-adapter"
 import type { PlatformConfig } from "@/entrypoints/subtitles.content/platforms"
+import { hboMaxSiteAdapter } from "@/utils/subtitles/fetchers/streaming/hbo-max"
+import { StreamingSubtitlesFetcher } from "@/utils/subtitles/fetchers/streaming/streaming-fetcher"
+import { UniversalVideoAdapter } from "../universal-adapter"
 import { createNetflixSubtitlesAdapter, getNetflixConfig } from "./netflix"
 
-// Registry of streaming sites that render official bilingual subtitles through the
-// shared StreamingSubtitlesFetcher. Each supported platform is one StreamingSite
-// entry; a new site (HBO Max, …) plugs in by adding its adapter here — the capture,
-// source/target selection and alignment plumbing is shared, not re-implemented.
+const URL_CHANGE_EVENT = "extension:URLChange"
+
 export interface StreamingSite {
   id: string
   matches: (url: URL) => boolean
   create: () => { config: PlatformConfig, adapter: UniversalVideoAdapter }
 }
 
+// HBO Max plays inside an SPA like Netflix, so it reuses the same URLChange
+// navigation events and floating-button UI. Native-caption selectors are
+// best-effort and may need adjustment against the real site.
+function streamingConfig(nativeSubtitles: string): PlatformConfig {
+  return {
+    selectors: {
+      video: "video",
+      playerContainer: "body",
+      nativeSubtitles,
+    },
+    events: {
+      navigateStart: URL_CHANGE_EVENT,
+      navigateFinish: URL_CHANGE_EVENT,
+    },
+    // Only player pages (those with a <video>) carry a video id; browse pages return
+    // null so they don't trigger a navigation reset that drops the next title.
+    getVideoId: () => document.querySelector("video") ? window.location.pathname : null,
+  }
+}
+
 const STREAMING_SITES: StreamingSite[] = [
   {
     id: "netflix",
@@ -21,6 +41,14 @@ const STREAMING_SITES: StreamingSite[] = [
       return { config, adapter: createNetflixSubtitlesAdapter(config) }
     },
   },
+  {
+    id: hboMaxSiteAdapter.id,
+    matches: hboMaxSiteAdapter.matches,
+    create: () => {
+      const config = streamingConfig("[data-testid='subtitle-text'], .subtitle, .subtitles, [class*='CaptionWindow-Fuse-Web-Play'], [class*='TextCue-Fuse-Web-Play']")
+      return { config, adapter: new UniversalVideoAdapter({ config, subtitlesFetcher: new StreamingSubtitlesFetcher(hboMaxSiteAdapter) }) }
+    },
+  },
 ]
 
 export function findStreamingSite(url: URL): StreamingSite | null {
diff --git a/src/utils/subtitles/__tests__/streaming-fetcher.test.ts b/src/utils/subtitles/__tests__/streaming-fetcher.test.ts
index df40b0ac8..7ee320a18 100644
--- a/src/utils/subtitles/__tests__/streaming-fetcher.test.ts
+++ b/src/utils/subtitles/__tests__/streaming-fetcher.test.ts
@@ -2,7 +2,10 @@
 import type { StreamingSiteAdapter, StreamingTrack } from "../fetchers/streaming/streaming-fetcher"
 import { afterEach, describe, expect, it, vi } from "vitest"
 import * as configStorage from "@/utils/config/storage"
+import * as backgroundFetchClient from "@/utils/content-script/background-fetch-client"
 import { parseSubtitleText } from "../fetchers/streaming/cue-parser"
+import { parseDashMpdTextTracks } from "../fetchers/streaming/dash-mpd"
+import { hboMaxSiteAdapter } from "../fetchers/streaming/hbo-max"
 import { StreamingSubtitlesFetcher } from "../fetchers/streaming/streaming-fetcher"
 
 const EN_VTT = `WEBVTT
@@ -17,6 +20,24 @@ const ZH_VTT = `WEBVTT
 你好
 `
 
+const DASH_MPD = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period>
+    <AdaptationSet id="41" lang="en-US" contentType="text">
+      <Label>English</Label>
+      <Role schemeIdUri="urn:mpeg:dash:role:2011" value="subtitle"/>
+      <Representation mimeType="text/vtt" id="t41" bandwidth="35">
+        <SegmentTemplate timescale="1000" startNumber="3" media="t/ff8956/t41/$Number$.vtt">
+          <SegmentTimeline>
+            <S t="0" d="1000" r="1"/>
+            <S d="1000"/>
+          </SegmentTimeline>
+        </SegmentTemplate>
+      </Representation>
+    </AdaptationSet>
+  </Period>
+</MPD>`
+
 function setLocation(pathname: string) {
   Object.defineProperty(window, "location", {
     value: { href: `https://stream.example${pathname}`, hostname: "stream.example", origin: "https://stream.example", pathname },
@@ -24,18 +45,25 @@ function setLocation(pathname: string) {
   })
 }
 
-// Fake site adapter exercising the shared source/target selection + alignment that
-// every streaming adapter (Netflix, and HBO Max in the follow-up) reuses.
-function fakeSite(tracks: StreamingTrack[]): StreamingSiteAdapter {
+// Fake WebVTT site exercising the same source/target fetch + parse path HBO Max uses.
+function webVttSite(tracks: StreamingTrack[]): StreamingSiteAdapter {
   return {
-    id: "fake",
+    id: "fake-webvtt",
     matches: () => true,
     discoverTracks: async () => tracks,
     fetchTrack: async (track: StreamingTrack) => parseSubtitleText(track.id === "zh" ? ZH_VTT : EN_VTT),
   }
 }
 
+function mockSubtitleFetch(byUrl: (url: string) => string) {
+  vi.spyOn(backgroundFetchClient, "backgroundFetch").mockImplementation(async (input: RequestInfo | URL) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
+    return { ok: true, text: async () => byUrl(url) } as Response
+  })
+}
+
 afterEach(() => {
+  hboMaxSiteAdapter.cleanup?.()
   vi.restoreAllMocks()
 })
 
@@ -43,7 +71,7 @@ describe("streamingSubtitlesFetcher", () => {
   it("aligns official source + target tracks into bilingual fragments", async () => {
     setLocation("/watch/1")
     vi.spyOn(configStorage, "getLocalConfig").mockResolvedValue({ language: { targetCode: "cmn-Hant" } } as any)
-    const fetcher = new StreamingSubtitlesFetcher(fakeSite([
+    const fetcher = new StreamingSubtitlesFetcher(webVttSite([
       { id: "en", language: "en", label: "English" },
       { id: "zh", language: "zh-Hant", label: "中文（繁體）" },
     ]))
@@ -54,3 +82,34 @@ describe("streamingSubtitlesFetcher", () => {
     expect(fetcher.isPreSegmented()).toBe(true)
   })
 })
+
+describe("hbo max DASH + WebVTT path", () => {
+  it("expands segmented WebVTT tracks from a DASH manifest", () => {
+    expect(parseDashMpdTextTracks(DASH_MPD, "https://cdn.example/video/dash.mpd?token=1")).toEqual([
+      {
+        id: "https://cdn.example/video/dash.mpd?token=1#41:t41",
+        url: "https://cdn.example/video/t/ff8956/t41/3.vtt",
+        urls: [
+          "https://cdn.example/video/t/ff8956/t41/3.vtt",
+          "https://cdn.example/video/t/ff8956/t41/4.vtt",
+          "https://cdn.example/video/t/ff8956/t41/5.vtt",
+        ],
+        segmentStartMs: [0, 1000, 2000],
+        language: "en-US",
+        label: "English",
+        kind: "subtitle",
+      },
+    ])
+  })
+
+  it("parses each WebVTT segment and applies its DASH start offset", async () => {
+    mockSubtitleFetch(url => url.endsWith("1.vtt") ? EN_VTT : ZH_VTT)
+    await expect(hboMaxSiteAdapter.fetchTrack({
+      urls: ["https://cdn.example/1.vtt", "https://cdn.example/2.vtt"],
+      segmentStartMs: [10_000, 20_000],
+    })).resolves.toEqual([
+      { text: "Hello", start: 10_000, end: 11_000 },
+      { text: "你好", start: 20_000, end: 21_000 },
+    ])
+  })
+})
diff --git a/src/utils/subtitles/fetchers/streaming/dash-mpd.ts b/src/utils/subtitles/fetchers/streaming/dash-mpd.ts
new file mode 100644
index 000000000..480524513
--- /dev/null
+++ b/src/utils/subtitles/fetchers/streaming/dash-mpd.ts
@@ -0,0 +1,76 @@
+import type { StreamingTrack } from "./streaming-fetcher"
+
+// Minimal DASH MPD parsing for HBO Max: turn the subtitle AdaptationSets of a
+// manifest into segmented WebVTT tracks (one entry per text Representation, with
+// every segment URL + its start time). Covers the common SegmentTemplate +
+// SegmentTimeline + $Number$ shape; richer DASH features aren't needed here.
+
+const MAX_SEGMENTS = 500
+
+function child(element: Element, name: string): Element | null {
+  return [...element.children].find(node => node.localName === name) ?? null
+}
+
+function isTextRepresentation(set: Element, rep: Element): boolean {
+  const types = `${set.getAttribute("contentType") ?? ""} ${set.getAttribute("mimeType") ?? ""} ${rep.getAttribute("mimeType") ?? ""}`
+  return /\btext\b|vtt|ttml/i.test(types)
+}
+
+function expandSegments(template: Element, rep: Element, manifestUrl: string): { url: string, startMs: number }[] {
+  const media = template.getAttribute("media")
+  const timeline = child(template, "SegmentTimeline")
+  if (!media || !timeline)
+    return []
+
+  const repId = rep.getAttribute("id") ?? ""
+  const timescale = Number(template.getAttribute("timescale")) || 1
+  let number = Number(template.getAttribute("startNumber")) || 1
+  let time = 0
+  const segments: { url: string, startMs: number }[] = []
+
+  for (const segment of [...timeline.children].filter(node => node.localName === "S")) {
+    const explicitTime = segment.getAttribute("t")
+    if (explicitTime !== null)
+      time = Number(explicitTime)
+    const duration = Number(segment.getAttribute("d")) || 0
+    const repeat = Number(segment.getAttribute("r")) || 0
+    for (let i = 0; i <= repeat && segments.length < MAX_SEGMENTS; i++) {
+      const url = media.replace(/\$RepresentationID\$/g, repId).replace(/\$Number\$/g, String(number))
+      segments.push({ url: new URL(url, manifestUrl).href, startMs: (time / timescale) * 1000 })
+      number += 1
+      time += duration
+    }
+  }
+  return segments
+}
+
+export function parseDashMpdTextTracks(manifestText: string, manifestUrl: string): StreamingTrack[] {
+  const doc = new DOMParser().parseFromString(manifestText, "application/xml")
+  if (doc.querySelector("parsererror"))
+    return []
+
+  return [...doc.querySelectorAll("AdaptationSet")].flatMap((set): StreamingTrack[] => {
+    const language = set.getAttribute("lang") ?? undefined
+    const label = child(set, "Label")?.textContent?.trim() || language
+    const kind = child(set, "Role")?.getAttribute("value") ?? "subtitles"
+
+    return [...set.children].filter(node => node.localName === "Representation").flatMap((rep): StreamingTrack[] => {
+      const template = child(rep, "SegmentTemplate") ?? child(set, "SegmentTemplate")
+      if (!template || !isTextRepresentation(set, rep))
+        return []
+      const segments = expandSegments(template, rep, manifestUrl)
+      if (!segments.length)
+        return []
+      const urls = segments.map(segment => segment.url)
+      return [{
+        id: `${manifestUrl}#${set.getAttribute("id") ?? "text"}:${rep.getAttribute("id") ?? urls[0]}`,
+        url: urls[0],
+        urls,
+        segmentStartMs: segments.map(segment => segment.startMs),
+        language,
+        label,
+        kind,
+      }]
+    })
+  })
+}
diff --git a/src/utils/subtitles/fetchers/streaming/hbo-max.ts b/src/utils/subtitles/fetchers/streaming/hbo-max.ts
new file mode 100644
index 000000000..9a1b44f06
--- /dev/null
+++ b/src/utils/subtitles/fetchers/streaming/hbo-max.ts
@@ -0,0 +1,57 @@
+import type { StreamingSiteAdapter, StreamingTrack } from "./streaming-fetcher"
+import type { SubtitlesFragment } from "@/utils/subtitles/types"
+import { parseSubtitleText } from "./cue-parser"
+import { parseDashMpdTextTracks } from "./dash-mpd"
+import { clearTrackStore, resolveTrackText, resolveTrackTexts, waitForNetworkTracks } from "./track-store"
+
+// HBO Max / Max adapter on the shared streaming framework. The MAIN-world
+// interceptor captures HBO's own subtitles as WebVTT requests or as a DASH
+// manifest; this adapter just turns those into fragments via the shared parsers.
+
+const VTT_URL = /\.vtt(?:[?#]|$)/i
+const MPD_URL = /\.mpd(?:[?#]|$)/i
+
+async function tracksFromDashManifests(captured: StreamingTrack[]): Promise<StreamingTrack[]> {
+  const manifests = captured.filter(track => track.kind === "dash-manifest" || MPD_URL.test(track.url ?? ""))
+  const parsed = await Promise.all(manifests.map(async (track) => {
+    try {
+      return track.url ? parseDashMpdTextTracks(await resolveTrackText(track), track.url) : []
+    }
+    catch {
+      return []
+    }
+  }))
+  return parsed.flat()
+}
+
+// HBO WebVTT segments are sometimes relative (start near 0) and sometimes already
+// absolute; only shift by the DASH segment offset when the cue looks relative.
+function parseSegment(text: string, offsetMs: number): SubtitlesFragment[] {
+  const fragments = parseSubtitleText(text)
+  if (!offsetMs || !fragments.length || fragments[0].start + 5_000 >= offsetMs)
+    return fragments
+  return parseSubtitleText(text, offsetMs)
+}
+
+export const hboMaxSiteAdapter: StreamingSiteAdapter = {
+  id: "hbo-max",
+  matches: url => /(?:^|\.)(?:max|hbomax)\.com$/i.test(url.hostname),
+  discoverTracks: async () => {
+    const captured = await waitForNetworkTracks()
+    const segmented = captured.filter(track => track.urls?.length && VTT_URL.test(track.url ?? ""))
+    if (segmented.length)
+      return segmented
+    const fromDash = await tracksFromDashManifests(captured)
+    if (fromDash.length)
+      return fromDash
+    return captured.filter(track => VTT_URL.test(track.url ?? ""))
+  },
+  fetchTrack: async (track: StreamingTrack) => {
+    if (track.segmentStartMs?.length) {
+      const texts = await resolveTrackTexts(track)
+      return texts.flatMap((text, index) => parseSegment(text, track.segmentStartMs?.[index] ?? 0))
+    }
+    return parseSubtitleText(await resolveTrackText(track))
+  },
+  cleanup: () => clearTrackStore(),
+}