feat: 8 条功能 + 身份口径改为号码布为准（含批量退赛/移出、基础数据导入导出、登录有效期）

用户给出的 8 条功能 + 一条口径变更，全部带真机/真浏览器验证：

① 录入页姓名后直接显示号码布（原「号码」列保留）
② 录入页批次进度条：`第 2 批 已录 5/8 · 3 条有错`，录完变绿；已录判据复用
   entryGuards.judgeEntryRow（与发布防呆同源，不会出现"进度条说录完、发布说缺 8 条"）
⑦ 小项列表双击 → 跳到该小项的组别（编辑/删除按钮不误触）
③ 赛事开关 `standings.live_on_publish`（默认开＝保持原行为）：关闭后分批发布只上屏成绩，
   名次/流水/榜单一起等该组录完再结算 —— 代理实读代码后纠正了我的前提：
   奖牌榜读的是 results.rank（buildRanked）而非流水汇总，只延迟流水会出现
   「有金牌但 0 分」。另提供 POST /api/results/settle 人工兜底 + GET /api/results/settlement 未结算清单
④ 组别「就地更新」PUT /api/events/{id}/categories/{categoryId}：有报名数据时也能改名/改年龄/
   改性别/改权重（旧路径是整表替换，一改就被 409 拦下）；改名不动报名/成绩/流水（真机逐字节比对）；
   权重真的变了才触发该组重算（容差 1e-9）
④辅 运动员列表多选+全选，POST /api/athletes/batch 一次请求完成整批停用/彻底删除（逐条回报，
   dryRun 预览走同一段 SQL 但不提交、不写审计）——这才是绕开限流的正解
新增 报名项批量：POST /api/entries/batch（scratch/restore/remove）。退赛只动 registered、
   跳过 dq/dns 并说明原因；移出是物理删除，必须显式清 score_ledger（该表 entry_id 是
   ON DELETE SET NULL，不显式删会留下"人没了分还在"的孤儿流水，验证基线 orphan=0）；
   退赛同时清 results.rank（否则出现"0 分还挂着金牌"）
⑤ GET /api/export/entries.xlsx 报名名单导出（13 列含批次，状态中文与录入页逐字一致）
⑥ 基础数据包：GET /api/export/basedata.xlsx + POST /api/export/basedata/import
   （四张表、表头只有一份定义、表头行自动定位、列缺席≠写空、按编码 upsert、绝不删除、
   行级中文错误带真实 Excel 行号、枚举走既有校验、新增单位一定是启用）
⑧ 登录有效期面板可配：系统设置新页签，1–720 小时，默认 12h → 24h；滑动续期 +
   Cookie 同步刷新（只服务端续期是假的，浏览器侧的 Max-Age 到点仍会丢 Cookie）
身份口径：号码布为唯一标识、证件号退出匹配（号码布不同=同名的两个人，新建并单独报告）；
   同一份表重复证件号不再报错；两个不同的人共用证件号仍报行级错误（唯一索引保留）

其它对齐：分项成绩表草稿行不再消失（成绩列「分数未录入」、名次/积分 `—`，没成绩的行同占位）；
大屏实时赛况单栏铺满（留白 370→78px）、字号上限 56→96px、≥7 行自动拆左右两块；
删除报名项/退赛/权重等改动都会重算并推榜单。

测试：服务端 13 包（连跑两遍）、前端 335 例、vue-tsc + build、Console 18 文件 —— 全绿。
文档：README、docs/ 四份（含 debug/使用说明 副本）、devdocs 05/08/04/13。
版本号 dev_0.1.5 → dev_0.1.6。

server/internal/httpapi/deferred_settlement_test.go

@@ -0,0 +1,466 @@
+package httpapi_test
+
+import (
+	"database/sql"
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+)
+
+// setLiveOnPublish 直接改赛事库设置，等价于管理端 PUT /api/settings。
+// 走库而不是接口是为了让用例只关心结算行为，设置写入由 TestLiveOnPublishSwitchPersists 单独覆盖。
+func setLiveOnPublish(t *testing.T, env *testEnv, value bool) {
+	t.Helper()
+	env.exec(t, `INSERT INTO settings (key, value, updated_at) VALUES ('standings.live_on_publish', ?, datetime('now'))
+	            ON CONFLICT(key) DO UPDATE SET value = excluded.value`, map[bool]string{true: "true", false: "false"}[value])
+}
+
+type settlementStatus struct {
+	LiveOnPublish bool `json:"liveOnPublish"`
+	Groups        []struct {
+		EventID      int64  `json:"eventId"`
+		CategoryID   int64  `json:"categoryId"`
+		CategoryName string `json:"categoryName"`
+		Required     int    `json:"required"`
+		Published    int    `json:"published"`
+	} `json:"groups"`
+}
+
+func readSettlement(t *testing.T, env *testEnv, client *http.Client, eventID, categoryID int64) settlementStatus {
+	t.Helper()
+	status, resp := env.do(client, http.MethodGet,
+		fmt.Sprintf("/api/results/settlement?eventId=%d&categoryId=%d", eventID, categoryID), nil, false)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("读结算状态应 200，得到 %d %+v", status, resp.Error)
+	}
+	return decodeData[settlementStatus](t, resp)
+}
+
+func activeLedgerRows(t *testing.T, env *testEnv, eventID int64) int {
+	t.Helper()
+	var n int
+	if err := env.ev.QueryRow(
+		`SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, eventID).Scan(&n); err != nil {
+		t.Fatalf("统计流水: %v", err)
+	}
+	return n
+}
+
+func standingsTotal(t *testing.T, env *testEnv, client *http.Client) float64 {
+	t.Helper()
+	_, resp := env.do(client, http.MethodGet, "/api/standings", nil, false)
+	rows := decodeData[[]map[string]any](t, resp)
+	var total float64
+	for _, row := range rows {
+		total += row["totalPoints"].(float64)
+	}
+	return total
+}
+
+// rankOrZero 读名次：未发布的成绩没有名次（NULL），这里折算成 0，方便分批快照比较。
+func rankOrZero(t *testing.T, env *testEnv, entryID int64) int {
+	t.Helper()
+	var rank sql.NullInt64
+	if err := env.ev.QueryRow(`SELECT rank FROM results WHERE entry_id = ?`, entryID).Scan(&rank); err != nil {
+		t.Fatalf("读取名次: %v", err)
+	}
+	if !rank.Valid {
+		return 0
+	}
+	return int(rank.Int64)
+}
+
+func changeLogCountOf(t *testing.T, env *testEnv, entityType string) int {
+	t.Helper()
+	var n int
+	if err := env.ev.QueryRow(`SELECT COUNT(*) FROM change_log WHERE entity_type = ?`, entityType).Scan(&n); err != nil {
+		t.Fatalf("统计 change_log: %v", err)
+	}
+	return n
+}
+
+// 默认（设置键不存在）必须是历史行为：分批发一批，流水与榜当场就变。
+func TestLiveOnPublishDefaultIsRealTime(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	entries := seedBatch(t, env, ids, 8)
+	env.createUser("recorder", "recorder-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "recorder", "recorder-pass")
+
+	times := make([]float64, 8)
+	for i := range times {
+		times[i] = 12.0 + float64(i)*0.1
+	}
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, times),
+	}, true)
+	status, resp := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true)
+	if status != http.StatusOK || !resp.OK {
+		t.Fatalf("发布应 200，得到 %d %+v", status, resp.Error)
+	}
+
+	// 4 条已发布 = 4 条流水；前四名 10+8+6+3 = 27 分上榜。
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 4, ids.event)
+	if got := standingsTotal(t, env, client); got != 27 {
+		t.Fatalf("默认设置下发布一批后榜单总分 = %v，期望 27", got)
+	}
+	if got := changeLogCountOf(t, env, "standings"); got != 1 {
+		t.Fatalf("默认设置下发布应推 1 次榜单，得到 %d", got)
+	}
+	if got := rankOfEntry(t, env, entries[0]); got != 1 {
+		t.Fatalf("第一名应第 1 名，得到 %d", got)
+	}
+}
+
+// 开关默认（键不存在）与显式 true 必须逐字节一致：
+// 这是「加开关不能悄悄改变现场既有行为」的证明。
+func TestLiveOnPublishDefaultMatchesExplicitTrue(t *testing.T) {
+	// snapshot 是一次发布之后的可比状态：名次、流水、榜单原始字节、榜单推送次数。
+	type snapshot struct {
+		ranks     []int
+		ledger    []string
+		standings string
+		pushes    int
+	}
+	run := func(t *testing.T, value *bool) (afterFirst, afterSecond snapshot) {
+		t.Helper()
+		env := newTestEnv(t)
+		ids := env.seed(t)
+		entries := seedBatch(t, env, ids, 8)
+		if value != nil {
+			setLiveOnPublish(t, env, *value)
+		}
+		env.createUser("recorder", "recorder-pass", "recorder")
+		client, _ := env.client()
+		env.login(client, "recorder", "recorder-pass")
+
+		read := func() snapshot {
+			t.Helper()
+			var snap snapshot
+			for _, id := range entries {
+				snap.ranks = append(snap.ranks, rankOrZero(t, env, id))
+			}
+			rows, err := env.ev.Query(
+				`SELECT entry_id, team_id, points FROM score_ledger WHERE event_id = ? AND voided = 0 ORDER BY entry_id, team_id`, ids.event)
+			if err != nil {
+				t.Fatalf("读流水: %v", err)
+			}
+			defer func() { _ = rows.Close() }()
+			for rows.Next() {
+				var entryID, teamID int64
+				var points float64
+				if err := rows.Scan(&entryID, &teamID, &points); err != nil {
+					t.Fatalf("扫描流水: %v", err)
+				}
+				snap.ledger = append(snap.ledger, fmt.Sprintf("%d/%d/%v", entryID, teamID, points))
+			}
+			if err := rows.Err(); err != nil {
+				t.Fatalf("遍历流水: %v", err)
+			}
+			snap.standings = rawData(t, env, client, "/api/standings")
+			snap.pushes = changeLogCountOf(t, env, "standings")
+			return snap
+		}
+
+		slow := make([]float64, 8)
+		fast := make([]float64, 8)
+		for i := range slow {
+			slow[i] = 12.0 + float64(i)*0.1
+			fast[i] = 10.0 + float64(i)*0.1
+		}
+		env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+			"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, slow),
+		}, true)
+		env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+			"eventId": ids.event, "categoryId": ids.category,
+		}, true)
+		afterFirst = read()
+
+		env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+			"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 8, 4, fast),
+		}, true)
+		env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+			"eventId": ids.event, "categoryId": ids.category,
+		}, true)
+		afterSecond = read()
+		return afterFirst, afterSecond
+	}
+
+	assertSame := func(t *testing.T, label string, absent, explicit snapshot) {
+		t.Helper()
+		if !reflect.DeepEqual(absent.ranks, explicit.ranks) {
+			t.Fatalf("%s：名次不一致：默认 %v vs 显式 true %v", label, absent.ranks, explicit.ranks)
+		}
+		if !reflect.DeepEqual(absent.ledger, explicit.ledger) {
+			t.Fatalf("%s：流水不一致：默认 %v vs 显式 true %v", label, absent.ledger, explicit.ledger)
+		}
+		if absent.standings != explicit.standings {
+			t.Fatalf("%s：榜单字节不一致：\n默认  %s\n显式  %s", label, absent.standings, explicit.standings)
+		}
+		if absent.pushes != explicit.pushes {
+			t.Fatalf("%s：榜单推送次数不一致：默认 %d vs 显式 true %d", label, absent.pushes, explicit.pushes)
+		}
+	}
+
+	absentFirst, absentSecond := run(t, nil)
+	explicit := true
+	trueFirst, trueSecond := run(t, &explicit)
+	assertSame(t, "第一批", absentFirst, trueFirst)
+	assertSame(t, "第二批", absentSecond, trueSecond)
+
+	// 反向证明这份快照确实受开关控制，否则上面的「一致」可能只是两条路径都坏了。
+	// 关掉开关后第一批只发 4/8：名次照写（延迟结算只省流水与榜单），流水必须为空、榜单必须不动。
+	off := false
+	offFirst, _ := run(t, &off)
+	if len(offFirst.ledger) != 0 {
+		t.Fatalf("关闭开关后第一批不该写流水，得到 %v", offFirst.ledger)
+	}
+	if offFirst.pushes != 0 {
+		t.Fatalf("关闭开关后第一批不该推榜单，得到 %d 次", offFirst.pushes)
+	}
+	if offFirst.standings == absentFirst.standings {
+		t.Fatalf("关闭开关后榜单应与默认不同，得到同一份：%s", offFirst.standings)
+	}
+}
+
+// 延迟结算：第一批只落成绩，名次 / 流水 / 榜单都不动；
+// 第二批录完自动结算，整组重算并把名次与榜单补上。
+func TestDeferredSettlementWaitsForWholeGroup(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	entries := seedBatch(t, env, ids, 8)
+	setLiveOnPublish(t, env, false)
+	env.createUser("recorder", "recorder-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "recorder", "recorder-pass")
+
+	slow := make([]float64, 8)
+	fast := make([]float64, 8)
+	for i := range slow {
+		slow[i] = 12.0 + float64(i)*0.1
+		fast[i] = 10.0 + float64(i)*0.1
+	}
+	// 发布之前的榜单原始字节：延迟结算下这批发布不允许改动它（含奖牌列）。
+	beforeStandings := rawData(t, env, client, "/api/standings")
+
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, slow),
+	}, true)
+	if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("第一批发布应 200，得到 %d %+v", status, e.Error)
+	}
+
+	// 成绩要上屏（可以看到时间），但名次 / 流水 / 榜单都要等结算。
+	assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND state = 'published'`, 4, ids.event)
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 0, ids.event)
+	assertCount(t, env, `SELECT COUNT(*) FROM change_log WHERE entity_type = 'standings'`, 0)
+	// 名次不写：奖牌榜统计读的就是 results.rank，分批写名次会让奖牌列跟总分对不上。
+	assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND rank IS NOT NULL`, 0, ids.event)
+	if got := rawData(t, env, client, "/api/standings"); got != beforeStandings {
+		t.Fatalf("延迟结算下榜单不该动：\n发布前 %s\n发布后 %s", beforeStandings, got)
+	}
+
+	// 未结算清单要能查到这一组。
+	first := readSettlement(t, env, client, ids.event, ids.category)
+	if first.LiveOnPublish {
+		t.Fatalf("设置已关闭，接口应回报 liveOnPublish=false: %+v", first)
+	}
+	if len(first.Groups) != 1 || first.Groups[0].Required != 8 || first.Groups[0].Published != 4 {
+		t.Fatalf("未结算清单应含 4/8 的该组，得到 %+v", first.Groups)
+	}
+
+	// 第二批录完 → 自动结算：整组重算，流水齐全，榜单正确。
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 8, 4, fast),
+	}, true)
+	if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("第二批发布应 200，得到 %d %+v", status, e.Error)
+	}
+
+	assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND state = 'published'`, 8, ids.event)
+	// 前六名得分 10+8+6+3+2+1 = 30，共 6 条流水。
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
+	if got := standingsTotal(t, env, client); got != 30 {
+		t.Fatalf("结算后榜单总分 = %v，期望 30", got)
+	}
+	if got := changeLogCountOf(t, env, "standings"); got != 1 {
+		t.Fatalf("结算应推 1 次榜单，得到 %d", got)
+	}
+	// 整组重算的证明：第二批更快，第一批第一名退到第 5 名。
+	if got := rankOfEntry(t, env, entries[4]); got != 1 {
+		t.Fatalf("第二批最快者应第 1 名，得到 %d", got)
+	}
+	if got := rankOfEntry(t, env, entries[0]); got != 5 {
+		t.Fatalf("第一批第一名应退到第 5 名，得到 %d", got)
+	}
+	if got := readSettlement(t, env, client, ids.event, ids.category); len(got.Groups) != 0 {
+		t.Fatalf("结算后未结算清单应为空，得到 %+v", got.Groups)
+	}
+}
+
+// 有人弃权（scratched）时不该再等他：7 人录完 + 1 人退赛也算全组录完，自动结算。
+func TestDeferredSettlementTreatsScratchedAsFinished(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	entries := seedBatch(t, env, ids, 8)
+	setLiveOnPublish(t, env, false)
+	env.createUser("recorder", "recorder-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "recorder", "recorder-pass")
+
+	// 第 8 人退赛（与前端「批量退赛」同一条接口）。
+	if status, e := env.do(client, http.MethodPost, "/api/entries/batch", map[string]any{
+		"action": "scratch", "ids": []int64{entries[7]},
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("批量退赛应 200，得到 %d %+v", status, e.Error)
+	}
+
+	times := make([]float64, 8)
+	for i := range times {
+		times[i] = 12.0 + float64(i)*0.1
+	}
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 7, 0, times),
+	}, true)
+	if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("发布应 200，得到 %d %+v", status, e.Error)
+	}
+
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
+	if got := standingsTotal(t, env, client); got != 30 {
+		t.Fatalf("退赛者不该阻塞结算，榜单总分 = %v，期望 30", got)
+	}
+	if got := readSettlement(t, env, client, ids.event, ids.category); len(got.Groups) != 0 {
+		t.Fatalf("全组（含退赛）录完后清单应为空，得到 %+v", got.Groups)
+	}
+}
+
+// 发布之后才标退赛：整组因此录完，退赛动作本身也要把这组结算掉，不能停在空流水上。
+func TestScratchAfterDeferredPublishSettlesGroup(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	entries := seedBatch(t, env, ids, 8)
+	setLiveOnPublish(t, env, false)
+	env.createUser("recorder", "recorder-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "recorder", "recorder-pass")
+
+	times := make([]float64, 8)
+	for i := range times {
+		times[i] = 12.0 + float64(i)*0.1
+	}
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 7, 0, times),
+	}, true)
+	env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true)
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 0, ids.event)
+
+	if status, e := env.do(client, http.MethodPost, "/api/entries/batch", map[string]any{
+		"action": "scratch", "ids": []int64{entries[7]},
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("批量退赛应 200，得到 %d %+v", status, e.Error)
+	}
+
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
+	if got := standingsTotal(t, env, client); got != 30 {
+		t.Fatalf("退赛补全整组后应结算，榜单总分 = %v，期望 30", got)
+	}
+}
+
+// 立即结算是延迟结算的人工兜底：按当前已发布成绩结算，并写审计。
+func TestManualSettleUsesPublishedResults(t *testing.T) {
+	env := newTestEnv(t)
+	ids := env.seed(t)
+	entries := seedBatch(t, env, ids, 8)
+	setLiveOnPublish(t, env, false)
+	env.createUser("recorder", "recorder-pass", "recorder")
+	client, _ := env.client()
+	env.login(client, "recorder", "recorder-pass")
+
+	times := make([]float64, 8)
+	for i := range times {
+		times[i] = 12.0 + float64(i)*0.1
+	}
+	env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, times),
+	}, true)
+	env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, true)
+
+	if status, e := env.do(client, http.MethodPost, "/api/results/settle", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category, "requestId": "settle-1",
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("立即结算应 200，得到 %d %+v", status, e.Error)
+	}
+
+	// 只有 4 条已发布 → 前四名 10+8+6+3 = 27 分。
+	assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 4, ids.event)
+	if got := standingsTotal(t, env, client); got != 27 {
+		t.Fatalf("立即结算后榜单总分 = %v，期望 27", got)
+	}
+	waitAudit(t, env, "result.settle", ids.event)
+
+	// 未登录不能结算。
+	guest, _ := env.client()
+	if status, _ := env.do(guest, http.MethodPost, "/api/results/settle", map[string]any{
+		"eventId": ids.event, "categoryId": ids.category,
+	}, false); status != http.StatusUnauthorized {
+		t.Fatalf("未登录结算应 401，得到 %d", status)
+	}
+}
+
+// 开关键写入 / 读出：PUT /api/settings 落库后 GET 要能读回，且缺键默认 true。
+func TestLiveOnPublishSwitchPersists(t *testing.T) {
+	env := newTestEnv(t)
+	env.seed(t)
+	env.createUser("admin", "admin-pass", "admin")
+	client, _ := env.client()
+	env.login(client, "admin", "admin-pass")
+
+	read := func() bool {
+		t.Helper()
+		_, resp := env.do(client, http.MethodGet, "/api/settings", nil, false)
+		settings := decodeData[map[string]any](t, resp)
+		return settings["standings"].(map[string]any)["liveOnPublish"].(bool)
+	}
+	if !read() {
+		t.Fatalf("缺键时 liveOnPublish 应默认 true")
+	}
+
+	if status, e := env.do(client, http.MethodPut, "/api/settings", map[string]any{
+		"standings": map[string]any{"liveOnPublish": false},
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("关闭开关应 200，得到 %d %+v", status, e.Error)
+	}
+	if read() {
+		t.Fatalf("关闭后 liveOnPublish 应读回 false")
+	}
+	// 只改一个字段不能把榜单口径的其余取值抹掉。
+	_, resp := env.do(client, http.MethodGet, "/api/settings", nil, false)
+	standings := decodeData[map[string]any](t, resp)["standings"].(map[string]any)
+	if standings["individualToTeamWeight"].(float64) != 1 || standings["rankingMode"] != "points" {
+		t.Fatalf("其余榜单口径不应被改动: %+v", standings)
+	}
+
+	if status, e := env.do(client, http.MethodPut, "/api/settings", map[string]any{
+		"standings": map[string]any{"liveOnPublish": true},
+	}, true); status != http.StatusOK || !e.OK {
+		t.Fatalf("重新打开应 200，得到 %d %+v", status, e.Error)
+	}
+	if !read() {
+		t.Fatalf("重新打开后 liveOnPublish 应读回 true")
+	}
+}