From e0460ed0c89d223d2dd0ecb3340d155136edfb77 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 4 Oct 2026 20:34:57 +0000
Subject: [PATCH 1/2] Seek to chapter in VOD player instead of shifting chat

Chapter "Open in player" links passed the chapter start as offset=,
which twitch-vod-chat treats as the chat offset, so chat was shifted by
the chapter start time instead of the video seeking there. Pass it as
t= (seek target) instead, and bump the twitch-vod-chat submodule to the
version that supports t=.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XuPs3nkTaDwZGoCD8oKKEV
---
 client-vue/src/components/vod/VodItemChapters.vue | 2 +-
 twitch-vod-chat                                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/client-vue/src/components/vod/VodItemChapters.vue b/client-vue/src/components/vod/VodItemChapters.vue
index e6e5b38c..3db244e7 100644
--- a/client-vue/src/components/vod/VodItemChapters.vue
+++ b/client-vue/src/components/vod/VodItemChapters.vue
@@ -234,7 +234,7 @@ function playerLink(offset = 0, chatdownload = false): string {
     if (!props.vod || !store.config) return "#";
     const video_path = `${props.vod.webpath}/${props.vod.basename}.mp4`;
     const chat_path = `${props.vod.webpath}/${props.vod.basename}.${chatdownload ? "chat" : "chatdump"}`;
-    return `${store.cfg<string>("basepath", "")}/vodplayer#source=file_http&video_path=${video_path}&chatfile=${chat_path}&offset=${offset}`;
+    return `${store.cfg<string>("basepath", "")}/vodplayer#source=file_http&video_path=${video_path}&chatfile=${chat_path}&t=${Math.floor(offset)}`;
 }
 
 function twitchVideoLink(video_id: string): string {
diff --git a/twitch-vod-chat b/twitch-vod-chat
index 39251925..823d4a9c 160000
--- a/twitch-vod-chat
+++ b/twitch-vod-chat
@@ -1 +1 @@
-Subproject commit 39251925ac72860b973cff0c8c93f4691e7cd951
+Subproject commit 823d4a9caf5335aeddd3c021c7291e6b4e12622d

From 44a18c5ac1102d98b3e47c6c9936621dbfa0fed7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 4 Oct 2026 21:08:19 +0000
Subject: [PATCH 2/2] Keep chat and chapters in sync with captures that had ad
 breaks

Streamlink filters out Twitch ad segments and the remux to mp4 collapses the
resulting gaps, so the captured video is shorter than the stream. Chat and
chapters are timed in stream time, so they drifted further after every ad
break (12+ minutes on a 4.5h stream).

Sync existing captures to the video using the recorded stream pauses:
- Map stream time to video time by removing the pauses before each point
  (StreamPauses helper). Nothing changes for captures without pauses.
- Serve a synced copy of the chat dump (<basename>.synced.chatdump) at
  /api/v0/vod/:uuid/synced.chatdump, generated on demand. The original
  chat dump is never modified.
- Use it in the player links, chat render for the captured video and clip
  chat cuts.
- Add video_offset/video_duration to chapters and use them for everything
  that refers to the captured video (chapter table, player and editor
  links, embedded chapters, LosslessCut EDL, VTT, split by chapters). The
  stream time offset is kept for Twitch links and chapter editing.

Optionally fill the pauses with black video when converting
(video.pad_stream_pauses, off by default):
- Cut the capture at each pause, at the exact timestamp gap if one matches
  or at the nearest keyframe of the estimated position, and insert a
  black, silent filler of the pause length using the concat demuxer.
- The capture is only stream copied; one short filler unit is encoded
  and repeated.
- Padded vods are flagged (stream_pauses_padded) so no sync is applied.
- Falls back to a normal conversion on any failure.

Also fix Helper.path_ffprobe returning the ffmpeg binary on Linux.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XuPs3nkTaDwZGoCD8oKKEV
---
 client-vue/src/components/vod/VodItem.vue     |  13 +-
 .../src/components/vod/VodItemChapters.vue    |  34 +-
 client-vue/src/core/Providers/Base/BaseVOD.ts |   6 +
 .../src/core/Providers/Base/BaseVODChapter.ts |   8 +
 .../core/Providers/Twitch/TwitchVODChapter.ts |   2 +
 client-vue/src/views/EditorView.vue           |  18 +-
 client-vue/test/mockdata.ts                   |   4 +
 common/Api/Client.ts                          |   9 +
 common/ServerConfig.ts                        |   7 +
 server/src/Controllers/Vod.ts                 |  40 +-
 server/src/Core/Helper.ts                     |   6 +-
 .../src/Core/Providers/Base/BaseAutomator.ts  |  94 +++-
 server/src/Core/Providers/Base/BaseVOD.ts     | 170 ++++++-
 .../src/Core/Providers/Base/BaseVODChapter.ts |  27 +-
 server/src/Core/Providers/Twitch/TwitchVOD.ts |  21 +-
 .../Core/Providers/Twitch/TwitchVODChapter.ts |   2 +
 server/src/Helpers/PadVideo.test.ts           | 211 +++++++++
 server/src/Helpers/PadVideo.ts                | 421 ++++++++++++++++++
 server/src/Helpers/StreamPauses.test.ts       | 187 ++++++++
 server/src/Helpers/StreamPauses.ts            | 131 ++++++
 server/src/Helpers/Video.ts                   | 225 +++++++++-
 server/src/Routes/Api.ts                      |   1 +
 server/src/Storage/JSON.ts                    |   2 +
 23 files changed, 1579 insertions(+), 60 deletions(-)
 create mode 100644 server/src/Helpers/PadVideo.test.ts
 create mode 100644 server/src/Helpers/PadVideo.ts
 create mode 100644 server/src/Helpers/StreamPauses.test.ts
 create mode 100644 server/src/Helpers/StreamPauses.ts

diff --git a/client-vue/src/components/vod/VodItem.vue b/client-vue/src/components/vod/VodItem.vue
index 792ac1ee..f14cd1bf 100644
--- a/client-vue/src/components/vod/VodItem.vue
+++ b/client-vue/src/components/vod/VodItem.vue
@@ -451,13 +451,22 @@ function openPlayer(): void {
         hash += `&video_path=${props.vod.webpath}/${props.vod.basename}_vod.mp4`;
     }
 
+    // stream pauses are cut out of the captured video, chat and chapters need to be synced to it
+    const syncToVideo = playerSettings.value.vodSource == "captured" && props.vod.needs_video_sync;
+
     if (playerSettings.value.chatSource == "captured") {
-        hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}.chatdump`;
+        if (syncToVideo) {
+            hash += `&chatfile=${store.cfg<string>("basepath", "")}/api/v0/vod/${props.vod.uuid}/synced.chatdump`;
+        } else {
+            hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}.chatdump`;
+        }
     } else {
         hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}_chat.json`;
     }
 
-    hash += `&chapters=${props.vod.chapters?.map((c) => `${c.offset}:${encodeURIComponent(c.title.replaceAll(":", "").replaceAll(";", ""))}`).join(";")}`;
+    hash += `&chapters=${props.vod.chapters
+        ?.map((c) => `${syncToVideo ? c.video_offset : c.offset}:${encodeURIComponent(c.title.replaceAll(":", "").replaceAll(";", ""))}`)
+        .join(";")}`;
 
     // url.searchParams.set("offset", this.playerSettings.offset.toString());
     // window.open(url.toString(), "_blank");
diff --git a/client-vue/src/components/vod/VodItemChapters.vue b/client-vue/src/components/vod/VodItemChapters.vue
index 3db244e7..deea1d0f 100644
--- a/client-vue/src/components/vod/VodItemChapters.vue
+++ b/client-vue/src/components/vod/VodItemChapters.vue
@@ -42,8 +42,8 @@
                             }"
                         >
                             <!-- start timestamp -->
-                            <td data-contents="offset" :title="formatDate(chapter.started_at)">
-                                {{ chapter.offset !== undefined ? humanDuration(chapter.offset) : "Unknown" }}
+                            <td data-contents="offset" :title="chapterOffsetTitle(chapter)">
+                                {{ chapter.video_offset !== undefined ? humanDuration(chapter.video_offset) : "Unknown" }}
                             </td>
 
                             <!-- start time -->
@@ -58,15 +58,15 @@
 
                             <!-- end time -->
                             <td v-if="showAdvanced" data-contents="ended_at">
-                                <template v-if="chapter.offset !== undefined && chapter.duration !== undefined">
-                                    {{ humanDuration(chapter.offset + chapter.duration) }}
+                                <template v-if="chapter.video_offset !== undefined && chapter.video_duration !== undefined">
+                                    {{ humanDuration(chapter.video_offset + chapter.video_duration) }}
                                 </template>
                             </td>
 
                             <!-- duration -->
                             <td data-contents="duration">
-                                <template v-if="chapter.duration">
-                                    {{ niceDuration(chapter.duration) }}
+                                <template v-if="chapter.video_duration">
+                                    {{ niceDuration(chapter.video_duration) }}
                                 </template>
                                 <template v-else>
                                     <duration-display :start-date="chapter.started_at.toISOString()" output-style="human" />
@@ -89,7 +89,7 @@
                                         <a
                                             class="px-1"
                                             target="_blank"
-                                            :href="playerLink(chapter.offset)"
+                                            :href="playerLink(chapter.video_offset)"
                                             title="Open in player"
                                             :class="{ 'is-spoiler': store.clientCfg('hideChapterTitlesAndGames') }"
                                         >
@@ -104,7 +104,11 @@
                                             :to="{
                                                 name: 'Editor',
                                                 params: { uuid: vod.uuid },
-                                                query: { start: chapter.offset, end: (chapter.offset || 0) + (chapter.duration || 0), chapter: chapterIndex },
+                                                query: {
+                                                    start: chapter.video_offset,
+                                                    end: (chapter.video_offset || 0) + (chapter.video_duration || 0),
+                                                    chapter: chapterIndex,
+                                                },
                                             }"
                                         >
                                             <span class="icon"><font-awesome-icon icon="cut" /></span>
@@ -233,10 +237,22 @@ const hasViewerCount = computed(() => {
 function playerLink(offset = 0, chatdownload = false): string {
     if (!props.vod || !store.config) return "#";
     const video_path = `${props.vod.webpath}/${props.vod.basename}.mp4`;
-    const chat_path = `${props.vod.webpath}/${props.vod.basename}.${chatdownload ? "chat" : "chatdump"}`;
+    let chat_path = `${props.vod.webpath}/${props.vod.basename}.${chatdownload ? "chat" : "chatdump"}`;
+    if (!chatdownload && props.vod.needs_video_sync) {
+        // stream pauses were cut out of the video, use the chat dump synced to it
+        chat_path = `${store.cfg<string>("basepath", "")}/api/v0/vod/${props.vod.uuid}/synced.chatdump`;
+    }
     return `${store.cfg<string>("basepath", "")}/vodplayer#source=file_http&video_path=${video_path}&chatfile=${chat_path}&t=${Math.floor(offset)}`;
 }
 
+function chapterOffsetTitle(chapter: ChapterTypes): string {
+    let title = formatDate(chapter.started_at);
+    if (chapter.offset !== undefined && chapter.video_offset !== undefined && Math.round(chapter.offset) !== Math.round(chapter.video_offset)) {
+        title += ` (${humanDuration(chapter.offset)} into the stream, ad breaks are cut out of the video)`;
+    }
+    return title;
+}
+
 function twitchVideoLink(video_id: string): string {
     return `https://www.twitch.tv/videos/${video_id}`;
 }
diff --git a/client-vue/src/core/Providers/Base/BaseVOD.ts b/client-vue/src/core/Providers/Base/BaseVOD.ts
index b76703fe..59bb9572 100644
--- a/client-vue/src/core/Providers/Base/BaseVOD.ts
+++ b/client-vue/src/core/Providers/Base/BaseVOD.ts
@@ -69,6 +69,10 @@ export default class BaseVOD {
 
     viewers: VodViewerEntry[] = [];
     stream_pauses: StreamPause[] = [];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded = false;
+    /** Chat and chapter times need to be mapped to the captured video because of stream pauses */
+    needs_video_sync = false;
 
     get current_chapter(): BaseVODChapter | undefined {
         if (this.chapters.length > 0) {
@@ -145,6 +149,8 @@ export default class BaseVOD {
         vod.stream_pauses = apiResponse.stream_pauses
             ? apiResponse.stream_pauses.map((entry) => ({ start: new Date(entry.start), end: new Date(entry.end) }))
             : [];
+        vod.stream_pauses_padded = apiResponse.stream_pauses_padded ?? false;
+        vod.needs_video_sync = apiResponse.needs_video_sync ?? false;
 
         return vod;
 
diff --git a/client-vue/src/core/Providers/Base/BaseVODChapter.ts b/client-vue/src/core/Providers/Base/BaseVODChapter.ts
index 0396a6b2..0703cb68 100644
--- a/client-vue/src/core/Providers/Base/BaseVODChapter.ts
+++ b/client-vue/src/core/Providers/Base/BaseVODChapter.ts
@@ -8,9 +8,15 @@ export class BaseVODChapter {
      */
     public started_at!: Date;
 
+    /** Seconds since the stream started */
     public offset?: number;
     public duration?: number;
 
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    public video_offset?: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    public video_duration?: number;
+
     // public game_id?: string;
     // public game?: TwitchGame;
 
@@ -34,6 +40,8 @@ export class BaseVODChapter {
         chapter.started_at = new Date(apiResponse.started_at);
         chapter.offset = apiResponse.offset;
         chapter.duration = apiResponse.duration;
+        chapter.video_offset = apiResponse.video_offset ?? apiResponse.offset;
+        chapter.video_duration = apiResponse.video_duration ?? apiResponse.duration;
         // chapter.strings = apiResponse.strings;
         // chapter.game_id = apiResponse.game_id;
         chapter.title = apiResponse.title;
diff --git a/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts b/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
index dc502ad8..d0d5bb76 100644
--- a/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
+++ b/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
@@ -19,6 +19,8 @@ export class TwitchVODChapter extends BaseVODChapter {
         chapter.started_at = new Date(apiResponse.started_at);
         chapter.offset = apiResponse.offset;
         chapter.duration = apiResponse.duration;
+        chapter.video_offset = apiResponse.video_offset ?? apiResponse.offset;
+        chapter.video_duration = apiResponse.video_duration ?? apiResponse.duration;
         // chapter.strings = apiResponse.strings;
         chapter.game_id = apiResponse.game_id;
         chapter.title = apiResponse.title;
diff --git a/client-vue/src/views/EditorView.vue b/client-vue/src/views/EditorView.vue
index 6457bde2..fe5d9480 100644
--- a/client-vue/src/views/EditorView.vue
+++ b/client-vue/src/views/EditorView.vue
@@ -156,12 +156,12 @@
                 <ul class="list">
                     <li v-for="(chapter, i) in vodData.chapters" :key="i">
                         <a
-                            v-if="chapter.offset !== undefined && chapter.duration !== undefined"
-                            @click="setCutpoints(chapter.offset || 0, chapter.duration || 0)"
+                            v-if="chapter.video_offset !== undefined && chapter.video_duration !== undefined"
+                            @click="setCutpoints(chapter.video_offset || 0, chapter.video_duration || 0)"
                         >
                             <div class="chapter-time">
-                                {{ humanDuration(chapter.offset) }} - {{ humanDuration(chapter.offset + chapter.duration) }} ({{
-                                    humanDuration(chapter.duration)
+                                {{ humanDuration(chapter.video_offset) }} - {{ humanDuration(chapter.video_offset + chapter.video_duration) }} ({{
+                                    humanDuration(chapter.video_duration)
                                 }})
                             </div>
                             <div class="chapter-game">
@@ -479,8 +479,8 @@ function timelineMouseMove(event: MouseEvent): void {
 
     if (vodData.value) {
         const idx = vodData.value.chapters.findIndex((chapter, i) => {
-            const o = i == 0 ? 0 : chapter.offset || 0;
-            return chapter.offset && chapter.duration && seconds >= o && seconds < o + chapter.duration;
+            const o = i == 0 ? 0 : chapter.video_offset || 0;
+            return chapter.video_offset && chapter.video_duration && seconds >= o && seconds < o + chapter.video_duration;
         });
         if (idx !== -1) {
             currentChapterHoverIndex.value = idx;
@@ -619,7 +619,7 @@ function submitForm(event: Event): void {
 
 function chapterWidth(chapter: BaseVODChapter): number {
     // const chapterOffset = chapter.offset || 0;
-    const chapterDuration = chapter.duration || 0;
+    const chapterDuration = chapter.video_duration || 0;
     const width = (chapterDuration / videoDuration.value) * 100;
     return width;
 }
@@ -697,8 +697,8 @@ watch(
 );
 
 function chapterStyle(index: number, chapter: BaseVODChapter): HTMLAttributes["style"] {
-    const chapterOffset = index == 0 ? 0 : chapter.offset || 0;
-    const chapterDuration = chapter.duration || 0;
+    const chapterOffset = index == 0 ? 0 : chapter.video_offset || 0;
+    const chapterDuration = chapter.video_duration || 0;
     const left = (chapterOffset / videoDuration.value) * 100;
     // cap width at duration
     const width = Math.min((chapterDuration / videoDuration.value) * 100, 100 - left);
diff --git a/client-vue/test/mockdata.ts b/client-vue/test/mockdata.ts
index 31c20e89..0b8d5b69 100644
--- a/client-vue/test/mockdata.ts
+++ b/client-vue/test/mockdata.ts
@@ -138,6 +138,8 @@ export const MockApiVODData: ApiTwitchVod = {
     channel_uuid: "",
     viewers: [],
     stream_pauses: [],
+    stream_pauses_padded: false,
+    needs_video_sync: false,
 };
 
 export const MockApiChapterData: ApiVodTwitchChapter = {
@@ -146,6 +148,8 @@ export const MockApiChapterData: ApiVodTwitchChapter = {
     duration: 0,
     started_at: "",
     offset: 0,
+    video_offset: 0,
+    video_duration: 0,
     is_mature: false,
     game_id: undefined,
     game_name: undefined,
diff --git a/common/Api/Client.ts b/common/Api/Client.ts
index 5893f5f0..f5113d3e 100644
--- a/common/Api/Client.ts
+++ b/common/Api/Client.ts
@@ -23,7 +23,12 @@ export interface ApiVodBaseChapter {
     duration: number;
     started_at: string;
     // datetime: PHPDateTimeJSON;
+    /** Seconds since the stream started */
     offset: number;
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    video_offset: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    video_duration: number;
 }
 
 export interface ApiVodTwitchChapter extends ApiVodBaseChapter {
@@ -120,6 +125,10 @@ export interface ApiBaseVod {
 
     viewers: { amount: number; timestamp: string }[];
     stream_pauses: { start: string; end: string }[];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded: boolean;
+    /** Chat and chapter times need to be mapped to the captured video because of stream pauses */
+    needs_video_sync: boolean;
 
     bookmarks: VODBookmark[];
 }
diff --git a/common/ServerConfig.ts b/common/ServerConfig.ts
index 1c6fa385..fa607a81 100644
--- a/common/ServerConfig.ts
+++ b/common/ServerConfig.ts
@@ -704,6 +704,13 @@ export const settingsFields = createSettingsFields({
         type: "boolean",
         default: false,
     },
+    "video.pad_stream_pauses": {
+        group: "Video",
+        text: "Fill ad breaks with black video",
+        type: "boolean",
+        default: false,
+        help: "When converting a capture, insert black, silent video where streamlink filtered out ad breaks, so the video is as long as the stream and chat and chapters stay in sync. Only a short black clip is encoded, the capture itself is still copied. Falls back to a normal conversion if it fails.",
+    },
     create_video_chapters: {
         group: "Video",
         text: "Create video chapters",
diff --git a/server/src/Controllers/Vod.ts b/server/src/Controllers/Vod.ts
index 0167c735..600c6fdc 100644
--- a/server/src/Controllers/Vod.ts
+++ b/server/src/Controllers/Vod.ts
@@ -392,7 +392,8 @@ export async function RenderWizard(
                 chat_font,
                 chat_font_size,
                 chat_source == "downloaded",
-                true
+                true,
+                vod_source != "downloaded"
             );
         } catch (error) {
             res.api(400, {
@@ -700,9 +701,10 @@ export async function CutVod(
     }
 
     if (vod.is_chat_downloaded || vod.is_chatdump_captured) {
+        // the clip is cut from the captured video, so use the chat dump synced to it
         const chat_file_in = vod.is_chat_downloaded
             ? vod.path_chat
-            : vod.path_chatdump;
+            : await vod.getChatdumpForVideo();
         const chat_file_out = path.join(
             BaseConfigDataFolder.saved_clips,
             `${vod.basename}_${time_in}-${time_out}_${segment_name}_chat.json`
@@ -896,6 +898,40 @@ export async function GetSync(
     */
 }
 
+/**
+ * Send the captured chat dump timed to the captured video.
+ * Stream pauses (ad breaks) are cut out of the video, so the chat is synced to match.
+ * Sends the original chat dump if no sync is needed.
+ */
+export async function GetVideoChatdump(
+    req: express.Request,
+    res: express.Response
+): Promise<void> {
+    const vod = LiveStreamDVR.getInstance().getVodByUUID(req.params.uuid);
+
+    if (!vod) {
+        res.api(400, {
+            status: "ERROR",
+            message: "Vod not found",
+        } as ApiErrorResponse);
+        return;
+    }
+
+    if (!vod.is_chatdump_captured) {
+        res.api(404, {
+            status: "ERROR",
+            message: "No chat dump captured for this vod",
+        } as ApiErrorResponse);
+        return;
+    }
+
+    const chatdump = await vod.getChatdumpForVideo();
+
+    res.sendFile(chatdump, {
+        headers: { "Content-Type": "application/json" },
+    });
+}
+
 export async function RenameVod(
     req: express.Request,
     res: express.Response
diff --git a/server/src/Core/Helper.ts b/server/src/Core/Helper.ts
index e0df1240..330734bc 100644
--- a/server/src/Core/Helper.ts
+++ b/server/src/Core/Helper.ts
@@ -276,7 +276,11 @@ export class Helper {
     public static path_ffprobe(): string | false {
         const f = this.path_ffmpeg();
         if (!f) return false;
-        return f.replace("ffmpeg.exe", "ffprobe.exe");
+        // ffprobe is next to ffmpeg, replace only the file name (ffmpeg or ffmpeg.exe)
+        return path.join(
+            path.dirname(f),
+            path.basename(f).replace(/^ffmpeg/i, "ffprobe")
+        );
     }
 
     public static python_scripts_dir_name(): string {
diff --git a/server/src/Core/Providers/Base/BaseAutomator.ts b/server/src/Core/Providers/Base/BaseAutomator.ts
index 6581c5fd..fe708ed4 100644
--- a/server/src/Core/Providers/Base/BaseAutomator.ts
+++ b/server/src/Core/Providers/Base/BaseAutomator.ts
@@ -7,7 +7,8 @@ import { Sleep } from "@/Helpers/Sleep";
 import { xClearInterval, xInterval } from "@/Helpers/Timeout";
 import { isTwitchVOD, isTwitchVODChapter } from "@/Helpers/Types";
 import type { RemuxReturn } from "@/Helpers/Video";
-import { remuxFile } from "@/Helpers/Video";
+import { pausesToIntervals, totalPauseDuration } from "@/Helpers/StreamPauses";
+import { remuxFile, remuxFileWithPadding } from "@/Helpers/Video";
 import type { TwitchVODChapterJSON } from "@/Storage/JSON";
 import type { VideoQuality } from "@common/Config";
 import type { NotificationCategory } from "@common/Defs";
@@ -1957,7 +1958,8 @@ export class BaseAutomator {
                 settings.chatFont,
                 settings.chatFontSize,
                 settings.chatSource == "downloaded",
-                true
+                true,
+                settings.vodSource != "downloaded"
             );
         } catch (error) {
             log(LOGLEVEL.ERROR, "automator.burnChat", (error as Error).message);
@@ -2252,6 +2254,21 @@ export class BaseAutomator {
         return false;
     }
 
+    /**
+     * Save the chapters for embedding in the converted video.
+     * @returns path to the chapters metadata file, if enabled
+     */
+    private async saveChaptersForConvert(): Promise<string | undefined> {
+        if (!this.vod) return undefined;
+        if (
+            Config.getInstance().cfg("create_video_chapters") &&
+            (await this.vod.saveFFMPEGChapters())
+        ) {
+            return this.vod.path_ffmpegchapters;
+        }
+        return undefined;
+    }
+
     private async convertVideo(): Promise<boolean> {
         if (!this.vod) throw new Error("VOD not set");
 
@@ -2259,23 +2276,68 @@ export class BaseAutomator {
             vod: await this.vod.toAPI(),
         } as VodUpdated);
 
-        let mf;
-        if (
-            Config.getInstance().cfg("create_video_chapters") &&
-            (await this.vod.saveFFMPEGChapters())
-        ) {
-            mf = this.vod.path_ffmpegchapters;
-        }
+        let result: RemuxReturn | undefined;
 
-        let result: RemuxReturn;
+        // fill stream pauses (ad breaks) with black video so chat and chapters stay in sync
+        const pauseIntervals =
+            this.vod.started_at &&
+            Config.getInstance().cfg<boolean>("video.pad_stream_pauses", false)
+                ? pausesToIntervals(this.vod.stream_pauses, this.vod.started_at)
+                : [];
 
-        try {
-            result = await remuxFile(
-                this.capture_filename,
-                this.converted_filename,
-                false,
-                mf
+        if (pauseIntervals.length > 0) {
+            log(
+                LOGLEVEL.INFO,
+                "automator.convertVideo",
+                `Filling ${pauseIntervals.length} stream pauses (${Math.round(
+                    totalPauseDuration(pauseIntervals)
+                )}s) of ${this.vod.basename} with black video`
             );
+
+            // chapters in the padded video are at their stream time
+            this.vod.stream_pauses_padded = true;
+            this.vod.calculateChapters();
+
+            try {
+                result = await remuxFileWithPadding(
+                    this.capture_filename,
+                    this.converted_filename,
+                    pauseIntervals,
+                    await this.saveChaptersForConvert()
+                );
+            } catch (err) {
+                log(
+                    LOGLEVEL.ERROR,
+                    "automator.convertVideo",
+                    `Failed to fill stream pauses, converting normally: ${
+                        (err as Error).message
+                    }`,
+                    err
+                );
+                result = undefined;
+            }
+
+            if (!result || !result.success) {
+                this.vod.stream_pauses_padded = false;
+                this.vod.calculateChapters();
+                if (fs.existsSync(this.converted_filename)) {
+                    fs.unlinkSync(this.converted_filename);
+                }
+                result = undefined;
+            }
+
+            await this.vod.saveJSON("stream pauses padded");
+        }
+
+        try {
+            if (!result) {
+                result = await remuxFile(
+                    this.capture_filename,
+                    this.converted_filename,
+                    false,
+                    await this.saveChaptersForConvert()
+                );
+            }
         } catch (err) {
             log(
                 LOGLEVEL.ERROR,
diff --git a/server/src/Core/Providers/Base/BaseVOD.ts b/server/src/Core/Providers/Base/BaseVOD.ts
index e84b7997..fbc3d7d8 100644
--- a/server/src/Core/Providers/Base/BaseVOD.ts
+++ b/server/src/Core/Providers/Base/BaseVOD.ts
@@ -1,6 +1,13 @@
 import { debugLog } from "@/Helpers/Console";
 import { exec, isExecError, startJob } from "@/Helpers/Execute";
 import { formatBytes } from "@/Helpers/Format";
+import type { PauseInterval } from "@/Helpers/StreamPauses";
+import {
+    pausesToIntervals,
+    streamTimeToVideoTime,
+    syncChatDumpToVideo,
+    totalPauseDuration,
+} from "@/Helpers/StreamPauses";
 import { xClearTimeout, xTimeout } from "@/Helpers/Timeout";
 import { isTwitchVOD, isTwitchVODChapter } from "@/Helpers/Types";
 import {
@@ -11,6 +18,7 @@ import {
 } from "@/Helpers/Video";
 import type { BaseVODChapterJSON, VODJSON } from "@/Storage/JSON";
 import type { ApiBaseVod } from "@common/Api/Client";
+import type { TwitchCommentDumpTD } from "@common/Comments";
 import type { VODBookmark } from "@common/Bookmark";
 import type { VideoQuality } from "@common/Config";
 import type { Providers } from "@common/Defs";
@@ -124,6 +132,8 @@ export class BaseVOD {
     public path_chatmask = "";
     public path_chatburn = "";
     public path_chatdump = "";
+    /** Chat dump with offsets mapped to the captured video, see {@link syncChatdumpToVideo} */
+    public path_chatdump_synced = "";
     // path_adbreak = "";
     public path_playlist = "";
     public path_ffmpegchapters = "";
@@ -157,6 +167,12 @@ export class BaseVOD {
 
     public stream_pauses: StreamPause[] = [];
 
+    /**
+     * The stream pauses were filled with black video during conversion,
+     * so the captured video already matches the stream time.
+     */
+    public stream_pauses_padded = false;
+
     public bookmarks: Array<VODBookmark> = [];
 
     public is_capture_paused = false; // no longer a file, just a flag
@@ -195,6 +211,9 @@ export class BaseVOD {
             /** Live chat dump */
             `${this.basename}.chatdump`,
 
+            /** Live chat dump synced to the captured video */
+            `${this.basename}.synced.chatdump`,
+
             /** in-progress chat dump */
             `${this.basename}.chatdump.txt`,
 
@@ -253,6 +272,112 @@ export class BaseVOD {
         return this.path_chatdump !== "" && fs.existsSync(this.path_chatdump);
     }
 
+    /**
+     * Stream pauses (ad breaks) that were cut out of the captured video,
+     * as intervals in seconds since the stream started.
+     *
+     * Empty if there were no pauses or they were padded during conversion,
+     * meaning chat and chapter times already match the captured video.
+     */
+    public get pauseIntervals(): PauseInterval[] {
+        if (this.stream_pauses_padded || !this.started_at) return [];
+        return pausesToIntervals(this.stream_pauses, this.started_at);
+    }
+
+    /**
+     * Chat and chapter times need to be mapped to the captured video.
+     */
+    public get needs_video_sync(): boolean {
+        return this.pauseIntervals.length > 0;
+    }
+
+    /**
+     * Map seconds since the stream started to seconds in the captured video.
+     */
+    public streamTimeToVideoTime(seconds: number): number {
+        return streamTimeToVideoTime(seconds, this.pauseIntervals);
+    }
+
+    /**
+     * Write a copy of the chat dump with offsets mapped to the captured video.
+     * Does nothing if no sync is needed or the synced file is up to date, unless forced.
+     * @returns path to the synced chat dump, or false if no sync is needed or possible
+     */
+    public async syncChatdumpToVideo(force = false): Promise<string | false> {
+        if (!this.is_chatdump_captured || !this.path_chatdump_synced) {
+            return false;
+        }
+
+        const intervals = this.pauseIntervals;
+
+        if (intervals.length == 0) {
+            // remove a synced file left over from before the vod was padded
+            if (fs.existsSync(this.path_chatdump_synced)) {
+                fs.unlinkSync(this.path_chatdump_synced);
+            }
+            return false;
+        }
+
+        if (
+            !force &&
+            fs.existsSync(this.path_chatdump_synced) &&
+            fs.statSync(this.path_chatdump_synced).mtimeMs >=
+                fs.statSync(this.path_chatdump).mtimeMs
+        ) {
+            return this.path_chatdump_synced;
+        }
+
+        log(
+            LOGLEVEL.INFO,
+            "vod.syncChatdumpToVideo",
+            `Syncing chat dump of ${this.basename} to video, removing ${
+                intervals.length
+            } stream pauses (${Math.round(totalPauseDuration(intervals))}s)`
+        );
+
+        const dump: TwitchCommentDumpTD = JSON.parse(
+            await fs.promises.readFile(this.path_chatdump, "utf8")
+        );
+
+        if (!dump || !Array.isArray(dump.comments)) {
+            log(
+                LOGLEVEL.ERROR,
+                "vod.syncChatdumpToVideo",
+                `Chat dump of ${this.basename} has no comments array`
+            );
+            return false;
+        }
+
+        const synced = syncChatDumpToVideo(dump, intervals);
+
+        // write to a temp file first so a half-written file is never served
+        const tempPath = `${this.path_chatdump_synced}.tmp`;
+        await fs.promises.writeFile(tempPath, JSON.stringify(synced));
+        await fs.promises.rename(tempPath, this.path_chatdump_synced);
+
+        return this.path_chatdump_synced;
+    }
+
+    /**
+     * The chat dump to use together with the captured video,
+     * synced to the video if needed.
+     */
+    public async getChatdumpForVideo(): Promise<string> {
+        try {
+            const synced = await this.syncChatdumpToVideo();
+            if (synced) return synced;
+        } catch (error) {
+            log(
+                LOGLEVEL.ERROR,
+                "vod.getChatdumpForVideo",
+                `Failed to sync chat dump of ${
+                    this.basename
+                } to video, using the original: ${(error as Error).message}`
+            );
+        }
+        return this.path_chatdump;
+    }
+
     public get is_chat_rendered(): boolean {
         return (
             this.path_chatrender !== "" && fs.existsSync(this.path_chatrender)
@@ -626,6 +751,8 @@ export class BaseVOD {
                     end: v.end.toISOString(),
                 };
             }),
+            stream_pauses_padded: this.stream_pauses_padded,
+            needs_video_sync: this.needs_video_sync,
 
             api_getDuration: await this.getDuration(true),
             api_getRecordingSize: this.getRecordingSize(),
@@ -696,6 +823,7 @@ export class BaseVOD {
                 ? [{ start: pause.start.toJSON(), end: pause.end.toJSON() }]
                 : [];
         });
+        generated.stream_pauses_padded = this.stream_pauses_padded;
 
         generated.external_vod_exists = this.external_vod_exists;
         generated.external_vod_id = this.external_vod_id;
@@ -836,7 +964,9 @@ export class BaseVOD {
         font: string,
         font_size: number,
         use_downloaded: boolean,
-        overwrite: boolean
+        overwrite: boolean,
+        /** Sync the captured chat to the captured video, disable when burning onto the downloaded vod */
+        sync_to_video = true
     ): Promise<boolean> {
         if (use_downloaded && !this.is_chat_downloaded) {
             console.error(chalk.redBright("No chat downloaded"));
@@ -892,10 +1022,14 @@ export class BaseVOD {
         args.push("chatrender");
         args.push("--temp-path", BaseConfigCacheFolder.cache);
         args.push("--ffmpeg-path", ffmpegBin);
-        args.push(
-            "--input",
-            path.normalize(use_downloaded ? this.path_chat : this.path_chatdump)
-        );
+        let chatInput = this.path_chat;
+        if (!use_downloaded) {
+            chatInput = sync_to_video
+                ? await this.getChatdumpForVideo()
+                : this.path_chatdump;
+        }
+
+        args.push("--input", path.normalize(chatInput));
         args.push(
             "--chat-height",
             (chat_height ? chat_height : this.video_metadata.height).toString()
@@ -1465,6 +1599,8 @@ export class BaseVOD {
 
         // console.debug(`Calculating chapters for ${this.basename}, ${this.chapters.length} chapters`);
 
+        const pauseIntervals = this.pauseIntervals;
+
         this.chapters.forEach((chapter, index) => {
             if (!this.started_at) return; // thanks scoping
 
@@ -1475,7 +1611,8 @@ export class BaseVOD {
             chapter.calculateDurationAndOffset(
                 this.started_at,
                 this.ended_at,
-                nextChapter ? nextChapter.started_at : undefined
+                nextChapter ? nextChapter.started_at : undefined,
+                pauseIntervals
             );
         });
 
@@ -1518,8 +1655,9 @@ export class BaseVOD {
         const titleConfig = Config.getInstance().cfg("video.chapters.title");
 
         this.chapters.forEach((chapter) => {
-            const offset = chapter.offset || 0;
-            const duration = chapter.duration || 0;
+            // position in the captured video, corrected for stream pauses
+            const offset = chapter.video_offset ?? chapter.offset ?? 0;
+            const duration = chapter.video_duration ?? chapter.duration ?? 0;
             const start = Math.floor(offset * 1000);
             const end = Math.floor((offset + duration) * 1000);
             // const title = isTwitchVODChapter(chapter)
@@ -1855,6 +1993,9 @@ export class BaseVOD {
         this.path_chatdump = this.realpath(
             path.join(this.directory, `${this.basename}.chatdump`)
         );
+        this.path_chatdump_synced = this.realpath(
+            path.join(this.directory, `${this.basename}.synced.chatdump`)
+        );
         // this.path_adbreak = this.realpath(path.join(this.directory, `${this.basename}.adbreak`));
         this.path_playlist = this.realpath(
             path.join(this.directory, `${this.basename}.m3u8`)
@@ -1924,16 +2065,21 @@ export class BaseVOD {
         let data = "";
 
         this.chapters.forEach((chapter, i) => {
-            let offset = chapter.offset;
+            // position in the captured video, corrected for stream pauses
+            let offset = chapter.video_offset ?? chapter.offset;
             if (offset === undefined) return;
 
-            offset -= this.chapters[0].offset || 0;
+            offset -=
+                this.chapters[0].video_offset ?? this.chapters[0].offset ?? 0;
 
             data += offset + ","; // offset
 
             if (i < this.chapters.length - 1) {
                 // not last chapter
-                data += offset + (chapter.duration || 0) + ",";
+                data +=
+                    offset +
+                    (chapter.video_duration ?? chapter.duration ?? 0) +
+                    ",";
             } else {
                 // last chapter
                 data += ",";
@@ -2307,6 +2453,8 @@ export class BaseVOD {
                 });
         }
 
+        this.stream_pauses_padded = this.json.stream_pauses_padded ?? false;
+
         this.external_vod_id = this.json.external_vod_id;
         this.external_vod_title = this.json.external_vod_title;
         this.external_vod_date = this.json.external_vod_date
diff --git a/server/src/Core/Providers/Base/BaseVODChapter.ts b/server/src/Core/Providers/Base/BaseVODChapter.ts
index 2cdc226e..0b877767 100644
--- a/server/src/Core/Providers/Base/BaseVODChapter.ts
+++ b/server/src/Core/Providers/Base/BaseVODChapter.ts
@@ -1,6 +1,8 @@
 import type { VODTypes } from "@/Core/LiveStreamDVR";
 import { LiveStreamDVR } from "@/Core/LiveStreamDVR";
 import { LOGLEVEL, log } from "@/Core/Log";
+import type { PauseInterval } from "@/Helpers/StreamPauses";
+import { streamTimeToVideoTime } from "@/Helpers/StreamPauses";
 import type { BaseVODChapterJSON } from "@/Storage/JSON";
 import type { ApiVodBaseChapter } from "@common/Api/Client";
 import type { Providers } from "@common/Defs";
@@ -13,9 +15,15 @@ export class BaseVODChapter {
      */
     public started_at!: Date;
 
+    /** Seconds since the stream started */
     public offset?: number;
     public duration?: number;
 
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    public video_offset?: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    public video_duration?: number;
+
     public title = "";
 
     /**
@@ -28,7 +36,8 @@ export class BaseVODChapter {
     public calculateDurationAndOffset(
         vod_started_at: Date,
         vod_ended_at: Date | undefined,
-        next_chapter_started_at: Date | undefined
+        next_chapter_started_at: Date | undefined,
+        pause_intervals: PauseInterval[] = []
     ): void {
         if (vod_started_at.getTime() > this.started_at.getTime()) {
             // this chapter started before the vod started
@@ -76,6 +85,20 @@ export class BaseVODChapter {
                 (this.started_at.getTime() - vod_started_at.getTime()) / 1000;
         }
 
+        if (this.offset !== undefined) {
+            this.video_offset = streamTimeToVideoTime(
+                this.offset,
+                pause_intervals
+            );
+            this.video_duration =
+                this.duration !== undefined
+                    ? streamTimeToVideoTime(
+                          this.offset + this.duration,
+                          pause_intervals
+                      ) - this.video_offset
+                    : undefined;
+        }
+
         // console.debug(`Calculated duration and offset for chapter: ${this.title}`, this.offset, this.duration);
     }
 
@@ -91,6 +114,8 @@ export class BaseVODChapter {
 
             offset: this.offset || 0,
             duration: this.duration || 0,
+            video_offset: this.video_offset ?? this.offset ?? 0,
+            video_duration: this.video_duration ?? this.duration ?? 0,
 
             started_at: this.started_at.toISOString(),
 
diff --git a/server/src/Core/Providers/Twitch/TwitchVOD.ts b/server/src/Core/Providers/Twitch/TwitchVOD.ts
index d8ea6a82..b4f6f08d 100644
--- a/server/src/Core/Providers/Twitch/TwitchVOD.ts
+++ b/server/src/Core/Providers/Twitch/TwitchVOD.ts
@@ -2011,10 +2011,14 @@ export class TwitchVOD extends BaseVOD {
                 );
             }
 
+            // position in the captured video, corrected for stream pauses
+            const videoOffset = chapter.video_offset ?? chapter.offset;
+            const videoDuration = chapter.video_duration ?? chapter.duration;
+
             if (
-                chapter.offset < 0 ||
-                chapter.duration < 0 ||
-                chapter.offset > this.duration
+                videoOffset < 0 ||
+                videoDuration < 0 ||
+                videoOffset > this.duration
             ) {
                 log(
                     LOGLEVEL.ERROR,
@@ -2027,7 +2031,7 @@ export class TwitchVOD extends BaseVOD {
             }
 
             if (
-                chapter.offset + chapter.duration > this.duration &&
+                videoOffset + videoDuration > this.duration &&
                 chapterIndex != this.chapters.length
             ) {
                 log(
@@ -2040,8 +2044,8 @@ export class TwitchVOD extends BaseVOD {
                 );
             }
 
-            const chapterStart = chapter.offset || 0;
-            const chapterEnd = chapter.offset + chapter.duration;
+            const chapterStart = videoOffset || 0;
+            const chapterEnd = videoOffset + videoDuration;
 
             let basepath = this.directory;
 
@@ -2364,8 +2368,9 @@ export class TwitchVOD extends BaseVOD {
         let data = `WEBVTT - Generated by ${AppName}\n\n`;
 
         this.chapters.forEach((chapter, i) => {
-            const offset = chapter.offset || 0;
-            const duration = chapter.duration || 0;
+            // position in the captured video, corrected for stream pauses
+            const offset = chapter.video_offset ?? chapter.offset ?? 0;
+            const duration = chapter.video_duration ?? chapter.duration ?? 0;
 
             const start = offset;
             const end = offset + duration;
diff --git a/server/src/Core/Providers/Twitch/TwitchVODChapter.ts b/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
index 0e51cab3..0de26612 100644
--- a/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
+++ b/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
@@ -93,6 +93,8 @@ export class TwitchVODChapter extends BaseVODChapter {
 
             offset: this.offset || 0,
             duration: this.duration || 0,
+            video_offset: this.video_offset ?? this.offset ?? 0,
+            video_duration: this.video_duration ?? this.duration ?? 0,
 
             started_at: this.started_at.toISOString(),
 
diff --git a/server/src/Helpers/PadVideo.test.ts b/server/src/Helpers/PadVideo.test.ts
new file mode 100644
index 00000000..e9af99f3
--- /dev/null
+++ b/server/src/Helpers/PadVideo.test.ts
@@ -0,0 +1,211 @@
+import type { PacketScan } from "./PadVideo";
+import {
+    PacketScanner,
+    buildConcatList,
+    fillerUnitFrames,
+    planPadding,
+} from "./PadVideo";
+
+const fps = 60;
+const fd = 1 / fps;
+
+/**
+ * Scan of a capture starting at 1.4s with a keyframe every 2 seconds,
+ * with the given seconds of capture time removed (timestamp gaps), like streamlink does with ads.
+ */
+function makeScan(
+    length: number,
+    gaps: { at: number; length: number }[]
+): PacketScan {
+    const scanner = new PacketScanner(fd);
+    let shift = 0;
+    const sortedGaps = [...gaps].sort((a, b) => a.at - b.at);
+    for (let frame = 0; frame < length * fps; frame++) {
+        const t = frame / fps;
+        const gap = sortedGaps.find((g) => Math.abs(g.at - t) < fd / 2);
+        if (gap) shift += gap.length;
+        const dts = 1.4 + t + shift;
+        const keyframe = frame % (2 * fps) == 0;
+        scanner.addLine(
+            `${(dts + 2 * fd).toFixed(6)},${dts.toFixed(6)},${
+                keyframe ? "K__" : "___"
+            }`
+        );
+    }
+    const scan = scanner.result();
+    if (!scan) throw new Error("no scan");
+    return scan;
+}
+
+describe("PacketScanner", () => {
+    it("finds timestamp gaps and keyframes", () => {
+        const scan = makeScan(60, [{ at: 20, length: 16 }]);
+        expect(scan.start).toBeCloseTo(1.4 + 2 * fd);
+        expect(scan.gaps).toHaveLength(1);
+        expect(scan.gaps[0].length).toBeCloseTo(16);
+        expect(scan.keyframes).toHaveLength(30);
+    });
+
+    it("estimates the frame duration if not given", () => {
+        const scanner = new PacketScanner();
+        for (let i = 0; i < 100; i++)
+            scanner.addLine(`${i / 30},${i / 30},___`);
+        const scan = scanner.result();
+        expect(scan && scan.frameDuration).toBeCloseTo(1 / 30);
+    });
+
+    it("ignores invalid lines", () => {
+        const scanner = new PacketScanner(fd);
+        scanner.addLine("N/A,N/A,K__");
+        scanner.addLine("");
+        expect(scanner.result()).toBe(false);
+    });
+});
+
+describe("planPadding", () => {
+    it("places filler exactly at matching timestamp gaps", () => {
+        const scan = makeScan(54, [
+            { at: 20, length: 16 },
+            { at: 44, length: 20 },
+        ]);
+        // pauses as recorded by streamlink logs, a bit off
+        const plan = planPadding(scan, [
+            { start: 20.4, end: 36.3 },
+            { start: 60.3, end: 80.5 },
+        ]);
+        expect(plan.matchedPauses).toBe(2);
+        expect(plan.estimatedPauses).toBe(0);
+        expect(plan.collapsedGaps).toBe(0);
+        expect(plan.totalFiller).toBeCloseTo(36);
+        expect(plan.parts.map((p) => p.type)).toEqual([
+            "source",
+            "filler",
+            "source",
+            "filler",
+            "source",
+        ]);
+
+        const [first, , second, , third] = plan.parts;
+        expect(first.type == "source" && first.inpoint).toBe(undefined);
+        expect(first.type == "source" && first.outpoint).toBeCloseTo(1.4 + 20);
+        // continues at the keyframe dts after the gap
+        expect(second.type == "source" && second.inpoint).toBeCloseTo(1.4 + 36);
+        expect(third.type == "source" && third.inpoint).toBeCloseTo(
+            1.4 + 44 + 36
+        );
+    });
+
+    it("estimates the position when there are no timestamp gaps", () => {
+        const scan = makeScan(54, []);
+        const plan = planPadding(scan, [
+            { start: 20.4, end: 36.3 },
+            { start: 60.3, end: 80.5 },
+        ]);
+        expect(plan.matchedPauses).toBe(0);
+        expect(plan.estimatedPauses).toBe(2);
+        expect(plan.totalFiller).toBeCloseTo(15.9 + 20.2);
+        const sources = plan.parts.filter((p) => p.type == "source");
+        // snapped to the nearest keyframes, at 20s and 44s of the collapsed video
+        expect(sources[0].type == "source" && sources[0].outpoint).toBeCloseTo(
+            1.4 + 20
+        );
+        expect(sources[1].type == "source" && sources[1].inpoint).toBeCloseTo(
+            1.4 + 20
+        );
+        expect(sources[1].type == "source" && sources[1].outpoint).toBeCloseTo(
+            1.4 + 44
+        );
+    });
+
+    it("collapses gaps without a matching pause like a normal conversion", () => {
+        const scan = makeScan(54, [{ at: 30, length: 12 }]);
+        const plan = planPadding(scan, []);
+        expect(plan.collapsedGaps).toBe(1);
+        expect(plan.totalFiller).toBe(0);
+        expect(plan.parts.map((p) => p.type)).toEqual(["source", "source"]);
+    });
+
+    it("does not match a gap of a very different length", () => {
+        const scan = makeScan(54, [{ at: 20, length: 60 }]);
+        const plan = planPadding(scan, [{ start: 20, end: 36 }]);
+        expect(plan.matchedPauses).toBe(0);
+        expect(plan.estimatedPauses).toBe(1);
+        expect(plan.collapsedGaps).toBe(1);
+    });
+
+    it("puts filler for a pause at the start before the first frame", () => {
+        const scan = makeScan(30, []);
+        const plan = planPadding(scan, [{ start: 0, end: 15 }]);
+        expect(plan.parts[0]).toEqual({ type: "filler", duration: 15 });
+        expect(plan.parts[1]).toEqual({ type: "source", inpoint: undefined });
+    });
+
+    it("merges pauses that snap to the same keyframe", () => {
+        const scan = makeScan(30, []);
+        const plan = planPadding(scan, [
+            { start: 10, end: 11 },
+            { start: 11.2, end: 12 },
+        ]);
+        expect(plan.parts.filter((p) => p.type == "filler")).toHaveLength(1);
+        expect(plan.totalFiller).toBeCloseTo(1.8);
+    });
+});
+
+describe("fillerUnitFrames", () => {
+    it("is a whole number of video and aac frames", () => {
+        for (const [rate, sampleRate] of [
+            [60, 48000],
+            [30, 48000],
+            [30000 / 1001, 48000],
+            [60, 44100],
+        ]) {
+            const frames = fillerUnitFrames(rate, sampleRate);
+            const seconds = frames / rate;
+            const aacFrames = (seconds * sampleRate) / 1024;
+            expect(Math.abs(aacFrames - Math.round(aacFrames))).toBeLessThan(
+                1e-6
+            );
+            expect(seconds).toBeGreaterThanOrEqual(4);
+        }
+    });
+});
+
+describe("buildConcatList", () => {
+    it("repeats the filler unit and trims the last one", () => {
+        const list = buildConcatList(
+            {
+                parts: [
+                    { type: "source", outpoint: 21.4 },
+                    { type: "filler", duration: 10 },
+                    { type: "source", inpoint: 37.4 },
+                ],
+                matchedPauses: 1,
+                estimatedPauses: 0,
+                collapsedGaps: 0,
+                totalFiller: 10,
+                messages: [],
+            },
+            "/data/it's.ts",
+            "/cache/filler.ts",
+            1.4,
+            4
+        );
+        expect(list).toBe(
+            [
+                "ffconcat version 1.0",
+                "file '/data/it'\\''s.ts'",
+                "outpoint 21.400000",
+                "file '/cache/filler.ts'",
+                "duration 4.000000",
+                "file '/cache/filler.ts'",
+                "duration 4.000000",
+                "file '/cache/filler.ts'",
+                "outpoint 3.400000",
+                "duration 2.000000",
+                "file '/data/it'\\''s.ts'",
+                "inpoint 37.400000",
+                "",
+            ].join("\n")
+        );
+    });
+});
diff --git a/server/src/Helpers/PadVideo.ts b/server/src/Helpers/PadVideo.ts
new file mode 100644
index 00000000..ac0d017f
--- /dev/null
+++ b/server/src/Helpers/PadVideo.ts
@@ -0,0 +1,421 @@
+import type { PauseInterval } from "./StreamPauses";
+import { streamTimeToVideoTime } from "./StreamPauses";
+
+/**
+ * Filling stream pauses (ad breaks) with black video when converting a capture.
+ *
+ * Streamlink drops the ad segments, so the captured video is shorter than the stream
+ * and everything timed against the stream (chat, chapters) drifts after every ad break.
+ * Here the capture is cut at each pause and a black, silent filler of the pause length
+ * is inserted, using only stream copy for the capture itself.
+ *
+ * The cut points are taken from timestamp jumps in the capture when they match a recorded
+ * pause, otherwise they are estimated from the recorded pause times and snapped to a keyframe.
+ */
+
+/** Timestamp jumps shorter than this are not considered gaps */
+export const GAP_MIN_SECONDS = 5;
+
+/** How far (in seconds) a timestamp gap may be from the expected pause position to match it */
+export const GAP_MATCH_POSITION_TOLERANCE = 60;
+
+export interface Keyframe {
+    pts: number;
+    dts: number;
+}
+
+export interface TimestampGap {
+    /** dts of the last video packet before the gap */
+    before: number;
+    /** dts of the first video packet after the gap */
+    after: number;
+    /** missing time in seconds */
+    length: number;
+}
+
+/** Result of scanning the video packets of a capture */
+export interface PacketScan {
+    /** pts of the first video packet */
+    start: number;
+    /** dts of the last video packet */
+    end: number;
+    frameDuration: number;
+    /** sorted by pts */
+    keyframes: Keyframe[];
+    /** sorted by position */
+    gaps: TimestampGap[];
+}
+
+export type PadPart =
+    | {
+          type: "source";
+          /**
+           * timestamp in the capture to start at, the dts of a keyframe.
+           * using the pts makes the concat demuxer start after the keyframe and break decoding
+           */
+          inpoint?: number;
+          /** dts in the capture to stop at */
+          outpoint?: number;
+      }
+    | {
+          type: "filler";
+          duration: number;
+      };
+
+export interface PadPlan {
+    parts: PadPart[];
+    /** pauses placed exactly at a timestamp gap */
+    matchedPauses: number;
+    /** pauses placed at an estimated position */
+    estimatedPauses: number;
+    /** timestamp gaps without a matching pause, collapsed like a normal conversion */
+    collapsedGaps: number;
+    totalFiller: number;
+    messages: string[];
+}
+
+interface Cut {
+    /** sort key, position in the capture */
+    position: number;
+    /** dts to stop the previous source part at, undefined to insert before the first frame */
+    outpoint?: number;
+    /** keyframe dts to continue at, undefined if the capture ends here */
+    inpoint?: number;
+    filler: number;
+}
+
+/**
+ * Scan ffprobe packet output lines (`pts_time,dts_time,flags`) of a video stream.
+ */
+export class PacketScanner {
+    private start?: number;
+    private lastDts?: number;
+    private keyframes: Keyframe[] = [];
+    private gaps: { before: number; after: number }[] = [];
+    private deltas: number[] = [];
+
+    public constructor(private frameDuration?: number) {}
+
+    public addLine(line: string): void {
+        const [ptsText, dtsText, flags] = line.trim().split(",");
+        const pts = parseFloat(ptsText);
+        const dts = parseFloat(dtsText);
+        if (isNaN(dts)) return;
+
+        if (this.start === undefined && !isNaN(pts)) this.start = pts;
+
+        if (flags && flags.includes("K") && !isNaN(pts)) {
+            this.keyframes.push({ pts, dts });
+        }
+
+        if (this.lastDts !== undefined) {
+            const delta = dts - this.lastDts;
+            if (delta >= GAP_MIN_SECONDS) {
+                this.gaps.push({ before: this.lastDts, after: dts });
+            } else if (this.deltas.length < 500 && delta > 0) {
+                this.deltas.push(delta);
+            }
+        }
+
+        this.lastDts = dts;
+    }
+
+    public result(): PacketScan | false {
+        if (this.start === undefined || this.lastDts === undefined) {
+            return false;
+        }
+
+        let frameDuration = this.frameDuration;
+        if (!frameDuration) {
+            if (this.deltas.length == 0) return false;
+            const sorted = [...this.deltas].sort((a, b) => a - b);
+            frameDuration = sorted[Math.floor(sorted.length / 2)];
+        }
+
+        return {
+            start: this.start,
+            end: this.lastDts,
+            frameDuration,
+            keyframes: [...this.keyframes].sort((a, b) => a.pts - b.pts),
+            gaps: this.gaps.map((g) => ({
+                ...g,
+                length: g.after - g.before - (frameDuration as number),
+            })),
+        };
+    }
+}
+
+function firstKeyframeAtOrAfter(
+    keyframes: Keyframe[],
+    time: number
+): Keyframe | undefined {
+    return keyframes.find((k) => k.pts >= time - 0.001);
+}
+
+function nearestKeyframe(
+    keyframes: Keyframe[],
+    time: number
+): Keyframe | undefined {
+    let best: Keyframe | undefined;
+    for (const k of keyframes) {
+        if (!best || Math.abs(k.pts - time) < Math.abs(best.pts - time)) {
+            best = k;
+        }
+    }
+    return best;
+}
+
+/**
+ * Plan where to cut the capture and how much filler to insert.
+ *
+ * @param scan video packet scan of the capture
+ * @param intervals stream pauses in seconds since the stream started
+ */
+export function planPadding(
+    scan: PacketScan,
+    intervals: PauseInterval[]
+): PadPlan {
+    const messages: string[] = [];
+
+    // position of each gap in the collapsed timeline (all gaps removed), like a normal conversion
+    let removedBefore = 0;
+    const gaps = scan.gaps.map((gap) => {
+        const collapsed =
+            gap.before + scan.frameDuration - scan.start - removedBefore;
+        removedBefore += gap.length;
+        return { ...gap, collapsed, matched: false };
+    });
+
+    const cuts: Cut[] = [];
+    let matchedPauses = 0;
+    let estimatedPauses = 0;
+
+    for (const pause of intervals) {
+        const duration = pause.end - pause.start;
+        // where the pause is in the collapsed video, assuming the video starts when the stream started
+        const expected = streamTimeToVideoTime(pause.start, intervals);
+
+        let match: (typeof gaps)[number] | undefined;
+        for (const gap of gaps) {
+            if (gap.matched) continue;
+            if (
+                Math.abs(gap.collapsed - expected) >
+                GAP_MATCH_POSITION_TOLERANCE
+            )
+                continue;
+            if (Math.abs(gap.length - duration) > Math.max(10, duration * 0.25))
+                continue;
+            if (
+                !match ||
+                Math.abs(gap.collapsed - expected) <
+                    Math.abs(match.collapsed - expected)
+            ) {
+                match = gap;
+            }
+        }
+
+        if (match) {
+            match.matched = true;
+            matchedPauses++;
+            const resume = firstKeyframeAtOrAfter(scan.keyframes, match.after);
+            cuts.push({
+                position: match.before,
+                outpoint: match.before + scan.frameDuration,
+                inpoint: resume?.dts,
+                filler: match.length,
+            });
+            messages.push(
+                `Pause at ${expected.toFixed(1)}s (${duration.toFixed(
+                    1
+                )}s) matched timestamp gap at ${match.collapsed.toFixed(
+                    1
+                )}s (${match.length.toFixed(1)}s)`
+            );
+            continue;
+        }
+
+        // no gap, estimate the position in the capture and snap it to a keyframe
+        estimatedPauses++;
+        const gapsBefore = gaps
+            .filter((g) => g.collapsed <= expected)
+            .reduce((acc, g) => acc + g.length, 0);
+        const target = scan.start + expected + gapsBefore;
+
+        if (target <= scan.start + scan.frameDuration) {
+            cuts.push({ position: scan.start, filler: duration });
+        } else if (target >= scan.end) {
+            cuts.push({
+                position: scan.end,
+                outpoint: scan.end + scan.frameDuration,
+                filler: duration,
+            });
+        } else {
+            const keyframe = nearestKeyframe(scan.keyframes, target);
+            if (!keyframe || keyframe.pts <= scan.start) {
+                cuts.push({ position: scan.start, filler: duration });
+            } else {
+                cuts.push({
+                    position: keyframe.pts,
+                    outpoint: keyframe.dts,
+                    inpoint: keyframe.dts,
+                    filler: duration,
+                });
+            }
+        }
+        messages.push(
+            `Pause at ${expected.toFixed(1)}s (${duration.toFixed(
+                1
+            )}s) has no timestamp gap, placed at the nearest keyframe`
+        );
+    }
+
+    // gaps without a pause (e.g. network issues) are collapsed, like a normal conversion
+    let collapsedGaps = 0;
+    for (const gap of gaps) {
+        if (gap.matched) continue;
+        collapsedGaps++;
+        const resume = firstKeyframeAtOrAfter(scan.keyframes, gap.after);
+        cuts.push({
+            position: gap.before,
+            outpoint: gap.before + scan.frameDuration,
+            inpoint: resume?.dts,
+            filler: 0,
+        });
+        messages.push(
+            `Timestamp gap at ${gap.collapsed.toFixed(
+                1
+            )}s (${gap.length.toFixed(1)}s) has no matching pause, collapsed`
+        );
+    }
+
+    cuts.sort((a, b) => a.position - b.position);
+
+    const parts: PadPart[] = [];
+    let inpoint: number | undefined = undefined;
+    let ended = false;
+
+    for (const cut of cuts) {
+        if (ended) {
+            // capture already ended, only filler can follow
+            if (cut.filler > 0)
+                parts.push({ type: "filler", duration: cut.filler });
+            continue;
+        }
+
+        if (cut.outpoint !== undefined) {
+            if (inpoint === undefined || cut.outpoint > inpoint) {
+                parts.push({ type: "source", inpoint, outpoint: cut.outpoint });
+            }
+        }
+
+        if (cut.filler > 0) {
+            parts.push({ type: "filler", duration: cut.filler });
+        }
+
+        if (cut.outpoint === undefined) {
+            // filler before the first frame, the capture continues from where it was
+            continue;
+        }
+
+        if (cut.inpoint === undefined) {
+            ended = true;
+        } else {
+            inpoint = cut.inpoint;
+        }
+    }
+
+    if (!ended) {
+        parts.push({ type: "source", inpoint });
+    }
+
+    // merge adjacent fillers
+    const merged: PadPart[] = [];
+    for (const part of parts) {
+        const last = merged[merged.length - 1];
+        if (part.type == "filler" && last && last.type == "filler") {
+            last.duration += part.duration;
+        } else {
+            merged.push({ ...part });
+        }
+    }
+
+    const totalFiller = merged.reduce(
+        (acc, p) => acc + (p.type == "filler" ? p.duration : 0),
+        0
+    );
+
+    return {
+        parts: merged,
+        matchedPauses,
+        estimatedPauses,
+        collapsedGaps,
+        totalFiller,
+        messages,
+    };
+}
+
+/**
+ * Number of video frames in one filler unit, chosen so that the unit is a whole number
+ * of both video frames and AAC frames (1024 samples), so repeated units don't drift.
+ */
+export function fillerUnitFrames(
+    fps: number,
+    sampleRate: number,
+    minSeconds = 4
+): number {
+    let base = Math.max(1, Math.round(fps));
+    for (let n = 1; n <= 1024; n++) {
+        const aacFrames = (n / fps) * (sampleRate / 1024);
+        if (Math.abs(aacFrames - Math.round(aacFrames)) < 1e-6) {
+            base = n;
+            break;
+        }
+    }
+    const baseSeconds = base / fps;
+    return base * Math.max(1, Math.ceil(minSeconds / baseSeconds));
+}
+
+function escapeConcatPath(file: string): string {
+    return `'${file.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Write an ffconcat list for the plan.
+ *
+ * @param source capture file
+ * @param filler filler unit file
+ * @param fillerStart start_time of the filler file
+ * @param fillerUnit duration of the filler unit
+ */
+export function buildConcatList(
+    plan: PadPlan,
+    source: string,
+    filler: string,
+    fillerStart: number,
+    fillerUnit: number
+): string {
+    const lines = ["ffconcat version 1.0"];
+
+    for (const part of plan.parts) {
+        if (part.type == "source") {
+            lines.push(`file ${escapeConcatPath(source)}`);
+            if (part.inpoint !== undefined)
+                lines.push(`inpoint ${part.inpoint.toFixed(6)}`);
+            if (part.outpoint !== undefined)
+                lines.push(`outpoint ${part.outpoint.toFixed(6)}`);
+        } else {
+            let remaining = part.duration;
+            while (remaining > 0.001) {
+                const length = Math.min(fillerUnit, remaining);
+                lines.push(`file ${escapeConcatPath(filler)}`);
+                if (length < fillerUnit - 0.001) {
+                    lines.push(`outpoint ${(fillerStart + length).toFixed(6)}`);
+                }
+                lines.push(`duration ${length.toFixed(6)}`);
+                remaining -= length;
+            }
+        }
+    }
+
+    return lines.join("\n") + "\n";
+}
diff --git a/server/src/Helpers/StreamPauses.test.ts b/server/src/Helpers/StreamPauses.test.ts
new file mode 100644
index 00000000..f6b45253
--- /dev/null
+++ b/server/src/Helpers/StreamPauses.test.ts
@@ -0,0 +1,187 @@
+import type { TwitchComment, TwitchCommentDumpTD } from "@common/Comments";
+import {
+    pausesToIntervals,
+    streamTimeToVideoTime,
+    syncChatDumpToVideo,
+    totalPauseDuration,
+} from "./StreamPauses";
+
+// capture 43333681128, a real stream with 8 ad breaks
+const started_at = new Date("2024-12-08T13:47:21.000Z");
+const pauses = [
+    ["2024-12-08T13:47:37.022Z", "2024-12-08T13:47:52.090Z"],
+    ["2024-12-08T14:49:27.406Z", "2024-12-08T14:51:02.077Z"],
+    ["2024-12-08T15:47:47.205Z", "2024-12-08T15:49:52.073Z"],
+    ["2024-12-08T16:09:47.309Z", "2024-12-08T16:11:52.038Z"],
+    ["2024-12-08T16:34:52.405Z", "2024-12-08T16:35:57.090Z"],
+    ["2024-12-08T16:48:49.121Z", "2024-12-08T16:50:52.053Z"],
+    ["2024-12-08T16:57:29.045Z", "2024-12-08T16:58:32.088Z"],
+    ["2024-12-08T17:22:07.156Z", "2024-12-08T17:24:12.100Z"],
+].map(([start, end]) => ({ start: new Date(start), end: new Date(end) }));
+
+const secondsSinceStart = (iso: string) =>
+    (new Date(iso).getTime() - started_at.getTime()) / 1000;
+
+describe("pausesToIntervals", () => {
+    it("converts the example stream pauses", () => {
+        const intervals = pausesToIntervals(pauses, started_at);
+        expect(intervals).toHaveLength(8);
+        expect(intervals[0].start).toBeCloseTo(16.022);
+        expect(intervals[0].end).toBeCloseTo(31.09);
+        expect(totalPauseDuration(intervals)).toBeCloseTo(734.94, 1);
+    });
+
+    it("returns nothing without pauses", () => {
+        expect(pausesToIntervals([], started_at)).toEqual([]);
+    });
+
+    it("ignores negligible pauses", () => {
+        expect(
+            pausesToIntervals(
+                [
+                    {
+                        start: new Date("2024-12-08T14:00:00.000Z"),
+                        end: new Date("2024-12-08T14:00:00.500Z"),
+                    },
+                ],
+                started_at
+            )
+        ).toEqual([]);
+    });
+
+    it("drops invalid pauses and merges overlapping ones", () => {
+        const intervals = pausesToIntervals(
+            [
+                {
+                    start: new Date("2024-12-08T14:00:30.000Z"),
+                    end: new Date("2024-12-08T14:01:30.000Z"),
+                },
+                {
+                    start: new Date("2024-12-08T14:00:00.000Z"),
+                    end: new Date("2024-12-08T14:01:00.000Z"),
+                },
+                {
+                    start: new Date("2024-12-08T15:00:00.000Z"),
+                    end: new Date("2024-12-08T14:59:00.000Z"),
+                },
+                { start: new Date("2024-12-08T15:00:00.000Z") },
+                {
+                    start: new Date("invalid"),
+                    end: new Date("2024-12-08T15:00:00.000Z"),
+                },
+            ],
+            started_at
+        );
+        expect(intervals).toHaveLength(1);
+        expect(intervals[0].end - intervals[0].start).toBeCloseTo(90);
+    });
+});
+
+describe("streamTimeToVideoTime", () => {
+    const intervals = pausesToIntervals(pauses, started_at);
+
+    it("does not change anything without pauses", () => {
+        expect(streamTimeToVideoTime(1234.5, [])).toBe(1234.5);
+    });
+
+    it("does not move times before the first pause", () => {
+        expect(streamTimeToVideoTime(10, intervals)).toBe(10);
+    });
+
+    it("moves times after a pause back by the pause duration", () => {
+        // 1:00:00 into the stream, only the pre-roll has passed
+        expect(streamTimeToVideoTime(3600, intervals)).toBeCloseTo(
+            3600 - 15.068
+        );
+        // 2:00:00, pre-roll and first mid-roll
+        expect(streamTimeToVideoTime(7200, intervals)).toBeCloseTo(
+            7200 - 15.068 - 94.671
+        );
+    });
+
+    it("moves times after the last pause back by all pauses", () => {
+        const end = secondsSinceStart("2024-12-08T18:25:32.134Z");
+        expect(end - streamTimeToVideoTime(end, intervals)).toBeCloseTo(
+            734.94,
+            1
+        );
+    });
+
+    it("maps times inside a pause to the cut point", () => {
+        const pauseStart = secondsSinceStart("2024-12-08T14:49:27.406Z");
+        const cut = streamTimeToVideoTime(pauseStart, intervals);
+        expect(streamTimeToVideoTime(pauseStart + 30, intervals)).toBeCloseTo(
+            cut
+        );
+        expect(streamTimeToVideoTime(pauseStart + 94, intervals)).toBeCloseTo(
+            cut
+        );
+    });
+
+    it("is monotonic", () => {
+        let last = -1;
+        for (let t = 0; t < 17000; t += 7) {
+            const v = streamTimeToVideoTime(t, intervals);
+            expect(v).toBeGreaterThanOrEqual(last);
+            last = v;
+        }
+    });
+
+    it("maps the second chapter of the example stream", () => {
+        const chapter = secondsSinceStart("2024-12-08T15:47:34.092Z");
+        expect(chapter).toBeCloseTo(7213.092);
+        expect(streamTimeToVideoTime(chapter, intervals)).toBeCloseTo(
+            7213.092 - 109.739
+        );
+    });
+});
+
+describe("syncChatDumpToVideo", () => {
+    const comment = (id: string, offset: number) =>
+        ({
+            _id: id,
+            content_offset_seconds: offset,
+        }) as unknown as TwitchComment;
+
+    const dump = {
+        comments: [
+            comment("a", 10),
+            comment("b", 50),
+            comment("c", 40),
+            comment("d", 100),
+        ],
+        video: {
+            title: "Chat Dump",
+            description: "",
+            id: "",
+            created_at: "",
+            start: 0,
+            end: 100,
+            length: 100,
+            viewCount: 0,
+            game: "",
+            chapters: [],
+        },
+        embeddedData: null,
+    } as TwitchCommentDumpTD;
+
+    it("maps offsets, collapses comments during pauses and keeps order", () => {
+        const result = syncChatDumpToVideo(dump, [{ start: 20, end: 60 }]);
+        expect(
+            result.comments.map((c) => [c._id, c.content_offset_seconds])
+        ).toEqual([
+            ["a", 10],
+            ["b", 20],
+            ["c", 20],
+            ["d", 60],
+        ]);
+        expect(result.video.length).toBe(60);
+        expect(result.video.end).toBe(60);
+    });
+
+    it("does not modify the original dump", () => {
+        syncChatDumpToVideo(dump, [{ start: 20, end: 60 }]);
+        expect(dump.comments[1].content_offset_seconds).toBe(50);
+        expect(dump.video.length).toBe(100);
+    });
+});
diff --git a/server/src/Helpers/StreamPauses.ts b/server/src/Helpers/StreamPauses.ts
new file mode 100644
index 00000000..bd272e9e
--- /dev/null
+++ b/server/src/Helpers/StreamPauses.ts
@@ -0,0 +1,131 @@
+import type { TwitchComment, TwitchCommentDumpTD } from "@common/Comments";
+
+/**
+ * A stream pause (usually an ad break filtered out by streamlink) as an
+ * interval in seconds relative to the stream start (started_at).
+ */
+export interface PauseInterval {
+    start: number;
+    end: number;
+}
+
+/**
+ * Pauses shorter than this in total are ignored, the video and chat are
+ * considered to be in sync already.
+ */
+export const MIN_TOTAL_PAUSE_SECONDS = 1;
+
+export function totalPauseDuration(intervals: PauseInterval[]): number {
+    return intervals.reduce((acc, p) => acc + (p.end - p.start), 0);
+}
+
+/**
+ * Convert stream pauses (wall-clock dates) to sorted, non-overlapping
+ * intervals in seconds relative to the stream start.
+ *
+ * Invalid pauses (missing dates, end before start) are dropped,
+ * pauses before the stream start are clipped to 0.
+ *
+ * Returns an empty array if the total pause duration is negligible,
+ * meaning no correction should be applied.
+ */
+export function pausesToIntervals(
+    pauses: { start?: Date; end?: Date }[],
+    started_at: Date
+): PauseInterval[] {
+    const base = started_at.getTime();
+
+    const intervals = pauses
+        .filter(
+            (p): p is { start: Date; end: Date } =>
+                p.start instanceof Date &&
+                p.end instanceof Date &&
+                !isNaN(p.start.getTime()) &&
+                !isNaN(p.end.getTime())
+        )
+        .map((p) => ({
+            start: Math.max(0, (p.start.getTime() - base) / 1000),
+            end: Math.max(0, (p.end.getTime() - base) / 1000),
+        }))
+        .filter((p) => p.end > p.start)
+        .sort((a, b) => a.start - b.start);
+
+    // merge overlapping intervals
+    const merged: PauseInterval[] = [];
+    for (const interval of intervals) {
+        const last = merged[merged.length - 1];
+        if (last && interval.start <= last.end) {
+            last.end = Math.max(last.end, interval.end);
+        } else {
+            merged.push({ ...interval });
+        }
+    }
+
+    if (totalPauseDuration(merged) < MIN_TOTAL_PAUSE_SECONDS) return [];
+
+    return merged;
+}
+
+/**
+ * Map a time in the stream (seconds since started_at, how chat and chapters are timed)
+ * to a time in the captured video, where the paused sections have been cut out.
+ *
+ * Times inside a pause are mapped to the point where the pause was cut.
+ */
+export function streamTimeToVideoTime(
+    seconds: number,
+    intervals: PauseInterval[]
+): number {
+    let removed = 0;
+    for (const pause of intervals) {
+        if (seconds >= pause.end) {
+            removed += pause.end - pause.start;
+        } else if (seconds > pause.start) {
+            removed += seconds - pause.start;
+            break;
+        } else {
+            break;
+        }
+    }
+    return seconds - removed;
+}
+
+/**
+ * Return a copy of a chat dump with all comment offsets mapped to video time.
+ * Comments are sorted by their new offset, the original order is kept for equal offsets.
+ */
+export function syncChatDumpToVideo(
+    dump: TwitchCommentDumpTD,
+    intervals: PauseInterval[]
+): TwitchCommentDumpTD {
+    const comments: TwitchComment[] = dump.comments
+        .map((comment, index) => ({
+            comment: {
+                ...comment,
+                content_offset_seconds: streamTimeToVideoTime(
+                    comment.content_offset_seconds,
+                    intervals
+                ),
+            },
+            index,
+        }))
+        .sort(
+            (a, b) =>
+                a.comment.content_offset_seconds -
+                    b.comment.content_offset_seconds || a.index - b.index
+        )
+        .map((c) => c.comment);
+
+    const result: TwitchCommentDumpTD = { ...dump, comments };
+
+    if (dump.video) {
+        result.video = {
+            ...dump.video,
+            start: streamTimeToVideoTime(dump.video.start || 0, intervals),
+            end: streamTimeToVideoTime(dump.video.end || 0, intervals),
+            length: streamTimeToVideoTime(dump.video.length || 0, intervals),
+        };
+    }
+
+    return result;
+}
diff --git a/server/src/Helpers/Video.ts b/server/src/Helpers/Video.ts
index 2f175294..4a2522a1 100644
--- a/server/src/Helpers/Video.ts
+++ b/server/src/Helpers/Video.ts
@@ -15,6 +15,16 @@ import path from "node:path";
 import { progressOutput } from "./Console";
 import { exec, execSimple, isExecError, startJob } from "./Execute";
 import { formatDuration } from "./Format";
+import type { PadPlan } from "./PadVideo";
+import {
+    PacketScanner,
+    buildConcatList,
+    fillerUnitFrames,
+    planPadding,
+} from "./PadVideo";
+import type { PauseInterval } from "./StreamPauses";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
 
 export interface RemuxReturn {
     stdout: string[];
@@ -36,7 +46,9 @@ export async function remuxFile(
     input: string,
     output: string,
     overwrite = false,
-    metadata_file?: string
+    metadata_file?: string,
+    /** options placed before the input, e.g. the input format */
+    input_options: string[] = []
 ): Promise<RemuxReturn> {
     const ffmpegPath = Helper.path_ffmpeg();
 
@@ -64,6 +76,7 @@ export async function remuxFile(
     const opts: string[] = [];
     // "-r", parseInt(info.video.FrameRate).toString(),
     // "-vsync", "cfr",
+    opts.push(...input_options);
     opts.push("-i", input);
 
     // write metadata to file
@@ -620,6 +633,216 @@ export async function ffprobe(filename: string): Promise<FFProbe> {
     }
 }
 
+function parseFrameRate(rate?: string): number | undefined {
+    if (!rate) return undefined;
+    const [num, den] = rate.split("/").map((v) => parseFloat(v));
+    const fps = den ? num / den : num;
+    return fps > 0 && isFinite(fps) ? fps : undefined;
+}
+
+/**
+ * Scan the timestamps of all video packets in a file, streaming the ffprobe output.
+ */
+function scanVideoPackets(
+    ffprobePath: string,
+    input: string,
+    frameDuration?: number
+): Promise<ReturnType<PacketScanner["result"]>> {
+    return new Promise((resolve, reject) => {
+        const scanner = new PacketScanner(frameDuration);
+        const proc = spawn(ffprobePath, [
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "packet=pts_time,dts_time,flags",
+            "-of",
+            "csv=p=0",
+            input,
+        ]);
+        const stderr: string[] = [];
+        proc.stderr.on("data", (data: Buffer) => stderr.push(data.toString()));
+        const lines = readline.createInterface({ input: proc.stdout });
+        lines.on("line", (line) => scanner.addLine(line));
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(
+                    new Error(
+                        `ffprobe packet scan failed (${code}): ${stderr
+                            .join("")
+                            .slice(0, 500)}`
+                    )
+                );
+                return;
+            }
+            resolve(scanner.result());
+        });
+    });
+}
+
+/**
+ * Remux a capture, filling the stream pauses (ad breaks) with black, silent video
+ * so the video length matches the stream and chat/chapters stay in sync.
+ *
+ * The capture itself is only stream copied, just the short filler unit is encoded.
+ * Throws if the capture can't be padded, the caller should fall back to {@link remuxFile}.
+ *
+ * @param intervals stream pauses in seconds since the stream started
+ */
+export async function remuxFileWithPadding(
+    input: string,
+    output: string,
+    intervals: PauseInterval[],
+    metadata_file?: string
+): Promise<RemuxReturn & { plan: PadPlan }> {
+    const ffmpegPath = Helper.path_ffmpeg();
+    const ffprobePath = Helper.path_ffprobe();
+    if (!ffmpegPath) throw new Error("Failed to find ffmpeg");
+    if (!ffprobePath || !fs.existsSync(ffprobePath)) {
+        throw new Error("Failed to find ffprobe");
+    }
+
+    const probe = await ffprobe(input);
+    const video = probe.streams.find((s) => s.codec_type == "video");
+    const audio = probe.streams.find((s) => s.codec_type == "audio");
+    if (!video || video.codec_type != "video" || video.codec_name != "h264") {
+        throw new Error("Padding needs an h264 video stream");
+    }
+    if (!audio || audio.codec_type != "audio" || audio.codec_name != "aac") {
+        throw new Error("Padding needs an aac audio stream");
+    }
+
+    const fps =
+        parseFrameRate(video.r_frame_rate) ||
+        parseFrameRate(video.avg_frame_rate);
+    const sampleRate = Number(audio.sample_rate);
+    if (!fps || !sampleRate || !video.width || !video.height) {
+        throw new Error(
+            "Could not determine video/audio parameters for padding"
+        );
+    }
+
+    log(
+        LOGLEVEL.INFO,
+        "video.remuxPadded",
+        `Scanning video timestamps of ${input}`
+    );
+    progressOutput(`🎞 Scanning ${path.basename(input)} for ad breaks`);
+
+    const scan = await scanVideoPackets(ffprobePath, input, 1 / fps);
+    if (!scan) throw new Error("No video packets found");
+
+    const plan = planPadding(scan, intervals);
+    for (const message of plan.messages) {
+        log(LOGLEVEL.INFO, "video.remuxPadded", message);
+    }
+    log(
+        LOGLEVEL.INFO,
+        "video.remuxPadded",
+        `Padding plan for ${path.basename(input)}: ${
+            plan.matchedPauses
+        } pauses at timestamp gaps, ` +
+            `${plan.estimatedPauses} estimated, ${plan.collapsedGaps} gaps collapsed, ` +
+            `${plan.totalFiller.toFixed(1)}s filler in ${
+                plan.parts.length
+            } parts`
+    );
+
+    if (plan.totalFiller < 1) throw new Error("Nothing to pad");
+
+    // encode one filler unit matching the capture, it's repeated for the whole pause
+    const unitFrames = fillerUnitFrames(fps, sampleRate);
+    const unitSeconds = unitFrames / fps;
+    const workBase = path.join(
+        BaseConfigCacheFolder.cache,
+        `pad_${path.basename(input, path.extname(input))}`
+    );
+    const fillerFile = `${workBase}_filler.ts`;
+    const listFile = `${workBase}.ffconcat`;
+
+    const profile = (video.profile || "").toLowerCase();
+    const x264Profile = profile.includes("baseline")
+        ? "baseline"
+        : profile == "main"
+        ? "main"
+        : "high";
+
+    try {
+        await execSimple(
+            ffmpegPath,
+            [
+                "-y",
+                "-f",
+                "lavfi",
+                "-i",
+                `color=c=black:s=${video.width}x${video.height}:r=${
+                    video.r_frame_rate || fps
+                }`,
+                "-f",
+                "lavfi",
+                "-i",
+                `anullsrc=r=${sampleRate}:cl=${
+                    audio.channel_layout ||
+                    (audio.channels == 1 ? "mono" : "stereo")
+                }`,
+                "-frames:v",
+                unitFrames.toString(),
+                "-t",
+                unitSeconds.toFixed(6),
+                "-c:v",
+                "libx264",
+                "-preset",
+                "ultrafast",
+                "-profile:v",
+                x264Profile,
+                "-pix_fmt",
+                video.pix_fmt || "yuv420p",
+                "-bf",
+                "0",
+                "-g",
+                unitFrames.toString(),
+                "-c:a",
+                "aac",
+                "-ar",
+                sampleRate.toString(),
+                "-ac",
+                (audio.channels || 2).toString(),
+                "-f",
+                "mpegts",
+                fillerFile,
+            ],
+            "pad filler"
+        );
+
+        if (!fs.existsSync(fillerFile) || fs.statSync(fillerFile).size == 0) {
+            throw new Error("Failed to encode filler");
+        }
+
+        const fillerProbe = await ffprobe(fillerFile);
+        const fillerStart = parseFloat(fillerProbe.format.start_time) || 0;
+
+        fs.writeFileSync(
+            listFile,
+            buildConcatList(plan, input, fillerFile, fillerStart, unitSeconds)
+        );
+
+        const result = await remuxFile(listFile, output, false, metadata_file, [
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+        ]);
+
+        return { ...result, plan };
+    } finally {
+        for (const file of [fillerFile, listFile]) {
+            if (fs.existsSync(file)) fs.unlinkSync(file);
+        }
+    }
+}
+
 export async function videometadata(
     filename: string,
     force = false
diff --git a/server/src/Routes/Api.ts b/server/src/Routes/Api.ts
index 2ad5ec42..cbdbae9c 100644
--- a/server/src/Routes/Api.ts
+++ b/server/src/Routes/Api.ts
@@ -107,6 +107,7 @@ router.post("/vod/:uuid/save", AuthAdmin, Vod.ArchiveVod);
 router.post("/vod/:uuid/bookmark", AuthAdmin, Vod.AddBookmark);
 router.delete("/vod/:uuid/bookmark", AuthAdmin, Vod.RemoveBookmark);
 router.get("/vod/:uuid/sync", AuthAdmin, Vod.GetSync);
+router.get("/vod/:uuid/synced.chatdump", AuthGuest, Vod.GetVideoChatdump);
 router.post("/vod/:uuid/rename", AuthAdmin, Vod.RenameVod);
 router.post("/vod/:uuid/fix_issues", AuthAdmin, Vod.FixIssues);
 router.post("/vod/:uuid/refresh_metadata", AuthAdmin, Vod.RefreshVodMetadata);
diff --git a/server/src/Storage/JSON.ts b/server/src/Storage/JSON.ts
index 1b8d2044..94ae6390 100644
--- a/server/src/Storage/JSON.ts
+++ b/server/src/Storage/JSON.ts
@@ -58,6 +58,8 @@ export interface VODJSON {
     viewers?: { timestamp: string; amount: number }[];
     // stream_pauses?: StreamPause[];
     stream_pauses?: { start?: string; end?: string }[];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded?: boolean;
 
     bookmarks: VODBookmark[];