fix(display,entry): 修大屏团体名次显示「-」与分项成绩第 3 栏缺第 1 名；发布改弹窗选口径；会话设备名与重命名；录分搜索框；版本 dev_0.5.15

本批七项（三处是现场报的 bug，四处是新功能）：

① 大屏上「纯团体项目」（如团体 4x100 接力）的名次全是「-」
   根因不在算分：纯团体名次只落在 channel_ranks，而 results.rank 被有意收窄成
   「个人名次」、对团体主体一直是 NULL；大屏的两个读者只读 results.rank、没有兜底
   （导出件与积分明细下钻早就有兜底，所以当时是「导出有、屏幕没有」）。
   改成读侧回落：results.rank 优先、为空时用通道名次。算分与写回一行未动。
   ⚠️ 优先级的理由：只更新名次的发布只更新 results.rank、不重建通道名次，
   若通道名次优先，个人项目会在那种发布之后显示旧名次。
   ⚠️ 已发布的数据不需要重发或重算，升级后大屏下一次刷新即显示。
   ⚠️ 仍未覆盖：只在「团体名次」卡片里按单位录名次、成绩行上没填的那类（无成绩行可挂）。

② 分项成绩页第 3 栏看不到第 1 名
   根因：快照 latestResults 的窗口原来按「行」截断（LIMIT 20），而屏上是一组一栏，
   切口只能落在最旧那一栏（通常是第 3 栏）内部，把该组建号最早的行挤掉
   （手录项目从第 1 名往下录 → 第 1 名建号最早）。
   改成「最近 8 组 × 每组 10 行」（先按每组最新发布时间取 8 组，再每组按名次取前 10 行）；
   组的 publishedAt 改为组内最新一条。底栏「最新完成项目」一起吃这个修复。
   ⚠️ 取舍：单组超过 10 行的部分不再下发（前端每栏只画 6 行、实时赛况上限 10 行）；
   将来把每栏行数上限调到 10 以上时，必须同步调这里的 R。

③ 录分列表「运动员 / 队」列可限宽 + 逐行展开收起
   多人团体名单以前把整列撑宽。收起限宽 14em（省略号）、超过 24 个显示宽度
   （中文算 2）出现「展开 / 收起」；个人项目不出现按钮；展开状态只在本机内存。
   取舍：展开那一行会把列略微撑宽（成绩列右移约 80px），收起即恢复。

④ 录入页「以决赛成绩发布」从常驻勾选框改成发布弹窗里二选一
   默认「只更新名次（不计分、不发奖牌）」；每次打开都复位、不吃上一次；
   Alt+Enter 走同一个入口；取消 = 什么都不发生。
   审核页保持原样的常驻勾选框（两个页面口径一样、形态不同）。

⑤ 大屏控制页「在线大屏」列表：可读设备名 + 手动重命名 + 修重复条目
   - 自动设备标签（系统 · 浏览器 · 分辨率 · 手机/平板/桌面），由大屏端在握手时上报，
     服务端截断到 80/300 字符并清掉控制字符；老客户端不报时列表与升级前逐字一致。
     ⚠️ 浏览器没有读主机名/设备名的 API，自动标签只是辅助区分。
   - 手动重命名（录入员及以上，与切页同档）：存在系统库 settings 的
     display.instance_aliases（机器级、重启与切赛事都不丢），清除即回到自动标签；
     显示优先级 alias → device → id（id 降级成小字）。上限 200 条，满了拒绝新增并提示，
     不静默顶掉别的设备。设备离线过久条目被清理后别名仍留着。
   - 修：以前给局域网设备切页后列表底部会多出一条该设备的离线条目
     （翻页会补发握手，而浏览器没有稳定 id、服务端每次新开一条实例）。
     现在浏览器本机记住实例 id（localStorage），服务端也复用同一条连接已有的 id。

⑥ 局域网地址条目都能出二维码
   以前只有第一条常驻出码；现在其余每条多一个「二维码」按钮：点一下临时显示，
   再点一次 / Esc / 点空白处收起，同一时刻只留一个，且只为当前打开的那条懒生成 SVG
   （不在渲染时为每条地址都算一遍）。第一条的常驻码与「复制链接」未变。

⑦ 录分列表加「搜姓名 / 号码布」搜索框（人多项目找人不费劲）
   复用既有的「姓名 / 工号 / 号码布」匹配口径（未新增第三份），支持模糊、大小写不敏感、
   全角空格、号码布数字口径（007 搜 7、7 搜 007）；命中高亮；提示「找到 N 条 / 共 M 条」；
   × / Esc / 清除三种清空方式；搜不到给明确空状态。
   ⚠️ 搜索只影响表格显示：发布范围、进度条（仍是该批次总人数）、勾选、清空范围、
      预览算分一律不受影响，界面上也写明了这一点。
   ⚠️ 搜索状态下粘贴跟随「屏幕上看到的顺序」（隐藏的行不会被写到）——避免第二条成绩
      静默写到看不见的人身上。

测试：四套自检 ×2 全绿（finalcheck_0515*.log：前端 1096 例 / Console 96 例 / 服务端 14 条 ok，
EXIT=0）。①②都做了红/绿对照（改回旧实现，新用例当场变红；②的失败信息即现场形状
「第 3 栏应从第 1 名开始，实际名次 [5 6 7 8]」）。⑥⑦用真浏览器（playwright + chromium）
实机跑过（24 项 / 29 项全过，含「进度条数字不变」「搜索框里按 Alt+Enter 什么也不发生」）。

无数据库迁移；已有成绩、名次、积分与榜单不变。
文档：《升级说明》新增 dev_0.5.15；《使用手册》发布/录入/大屏控制三块与批量订正过期说法；
《常见问题》新增 Q105–Q107；《部署指南》《上线检查清单》同步；
devdocs/05（hello 新字段 + 别名接口）、13（第五十五轮）、16/06/07/18 与两处前端注释的旧窗口说法一并订正。

server/internal/realtime/hub.go

@@ -511,7 +511,12 @@ func (h *Hub) handleHello(ctx context.Context, c *client, p helloPayload) {
 		if id == "" {
 			id = p.DisplayKey
 		}
-		h.registerDisplay(c, id, p.Page, p.Screen)
+		h.registerDisplay(c, id, displayRegistration{
+			page:      p.Page,
+			screen:    p.Screen,
+			device:    p.Device,
+			deviceRaw: p.DeviceRaw,
+		})
 		h.join(c, RoomDisplay)
 	}
 

server/internal/realtime/instances.go

@@ -30,6 +30,14 @@ type Instance struct {
 	// 管理端靠它把「本机显示器」与「在线实例」对上；局域网浏览器直接开 /display 时为空串。
 	// 用字符串而不是数字：显示器的 id 由 Electron 给，不保证是小的正整数。
 	Screen string `json:"screen"`
+	// Device 是浏览器报上来的设备标签（`安卓 13 · Chrome 120 · 1080×2400 @3x · 手机`），
+	// DeviceRaw 是原始 UA。老客户端不报时**整个键不出现**（omitempty），管理端列表退回显示 id。
+	Device    string `json:"device,omitempty"`
+	DeviceRaw string `json:"deviceRaw,omitempty"`
+	// Alias 是操作员手动起的名字。它**不住在注册表里**：注册表是内存的、实例过期即清理，
+	// 而别名是机器级的、必须活过重启与实例过期，所以由 httpapi 从系统库设置里读出来，
+	// 在返回列表时按实例 id 填进来（见 httpapi 的 loadInstanceAliases）。
+	Alias string `json:"alias,omitempty"`
 }
 
 // instanceState 是注册表的内部记录；同一 instanceId 的多条连接合并成一个实例。
@@ -37,6 +45,8 @@ type instanceState struct {
 	id            string
 	page          string
 	screen        string
+	device        string
+	deviceRaw     string
 	connectedAt   time.Time
 	lastHeartbeat time.Time
 	remoteAddr    string
@@ -45,24 +55,45 @@ type instanceState struct {
 	conns         int
 }
 
-// registerDisplay 把连接挂到大屏实例上；未带 instanceId 时由服务端生成，
-// 保证「刷新页面 = 同一实例」之外的连接也能被登记和查询。
-func (h *Hub) registerDisplay(c *client, id, page, screen string) string {
+// displayRegistration 是登记一个实例要用的 hello 字段。
+// 单独一个结构体而不是直接传 helloPayload：注册表只关心「在哪一页、哪块屏、什么设备」，
+// role / lastVersion 那些与它无关。
+type displayRegistration struct {
+	page      string
+	screen    string
+	device    string
+	deviceRaw string
+}
+
+// registerDisplay 把连接挂到大屏实例上。
+//
+// id 为空（局域网浏览器直接开 /display，URL 上没有 instance / screen）时**优先复用这条连接
+// 已经在用的实例 id**，只有从没用过才现生成一个：客户端翻页（setPage）与补齐设备标签都会
+// 再发一次 hello，而每次 hello 都现生成 `display-<随机>` 的话，老实例会永远留在注册表里
+// 变成一条「离线条目」（TTL 十分钟才清理），管理端「在线大屏」底下就凭空多出一条同一台
+// 设备的离线记录。刷新页面等新连接仍然各自登记，不会因此查不到。
+func (h *Hub) registerDisplay(c *client, id string, reg displayRegistration) string {
+	c.mu.Lock()
+	if id == "" {
+		id = c.instanceID
+	}
 	if id == "" {
 		id = "display-" + randomID()
 	}
-	now := time.Now()
-
-	c.mu.Lock()
 	prev := c.instanceID
 	c.instanceID = id
 	c.mu.Unlock()
 
 	// 同一连接重复 hello 或换了 instanceId 时，先归还旧实例的引用，避免计数虚高。
+	// 复用同一条 id 时 prev == id，引用计数不动——这正是「重复 hello 不许产生新实例」的一半。
 	if prev != "" && prev != id {
 		h.releaseDisplayID(prev, c)
 	}
 
+	device := sanitizeDeviceText(reg.device, maxDeviceChars)
+	deviceRaw := sanitizeDeviceText(reg.deviceRaw, maxDeviceRawChars)
+
+	now := time.Now()
 	h.mu.Lock()
 	defer h.mu.Unlock()
 	h.pruneInstancesLocked(now)
@@ -74,11 +105,19 @@ func (h *Hub) registerDisplay(c *client, id, page, screen string) string {
 	if prev != id {
 		st.conns++
 	}
-	if page != "" {
-		st.page = page
+	if reg.page != "" {
+		st.page = reg.page
 	}
-	if screen != "" {
-		st.screen = screen
+	if reg.screen != "" {
+		st.screen = reg.screen
+	}
+	// 设备标签只在这次报了非空值时覆盖：老客户端（以及 localStorage 不可用的客户端）
+	// 不带这两个字段，不该把上一次 hello 报上来的标签抹掉。
+	if device != "" {
+		st.device = device
+	}
+	if deviceRaw != "" {
+		st.deviceRaw = deviceRaw
 	}
 	st.lastHeartbeat = now
 	st.remoteAddr = c.remoteAddr
@@ -234,6 +273,8 @@ func (h *Hub) Instances() []Instance {
 			AckVersion:    st.ackVersion,
 			Slow:          st.slow,
 			Screen:        st.screen,
+			Device:        st.device,
+			DeviceRaw:     st.deviceRaw,
 		})
 	}
 	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })

server/internal/realtime/instances_test.go

@@ -0,0 +1,173 @@
+package realtime
+
+import (
+	"strings"
+	"testing"
+)
+
+// ---------- 设备字段的清洗与截断 ----------
+
+func TestSanitizeDeviceText(t *testing.T) {
+	longUA := strings.Repeat("汉", 400)
+	cases := []struct {
+		name  string
+		in    string
+		limit int
+		want  string
+	}{
+		{"原样保留可读标签", "安卓 13 · Chrome 120 · 1080×2400 @3x · 手机", maxDeviceChars,
+			"安卓 13 · Chrome 120 · 1080×2400 @3x · 手机"},
+		// 控制字符是能把管理端列表排版搞乱的东西（换行 / 制表 / 退格 / DEL），一律清掉。
+		{"换行与制表被清掉", "  安卓 13\n\tChrome 120 \r\n", maxDeviceChars, "安卓 13Chrome 120"},
+		{"DEL 与 C0 控制字符被清掉", "安卓\x00\x1b[31m 13\x7f", maxDeviceChars, "安卓[31m 13"},
+		{"首尾空白去掉", "  平板  ", maxDeviceChars, "平板"},
+		{"只空白视作没报", " \t\n ", maxDeviceChars, ""},
+		{"空串保持空串", "", maxDeviceChars, ""},
+		// 长度按**字符**不是字节：按字节截会把中文腰斩成半个字。
+		{"按字符截断（中文）", strings.Repeat("汉", 81), maxDeviceChars, strings.Repeat("汉", 80)},
+		{"恰好等于上限不截断", strings.Repeat("x", maxDeviceChars), maxDeviceChars, strings.Repeat("x", maxDeviceChars)},
+		{"超长 UA 截到 300 字符", longUA, maxDeviceRawChars, strings.Repeat("汉", maxDeviceRawChars)},
+		{"limit <= 0 不截断", strings.Repeat("x", 10), 0, strings.Repeat("x", 10)},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := sanitizeDeviceText(tc.in, tc.limit)
+			if got != tc.want {
+				t.Fatalf("清洗结果不符:\n得到 %q\n期望 %q", got, tc.want)
+			}
+		})
+	}
+}
+
+// 截断结果必须是合法 UTF-8（半个汉字会显示成替换方块）。
+func TestSanitizeDeviceTextKeepsValidUTF8(t *testing.T) {
+	got := sanitizeDeviceText(strings.Repeat("平板", 100), 5)
+	if got != "平板平板平" {
+		t.Fatalf("按字符截断结果应为 %q，得到 %q", "平板平板平", got)
+	}
+	for _, r := range got {
+		if r == '\uFFFD' {
+			t.Fatalf("截断后出现无效 UTF-8 字节: %q", got)
+		}
+	}
+}
+
+// ---------- 同一条连接重复 hello 不许产生新实例 ----------
+
+// 局域网浏览器（hello 不带 instanceId）翻页后 setPage 会再补一条 hello，
+// 第二次 hello 必须落在**同一个**实例上，否则注册表里会多出一条该设备的离线条目。
+func TestRegisterDisplayReusesInstanceForRepeatHelloWithoutID(t *testing.T) {
+	env := newTestEnv(t)
+	env.hub.SetSnapshotMinInterval(0)
+
+	c := env.dial(t, &helloPayload{Role: RoleDisplay, Page: "standings"})
+	c.recvEvent(EventSnapshot)
+
+	first := env.hub.Instances()
+	if len(first) != 1 {
+		t.Fatalf("首次 hello 后应只有一个实例，得到 %d 个: %+v", len(first), first)
+	}
+	if !strings.HasPrefix(first[0].ID, "display-") {
+		t.Fatalf("不带 instanceId 时实例 id 应由服务端生成，得到 %s", first[0].ID)
+	}
+
+	// 第二次仍不带 instanceId（真实场景：翻页补发的 hello，端上没有本机 id）。
+	c.send(EventHello, helloPayload{Role: RoleDisplay, Page: "medals"})
+	c.recvEvent(EventSnapshot)
+
+	got := env.hub.Instances()
+	if len(got) != 1 {
+		t.Fatalf("重复 hello 后注册表里应仍只有一个实例（旧实现会多出一条离线条目），得到 %d 个: %+v",
+			len(got), got)
+	}
+	if got[0].ID != first[0].ID {
+		t.Fatalf("重复 hello 应复用同一个实例 id：首次 %s，第二次 %s", first[0].ID, got[0].ID)
+	}
+	if !got[0].Online {
+		t.Fatalf("重复 hello 后实例应仍在线: %+v", got[0])
+	}
+	if got[0].Page != "medals" {
+		t.Fatalf("重复 hello 应刷新当前页为 medals，得到 %s", got[0].Page)
+	}
+
+	// 引用计数不能虚高：连接断开后实例必须立刻变成离线（虚高会显示成「还挂着一条连接」）。
+	c.close()
+	waitFor(t, "重复 hello 后实例仍能正确离线", func() bool {
+		insts := env.hub.Instances()
+		return len(insts) == 1 && !insts[0].Online
+	})
+}
+
+// 换了 instanceId 的连接仍然各自登记：复用只针对「这次没带 id」，不能把显式换 id 吃掉。
+func TestRegisterDisplaySwitchesInstanceWhenIDChanges(t *testing.T) {
+	env := newTestEnv(t)
+	env.hub.SetSnapshotMinInterval(0)
+
+	c := env.dial(t, &helloPayload{Role: RoleDisplay, InstanceID: "screen-1"})
+	c.recvEvent(EventSnapshot)
+	c.send(EventHello, helloPayload{Role: RoleDisplay, InstanceID: "screen-2"})
+	c.recvEvent(EventSnapshot)
+
+	insts := env.hub.Instances()
+	if len(insts) != 2 {
+		t.Fatalf("换 id 后应有两个实例，得到 %d 个: %+v", len(insts), insts)
+	}
+	if !instanceOnline(insts, "screen-2") {
+		t.Fatalf("新 id 应在线: %+v", insts)
+	}
+	// 旧实例的连接引用已归还，只剩「离线」的排查记录。
+	if instanceOnline(insts, "screen-1") {
+		t.Fatalf("旧 id 的连接引用应已归还，不该仍显示在线: %+v", insts)
+	}
+}
+
+// ---------- 设备字段进注册表 ----------
+
+func TestRegisterDisplayStoresSanitizedDevice(t *testing.T) {
+	env := newTestEnv(t)
+	env.hub.SetSnapshotMinInterval(0)
+
+	c := env.dial(t, &helloPayload{
+		Role:       RoleDisplay,
+		InstanceID: "pc-1",
+		Device:     "安卓 13\n · Chrome 120\t",
+		DeviceRaw:  "Mozilla/5.0 (Linux; Android 13)" + strings.Repeat("x", 400),
+	})
+	c.recvEvent(EventSnapshot)
+
+	insts := env.hub.Instances()
+	if len(insts) != 1 {
+		t.Fatalf("实例数应为 1，得到 %d", len(insts))
+	}
+	if insts[0].Device != "安卓 13 · Chrome 120" {
+		t.Fatalf("设备标签应清洗掉换行与制表，得到 %q", insts[0].Device)
+	}
+	if n := len([]rune(insts[0].DeviceRaw)); n != maxDeviceRawChars {
+		t.Fatalf("原始 UA 应按字符截到 %d，得到 %d 个字符", maxDeviceRawChars, n)
+	}
+	if strings.ContainsAny(insts[0].DeviceRaw, "\n\t") {
+		t.Fatalf("原始 UA 不该含控制字符: %q", insts[0].DeviceRaw)
+	}
+
+	// 老客户端（不带这两个字段）重连：不该把已经报上来的标签抹掉。
+	c.send(EventHello, helloPayload{Role: RoleDisplay, InstanceID: "pc-1"})
+	c.recvEvent(EventSnapshot)
+	if got := env.hub.Instances()[0]; got.Device == "" || got.DeviceRaw == "" {
+		t.Fatalf("不带设备字段的重复 hello 不该清空已有标签: %+v", got)
+	}
+}
+
+// 老客户端（不带 device / deviceRaw）行为与今天一致：字段留空，注册表照常登记。
+func TestRegisterDisplayWithoutDeviceFields(t *testing.T) {
+	env := newTestEnv(t)
+	c := env.dial(t, &helloPayload{Role: RoleDisplay, InstanceID: "old-1"})
+	c.recvEvent(EventSnapshot)
+
+	insts := env.hub.Instances()
+	if len(insts) != 1 || insts[0].ID != "old-1" || !insts[0].Online {
+		t.Fatalf("老客户端应照常登记: %+v", insts)
+	}
+	if insts[0].Device != "" || insts[0].DeviceRaw != "" {
+		t.Fatalf("老客户端没报设备字段时应留空: %+v", insts[0])
+	}
+}

server/internal/realtime/protocol.go

@@ -7,7 +7,9 @@ package realtime
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 	"time"
+	"unicode"
 )
 
 // 事件名与协议第 3 节的表格一一对应。
@@ -107,6 +109,64 @@ type helloPayload struct {
 	Page        string `json:"page,omitempty"`
 	// Screen 是 Console 从 URL 带下来的屏号（screen=<display.id>），局域网浏览器留空。
 	Screen string `json:"screen,omitempty"`
+	// Device 是浏览器自己拼好的设备标签（`安卓 13 · Chrome 120 · 1080×2400 @3x · 手机`），
+	// DeviceRaw 是原始 UA（排障用）。两者都 omitempty：**老客户端不带这两个字段，服务端行为
+	// 与今天逐字一致**（管理端列表退回显示实例 id）。
+	//
+	// 服务端不解析 UA，但也不能全信这两个值：它们是客户端自报的自由文本，会直接进管理端列表。
+	// 长度按**字符**截断、控制字符一律清掉，收口在 sanitizeDeviceText（registerDisplay 调用）。
+	Device    string `json:"device,omitempty"`
+	DeviceRaw string `json:"deviceRaw,omitempty"`
+}
+
+// 客户端自报文本的长度上限，按**字符**（rune）不是字节算：
+// `安卓 13 · Chrome 120` 这种标签按字节截会切出半个汉字，显示成乱码方框。
+const (
+	maxDeviceChars    = 80
+	maxDeviceRawChars = 300
+)
+
+// CleanUserText 清洗客户端自报的自由文本：去掉全部控制字符（换行、制表、退格、DEL…）与首尾空白。
+//
+// 这些值最终要显示在管理端「在线大屏」列表里，一个带换行的 device 能把整行排版顶歪；
+// 服务端是唯一的收口处，不能指望每个客户端都干净。TrimSpace 之后为空即视作「没报」，返回空串。
+//
+// 保留字符间的普通空格与各种可见符号：设备标签本来就长这样，不该被服务端改写。
+func CleanUserText(s string) string {
+	if s == "" {
+		return ""
+	}
+	var b strings.Builder
+	b.Grow(len(s))
+	for _, r := range s {
+		if unicode.IsControl(r) {
+			continue
+		}
+		b.WriteRune(r)
+	}
+	return strings.TrimSpace(b.String())
+}
+
+// TruncateChars 按字符（rune）截断到 maxChars 个；maxChars <= 0 表示不截断。
+// 会切断代理对时以整字符为界（Go 的 range 只落在字符起始字节上），不会切出半个 UTF-8 序列。
+func TruncateChars(s string, maxChars int) string {
+	if maxChars <= 0 {
+		return s
+	}
+	count := 0
+	for i := range s {
+		if count == maxChars {
+			return s[:i]
+		}
+		count++
+	}
+	return s
+}
+
+// sanitizeDeviceText 是 hello 里设备字段的收口：先清洗再截断。
+// 没有这两个字段的老客户端拿到的是空串，注册表按「没报」处理。
+func sanitizeDeviceText(s string, maxChars int) string {
+	return TruncateChars(CleanUserText(s), maxChars)
 }
 
 // ackPayload 是 C→S 的 ack 载荷；服务端据此识别慢客户端。

server/internal/realtime/snapshot.go

@@ -14,9 +14,28 @@ import (
 	"git.yeij.top/AskaEth/Scoreboard/server/internal/dto"
 )
 
-// latestResultsLimit 控制快照里「最新成绩」的行数上限，避免大屏首包过大。
-// 行会按「小项 + 组别」聚合后再下发，因此组数只会比这个值更少。
-const latestResultsLimit = 20
+// 快照「最新成绩」的窗口口径：先取最近发布的 K 组，再每组保底取前 R 行。
+//
+// 不能按「总行数」截断：行是按发布时间倒序取的，而组是按「首次出现」建号的，
+// 于是组数组的顺序 = 发布时间倒序——**屏上最旧的那一栏站在窗口尾部**，行数截断的切口
+// 只会落进那一组里，把「建号最早的行」切掉。手录名次的项目通常从第 1 名往下录，
+// 第 1 名的 results.id 最小 → 现场表现就是「最旧那一栏看不到第 1 名、从第 2 名开始」，
+// 且症状跟着**栏位**走（同一批项目挪到前面几栏就正常）。
+//
+// 最坏情况下快照下发 8 × 10 = 80 行（旧口径是全局 20 行），首包因此变大；
+// 换来的是每一组都从第 1 名开始，不再有「最旧一栏少一行」。
+const (
+	// latestResultsGroupLimit 保留的**组数**上限。一组 = 一个小项 + 一个组别，即大屏的一栏。
+	// 前端单屏最多 4 栏（web/src/display/useScoreboard.ts 把 resultsCount 夹在 1..4），
+	// 底栏只需最新一组；留一倍余量给「刚发布、还没轮到显示」的组，取 8。
+	latestResultsGroupLimit = 8
+
+	// latestResultsRowsPerGroup 每组保留的**行数**上限，按名次取前 R 行。
+	// 前端每栏只画 6 行（web/src/display/results.ts 的 RESULT_ROWS_PER_COLUMN），
+	// 并列名次会让一栏超过 6 行；实时赛况页的同一批数据上限是 10 行
+	// （web/src/display/live.ts 的 MAX_LIVE_ROWS），兜底取 10。
+	latestResultsRowsPerGroup = 10
+)
 
 // Snapshot 是 snapshot 事件的 data，也是客户端冷启动的完整状态。
 // 字段名与协议第 3 节一致；settings/standings/latestResults 的形状必须与 REST 同构，
@@ -423,15 +442,82 @@ func loadRecords(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
 	return rows.Err()
 }
 
+// mainChannelRankJoin 是大屏成绩行上名次列的「主通道 + 通道名次」两段关联，供 loadLatestResults
+// 与 httpapi 的 liveResultGroups 使用（两边必须逐字相同，否则分项成绩页与实时赛况的名次会打架）。
+//
+// 名次取「主通道」口径（devdocs 17 §11.3）：一行成绩只能出一个名次，主通道 = scope=athlete 优先，
+// 其次通道 sort_order 小者，与 export/load.go 的分项成绩表同一条规则。优先级是
+// **results.rank 优先、channel_ranks 兜底**（见下面各查询里的 COALESCE(r.rank, cr.rank)），
+// 不能照抄导出侧的 cr 优先：results.rank 是这条报名项自己的名次，而「只更新名次」的发布
+// （rankOnly，httpapi/scoring.go）只写 results.rank、不重建 channel_ranks——cr 一优先，
+// 个人项目在这种发布之后会显示上一次的旧名次。反过来 r 为空时才回落到 cr，
+// 正好补上团体主体名次：团体名次有意不写 results.rank（applyComputedRanks 只认个人主体）。
+//
+// 关联用 cr.entry_id = e.id，覆盖 basis=result 的名次（含纯团体项目，subject_key='e:<报名项id>'）。
+// 覆盖不到聚合 / 团体手工名次：那类 channel_ranks 行的 entry_id / result_id 都是 NULL，
+// 主体是 t:<单位id> / a:<运动员id>，而这类主体在分项成绩表里本来就没有对应的一行
+// （导出侧同一段子查询、同一处口径，见 export/load.go 的 loadEventRowsWithMembers）。
+// 取 MIN(cr2.id) = 报名项自己那一份名次：团体报名挂上队员后同一通道下还有每个队员的个人副本，
+// 直接按 entry_id JOIN 会把这一行印 N+1 遍（与导出侧同一处理）。
+//
+// ⚠️ 与 export/load.go（loadEventRowsWithMembers 的 cr 子查询）、httpapi/live_events.go（liveResultGroups）
+// 同源，改一处要改三处。
+const mainChannelRankJoin = `
+		  LEFT JOIN event_score_channels mc ON mc.id = (
+			SELECT c2.id FROM event_score_channels c2
+			 WHERE c2.event_id = r.event_id
+			 ORDER BY CASE WHEN c2.scope = 'athlete' THEN 0 ELSE 1 END, c2.sort_order, c2.id
+			 LIMIT 1)
+		  LEFT JOIN channel_ranks cr ON cr.id = (
+			SELECT MIN(cr2.id) FROM channel_ranks cr2
+			 WHERE cr2.channel_id = mc.id AND cr2.entry_id = e.id AND cr2.category_id = e.category_id)`
+
+// latestResultsScopedSelect 是窗口函数的输入：已发布、未作废的成绩行，每行只带分组键、
+// 发布时间与名次。时间表达式与主查询逐字相同——这里少一个兜底列，组的发布时间就会漂到别的列上。
+// 名次口径也必须与主查询一致（results.rank 优先、channel_ranks 兜底），
+// 否则「每组取前 R 行」和「组内展示顺序」会各按一套名次排。
+const latestResultsScopedSelect = `
+		SELECT r.id AS rid, r.event_id AS event_id, e.category_id AS category_id,
+		       COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at, '') AS ts,
+		       COALESCE(r.rank, cr.rank) AS rank_value
+		  FROM results r
+		  JOIN entries e ON e.id = r.entry_id` + mainChannelRankJoin + `
+		 WHERE r.state = 'published' AND r.status <> 'withdrawn'`
+
 // loadLatestResults 取最近发布的成绩，按「小项 + 组别」聚合成组后下发。
 // 已作废（status=withdrawn）的成绩必须排除，否则大屏会继续展示被作废的行；
 // 前端按组渲染（TickerBar 取最新一组、EventResultsPage 取前 N 组），平铺行会让它拿到 undefined。
+//
+// 窗口是「K 组 × 每组 R 行」而不是「总 N 行」，理由见上面那组常量的注释。三件事都在 SQL 里定死：
+//
+//  1. recent_groups：先按**组的发布时间**（= 组内最新一条的时间）倒序取前 K 组。并列时间按
+//     「该组最新那一行的 r.id」倒序决出——与旧实现「行按 ts DESC, r.id DESC 取回、组按首次出现建号」
+//     的顺序**逐位相同**，组数组的顺序不变（`Snapshot.LatestResults` 是 WS 契约）。
+//  2. bounded：每组按名次升序编号（无名次排最后，与下面 Go 侧那次 sort 同口径），只留前 R 行。
+//     ⚠️ 必须是「先定组、再每组截断」；退化成「取 N 行再分组」就还是同一个 bug，只是阈值变大。
+//  3. 组的时间取 anchors 定的 group_ts（组内最新一条），不是「这一组碰巧先被取回的那一行」——
+//     组内按名次截断之后，第一行的发布时间不再等于组的最新发布时间。
 func loadLatestResults(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
 	rows, err := tx.QueryContext(ctx, `
+		WITH scoped AS (`+latestResultsScopedSelect+`),
+		anchors AS (
+			SELECT event_id, category_id, ts AS group_ts, rid,
+			       ROW_NUMBER() OVER (PARTITION BY event_id, category_id ORDER BY ts DESC, rid DESC) AS anchor_no
+			  FROM scoped),
+		recent_groups AS (
+			SELECT event_id, category_id, group_ts
+			  FROM anchors WHERE anchor_no = 1
+			 ORDER BY group_ts DESC, rid DESC
+			 LIMIT ?),
+		bounded AS (
+			SELECT rid, event_id, category_id,
+			       ROW_NUMBER() OVER (PARTITION BY event_id, category_id
+			                          ORDER BY rank_value IS NULL, rank_value, rid) AS row_no
+			  FROM scoped)
 		SELECT r.event_id, COALESCE(ev.code, ''), COALESCE(ev.name, ''),
 		       e.category_id, COALESCE(cat.name, ''),
-		       COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at, ''),
-		       r.entry_id, r.rank, e.team_id,
+		       rg.group_ts,
+		       r.entry_id, COALESCE(r.rank, cr.rank), e.team_id,
 		       COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(t.short_name, ''), t.logo_path,
 		       e.athlete_id, COALESCE(a.name, ''), COALESCE(e.member_names, ''),
 		       COALESCE(r.result_text, ''), r.result_value, COALESCE(r.unit, ''), r.is_tie, r.status
@@ -440,10 +526,13 @@ func loadLatestResults(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
 		  JOIN events ev ON ev.id = r.event_id
 		  LEFT JOIN event_categories cat ON cat.id = e.category_id
 		  LEFT JOIN teams t ON t.id = e.team_id
-		  LEFT JOIN athletes a ON a.id = e.athlete_id
-		 WHERE r.state = 'published' AND r.status <> 'withdrawn'
-		 ORDER BY COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at) DESC, r.id DESC
-		 LIMIT ?`, latestResultsLimit)
+		  LEFT JOIN athletes a ON a.id = e.athlete_id`+mainChannelRankJoin+`
+		  JOIN bounded b ON b.rid = r.id
+		  JOIN recent_groups rg ON rg.event_id = b.event_id AND rg.category_id = b.category_id
+		 WHERE r.state = 'published' AND r.status <> 'withdrawn' AND b.row_no <= ?
+		 ORDER BY rg.group_ts DESC,
+		          COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at) DESC, r.id DESC`,
+		latestResultsGroupLimit, latestResultsRowsPerGroup)
 	if err != nil {
 		return fmt.Errorf("读取最新成绩: %w", err)
 	}
@@ -460,18 +549,20 @@ func loadLatestResults(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
 			eventID, categoryID  int64
 			eventCode, eventName string
 			categoryName         string
-			publishedAt          string
-			row                  dto.EventResultRow
-			rank                 sql.NullInt64
-			value                sql.NullFloat64
-			athleteID            sql.NullInt64
-			athleteName          string
-			shortName            string
-			logoPath             sql.NullString
-			memberNames          string
-			isTie                int
+			// groupPublishedAt 是这一**组**的发布时间（组内最新一条），来自 SQL 的 group_ts，
+			// 不是这一行自己的时间——组内按名次截断后，第一行的时间不再等于组的最新时间。
+			groupPublishedAt string
+			row              dto.EventResultRow
+			rank             sql.NullInt64
+			value            sql.NullFloat64
+			athleteID        sql.NullInt64
+			athleteName      string
+			shortName        string
+			logoPath         sql.NullString
+			memberNames      string
+			isTie            int
 		)
-		if err := rows.Scan(&eventID, &eventCode, &eventName, &categoryID, &categoryName, &publishedAt,
+		if err := rows.Scan(&eventID, &eventCode, &eventName, &categoryID, &categoryName, &groupPublishedAt,
 			&row.EntryID, &rank, &row.TeamID, &row.TeamCode, &row.TeamName, &shortName, &logoPath,
 			&athleteID, &athleteName, &memberNames,
 			&row.ResultText, &value, &row.Unit, &isTie, &row.Status); err != nil {
@@ -506,7 +597,7 @@ func loadLatestResults(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
 				EventName:    eventName,
 				CategoryID:   categoryID,
 				CategoryName: categoryName,
-				PublishedAt:  nilIfEmpty(publishedAt),
+				PublishedAt:  nilIfEmpty(groupPublishedAt),
 				Rows:         []dto.EventResultRow{},
 			})
 		}

server/internal/realtime/snapshot_test.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"strings"
 	"testing"
+	"time"
 
 	"git.yeij.top/AskaEth/Scoreboard/server/internal/dto"
 )
@@ -722,3 +723,375 @@ func TestSnapshotTeamsEventsWireFieldsPresent(t *testing.T) {
 		}
 	}
 }
+
+// insertTeamEvent 建一个纯团体小项（event_type=team），与现场「团体 4x100 接力」同形。
+func insertTeamEvent(t *testing.T, db *sql.DB, code, name string) int64 {
+	t.Helper()
+	if _, err := db.Exec(`INSERT OR IGNORE INTO sports(code, name) VALUES ('S1', '田径')`); err != nil {
+		t.Fatalf("插入大项: %v", err)
+	}
+	res, err := db.Exec(`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
+		VALUES (1, ?, ?, 'team', 'auto', 'time', 'asc', 'published')`, code, name)
+	if err != nil {
+		t.Fatalf("插入团体小项 %s: %v", code, err)
+	}
+	return lastID(t, res)
+}
+
+// insertTeamResult 写一条团体成绩：rank 列保持 NULL。
+// 团体名次有意不写 results.rank（applyComputedRanks 只认个人主体），发布后的真实形状就是这样。
+func insertTeamResult(t *testing.T, db *sql.DB, eventID, entryID int64, text string, value float64, verifiedAt string) int64 {
+	t.Helper()
+	res, err := db.Exec(`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state, status, verified_at)
+		VALUES (?, ?, NULL, ?, ?, 's', 'published', 'ok', ?)`, eventID, entryID, text, value, verifiedAt)
+	if err != nil {
+		t.Fatalf("插入团体成绩: %v", err)
+	}
+	return lastID(t, res)
+}
+
+// latestRowsByEntry 把快照「最新成绩」摊成 entryID -> 名次，便于逐条断言。
+func latestRowsByEntry(t *testing.T, snap *Snapshot) map[int64]*int {
+	t.Helper()
+	out := make(map[int64]*int)
+	for _, group := range snap.LatestResults {
+		for _, row := range group.Rows {
+			out[row.EntryID] = row.Rank
+		}
+	}
+	return out
+}
+
+// 团体项目的名次只落 channel_ranks、results.rank 有意留空，快照的 latestResults 必须回落到
+// channel_ranks：不回落的现场表现就是「团体 4x100 接力」发布之后，大屏分项成绩页与底栏上的
+// 名次整列都是「-」。库形态与发布后的真实落库一致（发布链路端到端钉在 httpapi 侧：
+// TestDisplayShowsTeamRankForTeamEvent）。
+func TestSnapshotLatestResultsFallsBackToChannelRanks(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "一队")
+	team2 := insertTeam(t, db, "T2", "第二单位", "二队")
+	eventID := insertTeamEvent(t, db, "T4X100", "4x100 米接力")
+	catID := insertCategory(t, db, eventID, "男子")
+	entry1 := insertEntry(t, db, eventID, catID, team1, 0)
+	entry2 := insertEntry(t, db, eventID, catID, team2, 0)
+	channelID := insertChannel(t, db, eventID, "team")
+	// 故意先写名次靠后的那条，验证组内按名次重排。
+	result2 := insertTeamResult(t, db, eventID, entry2, "46.10", 46.10, "2026-09-09T10:00:02Z")
+	result1 := insertTeamResult(t, db, eventID, entry1, "45.20", 45.20, "2026-09-09T10:00:01Z")
+	insertChannelRank(t, db, eventID, catID, channelID, entry1, result1, team1, 0, "team", "result", 1, 45.20)
+	insertChannelRank(t, db, eventID, catID, channelID, entry2, result2, team2, 0, "team", "result", 2, 46.10)
+
+	var ranked int
+	if err := db.QueryRow(`SELECT COUNT(*) FROM results WHERE event_id = ? AND rank IS NOT NULL`, eventID).Scan(&ranked); err != nil {
+		t.Fatalf("统计团体名次写回: %v", err)
+	}
+	if ranked != 0 {
+		t.Fatalf("前提不成立：团体名次不该写回 results.rank，得到 %d 行", ranked)
+	}
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+	if len(snap.LatestResults) != 1 || len(snap.LatestResults[0].Rows) != 2 {
+		t.Fatalf("应有 1 组 2 行，得到 %+v", snap.LatestResults)
+	}
+	ranks := latestRowsByEntry(t, snap)
+	for entryID, want := range map[int64]int{entry1: 1, entry2: 2} {
+		got := ranks[entryID]
+		if got == nil {
+			t.Fatalf("报名项 %d 的名次为空（大屏上就是「-」，得到 %+v）", entryID, snap.LatestResults)
+		}
+		if *got != want {
+			t.Fatalf("报名项 %d 的名次 = %d，期望 %d（来自 channel_ranks）", entryID, *got, want)
+		}
+	}
+	if snap.LatestResults[0].Rows[0].EntryID != entry1 {
+		t.Fatalf("组内应按名次排序（第一条应是第 1 名的报名项 %d），得到 %+v",
+			entry1, snap.LatestResults[0].Rows)
+	}
+}
+
+// 名次优先级必须是 results.rank 优先、channel_ranks 兜底：
+// 「只更新名次」的发布（rankOnly）只写 results.rank、不重建 channel_ranks，
+// 若 cr 优先，个人项目在这种发布之后会退回上一次的旧名次（从「正常」变成「显示旧名次」）。
+func TestSnapshotLatestResultsPrefersResultRank(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "")
+	eventID := insertEvent(t, db, "E1", "100米")
+	catID := insertCategory(t, db, eventID, "男子")
+	athlete1 := insertAthlete(t, db, "张三", team1)
+	entry1 := insertEntry(t, db, eventID, catID, team1, athlete1)
+	channelID := insertChannel(t, db, eventID, "athlete")
+	// results.rank = 2 是「只更新名次」那次发布写下的新名次；channel_ranks 还是上一次发布的 1。
+	result1 := insertResult(t, db, eventID, entry1, 2, "11.72", 11.72, "2026-09-09T10:00:01Z")
+	insertChannelRank(t, db, eventID, catID, channelID, entry1, result1, team1, athlete1, "athlete", "result", 1, 11.72)
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+	got := latestRowsByEntry(t, snap)[entry1]
+	if got == nil {
+		t.Fatalf("名次为空（大屏上就是「-」），期望 results.rank 的 2")
+	}
+	if *got != 2 {
+		t.Fatalf("名次应是 results.rank 的 2（新名次），得到 %d", *got)
+	}
+}
+
+// shiftTS 把 ISO 时间往后推 n 秒，造数里用来让「名次越靠后、发布时间越晚」（= 从第 1 名往下发）。
+func shiftTS(t *testing.T, base string, seconds int) string {
+	t.Helper()
+	ts, err := time.Parse(time.RFC3339, base)
+	if err != nil {
+		t.Fatalf("解析时间 %s: %v", base, err)
+	}
+	return ts.Add(time.Duration(seconds) * time.Second).Format(time.RFC3339)
+}
+
+// insertRankedGroup 造一组「小项 + 组别」：rows 条已发布成绩，名次 1..rows **按顺序录入**
+// （results.id 随名次递增，第 1 名建号最早），返回小项 id。
+// tsOf 给出每一行的发布时间：现场「从第 1 名往下录/往下发」时它随名次变晚，
+// 而一次发布刷同一时间戳时它是常量（并列靠 r.id 决先后）。
+func insertRankedGroup(t *testing.T, db *sql.DB, code, name string, teamID int64, rows int, tsOf func(rank int) string) int64 {
+	t.Helper()
+	eventID := insertEvent(t, db, code, name)
+	catID := insertCategory(t, db, eventID, "男子")
+	for rank := 1; rank <= rows; rank++ {
+		athlete := insertAthlete(t, db, fmt.Sprintf("%s-第%d名", code, rank), teamID)
+		entry := insertEntry(t, db, eventID, catID, teamID, athlete)
+		insertResult(t, db, eventID, entry, rank,
+			fmt.Sprintf("11.%02d", rank), 11+float64(rank)/100, tsOf(rank))
+	}
+	return eventID
+}
+
+// ranksOf 把一组的名次摊平成列表，只用于失败信息：直接 `%+v` 一整组行会打出一串指针地址。
+func ranksOf(group dto.EventResultGroup) []string {
+	out := make([]string, 0, len(group.Rows))
+	for _, row := range group.Rows {
+		if row.Rank == nil {
+			out = append(out, "—")
+			continue
+		}
+		out = append(out, fmt.Sprint(*row.Rank))
+	}
+	return out
+}
+
+// 快照「最新成绩」的窗口是「最近 K 组 × 每组前 R 行」，不是「总 N 行」。
+//
+// 这条用例钉的是现场那个 bug：行按发布时间倒序取、组按「首次出现」建号 → **屏上最旧的那一栏
+// 站在窗口尾部**，按总行数截断时切口只会落进那一组里，把「建号最早、也就是第 1 名」的行切掉。
+// 现场表现就是「第 3 栏看不到第 1 名、从第 2 名开始」，而且症状跟着**栏位**走、不跟着项目走。
+//
+// 旧实现（全局 20 行窗口）在这里必然失败：24 行里最旧的 4 行（第 3 栏的第 1–4 名）被切掉，
+// 第 3 栏第一行的名次是 5 而不是 1。既有用例拦不住它——那些用例每组最多 2 行、总量远小于 20。
+func TestSnapshotLatestResultsKeepsRankOneInEveryGroup(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "")
+	const rowsPerGroup = 8
+	// 三栏的发布时间：第 3 栏（下标 2）最早发布、建号也最早，旧实现下正是它站在窗口尾部。
+	publishedBases := [3]string{"2026-09-09T10:00:00Z", "2026-09-09T11:00:00Z", "2026-09-09T09:00:00Z"}
+
+	events := make([]int64, len(publishedBases))
+	// 造数顺序刻意与栏位顺序相反：先发布「最终落在第 3 栏」的那一组，再发另外两组。
+	for _, col := range []int{2, 0, 1} {
+		base := publishedBases[col]
+		events[col] = insertRankedGroup(t, db, fmt.Sprintf("E%d", col+1),
+			fmt.Sprintf("大屏第 %d 栏的小项", col+1), team1, rowsPerGroup,
+			func(rank int) string { return shiftTS(t, base, rank) })
+	}
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+
+	byEvent := make(map[int64]dto.EventResultGroup, len(snap.LatestResults))
+	totalRows := 0
+	for _, group := range snap.LatestResults {
+		byEvent[group.EventID] = group
+		totalRows += len(group.Rows)
+	}
+	if len(snap.LatestResults) < 3 {
+		t.Fatalf("三栏都应下发，得到 %d 组: %+v", len(snap.LatestResults), snap.LatestResults)
+	}
+	// 组数组的顺序不变（WS 契约）：发布时间倒序，最旧的那一组在最尾部 = 屏上最后一栏。
+	if snap.LatestResults[len(snap.LatestResults)-1].EventID != events[2] {
+		t.Fatalf("最旧发布的组应排在组数组尾部（第 3 栏），得到 %+v",
+			[]int64{snap.LatestResults[0].EventID, snap.LatestResults[1].EventID, snap.LatestResults[2].EventID})
+	}
+
+	wantRows := min(rowsPerGroup, latestResultsRowsPerGroup)
+	for col, eventID := range events {
+		group, ok := byEvent[eventID]
+		if !ok {
+			t.Fatalf("第 %d 栏（小项 %d）整组都没下发: %+v", col+1, eventID, snap.LatestResults)
+		}
+		// 断言顺序有讲究：先看第 1 名在不在，失败信息才是这个 bug 的原始形状。
+		if group.Rows[0].Rank == nil || *group.Rows[0].Rank != 1 {
+			t.Fatalf("第 %d 栏应从第 1 名开始，实际名次 %v（整组行数 %d）", col+1, ranksOf(group), len(group.Rows))
+		}
+		for i, row := range group.Rows {
+			if row.Rank == nil || *row.Rank != i+1 {
+				t.Fatalf("第 %d 栏的名次应连续升序，实际 %v", col+1, ranksOf(group))
+			}
+		}
+		if len(group.Rows) != wantRows {
+			t.Fatalf("第 %d 栏应有 %d 行（每组上限 R=%d），实际名次 %v",
+				col+1, wantRows, latestResultsRowsPerGroup, ranksOf(group))
+		}
+	}
+	// 总行数 > 20 是用例的前提（旧口径正是从这里翻车），放最后断言：
+	// 失败信息才优先说清「是哪一栏少了第 1 名」。
+	if totalRows <= 20 {
+		t.Fatalf("用例前提不成立：总行数必须 > 20（旧实现翻车的条件），得到 %d", totalRows)
+	}
+}
+
+// 每组只保留**名次最靠前**的 R 行，且组的发布时间取组内最新一条（哪怕那一行被 R 截掉）。
+//
+// 这一条同时挡住两种退化：①「先按总行数截断再分组」（会留下 12 行、超过 R）；
+// ②「组内取发布时间最新的 R 行」（会少掉第 1 名）。旧实现在这里也是红的（12 行一条不落地留下）。
+func TestSnapshotLatestResultsCapsRowsPerGroupByRank(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "")
+	base := "2026-09-09T10:00:00Z"
+	// 比 R 多 2 行：名次最靠后的两行必须被丢掉，第 1 名必须在。
+	rows := latestResultsRowsPerGroup + 2
+	eventID := insertRankedGroup(t, db, "E1", "男子 100 米", team1, rows,
+		func(rank int) string { return shiftTS(t, base, rank) })
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+	if len(snap.LatestResults) != 1 {
+		t.Fatalf("应只有 1 组，得到 %d: %+v", len(snap.LatestResults), snap.LatestResults)
+	}
+	group := snap.LatestResults[0]
+	if group.EventID != eventID {
+		t.Fatalf("组的小项应是 %d，得到 %d", eventID, group.EventID)
+	}
+	if len(group.Rows) != latestResultsRowsPerGroup {
+		t.Fatalf("一组最多 %d 行，实际名次 %v", latestResultsRowsPerGroup, ranksOf(group))
+	}
+	for i, row := range group.Rows {
+		if row.Rank == nil || *row.Rank != i+1 {
+			t.Fatalf("留下的必须是名次最靠前的 %d 行，实际名次 %v", latestResultsRowsPerGroup, ranksOf(group))
+		}
+	}
+	// 组的发布时间 = 组内最新一条（第 12 名那行的 base+12s），不是「留下的第一行」的 base+1s。
+	wantPublishedAt := shiftTS(t, base, rows)
+	if group.PublishedAt == nil || *group.PublishedAt != wantPublishedAt {
+		t.Fatalf("组的发布时间应取组内最新一条 %s，得到 %v", wantPublishedAt, group.PublishedAt)
+	}
+}
+
+// 组数超过 K 时只保留**最近发布**的 K 组：组数组尾部（屏上最后一栏）先被丢掉。
+func TestSnapshotLatestResultsCapsGroupCount(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "")
+	base := "2026-09-09T10:00:00Z"
+	const groupCount = latestResultsGroupLimit + 1
+
+	events := make([]int64, groupCount)
+	for i := 0; i < groupCount; i++ {
+		// 每组 1 行，发布时间依次变新：下标越大越新。
+		ts := shiftTS(t, base, i*60)
+		events[i] = insertRankedGroup(t, db, fmt.Sprintf("E%02d", i+1),
+			fmt.Sprintf("第 %d 个小项", i+1), team1, 1,
+			func(int) string { return ts })
+	}
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+	if len(snap.LatestResults) != latestResultsGroupLimit {
+		t.Fatalf("组数应封顶在 K=%d，得到 %d", latestResultsGroupLimit, len(snap.LatestResults))
+	}
+	if snap.LatestResults[0].EventID != events[groupCount-1] {
+		t.Fatalf("最新发布的组应排在最前，得到小项 %d，期望 %d", snap.LatestResults[0].EventID, events[groupCount-1])
+	}
+	kept := make(map[int64]bool, len(snap.LatestResults))
+	for _, group := range snap.LatestResults {
+		kept[group.EventID] = true
+	}
+	if kept[events[0]] {
+		t.Fatalf("最旧的那一组应被丢掉: %+v", snap.LatestResults)
+	}
+	for i := 1; i < groupCount; i++ {
+		if !kept[events[i]] {
+			t.Fatalf("最近发布的 %d 组都应保留，缺少小项 %d: %+v", latestResultsGroupLimit, events[i], snap.LatestResults)
+		}
+	}
+}
+
+// 一次发布会把范围内的行刷成**同一个** verified_at（httpapi/scoring.go 的 setPublished 用
+// datetime('now')），所以现场最常见的形态是「组内行时间全并列、跨组也可能并列」。
+// 并列时按 r.id 决先后，组的顺序必须与旧实现逐位相同（行按 ts DESC, r.id DESC 取回、
+// 组按首次出现建号 → 时间并列时等于「组内最大 r.id」倒序），否则大屏的栏位会换位置。
+func TestSnapshotLatestResultsTiedPublishTimestamps(t *testing.T) {
+	env := newTestEnv(t)
+	db := env.db
+
+	team1 := insertTeam(t, db, "T1", "第一单位", "")
+	// 三组同一次发布：9:30:00 那一秒。
+	const sameTS = "2026-09-09T09:30:00Z"
+	const rowsPerGroup = 8
+
+	events := make([]int64, 3)
+	// 造数顺序 = 发布顺序：先发第 3 栏那一组（建号最早），再发第 1、2 栏。
+	insertOrder := []int{2, 0, 1}
+	for _, col := range insertOrder {
+		events[col] = insertRankedGroup(t, db, fmt.Sprintf("E%d", col+1),
+			fmt.Sprintf("大屏第 %d 栏的小项", col+1), team1, rowsPerGroup,
+			func(int) string { return sameTS })
+	}
+
+	snap, err := env.hub.Snapshot(context.Background())
+	if err != nil {
+		t.Fatalf("构建快照: %v", err)
+	}
+	if len(snap.LatestResults) != 3 {
+		t.Fatalf("三组都应下发，得到 %d 组", len(snap.LatestResults))
+	}
+	// 时间并列 → 靠 r.id 决先后：最后发布的那一组（第 2 栏）在最前，最先发布的（第 3 栏）在最后。
+	wantOrder := []int{1, 0, 2}
+	for i, col := range wantOrder {
+		if snap.LatestResults[i].EventID != events[col] {
+			t.Fatalf("并列时间的组顺序应与发布顺序相反，第 %d 位应是第 %d 栏的小项 %d，得到 %d",
+				i+1, col+1, events[col], snap.LatestResults[i].EventID)
+		}
+	}
+	byEvent := make(map[int64]dto.EventResultGroup, len(snap.LatestResults))
+	for _, group := range snap.LatestResults {
+		byEvent[group.EventID] = group
+	}
+	for col, eventID := range events {
+		group := byEvent[eventID]
+		if group.Rows[0].Rank == nil || *group.Rows[0].Rank != 1 {
+			t.Fatalf("第 %d 栏应从第 1 名开始，实际名次 %v", col+1, ranksOf(group))
+		}
+		if len(group.Rows) != rowsPerGroup {
+			t.Fatalf("第 %d 栏应有 %d 行，实际名次 %v", col+1, rowsPerGroup, ranksOf(group))
+		}
+		// 并列时间下组的发布时间也是同一条，不能变成「某一行的时间」以外的值。
+		if group.PublishedAt == nil || *group.PublishedAt != sameTS {
+			t.Fatalf("第 %d 栏的发布时间应是 %s，得到 %v", col+1, sameTS, group.PublishedAt)
+		}
+	}
+}