更新 go.mod

自动合并按文件实际位置找弹幕，修掉「jsonl 文件不存在」
为什么：录制结束时 moveFile 已经把 .ass / .nick.ass / .jsonl 搬到保存目录，但合并时只有视频分段走了 findMovedFile 兜底，弹幕 jsonl 一直拿着录制时算出来的旧路径。于是文件明明安安稳稳躺在保存目录里，burnDanmu 却去旧位置找，自动合并以「jsonl 文件不存在」告终并推送一条失败通知。连带还有两处也指向错误位置：tempMergeOutput 用 filepath.Dir(jsonlFile) 决定中间成片写到哪个目录，mergeDelDanmu 按它去删那三个弹幕文件。处理方式是新增 resolveAfterMove(path)——找不着就退回原路径，这样报错还能说清本来想找哪儿——然后在两处归一：prepareForMerge 让返回的 jsonl 是解析后的路径；autoMergeJob 里也要归一，因为中间成片写到哪、事后删哪几个文件都看这条路径。上一个提交（录制直接写保存目录）落地后这条会退化成空操作，文件压根不再挪窝；留着它是为了兜住「运行中改了保存目录」「老录播补合并」这类场景。验证： - 新增 automerge_test.go 两条：prepareForMerge 返回的视频与 jsonl 都从录制位置解析到保存位置；目标目录里没有同名文件时退回原路径而不是返回空串。 - go test ./... 23.6s 与 go test -race ./... 26.4s 均全绿，215 个顶层用例。 - 反向验证新增一项：删掉 prepareForMerge 里那句归一，对应用例确实变红。 - 验证边界说明：测到的是路径解析这一层，没有构造一整场录制跑真 ffmpeg 走完合并流程 ——那需要一整套直播素材，成本远高于收益。
2026-10-22 02:15:13 +08:00 · 2026-09-28 02:04:10 +08:00 · 2026-09-28 02:03:56 +08:00 · 2026-09-28 02:03:39 +08:00 · 2026-09-27 11:10:00 +08:00 · 2026-09-27 10:36:29 +08:00
38 changed files with 7311 additions and 604 deletions
@@ -75,7 +75,7 @@ GOOS=windows GOARCH=amd64 go build -o acfunlive.exe
            "qualities": []     // 开播时读到的码率档位列表，缓存下来让没开播时也能显示对应关系
        }
    ],
-    "directory": "",            // 录制文件保存的文件夹，留空是程序运行时的 -record 文件夹
+    "directory": "",            // 录播和弹幕文件的保存根目录，录制时就直接写在这里；留空用运行时的 -record 文件夹
    "webPort": 51880,           // web UI 的端口，为 0 时不启动 web UI

    "autoMerge": false,         // 直播结束后自动把弹幕层合并进录播
@@ -127,7 +127,7 @@ GOOS=windows GOARCH=amd64 go build -o acfunlive.exe

 档位表要开播后读直播源列表才知道（写在`config.json`的`qualities`里缓存）。没读到过的行，选项后面不会带档位名，旁边的`档位`按钮可以去直播间接一次（主播没开播时会失败并提示，服务端本身要重试三次、约 5 秒，所以点下去会先给一句`正在读取码率档位…`）。读档位的时机是：录制开始取流时、页面上点`档位`按钮、以及发现主播在直播但还没有档位缓存时自动读一次（同一个主播 10 秒内只读一次）。录制始终是原画质直接保存（`-c copy`），不会重新编码，所以只能在这几个档位里挑。

-录播原片和弹幕文件（`.ass`、`.nick.ass`、`.jsonl`）保存在保存目录下的`recordSubdir`子文件夹里（默认`record`），两者同名配对才能自动合并；合并后的成片保存在`mergeSubdir`子文件夹里（默认`merged`），留空则用默认值，两个名字不能相同。如果设置了`mergeOutputDir`，成片优先移动到那里。
+录播原片和弹幕文件（`.ass`、`.nick.ass`、`.jsonl`）保存在保存目录下的`recordSubdir`子文件夹里（默认`record`），**录制过程中 ffmpeg 就直接写在这里**，不会再先落到别处中转；两者同名配对才能自动合并。保存目录的优先级是：`directory` > 命令行`-record`指定的文件夹 > 程序所在目录。合并后的成片保存在`mergeSubdir`子文件夹里（默认`merged`），留空则用默认值，两个名字不能相同。如果设置了`mergeOutputDir`，成片优先移动到那里。

 合成**先在录播文件夹里做完，写完了才落到成片文件夹**（同一个盘时是直接改名，几乎瞬时；跨盘会自动拷贝）：成片文件夹是网络盘、外接盘或者中途断线时，不会在里面留下一个写到一半、看起来却像正常成片的文件。合成失败或中途强杀程序时，临时文件（`acfunlive_chunk_*`、`*.acfunlive.part`）不会出现在文件管理的列表里，程序下次启动会自动清掉。

@@ -162,22 +162,23 @@ GOOS=windows GOARCH=amd64 go build -o acfunlive.exe

 web UI 默认通过`http://localhost:51880`访问（端口对应`webPort`），可以在网页里增删主播、切换每个主播的弹幕和录播开关、选择录制的码率档位、修改保存目录和自动合并设置。

-页面按用途分成六个分区，顶部一条导航切换，地址栏会跟着带上`#分区名`，所以刷新、收藏、直接把链接发给别人都能落到同一个分区：
+页面按用途分成七个分区，顶部一条导航切换，地址栏会跟着带上`#分区名`，所以刷新、收藏、直接把链接发给别人都能落到同一个分区：

 | 分区 | 内容 |
 | --- | --- |
 | 监控 | 当前转换任务的进度卡片、添加主播、主播列表（默认打开的分区），以及运行日志 |
 | 录制 | 保存目录和子文件夹、录播格式、默认码率上限、ffmpeg 路径 |
-| 合并 | 自动合并开关、成片输出目录和合成码率、手动合并 |
+| 合并 | 自动合并开关、成片输出目录和合成码率、手动合并（可一次排多个任务，每个任务单独配参数） |
+| 转码 | 把录播、成片或磁盘上任意位置的视频重新压一遍：每个文件单独配置编码器、码率、帧率、分辨率、音频，并预估产物大小 |
 | 通知 | 推送哪些事件，以及 QQ 机器人 / MeoW 两个渠道的配置和测试连通 |
 | 文件 | 磁盘剩余容量、录播和成片的文件列表 |
 | 设置 | 是否允许外网访问、管理口令的查看与更换 |

 ### 转换任务进度

-自动合并和手动合并跑起来之后，`监控`分区顶部会出现一张`转换任务`卡片，页面最顶上还有一条很细的全局进度条，切到哪个分区都能看到。卡片里给的是：
+自动合并、手动合并和转码跑起来之后，`监控`分区顶部会出现一张`转换任务`卡片，页面最顶上还有一条很细的全局进度条，切到哪个分区都能看到。卡片里给的是：

- **阶段步骤条**：准备 → 分段拼接 → 获取头像 → 画面渲染 → 拼接与落盘，走过的打勾、当前的高亮（暂停时变红）；
+- **阶段步骤条**：合并是准备 → 分段拼接 → 获取头像 → 画面渲染 → 拼接与落盘，转码是准备 → 转码 → 落盘，走过的打勾、当前的高亮（暂停时变红）；一次排了多个任务时标题上还会标`第 n/N 个`；
 - **总进度条和百分比**：渲染阶段按「已渲染时长 ÷ 视频总时长」算，其余阶段按各自的完成比例折算后加权；
 - **实时指标**：渲染倍速、帧率、已处理时长 / 总时长、已用时间、已写出多少；
 - **预计剩余时间**：渲染阶段用「剩余时长 ÷ 当前倍速」，别的阶段按已用时间线性外推；
@@ -253,15 +254,47 @@ acfunlive -danmuburn xxx.jsonl -video xxx.flv -ffmpeg D:\tools\ffmpeg.exe

 ### 手动合并

-web UI 的`合并`分区里的`手动合并`用来自己挑视频和弹幕出片，适合手动停止录制过的一场、或者手里只有零散文件的情况。
+web UI 的`合并`分区里的`手动合并`用来自己挑视频和弹幕出片，适合手动停止录制过的一场、或者手里只有零散文件的情况。**可以一次排多个任务，每个任务一套自己的文件和参数。**

- **视频**：既可以在文本框里一行一个地填，也可以从录播目录的下拉列表里多选（选完自动填进文本框）。填的名字不带路径就按录播目录找，带路径的相对和绝对都能用，所以录播目录以外的文件也合得来。粘贴路径时带上的引号会被自动去掉。
- **弹幕**：支持`.jsonl`和`.ass`。填`.ass`时会先还原成 jsonl 再合并（规则和`-danmuburn`一样，优先用同名的 jsonl），还原结果写回录播目录，页面的下拉列表里也会出现。**选好视频会自动找同名弹幕文件**（同目录下依次找`.jsonl`、`.ass`、`.nick.ass`，同目录没有再去录播目录找一次），找到就自动填上并提示一句；找不到、或者弹幕框里已经有内容时就保持原样，自己手选即可。
+选好视频后会按文件名自动归组：文件名是`2026-09-25 01-00-00 主播名 标题.mp4`这种格式，去掉开头的时间和扩展名后剩下的（主播名 + 标题）相同、而且相邻两段录制时间差在 2 小时以内的算同一场——同一场断流分成的几段归到一个任务里、先拼起来再合，不同场次各排一个任务、依次合出多个成片。归错了（比如同一天连着两场、标题又一样但间隔在 2 小时内）可以点任务行上的`拆成单独任务`把它们拆开。
+
+每个任务行里能单独改：
+
+- **视频**：行里列出这一组的文件，可以整组移除或拆成一人一个任务。既可以从录播目录的下拉列表里多选，也可以点`浏览`从别的文件夹挑。填的名字不带路径就按录播目录找，带路径的相对和绝对都能用。
+- **弹幕**：支持`.jsonl`和`.ass`。填`.ass`时会先还原成 jsonl 再合并（规则和`-danmuburn`一样，优先用同名的 jsonl）。**选好视频会自动找同名弹幕文件**（同目录下依次找`.jsonl`、`.ass`、`.nick.ass`，同目录没有再去录播目录找一次），找到就自动填上；找不到就保持空着，用行里的`…`按钮手选。
 - **时间偏移**：留空时按文件名里的录制时间自动推算（视频时间 = 弹幕时间 + 偏移），也可以自己填，比如录播比弹幕晚开始 3 秒就填`3`。
- **输出文件名**：可以改，重名时自动加`(2)`之类的后缀，不会覆盖已有文件。
- **先预览再合并**：`预览`按钮会先把分段顺序、各段时长、总时长、弹幕条数和时间范围、推算出的偏移、以及要用的弹幕文件列出来，确认没问题再点`开始合并`。
+- **输出文件名**：留空时按弹幕文件名加`_弹幕合并`自动命名，重名会自动加`(2)`之类的后缀；自己填了名字就按填的来（**与已有文件同名时会被覆盖**，注意别填错）。
+- **本次的合成参数**：码率（Kbps）、输出帧率、弹幕字号（像素）、编码器。**留空就沿用`成片输出`里的全局设置**，填了就只对这一个任务生效——比如某一场要压小一点、另一场保持原码率。
+- **先预览再合并**：`检查`按钮会把每个任务的分段顺序、各段时长、总时长、弹幕条数和时间范围、推算出的偏移、以及要用的弹幕文件逐段列出来，确认没问题再点`开始合并`。

-一次只允许跑一个手动合并任务，重复提交会被拒绝并提示现在这个成片的名字。合并期间成片会标记`写入中`，和录制一样不能删除；合并失败的原因会显示在页面上，不用去翻日志。多个视频会按文件名里的录制时间自动排序再拼接，所以下拉里选出来的顺序不影响结果，弹幕时间轴会按各段时长重新对齐。
+一次只跑一个合并任务，排着的按列表顺序来；重复提交会被拒绝并提示现在这个成片的名字。合并期间成片会标记`写入中`，和录制一样不能删除；合并失败的原因会显示在页面上，不用去翻日志。同一组里的多个视频会按文件名里的录制时间自动排序再拼接，所以下拉里选出来的顺序不影响结果，弹幕时间轴会按各段时长重新对齐。
+
+### 转码
+
+`转码`分区用来把视频重新压一遍：体积太大想压小、想换成 HEVC、想降分辨率或帧率、想换音轨，都在这里做。源文件不限于本程序录的录播和成片，磁盘上任何位置的文件都能丢进来。**转码不动原文件**，成片另存到输出目录（留空就是成片文件夹）。
+
+源文件有两个入口，挑哪个都行：
+
+- **从文件列表挑**：录播和成片文件夹里的文件列在左边，按 Ctrl 点可以多选，选中后点`加入列表`。
+- **自己填路径**：右边的输入框一行一个路径，可以是从资源管理器复制来的绝对路径，也可以是录播/成片文件夹里的文件名（只写文件名就按这两个文件夹找）。点`浏览…`可以从磁盘上任意位置挑，支持多选、可以跨文件夹跨盘攒，选完只往输入框里追加，不会清掉已经填好的。
+
+两个入口进来的文件进的是同一个待转码列表，每条互不影响。
+
+每个文件一行，参数各自独立：
+
+| 参数 | 说明 |
+| --- | --- |
+| 输出文件名 | 默认是`原名_转码.mp4`；这个默认名重名时会自动加`(2)`之类的后缀，自己改成别的名字就按填的来（**与已有文件同名时会被覆盖**） |
+| 编码器 | `自动`按本机可用性挑（优先 Intel QSV 的 HEVC），也可以指定 HEVC 硬件 / H.264 硬件 / H.264 软件；本机没有的编码器会被挡住 |
+| 码率控制 | `源片码率的比例`（默认 60%）/ `指定目标码率` / `质量模式`（CRF 或 ICQ，数值越小画质越好）/ `跟随源片码率` |
+| 编码速度 | veryfast ~ slower，慢一点压得小一点 |
+| 输出帧率 | 0 表示跟随源片；转码场景下可以按填的值升也可以降 |
+| 分辨率 | 按高度缩放，只列出比源片低的档，不会把小图放大 |
+| 音频 | 直接拷贝 / 重编码 128k 或 192k / 去掉音轨 |
+
+每行下面实时显示**预估产物大小**和相对源片的百分比（体积是服务端按「码率 × 时长」算的，目标码率模式是准数，质量模式只给粗估并标注依据），列表底部还有一整批的合计。调好第一个之后点`把第一个的参数套到全部`可以一次性铺给其它行。
+
+转码和合并共用同一张进度卡片、同一个任务位，所以一次只跑一个文件，排着的按列表顺序来，也能在`监控`页暂停和停止；停止只丢当前这个，已经在输出目录里落地的成品不受影响。

 ### 通知推送

@@ -139,12 +139,14 @@ func speakerText(name string, uid int64, content string) string {
 }

 // 从 ASS 文件还原弹幕记录，支持原格式（\move）和昵称头像版（\an7\move）
-func parseAssFile(path string) (danmuMeta, []danmuRecord, error) {
+// 第二个返回值是没能解析出来的行数，日志交给调用方打：页面的「检查」和真正的合并
+// 会各解析一遍同一个 .ass，日志只该出现一次
+func parseAssFile(path string) (danmuMeta, []danmuRecord, int, error) {
 	var meta danmuMeta

 	f, err := os.Open(path)
 	if err != nil {
-		return meta, nil, err
+		return meta, nil, 0, err
 	}
 	defer f.Close()

@@ -157,6 +159,9 @@ func parseAssFile(path string) (danmuMeta, []danmuRecord, error) {
 	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
 	for scanner.Scan() {
 		line := strings.TrimRight(scanner.Text(), "\r")
+		// 有些编辑器/工具保存的 ASS 头上有 UTF-8 BOM，第一个 "[" 会被它挡住：
+		// 整份文件进不了任何一节，最后只会报一句「可能不是弹幕文件」，跟真实原因完全对不上
+		line = strings.TrimPrefix(line, "\ufeff")
 		t := strings.TrimSpace(line)
 		if t == "" || strings.HasPrefix(t, ";") {
 			continue
@@ -272,33 +277,27 @@ func parseAssFile(path string) (danmuMeta, []danmuRecord, error) {
 		}
 	}
 	if err := scanner.Err(); err != nil {
-		return meta, nil, err
+		return meta, nil, bad, err
 	}

 	if meta.PlayResX == 0 || meta.PlayResY == 0 {
-		return meta, nil, errors.New("ASS 文件里没有 PlayResX / PlayResY，可能不是弹幕文件")
+		return meta, nil, bad, errors.New("ASS 文件里没有 PlayResX / PlayResY，可能不是弹幕文件")
 	}
 	if meta.FontSize == 0 {
-		return meta, nil, errors.New("ASS 文件里没找到字幕字号（Style: Danmu）")
+		return meta, nil, bad, errors.New("ASS 文件里没找到字幕字号（Style: Danmu）")
 	}
 	if len(records) == 0 {
 		if bad > 0 {
-			return meta, nil, fmt.Errorf("ASS 里的 %d 行弹幕都没能解析出来", bad)
+			return meta, nil, bad, fmt.Errorf("ASS 里的 %d 行弹幕都没能解析出来", bad)
 		}
-		return meta, nil, errNoDanmu
+		return meta, nil, bad, errNoDanmu
 	}

 	// 分块渲染要求记录按时间递增，这里统一排一遍
 	sort.SliceStable(records, func(i, j int) bool { return records[i].Time < records[j].Time })
 	// 文件名前缀就是录制开始的时刻，用它算偏移最稳
 	meta.StartTime = nameStartNs(path)
-	if bad > 0 {
-		lPrintWarnf("%s 里有 %d 行弹幕没能解析出来，已跳过", filepath.Base(path), bad)
-	}
-	lPrintf("已从 %s 还原出 %d 条弹幕（%dx%d，字号 %d，弹幕到 %s）",
-		filepath.Base(path), len(records), meta.PlayResX, meta.PlayResY, meta.FontSize,
-		formatSeconds(records[len(records)-1].Time))
-	return meta, records, nil
+	return meta, records, bad, nil
 }

 // 按本程序的 jsonl 格式写文件（首行是元数据）
@@ -29,10 +29,15 @@ func finishPart(liveID string, danmu bool) {
 		info.isRecording = false
 		info.recordDone = true
 	}
-	shouldMerge := config.AutoMerge && mainCtx.Err() == nil &&
+	// 弹幕文件写坏过就别合并了：成片会缺一大截弹幕，界面上看不出是缺还是本来就没弹幕
+	broke := info.danmuWriteFailed
+	shouldMerge := config.AutoMerge && mainCtx.Err() == nil && !broke &&
 		!info.danmuStopped && !info.recordStopped &&
 		info.danmuDone && info.recordDone && !info.mergeStarted &&
 		info.assFile != "" && info.firstRecordFile != ""
+	if broke && config.AutoMerge && info.danmuDone && info.recordDone && !info.mergeStarted {
+		lPrintWarn("本场弹幕文件在录制时写盘出错，跳过自动合并（录播和弹幕文件都留着）")
+	}
 	var segs []recordSegment
 	if shouldMerge {
 		info.mergeStarted = true
@@ -80,11 +85,25 @@ func findMovedFile(path string) string {
 	return ""
 }

+// 收拢到实际位置：找不着时退回原路径，让后面的报错还能指出「本来想找哪儿」
+func resolveAfterMove(path string) string {
+	if p := findMovedFile(path); p != "" {
+		return p
+	}
+	return path
+}
+
 // 录播因为断流可能分成多段：单段直接使用，多段先拼成完整视频并把弹幕时间映射到拼接后的时间轴。
-// 返回合并要用的视频、字幕文件和弹幕相对视频起点的时间偏移，以及清理临时文件的函数。
-func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string, danmuStartNs int64) (string, string, float64, func(), error) {
+// 返回合并要用的视频、字幕文件和弹幕相对视频起点的时间偏移、**实际参与合并的源文件**，
+// 以及清理临时文件的函数。used 是给「合并完删源视频」用的：中途回退成「只合并第一个分段」时，
+// 后面的分段并没有进成片，按原分段列表全删就等于把后半场永久丢了。
+func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string, danmuStartNs int64) (string, string, float64, []string, func(), error) {
 	noop := func() {}

+	// 弹幕文件同样会被移动过去。以前只有视频分段走了查找，弹幕还拿着录制时的路径，
+	// 结果就是视频找得到、弹幕找不到，合并以「jsonl 文件不存在」告终
+	jsonlFile = resolveAfterMove(jsonlFile)
+
 	// 录制结束时文件可能已经被移动到保存目录，逐个找实际位置
 	files := make([]string, 0, len(segs))
 	starts := make([]int64, 0, len(segs))
@@ -95,11 +114,11 @@ func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string,
 		}
 	}
 	if len(files) == 0 {
-		return "", "", 0, noop, errors.New("找不到录播视频文件")
+		return "", "", 0, nil, noop, errors.New("找不到录播视频文件")
 	}
 	if len(files) == 1 {
 		offset := float64(danmuStartNs-starts[0]) / 1e9
-		return files[0], jsonlFile, offset, noop, nil
+		return files[0], jsonlFile, offset, files, noop, nil
 	}

 	lPrintf("本场录播中途中断过，共 %d 个分段，先拼接成完整视频再合并", len(files))
@@ -111,7 +130,7 @@ func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string,
 		if durs[i] <= 0 {
 			lPrintWarnf("无法获取分段 %s 的时长，本场只合并第一个分段（后半场没有弹幕）", filepath.Base(f))
 			offset := float64(danmuStartNs-starts[0]) / 1e9
-			return files[0], jsonlFile, offset, noop, nil
+			return files[0], jsonlFile, offset, files[:1], noop, nil
 		}
 	}

@@ -131,13 +150,13 @@ func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string,
 	}); err != nil {
 		// 任务被手动停止时不要再退化成「只合并第一个分段」，
 		// 也别把拼到一半的中间文件留下
-		if jobStopRequested() {
-			_ = os.Remove(joined)
-			return "", "", 0, noop, errJobStopped
+		_ = os.Remove(joined)
+		if errors.Is(err, errJobStopped) {
+			return "", "", 0, nil, noop, errJobStopped
 		}
 		lPrintWarnf("拼接录播分段失败，本场只合并第一个分段（后半场没有弹幕）：%v", err)
 		offset := float64(danmuStartNs-starts[0]) / 1e9
-		return files[0], jsonlFile, offset, noop, nil
+		return files[0], jsonlFile, offset, files[:1], noop, nil
 	}

 	newJsonl := filepath.Join(dir, chunkTempPrefix+"remapped.jsonl")
@@ -145,14 +164,14 @@ func prepareForMerge(ffmpegFile string, segs []recordSegment, jsonlFile string,
 		_ = os.Remove(joined)
 		lPrintWarnf("重映射弹幕时间失败，本场只合并第一个分段（后半场没有弹幕）：%v", err)
 		offset := float64(danmuStartNs-starts[0]) / 1e9
-		return files[0], jsonlFile, offset, noop, nil
+		return files[0], jsonlFile, offset, files[:1], noop, nil
 	}

 	cleanup := func() {
 		_ = os.Remove(joined)
 		_ = os.Remove(newJsonl)
 	}
-	return joined, newJsonl, 0, cleanup, nil
+	return joined, newJsonl, 0, files, cleanup, nil
 }

 // 把弹幕时间从「真实时间轴」映射到「分段拼接后的时间轴」
@@ -242,14 +261,22 @@ func remapJsonlTimes(srcFile, dstFile string, starts []int64, durs []float64, da
 	return nil
 }

-// 自动合并入口：把结果写进任务进度；日志措辞仍由内部负责
+// 自动合并入口：排队跑完一场，把结果写进任务进度；日志措辞仍由内部负责
 func autoMerge(uid int, segs []recordSegment, jsonlFile string, danmuStartNs int64) {
-	err := autoMergeJob(uid, segs, jsonlFile, danmuStartNs)
+	// 多个主播可能同时下播，而全局只有一份任务状态：先排队，跑到了再登记进度
+	if jobActive() {
+		lPrintf("已有合并任务在跑（%s），本场先排队等待", jobBusyName())
+	}
+	err := runMergeExclusive(func() error {
+		return autoMergeJob(uid, segs, jsonlFile, danmuStartNs)
+	})
 	if err == errJobStopped {
 		// 停止不是故障，内部不打印，这里补一句
 		lPrintWarn("自动合并已被手动停止" + longID(uid))
 	}
 	jobFinish(jobErrText(err))
+	// 失败要推一条，否则只有盯着控制台才知道这场没合成出来
+	notifyMergeFailure(uid, autoMergeOutFile(jsonlFile), err)
 }

 // 把错误翻成给界面看的原因：正常结束和「没有弹幕」都不算失败
@@ -263,10 +290,20 @@ func jobErrText(err error) string {
 	return err.Error()
 }

+// 自动合并成片的最终路径：成片目录 + 与弹幕文件同名的「_弹幕合并.mp4」
+func autoMergeOutFile(jsonlFile string) string {
+	name := filepath.Base(strings.TrimSuffix(jsonlFile, ".jsonl") + "_弹幕合并.mp4")
+	return filepath.Join(mergeSaveDir(), name)
+}
+
 // 执行自动合并及后续的删除/移动。日志都在内部按原措辞打印，返回值只给上层写进度用
 func autoMergeJob(uid int, segs []recordSegment, jsonlFile string, danmuStartNs int64) error {
 	lPrintln("开始自动合并" + longID(uid) + "的录播和弹幕层")

+	// 录制结束时弹幕文件可能已被移动到保存目录，先把路径收拢到实际位置：
+	// 中间成片写到哪、事后删哪几个弹幕文件都按这一条路径来，用旧路径会指向错误的地方
+	jsonlFile = resolveAfterMove(jsonlFile)
+
 	// 视频和弹幕是一次录制产生的，文件名去掉扩展名后应该一致（扩展名由 recordFormat 决定）
 	if len(segs) > 0 {
 		videoBase := filepath.Base(strings.TrimSuffix(segs[0].file, filepath.Ext(segs[0].file)))
@@ -290,7 +327,7 @@ func autoMergeJob(uid int, segs []recordSegment, jsonlFile string, danmuStartNs
 		lPrintWarnf("创建成片文件夹 %s 失败：%v", mergeDir, err)
 		return fmt.Errorf("创建成片文件夹 %s 失败：%v", mergeDir, err)
 	}
-	outFile := filepath.Join(mergeDir, filepath.Base(strings.TrimSuffix(jsonlFile, ".jsonl")+"_弹幕合并.mp4"))
+	outFile := autoMergeOutFile(jsonlFile)
 	tmpOut := tempMergeOutput(jsonlFile, filepath.Base(outFile))

 	// 输入大小按各分段实际位置合计（录制结束时文件可能已被移动到保存目录）
@@ -300,9 +337,12 @@ func autoMergeJob(uid int, segs []recordSegment, jsonlFile string, danmuStartNs
 			inputBytes += fileSizeOrZero(p)
 		}
 	}
-	jobStart("自动合并", filepath.Base(outFile), inputBytes, 0)
+	if !jobStart(jobKindAutoMerge, filepath.Base(outFile), inputBytes, 0) {
+		// 走到这里说明没先拿 mergeSlot，与其把别人的进度冲掉不如直接放弃这一场
+		return errors.New("开始任务失败：还有别的合并任务没结束，本场合并已跳过")
+	}

-	video, jsonl, offset, cleanup, err := prepareForMerge(ffmpegFile, segs, jsonlFile, danmuStartNs)
+	video, jsonl, offset, used, cleanup, err := prepareForMerge(ffmpegFile, segs, jsonlFile, danmuStartNs)
 	defer cleanup()
 	if err != nil {
 		lPrintErrf("自动合并失败：%v", err)
@@ -311,7 +351,8 @@ func autoMergeJob(uid int, segs []recordSegment, jsonlFile string, danmuStartNs

 	// 标记成正在写入，避免在 web UI 的文件管理里把还没写完的成片删掉
 	markFileActive(tmpOut, true)
-	burnErr := burnDanmu(jsonl, video, tmpOut, offset)
+	// 自动合并没有单独的参数，全部沿用全局设置
+	burnErr := burnDanmu(jsonl, video, tmpOut, offset, mergeOptions{})
 	markFileActive(tmpOut, false)
 	if burnErr != nil {
 		_ = os.Remove(tmpOut)
@@ -337,9 +378,9 @@ func autoMergeJob(uid int, segs []recordSegment, jsonlFile string, danmuStartNs
 		longID(uid)+" 的录播和弹幕合并完成\n"+outFile)

 	if config.MergeDelVideo {
-		// 源视频可能有多个分段，全部删掉
-		for _, s := range segs {
-			p := findMovedFile(s.file)
+		// 只删真正进了成片的分段：拼接中途回退成「只合并第一段」时，后面的分段没被合并，
+		// 按原分段列表全删就等于把后半场永久丢掉
+		for _, p := range used {
 			if p == "" {
 				continue
 			}
@@ -0,0 +1,76 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// 录制结束时文件会被移动到保存目录，视频分段和弹幕文件都要按新位置找。
+// 以前只有视频分段走了查找，弹幕还拿着录制时的路径：视频找到了、弹幕找不到，
+// 整场合并以「jsonl 文件不存在」告终（用户看到的就是合成失败 + 一条失败推送）。
+func TestPrepareForMergeFindsMovedJsonl(t *testing.T) {
+	savedConfig := config
+	defer func() { config = savedConfig }()
+
+	root := t.TempDir()
+	config.Directory = root
+	config.RecordSubdir = "record"
+	if err := os.MkdirAll(recordSaveDir(), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	name := "2026-09-27 22-40-42 甲 标题"
+	// 录制时的位置：文件已经被搬走，这里不该再有
+	oldDir := t.TempDir()
+	oldVideo := filepath.Join(oldDir, name+".mp4")
+	oldJsonl := filepath.Join(oldDir, name+".jsonl")
+	// 实际位置
+	newVideo := filepath.Join(recordSaveDir(), name+".mp4")
+	newJsonl := filepath.Join(recordSaveDir(), name+".jsonl")
+	for _, p := range []string{newVideo, newJsonl} {
+		if err := os.WriteFile(p, []byte("{}\n"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	segs := []recordSegment{{file: oldVideo, startNs: 0}}
+	video, jsonl, _, _, cleanup, err := prepareForMerge("没有这个-ffmpeg.exe", segs, oldJsonl, 0)
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("单段不该报错：%v", err)
+	}
+	if video != newVideo {
+		t.Errorf("视频应当按保存目录里的实际位置找：\n got  %s\n want %s", video, newVideo)
+	}
+	if jsonl != newJsonl {
+		t.Errorf("弹幕文件应当按保存目录里的实际位置找：\n got  %s\n want %s", jsonl, newJsonl)
+	}
+}
+
+// 文件确实不在（既没在录制时的位置、也不在保存目录）时，要退回原路径而不是空串：
+// 否则报错会变成「文件不存在：」，看不出到底缺的是哪个
+func TestResolveAfterMoveKeepsOriginalWhenMissing(t *testing.T) {
+	savedConfig := config
+	defer func() { config = savedConfig }()
+
+	root := t.TempDir()
+	config.Directory = root
+	config.RecordSubdir = "record"
+
+	gone := filepath.Join(t.TempDir(), "这个目录是对的但文件不在.mp4")
+	if got := resolveAfterMove(gone); got != gone {
+		t.Errorf("找不到时应当退回原路径：got %q want %q", got, gone)
+	}
+
+	real := filepath.Join(root, "record", "在保存目录里.mp4")
+	if err := os.MkdirAll(filepath.Dir(real), 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(real, []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if got := resolveAfterMove(real); got != real {
+		t.Errorf("文件就在原路径时不该改：got %q want %q", got, real)
+	}
+}
@@ -0,0 +1,377 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"image"
+	"image/png"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// 换掉真的反查动作，返回调用次数
+func stubLookupAvatarURL(t *testing.T, f func(uid int64) string) *int64 {
+	t.Helper()
+	var calls int64
+	old := lookupAvatarURL
+	lookupAvatarURL = func(uid int64) string {
+		atomic.AddInt64(&calls, 1)
+		return f(uid)
+	}
+	t.Cleanup(func() { lookupAvatarURL = old })
+	return &calls
+}
+
+// 清空进程内的链接记忆，模拟「重启进程」，用完恢复
+func resetAvatarURLMemo(t *testing.T) {
+	t.Helper()
+	avatarURLMemo.Lock()
+	prevM, prevAt, prevDir, prevLoaded := avatarURLMemo.m, avatarURLMemo.at, avatarURLMemo.dir, avatarURLMemo.loaded
+	avatarURLMemo.m, avatarURLMemo.at, avatarURLMemo.dir, avatarURLMemo.loaded = nil, nil, "", false
+	avatarURLMemo.Unlock()
+	t.Cleanup(func() {
+		avatarURLMemo.Lock()
+		avatarURLMemo.m, avatarURLMemo.at, avatarURLMemo.dir, avatarURLMemo.loaded = prevM, prevAt, prevDir, prevLoaded
+		avatarURLMemo.Unlock()
+	})
+}
+
+// 直接写落盘文件（绕过 append，方便造历史记录）
+func writeAvatarURLCacheFile(t *testing.T, dir string, lines []string) string {
+	t.Helper()
+	path := filepath.Join(dir, avatarURLCacheFile)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	body := strings.Join(lines, "\n")
+	if body != "" {
+		body += "\n"
+	}
+	if err := os.WriteFile(path, []byte(body), 0644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// 查到的链接要落盘，重启进程后不再重复反查
+func TestAvatarURLCacheSurvivesRestart(t *testing.T) {
+	dir := t.TempDir()
+	resetAvatarURLMemo(t)
+	calls := stubLookupAvatarURL(t, func(uid int64) string {
+		return fmt.Sprintf("https://example.invalid/%d.png", uid)
+	})
+
+	url1, fetched1 := avatarURLByUID(42, dir)
+	if !fetched1 {
+		t.Fatal("第一次应当真的去查")
+	}
+	if url1 != "https://example.invalid/42.png" {
+		t.Fatalf("拿到的链接不对：%q", url1)
+	}
+	if atomic.LoadInt64(calls) != 1 {
+		t.Fatalf("第一次应当查 1 次，实际 %d", atomic.LoadInt64(calls))
+	}
+
+	// 同进程第二次：内存记忆命中，不再查
+	if _, fetched := avatarURLByUID(42, dir); fetched {
+		t.Fatal("同进程内第二次不该再查")
+	}
+
+	// 模拟重启：清空内存，只留落盘文件
+	resetAvatarURLMemo(t)
+	url2, fetched2 := avatarURLByUID(42, dir)
+	if fetched2 {
+		t.Fatal("重启后应当直接用落盘记录，不再向 AcFun 查")
+	}
+	if url2 != url1 {
+		t.Fatalf("落盘记录里的链接应当和当初查到的一样，实际 %q", url2)
+	}
+	if n := atomic.LoadInt64(calls); n != 1 {
+		t.Fatalf("整个过程只该查 1 次，实际 %d 次", n)
+	}
+}
+
+// 过期的记录要重新查（给主播换头像留出路），没到期的直接用
+func TestAvatarURLCacheTTL(t *testing.T) {
+	dir := t.TempDir()
+	now := time.Now()
+	writeAvatarURLCacheFile(t, dir, []string{
+		fmt.Sprintf(`{"uid":1,"url":"https://old/1.png","at":%d}`, now.Add(-8*24*time.Hour).Unix()),
+		fmt.Sprintf(`{"uid":2,"url":"https://fresh/2.png","at":%d}`, now.Add(-time.Hour).Unix()),
+	})
+	resetAvatarURLMemo(t)
+	stubLookupAvatarURL(t, func(uid int64) string { return "https://rechecked/x.png" })
+
+	if u, fetched := avatarURLByUID(2, dir); fetched || u != "https://fresh/2.png" {
+		t.Fatalf("没到期的记录应当直接用，实际 (%q, fetched=%v)", u, fetched)
+	}
+	if u, fetched := avatarURLByUID(1, dir); !fetched || u != "https://rechecked/x.png" {
+		t.Fatalf("过了有效期的记录应当重新查，实际 (%q, fetched=%v)", u, fetched)
+	}
+}
+
+// 文件里有重复行、过期行和坏行时，加载后顺手压一遍，别让它一直长
+func TestAvatarURLCacheCompactsFile(t *testing.T) {
+	dir := t.TempDir()
+	now := time.Now()
+	path := writeAvatarURLCacheFile(t, dir, []string{
+		fmt.Sprintf(`{"uid":7,"url":"https://a/7.png","at":%d}`, now.Add(-3*time.Minute).Unix()),
+		fmt.Sprintf(`{"uid":7,"url":"https://b/7.png","at":%d}`, now.Add(-2*time.Minute).Unix()),
+		fmt.Sprintf(`{"uid":7,"url":"https://c/7.png","at":%d}`, now.Add(-time.Minute).Unix()),
+		fmt.Sprintf(`{"uid":8,"url":"https://old/8.png","at":%d}`, now.Add(-30*24*time.Hour).Unix()),
+		`这不是 json`,
+	})
+	resetAvatarURLMemo(t)
+	stubLookupAvatarURL(t, func(uid int64) string { return "" })
+
+	if u, fetched := avatarURLByUID(7, dir); fetched || u != "https://c/7.png" {
+		t.Fatalf("同一 uid 应当以后写的为准（c），实际 (%q, fetched=%v)", u, fetched)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
+	if len(lines) != 1 {
+		t.Fatalf("压缩后应当只剩 1 行有效记录，实际 %d 行：%v", len(lines), lines)
+	}
+	if !strings.Contains(lines[0], "https://c/7.png") {
+		t.Fatalf("压缩后保留的应当是最新的那条：%s", lines[0])
+	}
+}
+
+// 新查到的链接要追加到落盘文件里
+func TestAvatarURLCacheAppendsNewEntries(t *testing.T) {
+	dir := t.TempDir()
+	resetAvatarURLMemo(t)
+	stubLookupAvatarURL(t, func(uid int64) string { return fmt.Sprintf("https://x/%d.png", uid) })
+
+	if _, fetched := avatarURLByUID(11, dir); !fetched {
+		t.Fatal("第一次应当去查")
+	}
+	data, err := os.ReadFile(filepath.Join(dir, avatarURLCacheFile))
+	if err != nil {
+		t.Fatalf("落盘文件应当已生成：%v", err)
+	}
+	if !strings.Contains(string(data), `"uid":11`) || !strings.Contains(string(data), "https://x/11.png") {
+		t.Fatalf("落盘内容不对：%s", data)
+	}
+}
+
+// 头像并发获取：首次全部下载，第二次全部命中缓存，不会重复下载
+func TestFetchAvatarsReusesCache(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	var hits int64
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&hits, 1)
+		_ = png.Encode(w, image.NewRGBA(image.Rect(0, 0, 8, 8)))
+	}))
+	defer srv.Close()
+
+	const n = 20
+	uids := make([]int64, 0, n)
+	urlByUID := make(map[int64]string, n)
+	for i := 0; i < n; i++ {
+		uid := int64(1000 + i)
+		uids = append(uids, uid)
+		urlByUID[uid] = fmt.Sprintf("%s/av%d.png", srv.URL, uid)
+	}
+
+	paths, stat, err := fetchAvatars(uids, urlByUID, dir, "")
+	if err != nil {
+		t.Fatalf("获取头像不该出错：%v", err)
+	}
+	if len(paths) != n {
+		t.Fatalf("应当拿到 %d 个头像，实际 %d", n, len(paths))
+	}
+	if stat.imgDownloaded != n || stat.imgReused != 0 || stat.failed != 0 {
+		t.Fatalf("首次应当全部下载：下载 %d 复用 %d 失败 %d", stat.imgDownloaded, stat.imgReused, stat.failed)
+	}
+	if got := atomic.LoadInt64(&hits); got != n {
+		t.Fatalf("首次应当请求 %d 次，实际 %d", n, got)
+	}
+
+	// 第二次：全部命中缓存，一次网络都不该发
+	paths2, stat2, err := fetchAvatars(uids, urlByUID, dir, "")
+	if err != nil {
+		t.Fatalf("第二次获取头像不该出错：%v", err)
+	}
+	if len(paths2) != n {
+		t.Fatalf("第二次也应当拿到 %d 个头像，实际 %d", n, len(paths2))
+	}
+	if stat2.imgReused != n || stat2.imgDownloaded != 0 {
+		t.Fatalf("第二次应当全部复用缓存：复用 %d 下载 %d", stat2.imgReused, stat2.imgDownloaded)
+	}
+	if got := atomic.LoadInt64(&hits); got != n {
+		t.Fatalf("第二次不该再下载，累计请求数应当还是 %d，实际 %d", n, got)
+	}
+}
+
+// 统计要能区分「链接复用」和「真的去查了」
+func TestFetchAvatarsCountsLinkLookups(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = png.Encode(w, image.NewRGBA(image.Rect(0, 0, 8, 8)))
+	}))
+	defer srv.Close()
+
+	resetAvatarURLMemo(t)
+	lookups := stubLookupAvatarURL(t, func(uid int64) string { return srv.URL + "/looked.png" })
+
+	uids := []int64{1, 2, 3}
+	urlByUID := map[int64]string{
+		1: srv.URL + "/own.png", // 自带的链接
+		2: "",
+		3: "",
+	}
+	paths, stat, err := fetchAvatars(uids, urlByUID, dir, "")
+	if err != nil {
+		t.Fatalf("不该出错：%v", err)
+	}
+	if len(paths) != 3 {
+		t.Fatalf("三个用户都该拿到头像，实际 %d", len(paths))
+	}
+	if stat.fetched != 2 {
+		t.Fatalf("应当有 2 个走了反查，实际 %d", stat.fetched)
+	}
+	if stat.reusedLink != 0 {
+		t.Fatalf("第一次没有可复用的链接，实际 %d", stat.reusedLink)
+	}
+	if got := atomic.LoadInt64(lookups); got != 2 {
+		t.Fatalf("反查动作应当只发生 2 次，实际 %d", got)
+	}
+
+	// 再跑一次：这两个 uid 的链接已经记下了，不该再查
+	_, stat2, err := fetchAvatars(uids, urlByUID, dir, "")
+	if err != nil {
+		t.Fatalf("第二次不该出错：%v", err)
+	}
+	if stat2.reusedLink != 2 || stat2.fetched != 0 {
+		t.Fatalf("第二次应当复用链接：复用 %d 反查 %d", stat2.reusedLink, stat2.fetched)
+	}
+	if got := atomic.LoadInt64(lookups); got != 2 {
+		t.Fatalf("第二次不该再查链接，累计应当还是 2 次，实际 %d", got)
+	}
+}
+
+// 任务被停止时，获取头像要立刻收工并返回 errJobStopped
+func TestFetchAvatarsStopsWhenAsked(t *testing.T) {
+	withJobFlags(t, true, false, true)
+	dir := t.TempDir()
+	_, _, err := fetchAvatars([]int64{1}, map[int64]string{1: "http://127.0.0.1:1/x.png"}, dir, "")
+	if !errors.Is(err, errJobStopped) {
+		t.Fatalf("应当返回 errJobStopped，实际 %v", err)
+	}
+}
+
+// 统计里的「新下载」要能识别出「这个文件本来就在」
+func TestFetchAvatarsCountsReuseAfterRestart(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = png.Encode(w, image.NewRGBA(image.Rect(0, 0, 8, 8)))
+	}))
+	defer srv.Close()
+
+	uids := []int64{5001}
+	urlByUID := map[int64]string{5001: srv.URL + "/a.png"}
+
+	// 先下载一次，再把内存里的链接记忆清掉（模拟重启后再合并同一场）
+	if _, stat, err := fetchAvatars(uids, urlByUID, dir, ""); err != nil || stat.imgDownloaded != 1 {
+		t.Fatalf("首次应当下载 1 个：%v %+v", err, stat)
+	}
+	resetAvatarURLMemo(t)
+	if _, stat, err := fetchAvatars(uids, urlByUID, dir, ""); err != nil || stat.imgReused != 1 || stat.imgDownloaded != 0 {
+		t.Fatalf("重启后应当复用缓存：%v %+v", err, stat)
+	}
+}
+
+// 落盘文件写坏/读不出时不能影响合并，只是这次多查几遍
+func TestAvatarURLCacheBrokenFileIsIgnored(t *testing.T) {
+	dir := t.TempDir()
+	writeAvatarURLCacheFile(t, dir, []string{"{坏的一行", "还是坏的"})
+	resetAvatarURLMemo(t)
+	calls := stubLookupAvatarURL(t, func(uid int64) string { return "https://ok/1.png" })
+
+	u, fetched := avatarURLByUID(1, dir)
+	if !fetched || u != "https://ok/1.png" {
+		t.Fatalf("坏文件应当忽略并照常反查，实际 (%q, fetched=%v)", u, fetched)
+	}
+	if atomic.LoadInt64(calls) != 1 {
+		t.Fatalf("应当查 1 次，实际 %d", atomic.LoadInt64(calls))
+	}
+}
+
+// 确认落盘用的是头像缓存目录里的固定文件名（别改到别处去）
+func TestAvatarURLCacheFilePath(t *testing.T) {
+	dir := t.TempDir()
+	resetAvatarURLMemo(t)
+	stubLookupAvatarURL(t, func(uid int64) string { return "https://x/1.png" })
+	avatarURLByUID(1, dir)
+
+	want := filepath.Join(dir, avatarURLCacheFile)
+	if _, err := os.Stat(want); err != nil {
+		t.Fatalf("落盘文件应当在 %s：%v", want, err)
+	}
+	// 顺带确认它能被当成普通 jsonl 读出来（一行一条）
+	f, err := os.Open(want)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	data, err := io.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "https://x/1.png") {
+		t.Fatalf("内容不对：%s", data)
+	}
+}
+
+// 头像确实是并发获取的：串行做几百个用户要好几分钟，这条锁住「同时有多个请求在跑」
+func TestFetchAvatarsRunsConcurrently(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	var active, maxActive int64
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		cur := atomic.AddInt64(&active, 1)
+		for {
+			old := atomic.LoadInt64(&maxActive)
+			if cur <= old || atomic.CompareAndSwapInt64(&maxActive, old, cur) {
+				break
+			}
+		}
+		time.Sleep(40 * time.Millisecond) // 让并发的重叠看得见
+		atomic.AddInt64(&active, -1)
+		_ = png.Encode(w, image.NewRGBA(image.Rect(0, 0, 8, 8)))
+	}))
+	defer srv.Close()
+
+	const n = 12
+	uids := make([]int64, 0, n)
+	urlByUID := make(map[int64]string, n)
+	for i := 0; i < n; i++ {
+		uid := int64(2000 + i)
+		uids = append(uids, uid)
+		urlByUID[uid] = fmt.Sprintf("%s/c%d.png", srv.URL, uid)
+	}
+
+	if _, _, err := fetchAvatars(uids, urlByUID, dir, ""); err != nil {
+		t.Fatalf("不该出错：%v", err)
+	}
+	if got := atomic.LoadInt64(&maxActive); got < 2 {
+		t.Fatalf("头像应当是并发获取的，同时最多只有 %d 个请求在跑（串行会把几百人拖成几分钟）", got)
+	}
+}
@@ -10,9 +10,14 @@ import (
 	"image/gif"
 	"image/jpeg"
 	"image/png"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
+	"sync/atomic"
 	"testing"
+	"time"
 )

 // 2x2 的静态 webp（纯红），用来确认 webp 解码器确实注册上了
@@ -145,7 +150,13 @@ func TestEnsureAvatarMigratesLegacyCache(t *testing.T) {
 	sum := sha1.Sum([]byte(url))
 	name := fmt.Sprintf("%d_%x.png", int64(7), sum[:6])
 	old := filepath.Join(legacyDir, name)
-	if err := os.WriteFile(old, []byte("cached-png"), 0644); err != nil {
+	// 旧位置放的是真 PNG（旧版本自己也是用 png.Encode 写的）：
+	// 现在搬过来之前会校验完整性，随便一段字节的话会被当成半截文件丢掉
+	var pngBuf bytes.Buffer
+	if err := png.Encode(&pngBuf, image.NewRGBA(image.Rect(0, 0, 8, 8))); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(old, pngBuf.Bytes(), 0644); err != nil {
 		t.Fatal(err)
 	}

@@ -155,8 +166,8 @@ func TestEnsureAvatarMigratesLegacyCache(t *testing.T) {
 		t.Fatalf("应搬到 %q，实际 %q", want, got)
 	}
 	data, err := os.ReadFile(want)
-	if err != nil || string(data) != "cached-png" {
-		t.Fatalf("搬过来的内容不对：%v %q", err, data)
+	if err != nil || !bytes.Equal(data, pngBuf.Bytes()) {
+		t.Fatalf("搬过来的内容不对：%v（%d 字节 vs %d 字节）", err, len(data), pngBuf.Len())
 	}
 	if _, err := os.Stat(old); !os.IsNotExist(err) {
 		t.Errorf("旧位置的文件应被搬走，实际还在：%v", err)
@@ -167,3 +178,121 @@ func TestEnsureAvatarMigratesLegacyCache(t *testing.T) {
 		t.Errorf("命中缓存应返回 %q，实际 %q", want, got)
 	}
 }
+
+// 旧位置那份也是半截文件时，不能搬过来用：会一路传给 ffmpeg 当输入
+func TestEnsureAvatarRejectsBrokenLegacyCache(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	root := t.TempDir()
+	cacheDir := filepath.Join(root, "program", avatarCacheDir)
+	legacyDir := filepath.Join(root, "record", avatarCacheDir)
+	if err := os.MkdirAll(legacyDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	url := "http://127.0.0.1:9/never.png"
+	old := filepath.Join(legacyDir, avatarCacheName(8, url))
+	if err := os.WriteFile(old, []byte("这根本不是 PNG"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// 连不通的地址 + 坏缓存 → 拿不到头像，但绝不能把坏文件留在缓存目录里
+	if got := ensureAvatar(8, url, cacheDir); got != "" {
+		t.Fatalf("坏缓存不该被采用，实际返回 %q", got)
+	}
+	if validCachedAvatar(filepath.Join(cacheDir, avatarCacheName(8, url))) {
+		t.Fatal("坏文件不该出现在缓存目录里")
+	}
+}
+
+// ==================== 头像下载的容量上限 ====================
+// CDN 的响应大小和图片尺寸都是外部输入，必须有上限。
+// 改之前 downloadAvatar 用的是裸 io.ReadAll：实测一个头像就能吃掉 512MB 内存。
+
+// 异常大的响应必须在读完之前就被截住，不能整份读进内存
+func TestDownloadAvatarCapsResponseBody(t *testing.T) {
+	var wanted int64 = avatarMaxBytes + 8<<20 // 比上限多 8MB
+	var served int64
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "image/png")
+		buf := make([]byte, 1<<20)
+		for atomic.AddInt64(&served, int64(len(buf))) < wanted {
+			if _, err := w.Write(buf); err != nil {
+				return
+			}
+		}
+	}))
+	defer srv.Close()
+
+	out := filepath.Join(t.TempDir(), "a.png")
+	done := make(chan error, 1)
+	go func() { done <- downloadAvatar(1, srv.URL, out) }()
+
+	select {
+	case err := <-done:
+		if err == nil {
+			t.Fatal("超过体积上限的头像应当报错，实际下载成功了")
+		}
+		if !strings.Contains(err.Error(), "超过") {
+			t.Errorf("报错要说清是体积超限，实际：%v", err)
+		}
+		// 客户端只读到上限就撒手，服务端这边根本写不完整个响应。
+		// 反过来，如果 served 达到了 wanted，说明整份都被读进内存了 —— 限制没生效
+		if got := atomic.LoadInt64(&served); got >= wanted {
+			t.Errorf("整份响应都被读完了（%.1f MB），说明没有截断（上限 %d MB）",
+				float64(got)/1048576, avatarMaxBytes>>20)
+		}
+		t.Logf("  已接收 %.1f MB 时就被截住（上限 %d MB）",
+			float64(atomic.LoadInt64(&served))/1048576, avatarMaxBytes>>20)
+	case <-time.After(30 * time.Second):
+		t.Fatalf("超过 30 秒还没结束，限制没生效（已接收 %.1f MB）",
+			float64(atomic.LoadInt64(&served))/1048576)
+	}
+	if _, err := os.Stat(out); err == nil {
+		t.Error("下载失败不该留下文件")
+	}
+}
+
+// 正常的头像是能下下来的：上限不能误伤
+func TestDownloadAvatarAcceptsNormalSize(t *testing.T) {
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, image.NewRGBA(image.Rect(0, 0, 96, 96))); err != nil {
+		t.Fatal(err)
+	}
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "image/png")
+		_, _ = w.Write(buf.Bytes())
+	}))
+	defer srv.Close()
+
+	out := filepath.Join(t.TempDir(), "ok.png")
+	if err := downloadAvatar(1, srv.URL, out); err != nil {
+		t.Fatalf("正常大小的头像应当能下载，实际报错：%v", err)
+	}
+	if _, err := os.Stat(out); err != nil {
+		t.Errorf("下载成功却没生成文件：%v", err)
+	}
+}
+
+// 压缩炸弹：几十 KB 的图可以解压出上亿像素，解码后必须再检查一次尺寸
+func TestDecodeAvatarCapsPixels(t *testing.T) {
+	side := 3000 // 900 万像素，刚过 2048x2048 的上限
+	big := image.NewGray(image.Rect(0, 0, side, side))
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, big); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := decodeAvatar(buf.Bytes(), "image/png"); err == nil {
+		t.Fatalf("%dx%d 的头像应当被尺寸上限拦住", side, side)
+	} else if !strings.Contains(err.Error(), "超出上限") {
+		t.Errorf("报错要说清是尺寸超限，实际：%v", err)
+	}
+
+	// 常见的头像尺寸不受影响
+	ok := image.NewRGBA(image.Rect(0, 0, 300, 300))
+	var b2 bytes.Buffer
+	if err := png.Encode(&b2, ok); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := decodeAvatar(b2.Bytes(), "image/png"); err != nil {
+		t.Errorf("300x300 的普通头像不该被拦：%v", err)
+	}
+}
@@ -0,0 +1,374 @@
+package main
+
+import (
+	"errors"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// 密集弹幕：每 0.02 秒一条，10 秒停留窗口里能塞进 500 条。
+// 块尾扩张原来没有上限，会把窗口里的弹幕几乎全并进同一块
+func denseRecords(n int) []danmuRecord {
+	records := make([]danmuRecord, 0, n)
+	for i := 0; i < n; i++ {
+		records = append(records, danmuRecord{
+			Time:    float64(i) * 0.02,
+			UID:     int64(i%5 + 1),
+			Name:    "密集测试",
+			Content: "弹幕内容",
+			Lane:    i % 10,
+		})
+	}
+	return records
+}
+
+// 单块条数必须被硬上限挡住（续画 + 本块新出现的条数一起算），否则 -filter_complex
+// 会撑爆命令行长度。
+//
+// 「新出现」的那些条按顺序拼起来必须正好是原始列表：续画只是同一批弹幕在后面几块里
+// 接着画，不能算成新弹幕，更不能有哪一条一次都没算成新出现（那就整条丢了）
+func TestSplitDanmuChunksCapsBlockSize(t *testing.T) {
+	records := denseRecords(600)
+	chunks := splitDanmuChunks(records, 0, 0)
+	if len(chunks) < 2 {
+		t.Fatalf("这么多弹幕应当分成多块，实际 %d 块", len(chunks))
+	}
+	fresh := make([]danmuRecord, 0, len(records))
+	for i, ch := range chunks {
+		if n := len(ch.records); n > maxDanmuPerChunkHard {
+			t.Fatalf("第 %d 块有 %d 条弹幕，超过硬上限 %d", i+1, n, maxDanmuPerChunkHard)
+		}
+		if ch.carried < 0 || ch.carried > len(ch.records) {
+			t.Fatalf("第 %d 块的 carried=%d 越界（这一块共 %d 条）", i+1, ch.carried, len(ch.records))
+		}
+		fresh = append(fresh, ch.records[ch.carried:]...)
+	}
+	if len(fresh) != len(records) {
+		t.Fatalf("新出现的弹幕总数应当是 %d，实际 %d", len(records), len(fresh))
+	}
+	for i := range records {
+		if fresh[i].Time != records[i].Time || fresh[i].Content != records[i].Content {
+			t.Fatalf("第 %d 条新弹幕对不上：拿到 %+v，期望 %+v", i, fresh[i], records[i])
+		}
+	}
+}
+
+// 一条弹幕停留 10 秒，块边界经常从它中间切过去：分块器必须把它「续画」到后面几块里。
+// 不续画的话每个块头屏幕上只剩刚出现的那几条，要 10 秒才重新填满 —— 观众看到的就是
+// 「弹幕突然加速冲过去，然后一段时间屏幕上什么都没有」
+func TestSplitDanmuChunksCarriesOnScreenDanmu(t *testing.T) {
+	records := denseRecords(600) // 每 0.02 秒一条，10 秒窗口里同时有 500 条
+	chunks := splitDanmuChunks(records, 0, 0)
+
+	carriedTotal, fresh := 0, 0
+	for i, ch := range chunks {
+		carriedTotal += ch.carried
+		fresh += len(ch.records) - ch.carried
+		for _, r := range ch.records[:ch.carried] {
+			// 续画只能是「上几块里已经出现过、此刻还在屏上」的那些
+			if r.Time >= ch.start {
+				t.Fatalf("第 %d 块（起点 %.3f）把时间 %.3f 的弹幕当成了续画，它不是上一块留下来的",
+					i+1, ch.start, r.Time)
+			}
+			if r.Time < ch.start-danmuShowSeconds {
+				t.Fatalf("第 %d 块（起点 %.3f）续画了时间 %.3f 的弹幕，它早就滚出屏了",
+					i+1, ch.start, r.Time)
+			}
+		}
+	}
+	if carriedTotal == 0 {
+		t.Fatal("这么密的弹幕不可能完全没有需要续画的块，续画逻辑没生效")
+	}
+	if fresh != len(records) {
+		t.Fatalf("新出现的弹幕数不对：%d，期望 %d", fresh, len(records))
+	}
+}
+
+// 块与块必须首尾相接，而且每条弹幕的 10 秒停留窗口要在所有块里被完整画满：
+// 中间只要有缺口，观众就会看到那条弹幕闪一下又消失
+func TestSplitDanmuChunksCoversEveryShowWindow(t *testing.T) {
+	// 每 0.5 秒一条：10 秒窗口里同时有 20 条，续画远放得下，不会触发「挤掉最早的几条」
+	records := make([]danmuRecord, 600)
+	for i := range records {
+		records[i] = danmuRecord{Time: float64(i) * 0.5, UID: 1, Name: "甲", Content: "弹幕", Lane: i % 10}
+	}
+	chunks := splitDanmuChunks(records, 0, 0)
+
+	for i := 1; i < len(chunks); i++ {
+		if chunks[i].start != chunks[i-1].end {
+			t.Fatalf("第 %d 块和第 %d 块之间有空隙：%.3f -> %.3f",
+				i, i+1, chunks[i-1].end, chunks[i].start)
+		}
+	}
+
+	for _, r := range records {
+		covered := r.Time
+		for _, ch := range chunks {
+			vs, ve, ok := danmuVisibleInChunk(r, 0, ch)
+			if !ok {
+				continue
+			}
+			if vs > covered+1e-9 {
+				t.Fatalf("时间 %.3f 的弹幕在 %.3f~%.3f 之间没被画出来（前后两块没接上）",
+					r.Time, covered, vs)
+			}
+			if ve > covered {
+				covered = ve
+			}
+		}
+		if covered < r.Time+danmuShowSeconds-1e-9 {
+			t.Fatalf("时间 %.3f 的弹幕只画到 %.3f，10 秒停留窗口没画满", r.Time, covered)
+		}
+	}
+}
+
+// 同一时刻挤了一堆弹幕（时间戳重复）时块尾会和块头重合，那种块渲染出来一帧都没有，
+// 拼进成片就是一段黑屏/缺帧
+func TestSplitDanmuChunksNeverProducesEmptySpan(t *testing.T) {
+	records := make([]danmuRecord, 0, 400)
+	for i := 0; i < 400; i++ {
+		records = append(records, danmuRecord{
+			Time: 5, UID: 1, Name: "甲", Content: "同一时刻", Lane: i % 10, Width: 100,
+		})
+	}
+	chunks := splitDanmuChunks(records, 0, 0)
+	if len(chunks) < 2 {
+		t.Fatalf("400 条应当分成多块，实际 %d 块", len(chunks))
+	}
+	for i, ch := range chunks {
+		if math.IsInf(ch.end, 1) {
+			continue
+		}
+		if ch.end <= ch.start {
+			t.Fatalf("第 %d 块的时间范围是空的（%.3f ~ %.3f），渲染出来一帧都没有",
+				i+1, ch.start, ch.end)
+		}
+	}
+}
+
+// 回退成「只合并第一个分段」时，used 必须只剩第一段：
+// 自动合并收尾按 used 删源视频，返回全部就等于把没进成片的后半场删掉
+func TestPrepareForMergeOnlyMarksUsedSegments(t *testing.T) {
+	dir := t.TempDir()
+	a := filepath.Join(dir, "a.mp4")
+	b := filepath.Join(dir, "b.mp4")
+	for _, p := range []string{a, b} {
+		if err := os.WriteFile(p, []byte("x"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	jsonl := filepath.Join(dir, "a.jsonl")
+	if err := os.WriteFile(jsonl, []byte("{}\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// 用一个不存在的 ffmpeg：probeDuration 拿不到时长，触发「只合并第一个分段」的回退
+	segs := []recordSegment{{file: a, startNs: 0}, {file: b, startNs: int64(time.Second)}}
+	video, _, _, used, cleanup, err := prepareForMerge(filepath.Join(dir, "没有这个-ffmpeg.exe"), segs, jsonl, 0)
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("回退不该报错：%v", err)
+	}
+	if video != a {
+		t.Fatalf("回退后应当合并第一段，实际 %s", video)
+	}
+	if len(used) != 1 || used[0] != a {
+		t.Fatalf("回退成只合并第一段时 used 应只含第一段，实际 %v", used)
+	}
+}
+
+// 直接改全局任务状态：测试里只碰 stopped 这一个字段，用完恢复
+func setJobStopped(t *testing.T, v bool) {
+	t.Helper()
+	job.Lock()
+	prev := job.stopped
+	job.stopped = v
+	job.Unlock()
+	t.Cleanup(func() {
+		job.Lock()
+		job.stopped = prev
+		job.Unlock()
+	})
+}
+
+// 现场生成一个 1 秒的小视频分段
+func makeTinyVideo(t *testing.T, ffmpegFile, path, color string) {
+	t.Helper()
+	if err := runFFmpegWith(ffmpegFile, []string{
+		"-y", "-f", "lavfi", "-i", "color=c=" + color + ":s=160x120:d=1:r=10",
+		"-c:v", "libx264", "-pix_fmt", "yuv420p", path,
+	}, filepath.Dir(path), nil); err != nil {
+		t.Skipf("生成测试分段失败，跳过：%v", err)
+	}
+}
+
+// 多段都拿到时长、成功拼接时，used 应当是全部分段（原来的删除行为不变）
+func TestPrepareForMergeMarksAllSegmentsWhenJoined(t *testing.T) {
+	ffmpegFile := getFFmpeg()
+	if ffmpegFile == "" {
+		t.Skip("找不到 ffmpeg，跳过")
+	}
+	setJobStopped(t, false)
+	dir := t.TempDir()
+	a, b := filepath.Join(dir, "a.mp4"), filepath.Join(dir, "b.mp4")
+	makeTinyVideo(t, ffmpegFile, a, "red")
+	makeTinyVideo(t, ffmpegFile, b, "blue")
+	jsonl := filepath.Join(dir, "a.jsonl")
+	if err := os.WriteFile(jsonl, []byte(`{"playResX": 160, "playResY": 120, "fontSize": 20, "startTime": 0}`+"\n"+
+		`{"t": 0.2, "uid": 1, "name": "n", "avatar": "", "content": "c", "lane": 0, "width": 0}`+"\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	segs := []recordSegment{{file: a, startNs: 0}, {file: b, startNs: int64(time.Second)}}
+	video, out, _, used, cleanup, err := prepareForMerge(ffmpegFile, segs, jsonl, 0)
+	defer cleanup()
+	if err != nil {
+		t.Fatalf("拼接两个正常分段不该报错：%v", err)
+	}
+	if video != filepath.Join(dir, chunkTempPrefix+"joined.mp4") {
+		t.Fatalf("应当用拼接后的文件合并，实际 %s", video)
+	}
+	if len(used) != 2 {
+		t.Fatalf("拼接成功时 used 应包含全部分段，实际 %v", used)
+	}
+	if _, err := os.Stat(out); err != nil {
+		t.Fatalf("重映射的弹幕文件应当存在：%v", err)
+	}
+	// cleanup 必须把中间文件收干净
+	cleanup()
+	if _, err := os.Stat(video); err == nil {
+		t.Fatalf("清理后拼接出来的中间视频还在：%s", video)
+	}
+	if _, err := os.Stat(out); err == nil {
+		t.Fatalf("清理后重映射的弹幕文件还在：%s", out)
+	}
+}
+
+// 拼接中途被停止：要报成 errJobStopped，并且把拼到一半的中间文件删掉
+// （留在录播目录里既占几 GB 又带 chunkTempPrefix，界面文件列表里根本看不见）
+func TestPrepareForMergeDropsJoinedWhenStopped(t *testing.T) {
+	ffmpegFile := getFFmpeg()
+	if ffmpegFile == "" {
+		t.Skip("找不到 ffmpeg，跳过")
+	}
+	setJobStopped(t, false)
+	dir := t.TempDir()
+	a, b := filepath.Join(dir, "a.mp4"), filepath.Join(dir, "b.mp4")
+	makeTinyVideo(t, ffmpegFile, a, "red")
+	makeTinyVideo(t, ffmpegFile, b, "blue")
+	jsonl := filepath.Join(dir, "a.jsonl")
+	if err := os.WriteFile(jsonl, []byte("{}\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	joined := filepath.Join(dir, chunkTempPrefix+"joined.mp4")
+	if err := os.WriteFile(joined, []byte("拼到一半的内容"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	setJobStopped(t, true)
+
+	segs := []recordSegment{{file: a, startNs: 0}, {file: b, startNs: int64(time.Second)}}
+	_, _, _, used, cleanup, err := prepareForMerge(ffmpegFile, segs, jsonl, 0)
+	defer cleanup()
+	if !errors.Is(err, errJobStopped) {
+		t.Fatalf("被停止时应当返回 errJobStopped，实际 %v", err)
+	}
+	if len(used) != 0 {
+		t.Fatalf("被停止时不该把任何分段算作已合并，实际 %v", used)
+	}
+	if _, err := os.Stat(joined); err == nil {
+		t.Fatalf("停止后拼到一半的中间文件应当被删掉：%s", joined)
+	}
+}
+
+// 任务处于「已请求停止」时，拼接失败要报成 errJobStopped，而不是「拼接失败」
+func TestConcatChunksReportsStopped(t *testing.T) {
+	dir := t.TempDir()
+	f := filepath.Join(dir, "in.mp4")
+	if err := os.WriteFile(f, []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "out.mp4")
+
+	setJobStopped(t, true)
+
+	err := concatChunks(filepath.Join(dir, "没有这个-ffmpeg.exe"), []string{f}, out, dir, nil)
+	if !errors.Is(err, errJobStopped) {
+		t.Fatalf("停止状态下拼接失败应当返回 errJobStopped，实际 %v", err)
+	}
+}
+
+// 没有停止请求时，拼接失败就是普通错误，别报成「已停止」
+func TestConcatChunksReportsFailureWhenNotStopped(t *testing.T) {
+	dir := t.TempDir()
+	f := filepath.Join(dir, "in.mp4")
+	if err := os.WriteFile(f, []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "out.mp4")
+
+	setJobStopped(t, false)
+
+	err := concatChunks(filepath.Join(dir, "没有这个-ffmpeg.exe"), []string{f}, out, dir, nil)
+	if err == nil {
+		t.Fatal("拼接应当失败")
+	}
+	if errors.Is(err, errJobStopped) {
+		t.Fatalf("没有停止请求时不该报成已停止：%v", err)
+	}
+	if !strings.Contains(err.Error(), "拼接") {
+		t.Fatalf("错误信息应当说明是拼接失败，实际 %v", err)
+	}
+}
+
+// 确定性失败不该白白重试三次
+func TestRunThriceSkipsNoRetry(t *testing.T) {
+	calls := 0
+	err := runThrice(func() error {
+		calls++
+		return noRetry(errors.New("确定性失败"))
+	})
+	if calls != 1 {
+		t.Fatalf("标记为不重试的错误应当只尝试一次，实际 %d 次", calls)
+	}
+	if err == nil || !strings.Contains(err.Error(), "确定性失败") {
+		t.Fatalf("错误应当原样返回，实际 %v", err)
+	}
+	if strings.Contains(err.Error(), "运行三次") {
+		t.Fatalf("不该被包装成「运行三次都出现错误」：%v", err)
+	}
+}
+
+// 普通错误仍然照旧重试
+func TestRunThriceStillRetriesNormalError(t *testing.T) {
+	calls := 0
+	err := runThrice(func() error {
+		calls++
+		if calls == 2 {
+			return nil
+		}
+		return errors.New("暂时失败")
+	})
+	if err != nil {
+		t.Fatalf("第二次成功时不该报错：%v", err)
+	}
+	if calls != 2 {
+		t.Fatalf("普通错误应当重试，实际只尝试了 %d 次", calls)
+	}
+}
+
+// 交给 exec 的 ffmpeg 路径必须是绝对路径：
+// Windows 上 exec 会直接拒绝执行「相对当前目录」找到的可执行文件
+func TestGetFFmpegReturnsAbsPath(t *testing.T) {
+	p := getFFmpeg()
+	if p == "" {
+		t.Skip("本机找不到 ffmpeg，跳过")
+	}
+	if !filepath.IsAbs(p) {
+		t.Fatalf("getFFmpeg 应当返回绝对路径，实际 %q", p)
+	}
+}
@@ -0,0 +1,86 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// 按最坏情况（每条弹幕一个不同用户、每个都带头像、文字宽度顶满整屏）渲染一块，
+// 返回这一块的命令行长度。长度从 renderChunk 自己的自检错误里读出来；
+// 没触发自检就返回 (0, false)。
+//
+// 头像路径必须按 renderChunk 真正会拿到的形态造 —— 预缩放目录里的短相对路径
+// （见 prepareAvatarInputs），不是 avatar_cache 里的长绝对路径；用后者量出来的是
+// 一个早就不存在的旧版长度，会把上限算得过分保守。
+//
+// 线上的那次事故就是这里没守住：单块 200 条时实测 48288 字符，远超 Windows 的 32767，
+// 而 exec 只回一句 "The filename or extension is too long"，看不出跟弹幕数量有关。
+func chunkCommandLenProbe(t *testing.T, n int) (length int, over bool) {
+	t.Helper()
+	dir := t.TempDir()
+	avatars := make(map[int64]string, n)
+	records := make([]danmuRecord, 0, n)
+	for i := 0; i < n; i++ {
+		uid := int64(1000000 + i)
+		avatars[uid] = chunkAvatarDir + "/" + fmt.Sprintf("%d.png", i+1)
+		records = append(records, danmuRecord{
+			Time: float64(i) * 0.05, UID: uid, Name: "观众甲",
+			Content: "这条弹幕稍微长一点测试宽度", Lane: i % 100, Width: 1920,
+		})
+	}
+	ctx := &burnContext{
+		ffmpegFile: filepath.Join(dir, "没有这个-ffmpeg.exe"), // 自检在 exec 之前，跑不到它
+		outFile:    filepath.Join(dir, "out.mp4"),
+		meta:       danmuMeta{PlayResX: 1920, PlayResY: 1080, FontSize: 42},
+		avatars:    avatars,
+		dir:        dir,
+	}
+	err := ctx.renderChunk(danmuChunk{start: 0, end: 60, records: records}, "chunk.ass", ctx.outFile, false, nil)
+	if err == nil {
+		t.Fatal("用不存在的 ffmpeg 路径不该成功")
+	}
+	if !strings.Contains(err.Error(), "命令过长") {
+		return 0, false
+	}
+	if _, scanErr := fmt.Sscanf(err.Error(), "ffmpeg 命令过长（%d 字符", &length); scanErr != nil {
+		t.Fatalf("没能从错误里读出长度：%v / %s", scanErr, err)
+	}
+	return length, true
+}
+
+// 按硬上限切出来的块，在最坏情况下也不能顶破命令行上限
+func TestChunkCommandLengthUnderLimit(t *testing.T) {
+	if length, over := chunkCommandLenProbe(t, maxDanmuPerChunkHard); over {
+		t.Fatalf("按硬上限 %d 条渲染，命令长达 %d 字符，已经超过安全值 %d",
+			maxDanmuPerChunkHard, length, maxCommandLineLen)
+	}
+}
+
+// 块大到一定程度必须被自检拦住，并报出「多少条弹幕、多少个头像」这种能定位的信息
+func TestRenderChunkReportsTooLongCommand(t *testing.T) {
+	length, over := chunkCommandLenProbe(t, 300)
+	if !over {
+		t.Fatal("300 条的最坏情况应当被自检拦住，否则交给 exec 只会报一句看不出原因的错")
+	}
+	if length <= maxCommandLineLen {
+		t.Fatalf("自检报出的长度 %d 应当大于阈值 %d", length, maxCommandLineLen)
+	}
+}
+
+// 硬上限本身要留出余量：真跑一遍「上限条数 + 最坏情况」，而不是拿一个会过期的
+// 单条估算值乘一乘。换了头像方案（绝对路径 → 预缩放短路径）、滤镜写法或
+// 单条 overlay 的表达式以后，这个用例会跟着一起变，不会悄悄失效
+func TestChunkHardLimitLeavesHeadroom(t *testing.T) {
+	if length, over := chunkCommandLenProbe(t, maxDanmuPerChunkHard); over {
+		t.Fatalf("硬上限 %d 条的最坏情况实测 %d 字符，已经超过安全值 %d",
+			maxDanmuPerChunkHard, length, maxCommandLineLen)
+	}
+	// 再往上加一成也不该顶破安全值，防止上限被悄悄调高到刚好卡线
+	headroom := maxDanmuPerChunkHard / 10
+	if length, over := chunkCommandLenProbe(t, maxDanmuPerChunkHard+headroom); over {
+		t.Fatalf("上限再高 %d 条（共 %d 条）就顶破了安全值 %d 字符，余量太小",
+			headroom, maxDanmuPerChunkHard+headroom, length)
+	}
+}
@@ -129,7 +129,7 @@ var configMu sync.Mutex
 // 设置数据
 type configData struct {
 	UIDs      uidList `json:"uids"`      // 要录制的主播 uid 列表和各自的开关
-	Directory string  `json:"directory"` // 弹幕文件录制结束后会被移动到该文件夹
+	Directory string  `json:"directory"` // 录播和弹幕文件保存的根目录，留空用 -record 指定的文件夹
 	WebPort   int     `json:"webPort"`   // web UI 的本地端口，为 0 时不启动 web UI

 	AutoMerge      bool   `json:"autoMerge"`      // 直播结束后自动把弹幕层合并进录播
@@ -137,6 +137,7 @@ type configData struct {
 	MergeDelDanmu  bool   `json:"mergeDelDanmu"`  // 合并完成后删除弹幕文件
 	MergeOutputDir string `json:"mergeOutputDir"` // 合并完成后成片移动到该文件夹，留空不移动
 	MergeBitrate   int    `json:"mergeBitrate"`   // 合并成片的目标码率（Kbps），0 表示使用默认质量
+	MergeFps       int    `json:"mergeFps"`       // 合并成片的输出帧率，0 表示跟随源片（只在高于源片时生效，源片帧率不会被降下来）
 	DanmuFontSize  int    `json:"danmuFontSize"`  // 合并时弹幕文字的字号（像素，头像随字号等比缩放），0 表示按画面分辨率自动

 	// 新添加主播的默认录制档位（留空/非法按第二高）与自定义时的码率上限
@@ -154,7 +155,8 @@ type configData struct {
 	NotifyLiveOn      bool   `json:"notifyLiveOn"`      // 开播时推送
 	NotifyLiveOff     bool   `json:"notifyLiveOff"`     // 下播时推送
 	NotifyRecordStart bool   `json:"notifyRecordStart"` // 开始录制直播视频时推送
-	NotifyMergeDone   bool   `json:"notifyMergeDone"`   // 自动合并完成时推送
+	NotifyMergeDone   bool   `json:"notifyMergeDone"`   // 合并完成时推送
+	NotifyMergeFail   bool   `json:"notifyMergeFail"`   // 合并失败时推送（用户手动停止不算失败，不推）

 	MeowEnabled    bool   `json:"meowEnabled"`    // MeoW 推送的渠道开关
 	MeowNickname   string `json:"meowNickname"`   // MeoW 昵称，推送地址里的路径参数
@@ -188,25 +190,29 @@ func saveRootDir() string {
 	if config.Directory != "" {
 		return absOrSelf(config.Directory)
 	}
-	if recordDir == nil {
-		return ""
+	if recordDir != nil && *recordDir != "" {
+		return absOrSelf(*recordDir)
 	}
-	return absOrSelf(*recordDir)
+	// 命令行参数还没解析时（比如 initialize 之前被调用）退回程序所在目录，
+	// 再不济退回当前工作目录：这里返回空串的话，后面拼出来的就是个相对路径，
+	// ffmpeg 会按自己的当前目录去写，录制文件就不知道落到哪去了
+	if exeDir != "" {
+		return absOrSelf(exeDir)
+	}
+	if wd, err := os.Getwd(); err == nil {
+		return wd
+	}
+	return "."
 }

-// 录播和弹幕文件保存的文件夹
+// 录播和弹幕文件保存的文件夹。
+// 录制过程中 ffmpeg 就直接写在这里，不会再中途挪窝：以前单独有一个「录制中的目录」，
+// 它只认 -record 参数不看 directory 设置，配了保存目录的人会发现文件先落在程序目录下，
+// 录完才搬一次（跨盘就是整份文件再复制一遍），提前中断还会留在那儿。
 func recordSaveDir() string {
 	return filepath.Join(saveRootDir(), config.RecordSubdir)
 }

-// 录制过程中文件直接写入的文件夹
-func recordingDir() string {
-	if recordDir == nil {
-		return config.RecordSubdir
-	}
-	return filepath.Join(absOrSelf(*recordDir), config.RecordSubdir)
-}
-
 // 合并成片保存的文件夹
 func mergeSaveDir() string {
 	if config.MergeOutputDir != "" {
@@ -224,6 +230,9 @@ const (
 // 录播视频默认的封装格式。原版（orzogc/acfunlive）用 config.Output 决定扩展名，默认就是 mp4
 const defaultRecordFormat = "mp4"

+// 合并输出帧率的上限。再高只会让渲染更慢，对弹幕流畅度没有意义
+const maxMergeFps = 240
+
 // 支持的录播封装格式。录制用的是 -c copy，只换容器不转码，所以这些都只是封装差别
 var recordFormats = map[string]struct{}{
 	"mp4": {},
@@ -256,11 +265,12 @@ func recordFileExt() string {

 // 默认设置
 var config = configData{
-	UIDs:          uidList{},
-	WebPort:       51880,
-	RecordSubdir:  defaultRecordSubdir,
-	MergeSubdir:   defaultMergeSubdir,
-	NotifyEnabled: true,
+	UIDs:            uidList{},
+	WebPort:         51880,
+	RecordSubdir:    defaultRecordSubdir,
+	MergeSubdir:     defaultMergeSubdir,
+	NotifyEnabled:   true,
+	NotifyMergeFail: true,
 }

 // Windows 下不能用作文件（夹）名的保留字
@@ -322,10 +332,11 @@ func loadConfig() {
 	checkErr(err)

 	if json.Valid(data) {
-		// 老设置文件里没有 notifyEnabled 这个字段，默认按「开启」处理，
+		// 老设置文件里没有 notifyEnabled / notifyMergeFail 这两个字段，默认按「开启」处理，
 		// 否则升级后已经配好的推送会被静默关掉。写在 Unmarshal 前面，
 		// 文件里显式写了 false 时仍会被覆盖成 false
 		config.NotifyEnabled = true
+		config.NotifyMergeFail = true
 		err = json.Unmarshal(data, &config)
 		checkErr(err)
 	} else {
@@ -335,11 +346,18 @@ func loadConfig() {

 // 命令行合成模式（-danmuburn）也读取设置文件，让 ffmpeg 路径、成片目录等配置生效
 func loadConfigForDanmuburn() {
-	if *configDir == "" {
+	// 这条路径不走 initialize()，exeDir 得自己定：头像缓存放哪、ffmpeg 去哪找都看它。
+	// 漏掉的话 cacheDir 会变成「当前工作目录/avatar_cache」，换目录跑就会重新下一遍头像，
+	// 更糟的是旧版把头像绝对路径直接写进滤镜，拿到相对路径时 ffmpeg（工作目录是弹幕目录）
+	// 就找不到文件、整块渲染失败
+	if exeDir == "" {
 		if exePath, err := os.Executable(); err == nil {
-			*configDir = filepath.Dir(exePath)
+			exeDir = filepath.Dir(exePath)
 		}
 	}
+	if *configDir == "" {
+		*configDir = exeDir
+	}
 	if *configDir == "" {
 		return
 	}
@@ -386,6 +404,20 @@ func currentAuthToken() string {
 	return config.AuthToken
 }

+// 检查配置里的文件夹字段，返回错误信息，空字符串表示通过。
+// 启动读配置、web UI 改设置、转码排队都用这一份 —— 以前各自实现，
+// 启动那份直接 os.Stat + checkErr，目录不存在时会 panic 崩掉整个进程。
+func checkDirField(path, name string) string {
+	if path == "" {
+		return ""
+	}
+	info, err := os.Stat(path)
+	if err != nil || !info.IsDir() {
+		return name + " 必须是存在的文件夹：" + path
+	}
+	return ""
+}
+
 // 检查 config.json 里的配置
 func checkConfig() {
 	for _, u := range config.UIDs {
@@ -398,21 +430,15 @@ func checkConfig() {
 		lPrintErr(configFile + "里的 webPort 必须为 0（不启动 web UI）或者大于 1023 且少于 65536")
 		os.Exit(1)
 	}
-	if config.Directory != "" {
-		info, err := os.Stat(config.Directory)
-		checkErr(err)
-		if !info.IsDir() {
-			lPrintErrf("%s里的directory必须是存在的文件夹：%s", configFile, config.Directory)
-			os.Exit(1)
-		}
+	// 目录不在（盘没插、路径拼错）要给人话提示然后退出，不能直接 panic：
+	// 崩溃时文件系统风险未知，而且服务被托管时会被反复拉起来
+	if msg := checkDirField(config.Directory, configFile+"里的directory"); msg != "" {
+		lPrintErr(msg)
+		os.Exit(1)
 	}
-	if config.MergeOutputDir != "" {
-		info, err := os.Stat(config.MergeOutputDir)
-		checkErr(err)
-		if !info.IsDir() {
-			lPrintErrf("%s里的mergeOutputDir必须是存在的文件夹：%s", configFile, config.MergeOutputDir)
-			os.Exit(1)
-		}
+	if msg := checkDirField(config.MergeOutputDir, configFile+"里的mergeOutputDir"); msg != "" {
+		lPrintErr(msg)
+		os.Exit(1)
 	}
 	if config.MergeBitrate < 0 {
 		lPrintErrf("%s里的mergeBitrate不能小于 0", configFile)
@@ -422,6 +448,10 @@ func checkConfig() {
 		lPrintErrf("%s里的danmuFontSize不能小于 0（0 表示按画面分辨率自动）", configFile)
 		os.Exit(1)
 	}
+	if config.MergeFps < 0 || config.MergeFps > maxMergeFps {
+		lPrintErrf("%s里的mergeFps只能在 0（跟随源片）到 %d 之间", configFile, maxMergeFps)
+		os.Exit(1)
+	}
 	if config.DefaultBitrate < 0 {
 		lPrintErrf("%s里的defaultBitrate不能小于 0", configFile)
 		os.Exit(1)
@@ -462,7 +492,7 @@ func checkConfig() {
 		config.FFmpegPath = ""
 	}
 	// 确保保存文件夹存在
-	for _, d := range []string{recordingDir(), recordSaveDir(), mergeSaveDir()} {
+	for _, d := range []string{recordSaveDir(), mergeSaveDir()} {
 		if err := os.MkdirAll(d, 0755); err != nil {
 			lPrintErrf("创建文件夹 %s 失败：%v", d, err)
 			os.Exit(1)
@@ -1101,7 +1131,9 @@ func (s *streamer) moveDanmuFiles(assFile string) {
 	s.moveFile(jsonlFile)
 }

-// 移动文件
+// 把送出文件到保存目录下，路径一致时什么也不做。
+// 录制的产出本来就写在 recordSaveDir() 里（见 recordSaveDir 的注释），
+// 这里是条保险：路径由别处给进来、或者运行中被改过保存目录时，仍以当前配置为准收拢一次。
 func (s *streamer) moveFile(oldFile string) {
 	if oldFile == "" {
 		return
@@ -4,9 +4,92 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )

+// 「合并失败」推送是新增的开关，老设置文件里没有这个字段 —— 升级后不能静默关掉，
+// 也不能把用户显式写的 false 顶回 true。同一个坑「推送渠道」已经踩过一次
+func TestLoadConfigPresetsNotifyMergeFail(t *testing.T) {
+	dir := t.TempDir()
+	savedConfig := config
+	savedLocation := configFileLocation
+	oldDir := configDir
+	if configDir == nil {
+		configDir = new(string)
+	}
+	defer func() {
+		config = savedConfig
+		configFileLocation = savedLocation
+		configDir = oldDir
+	}()
+	*configDir = dir
+	configFileLocation = filepath.Join(dir, configFile)
+
+	// 老文件：连 notifyEnabled 都没有，两个开关都该是默认开
+	content, _ := json.Marshal(map[string]any{"uids": []any{}, "mergeFps": 60})
+	if err := os.WriteFile(configFileLocation, content, 0644); err != nil {
+		t.Fatal(err)
+	}
+	config.NotifyMergeFail = false // 先弄脏，确认是 Unmarshal 之前被顶回 true 的
+	loadConfig()
+	if !config.NotifyMergeFail {
+		t.Error("老设置文件里没有 notifyMergeFail 时应当按开启处理")
+	}
+	if config.MergeFps != 60 {
+		t.Errorf("mergeFps 没读进来：%d", config.MergeFps)
+	}
+
+	// 文件里显式写了 false，必须尊重
+	content, _ = json.Marshal(map[string]any{"notifyMergeFail": false, "mergeFps": 0})
+	if err := os.WriteFile(configFileLocation, content, 0644); err != nil {
+		t.Fatal(err)
+	}
+	config.NotifyMergeFail = true
+	loadConfig()
+	if config.NotifyMergeFail {
+		t.Error("文件里显式写的 notifyMergeFail=false 被顶回了 true")
+	}
+	if config.MergeFps != 0 {
+		t.Errorf("mergeFps 应当是 0，实际 %d", config.MergeFps)
+	}
+}
+
+// 命令行合成模式（-danmuburn）不走 initialize()，exeDir 必须由 loadConfigForDanmuburn 自己定：
+// 漏掉的话头像缓存就变成「当前工作目录/avatar_cache」—— 换个目录跑要重新下一遍头像，
+// 更糟的是旧版把头像一个相对路径写进滤镜，而 ffmpeg 的工作目录是弹幕目录，
+// 于是找不到文件、整块渲染失败（报错只显示「打不开 avatar_cache\xxx.png」）
+func TestLoadConfigForDanmuburnSetsExeDir(t *testing.T) {
+	savedConfig := config
+	savedExe, savedLocation := exeDir, configFileLocation
+	oldDir, oldRecordDir := configDir, recordDir
+	if configDir == nil {
+		configDir = new(string)
+	}
+	if recordDir == nil {
+		recordDir = new(string)
+	}
+	defer func() {
+		config = savedConfig
+		exeDir, configFileLocation = savedExe, savedLocation
+		configDir, recordDir = oldDir, oldRecordDir
+	}()
+
+	exeDir = ""
+	*configDir = ""
+	loadConfigForDanmuburn()
+
+	if exeDir == "" {
+		t.Fatal("loadConfigForDanmuburn 应当把 exeDir 定下来，否则头像缓存会落到当前工作目录")
+	}
+	if !filepath.IsAbs(avatarCachePath()) {
+		t.Fatalf("头像缓存路径应当是绝对路径，实际 %q", avatarCachePath())
+	}
+	if filepath.Dir(configFileLocation) != exeDir {
+		t.Errorf("没指定 -config 时设置文件应当在程序目录，实际 %q（exeDir=%q）", configFileLocation, exeDir)
+	}
+}
+
 // 改设置会重新读取配置（web UI 保存、或直接改 config.json），
 // 这一步绝不能删掉正在进行的合并的临时文件 —— 否则合并会当场失败。
 func TestReloadConfigKeepsMergeTempFiles(t *testing.T) {
@@ -63,3 +146,48 @@ func TestReloadConfigKeepsMergeTempFiles(t *testing.T) {
 		}
 	}
 }
+
+// 保存目录填错（盘没插、路径拼错）时启动必须给一句人话再退出，
+// 不能 panic 崩掉整个进程 —— 服务被托管时崩了还会被反复拉起来
+func TestCheckDirFieldReportsMissingDir(t *testing.T) {
+	root := t.TempDir()
+	if msg := checkDirField("", "directory"); msg != "" {
+		t.Errorf("留空表示不指定，不该报错：%s", msg)
+	}
+	if msg := checkDirField(root, "directory"); msg != "" {
+		t.Errorf("存在的文件夹不该报错：%s", msg)
+	}
+	if msg := checkDirField(filepath.Join(root, "没有这个目录"), "directory"); !strings.Contains(msg, "必须是存在的文件夹") {
+		t.Errorf("目录不存在时要给出提示，实际返回 %q", msg)
+	}
+	file := filepath.Join(root, "afile")
+	if err := os.WriteFile(file, []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if msg := checkDirField(file, "directory"); msg == "" {
+		t.Error("指向文件而不是文件夹时应当报错")
+	}
+}
+
+// checkConfig 里曾经直接 os.Stat + checkErr：目录不在时会 panic 崩掉进程。
+// 这条路径没法在测试里真跑一遍（失败时是 os.Exit(1)，会把整个测试进程带走），
+// 所以退一步把「只能给提示再退出」钉在源码上。
+func TestCheckConfigNeverPanicsOnMissingDir(t *testing.T) {
+	src, err := os.ReadFile("config.go")
+	if err != nil {
+		t.Skip("读不到 config.go：" + err.Error())
+	}
+	text := string(src)
+	start := strings.Index(text, "func checkConfig()")
+	if start < 0 {
+		t.Fatal("config.go 里找不到 checkConfig")
+	}
+	rest := text[start:]
+	end := strings.Index(rest, "\n}\n")
+	if end < 0 {
+		t.Fatal("checkConfig 的函数体没有正常收尾")
+	}
+	if strings.Contains(rest[:end], "checkErr(") {
+		t.Error("checkConfig 里不能用 checkErr：出错会变成 panic 崩进程，改成 lPrintErr + os.Exit(1)")
+	}
+}
@@ -146,6 +146,18 @@ func textWidth(text string, fontSize int) int {
 	return w
 }

+// 弹幕滚动的两个关键时刻：完全进入（emerge）和完全离开（left）。
+// resX 是画面宽度、length 是弹幕宽度，两者相加是它要走的整段行程。
+// 配置异常（PlayResX 为 0）碰上空内容时这段行程会是 0，直接拿它做除数是整数除零 panic
+// （会终止整场录制），这种情况退回「半个停留时长」，至少让它正常显示出来。
+func scrollMarks(rel int64, resX, length int, show int64) (emerge, left int64) {
+	total := int64(resX + length)
+	if total <= 0 {
+		return rel + show/2, rel + show
+	}
+	return rel + int64(length)*show/total, rel + int64(resX)*show/total
+}
+
 // 在弹道数组里寻找空闲弹道，返回弹道行号，没有空闲返回 -1，公式与 acfundanmu 保持一致
 func placeLane(last []laneState, dt laneState, leftTime int64) int {
 	for i, t := range last {
@@ -165,6 +177,21 @@ type danmuWriter struct {
 	jsonl *os.File
 	lastO []laneState // 原格式的弹道状态
 	lastN []laneState // 昵称头像版的弹道状态
+	err   error       // 写盘出过的错。只记头一个，见 danmuWriter.fail
+}
+
+// 记一次写盘错误。只保留第一个：磁盘满了之后每写一条都会失败，
+// 全记下来只会把日志刷爆，而第一个就足以说明原因
+func (w *danmuWriter) fail(what string, err error) {
+	if w.err == nil {
+		w.err = fmt.Errorf("%s失败：%v", what, err)
+	}
+}
+
+// 本场弹幕有没有写坏。写坏的文件不能当正常的用 —— 否则合并出来的成片
+// 会缺一大截弹幕，而日志里什么都看不出来
+func (w *danmuWriter) failed() bool {
+	return w.err != nil
 }

 // 返回昵称头像版 ASS 和 jsonl 的文件路径
@@ -189,17 +216,33 @@ func newDanmuWriter(liveID, streamName string, cfg acfundanmu.SubConfig, assFile
 	w.jsonl, err = os.OpenFile(jsonlFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
 	checkErr(err)

-	fmt.Fprintf(w.ass, scriptInfoTmpl, liveID, streamName, cfg.Title, cfg.PlayResX, cfg.PlayResY)
-	fmt.Fprintf(w.ass, stylesTmpl, cfg.FontSize)
-	fmt.Fprint(w.ass, eventsTmpl)
-	fmt.Fprintf(w.nick, scriptInfoTmpl, liveID, streamName, cfg.Title+" 昵称头像版", cfg.PlayResX, cfg.PlayResY)
-	fmt.Fprintf(w.nick, stylesTmpl, cfg.FontSize)
-	fmt.Fprint(w.nick, eventsTmpl)
+	if _, err := fmt.Fprintf(w.ass, scriptInfoTmpl, liveID, streamName, cfg.Title, cfg.PlayResX, cfg.PlayResY); err != nil {
+		w.fail("写原格式 ASS 文件头", err)
+	}
+	if _, err := fmt.Fprintf(w.ass, stylesTmpl, cfg.FontSize); err != nil {
+		w.fail("写原格式 ASS 文件头", err)
+	}
+	if _, err := fmt.Fprint(w.ass, eventsTmpl); err != nil {
+		w.fail("写原格式 ASS 文件头", err)
+	}
+	if _, err := fmt.Fprintf(w.nick, scriptInfoTmpl, liveID, streamName, cfg.Title+" 昵称头像版", cfg.PlayResX, cfg.PlayResY); err != nil {
+		w.fail("写昵称头像版 ASS 文件头", err)
+	}
+	if _, err := fmt.Fprintf(w.nick, stylesTmpl, cfg.FontSize); err != nil {
+		w.fail("写昵称头像版 ASS 文件头", err)
+	}
+	if _, err := fmt.Fprint(w.nick, eventsTmpl); err != nil {
+		w.fail("写昵称头像版 ASS 文件头", err)
+	}

 	meta, err := json.Marshal(danmuMeta{PlayResX: cfg.PlayResX, PlayResY: cfg.PlayResY, FontSize: cfg.FontSize, StartTime: cfg.StartTime})
 	checkErr(err)
-	w.jsonl.Write(meta)
-	w.jsonl.Write([]byte("\n"))
+	if _, err := w.jsonl.Write(meta); err != nil {
+		w.fail("写弹幕 jsonl 文件头", err)
+	}
+	if _, err := w.jsonl.Write([]byte("\n")); err != nil {
+		w.fail("写弹幕 jsonl 文件头", err)
+	}
 	return w
 }

@@ -211,17 +254,19 @@ func (w *danmuWriter) write(c *acfundanmu.Comment) {

 	// 原格式 ASS，碰撞避让和坐标公式与 acfundanmu 完全一致
 	length := utf8.RuneCountInString(c.Content) * s.FontSize
+	emergeO, leftO := scrollMarks(rel, s.PlayResX, length, danmuShowDur)
 	dtO := laneState{
 		appear:    rel,
-		emerge:    rel + (int64(length)*danmuShowDur)/int64(s.PlayResX+length),
+		emerge:    emergeO,
 		disappear: rel + danmuShowDur,
 	}
-	leftO := rel + (int64(s.PlayResX)*danmuShowDur)/int64(s.PlayResX+length)
 	if i := placeLane(w.lastO, dtO, leftO); i >= 0 {
-		fmt.Fprintf(w.ass, dialogueTmpl,
+		if _, err := fmt.Fprintf(w.ass, dialogueTmpl,
 			assTime(dtO.appear), assTime(dtO.disappear),
 			strings.ReplaceAll(c.Nickname, ",", " "), c.UserID,
-			s.PlayResX+length/2, s.FontSize*(i+1), -length/2, s.FontSize*(i+1), c.Content)
+			s.PlayResX+length/2, s.FontSize*(i+1), -length/2, s.FontSize*(i+1), c.Content); err != nil {
+			w.fail("写原格式 ASS", err)
+		}
 	}

 	// 昵称头像版 ASS，\an7 锚点在文本左上角，头像由 ffmpeg 叠在文字左侧，不依赖字体渲染宽度
@@ -229,17 +274,19 @@ func (w *danmuWriter) write(c *acfundanmu.Comment) {
 	width := textWidth(text, s.FontSize)
 	avW, avGap := avatarSize(s.FontSize), avatarGap(s.FontSize)
 	total := avW + avGap + width // 头像、间隔和文字的总宽度
+	emergeN, leftN := scrollMarks(rel, s.PlayResX, total, danmuShowDur)
 	dtN := laneState{
 		appear:    rel,
-		emerge:    rel + (int64(total)*danmuShowDur)/int64(s.PlayResX+total),
+		emerge:    emergeN,
 		disappear: rel + danmuShowDur,
 	}
-	leftN := rel + (int64(s.PlayResX)*danmuShowDur)/int64(s.PlayResX+total)
 	if i := placeLane(w.lastN, dtN, leftN); i >= 0 {
-		fmt.Fprintf(w.nick, dialogueNickTmpl,
+		if _, err := fmt.Fprintf(w.nick, dialogueNickTmpl,
 			assTime(dtN.appear), assTime(dtN.disappear),
 			strings.ReplaceAll(c.Nickname, ",", " "), c.UserID,
-			s.PlayResX+avW+avGap, s.FontSize*i, -width, s.FontSize*i, text)
+			s.PlayResX+avW+avGap, s.FontSize*i, -width, s.FontSize*i, text); err != nil {
+			w.fail("写昵称头像版 ASS", err)
+		}
 		rec := danmuRecord{
 			Time:    float64(rel) / 1e9,
 			UID:     c.UserID,
@@ -251,8 +298,12 @@ func (w *danmuWriter) write(c *acfundanmu.Comment) {
 		}
 		b, err := json.Marshal(rec)
 		checkErr(err)
-		w.jsonl.Write(b)
-		w.jsonl.Write([]byte("\n"))
+		if _, err := w.jsonl.Write(b); err != nil {
+			w.fail("写弹幕 jsonl", err)
+		}
+		if _, err := w.jsonl.Write([]byte("\n")); err != nil {
+			w.fail("写弹幕 jsonl", err)
+		}
 	}
 }

@@ -276,11 +327,20 @@ func (w *danmuWriter) consume(ctx context.Context, ac *acfundanmu.AcFunLive) {
 	}
 }

-// 关闭所有文件
-func (w *danmuWriter) close() {
-	w.ass.Close()
-	w.nick.Close()
-	w.jsonl.Close()
+// 关闭所有文件，并把整个录制过程中出过的写盘错误一并交出来。
+// Close 自己的错误也要记：os.File 在部分系统上（NFS、某些网络盘）是到 Close
+// 才报出「写不进去」的，只盯每次 Write 的返回值会漏掉这种情况
+func (w *danmuWriter) close() error {
+	if err := w.ass.Close(); err != nil {
+		w.fail("关闭原格式 ASS", err)
+	}
+	if err := w.nick.Close(); err != nil {
+		w.fail("关闭昵称头像版 ASS", err)
+	}
+	if err := w.jsonl.Close(); err != nil {
+		w.fail("关闭弹幕 jsonl", err)
+	}
+	return w.err
 }

 // ==================== 录制流程 ====================
@@ -305,7 +365,15 @@ func (s streamer) getDanmu(ctx context.Context, info liveInfo) {
 	_ = ac.StartDanmu(ctx, false)
 	streamInfo := ac.GetStreamInfo()
 	w := newDanmuWriter(streamInfo.LiveID, streamInfo.StreamName, info.cfg, info.assFile)
-	defer w.close()
+	// 写盘出错要到关文件时才收得全（有的系统到 Close 才报「写不进去」）。
+	// 必须说出来：否则本场照常自动合并，出来的成片缺一大截弹幕，日志里却一切正常
+	defer func() {
+		if err := w.close(); err != nil {
+			lPrintErrf("录制%s的直播弹幕时写盘出错，弹幕文件不完整：%v", s.longID(), err)
+			lPrintErrf("本场不做自动合并，弹幕文件保留在 %s，请检查磁盘空间后手动合并", info.assFile)
+			updateLiveInfo(info.LiveID, func(i *liveInfo) { i.danmuWriteFailed = true })
+		}
+	}()
 	w.consume(ctx, ac)

 	// 断流后先观察一个窗口：网络波动或主播短暂掉线（20 秒内）恢复时沿用同一个写入器接着写，
@@ -0,0 +1,309 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"image"
+	"image/png"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+// ==================== ffmpeg 报错的可见性 ====================
+
+// 尾部 writer 只留最近若干行（ffmpeg 的进度行会不停刷）
+func TestTailWriterKeepsLastLines(t *testing.T) {
+	w := newTailWriter(3)
+	fmt.Fprint(w, "第1行\n第2行\n第3行\r第4行\n第5行\n")
+	got := w.String()
+	if !strings.Contains(got, "第5行") {
+		t.Fatalf("应当保留最后一行：%q", got)
+	}
+	if strings.Contains(got, "第1行") || strings.Contains(got, "第2行") {
+		t.Fatalf("超出保留行数的旧内容应当被丢掉：%q", got)
+	}
+	if lines := strings.Split(got, "\n"); len(lines) != 3 {
+		t.Fatalf("应当只留 3 行，实际 %d 行：%q", len(lines), got)
+	}
+}
+
+// 失败时要把 ffmpeg 自己的报错带上，不然只剩一句 exit status
+func TestFFmpegResultCarriesStderr(t *testing.T) {
+	err := ffmpegResult(errors.New("exit status 0xffffffea"), "Error binding filtergraph inputs/outputs")
+	if err == nil {
+		t.Fatal("应当返回错误")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "exit status 0xffffffea") || !strings.Contains(msg, "Error binding filtergraph") {
+		t.Fatalf("错误里应当同时有退出状态和 ffmpeg 的说明，实际：%s", msg)
+	}
+
+	// 成功时不带任何东西
+	if got := ffmpegResult(nil, "随便什么输出"); got != nil {
+		t.Fatalf("成功时应当返回 nil，实际 %v", got)
+	}
+	// 没有 stderr 时保持原样
+	plain := errors.New("exit status 1")
+	if got := ffmpegResult(plain, "   "); got != plain {
+		t.Fatalf("没有 ffmpeg 输出时应当原样返回，实际 %v", got)
+	}
+}
+
+// 跟编码器无关的失败不该挨个回退重试
+func TestEncoderMightHelp(t *testing.T) {
+	unrelated := []string{
+		"Error binding filtergraph inputs/outputs: Invalid argument",
+		"Error initializing filtergraph",
+		"Error opening input: No such file or directory",
+	}
+	for _, msg := range unrelated {
+		if encoderMightHelp(errors.New(msg)) {
+			t.Fatalf("这类失败跟编码器无关，不该回退重试：%s", msg)
+		}
+	}
+	related := []string{
+		"Error initializing output stream 0:0 -- Error while opening encoder",
+		"hevc_qsv: Function not implemented",
+	}
+	for _, msg := range related {
+		if !encoderMightHelp(errors.New(msg)) {
+			t.Fatalf("编码器自身的失败应当允许回退：%s", msg)
+		}
+	}
+}
+
+// ==================== 头像缓存完整性 ====================
+
+func tinyPNG(t *testing.T) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, image.NewRGBA(image.Rect(0, 0, 8, 8))); err != nil {
+		t.Fatal(err)
+	}
+	return buf.Bytes()
+}
+
+// 半截的 PNG 不能被当成可用缓存
+func TestValidCachedAvatar(t *testing.T) {
+	dir := t.TempDir()
+	good := tinyPNG(t)
+
+	full := filepath.Join(dir, "full.png")
+	if err := os.WriteFile(full, good, 0644); err != nil {
+		t.Fatal(err)
+	}
+	if !validCachedAvatar(full) {
+		t.Fatal("完整的 PNG 应当算有效")
+	}
+
+	// 砍掉尾巴（模拟下载中断）
+	cut := filepath.Join(dir, "cut.png")
+	if err := os.WriteFile(cut, good[:len(good)-8], 0644); err != nil {
+		t.Fatal(err)
+	}
+	if validCachedAvatar(cut) {
+		t.Fatal("半截 PNG 不该算有效")
+	}
+
+	empty := filepath.Join(dir, "empty.png")
+	if err := os.WriteFile(empty, nil, 0644); err != nil {
+		t.Fatal(err)
+	}
+	if validCachedAvatar(empty) {
+		t.Fatal("空文件不该算有效")
+	}
+	if validCachedAvatar(filepath.Join(dir, "不存在.png")) {
+		t.Fatal("不存在的文件不该算有效")
+	}
+}
+
+// 命中的是半截缓存时要重新下载，下载完必须是完整 PNG
+func TestEnsureAvatarRedownloadsBrokenCache(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	var hits int64
+	body := tinyPNG(t)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&hits, 1)
+		w.Header().Set("Content-Type", "image/png")
+		_, _ = w.Write(body)
+	}))
+	defer srv.Close()
+
+	url := srv.URL + "/a.png"
+	path := filepath.Join(dir, avatarCacheName(42, url))
+	// 先摆一个「写了一半」的缓存
+	if err := os.WriteFile(path, body[:len(body)-8], 0644); err != nil {
+		t.Fatal(err)
+	}
+	if validCachedAvatar(path) {
+		t.Fatal("前置条件不成立：半截文件应当被判为无效")
+	}
+
+	got := ensureAvatar(42, url, dir)
+	if got != path {
+		t.Fatalf("应当返回缓存路径 %q，实际 %q", path, got)
+	}
+	if atomic.LoadInt64(&hits) == 0 {
+		t.Fatal("半截缓存应当触发重新下载")
+	}
+	if !validCachedAvatar(path) {
+		t.Fatal("重新下载之后应当是完整的 PNG")
+	}
+}
+
+// 完好的缓存不该再走网络
+func TestEnsureAvatarUsesGoodCache(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	var hits int64
+	body := tinyPNG(t)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(&hits, 1)
+		_, _ = w.Write(body)
+	}))
+	defer srv.Close()
+
+	url := srv.URL + "/b.png"
+	path := filepath.Join(dir, avatarCacheName(43, url))
+	if err := os.WriteFile(path, body, 0644); err != nil {
+		t.Fatal(err)
+	}
+	if got := ensureAvatar(43, url, dir); got != path {
+		t.Fatalf("应当直接命中缓存，实际 %q", got)
+	}
+	if n := atomic.LoadInt64(&hits); n != 0 {
+		t.Fatalf("完好的缓存不该再请求网络，实际 %d 次", n)
+	}
+}
+
+// 下载过程中不会留下能被误用的半截文件
+func TestDownloadAvatarWritesAtomically(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write(tinyPNG(t))
+	}))
+	defer srv.Close()
+
+	url := srv.URL + "/c.png"
+	path := filepath.Join(dir, avatarCacheName(44, url))
+	if err := downloadAvatar(44, url, path); err != nil {
+		t.Fatalf("下载不该失败：%v", err)
+	}
+	if !validCachedAvatar(path) {
+		t.Fatal("下载完的缓存应当是完整 PNG")
+	}
+	// 临时文件不该留下
+	if entries, err := os.ReadDir(dir); err == nil {
+		for _, e := range entries {
+			if strings.HasSuffix(e.Name(), ".part") {
+				t.Fatalf("不该留下临时文件：%s", e.Name())
+			}
+		}
+	}
+}
+
+// 记录当前日志长度，返回一个能读到之后新增内容的函数
+func logCursor() func() string {
+	logString.Lock()
+	start := logString.str.Len()
+	logString.Unlock()
+	return func() string {
+		logString.Lock()
+		defer logString.Unlock()
+		data := logString.str.String()
+		if start > len(data) {
+			return data // 中间被 Reset 过，那就给全部
+		}
+		return data[start:]
+	}
+}
+
+// 头像输入打不开属于「跟编码器无关」的失败：不该挨个编码器回退重试，
+// 而且 ffmpeg 自己的报错必须留在日志里（否则只剩一句 exit status 0xffffffea）
+func TestRenderChunkDoesNotFallBackOnUnrelatedFailure(t *testing.T) {
+	ffmpegFile := getFFmpeg()
+	if ffmpegFile == "" {
+		t.Skip("找不到 ffmpeg，跳过")
+	}
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	video := filepath.Join(dir, "in.mp4")
+	makeTinyVideo(t, ffmpegFile, video, "red")
+
+	uid := int64(1)
+	chunk := danmuChunk{start: 0, end: 1, records: []danmuRecord{
+		{Time: 0.2, UID: uid, Name: "甲", Content: "正常一条", Lane: 0, Width: 100},
+	}}
+	ctx := &burnContext{
+		ffmpegFile: ffmpegFile,
+		videoFile:  video,
+		outFile:    filepath.Join(dir, "out.mp4"),
+		meta:       danmuMeta{PlayResX: 160, PlayResY: 120, FontSize: 20},
+		// 头像文件根本不存在：ffmpeg 打开输入就会失败
+		avatars: map[int64]string{uid: filepath.Join(dir, "根本没有这个头像.png")},
+		dir:     dir,
+		// 故意不指定 encoder：从候选列表第一个开始，才能看出有没有挨个回退
+	}
+	ad, gap := avatarSize(ctx.meta.FontSize), avatarGap(ctx.meta.FontSize)
+	if err := writeChunkAss(filepath.Join(dir, "chunk.ass"), ctx.meta, chunk, 0, ad, gap); err != nil {
+		t.Fatal(err)
+	}
+
+	read := logCursor()
+	err := ctx.renderChunk(chunk, "chunk.ass", filepath.Join(dir, "out.mp4"), false, nil)
+	if err == nil {
+		t.Fatal("头像打不开时应当渲染失败")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "ffmpeg 最后的输出") {
+		t.Fatalf("错误里应当带上 ffmpeg 自己的输出：%s", msg)
+	}
+	if log := read(); strings.Contains(log, "回退到") {
+		t.Fatalf("输入打不开跟编码器无关，不该挨个回退重试：\n%s", log)
+	}
+}
+
+// 启动时那段版本/编译配置要过滤掉，别把真正的报错挤出日志
+func TestTailWriterSkipsStartupNoise(t *testing.T) {
+	w := newTailWriter(10)
+	fmt.Fprint(w, "ffmpeg version n9.0.2-3\n"+
+		"  built with gcc 16.2.0\n"+
+		"  configuration: --prefix=/ffbuild --enable-gpl --enable-libass 等等很长的一行\n"+
+		"  libavutil      61.  1.102 / 61.  1.102\n"+
+		"  libswscale     10.  1.102 / 10.  1.102\n"+
+		"[in#0 @ 0x1] moov atom not found\n"+
+		"Error opening input files: Invalid data found when processing input\n")
+	got := w.String()
+	for _, noise := range []string{"ffmpeg version", "configuration:", "libavutil", "libswscale", "built with"} {
+		if strings.Contains(got, noise) {
+			t.Fatalf("启动信息应当被过滤掉（%s），实际：%q", noise, got)
+		}
+	}
+	if !strings.Contains(got, "moov atom not found") || !strings.Contains(got, "Invalid data found") {
+		t.Fatalf("真正的报错必须保留：%q", got)
+	}
+}
+
+// 头像直径再小也要 >= 1，否则 scale=0:0 会让 ffmpeg 直接 EINVAL
+func TestAvatarSizeNeverZero(t *testing.T) {
+	for _, fs := range []int{0, 1, 2, 5, 42, 60} {
+		if got := avatarSize(fs); got < 1 {
+			t.Fatalf("字号 %d 算出的头像直径是 %d，应当至少为 1", fs, got)
+		}
+	}
+	if got := avatarSize(60); got != 48 {
+		t.Fatalf("正常字号的口径不该变：60 -> %d（应为 48）", got)
+	}
+}
@@ -258,22 +258,6 @@ func getLiveID(uid int) string {
 	return ""
 }

-// 根据 uid 查看主播是否正在直播
-func isLiveOn(uid int) bool {
-	liveRooms.RLock()
-	_, ok := liveRooms.rooms[uid]
-	liveRooms.RUnlock()
-	if ok {
-		return true
-	}
-
-	if isLive, room, err := tryFetchLiveInfo(uid); err == nil {
-		defer liveRoomPool.Put(room)
-		return isLive
-	}
-	return false
-}
-
 // 获取主播直播间的标题
 func (s *streamer) getTitle() string {
 	return getTitle(s.UID)
@@ -24,5 +24,5 @@ func transFilename(filename string) string {
 		}
 		filename = filename[:cut]
 	}
-	return filepath.Join(recordingDir(), filename)
+	return filepath.Join(recordSaveDir(), filename)
 }
@@ -0,0 +1,86 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// 录制过程中 ffmpeg 是按 transFilename 给的路径写文件的。
+// 以前这条路径走的是 -record 参数而不是 directory 设置，配了保存目录的人会看到
+// 文件先落在程序目录里、录完才搬一次；这里把「必须等于最终保存目录」钉死。
+func TestTransFilenameSavesIntoConfiguredDir(t *testing.T) {
+	savedConfig, savedRecordDir := config, recordDir
+	defer func() { config, recordDir = savedConfig, savedRecordDir }()
+
+	root, dashDir := t.TempDir(), t.TempDir()
+	recordDir = &dashDir
+	config.RecordSubdir = "record"
+
+	// 配了 directory：不管 -record 参数是什么，都得以它为准
+	config.Directory = root
+	got := filepath.Clean(transFilename("2026-09-27 22-40-42 甲 标题.mp4"))
+	want := filepath.Join(root, "record", "2026-09-27 22-40-42 甲 标题.mp4")
+	if got != filepath.Clean(want) {
+		t.Errorf("配了 directory 后录制路径不对：\n got  %s\n want %s", got, want)
+	}
+	if !strings.HasPrefix(got, filepath.Clean(root)) {
+		t.Errorf("录制路径落在了保存目录之外：%s", got)
+	}
+
+	// 没配 directory：回落到 -record 指定的文件夹
+	config.Directory = ""
+	got = filepath.Clean(transFilename("x.mp4"))
+	if filepath.Dir(got) != filepath.Clean(filepath.Join(dashDir, "record")) {
+		t.Errorf("directory 为空时应回落到 -record 目录：%s", got)
+	}
+
+	// 连 -record 都还没解析时也不能拼出相对路径，否则 ffmpeg 会写到进程的工作目录去
+	blank := ""
+	recordDir = &blank
+	if root := saveRootDir(); !filepath.IsAbs(root) {
+		t.Errorf("传入的参数都没解析时 saveRootDir 仍应是绝对路径，实际 %q", root)
+	}
+	if got := filepath.Clean(transFilename("x.mp4")); !filepath.IsAbs(got) {
+		t.Errorf("录制路径不能是相对路径：%q", got)
+	}
+}
+
+// 保存目录和录制目录现在是一个，moveFile 再挪一遍等于白复制一份（跨盘时尤其慢）
+func TestMoveFileKeepsFileInSaveDir(t *testing.T) {
+	savedConfig, savedRecordDir := config, recordDir
+	defer func() { config, recordDir = savedConfig, savedRecordDir }()
+
+	root := t.TempDir()
+	recordDir = &root
+	config.Directory = root
+	config.RecordSubdir = "record"
+
+	if err := os.MkdirAll(recordSaveDir(), 0755); err != nil {
+		t.Fatal(err)
+	}
+	p := filepath.Join(recordSaveDir(), "2026-09-27 22-40-42 甲 标题.mp4")
+	if err := os.WriteFile(p, []byte("fake"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	s := &streamer{UID: 1}
+	s.moveFile(p)
+	if _, err := os.Stat(p); err != nil {
+		t.Errorf("文件已经在保存目录里了，moveFile 不该动它：%v", err)
+	}
+
+	// 别处给进来的路径（比如手填的绝对路径）仍要收拢到保存目录
+	outside := filepath.Join(t.TempDir(), "outside.mp4")
+	if err := os.WriteFile(outside, []byte("fake"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	s.moveFile(outside)
+	if _, err := os.Stat(outside); !os.IsNotExist(err) {
+		t.Errorf("保存目录之外的文件应当被移动，原位置却还在")
+	}
+	if _, err := os.Stat(filepath.Join(recordSaveDir(), "outside.mp4")); err != nil {
+		t.Errorf("文件没有出现在保存目录里：%v", err)
+	}
+}
@@ -16,7 +16,7 @@ func transFilename(filename string) string {
 	// 转换文件名不允许的特殊字符
 	re := regexp.MustCompile(`[<>:"/\\|?*\r\n]`)
 	filename = re.ReplaceAllString(filename, "-")
-	dir := recordingDir()
+	dir := recordSaveDir()
 	outFilename := filepath.Join(dir, filename)
 	if utf8.RuneCountInString(outFilename) <= maxPathRunes {
 		return outFilename
@@ -0,0 +1,101 @@
+package main
+
+import (
+	"math"
+	"path/filepath"
+	"testing"
+)
+
+// 输出帧率只在目标的**上面**才生效：源片本来就 60fps 时填 30 只会把画面压得更卡，
+// 源片帧率探测不到（0）时也不动，免得把高帧率源押到某个值
+func TestOutputFpsOnlyRaises(t *testing.T) {
+	for _, c := range []struct {
+		target int
+		source float64
+		want   int
+	}{
+		{0, 30, 0},      // 没填：跟随源片
+		{60, 0, 0},      // 源片帧率探测不到：不动
+		{60, 30, 60},    // 15/24/30fps 录播里弹幕一格一格跳，提上去
+		{60, 60, 0},     // 已经一样高：不动
+		{60, 59.94, 60}, // 29.97/59.94 这类小数帧率要当成「低一点点」
+		{30, 60, 0},     // 降帧没意义
+		{-1, 30, 0},     // 非法值当成没填
+	} {
+		if got := outputFps(c.target, c.source); got != c.want {
+			t.Errorf("outputFps(%d, %g) = %d，期望 %d", c.target, c.source, got, c.want)
+		}
+	}
+}
+
+// 透明头像层模式没有源片可跟：设置填了就按填的，没填固定 30
+func TestLayerFpsFallback(t *testing.T) {
+	if got := layerFps(0); got != defaultLayerFps {
+		t.Errorf("layerFps(0) = %d，期望 %d", got, defaultLayerFps)
+	}
+	if got := layerFps(60); got != 60 {
+		t.Errorf("layerFps(60) = %d，期望 60", got)
+	}
+	// 手工构造的 burnContext 没填这个字段时也不能把 r=0 交给 ffmpeg
+	// （color 源拿 r=0 会直接 EINVAL，症状是 exit status 0xffffffea）
+	ctx := &burnContext{}
+	if got := ctx.layerRate(); got != defaultLayerFps {
+		t.Errorf("没填 layerFps 的 burnContext 应当回落到 %d，实际 %d", defaultLayerFps, got)
+	}
+	ctx.layerFps = 25
+	if got := ctx.layerRate(); got != 25 {
+		t.Errorf("填了 layerFps 就按填的来，实际 %d", got)
+	}
+}
+
+// 低帧率源设了输出帧率时，成片帧率真的会提上去：
+// fps 滤镜必须加在字幕/头像之前，弹幕才会按新帧率重绘；
+// 加在之后只是把已经画好的几帧复制一遍，看起来还是卡
+func TestRenderChunkRaisesFrameRate(t *testing.T) {
+	ffmpegFile := getFFmpeg()
+	if ffmpegFile == "" {
+		t.Skip("找不到 ffmpeg，跳过")
+	}
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	src := filepath.Join(dir, "src.mp4")
+	if err := runFFmpegWith(ffmpegFile, []string{
+		"-y", "-f", "lavfi", "-i", "color=c=black:s=160x120:d=1:r=15",
+		"-c:v", "libx264", "-pix_fmt", "yuv420p", src,
+	}, dir, nil); err != nil {
+		t.Skipf("生成 15fps 测试视频失败，跳过：%v", err)
+	}
+
+	chunk := danmuChunk{start: 0, end: 1, records: []danmuRecord{
+		{Time: 0.1, UID: 7, Name: "甲", Content: "提帧测试", Lane: 0, Width: 100},
+	}}
+	ctx := &burnContext{
+		ffmpegFile: ffmpegFile,
+		videoFile:  src,
+		outFile:    filepath.Join(dir, "out.mp4"),
+		meta:       danmuMeta{PlayResX: 160, PlayResY: 120, FontSize: 20},
+		avatars:    map[int64]string{},
+		dir:        dir,
+		encoder:    "libx264",
+		outFps:     outputFps(30, 15),
+	}
+	if ctx.outFps != 30 {
+		t.Fatalf("15fps 源设 30 应当产出 outFps=30，实际 %d", ctx.outFps)
+	}
+
+	assName := chunkTempPrefix + "fps_test.ass"
+	if err := writeChunkAss(filepath.Join(dir, assName), ctx.meta, chunk, 0,
+		avatarSize(ctx.meta.FontSize), avatarGap(ctx.meta.FontSize)); err != nil {
+		t.Fatal(err)
+	}
+
+	out := filepath.Join(dir, "chunk.mp4")
+	if err := ctx.renderChunk(chunk, assName, out, true, nil); err != nil {
+		t.Fatalf("提帧渲染不该失败：%v", err)
+	}
+	info := probeVideoStream(ffmpegFile, out)
+	if math.Abs(info.fps-30) > 0.5 {
+		t.Fatalf("成片帧率应当是 30，实际 %.2f", info.fps)
+	}
+}
@@ -1,6 +1,6 @@
 module github.com/orzogc/acfunlive

-go 1.26.0
+go 1.27.3

 require (
 	github.com/PuerkitoBio/goquery v1.13.0
@@ -27,13 +27,39 @@ var mergeVideoExts = map[string]struct{}{
 var mergeDanmuExts = map[string]struct{}{".jsonl": {}, ".ass": {}}

 // 手动合并的请求体
+//
+// 两种写法：只填 videos/danmu 是单个任务（老样子）；填 jobs 是一次排多个任务，
+// 每个任务自带视频、弹幕和合成参数，服务端按顺序串行合并
 type mergeRequest struct {
 	Videos  []string `json:"videos"`  // 视频文件，可多个（断流分段）：文件名或绝对/相对路径
 	Danmu   string   `json:"danmu"`   // 弹幕文件：.jsonl 直接用，.ass / .nick.ass 先还原成 jsonl
 	Offset  *float64 `json:"offset"`  // 手动指定的偏移（秒），不填则按文件名里的录制时间推算
 	OutName string   `json:"outName"` // 输出文件名，留空用默认名且自动避开重名
+
+	Options mergeOptions  `json:"options"` // 这一次合成的参数，不填的项用全局设置
+	Jobs    []mergeJobReq `json:"jobs"`    // 批量：每个任务一套自己的文件和参数
 }

+// 批量里的一个合并任务
+type mergeJobReq struct {
+	Videos  []string     `json:"videos"`  // 这一组的视频，多个就是同一场的断流分段，会先拼起来
+	Danmu   string       `json:"danmu"`   // 这一组的弹幕文件
+	Offset  *float64     `json:"offset"`  // 这一组的偏移
+	OutName string       `json:"outName"` // 这一组的输出文件名
+	Options mergeOptions `json:"options"` // 这一组的合成参数
+}
+
+// 一次最多排多少个合并任务。再多就得等太久，队列状态也会一直占着
+const maxMergeJobs = 50
+
+// 批量任务里每个任务的结果，页面按它显示「第几个、成功还是失败」
+type mergeJobResult struct {
+	OutName string `json:"outName"`
+	Err     string `json:"err"` // 空表示成功
+}
+
+func (r mergeJobResult) ok() bool { return r.Err == "" }
+
 // 检查结果里每个视频的信息
 type mergeVideoInfo struct {
 	Name     string  `json:"name"`
@@ -65,6 +91,7 @@ type mergePlan struct {
 	out    string   // 成片的绝对路径
 	meta   danmuMeta
 	offset *float64
+	opts   mergeOptions // 这一组自己的合成参数
 	info   mergeInfo
 }

@@ -75,6 +102,10 @@ var mergeRun struct {
 	outName string
 	lastErr string
 	doneAt  int64
+	// 批量合并的进度：一共几个、已经做完几个、每个的结果
+	total   int
+	done    int
+	results []mergeJobResult
 }

 // 手动合并是否正在进行
@@ -84,6 +115,15 @@ func mergeRunSnapshot() (busy bool, out string, lastErr string, doneAt int64) {
 	return mergeRun.busy, mergeRun.outName, mergeRun.lastErr, mergeRun.doneAt
 }

+// 批量合并的队列进度，页面用它显示「第 2/3 个」和各任务的结果
+func mergeQueueSnapshot() (busy bool, done, total int, results []mergeJobResult) {
+	mergeRun.Lock()
+	defer mergeRun.Unlock()
+	out := make([]mergeJobResult, len(mergeRun.results))
+	copy(out, mergeRun.results)
+	return mergeRun.busy, mergeRun.done, mergeRun.total, out
+}
+
 // 解析用户填的路径：可以先当文件名在录播/成片文件夹里找，也可以填绝对或相对路径
 func resolveMergeInput(value string) (string, error) {
 	value = strings.TrimSpace(value)
@@ -251,6 +291,9 @@ type danmuSource struct {
 	last      float64
 	hasAvatar bool
 	source    string // 来源说明
+	// 从 .ass 还原出来的结果写不进原目录、退到系统临时目录时置位：
+	// 这种文件调用方用完必须删掉，别在临时目录里越攒越多
+	tempJsonl bool
 }

 func prepareDanmuSource(path string, write bool) (danmuSource, error) {
@@ -275,7 +318,7 @@ func prepareDanmuSource(path string, write bool) (danmuSource, error) {
 		}
 	}

-	meta, records, err := parseAssFile(path)
+	meta, records, bad, err := parseAssFile(path)
 	if err != nil {
 		return danmuSource{}, err
 	}
@@ -286,6 +329,12 @@ func prepareDanmuSource(path string, write bool) (danmuSource, error) {
 		return src, nil
 	}

+	// 还原日志只在真正落盘这次打：页面的「检查」也会解析一遍同一个 .ass，
+	// 两处都打日志的话同一次还原会在日志里出现两遍
+	summary := fmt.Sprintf("已从 %s 还原出 %d 条弹幕（%dx%d，字号 %d，弹幕到 %s）",
+		filepath.Base(path), len(records), meta.PlayResX, meta.PlayResY, meta.FontSize,
+		formatSeconds(records[len(records)-1].Time))
+
 	if err := writeJsonlFile(jsonlPath, meta, records); err != nil {
 		// 目录只读等情况退到临时目录，不影响这次合并
 		tmp := filepath.Join(os.TempDir(), chunkTempPrefix+"converted.jsonl")
@@ -294,12 +343,31 @@ func prepareDanmuSource(path string, write bool) (danmuSource, error) {
 		}
 		lPrintWarnf("无法把还原结果写入 %s（%v），改用临时文件 %s", jsonlPath, err, tmp)
 		src.jsonlPath = tmp
+		src.tempJsonl = true
+		lPrintf("%s，写成 %s", summary, filepath.Base(tmp))
+		logAssBadLines(path, bad)
 		return src, nil
 	}
-	lPrintf("已把 %s 还原成 %s", filepath.Base(path), filepath.Base(jsonlPath))
+	lPrintf("%s，写成 %s", summary, filepath.Base(jsonlPath))
+	logAssBadLines(path, bad)
 	return src, nil
 }

+// .ass 里有行没能解析出来时提醒一次（只在真正落盘那次调，避免重复）
+func logAssBadLines(path string, bad int) {
+	if bad > 0 {
+		lPrintWarnf("%s 里有 %d 行弹幕没能解析出来，已跳过", filepath.Base(path), bad)
+	}
+}
+
+// .ass 还原结果退到系统临时目录时，用完就删。只删标记过的临时文件：
+// 正常情况 jsonlPath 是用户录播目录里的同名 jsonl，删了就是丢数据
+func dropTempDanmu(src danmuSource) {
+	if src.tempJsonl {
+		_ = os.Remove(src.jsonlPath)
+	}
+}
+
 // 输出文件名只能是文件名本身，且固定为 mp4
 func sanitizeOutName(name string) (string, error) {
 	name = strings.TrimSpace(name)
@@ -331,9 +399,44 @@ func freeOutPath(dir, base string) string {
 	return cand
 }

+// 把一次请求拆成若干个合并任务并逐个检查。全部检查通过才返回：
+// 排到第 3 个才发现文件不对、前两个已经合完了，这种情况很难跟用户解释
+func buildMergePlans(req mergeRequest) ([]mergePlan, error) {
+	if len(req.Jobs) == 0 {
+		plan, err := buildMergePlan(req)
+		if err != nil {
+			return nil, err
+		}
+		return []mergePlan{plan}, nil
+	}
+	if len(req.Jobs) > maxMergeJobs {
+		return nil, fmt.Errorf("一次最多排 %d 个合并任务，这次有 %d 个", maxMergeJobs, len(req.Jobs))
+	}
+	plans := make([]mergePlan, 0, len(req.Jobs))
+	for i, job := range req.Jobs {
+		plan, err := buildMergePlan(mergeRequest{
+			Videos:  job.Videos,
+			Danmu:   job.Danmu,
+			Offset:  job.Offset,
+			OutName: job.OutName,
+			Options: job.Options,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("第 %d 个任务：%v", i+1, err)
+		}
+		plans = append(plans, plan)
+	}
+	return plans, nil
+}
+
 // 解析请求、检查文件并算出合并参数
 func buildMergePlan(req mergeRequest) (mergePlan, error) {
 	var plan mergePlan
+	ffmpegFile := getFFmpeg()
+	plan.opts = req.Options
+	if msg := req.Options.validate(ffmpegFile); msg != "" {
+		return plan, errors.New(msg)
+	}

 	// 视频：一行一个，允许夹带空行
 	var values []string
@@ -403,7 +506,6 @@ func buildMergePlan(req mergeRequest) (mergePlan, error) {
 		DanmuHasAvatar: src.hasAvatar,
 		Source:         src.source,
 	}
-	ffmpegFile := getFFmpeg()
 	for _, f := range plan.videos {
 		fi, err := os.Stat(f)
 		if err != nil {
@@ -448,7 +550,9 @@ func buildMergePlan(req mergeRequest) (mergePlan, error) {
 	if info.Duration > 0 && src.last+info.Offset >= info.Duration {
 		info.Warnings = append(info.Warnings, fmt.Sprintf(
 			"最后一条弹幕在 %.1f 秒，加上偏移后已超出视频总长 %.1f 秒，超出的弹幕会被丢掉；"+
-				"如果这个视频只是整场的一段，请把同场的其它分段一起加进来",
+				"如果这个视频只是整场的一段，请把同场的其它分段一起加进来；"+
+				"如果弹幕整体都落在时长之外，通常是这个弹幕文件的时间基准和视频不一致"+
+				"（合成时会按第一条弹幕自动对齐，日志里有平移量），也可以自己填「偏移」",
 			src.last+info.Offset, info.Duration))
 	}
 	if info.Duration == 0 {
@@ -459,8 +563,9 @@ func buildMergePlan(req mergeRequest) (mergePlan, error) {
 	return plan, nil
 }

-// 真正执行合并，进度既打到运行日志里，也同步给 web UI 的任务卡片
-func runManualMerge(plan mergePlan) error {
+// 真正执行合并，进度既打到运行日志里，也同步给 web UI 的任务卡片。
+// idx / total 是批量队列里的位置（单任务传 1, 1），只用来在日志和界面上标「第几个」
+func runManualMerge(plan mergePlan, idx, total int) error {
 	ffmpegFile := getFFmpeg()
 	if ffmpegFile == "" {
 		return errors.New("找不到 ffmpeg，请先在设置里填写 ffmpeg 路径")
@@ -471,12 +576,19 @@ func runManualMerge(plan mergePlan) error {
 	for _, v := range plan.info.Videos {
 		inputBytes += v.Size
 	}
-	jobStart("手动合并", plan.info.OutName, inputBytes, plan.info.Duration)
+	if !jobStart(jobKindManualMerge, plan.info.OutName, inputBytes, plan.info.Duration) {
+		return errJobNotStarted
+	}
+	if idx > 0 && total > 0 {
+		jobQueue(idx, total)
+	}

 	src, err := prepareDanmuSource(plan.danmu, true)
 	if err != nil {
 		return err
 	}
+	// 还原结果写不进原目录时用的是系统临时目录里的文件，合并完就删掉
+	defer dropTempDanmu(src)

 	// 每一段的录制开始时刻取自文件名，用来算偏移和拼接后的时间轴
 	segs := make([]recordSegment, 0, len(plan.videos))
@@ -503,7 +615,8 @@ func runManualMerge(plan mergePlan) error {
 	}

 	// 复用自动合并那条链路：多段会先拼接并把弹幕时间重映射到拼接后的时间轴
-	video, jsonl, autoOffset, cleanup, err := prepareForMerge(ffmpegFile, segs, src.jsonlPath, danmuStartNs)
+	// （手动合并不删源视频，所以这里用不上「实际参与合并的文件」）
+	video, jsonl, autoOffset, _, cleanup, err := prepareForMerge(ffmpegFile, segs, src.jsonlPath, danmuStartNs)
 	defer cleanup()
 	if err != nil {
 		return err
@@ -526,13 +639,18 @@ func runManualMerge(plan mergePlan) error {
 	// 成片目录可能是网络盘或外接盘，直接往里写、写到一半失败会在那里留个半成品
 	tmpOut := tempMergeOutput(plan.danmu, filepath.Base(plan.out))

-	lPrintf("手动合并开始：视频 %s，弹幕 %s，偏移 %.3f 秒（%s）",
-		filepath.Base(video), filepath.Base(jsonl), offset, note)
+	// 批量合并时在日志里标出这是第几个，翻日志的时候对得上号
+	tag := ""
+	if total > 1 {
+		tag = fmt.Sprintf("（第 %d/%d 个）", idx, total)
+	}
+	lPrintf("手动合并开始%s：视频 %s，弹幕 %s，偏移 %.3f 秒（%s）",
+		tag, filepath.Base(video), filepath.Base(jsonl), offset, note)
 	lPrintf("先在本地合成 %s，完成后落到 %s", filepath.Base(tmpOut), plan.out)

 	// 标记成正在写入，避免在文件管理里把还没写完的成片删掉
 	markFileActive(tmpOut, true)
-	burnErr := burnDanmu(jsonl, video, tmpOut, offset)
+	burnErr := burnDanmu(jsonl, video, tmpOut, offset, plan.opts)
 	markFileActive(tmpOut, false)
 	if burnErr != nil {
 		_ = os.Remove(tmpOut)
@@ -544,7 +662,7 @@ func runManualMerge(plan mergePlan) error {
 		return err
 	}

-	lPrintln("手动合并完成：" + plan.out)
+	lPrintln("手动合并完成" + tag + "：" + plan.out)
 	// 通知：手动合并没有 uid，能从文件名对上哪个主播就带上名字，对不上就用通用文案
 	uid := guessUIDByFileName(plan.out)
 	if uid == 0 {
@@ -554,24 +672,38 @@ func runManualMerge(plan mergePlan) error {
 	if uid > 0 {
 		text = longID(uid) + " 的录播和弹幕（手动合并）完成\n" + plan.out
 	}
+	if total > 1 {
+		text += fmt.Sprintf("\n（第 %d/%d 个）", idx, total)
+	}
 	sendNotify(notifyEventMergeDone, uid, nameForLog(uid), "", "", plan.out, text)
 	return nil
 }

-// 检查合并参数，回显时长、弹幕条数和推测的偏移，不做实际合成
+// 检查合并参数，回显时长、弹幕条数和推测的偏移，不做实际合成。
+// 请求里带 jobs 时一次检查多个任务，返回 {jobs:[...]}；单个任务仍直接返回 info
 func mergeInfoHandler(w http.ResponseWriter, r *http.Request) {
 	var req mergeRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "请求不是合法的 json："+err.Error(), http.StatusBadRequest)
 		return
 	}
-	plan, err := buildMergePlan(req)
+	plans, err := buildMergePlans(req)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
-	if err := json.NewEncoder(w).Encode(plan.info); err != nil {
+	if len(req.Jobs) == 0 {
+		if err := json.NewEncoder(w).Encode(plans[0].info); err != nil {
+			lPrintErrf("输出合并检查结果失败：%v", err)
+		}
+		return
+	}
+	infos := make([]mergeInfo, 0, len(plans))
+	for _, p := range plans {
+		infos = append(infos, p.info)
+	}
+	if err := json.NewEncoder(w).Encode(map[string]any{"jobs": infos}); err != nil {
 		lPrintErrf("输出合并检查结果失败：%v", err)
 	}
 }
@@ -583,7 +715,7 @@ func mergeHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "请求不是合法的 json："+err.Error(), http.StatusBadRequest)
 		return
 	}
-	plan, err := buildMergePlan(req)
+	plans, err := buildMergePlans(req)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -596,44 +728,92 @@ func mergeHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "已经有一个手动合并在进行（"+busyOut+"），等它结束再说", http.StatusConflict)
 		return
 	}
+	// 任务卡片只有一份：自动合并也可能占着它，那时手动的也得等
+	if !tryTakeMergeSlot() {
+		mergeRun.Unlock()
+		busy := jobBusyName()
+		if busy == "" {
+			busy = "另一个合并任务"
+		}
+		http.Error(w, "已经有一个合并在进行（"+busy+"），等它结束再说", http.StatusConflict)
+		return
+	}
 	mergeRun.busy = true
-	mergeRun.outName = plan.info.OutName
+	mergeRun.outName = plans[0].info.OutName
 	mergeRun.lastErr = ""
+	mergeRun.total = len(plans)
+	mergeRun.done = 0
+	mergeRun.results = nil
 	mergeRun.Unlock()

+	total := len(plans)
 	safeGo("手动合并", func() {
+		defer releaseMergeSlot()
 		defer func() {
 			mergeRun.Lock()
 			mergeRun.busy = false
 			mergeRun.doneAt = time.Now().Unix()
 			mergeRun.Unlock()
 		}()
-		err := runManualMerge(plan)
-		// 任务卡片挂在这条链路上，无论成败都要收尾，否则进度会一直留在界面上
-		jobFinish(jobErrText(err))
-		if err == nil {
-			return
-		}
-		msg := err.Error()
-		switch err {
-		case errNoDanmu:
-			msg = "弹幕文件里没有弹幕"
-			lPrintWarn("弹幕文件里没有弹幕，取消手动合并")
-		case errJobStopped:
-			// 手动停止不是失败，别让界面弹「合并失败」
-			lPrintWarn("手动合并已被手动停止")
+		stopped := false
+		for i, plan := range plans {
 			mergeRun.Lock()
-			mergeRun.lastErr = ""
+			mergeRun.outName = plan.info.OutName
+			mergeRun.done = i
 			mergeRun.Unlock()
-			return
-		default:
-			lPrintErrf("手动合并失败：%v", err)
+
+			err := runManualMerge(plan, i+1, total)
+			// 任务卡片挂在这条链路上，无论成败都要收尾，否则进度会一直留在界面上。
+			// 只有真的起了任务才收尾：没起成说明占着卡片的是别的任务，别把人家的进度清掉
+			if err != errJobNotStarted {
+				jobFinish(jobErrText(err))
+			}
+			if err == nil {
+				mergeRun.Lock()
+				mergeRun.results = append(mergeRun.results, mergeJobResult{OutName: plan.info.OutName})
+				mergeRun.Unlock()
+				continue
+			}
+			msg := err.Error()
+			switch err {
+			case errNoDanmu:
+				msg = "弹幕文件里没有弹幕"
+				lPrintWarn("弹幕文件里没有弹幕，跳过这个任务")
+			case errJobStopped:
+				// 手动停止不是失败，别让界面弹「合并失败」；排在后面的任务也不再接着做
+				lPrintWarn("手动合并已被手动停止，剩下的任务不再继续")
+				stopped = true
+			default:
+				lPrintErrf("手动合并失败：%v", err)
+				notifyMergeFailure(guessUIDByFileName(plan.out), plan.out, err)
+			}
+			mergeRun.Lock()
+			mergeRun.results = append(mergeRun.results, mergeJobResult{OutName: plan.info.OutName, Err: msg})
+			mergeRun.lastErr = msg
+			mergeRun.Unlock()
+			if stopped {
+				break
+			}
 		}
 		mergeRun.Lock()
-		mergeRun.lastErr = msg
+		mergeRun.done = len(mergeRun.results)
 		mergeRun.Unlock()
+		if total > 1 {
+			ok, failed := 0, 0
+			mergeRun.Lock()
+			for _, r := range mergeRun.results {
+				if r.ok() {
+					ok++
+				} else {
+					failed++
+				}
+			}
+			mergeRun.Unlock()
+			lPrintf("手动合并队列结束：共 %d 个，成功 %d 个，失败 %d 个", total, ok, failed)
+		}
 	})

 	w.Header().Set("Content-Type", "application/json")
-	_, _ = w.Write([]byte(`{"outName":` + strconv.Quote(plan.info.OutName) + `}`))
+	_, _ = w.Write([]byte(`{"count":` + strconv.Itoa(total) +
+		`,"outName":` + strconv.Quote(plans[0].info.OutName) + `}`))
 }
@@ -63,6 +63,16 @@ Dialogue: 0,0:00:03.50,0:00:13.50,Danmu,丙(303),20,20,2,,{\move(400,24,-40,24)}

 // 测试用的 ffmpeg，找不到就跳过
 // 依次找 PATH 和源码目录（以及上一级目录）里的 ffmpeg，不写死某台机器上的路径
+// 按真实链路跑一次手动合并：独占任务位，跑完一定要收尾。
+// 不能直接调 runManualMerge —— 上一个用例如果没收尾，jobStart 会拒掉这一场
+// （正是它的职责），测试就会莫名其妙失败
+func execManualMerge(plan mergePlan) error {
+	jobFinish("")
+	err := runMergeExclusive(func() error { return runManualMerge(plan, 1, 1) })
+	jobFinish(jobErrText(err))
+	return err
+}
+
 func testFFmpeg(t *testing.T) string {
 	t.Helper()
 	cands := []string{"ffmpeg"}
@@ -153,7 +163,7 @@ func TestParseAssFilePlain(t *testing.T) {
 	dir := setupMergeTest(t)
 	path := writeTestFile(t, filepath.Join(dir, "2026-09-25 01-00-00 测试主播 标题.ass"), plainAssFixture)

-	meta, records, err := parseAssFile(path)
+	meta, records, _, err := parseAssFile(path)
 	if err != nil {
 		t.Fatalf("解析失败：%v", err)
 	}
@@ -193,7 +203,7 @@ func TestParseAssFileNick(t *testing.T) {
 	dir := setupMergeTest(t)
 	path := writeTestFile(t, filepath.Join(dir, "2026-09-25 01-00-00 测试主播 标题.nick.ass"), nickAssFixture)

-	meta, records, err := parseAssFile(path)
+	meta, records, _, err := parseAssFile(path)
 	if err != nil {
 		t.Fatalf("解析失败：%v", err)
 	}
@@ -228,7 +238,7 @@ func TestParseAssFileWithoutFormatLine(t *testing.T) {
 	dir := setupMergeTest(t)
 	path := writeTestFile(t, filepath.Join(dir, "noformat.ass"), noFormatAssFixture)

-	meta, records, err := parseAssFile(path)
+	meta, records, _, err := parseAssFile(path)
 	if err != nil {
 		t.Fatalf("解析失败：%v", err)
 	}
@@ -257,7 +267,7 @@ func TestParseAssFileRejectsBadFile(t *testing.T) {
 	}
 	for name, content := range cases {
 		path := writeTestFile(t, filepath.Join(dir, name), content)
-		if _, _, err := parseAssFile(path); err == nil {
+		if _, _, _, err := parseAssFile(path); err == nil {
 			t.Fatalf("%s 应该报错", name)
 		}
 	}
@@ -641,7 +651,7 @@ Dialogue: 0,0:00:05.00,0:00:15.00,Danmu,甲(101),20,20,2,,{\move(400,72,-40,72)}
 	}

 	// 真正合并
-	if err := runManualMerge(plan); err != nil {
+	if err := execManualMerge(plan); err != nil {
 		t.Fatalf("手动合并失败：%v", err)
 	}
 	if _, err := os.Stat(plan.out); err != nil {
@@ -708,7 +718,7 @@ Dialogue: 0,0:00:05.00,0:00:15.00,Danmu,乙(202),0,0,0,,{\move(400,48,-40,48)}
 	if filepath.Base(plan.videos[0]) != filepath.Base(v1) {
 		t.Fatalf("分段顺序应纠正为第一段在前，实际 %q", filepath.Base(plan.videos[0]))
 	}
-	if err := runManualMerge(plan); err != nil {
+	if err := execManualMerge(plan); err != nil {
 		t.Fatalf("多段手动合并失败：%v", err)
 	}
 	d := probeDuration(ffmpeg, plan.out)
@@ -834,3 +844,127 @@ func TestFindDanmuForVideo(t *testing.T) {
 		}
 	})
 }
+
+// ==================== 一次排多个合并任务 ====================
+
+// 造一组能过检查的「视频 + 弹幕」：视频随便写点字节，弹幕用真能解析的 jsonl
+// 文件要落在录播目录里，因为请求里只带文件名，resolveMergeInput 按录播目录找
+func writeMergePair(t *testing.T, name string) (string, string) {
+	t.Helper()
+	video := filepath.Join(recordSaveDir(), name+".mp4")
+	writeTestFile(t, video, "video")
+	jsonl := filepath.Join(recordSaveDir(), name+".jsonl")
+	writeTestFile(t, jsonl,
+		"{\"playResX\":1920,\"playResY\":1080,\"fontSize\":48,\"startTime\":0}\n"+
+			"{\"uid\":101,\"content\":\"第一条\",\"time\":1,\"lane\":0}\n")
+	return filepath.Base(video), filepath.Base(jsonl)
+}
+
+// 批量请求要能拆成多个方案，且每个方案各自带上自己的参数
+func TestBuildMergePlansBatch(t *testing.T) {
+	setupMergeTest(t)
+	v1, d1 := writeMergePair(t, "2026-09-25 01-00-00 甲 第一场")
+	v2, d2 := writeMergePair(t, "2026-09-25 02-00-00 乙 第二场")
+
+	br1, fps2 := 1500, 60
+	plans, err := buildMergePlans(mergeRequest{Jobs: []mergeJobReq{
+		{Videos: []string{v1}, Danmu: d1, Options: mergeOptions{Bitrate: &br1}},
+		{Videos: []string{v2}, Danmu: d2, Options: mergeOptions{Fps: &fps2}},
+	}})
+	if err != nil {
+		t.Fatalf("批量检查失败：%v", err)
+	}
+	if len(plans) != 2 {
+		t.Fatalf("应拆成 2 个方案，实际 %d", len(plans))
+	}
+	if plans[0].opts.bitrate() != 1500 {
+		t.Errorf("第一个任务的码率没带上：%d", plans[0].opts.bitrate())
+	}
+	if plans[1].opts.bitrate() != config.MergeBitrate {
+		t.Errorf("第二个任务没填码率就该用全局设置，实际 %d", plans[1].opts.bitrate())
+	}
+	if plans[1].opts.fps() != 60 {
+		t.Errorf("第二个任务的帧率没带上：%d", plans[1].opts.fps())
+	}
+	// 输出名各自独立
+	if plans[0].info.OutName == plans[1].info.OutName {
+		t.Errorf("两个任务的输出名撞了：%s", plans[0].info.OutName)
+	}
+
+	// 单个任务（老写法）仍然只出一个方案
+	one, err := buildMergePlans(mergeRequest{Videos: []string{v1}, Danmu: d1})
+	if err != nil || len(one) != 1 {
+		t.Fatalf("单个任务应只出 1 个方案，实际 %d（err=%v）", len(one), err)
+	}
+}
+
+// 排在后面的任务有问题时要连序号一起报出来，并且一个都不该开始
+func TestBuildMergePlansReportsBadIndex(t *testing.T) {
+	setupMergeTest(t)
+	v1, d1 := writeMergePair(t, "2026-09-25 01-00-00 甲 第一场")
+
+	_, err := buildMergePlans(mergeRequest{Jobs: []mergeJobReq{
+		{Videos: []string{v1}, Danmu: d1},
+		{Videos: []string{v1}, Danmu: "不存在的弹幕.jsonl"},
+	}})
+	if err == nil {
+		t.Fatal("第二个任务的文件不存在，应当报错")
+	}
+	if !strings.Contains(err.Error(), "第 2 个任务") {
+		t.Errorf("报错里该带上序号，实际：%v", err)
+	}
+}
+
+// 一次排太多要挡住，别让人不小心把几十场全排上
+func TestBuildMergePlansCapsCount(t *testing.T) {
+	setupMergeTest(t)
+	v1, d1 := writeMergePair(t, "2026-09-25 01-00-00 甲 第一场")
+	jobs := make([]mergeJobReq, 0, maxMergeJobs+1)
+	for i := 0; i < maxMergeJobs+1; i++ {
+		jobs = append(jobs, mergeJobReq{Videos: []string{v1}, Danmu: d1})
+	}
+	if _, err := buildMergePlans(mergeRequest{Jobs: jobs}); err == nil {
+		t.Errorf("超过 %d 个任务应当被挡住", maxMergeJobs)
+	}
+}
+
+// 逐任务参数的兜底和校验
+func TestMergeOptionsFallbackAndValidate(t *testing.T) {
+	ff := testFFmpeg(t)
+	config.MergeBitrate, config.MergeFps, config.DanmuFontSize = 2000, 30, 42
+	defer func() { config.MergeBitrate, config.MergeFps, config.DanmuFontSize = 0, 0, 0 }()
+
+	var empty mergeOptions
+	if empty.bitrate() != 2000 || empty.fps() != 30 || empty.fontSize() != 42 {
+		t.Errorf("没填的项应回落到全局设置，实际 %d / %d / %d",
+			empty.bitrate(), empty.fps(), empty.fontSize())
+	}
+	// 填 0 是有明确含义的，不能被当成「没填」
+	zero := 0
+	if (mergeOptions{Bitrate: &zero}).bitrate() != 0 {
+		t.Error("填了 0 就应当是 0（自动码率），不是全局设置的值")
+	}
+	if msg := (mergeOptions{Fps: &zero}).validate(ff); msg != "" {
+		t.Errorf("帧率 0（跟随源片）不该被挡：%s", msg)
+	}
+	if msg := (mergeOptions{Encoder: "auto"}).validate(ff); msg != "" {
+		t.Errorf("auto 表示自动挑，不该被挡：%s", msg)
+	}
+	bad := -1
+	if msg := (mergeOptions{Bitrate: &bad}).validate(ff); msg == "" {
+		t.Error("负的码率应当被挡住")
+	}
+	over := maxMergeFps + 1
+	if msg := (mergeOptions{Fps: &over}).validate(ff); msg == "" {
+		t.Error("超出上限的帧率应当被挡住")
+	}
+	if msg := (mergeOptions{Encoder: "av1_nvenc"}).validate(ff); msg == "" {
+		t.Error("本机没有的编码器应当被挡住")
+	}
+	// 本机可用的编码器要放行
+	for _, e := range availableEncoders(ff) {
+		if msg := (mergeOptions{Encoder: e}).validate(ff); msg != "" {
+			t.Errorf("本机可用的 %s 不该被挡：%s", e, msg)
+		}
+	}
+}
@@ -261,6 +261,8 @@ func notifyEventTitle(event string) string {
 		return "开始录制"
 	case notifyEventMergeDone:
 		return "合并完成"
+	case notifyEventMergeFail:
+		return "合并失败"
 	}
 	return "AcFun 直播录制"
 }
@@ -0,0 +1,123 @@
+package main
+
+import (
+	"math"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// avatarXExpr 产出的表达式就长这样：A-(A+T)*(t<±S>)/D
+var avatarXExprRE = regexp.MustCompile(`^(\d+)-\((\d+)\+(\d+)\)\*\(t([+-]\d+\.\d+)\)/(\d+)$`)
+
+// 按块内时间 t 求 avatarXExpr 的值。只认它自己产出的这一种形式；
+// 表达式一改，这里的正则就会失配，用例会明确报出来
+func evalAvatarXExpr(t *testing.T, expr string, tInChunk float64) float64 {
+	t.Helper()
+	m := avatarXExprRE.FindStringSubmatch(expr)
+	if m == nil {
+		t.Fatalf("头像 x 表达式的形式变了，这个用例要跟着改：%s", expr)
+	}
+	playResX, _ := strconv.Atoi(m[1])
+	base, _ := strconv.Atoi(m[2])
+	total, _ := strconv.Atoi(m[3])
+	shift, _ := strconv.ParseFloat(m[4], 64)
+	den, _ := strconv.ParseFloat(m[5], 64)
+	if base != playResX {
+		t.Fatalf("表达式里两个底数不一致：%s", expr)
+	}
+	if den != danmuShowSeconds {
+		t.Fatalf("表达式的分母 %g 和弹幕停留时长 %g 对不上：%s", den, danmuShowSeconds, expr)
+	}
+	// %+.3f 打出来的是带符号的偏移量，所以这里是 t + shift
+	return float64(playResX) - float64(playResX+total)*(tInChunk+shift)/den
+}
+
+// 文字层（libass 的 \move）和头像层（overlay 的 x 表达式）必须是同一条运动轨迹。
+// 两边一旦各算各的，被块边界截断的弹幕就会出现「文字已经走到左边、头像还在半路上」——
+// 线上看到的就是「头像在中途偏离弹幕轨迹」
+func TestAvatarAndTextShareSameMotion(t *testing.T) {
+	const playResX, avPad, total = 1920, 40, 600
+	for _, t0 := range []float64{0, 0.5, 123.456} {
+		// 块起点取三种典型位置：就是弹幕起播那一刻、在它之前 3 秒（被截断的续画）、
+		// 以及一个很大的时间轴位置（验证大数下公式也不跑偏）
+		for _, chunkStart := range []float64{t0, t0 - 3, t0 + 2000} {
+			expr := avatarXExpr(playResX, total, chunkStart-t0)
+			for _, tAbs := range []float64{t0, t0 + 0.01, t0 + 1.5, t0 + 9.999, t0 + danmuShowSeconds} {
+				wantText := danmuTextX(playResX, avPad, total, tAbs, t0)
+				gotAv := evalAvatarXExpr(t, expr, tAbs-chunkStart)
+				if math.Abs(gotAv-(wantText-float64(avPad))) > 0.5 {
+					t.Fatalf("t0=%.3f 块起点=%.3f t=%.3f 时文字左边缘 %.2f、头像 %.2f，"+
+						"两者应当相差一个头像宽度 %d", t0, chunkStart, tAbs, wantText, gotAv, avPad)
+				}
+			}
+		}
+	}
+
+	// 出发点和终点也要对：起播瞬间文字左边缘刚好在画面右侧外一个「头像+间隔」处
+	// （对应的头像左边缘正好贴着画面右边界），停留结束时整条刚好完全离开左边界 ——
+	// 起点是 playResX 出头的那点偏移，终点是 -total，行程正好 playResX+total
+	if got := danmuTextX(playResX, avPad, total, 0, 0); got != float64(playResX+avPad) {
+		t.Errorf("起播瞬间文字左边缘应当是 %d，实际 %.2f", playResX+avPad, got)
+	}
+	if got := danmuAvatarX(playResX, avPad, total, 0, 0); got != float64(playResX) {
+		t.Errorf("起播瞬间头像左边缘应当贴着画面右边界 %d，实际 %.2f", playResX, got)
+	}
+	if got := danmuTextX(playResX, avPad, total, danmuShowSeconds, 0); got != float64(avPad-total) {
+		t.Errorf("停留结束时文字左边缘应当是 %d，实际 %.2f", avPad-total, got)
+	}
+	if got := danmuAvatarX(playResX, avPad, total, danmuShowSeconds, 0); got != float64(-total) {
+		t.Errorf("停留结束时头像左边缘（整条的左端）应当是 %d，实际 %.2f", -total, got)
+	}
+}
+
+// 写进 ASS 的 \move 起止点必须按**绝对时间**算，而不是「截断之后的这一小段」：
+// 拿截断后的时长当整段行程（旧实现：终点写死 -Width）等于把 10 秒的路挤进零点几秒，
+// 文字会飞过去；分块渲染里 66.4% 的弹幕都被截断过，所以这个错法影响面极大
+func TestWriteChunkAssKeepsAbsoluteTrajectory(t *testing.T) {
+	dir := t.TempDir()
+	meta := danmuMeta{PlayResX: 1920, PlayResY: 1080, FontSize: 42}
+	avW, avGap := avatarSize(meta.FontSize), avatarGap(meta.FontSize)
+	total := avW + avGap + 480
+
+	// 块从 100 秒开始，弹幕起播在 96 秒 —— 块头把它切掉了，只剩最后 6 秒可见
+	chunk := danmuChunk{start: 100, end: 130, records: []danmuRecord{
+		{Time: 96, UID: 7, Name: "甲", Content: "被块头截断的", Lane: 2, Width: 480},
+	}}
+	path := filepath.Join(dir, "chunk.ass")
+	if err := writeChunkAss(path, meta, chunk, 0, avW, avGap); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m := regexp.MustCompile(`\\move\((-?\d+),(-?\d+),(-?\d+),(-?\d+)\)`).FindStringSubmatch(string(data))
+	if m == nil {
+		t.Fatalf("ASS 里找不到 \\move：\n%s", data)
+	}
+	nums := make([]int, 4)
+	for i := range nums {
+		nums[i], _ = strconv.Atoi(m[i+1])
+	}
+
+	t0 := 96.0
+	wantX1 := int(math.Round(danmuTextX(meta.PlayResX, avW+avGap, total, chunk.start, t0)))
+	wantX2 := int(math.Round(danmuTextX(meta.PlayResX, avW+avGap, total, t0+danmuShowSeconds, t0)))
+	if nums[0] != wantX1 || nums[2] != wantX2 {
+		t.Errorf("\\move 起止点应当是 (%d → %d)，实际 (%d → %d)；"+
+			"终点按截断后的时长算会把 10 秒的路挤进 %.1f 秒里，文字直接飞过去",
+			wantX1, wantX2, nums[0], nums[2], chunk.end-t0)
+	}
+	// 终点必须是「走完全程、整条离开左边界」的位置，不是文字宽度本身
+	if nums[2] != avW+avGap-total {
+		t.Errorf("停留结束时的终点应当是 %d（= avPad - total），实际 %d", avW+avGap-total, nums[2])
+	}
+	if strings.Contains(string(data), "{") && !strings.Contains(string(data), `\an7`) {
+		t.Error("对话行丢了 \\an7 定位锚点")
+	}
+}
@@ -18,11 +18,12 @@ const (
 	notifyEventLiveOff     = "liveOff"
 	notifyEventRecordStart = "recordStart"
 	notifyEventMergeDone   = "mergeDone"
+	notifyEventMergeFail   = "mergeFail"
 )

 // 推送到 webhook 的请求体
 type notifyPayload struct {
-	Event string `json:"event"` // 事件名：liveOn、liveOff、recordStart、mergeDone
+	Event string `json:"event"` // 事件名：liveOn、liveOff、recordStart、mergeDone、mergeFail
 	UID   int    `json:"uid"`   // 主播 uid
 	Name  string `json:"name"`  // 主播名字
 	Title string `json:"title"` // 直播标题（下播和合并完成时可能为空）
@@ -81,6 +82,7 @@ type notifySetting struct {
 	liveOff     bool
 	recordStart bool
 	mergeDone   bool
+	mergeFail   bool
 }

 func currentNotifySetting() notifySetting {
@@ -100,6 +102,7 @@ func currentNotifySetting() notifySetting {
 		liveOff:     config.NotifyLiveOff,
 		recordStart: config.NotifyRecordStart,
 		mergeDone:   config.NotifyMergeDone,
+		mergeFail:   config.NotifyMergeFail,
 	}
 }

@@ -114,6 +117,8 @@ func (n notifySetting) enabled(event string) bool {
 		return n.recordStart
 	case notifyEventMergeDone:
 		return n.mergeDone
+	case notifyEventMergeFail:
+		return n.mergeFail
 	}
 	return false
 }
@@ -201,6 +206,22 @@ func sendNotify(event string, uid int, name, title, url, file, text string) {
 	}
 }

+// 合并失败时推送。nil、「弹幕文件里没有弹幕」和被手动停止都不算失败，不会推送。
+// fileName 用于正文里标出是哪一场，拿不到就留空
+func notifyMergeFailure(uid int, fileName string, err error) {
+	if err == nil || err == errNoDanmu || err == errJobStopped {
+		return
+	}
+	text := "合并失败"
+	if uid > 0 {
+		text += "（" + longID(uid) + " 的录播和弹幕）"
+	} else if fileName != "" {
+		text += "（" + fileName + "）"
+	}
+	text += "\n原因：" + err.Error()
+	sendNotify(notifyEventMergeFail, uid, nameForLog(uid), "", "", fileName, text)
+}
+
 // 把事件 POST 到 webhook，同时返回 HTTP 状态码（失败时也会带上，方便测试接口显示细节）
 func postNotify(addr, token string, p notifyPayload) (int, error) {
 	data, err := json.Marshal(p)
@@ -2,6 +2,7 @@ package main

 import (
 	"encoding/json"
+	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -438,6 +439,7 @@ func TestNotifyEventTitle(t *testing.T) {
 		notifyEventLiveOff:     "下播提醒",
 		notifyEventRecordStart: "开始录制",
 		notifyEventMergeDone:   "合并完成",
+		notifyEventMergeFail:   "合并失败",
 	} {
 		if got := notifyEventTitle(event); got != want {
 			t.Errorf("notifyEventTitle(%q) = %q，期望 %q", event, got, want)
@@ -445,6 +447,77 @@ func TestNotifyEventTitle(t *testing.T) {
 	}
 }

+// 合并失败要推送，而「正常结束 / 文件里没有弹幕 / 用户自己点的停止」都不许推：
+// 前两种本来就不算失败，第三种推「合并失败」会误导
+func TestNotifyMergeFailureFanOut(t *testing.T) {
+	savedConfig := config
+	resetMeowBadNick()
+	defer func() {
+		config = savedConfig
+		resetMeowBadNick()
+	}()
+
+	var mu sync.Mutex
+	var hooks []notifyPayload
+	webhook := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var p notifyPayload
+		_ = json.NewDecoder(r.Body).Decode(&p)
+		mu.Lock()
+		hooks = append(hooks, p)
+		mu.Unlock()
+		_, _ = w.Write([]byte("ok"))
+	}))
+	defer webhook.Close()
+
+	countHooks := func() int {
+		mu.Lock()
+		defer mu.Unlock()
+		return len(hooks)
+	}
+	waitHooks := func(want int) {
+		t.Helper()
+		deadline := time.Now().Add(5 * time.Second)
+		for time.Now().Before(deadline) && countHooks() < want {
+			time.Sleep(20 * time.Millisecond)
+		}
+	}
+
+	config.NotifyEnabled = true
+	config.NotifyURL = webhook.URL
+	config.NotifyMergeFail = true
+	config.NotifyMergeDone = false
+
+	notifyMergeFailure(280178, "2026-09-25 01-00-00 甲_弹幕合并.mp4", errors.New("磁盘写满了"))
+	waitHooks(1)
+	mu.Lock()
+	got := append([]notifyPayload{}, hooks...)
+	mu.Unlock()
+	if len(got) != 1 {
+		t.Fatalf("合并失败应当推送一条，实际 %d 条", len(got))
+	}
+	if got[0].Event != notifyEventMergeFail {
+		t.Errorf("事件名应当是 %s，实际 %s", notifyEventMergeFail, got[0].Event)
+	}
+	if !strings.Contains(got[0].Text, "磁盘写满了") {
+		t.Errorf("正文里应当带上失败原因，实际：%s", got[0].Text)
+	}
+
+	notifyMergeFailure(280178, "x.mp4", nil)
+	notifyMergeFailure(280178, "x.mp4", errNoDanmu)
+	notifyMergeFailure(280178, "x.mp4", errJobStopped)
+	time.Sleep(300 * time.Millisecond)
+	if n := countHooks(); n != 1 {
+		t.Errorf("正常结束 / 没有弹幕 / 手动停止都不该推送，实际共 %d 条", n)
+	}
+
+	config.NotifyMergeFail = false
+	notifyMergeFailure(280178, "x.mp4", errors.New("又失败了"))
+	time.Sleep(300 * time.Millisecond)
+	if n := countHooks(); n != 1 {
+		t.Errorf("没勾「合并失败」时不该推送，实际共 %d 条", n)
+	}
+}
+
 // 两个渠道的启用条件必须互相独立，并且都受各自开关控制
 func TestNotifySettingChannelReady(t *testing.T) {
 	cases := []struct {
@@ -654,7 +727,7 @@ func TestManualMergeSendsMergeDoneNotify(t *testing.T) {
 	if err != nil {
 		t.Fatalf("检查失败：%v", err)
 	}
-	if err := runManualMerge(plan); err != nil {
+	if err := runManualMerge(plan, 1, 1); err != nil {
 		t.Fatalf("手动合并失败：%v", err)
 	}

@@ -104,10 +104,27 @@ func TestCleanTempFiles(t *testing.T) {
 		writeTestFile(t, filepath.Join(recordSaveDir(), "2026-09-25 01-00-00 甲.mp4"), "视频"),
 		writeTestFile(t, filepath.Join(mergeSaveDir(), "2026-09-25 01-00-00 甲_弹幕合并.mp4"), "成片"),
 	}
+	// 预缩放头像是个目录，也要一起清掉；别顺手把普通的录播子目录当成临时文件夹删了
+	avatarDir := filepath.Join(recordSaveDir(), chunkAvatarDir)
+	if err := os.MkdirAll(avatarDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	writeTestFile(t, filepath.Join(avatarDir, "1.png"), "头像")
+	normalDir := filepath.Join(recordSaveDir(), "别的文件夹")
+	if err := os.MkdirAll(normalDir, 0755); err != nil {
+		t.Fatal(err)
+	}

 	cleanTempFiles(recordSaveDir())
 	cleanTempFiles(mergeSaveDir())

+	if _, err := os.Stat(avatarDir); !os.IsNotExist(err) {
+		t.Errorf("残留的预缩放头像文件夹应该被整个清掉：%s", chunkAvatarDir)
+	}
+	if _, err := os.Stat(normalDir); err != nil {
+		t.Errorf("名字不带临时前缀的目录不该被删：%s", filepath.Base(normalDir))
+	}
+
 	for _, p := range append(append([]string{}, staleRecord...), staleMerge) {
 		if _, err := os.Stat(p); !os.IsNotExist(err) {
 			t.Errorf("残留的临时文件应该被清掉：%s", filepath.Base(p))
@@ -0,0 +1,208 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/orzogc/acfundanmu"
+)
+
+// 直接摆布全局任务状态：测试里只碰这几个标志位，用完恢复
+func withJobFlags(t *testing.T, active, paused, stopped bool) {
+	t.Helper()
+	job.Lock()
+	prevActive, prevPaused, prevStopped, prevProc := job.active, job.paused, job.stopped, job.proc
+	job.active, job.paused, job.stopped = active, paused, stopped
+	job.Unlock()
+	t.Cleanup(func() {
+		job.Lock()
+		job.active, job.paused, job.stopped, job.proc = prevActive, prevPaused, prevStopped, prevProc
+		job.Unlock()
+	})
+}
+
+// resX + length 为 0（PlayResX 配置异常 + 空内容）时不能整数除零
+func TestScrollMarksFallsBackWhenTotalIsZero(t *testing.T) {
+	emerge, left := scrollMarks(1000, 0, 0, danmuShowDur)
+	if emerge != 1000+danmuShowDur/2 {
+		t.Fatalf("行程为 0 时 emerge 应当退到半个停留时长，实际 %d", emerge-1000)
+	}
+	if left != 1000+danmuShowDur {
+		t.Fatalf("行程为 0 时 left 应当退到一个停留时长，实际 %d", left-1000)
+	}
+}
+
+// 端到端：配置里 PlayResX 为 0 又收到一条空弹幕时，写入器不能 panic
+func TestDanmuWriterSurvivesZeroPlayRes(t *testing.T) {
+	dir := t.TempDir()
+	cfg := acfundanmu.SubConfig{Title: "测试", PlayResX: 0, PlayResY: 0,
+		FontSize: 40, StartTime: 1700000000000000000}
+	w := newDanmuWriter("liveid", "stream", cfg, filepath.Join(dir, "zero.ass"))
+
+	c := &acfundanmu.Comment{Content: ""} // 空内容 → 宽度 0，和 PlayResX=0 一起把分母变成 0
+	c.SendTime = (cfg.StartTime + int64(time.Second)) / 1e6
+	c.UserID = 1
+	c.Nickname = "甲"
+	w.write(c) // 原来这里整数除零 panic，会终止整场录制
+	if err := w.close(); err != nil {
+		t.Fatalf("关文件不该报错：%v", err)
+	}
+	if w.failed() {
+		t.Fatalf("写盘不该出错：%v", w.err)
+	}
+
+	// 这条弹幕仍要正常出现在 jsonl 里
+	b, err := os.ReadFile(filepath.Join(dir, "zero.jsonl"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lines := strings.Split(strings.TrimSpace(string(b)), "\n"); len(lines) != 2 {
+		t.Fatalf("应当写出 1 条弹幕记录（加首行元数据共 2 行），实际 %d 行", len(lines))
+	}
+}
+
+// 任务已请求停止时，jobAttach 要就地结束刚启动的进程，
+// 否则用户点了停止还得等整个块渲完
+func TestJobAttachKillsProcessWhenStopped(t *testing.T) {
+	var cmd *exec.Cmd
+	if runtime.GOOS == "windows" {
+		cmd = exec.Command("cmd", "/c", "ping", "-n", "30", "127.0.0.1")
+	} else {
+		cmd = exec.Command("sleep", "30")
+	}
+	if err := cmd.Start(); err != nil {
+		t.Skipf("起不了测试子进程，跳过：%v", err)
+	}
+	defer func() { _ = cmd.Process.Kill() }()
+
+	withJobFlags(t, true, false, true) // 任务已经处于「已请求停止」
+	jobAttach(cmd)
+	defer jobDetach(cmd)
+
+	done := make(chan error, 1)
+	go func() { done <- cmd.Wait() }()
+	select {
+	case <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatal("任务已请求停止时，jobAttach 应当就地结束刚启动的进程，不能等它自己跑完")
+	}
+}
+
+// 挂起失败（进程已经不在）时不能留着「已暂停」的状态
+func TestJobPauseRollsBackStateWhenSuspendFails(t *testing.T) {
+	withJobFlags(t, true, false, false)
+	fake := &exec.Cmd{Process: &os.Process{Pid: 999999}} // 不存在的进程号，挂起必然失败
+	jobAttach(fake)
+	defer jobDetach(fake)
+
+	if err := jobPause(); err == nil {
+		t.Fatal("挂起一个不存在的进程应当报错")
+	}
+	job.Lock()
+	paused := job.paused
+	job.Unlock()
+	if paused {
+		t.Fatal("挂起失败后不该留着「已暂停」：界面会显示已暂停，而 ffmpeg 其实还在跑")
+	}
+}
+
+// 只有标记成临时的 jsonl 才能删，正常同名 jsonl 一个字节都不能动
+func TestDropTempDanmuOnlyRemovesTempFile(t *testing.T) {
+	dir := t.TempDir()
+
+	keep := filepath.Join(dir, "keep.jsonl")
+	if err := os.WriteFile(keep, []byte("{}\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	dropTempDanmu(danmuSource{jsonlPath: keep})
+	if _, err := os.Stat(keep); err != nil {
+		t.Fatalf("正常的同名 jsonl 不能被删掉：%v", err)
+	}
+
+	tmp := filepath.Join(dir, "tmp.jsonl")
+	if err := os.WriteFile(tmp, []byte("{}\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	dropTempDanmu(danmuSource{jsonlPath: tmp, tempJsonl: true})
+	if _, err := os.Stat(tmp); err == nil {
+		t.Fatal("标记为临时的还原结果应当在收尾时删掉")
+	}
+}
+
+// 还原结果写不进原目录时退回系统临时目录，并且要打上临时标记
+func TestPrepareDanmuSourceMarksTempFile(t *testing.T) {
+	dir := t.TempDir()
+	assPath := filepath.Join(dir, "bom.ass")
+	if err := os.WriteFile(assPath, []byte(plainAssFixture), 0644); err != nil {
+		t.Fatal(err)
+	}
+	// 同名 jsonl 占成只读：写不进去，只能退到临时目录
+	jsonlPath := filepath.Join(dir, "bom.jsonl")
+	if err := os.WriteFile(jsonlPath, []byte("{}\n"), 0444); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chmod(jsonlPath, 0644) })
+
+	src, err := prepareDanmuSource(assPath, true)
+	if err != nil {
+		t.Skipf("这台机器上没能造出「写不进去」的条件，跳过：%v", err)
+	}
+	if !src.tempJsonl {
+		t.Skip("写进原目录成功了（文件系统不认只读属性），跳过")
+	}
+	if src.jsonlPath == jsonlPath {
+		t.Fatal("退回临时文件时 jsonlPath 不该还指着原路径")
+	}
+	if _, err := os.Stat(src.jsonlPath); err != nil {
+		t.Fatalf("临时文件应当已经写好：%v", err)
+	}
+	dropTempDanmu(src)
+	if _, err := os.Stat(src.jsonlPath); err == nil {
+		t.Fatal("临时文件应当在收尾时被删掉")
+	}
+}
+
+// 带 UTF-8 BOM 的 ASS 也要能整份解析出来
+func TestParseAssFileAcceptsBOM(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "bom.ass")
+	if err := os.WriteFile(p, []byte("\ufeff"+plainAssFixture), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	meta, records, _, err := parseAssFile(p)
+	if err != nil {
+		t.Fatalf("带 BOM 的 ASS 应当能正常解析，实际报错：%v", err)
+	}
+	if meta.PlayResX != 1920 || meta.PlayResY != 1080 {
+		t.Fatalf("分辨率应当解析出来，实际 %dx%d", meta.PlayResX, meta.PlayResY)
+	}
+	if meta.FontSize != 48 {
+		t.Fatalf("字号应当解析出来，实际 %d", meta.FontSize)
+	}
+	if len(records) != 2 {
+		t.Fatalf("应当读到 2 条弹幕（Comment 那行不算），实际 %d", len(records))
+	}
+}
+
+// 停止后下载头像不该把三次重试耗完（原来最坏要等 96 秒才响应停止）
+func TestEnsureAvatarGivesUpAtOnceWhenStopped(t *testing.T) {
+	withJobFlags(t, true, false, true)
+	dir := t.TempDir()
+
+	t0 := time.Now()
+	got := ensureAvatar(424242, "http://127.0.0.1:1/none.png", dir)
+	elapsed := time.Since(t0)
+
+	if got != "" {
+		t.Fatalf("停止状态下不该返回头像路径，实际 %q", got)
+	}
+	if elapsed > 3*time.Second {
+		t.Fatalf("停止后应当立刻放弃这个头像，实际等了 %v", elapsed)
+	}
+}
@@ -1,10 +1,12 @@
 // 转换任务（合并 / 烧录弹幕）的实时进度与暂停、停止控制。
-// 进度只保留一份全局状态：同一时间只允许一个合并任务在跑（mergeRun 已经拦住了）。
+// 进度只保留一份全局状态：同一时间只允许一个合并任务在跑，串行靠下面的 mergeSlot 保证
+// （mergeRun.busy 只拦得住手动合并之间，拦不住自动合并，也拦不住手动与自动互相穿插）。
 package main

 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"math"
 	"net/http"
 	"os/exec"
@@ -12,6 +14,13 @@ import (
 	"time"
 )

+// 任务类型。阶段划分按它来取（见 jobPhasePlanFor）
+const (
+	jobKindManualMerge = "手动合并"
+	jobKindAutoMerge   = "自动合并"
+	jobKindTranscode   = "转码"
+)
+
 // 任务阶段，前端按这个顺序画步骤条
 var jobPhaseNames = []string{"准备", "分段拼接", "获取头像", "画面渲染", "拼接与落盘"}

@@ -28,6 +37,36 @@ const (
 // 其余阶段按经验估：拼接分段与头像下载是分钟级，准备和落盘是秒级。
 var jobPhaseWeights = []float64{0.02, 0.08, 0.10, 0.75, 0.05}

+// 一类任务的阶段划分。转码没有弹幕和头像，步骤比合并少，硬套合并那套步骤条
+// 会冒出两个永远走不到的空阶段
+type jobPhasePlan struct {
+	names   []string
+	weights []float64
+	render  int // 哪个阶段是真正耗时的主阶段，ETA 按它算
+}
+
+// 合并类任务的阶段（默认），转码类任务的阶段
+var (
+	mergePhasePlan = jobPhasePlan{names: jobPhaseNames, weights: jobPhaseWeights, render: jobPhaseRender}
+	// 转码：探测一下参数就开始编，编完落到成片目录
+	transcodePhasePlan = jobPhasePlan{
+		names:   []string{"准备", "转码", "落盘"},
+		weights: []float64{0.03, 0.92, 0.05},
+		render:  1,
+	}
+)
+
+// 转码任务阶段里「转码」这一步的序号
+const jobPhaseTranscode = 1
+
+// 按任务类型取阶段划分，没见过的类型按合并处理
+func jobPhasePlanFor(kind string) jobPhasePlan {
+	if kind == jobKindTranscode {
+		return transcodePhasePlan
+	}
+	return mergePhasePlan
+}
+
 // 渲染进度的采样间隔与折线最多保留的点数（1 秒 1 个，够画两分钟）
 const (
 	jobSampleInterval = time.Second
@@ -37,6 +76,10 @@ const (
 // 任务被手动停止时各层返回这个错误：调用方据此清理临时文件，不再回退其它编码器
 var errJobStopped = errors.New("任务已被手动停止")

+// 起任务时任务位被别人占着：这次没有真的开始，调用方据此跳过 jobFinish，
+// 不然会把正在跑的那个任务的进度卡片清掉
+var errJobNotStarted = errors.New("已经有别的任务在跑，请先等它结束")
+
 // 速度折线上的一个点
 type jobSample struct {
 	T     float64 `json:"t"`     // 任务开始后的秒数
@@ -62,6 +105,8 @@ type jobInfo struct {
 	ChunkTotal   int         `json:"chunkTotal"`
 	AvatarDone   int         `json:"avatarDone"`
 	AvatarTotal  int         `json:"avatarTotal"`
+	QueueDone    int         `json:"queueDone"`   // 批量任务：已经做完第几个（从 1 开始），单任务为 0
+	QueueTotal   int         `json:"queueTotal"`  // 批量任务：一共几个
 	InputBytes   int64       `json:"inputBytes"`  // 源视频总大小
 	EstOutBytes  int64       `json:"estOutBytes"` // 预计成片大小
 	EstSource    string      `json:"estSource"`   // 预计值的来源：bitrate / measured
@@ -77,7 +122,7 @@ type jobInfo struct {

 // 全局唯一的任务状态
 type jobState struct {
-	sync.Mutex
+	sync.RWMutex
 	active   bool
 	kind     string
 	outName  string
@@ -88,6 +133,14 @@ type jobState struct {
 	stopped  bool
 	proc     *exec.Cmd // 当前在跑的 ffmpeg，暂停/停止都作用在它身上

+	// 当前任务的阶段划分，随任务类型在 jobStart 时定下来
+	phases    []string
+	weights   []float64
+	renderIdx int
+	// 批量任务（手动合并队列、转码队列）的进度，单任务时都是 0
+	queueDone  int
+	queueTotal int
+
 	totalSec float64
 	doneSec  float64
 	speed    float64
@@ -115,13 +168,56 @@ type jobState struct {

 var job jobState

-// 开始一个新任务。kind 是任务类型，totalSec 是视频总时长（拿不到填 0）
-func jobStart(kind, outName string, inputBytes int64, totalSec float64) {
+// 合并任务的串行锁。全局 job 状态只有一份，两个任务同时跑的话后启动的会把前一个的
+// 进度和输出名清掉，「停止」也会杀掉别家任务的 ffmpeg，所以必须排队。
+// 手动合并用 TryLock（抢不到立刻告诉用户），自动合并用 Lock（后台任务，排队等就行）。
+var mergeSlot sync.Mutex
+
+// 尝试占用合并任务位，被占着返回 false。给手动合并用：不能让 HTTP 请求干等着
+func tryTakeMergeSlot() bool {
+	return mergeSlot.TryLock()
+}
+
+// 占用合并任务位，被占着就等到前一个跑完。给自动合并用
+func takeMergeSlot() {
+	mergeSlot.Lock()
+}
+
+func releaseMergeSlot() {
+	mergeSlot.Unlock()
+}
+
+// 排队跑完一整个合并任务：先独占任务位，跑完后一定释放，被调用方 panic 也不漏。
+// 内部出错会被翻成 error 而不是让上层去 recover —— 任务卡片只有走到 jobFinish 才会收尾，
+// 漏掉的话进度会永远停在界面上（之前 panic 后卡片一直转就是这么来的）
+func runMergeExclusive(f func() error) (err error) {
+	takeMergeSlot()
+	defer releaseMergeSlot()
+	defer func() {
+		if p := recover(); p != nil {
+			err = fmt.Errorf("合并任务内部出错：%v", p)
+			lPrintErrf("合并任务内部出错，已兜住：%v", p)
+		}
+	}()
+	return f()
+}
+
+// 开始一个新任务。kind 是任务类型，totalSec 是视频总时长（拿不到填 0）。
+// 已经有任务在跑时返回 false 并且什么都不动：调用方应该先拿到 mergeSlot，
+// 这里再做一次判断是为了让误用（忘记排队）只会失败而不会互相覆盖
+func jobStart(kind, outName string, inputBytes int64, totalSec float64) bool {
 	job.Lock()
 	defer job.Unlock()
+	if job.active {
+		return false
+	}
 	job.active = true
 	job.kind = kind
 	job.outName = outName
+	plan := jobPhasePlanFor(kind)
+	job.phases = plan.names
+	job.weights = plan.weights
+	job.renderIdx = plan.render
 	job.phaseIdx = 0
 	job.phasePct = 0
 	job.started = time.Now()
@@ -134,6 +230,7 @@ func jobStart(kind, outName string, inputBytes int64, totalSec float64) {
 	job.fps = 0
 	job.chunkDone, job.chunkTotal = 0, 0
 	job.avatarDone, job.avatarTotal = 0, 0
+	job.queueDone, job.queueTotal = 0, 0
 	job.inputBytes = inputBytes
 	job.planOutBytes = 0
 	job.liveOutBytes = 0
@@ -143,6 +240,24 @@ func jobStart(kind, outName string, inputBytes int64, totalSec float64) {
 	job.errText = ""
 	job.message = ""
 	job.doneAt = 0
+	return true
+}
+
+// 当前是否有任务在跑。给界面提示和「现在能不能接新任务」的判断用
+func jobActive() bool {
+	job.RLock()
+	defer job.RUnlock()
+	return job.active
+}
+
+// 当前任务的名字（没任务时为空），拒绝新任务时用它告诉用户在忙什么
+func jobBusyName() string {
+	job.RLock()
+	defer job.RUnlock()
+	if !job.active {
+		return ""
+	}
+	return job.outName
 }

 // 任务结束。errText 为空表示成功，errJobStopped.Error() 表示被手动停止
@@ -158,7 +273,7 @@ func jobFinish(errText string) {
 	job.doneAt = time.Now().Unix()
 	switch errText {
 	case "":
-		job.phaseIdx = len(jobPhaseNames)
+		job.phaseIdx = len(job.phases)
 		job.phasePct = 1
 		job.message = "已完成"
 	case errJobStopped.Error():
@@ -168,13 +283,6 @@ func jobFinish(errText string) {
 	}
 }

-// 任务是否正在跑
-func jobActive() bool {
-	job.Lock()
-	defer job.Unlock()
-	return job.active
-}
-
 // 是否已经被要求停止
 func jobStopRequested() bool {
 	job.Lock()
@@ -294,6 +402,16 @@ func jobAvatars(done, total int) {
 	}
 }

+// 批量任务（手动合并队列、转码队列）排到第几个。done 从 1 开始，total 是总数
+func jobQueue(done, total int) {
+	job.Lock()
+	defer job.Unlock()
+	if !job.active {
+		return
+	}
+	job.queueDone, job.queueTotal = done, total
+}
+
 // 设置任务总时长（视频秒数），ETA 和渲染百分比都靠它
 func jobSetTotal(sec float64) {
 	job.Lock()
@@ -315,13 +433,22 @@ func jobPlanSize(bytes int64) {
 }

 // 把当前 ffmpeg 进程注册进来，暂停/停止才作用得到。
-// 如果注册时任务已经处于暂停状态，直接把它挂起（在启动前点了暂停的情况）
+// 如果注册时任务已经处于暂停状态，直接把它挂起（在启动前点了暂停的情况）；
+// 如果任务已经被要求停止，就地杀掉 —— jobGate 已经过去了，不补这一刀的话
+// 用户点了停止还得等整个块渲完（大块的渲染可能要几分钟）
 func jobAttach(cmd *exec.Cmd) {
 	job.Lock()
 	job.proc = cmd
-	paused := job.paused
+	paused, stopped := job.paused, job.stopped
 	job.Unlock()
-	if paused && cmd != nil && cmd.Process != nil {
+	if cmd == nil || cmd.Process == nil {
+		return
+	}
+	if stopped {
+		_ = cmd.Process.Kill()
+		return
+	}
+	if paused {
 		_ = suspendProcess(cmd.Process)
 	}
 }
@@ -349,7 +476,16 @@ func jobPause() error {
 	cmd := job.proc
 	job.Unlock()
 	if cmd != nil && cmd.Process != nil {
-		return suspendProcess(cmd.Process)
+		if err := suspendProcess(cmd.Process); err != nil {
+			// 没挂住就别留着「已暂停」：界面会显示暂停了、ffmpeg 其实还在跑，
+			// 用户以为停住了却在烧 CPU。只在进程还是同一个时回滚，免得踩到已经换过的进程
+			job.Lock()
+			if job.proc == cmd {
+				job.paused = false
+			}
+			job.Unlock()
+			return err
+		}
 	}
 	return nil
 }
@@ -369,7 +505,15 @@ func jobResume() error {
 	cmd := job.proc
 	job.Unlock()
 	if cmd != nil && cmd.Process != nil {
-		return resumeProcess(cmd.Process)
+		if err := resumeProcess(cmd.Process); err != nil {
+			// 没恢复成就把状态放回「已暂停」：否则界面显示在跑、ffmpeg 其实还停着
+			job.Lock()
+			if job.proc == cmd {
+				job.paused = true
+			}
+			job.Unlock()
+			return err
+		}
 	}
 	return nil
 }
@@ -403,8 +547,12 @@ func clamp01(v float64) float64 {

 // 总进度：已走完的阶段按权重全算，当前阶段按阶段内比例折算
 func (j *jobState) percentLocked() float64 {
+	weights := j.weights
+	if len(weights) == 0 {
+		weights = jobPhaseWeights
+	}
 	p := 0.0
-	for i, w := range jobPhaseWeights {
+	for i, w := range weights {
 		switch {
 		case i < j.phaseIdx:
 			p += w
@@ -420,7 +568,7 @@ func (j *jobState) etaLocked(now time.Time) float64 {
 	if !j.active {
 		return 0
 	}
-	if j.phaseIdx == jobPhaseRender && j.speed > 0 && j.totalSec > j.doneSec {
+	if j.phaseIdx == j.renderIdx && j.speed > 0 && j.totalSec > j.doneSec {
 		return (j.totalSec - j.doneSec) / j.speed
 	}
 	pct := j.percentLocked()
@@ -440,7 +588,7 @@ func jobSnapshot() jobInfo {
 		Kind:        job.kind,
 		OutName:     job.outName,
 		PhaseIdx:    job.phaseIdx,
-		Phases:      jobPhaseNames,
+		Phases:      job.phases,
 		Paused:      job.paused,
 		Stopping:    job.stopped,
 		Speed:       job.speed,
@@ -451,6 +599,8 @@ func jobSnapshot() jobInfo {
 		ChunkTotal:  job.chunkTotal,
 		AvatarDone:  job.avatarDone,
 		AvatarTotal: job.avatarTotal,
+		QueueDone:   job.queueDone,
+		QueueTotal:  job.queueTotal,
 		InputBytes:  job.inputBytes,
 		OutBytes:    job.outBytes,
 		Message:     job.message,
@@ -3,10 +3,22 @@ package main
 import (
 	"errors"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )

+// 测试用的「开一个新任务」。全局任务只有一份，用例之间必须清干净：
+// 上一个没收尾的话 jobStart 会拒绝覆盖（这是刻意的防串台），断言就会读到别人的数据
+func startJobForTest(t *testing.T, kind, outName string, inputBytes int64, totalSec float64) {
+	t.Helper()
+	jobFinish("")
+	if !jobStart(kind, outName, inputBytes, totalSec) {
+		t.Fatalf("jobStart 失败：还残留着未结束的任务 %q", jobBusyName())
+	}
+	t.Cleanup(func() { jobFinish("") })
+}
+
 // 阶段权重加起来必须正好是 1，否则总进度永远到不了 100%
 func TestJobPhaseWeightsSumToOne(t *testing.T) {
 	if len(jobPhaseNames) != len(jobPhaseWeights) {
@@ -23,8 +35,7 @@ func TestJobPhaseWeightsSumToOne(t *testing.T) {

 // 总进度：走过的阶段按权重满算，当前阶段按比例折算
 func TestJobPercentByPhase(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 100)
-	t.Cleanup(func() { jobFinish("") })
+	startJobForTest(t, "测试", "x.mp4", 0, 100)

 	if got := jobSnapshot().Percent; got != 0 {
 		t.Errorf("刚开始时总进度应为 0，实际 %v", got)
@@ -50,7 +61,7 @@ func TestJobPercentByPhase(t *testing.T) {

 // 阶段序号只往前走，重复设置同一阶段不会把进度打回 0
 func TestJobPhaseOnlyMovesForward(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 100)
+	startJobForTest(t, "测试", "x.mp4", 0, 100)
 	defer jobFinish("")
 	jobSetPhase(jobPhaseRender)
 	jobRender(60, 1, 25, 0)
@@ -66,7 +77,7 @@ func TestJobPhaseOnlyMovesForward(t *testing.T) {

 // 渲染阶段的 ETA = 剩余时长 ÷ 倍速
 func TestJobEtaFromSpeed(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 200)
+	startJobForTest(t, "测试", "x.mp4", 0, 200)
 	defer jobFinish("")
 	jobSetPhase(jobPhaseRender)
 	jobRender(50, 2.0, 25, 0)
@@ -78,7 +89,7 @@ func TestJobEtaFromSpeed(t *testing.T) {

 // 预计输出大小：先给按码率估的值，渲染过 5% 之后换成按已写出字节外推
 func TestJobEstOutSize(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 100)
+	startJobForTest(t, "测试", "x.mp4", 0, 100)
 	defer jobFinish("")
 	jobSetPhase(jobPhaseRender)

@@ -99,7 +110,7 @@ func TestJobEstOutSize(t *testing.T) {
 	}

 	// 比例太小的时候不急着外推，免得开头抖动
-	jobStart("测试", "x.mp4", 0, 100)
+	startJobForTest(t, "测试", "x.mp4", 0, 100)
 	jobSetPhase(jobPhaseRender)
 	jobPlanSize(5000)
 	jobRender(1, 1, 25, 100)
@@ -110,7 +121,7 @@ func TestJobEstOutSize(t *testing.T) {

 // 速度折线：最多保留固定点数，且按秒采样
 func TestJobSamples(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 100)
+	startJobForTest(t, "测试", "x.mp4", 0, 100)
 	defer jobFinish("")
 	jobSetPhase(jobPhaseRender)
 	// 同一秒内连着报多次只留一个点
@@ -136,7 +147,7 @@ func TestJobSamples(t *testing.T) {

 // 暂停 / 恢复 / 停止的状态流转；停止后闸门必须让上层拿到 errJobStopped
 func TestJobPauseStopGate(t *testing.T) {
-	jobStart("测试", "x.mp4", 0, 100)
+	startJobForTest(t, "测试", "x.mp4", 0, 100)
 	defer jobFinish("")

 	if err := jobPause(); err != nil {
@@ -281,7 +292,7 @@ func TestScanFFmpegProgressTolerant(t *testing.T) {

 // 截图式地看一眼任务快照的字段都填上了
 func TestJobSnapshotFields(t *testing.T) {
-	jobStart("手动合并", "成片.mp4", 123456, 3600)
+	startJobForTest(t, "手动合并", "成片.mp4", 123456, 3600)
 	defer jobFinish("")
 	jobSetPhase(jobPhaseAvatar)
 	jobAvatars(3, 10)
@@ -306,3 +317,99 @@ func TestJobSnapshotFields(t *testing.T) {
 		t.Error("任务在跑的时候应该可暂停")
 	}
 }
+
+// ==================== 任务串行化 ====================
+// 全局任务状态只有一份：两个合并同时跑的话，后启动的会把前一个的进度和输出名清掉，
+// 点「停止」还会杀掉别家任务的 ffmpeg。下面几条例外情况锁住改串行之后的语义。
+
+// jobStart 在已经有任务在跑时必须拒绝，并且一个字段都不能动
+func TestJobStartRejectsWhenBusy(t *testing.T) {
+	startJobForTest(t, "自动合并", "甲_弹幕合并.mp4", 1000, 100)
+	jobSetPhase(jobPhaseRender)
+	jobRender(30, 1.2, 25, 5000)
+
+	if ok := jobStart("手动合并", "乙_弹幕合并.mp4", 2000, 200); ok {
+		t.Fatal("已经有任务在跑，jobStart 应当返回 false")
+	}
+	info := jobSnapshot()
+	if info.Kind != "自动合并" || info.OutName != "甲_弹幕合并.mp4" {
+		t.Errorf("被拒之后不该动别人的任务信息：%+v", info)
+	}
+	if info.InputBytes != 1000 || info.TotalSec != 100 {
+		t.Errorf("被拒之后输入大小和总时长也不该变：%+v", info)
+	}
+	if info.Percent < 25 || info.Percent > 45 {
+		t.Errorf("被拒之后进度必须还是原任务自己的（25~45），实际 %v", info.Percent)
+	}
+	if !info.Active {
+		t.Error("拒绝新任务不代表把老任务结束掉")
+	}
+}
+
+// 任务位被占着时手动合并要立刻知道（不能让页面干等），抢不到只能有一个赢
+func TestMergeSlotTryLockExclusive(t *testing.T) {
+	if !tryTakeMergeSlot() {
+		t.Fatal("空闲时手动合并应该抢得到任务位")
+	}
+	if tryTakeMergeSlot() {
+		t.Fatal("任务位已经被占着，第二次 TryLock 不该成功")
+	}
+	releaseMergeSlot()
+	if !tryTakeMergeSlot() {
+		t.Fatal("释放之后应该又能抢到")
+	}
+	releaseMergeSlot()
+}
+
+// 自动合并（十几个主播同时下播很常见）必须排队而不是并发
+func TestMergeSlotSerializes(t *testing.T) {
+	if !tryTakeMergeSlot() {
+		t.Fatal("前置条件：任务位本该是空的")
+	}
+	const n = 4
+	order := make([]int, 0, n)
+	var mu sync.Mutex
+	done := make(chan struct{}, n)
+	for i := 0; i < n; i++ {
+		idx := i
+		go func() {
+			defer func() { done <- struct{}{} }()
+			// 和真实链路一致：自动合并会一直等到轮到自己
+			_ = runMergeExclusive(func() error {
+				mu.Lock()
+				order = append(order, idx)
+				mu.Unlock()
+				time.Sleep(20 * time.Millisecond)
+				return nil
+			})
+		}()
+	}
+	time.Sleep(60 * time.Millisecond) // 让它们先堆在门外
+	releaseMergeSlot()
+	for i := 0; i < n; i++ {
+		select {
+		case <-done:
+		case <-time.After(5 * time.Second):
+			t.Fatalf("第 %d 个任务没跑完，队列卡住了", i)
+		}
+	}
+	if len(order) != n {
+		t.Fatalf("应当 %d 个任务都跑完，实际 %d 个", n, len(order))
+	}
+}
+
+// 任务内部 panic 时也必须释放任务位、并且能翻成错误
+// —— 否则卡片会永远停在「进行中」，队列也被锁死
+func TestMergeExclusiveReleasesOnPanic(t *testing.T) {
+	err := runMergeExclusive(func() error { panic("模拟内部出错") })
+	if err == nil {
+		t.Fatal("内部 panic 应当被翻成错误返回")
+	}
+	if !strings.Contains(err.Error(), "模拟内部出错") {
+		t.Errorf("错误信息里应带上原因，实际：%v", err)
+	}
+	if !tryTakeMergeSlot() {
+		t.Fatal("panic 之后任务位必须已经释放")
+	}
+	releaseMergeSlot()
+}
@@ -46,7 +46,7 @@ func getFFmpeg() string {
 	}

 	if p, err := exec.LookPath("ffmpeg"); err == nil {
-		return p
+		return absExe(p)
 	}

 	for _, dir := range []string{
@@ -57,12 +57,25 @@ func getFFmpeg() string {
 	} {
 		p := filepath.Join(dir, name)
 		if info, err := os.Stat(p); err == nil && !info.IsDir() {
-			return p
+			return absExe(p)
 		}
 	}
 	return ""
 }

+// 转成绝对路径再交给 exec：合并时 ffmpeg 的工作目录会被改成输出目录，
+// 相对路径到那边就找不着了；而且 Windows 上 exec 会直接拒绝执行
+// 「相对当前目录」找到的可执行文件（报错信息完全看不出跟路径有关）
+func absExe(p string) string {
+	if p == "" || filepath.IsAbs(p) {
+		return p
+	}
+	if abs, err := filepath.Abs(p); err == nil {
+		return abs
+	}
+	return p
+}
+
 // 检查设置里指定的 ffmpeg 路径，返回错误信息，空字符串表示可用（或没填）
 func checkFFmpegPath(path string) string {
 	p := strings.TrimSpace(path)
@@ -208,11 +221,6 @@ func stopRecord(uid int) bool {
 	return true
 }

-// 退出直播视频录制相关操作
-func quitRecord(liveID string) {
-	updateLiveInfo(liveID, func(i *liveInfo) { i.isRecording = false })
-}
-
 // 初始化直播视频录制
 func (s streamer) initRecord(ctx context.Context, liveID, filename string) {
 	defer func() {
@@ -2,14 +2,34 @@ package main

 import (
 	"bufio"
+	"context"
 	"encoding/json"
+	"errors"
 	"os"
 	"path/filepath"
+	"strings"
+	"sync"
 	"testing"
+	"time"

 	"github.com/orzogc/acfundanmu"
 )

+// 等替换过的后台任务全部收工。用例里触发了 fire-and-forget 的合并时，必须在用例结束前等它们跑完
+func waitBackground(t *testing.T, bg *sync.WaitGroup, timeout time.Duration) {
+	t.Helper()
+	done := make(chan struct{})
+	go func() {
+		bg.Wait()
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(timeout):
+		t.Error("等后台任务收工超时，它可能还在读全局配置")
+	}
+}
+
 // 用真正的录制写入器（danmuWriter）产生 jsonl，再按合并的流程重排一遍，
 // 验证「本程序自己录下来的弹幕」合出来和以前一模一样（弹道、宽度都不变）。
 // 这也是手动合并与自动合并的分水岭：录制侧写文件完全不经过 relayoutLanes，
@@ -91,3 +111,160 @@ func countEmpty(recs []danmuRecord) int {
 	}
 	return n
 }
+
+// ==================== 写盘出错必须能被发现 ====================
+// 弹幕是边录边写的，写盘失败（磁盘满、外接盘/网络盘掉线）如果没人管，
+// 程序会照常宣告「录制完成」并自动合并 —— 出来的成片缺一大截弹幕，
+// 而日志里什么都看不出来。下面几条例外情况锁住「失败要浮出来」。
+
+// 写入失败必须被记下来，并且在 close() 时交出来
+func TestDanmuWriteErrorSurfacedOnClose(t *testing.T) {
+	dir := t.TempDir()
+	cfg := acfundanmu.SubConfig{Title: "测试直播", PlayResX: 1920, PlayResY: 1080,
+		FontSize: 48, StartTime: 1700000000000000000}
+	ass := filepath.Join(dir, "live.ass")
+	w := newDanmuWriter("liveid", "stream", cfg, ass)
+	if w.failed() {
+		t.Fatalf("刚建好的写入器不该有错误，实际：%v", w.err)
+	}
+
+	// 用「写到已关闭的句柄」来走同一条错误路径（和磁盘满、盘掉线一样，
+	// 都是 os.File.Write 返回 error）。换掉之前先把原来的句柄关掉，别泄漏
+	if err := w.jsonl.Close(); err != nil {
+		t.Fatal(err)
+	}
+	dead, err := os.Open(filepath.Join(dir, "live.jsonl"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := dead.Close(); err != nil {
+		t.Fatal(err)
+	}
+	w.jsonl = dead
+
+	c := &acfundanmu.Comment{Content: "这条应该写失败"}
+	c.SendTime = (cfg.StartTime + int64(500)*1e6) / 1e6
+	c.UserID = 7
+	c.Nickname = "观众"
+	w.write(c)
+
+	if !w.failed() {
+		t.Fatal("写入失败之后 failed() 应为 true（改之前错误是被丢掉的）")
+	}
+	err = w.close()
+	if err == nil {
+		t.Fatal("close() 必须把写盘错误交出来，实际返回 nil")
+	}
+	if !strings.Contains(err.Error(), "jsonl") {
+		t.Errorf("错误信息里要能看出是哪个文件出的问题，实际：%v", err)
+	}
+}
+
+// 只记第一个错：磁盘满了之后每写一条都会失败，全记下来会把日志刷爆
+func TestDanmuWriteKeepsOnlyFirstError(t *testing.T) {
+	w := &danmuWriter{}
+	w.fail("第一次", errors.New("磁盘满了"))
+	first := w.err
+	w.fail("第二次", errors.New("还是写不进去"))
+	w.fail("第三次", errors.New("依旧写不进去"))
+	if w.err != first {
+		t.Fatalf("错误应保持在第一个，实际被后来的覆盖了：%v", w.err)
+	}
+	if !strings.Contains(w.err.Error(), "磁盘满了") {
+		t.Errorf("应保留第一个错误的原因，实际：%v", w.err)
+	}
+}
+
+// 正常录制不能被误判成失败（这是「加检查」最容易踩的反向坑）
+func TestDanmuWriteNoFalseAlarm(t *testing.T) {
+	dir := t.TempDir()
+	cfg := acfundanmu.SubConfig{Title: "测试直播", PlayResX: 1920, PlayResY: 1080,
+		FontSize: 48, StartTime: 1700000000000000000}
+	w := newDanmuWriter("liveid", "stream", cfg, filepath.Join(dir, "ok.ass"))
+	for i := 0; i < 30; i++ {
+		c := &acfundanmu.Comment{Content: "正常弹幕"}
+		c.SendTime = (cfg.StartTime + int64(i)*220*1e6) / 1e6
+		c.UserID = int64(100 + i)
+		c.Nickname = "观众"
+		w.write(c)
+	}
+	if w.failed() {
+		t.Fatalf("正常写入不该判失败：%v", w.err)
+	}
+	if err := w.close(); err != nil {
+		t.Fatalf("正常写完后 close() 应返回 nil，实际：%v", err)
+	}
+}
+
+// 弹幕文件写坏之后必须跳过自动合并：只是打一条日志的话，
+// 照样会合成一个「缺了一大截弹幕」的成片，而且是静默的
+func TestFinishPartSkipsMergeWhenDanmuBroken(t *testing.T) {
+	// 这个用例会真的触发自动合并（safeGo 起的 goroutine）。它跑到用例结束之后还会读全局配置，
+	// 而下一个用例开头就改配置 → -race 会判成数据竞争。所以这里把后台任务换成可等待的版本，
+	// 清理时先等它收工再还原全局变量
+	var bg sync.WaitGroup
+	oldRun := runBackground
+	runBackground = func(f func()) {
+		bg.Add(1)
+		go func() {
+			defer bg.Done()
+			f()
+		}()
+	}
+	oldAuto, oldCtx := config.AutoMerge, mainCtx
+	t.Cleanup(func() {
+		waitBackground(t, &bg, 60*time.Second)
+		config.AutoMerge, mainCtx = oldAuto, oldCtx
+		runBackground = oldRun
+	})
+	config.AutoMerge = true
+	mainCtx = context.Background()
+
+	dir := t.TempDir()
+	video := filepath.Join(dir, "v.mp4")
+	ass := filepath.Join(dir, "v.ass")
+	if err := os.WriteFile(video, []byte("fake"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(ass, []byte("[Script Info]"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// 测试里没跑 initialize()，这张表还没建起来
+	lInfoMap.Lock()
+	if lInfoMap.info == nil {
+		lInfoMap.info = make(map[string]liveInfo)
+	}
+	lInfoMap.Unlock()
+
+	// 对照组：一切都正常时应该触发合并
+	good := "good-live-id"
+	lInfoMap.Lock()
+	lInfoMap.info[good] = liveInfo{LiveID: good, uid: 1, assFile: ass, firstRecordFile: video,
+		recordStartNs: time.Now().UnixNano(), recordSegments: []recordSegment{{file: video, startNs: time.Now().UnixNano()}}}
+	lInfoMap.Unlock()
+	finishPart(good, true)
+	finishPart(good, false)
+	lInfoMap.RLock()
+	started := lInfoMap.info[good].mergeStarted
+	lInfoMap.RUnlock()
+	if !started {
+		t.Fatal("对照组：条件都满足时应当触发自动合并（否则这条测试本身没意义）")
+	}
+
+	// 实验组：同样条件，但弹幕写盘出过错
+	bad := "bad-live-id"
+	lInfoMap.Lock()
+	lInfoMap.info[bad] = liveInfo{LiveID: bad, uid: 2, assFile: ass, firstRecordFile: video,
+		danmuWriteFailed: true,
+		recordStartNs:    time.Now().UnixNano(), recordSegments: []recordSegment{{file: video, startNs: time.Now().UnixNano()}}}
+	lInfoMap.Unlock()
+	finishPart(bad, true)
+	finishPart(bad, false)
+	lInfoMap.RLock()
+	got := lInfoMap.info[bad].mergeStarted
+	lInfoMap.RUnlock()
+	if got {
+		t.Error("弹幕文件写坏过，不该触发自动合并（否则会合成一个缺弹幕的成片）")
+	}
+}
@@ -0,0 +1,56 @@
+package main
+
+import (
+	"image"
+	"image/png"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// 一块里同一个人有多条弹幕、但其中一条整条落在块外（会被裁掉）时，
+// 头像的 split 份数必须和真正用到的份数一致 —— 否则 split 会多出一个没人接收的输出 pad，
+// ffmpeg 直接以 EINVAL（Windows 上就是 exit status 0xffffffea）退出，
+// 报错完全看不出跟弹幕有关，还会连累三个编码器挨个"失败"。
+func TestRenderChunkMatchesSplitWithVisibleDanmu(t *testing.T) {
+	ffmpegFile := getFFmpeg()
+	if ffmpegFile == "" {
+		t.Skip("找不到 ffmpeg，跳过")
+	}
+	withJobFlags(t, true, false, false)
+	dir := t.TempDir()
+
+	// 头像
+	av := filepath.Join(dir, "av.png")
+	f, err := os.Create(av)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := png.Encode(f, image.NewRGBA(image.Rect(0, 0, 16, 16))); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+
+	// 同一个 uid 两条弹幕：一条在块内可见，另一条时间远在块外
+	uid := int64(7)
+	chunk := danmuChunk{start: 0, end: 1, records: []danmuRecord{
+		{Time: 0.2, UID: uid, Name: "甲", Content: "块内可见的", Lane: 0, Width: 100},
+		{Time: 30.0, UID: uid, Name: "甲", Content: "整条在块外的", Lane: 1, Width: 100},
+	}}
+
+	ctx := &burnContext{
+		ffmpegFile: ffmpegFile,
+		outFile:    filepath.Join(dir, "out.mp4"),
+		meta:       danmuMeta{PlayResX: 160, PlayResY: 120, FontSize: 20},
+		avatars:    map[int64]string{uid: av},
+		dir:        dir,
+		encoder:    "libx264", // 直接指定软编，别让 QSV 的兼容性干扰这条用例
+	}
+	out := filepath.Join(dir, "chunk.mov")
+	if err := ctx.renderChunk(chunk, "chunk.ass", out, false, nil); err != nil {
+		t.Fatalf("同一个人有两条弹幕、其中一条在块外时不该渲染失败：%v", err)
+	}
+	if !fileExists(out) {
+		t.Fatalf("应当产出文件：%s", out)
+	}
+}
@@ -0,0 +1,605 @@
+package main
+
+import (
+	"encoding/json"
+	"math"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// ==================== 参数校验 ====================
+
+// 没填的项要补成默认值，不然拼出来的 ffmpeg 命令会带着一堆空参数
+func TestTranscodeOptionsNormalize(t *testing.T) {
+	o := transcodeOptions{}
+	n := o.normalize()
+	if n.Mode != rateModeSource {
+		t.Errorf("模式空时应按「跟随源片」，实际 %q", n.Mode)
+	}
+	if n.Preset != defaultTranscodePreset {
+		t.Errorf("预设空时应取 %q，实际 %q", defaultTranscodePreset, n.Preset)
+	}
+	if n.Audio != audioCopy {
+		t.Errorf("音频空时应按直接拷贝，实际 %q", n.Audio)
+	}
+}
+
+// 各种填错的情况都要在开跑之前挡住，别等 ffmpeg 报一句看不懂的错
+func TestTranscodeOptionsValidate(t *testing.T) {
+	ff := testFFmpeg(t)
+	bad := map[string]transcodeOptions{
+		"模式不认识":   {Mode: "xyz"},
+		"选了码率却没填": {Mode: rateModeBitrate},
+		"质量值越界":   {Mode: rateModeQuality, Quality: 99},
+		"比例越界":    {Mode: rateModePercent, Percent: 1000},
+		"码率上界越界":  {Mode: rateModeBitrate, Bitrate: maxBitrateKbps + 1},
+		"预设不认识":   {Preset: "ultrafast"},
+		"帧率越界":    {Fps: maxMergeFps + 1},
+		"缩放高度太小":  {Scale: 10},
+		"音频处理不认识": {Audio: "mp3"},
+		"编码器本机没有": {Encoder: "av1_nvenc"},
+	}
+	for name, o := range bad {
+		if msg := o.validate(ff); msg == "" {
+			t.Errorf("%s：应当被挡住，实际通过了", name)
+		}
+	}
+	// 正常参数要能过
+	ok := transcodeOptions{Mode: rateModeBitrate, Bitrate: 2000, Preset: "fast", Fps: 30, Scale: 720, Audio: audioAAC128}
+	if msg := ok.validate(ff); msg != "" {
+		t.Errorf("正常参数不该被挡：%s", msg)
+	}
+	if msg := (transcodeOptions{Encoder: "auto"}).validate(ff); msg != "" {
+		t.Errorf("auto 表示自动挑，不该被挡：%s", msg)
+	}
+}
+
+// ==================== 体积估算 ====================
+
+// 目标码率模式的体积是能算准的：码率 × 时长
+func TestEstimateTranscodeBitrateMode(t *testing.T) {
+	p := transcodeProbe{Duration: 100, VideoKbps: 4000, AudioKbps: 128}
+	got := estimateTranscode(transcodeOptions{Mode: rateModeBitrate, Bitrate: 2000, Audio: audioAAC128}, p, "h264_qsv")
+	// 视频 2000 + 音频 128 = 2128 kbps × 100 秒 = 26.6 MB
+	want := int64((2000 + 128) * 1000 / 8 * 100)
+	if got.Bytes != want {
+		t.Errorf("预估体积应为 %d，实际 %d", want, got.Bytes)
+	}
+	if !got.Exact {
+		t.Error("目标码率模式算出来的是准数，不该标成粗估")
+	}
+	if got.VideoKbps != 2000 || got.AudioKbps != 128 {
+		t.Errorf("预估码率不对：视频 %d、音频 %d", got.VideoKbps, got.AudioKbps)
+	}
+}
+
+// 按比例模式：60% 就是源片的六成
+func TestEstimateTranscodePercentMode(t *testing.T) {
+	p := transcodeProbe{Duration: 60, VideoKbps: 5000}
+	got := estimateTranscode(transcodeOptions{Mode: rateModePercent, Percent: 60, Audio: audioNone}, p, "libx264")
+	want := int64(3000 * 1000 / 8 * 60)
+	if got.Bytes != want {
+		t.Errorf("60%% 的源片码率应为 %d，实际 %d", want, got.Bytes)
+	}
+	if got.AudioKbps != 0 {
+		t.Errorf("去掉音轨后音频码率应为 0，实际 %d", got.AudioKbps)
+	}
+}
+
+// 质量模式只能粗估：数值越大体积越小，且要标成粗估
+func TestEstimateTranscodeQualityMode(t *testing.T) {
+	p := transcodeProbe{Duration: 100, VideoKbps: 4000, AudioKbps: 128}
+	low := estimateTranscode(transcodeOptions{Mode: rateModeQuality, Quality: 18}, p, "libx264")
+	high := estimateTranscode(transcodeOptions{Mode: rateModeQuality, Quality: 28}, p, "libx264")
+	if low.Bytes <= high.Bytes {
+		t.Errorf("质量值 18（%d 字节）应比 28（%d 字节）体积大", low.Bytes, high.Bytes)
+	}
+	if low.Exact || high.Exact {
+		t.Error("质量模式只能粗估，不该标成准数")
+	}
+	if high.Note == "" {
+		t.Error("粗估要给出依据说明，界面上要能看出来这不是准数")
+	}
+}
+
+// 质量值的系数表要单调：数值越大系数越小
+func TestQualityFactorMonotonic(t *testing.T) {
+	prev := math.Inf(1)
+	for q := 0; q <= 51; q++ {
+		f := qualityFactor(q)
+		if f > prev+1e-9 {
+			t.Fatalf("质量值 %d 的系数 %v 比上一个还大，压得越狠体积越大了", q, f)
+		}
+		if f <= 0 {
+			t.Fatalf("质量值 %d 的系数不该是 %v", q, f)
+		}
+		prev = f
+	}
+	// 表上的点要精确命中
+	if got := qualityFactor(18); math.Abs(got-1.0) > 1e-9 {
+		t.Errorf("CRF 18 是基准，系数应为 1，实际 %v", got)
+	}
+}
+
+// 缩到更低分辨率后，同样的码率要求下产物应更小
+func TestEstimateTranscodeScalingShrinks(t *testing.T) {
+	p := transcodeProbe{Duration: 100, VideoKbps: 4000, Height: 1080}
+	full := estimateTranscode(transcodeOptions{Mode: rateModeSource}, p, "libx264")
+	half := estimateTranscode(transcodeOptions{Mode: rateModeSource, Scale: 540}, p, "libx264")
+	if half.Bytes >= full.Bytes {
+		t.Errorf("缩到 540p（%d）应比原样（%d）小", half.Bytes, full.Bytes)
+	}
+	// 按面积算：540/1080 = 0.5，码率约为四分之一
+	if half.VideoKbps > full.VideoKbps/3 {
+		t.Errorf("高度减半后码率应降到约四分之一，实际 %d → %d", full.VideoKbps, half.VideoKbps)
+	}
+}
+
+// 源片没有音轨时别凭空加一份音频码率（拷贝模式拷不出音轨来）
+func TestEstimateTranscodeNoAudioTrack(t *testing.T) {
+	// HasAudio 没置位 = 探测不到音轨
+	p := transcodeProbe{Duration: 100, VideoKbps: 4000}
+	got := estimateTranscode(transcodeOptions{Mode: rateModeBitrate, Bitrate: 2000, Audio: audioCopy}, p, "libx264")
+	want := int64(2000 * 1000 / 8 * 100)
+	if got.Bytes != want {
+		t.Errorf("没有音轨时不该算音频：应 %d，实际 %d（音频 %d kbps）", want, got.Bytes, got.AudioKbps)
+	}
+	if got.AudioKbps != 0 {
+		t.Errorf("没有音轨时音频码率应为 0，实际 %d", got.AudioKbps)
+	}
+	// 显式要求重编码音频的话仍然按目标算（源片没有也只是多加一条空轨，不至于算错体积量级）
+	got = estimateTranscode(transcodeOptions{Mode: rateModeBitrate, Bitrate: 2000, Audio: audioAAC128}, p, "libx264")
+	if got.AudioKbps != 128 {
+		t.Errorf("显式重编码 128k 时应按 128 算，实际 %d", got.AudioKbps)
+	}
+}
+
+// 探测不到视频码率时按「体积 ÷ 时长」倒推，不能算成 0（那会显示成「—」）
+func TestVideoKbpsFallsBackToFileSize(t *testing.T) {
+	// 100 秒、50 MB 的文件 → 约 4000 kbps，扣掉 128k 音轨
+	m := mediaInfo{duration: 100, hasAudio: true, audioKbps: 128}
+	got := videoKbpsOf(m, 50*1024*1024)
+	if got < 3000 || got > 4500 {
+		t.Errorf("倒推的源片码率应在 3000~4500 之间，实际 %d", got)
+	}
+}
+
+// 容器总码率含音频，不能直接当视频码率：算体积时会和音频重复计一遍，
+// 「跟随源片」时也会把音轨的码率算进视频里
+func TestVideoKbpsDropsAudioFromContainer(t *testing.T) {
+	m := mediaInfo{containerKbps: 3000, hasAudio: true, audioKbps: 192}
+	if got := videoKbpsOf(m, 0); got != 2808 {
+		t.Errorf("容器 3000 扣掉 192 音轨应为 2808，实际 %d", got)
+	}
+	// 视频流自己写了码率就以它为准，不再动
+	m.videoKbps = 2600
+	if got := videoKbpsOf(m, 0); got != 2600 {
+		t.Errorf("视频流自己写了码率就该用它，实际 %d", got)
+	}
+	// 没有音轨时不扣
+	m = mediaInfo{containerKbps: 3000}
+	if got := videoKbpsOf(m, 0); got != 3000 {
+		t.Errorf("没有音轨时不扣，实际 %d", got)
+	}
+	// 音轨码率探测不到时按经验值扣，别一点不扣
+	m = mediaInfo{containerKbps: 3000, hasAudio: true}
+	if got := videoKbpsOf(m, 0); got != 3000-defaultAudioKbps {
+		t.Errorf("音轨码率未知时应按 %d 扣，实际 %d", defaultAudioKbps, got)
+	}
+}
+
+// 合并那边的自动码率一直按「视频流码率，没有就用容器总码率（含音频）」算，
+// 改口径会让所有自动合并的成片都变小一截，这里锁住
+func TestStreamOrContainerKbpsKeepsOldBehavior(t *testing.T) {
+	if got := streamOrContainerKbps(mediaInfo{videoKbps: 2000, containerKbps: 2500}); got != 2000 {
+		t.Errorf("有视频流码率时应优先用它，实际 %d", got)
+	}
+	if got := streamOrContainerKbps(mediaInfo{containerKbps: 2500, hasAudio: true, audioKbps: 192}); got != 2500 {
+		t.Errorf("没有视频流码率时应退回容器总码率（含音频），实际 %d", got)
+	}
+}
+
+// 探测结果的解析：容器总码率和视频流码率要分开记，封面图不能算成画面
+func TestParseMediaInfoSplitsBitrates(t *testing.T) {
+	out := "Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'x.mp4':\n" +
+		"  Duration: 00:02:55.07, start: 0.000000, bitrate: 1767 kb/s\n" +
+		"  Stream #0:0[0x1](und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 1920x1080 [SAR 1:1 DAR 16:9], 1234 kb/s, 30 fps, 30 tbr, 15360 tbn\n" +
+		"  Stream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, stereo, fltp, 192 kb/s\n"
+	m := parseMediaInfo(out)
+	if !m.hasVideo {
+		t.Error("有视频轨时 hasVideo 应为 true")
+	}
+	if m.videoKbps != 1234 || m.containerKbps != 1767 {
+		t.Errorf("视频流码率和容器总码率要分开记，实际 %d / %d", m.videoKbps, m.containerKbps)
+	}
+	if m.width != 1920 || m.height != 1080 || m.fps != 30 {
+		t.Errorf("画面参数没解析对：%dx%d %v fps", m.width, m.height, m.fps)
+	}
+	if !m.hasAudio || m.audioKbps != 192 {
+		t.Errorf("音轨没解析对：hasAudio=%v %d kbps", m.hasAudio, m.audioKbps)
+	}
+	if m.codec != "h264" {
+		t.Errorf("编码器名应为 h264，实际 %q", m.codec)
+	}
+	if d := m.duration; d < 175.0 || d > 175.2 {
+		t.Errorf("时长应为 175.07 秒，实际 %v", d)
+	}
+
+	// 只有封面图（attached pic）的文件不算有视频轨，否则转码时会当成画面
+	pic := "  Duration: 00:00:10.00, start: 0.000000, bitrate: 128 kb/s\n" +
+		"  Stream #0:0[0x1]: Video: mjpeg (attached pic), yuvj420p, 600x600, 90k tbr\n" +
+		"  Stream #0:1: Audio: mp3, 44100 Hz, stereo, 128 kb/s\n"
+	pm := parseMediaInfo(pic)
+	if pm.hasVideo {
+		t.Error("封面图不该算视频轨")
+	}
+	if pm.width != 0 {
+		t.Errorf("封面图的分辨率不该当画面用，实际 %d", pm.width)
+	}
+}
+
+// 同一个文件反复探测要走缓存（体积估算跟着输入框重发，每次起一个 ffmpeg 会把 CPU 占住），
+// 但文件变了必须重新探
+func TestProbeMediaCacheInvalidatesOnChange(t *testing.T) {
+	ff := testFFmpeg(t)
+	setupMergeTest(t)
+	path := filepath.Join(recordSaveDir(), "缓存.mp4")
+	if out, err := exec.Command(ff, "-hide_banner", "-y", "-f", "lavfi", "-i",
+		"testsrc=size=160x120:rate=10:duration=1", "-c:v", "libx264", "-pix_fmt", "yuv420p", path).CombinedOutput(); err != nil {
+		t.Skipf("造不出测试视频，跳过：%v %s", err, out)
+	}
+
+	probeCache.Lock()
+	probeCache.m = nil
+	probeCache.Unlock()
+
+	first := probeMediaCached(ff, path)
+	if first.duration <= 0 {
+		t.Fatalf("探测不到时长：%+v", first)
+	}
+	// 第二次必须命中缓存：键的数量不该变
+	probeCache.Lock()
+	n1 := len(probeCache.m)
+	probeCache.Unlock()
+	if again := probeMediaCached(ff, path); again.duration != first.duration {
+		t.Errorf("命中缓存时结果应一致，实际 %v ≠ %v", again.duration, first.duration)
+	}
+	probeCache.Lock()
+	n2 := len(probeCache.m)
+	probeCache.Unlock()
+	if n1 != 1 || n2 != 1 {
+		t.Errorf("同一个文件第二次探测不该新增缓存项，实际 %d → %d", n1, n2)
+	}
+
+	// 换个更长的片子放同一个路径：体积和修改时间都变了，必须重新探
+	if out, err := exec.Command(ff, "-hide_banner", "-y", "-f", "lavfi", "-i",
+		"testsrc=size=160x120:rate=10:duration=3", "-c:v", "libx264", "-pix_fmt", "yuv420p", path).CombinedOutput(); err != nil {
+		t.Fatalf("重造测试视频失败：%v %s", err, out)
+	}
+	changed := probeMediaCached(ff, path)
+	if changed.duration <= first.duration+0.5 {
+		t.Errorf("文件换成 3 秒的了，时长该跟着变（%v → %v）", first.duration, changed.duration)
+	}
+}
+
+// ==================== ffmpeg 参数 ====================
+
+// 指定的编码器要被用上；没指定时按本机可用的挑
+func TestTranscodeArgsEncoder(t *testing.T) {
+	ff := testFFmpeg(t)
+	src := mediaInfo{duration: 10, width: 1920, height: 1080, fps: 30, videoKbps: 4000}
+
+	args, enc, _ := transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Encoder: "libx264"}, src)
+	if enc != "libx264" {
+		t.Fatalf("指定 libx264 就该用它，实际 %s", enc)
+	}
+	if !containsSeq(args, "-c:v", "libx264") {
+		t.Errorf("命令里没有 -c:v libx264：%v", args)
+	}
+	// -c:v 必须在 -i 之后，否则 ffmpeg 会当成输入选项
+	iPos, cPos := indexOf(args, "in.mp4"), indexOf(args, "-c:v")
+	if iPos < 0 || cPos < 0 || cPos < iPos {
+		t.Errorf("-c:v 要放在 -i 之后，实际 %v", args)
+	}
+
+	_, auto, _ := transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{}, src)
+	if auto == "" {
+		t.Fatal("自动模式也该挑出一个编码器")
+	}
+	if !containsSeq(args, "-map", "0:v:0") {
+		t.Errorf("应显式只映射第一条视频流（跳过封面图），实际 %v", args)
+	}
+}
+
+// 质量模式下给质量参数、给目标码率模式下给码率参数，两者不能同时出现
+func TestTranscodeArgsRateControl(t *testing.T) {
+	ff := testFFmpeg(t)
+	src := mediaInfo{duration: 10, width: 1920, height: 1080, fps: 30, videoKbps: 4000}
+
+	args, _, _ := transcodeArgs(ff, "in.mp4", "out.mp4",
+		transcodeOptions{Mode: rateModeBitrate, Bitrate: 1500}, src)
+	if !containsSeq(args, "-b:v", "1500k") {
+		t.Errorf("目标码率模式应给 -b:v 1500k，实际 %v", args)
+	}
+	if has(args, "-crf") || has(args, "-global_quality") {
+		t.Errorf("给了目标码率就不该再给质量参数：%v", args)
+	}
+
+	// 质量模式没填数值时用默认值，不能把 0 塞给 ffmpeg
+	args, _, _ = transcodeArgs(ff, "in.mp4", "out.mp4",
+		transcodeOptions{Mode: rateModeQuality, Encoder: "libx264"}, src)
+	if !containsSeq(args, "-crf", "23") {
+		t.Errorf("软编的质量模式应默认 CRF 23，实际 %v", args)
+	}
+}
+
+// 缩放和帧率：只缩不放，帧率变了才加 fps 滤镜
+func TestTranscodeArgsFilters(t *testing.T) {
+	ff := testFFmpeg(t)
+	src := mediaInfo{duration: 10, width: 1920, height: 1080, fps: 30, videoKbps: 4000}
+
+	args, _, fps := transcodeArgs(ff, "in.mp4", "out.mp4",
+		transcodeOptions{Scale: 720, Fps: 60}, src)
+	vf := valueAfter(args, "-vf")
+	if !strings.Contains(vf, "scale=-2:720") {
+		t.Errorf("缩放应写进 -vf，实际 %q", vf)
+	}
+	if !strings.Contains(vf, "fps=60") {
+		t.Errorf("帧率变化应写进 -vf，实际 %q", vf)
+	}
+	if fps != 60 {
+		t.Errorf("返回的帧率应为 60，实际 %d", fps)
+	}
+
+	// 帧率跟源片一样时不加滤镜，白跑一遍滤镜只会更慢
+	_, _, fps = transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Fps: 30}, src)
+	if fps != 0 {
+		t.Errorf("帧率没变时不该加 fps 滤镜，实际返回 %d", fps)
+	}
+	// 目标比源片高时也不放大
+	_, _, _ = transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Scale: 2160}, src)
+	if vf := valueAfter(transcodeArgsArgs(ff, src), "-vf"); strings.Contains(vf, "scale") {
+		t.Errorf("不该把 1080p 放大到 2160p，实际 %q", vf)
+	}
+}
+
+// HEVC 要带 hvc1 标签，否则 Apple 系打不开
+func TestTranscodeArgsHEVCTag(t *testing.T) {
+	ff := testFFmpeg(t)
+	src := mediaInfo{duration: 10, width: 1920, height: 1080, fps: 30, videoKbps: 4000}
+	args, _, _ := transcodeArgs(ff, "in.mp4", "out.mp4",
+		transcodeOptions{Encoder: "hevc_qsv", Mode: rateModeBitrate, Bitrate: 2000}, src)
+	if !containsSeq(args, "-tag:v", "hvc1") {
+		t.Errorf("HEVC 要写 hvc1，实际 %v", args)
+	}
+	args, _, _ = transcodeArgs(ff, "in.mp4", "out.mp4",
+		transcodeOptions{Encoder: "libx264", Mode: rateModeBitrate, Bitrate: 2000}, src)
+	if has(args, "-tag:v") {
+		t.Errorf("H.264 不该加 hvc1，实际 %v", args)
+	}
+}
+
+// 音频的三种处理要各自拼对
+func TestTranscodeArgsAudio(t *testing.T) {
+	ff := testFFmpeg(t)
+	src := mediaInfo{duration: 10, width: 1280, height: 720, fps: 30, videoKbps: 2000, hasAudio: true, audioKbps: 128}
+
+	args, _, _ := transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Audio: audioNone}, src)
+	if !has(args, "-an") {
+		t.Errorf("去掉音轨应给 -an，实际 %v", args)
+	}
+	args, _, _ = transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Audio: audioAAC192}, src)
+	if !containsSeq(args, "-c:a", "aac") || !containsSeq(args, "-b:a", "192k") {
+		t.Errorf("AAC 192k 没拼对：%v", args)
+	}
+	args, _, _ = transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Audio: audioCopy}, src)
+	if !containsSeq(args, "-c:a", "copy") {
+		t.Errorf("直接拷贝应给 -c:a copy，实际 %v", args)
+	}
+}
+
+// ==================== 端到端：真的转一个 ====================
+
+// 拿 ffmpeg 造一段两秒的测试视频，再按各种参数真转一遍。
+// 只验证参数和落盘，体积大小不断言（不同机器编码结果不一样）
+func TestRunTranscodeProducesFile(t *testing.T) {
+	ff := testFFmpeg(t)
+	setupMergeTest(t)
+	src := filepath.Join(recordSaveDir(), "源片.mp4")
+	if out, err := exec.Command(ff, "-hide_banner", "-y", "-f", "lavfi", "-i",
+		"testsrc=size=640x360:rate=30:duration=2", "-c:v", "libx264", "-pix_fmt", "yuv420p", src).CombinedOutput(); err != nil {
+		t.Skipf("造不出测试视频，跳过：%v %s", err, out)
+	}
+
+	jobFinish("")
+	var got string
+	err := runMergeExclusive(func() error {
+		var e error
+		got, e = runTranscode(transcodeJobReq{
+			Dir: filepath.Base(recordSaveDir()), Name: filepath.Base(src),
+			Options: transcodeOptions{Mode: rateModeBitrate, Bitrate: 800, Scale: 360, Preset: "veryfast"},
+		}, mergeSaveDir(), 1, 1)
+		return e
+	})
+	jobFinish(jobErrText(err))
+	if err != nil {
+		t.Fatalf("转码失败：%v", err)
+	}
+	if got != "源片_转码.mp4" {
+		t.Errorf("返回的成片名不对：%q", got)
+	}
+	want := filepath.Join(mergeSaveDir(), "源片_转码.mp4")
+	if _, err := os.Stat(want); err != nil {
+		t.Fatalf("成片没落到 %s：%v", want, err)
+	}
+	// 转出来的文件不能是空壳
+	if n := fileSizeOrZero(want); n < 1024 {
+		t.Errorf("成片只有 %d 字节，不正常", n)
+	}
+}
+
+// 只有音轨的文件要当场挡住并说清原因，别等 ffmpeg 报一句「matches no streams」
+func TestRunTranscodeRejectsAudioOnly(t *testing.T) {
+	ff := testFFmpeg(t)
+	setupMergeTest(t)
+	src := filepath.Join(recordSaveDir(), "只有声音.mp4")
+	if out, err := exec.Command(ff, "-hide_banner", "-y", "-f", "lavfi", "-i",
+		"sine=frequency=440:duration=1", "-c:a", "aac", "-vn", src).CombinedOutput(); err != nil {
+		t.Skipf("造不出只有音轨的文件，跳过：%v %s", err, out)
+	}
+
+	jobFinish("")
+	err := runMergeExclusive(func() error {
+		_, e := runTranscode(transcodeJobReq{
+			Dir: filepath.Base(recordSaveDir()), Name: filepath.Base(src),
+		}, mergeSaveDir(), 1, 1)
+		return e
+	})
+	jobFinish(jobErrText(err))
+	if err == nil {
+		t.Fatal("只有音轨的文件不该转得下去")
+	}
+	if !strings.Contains(err.Error(), "没有视频轨") {
+		t.Errorf("报错要说明是没有视频轨，实际：%v", err)
+	}
+}
+
+// ==================== 小工具 ====================
+
+func has(args []string, v string) bool {
+	for _, a := range args {
+		if a == v {
+			return true
+		}
+	}
+	return false
+}
+
+// ==================== 源文件定位 ====================
+
+// 填了路径就按路径找，录播/成片文件夹之外的文件也要能转；没填才回落到 dir + name
+func TestResolveTranscodeJobByPath(t *testing.T) {
+	setupMergeTest(t)
+	outside := t.TempDir()
+	video := filepath.Join(outside, "别处的录播.mp4")
+	writeTestFile(t, video, "x")
+
+	// 绝对路径要认，从资源管理器复制来的带引号路径也要认
+	for _, in := range []string{video, `"` + video + `"`} {
+		got, err := resolveTranscodeJob(transcodeJobReq{Path: in})
+		if err != nil {
+			t.Fatalf("%q 应当能解析：%v", in, err)
+		}
+		if normalizePath(got) != normalizePath(video) {
+			t.Errorf("%q 解析成了 %q，想要 %q", in, got, video)
+		}
+	}
+
+	// 不填路径时还是按录播目录 + 文件名找，老写法不能坏
+	rec := filepath.Join(recordSaveDir(), "录播里的.mp4")
+	writeTestFile(t, rec, "x")
+	got, err := resolveTranscodeJob(transcodeJobReq{Dir: "record", Name: "录播里的.mp4"})
+	if err != nil {
+		t.Fatalf("dir + name 应当能解析：%v", err)
+	}
+	if normalizePath(got) != normalizePath(rec) {
+		t.Errorf("dir + name 解析成了 %q，想要 %q", got, rec)
+	}
+}
+
+// 路径这条能指向磁盘上任何文件，格式白名单必须照样过一遍
+func TestResolveTranscodeJobRejectsBadPath(t *testing.T) {
+	setupMergeTest(t)
+	outside := t.TempDir()
+	danmu := filepath.Join(outside, "某场.jsonl")
+	writeTestFile(t, danmu, "{}")
+	sub := filepath.Join(outside, "子文件夹")
+	if err := os.MkdirAll(sub, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	bad := map[string]transcodeJobReq{
+		"不是视频后缀":   {Path: danmu},
+		"指向文件夹":    {Path: sub},
+		"路径不存在":    {Path: filepath.Join(outside, "没有这个文件.mp4")},
+		"路径和名字都没填": {},
+	}
+	for name, j := range bad {
+		if _, err := resolveTranscodeJob(j); err == nil {
+			t.Errorf("%s：应当被挡住，实际通过了", name)
+		}
+	}
+}
+
+// 探测接口要认 {path} —— 这是「转码任意文件」的实际入口，只测 resolve 不足以证明接线对了。
+// 这里故意用一个不是视频的文件：探测拿不到流信息，但接口仍要 200 并把路径原样回显
+func TestTranscodeProbeHandlerAcceptsPath(t *testing.T) {
+	setupMergeTest(t)
+	outside := t.TempDir()
+	video := filepath.Join(outside, "别处.mp4")
+	writeTestFile(t, video, "not a real video")
+
+	body := `{"files":[{"path":` + strconv.Quote(video) + `}]}`
+	req := httptest.NewRequest("POST", "/api/transcode/probe", strings.NewReader(body))
+	rec := httptest.NewRecorder()
+	transcodeProbeHandler(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("按路径探测应当 200，实际 %d：%s", rec.Code, rec.Body.String())
+	}
+	var resp struct {
+		Files []struct {
+			Name string `json:"name"`
+			Path string `json:"path"`
+		} `json:"files"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Files) != 1 || resp.Files[0].Name != "别处.mp4" {
+		t.Fatalf("探测结果不对：%+v", resp.Files)
+	}
+	if normalizePath(resp.Files[0].Path) != normalizePath(video) {
+		t.Errorf("回显的 path 是 %q，想要 %q", resp.Files[0].Path, video)
+	}
+}
+
+func indexOf(args []string, v string) int {
+	for i, a := range args {
+		if a == v {
+			return i
+		}
+	}
+	return -1
+}
+
+// 参数里是否连续出现了这两个值
+func containsSeq(args []string, a, b string) bool {
+	for i := 0; i+1 < len(args); i++ {
+		if args[i] == a && args[i+1] == b {
+			return true
+		}
+	}
+	return false
+}
+
+// 取 -vf 后面的值
+func valueAfter(args []string, key string) string {
+	for i, a := range args {
+		if a == key && i+1 < len(args) {
+			return args[i+1]
+		}
+	}
+	return ""
+}
+
+// 单独构造一次参数给上面的用例用（避免重复拼 src）
+func transcodeArgsArgs(ff string, src mediaInfo) []string {
+	args, _, _ := transcodeArgs(ff, "in.mp4", "out.mp4", transcodeOptions{Scale: 2160}, src)
+	return args
+}
@@ -3,6 +3,7 @@ package main

 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -67,8 +68,11 @@ type liveInfo struct {
 	danmuStopped    bool               // 弹幕是否被用户手动停止（手动停止不触发自动合并）
 	recordStopped   bool               // 视频是否被用户手动停止
 	mergeStarted    bool               // 自动合并是否已经启动
-	doneAt          int64              // 最近一次录制结束的时刻，纳秒 Unix（用于延迟清理这条记录）
-	resumeUntil     int64              // 断流后等待直播恢复的截止时刻，纳秒 Unix；0 表示没在等待
+	// 弹幕文件在写盘时出过错（磁盘满、网络盘断开等）。文件是不完整的，
+	// 拿它合并会得到一个缺弹幕的成片，所以本场跳过自动合并
+	danmuWriteFailed bool
+	doneAt           int64 // 最近一次录制结束的时刻，纳秒 Unix（用于延迟清理这条记录）
+	resumeUntil      int64 // 断流后等待直播恢复的截止时刻，纳秒 Unix；0 表示没在等待
 }

 // streamerInfo 的 map
@@ -103,17 +107,37 @@ func checkErr(err error) {
 	}
 }

+// 后台任务真正怎么起。单独抽成一个变量是为了让测试能换成「可等待」的版本：
+// fire-and-forget 的 goroutine 漏到测试结束之后，会在下一个测试改全局配置时读它们，
+// -race 会判成数据竞争
+var runBackground = func(f func()) { go f() }
+
 // 后台任务的统一入口：兜底 recover，避免单个任务的 panic 终止整个进程
 // name 用于日志里指出是哪个任务出错，f 里可以继续做自己的 recover
 func safeGo(name string, f func()) {
-	go func() {
+	runBackground(func() {
 		defer func() {
 			if err := recover(); err != nil {
 				lPrintErrf("%s 发生错误并已恢复，其它录制任务不受影响：%v", name, err)
 			}
 		}()
 		f()
-	}()
+	})
+}
+
+// 不需要重试的错误：再试一遍也只是重复同样的失败（比如头像本身就超出体积/尺寸上限），
+// 硬重试只会白白把几 MB 的响应重新下一遍
+type noRetryError struct{ err error }
+
+func (e noRetryError) Error() string { return e.err.Error() }
+func (e noRetryError) Unwrap() error { return e.err }
+
+// 把错误标记成「重试也没用」
+func noRetry(err error) error {
+	if err == nil {
+		return nil
+	}
+	return noRetryError{err}
 }

 // 尝试运行，三次出错后结束运行
@@ -121,6 +145,10 @@ func runThrice(f func() error) error {
 	var err error
 	for retry := 0; retry < 3; retry++ {
 		if err = f(); err != nil {
+			var nr noRetryError
+			if errors.As(err, &nr) {
+				return err
+			}
 			log.Printf("%v", err)
 		} else {
 			return nil
@@ -225,13 +253,6 @@ func getLiveInfo(liveID string) (liveInfo, bool) {
 	return liveInfo{}, false
 }

-// 将 info 放进 lInfoMap 里
-func setLiveInfo(info liveInfo) {
-	lInfoMap.Lock()
-	defer lInfoMap.Unlock()
-	lInfoMap.info[info.LiveID] = info
-}
-
 // 原地更新 liveInfo 的部分字段，不覆盖其他字段（弹幕和视频录制共用同一个 liveInfo）
 func updateLiveInfo(liveID string, f func(*liveInfo)) {
 	lInfoMap.Lock()
@@ -252,14 +273,6 @@ func isDanmu(liveID string) bool {
 	return false
 }

-// 根据 liveID 查询是否正在录制直播视频
-func isRecording(liveID string) bool {
-	if info, ok := getLiveInfo(liveID); ok {
-		return info.isRecording
-	}
-	return false
-}
-
 // 跨盘搬运成片时的临时后缀：拷一半失败也能一眼看出不是成品
 const partSuffix = ".acfunlive.part"

@@ -350,10 +363,19 @@ func cleanTempFiles(dir string) {
 		return
 	}
 	for _, e := range entries {
+		name := e.Name()
+		// 预缩放头像是个目录（chunkAvatarDir），别被整个跳过
 		if e.IsDir() {
+			if strings.HasPrefix(name, chunkTempPrefix) {
+				path := filepath.Join(dir, name)
+				if err := os.RemoveAll(path); err == nil {
+					lPrintln("清理上次留下的临时文件夹：" + name)
+				} else {
+					lPrintWarnf("临时文件夹 %s 现在删不掉，下次启动会自动清理：%v", path, err)
+				}
+			}
 			continue
 		}
-		name := e.Name()
 		if !strings.HasPrefix(name, chunkTempPrefix) && !strings.HasSuffix(name, partSuffix) {
 			continue
 		}
@@ -0,0 +1,219 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// 造 n 条弹幕：从 start 秒开始，每条间隔 step
+func mkDanmuForFit(start, step float64, n int) []danmuRecord {
+	out := make([]danmuRecord, 0, n)
+	for i := 0; i < n; i++ {
+		out = append(out, danmuRecord{
+			Time: start + float64(i)*step, UID: int64(100 + i), Name: "甲",
+			Content: fmt.Sprintf("第 %d 条", i), Width: 100,
+		})
+	}
+	return out
+}
+
+// 正常场次：时间轴一点都不该动
+func TestFitDanmuToVideoLeavesNormalAlone(t *testing.T) {
+	records := mkDanmuForFit(1, 1, 10) // 1 ~ 10 秒
+	got, off := fitDanmuToVideo(records, 0, 60)
+	if len(got) != 10 || off != 0 {
+		t.Fatalf("正常场次不该动：留 %d 条、偏移 %v", len(got), off)
+	}
+}
+
+// 弹幕确实录得比视频久（视频中途断过）：只丢尾部超出的，时间轴不动
+func TestFitDanmuToVideoDropsTailOnly(t *testing.T) {
+	records := mkDanmuForFit(1, 5, 20) // 1 ~ 96 秒，视频只有 50 秒
+	got, off := fitDanmuToVideo(records, 0, 50)
+	if off != 0 {
+		t.Fatalf("只该丢尾部，偏移应保持 0，实际 %v", off)
+	}
+	if len(got) == 0 || len(got) == len(records) {
+		t.Fatalf("应该留一部分、丢一部分，实际留 %d 条", len(got))
+	}
+	if last := got[len(got)-1].Time; last >= 50 {
+		t.Fatalf("留下的最后一条应在视频内，实际 %v", last)
+	}
+}
+
+// 时间基准整体偏移的 .ass（时间相对程序启动、不是录制开始）：按第一条弹幕对齐视频起点
+func TestFitDanmuToVideoAlignsShiftedTimeBase(t *testing.T) {
+	// 现实素材的形状：7849.92 ~ 13286.59 秒 / 视频 5456.883 秒
+	records := mkDanmuForFit(7849.92, 5.7, 955)
+	got, off := fitDanmuToVideo(records, 0, 5456.883)
+	if off != -7849.92 {
+		t.Fatalf("偏移应为 -7849.92，实际 %v", off)
+	}
+	if len(got) != len(records) {
+		t.Fatalf("跨度装得进视频，不该丢弹幕，实际留 %d / %d 条", len(got), len(records))
+	}
+	if first := got[0].Time + off; first != 0 {
+		t.Fatalf("第一条应落在视频起点，实际 %v", first)
+	}
+	if end := got[len(got)-1].Time + off; end >= 5456.883 {
+		t.Fatalf("最后一条应在视频内，实际 %v", end)
+	}
+}
+
+// 边界：跨度刚好比视频短一点点，对齐后一条都不该丢
+func TestFitDanmuToVideoAlignJustFits(t *testing.T) {
+	records := mkDanmuForFit(1000, 1, 1000) // 1000 ~ 1999 秒，跨度 999 秒
+	got, off := fitDanmuToVideo(records, 0, 1000)
+	if off != -1000 {
+		t.Fatalf("偏移应为 -1000，实际 %v", off)
+	}
+	if len(got) != len(records) {
+		t.Fatalf("跨度装得进视频，不该丢弹幕，实际留 %d / %d 条", len(got), len(records))
+	}
+	if end := got[len(got)-1].Time + off; end >= 1000 {
+		t.Fatalf("最后一条应在视频内，实际 %v", end)
+	}
+}
+
+// 弹幕跨度本身就装不进视频：平移救不回来，只能按原行为一条不留
+func TestFitDanmuToVideoGivesUpWhenSpanTooLong(t *testing.T) {
+	records := mkDanmuForFit(7849.92, 10, 100) // 跨度 990 秒 > 视频 500 秒
+	got, off := fitDanmuToVideo(records, 0, 500)
+	if len(got) != 0 {
+		t.Fatalf("跨度装不下时应一条不留，实际 %d 条", len(got))
+	}
+	if off != 0 {
+		t.Fatalf("放弃时不该改偏移，实际 %v", off)
+	}
+}
+
+// 偏移把弹幕整体推到视频之前时保持原行为（这些条目不算「超出时长」，由渲染那边处理）
+func TestFitDanmuToVideoKeepsAllBeforeVideoBehaviour(t *testing.T) {
+	records := mkDanmuForFit(100, 1, 10)
+	got, off := fitDanmuToVideo(records, -1000, 500)
+	if len(got) != len(records) || off != -1000 {
+		t.Fatalf("整体在视频之前时不该动：留 %d 条、偏移 %v", len(got), off)
+	}
+}
+
+// 用户实测的那种场次：.ass 时间基准比视频晚一大截，合并要能成功并且真的画上弹幕
+func TestManualMergeFromShiftedAssEndToEnd(t *testing.T) {
+	dir := setupMergeTest(t)
+	ffmpeg := getFFmpeg()
+	if ffmpeg == "" {
+		t.Skip("没有 ffmpeg")
+	}
+
+	name := "2026-09-25 02-00-00 测试主播 时间基准偏移"
+	video := filepath.Join(recordSaveDir(), name+".mp4")
+	cmd := exec.Command(ffmpeg, "-v", "error", "-y",
+		"-f", "lavfi", "-i", "color=c=black:size=640x360:rate=25", "-t", "8",
+		"-c:v", "libx264", "-preset", "ultrafast", "-pix_fmt", "yuv420p", video)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("生成测试视频失败：%v\n%s", err, out)
+	}
+
+	// 弹幕时间整体比录制起点晚 2 小时（模拟「程序先开着、直播中途才开始录」）
+	ass := fmt.Sprintf(`[Script Info]
+Title: %s
+ScriptType: v4.00+
+Collisions: Normal
+PlayResX: 640
+PlayResY: 360
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Danmu,Microsoft YaHei,40,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,0,2,20,20,2,0
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,2:00:01.00,2:00:11.00,Danmu,甲(101),20,20,2,,{\move(400,40,-40,40)}第一条弹幕
+Dialogue: 0,2:00:03.00,2:00:13.00,Danmu,乙(202),20,20,2,,{\move(400,80,-40,80)}第二条弹幕
+Dialogue: 0,2:00:05.00,2:00:15.00,Danmu,甲(101),20,20,2,,{\move(400,120,-40,120)}第三条弹幕
+`, name)
+	assPath := writeTestFile(t, filepath.Join(recordSaveDir(), name+".ass"), ass)
+
+	if _, err := prepareDanmuSource(assPath, true); err != nil {
+		t.Fatalf("还原弹幕失败：%v", err)
+	}
+	plan, err := buildMergePlan(mergeRequest{Videos: []string{video}, Danmu: assPath})
+	if err != nil {
+		t.Fatalf("检查失败：%v", err)
+	}
+
+	var buf bytes.Buffer
+	oldOut := logger.Writer()
+	logger.SetOutput(&buf)
+	err = execManualMerge(plan)
+	logger.SetOutput(oldOut)
+	if err != nil {
+		t.Fatalf("时间基准偏移的场次应当能合出来，实际失败：%v\n日志：\n%s", err, buf.String())
+	}
+	log := buf.String()
+	if !strings.Contains(log, "按「第一条弹幕对齐视频起点」") {
+		t.Fatalf("日志里应写明自动对齐：\n%s", log)
+	}
+	if !strings.Contains(log, "对齐后弹幕覆盖") {
+		t.Fatalf("日志里应写明对齐后的覆盖范围：\n%s", log)
+	}
+
+	if _, err := os.Stat(plan.out); err != nil {
+		t.Fatalf("没有生成成片：%v", err)
+	}
+
+	// 成片里确实画了弹幕：同一时刻抽帧，有字的帧 PNG 一定比纯黑源片大
+	shot := func(src, tag string) int {
+		out := filepath.Join(dir, "shot_"+tag+".png")
+		c := exec.Command(ffmpeg, "-v", "error", "-y", "-ss", "3", "-i", src,
+			"-frames:v", "1", "-update", "1", out)
+		if o, err := c.CombinedOutput(); err != nil {
+			t.Fatalf("抽帧失败：%v\n%s", err, o)
+		}
+		fi, err := os.Stat(out)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return int(fi.Size())
+	}
+	srcSize, outSize := shot(video, "src"), shot(plan.out, "out")
+	if outSize <= srcSize {
+		t.Fatalf("成片的帧没有比纯黑源片大，弹幕很可能没画上：源 %d 字节、成片 %d 字节", srcSize, outSize)
+	}
+	t.Logf("抽帧大小：源 %d 字节、成片 %d 字节", srcSize, outSize)
+}
+
+// 同一次 .ass 还原只该在日志里出现一条（页面的「检查」和合并都会解析一遍）
+func TestPrepareDanmuSourceLogsRestoreOnce(t *testing.T) {
+	setupMergeTest(t)
+	path := writeTestFile(t,
+		filepath.Join(recordSaveDir(), "2026-09-25 03-00-00 测试主播 标题.ass"), plainAssFixture)
+
+	var buf bytes.Buffer
+	oldOut := logger.Writer()
+	logger.SetOutput(&buf)
+	defer logger.SetOutput(oldOut)
+
+	// 「检查」先解析一遍（不落盘），合并再解析一遍并落盘
+	if _, err := prepareDanmuSource(path, false); err != nil {
+		t.Fatalf("检查失败：%v", err)
+	}
+	if _, err := prepareDanmuSource(path, true); err != nil {
+		t.Fatalf("还原失败：%v", err)
+	}
+
+	log := buf.String()
+	if n := strings.Count(log, "还原出"); n != 1 {
+		t.Fatalf("「还原出」应只出现 1 次，实际 %d 次：\n%s", n, log)
+	}
+	if n := strings.Count(log, "还原成"); n != 0 {
+		t.Fatalf("不该再有「还原成」这条日志，实际 %d 次：\n%s", n, log)
+	}
+	if !strings.Contains(log, filepath.Base(path)) {
+		t.Fatalf("日志里应写明是哪个文件：\n%s", log)
+	}
+}
@@ -2,10 +2,17 @@
 package main

 import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"path/filepath"
+	"regexp"
 	"testing"
+	"time"
 )

 // 测试期间换一个管理口令
@@ -155,3 +162,287 @@ func TestAuthTokenCandidatesOrder(t *testing.T) {
 		t.Fatalf("非 Bearer 的 Authorization 不该当候选：%q", got)
 	}
 }
+
+// ==================== 口令错误记录的容量 ====================
+// IP 是外部给的：只靠「过期清理」挡不住换着地址撞口令的情况，
+// 必须要有硬上限。这些用例锁住这一点。
+
+// 换着来源持续撞口令，表必须被压在上限以内，不能一直涨
+func TestAuthFailTableHasHardCap(t *testing.T) {
+	saved, savedSweep := authFail.m, authFail.sinceSweep
+	t.Cleanup(func() {
+		authFail.Lock()
+		authFail.m, authFail.sinceSweep = saved, savedSweep
+		authFail.Unlock()
+	})
+	authFail.Lock()
+	authFail.m, authFail.sinceSweep = nil, 0
+	authFail.Unlock()
+
+	// 每个都是新来源、且都是「刚刚」失败过 —— 过期清理一条都删不掉的情况
+	for i := 0; i < authFailMaxEntries*2; i++ {
+		authFailDelay(fmt.Sprintf("198.51.100.%d", i))
+	}
+	got := 0
+	authFail.Lock()
+	got = len(authFail.m)
+	authFail.Unlock()
+	if got > authFailMaxEntries {
+		t.Errorf("记录数应被压在上限 %d 以内，实际 %d（换 IP 撞口令会把内存写满）",
+			authFailMaxEntries, got)
+	}
+	t.Logf("  %d 个新来源撞完，表内留下 %d 条（上限 %d）", authFailMaxEntries*2, got, authFailMaxEntries)
+}
+
+// 超过过期时间的记录要被扫掉，不是在表里一直躺着
+func TestAuthFailExpiredEntriesGetSwept(t *testing.T) {
+	saved, savedSweep := authFail.m, authFail.sinceSweep
+	t.Cleanup(func() {
+		authFail.Lock()
+		authFail.m, authFail.sinceSweep = saved, savedSweep
+		authFail.Unlock()
+	})
+	authFail.Lock()
+	authFail.m, authFail.sinceSweep = nil, 0
+	authFail.Unlock()
+
+	for i := 0; i < authFailSweepEvery+5; i++ {
+		authFailDelay(fmt.Sprintf("203.0.113.%d", i))
+	}
+	authFail.Lock()
+	before := len(authFail.m)
+	// 把记录的最后时间推到过期之前
+	for k, v := range authFail.m {
+		authFail.m[k] = authFailEntry{count: v.count, last: time.Now().Add(-2 * authFailExpire)}
+	}
+	authFail.Unlock()
+
+	sweepAuthFail(time.Now())
+	authFail.Lock()
+	after := len(authFail.m)
+	authFail.Unlock()
+	if after != 0 {
+		t.Errorf("已经全部过期的记录应被扫干净，扫之前 %d 条，扫之后 %d 条", before, after)
+	}
+}
+
+// 扫表必须是自动发生的：不要求调用方记着手动清理，
+// 混在里面的过期项应该在若干次记录之后自己消失
+func TestAuthFailSweepsPeriodically(t *testing.T) {
+	saved, savedSweep := authFail.m, authFail.sinceSweep
+	t.Cleanup(func() {
+		authFail.Lock()
+		authFail.m, authFail.sinceSweep = saved, savedSweep
+		authFail.Unlock()
+	})
+	authFail.Lock()
+	authFail.m, authFail.sinceSweep = nil, 0
+	authFail.Unlock()
+
+	// 直接往里塞一条早就过期了的记录（绕过 authFailDelay，模拟「以前留下的」）
+	authFail.Lock()
+	if authFail.m == nil {
+		authFail.m = make(map[string]authFailEntry)
+	}
+	authFail.m["203.0.113.99"] = authFailEntry{count: 1, last: time.Now().Add(-2 * authFailExpire)}
+	authFail.Unlock()
+
+	// 之后只要还在有人失败，过一阵子它就应该被清掉
+	for i := 0; i < authFailSweepEvery+1; i++ {
+		authFailDelay(fmt.Sprintf("198.51.100.%d", i))
+	}
+
+	authFail.Lock()
+	_, still := authFail.m["203.0.113.99"]
+	authFail.Unlock()
+	if still {
+		t.Errorf("记了 %d 次之后，过期记录应当已经被自动扫掉", authFailSweepEvery+1)
+	}
+}
+
+// 同一个来源的计数不能无限涨（临界点是延迟早已封顶，再涨只是让数字溢出）
+func TestAuthFailCountCapped(t *testing.T) {
+	saved, savedSweep := authFail.m, authFail.sinceSweep
+	t.Cleanup(func() {
+		authFail.Lock()
+		authFail.m, authFail.sinceSweep = saved, savedSweep
+		authFail.Unlock()
+	})
+	authFail.Lock()
+	authFail.m, authFail.sinceSweep = nil, 0
+	authFail.Unlock()
+
+	for i := 0; i < authFailMaxCount+50; i++ {
+		authFailDelay("192.0.2.9")
+	}
+	authFail.Lock()
+	c := authFail.m["192.0.2.9"].count
+	authFail.Unlock()
+	if c > authFailMaxCount {
+		t.Errorf("同一来源的次数应封顶在 %d，实际 %d", authFailMaxCount, c)
+	}
+	if d := authFailDelay("192.0.2.9"); d != authMaxDelay {
+		t.Errorf("打满之后延迟应封顶在 %v，实际 %v", authMaxDelay, d)
+	}
+}
+
+// 客户端断开时延迟等待必须立刻返回，不能傻等满 2 秒
+func TestAwaitAuthDelayStopsOnCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		time.Sleep(80 * time.Millisecond)
+		cancel()
+	}()
+	start := time.Now()
+	waited := awaitAuthDelay(ctx, 2*time.Second)
+	used := time.Since(start)
+	if waited {
+		t.Error("上游取消时 awaitAuthDelay 应返回 false")
+	}
+	if used > time.Second {
+		t.Errorf("上游取消后应立刻返回，实际等了 %v", used)
+	}
+	// 正常等待不受影响
+	if !awaitAuthDelay(context.Background(), 10*time.Millisecond) {
+		t.Error("没被取消时应当正常等完再返回 true")
+	}
+}
+
+var (
+	webInputIDRe       = regexp.MustCompile(`<(?:input|select|textarea)[^>]*\bid="([A-Za-z0-9_]+)"`)
+	webSettingFieldsRe = regexp.MustCompile(`var settingFields = \[([^\]]*)\]`)
+	webNumberFieldsRe  = regexp.MustCompile(`var numberFields = \{([^}]*)\}`)
+	webQuotedRe        = regexp.MustCompile(`"([A-Za-z0-9_]+)"`)
+)
+
+// 设置页里每个能改的输入框都必须在 settingFields 里登记：漏登记的后果是「改了、按了保存，
+// 值却没被提交」，3 秒后刷新又被刷回原值 —— 页面看起来完全正常，也没有任何报错。
+// 反过来，settingFields 里写的 id 如果页面上不存在，refresh 时就静默填不进去。
+//
+// settingFields / numberFields 都是页面里的 JS 变量（整页在 webuiHTML 这个原始串里），
+// 所以这里直接把它们从串里抠出来比对，不另维护一份名单
+func TestWebuiSettingFieldsMatchInputs(t *testing.T) {
+	ids := map[string]bool{}
+	for _, m := range webInputIDRe.FindAllStringSubmatch(webuiHTML, -1) {
+		ids[m[1]] = true
+	}
+
+	m := webSettingFieldsRe.FindStringSubmatch(webuiHTML)
+	if m == nil {
+		t.Fatal("没能在页面里找到 settingFields 列表")
+	}
+	settings := map[string]bool{}
+	for _, q := range webQuotedRe.FindAllStringSubmatch(m[1], -1) {
+		settings[q[1]] = true
+		if !ids[q[1]] {
+			t.Errorf("settingFields 里的 %q 在页面上找不到对应的输入框", q[1])
+		}
+	}
+
+	// 这些输入框刻意不进设置：要么是手动合并卡片自己的参数（随合并请求提交），
+	// 要么是路径选择弹窗 / 口令框的内部状态
+	notSettings := map[string]string{
+		"authTokenNew":  "重新生成口令，走单独的接口",
+		"authTokenView": "只读展示当前口令",
+		"tokenInput":    "页面解锁框，不是设置项",
+		"newuid":        "添加主播，走主播接口",
+		"pickHidden":    "路径选择弹窗的内部状态",
+		"pickPath":      "路径选择弹窗的内部状态",
+		"mrgVideoPick":  "手动合并：视频列表，随合并请求提交",
+		"tcFilePick":    "转码：待选文件列表，随转码请求提交",
+		"tcPaths":       "转码：手填的文件路径列表，随转码请求提交",
+		"tcOutDir":      "转码：输出目录，随转码请求提交",
+	}
+	for id := range ids {
+		if settings[id] {
+			continue
+		}
+		if _, ok := notSettings[id]; ok {
+			continue
+		}
+		t.Errorf("页面上的 %q 既不在 settingFields 里，也没说明为什么不算设置项：改了它不会被保存", id)
+	}
+
+	// numberFields 里的 id 必须都是设置项，否则 parseInt 的结果没人用
+	n := webNumberFieldsRe.FindStringSubmatch(webuiHTML)
+	if n == nil {
+		t.Fatal("没能在页面里找到 numberFields 列表")
+	}
+	for _, m := range regexp.MustCompile(`([A-Za-z0-9_]+)\s*:`).FindAllStringSubmatch(n[1], -1) {
+		if !settings[m[1]] {
+			t.Errorf("numberFields 里的 %q 不是设置项", m[1])
+		}
+	}
+}
+
+// 保存设置必须把新增字段真的落到 config 上：漏一个赋值就是「界面显示已保存、实际没生效」，
+// 3 秒后刷新还被刷回原值，页面上完全看不出问题
+func TestWebConfigHandlerSavesMergeFpsAndNotifyMergeFail(t *testing.T) {
+	dir := setupMergeTest(t)
+	savedConfig := config
+	savedLocation := configFileLocation
+	oldDir := configDir
+	if configDir == nil {
+		configDir = new(string)
+	}
+	defer func() {
+		config = savedConfig
+		configFileLocation = savedLocation
+		configDir = oldDir
+	}()
+	*configDir = dir
+	configFileLocation = filepath.Join(dir, configFile)
+
+	post := func(body map[string]any) string {
+		t.Helper()
+		data, err := json.Marshal(body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		req := httptest.NewRequest(http.MethodPost, "/api/config", bytes.NewReader(data))
+		rec := httptest.NewRecorder()
+		webConfigHandler(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("保存设置被拒（%d）：%s", rec.Code, rec.Body.String())
+		}
+		return rec.Body.String()
+	}
+	base := func() map[string]any {
+		return map[string]any{
+			"directory":    dir,
+			"ffmpegPath":   testFFmpeg(t),
+			"recordSubdir": defaultRecordSubdir,
+			"mergeSubdir":  defaultMergeSubdir,
+		}
+	}
+
+	config.MergeFps = 0
+	config.NotifyMergeFail = true
+	b := base()
+	b["mergeFps"] = 60
+	b["notifyMergeFail"] = false
+	post(b)
+	if config.MergeFps != 60 {
+		t.Errorf("mergeFps 没被保存下来：%d", config.MergeFps)
+	}
+	if config.NotifyMergeFail {
+		t.Error("notifyMergeFail=false 没被保存下来")
+	}
+
+	// 超范围（负数或大得离谱）必须挡在保存之前
+	for _, bad := range []int{-1, maxMergeFps + 1} {
+		config.MergeFps = 7
+		b = base()
+		b["mergeFps"] = bad
+		data, _ := json.Marshal(b)
+		req := httptest.NewRequest(http.MethodPost, "/api/config", bytes.NewReader(data))
+		rec := httptest.NewRecorder()
+		webConfigHandler(rec, req)
+		if rec.Code != http.StatusBadRequest {
+			t.Errorf("mergeFps=%d 应当被拒（400），实际 %d", bad, rec.Code)
+		}
+		if config.MergeFps != 7 {
+			t.Errorf("mergeFps=%d 被拒后不该改到配置里，实际 %d", bad, config.MergeFps)
+		}
+	}
+}