feat(entry): 团体项目多队（迁移 0025）+ 修联队团体名次 / 大屏分项成绩 / 预览算分口径；版本 dev_0.5.5

## 一、新能力：团体项目多队
现场：羽毛球双打，一个单位可能派两个队，一个单位两个队各占一个名次。
- 迁移 `0025_entry_squad.sql`：`entries` 加 `squad TEXT NOT NULL DEFAULT ''`（自由文本队名，空串＝不区分队伍）；
  唯一索引由 `(category_id, team_id) WHERE athlete_id IS NULL` 换成 `(category_id, team_id, squad) WHERE athlete_id IS NULL`
  —— 原来那条正是「一个单位在一个组别只能报一条团体报名」的拦路虎。
- 导入：**第 13 列「队伍」**（`squad` / 队伍 / 队名 / 队伍名，可选，放最后）；老 12 列表照常导入。
- 显示：`单位名 + 队名`（不加括号），榜单不写队名（分与牌本来就归单位）。
- 新增「改队名」：`PUT /api/entries/{id}/squad` + 「成员单位与份额」弹窗里的队伍输入框（只对纯团体报名显示）。
  改队名**不需要重算**（`grep squad server/internal/domain/` = 0 处，改名前后流水/名次/榜单逐字节相同）。
- **老数据零变化**：接口层 JSON 剥掉新字段后逐字节相同；导出层 9 份导出件全单元格 750 行 dump 的 md5 相同。

## 二、修：团体名次控件没体现联队
联队的成员单位在「团体名次」里各占一行 → **合并成一行**（标签用大屏/导出一致的联队名），名次**只落主单位**；
成员单位不再进保存载荷，顺手堵掉「看 A、B 各一行，给 B 也录一个名次 → B 重复拿分」。
被并掉的成员单位原来若录过名次，区块里点名提示「已并入联队那一行，保存后清除」，不静默吞。

## 三、修：大屏「分项成绩」排名错乱
现场：第 3 栏列出的项目排名跳着显示（3、6、9、14、15、16），羽毛球单打第 1 名不显示。
**根因**：`group.rows.slice(0, 6)` 取的是**数据到达顺序**，整条渲染链**没有一处读 `rank`**。
修法：按名次升序（并列保持原先后、无名次排最后）再截断 —— 与同页「实时赛况」的既有口径一致。
复现证据：修前 `actual: [3,6,9,14,15,16]`（与现场数字一致）、`expected: [1,2,3,4,5,6]`。
顺带澄清：「只有第 3 栏出问题」不是栏的问题，是那一栏分到的数据次序不成立。

## 四、修：录入页预览算分与后端口径不一致（四处 + 一条延伸）
现场：手动录名次的项目（台球）「积分（自动）」列全是 0，而后端**有分**。
1. **预览不读 `channel_manual_ranks`、也不按通道 scope 分名次来源** → 「按单位录名次」的项目预览全 0，反过来名次填在成绩表时预览有分而服务端 0；
2. **末位归零判据不同**：预览原本「区间跨末位就整组归零」，与后端的 `startRank == lastPlace` 不符（并列第 1 时预览 0、服务端 10）；
3. **`compare=none` 时预览静默降级成 manual**（后端此时直接报错）→ 改为同口径：显示**原因**而不是一个算不出来的数字；
4. **管理端保存计分通道缺守卫**：`compare=none + basis=result/aggregate` 原先只有规则包导入拦，手工能配出来、到发布才报错 → 保存前 400 + 人话。
延伸：预览的「已发布分」基线**只扣行分**，不挂报名项的分（团体名次那类）没扣 → 发布确认框「最大分差」虚高；新增 `unitPoints` 一并扣。

## 五、修：手录名次项目的「成绩」列空白
`displayResult()` 在 `resultValue`/`resultText` 都拿不到时**漏出空值**（且函数声明返回 `string`）→
新增占位 `—`、类型收紧，实时赛况与底栏对齐同一口径。

## 文档
`docs/报名名单导入规范.md`（12 → 13 列）、`docs/使用手册.md`（多队章节）、
`docs/升级说明.md`（新增 `dev_0.5.5` 一节）、`debug/使用说明/` 七份同步。

## 验证
- 全量自检两轮**全绿、`EXIT=0`**：服务端 14 包 / 前端 **883 例** 0 fail / Console 68 例 0 fail。
- 各块都先写会红的测试、留了原始输出（含现场报的那组数字与「预览全 0」）。

## 版本
`dev_0.5.4` → **`dev_0.5.5`**（含数据迁移 `0025`）；安装器素材同步重生成（照例只动 `brand.bmp` 两张）。

## 下一批
`dev_0.5.6` = **团体报名队员身份**（把队员从文字名单变成人员关联，标识用**号码布**），工单见 `devdocs/20-团体报名队员身份.md`。

web/src/display/components/DetailOverlay.vue

@@ -2,6 +2,7 @@
 import { computed, onUnmounted, ref, watch } from 'vue'
 import { breakdownAthleteName, breakdownRevisionLine, breakdownSourceTag } from '@/shared'
 import { useScoreboard } from '../useScoreboard'
+import { resultTextOrPlaceholder } from '../results'
 import AnimatedNumber from './AnimatedNumber.vue'
 
 const { detail } = useScoreboard()
@@ -72,7 +73,7 @@ const autoClose = computed(() => (detail.value?.autoCloseSeconds ?? 0) > 0)
             </span>
             <span class="col-athlete">{{ breakdownAthleteName(item, teamName) }}</span>
             <span class="col-rank">{{ item.rank ?? '—' }}</span>
-            <span class="col-result">{{ item.resultText ?? '—' }}</span>
+            <span class="col-result">{{ resultTextOrPlaceholder(item.resultText) }}</span>
             <span class="col-points">{{ item.points }}</span>
             <!--
               修订痕迹占满一整行、只在这一分确实被改过时才出现：大屏不能悬停，观众要一眼看到

web/src/display/components/TickerBar.vue

@@ -3,6 +3,7 @@ import { computed, onUnmounted, ref, watch } from 'vue'
 import { medalBoardRows } from '@/shared'
 import type { EventResultRow } from '@/shared'
 import { tickerRowText } from '../jointTeams'
+import { displayResult } from '../results'
 import { useScoreboard } from '../useScoreboard'
 import { DEFAULT_ROTATE_SECONDS } from '../guards'
 
@@ -13,16 +14,17 @@ interface TickerItem {
   label: string
 }
 
-const { standings, latestResults, announceText, detail, settings, jointTeamOf } = useScoreboard()
+const { standings, latestResults, announceText, detail, settings, jointTeamOf, squadOf } =
+  useScoreboard()
 
 /**
  * 底栏「最新完成项目」一行里的名字：团体行是联队时写「A+B联队」。
  *
  * 底栏放不下两个 logo，但两个单位的名字必须都在——只写主单位会让现场以为
- * 这条成绩是它一家拿的（成员单位来自报名表，见 display/jointTeams.ts）。
+ * 这条成绩是它一家拿的（成员单位与队名都来自报名表，见 display/jointTeams.ts）。
  */
 function chipName(row: EventResultRow): string {
-  return tickerRowText(row, jointTeamOf(row.entryId))
+  return tickerRowText(row, jointTeamOf(row.entryId), squadOf(row.entryId))
 }
 
 // 与单位奖牌榜页同一口径：按服务端的奖牌榜顺序（金→银→铜）取前 3，不在前端自己重排。
@@ -90,7 +92,7 @@ onUnmounted(() => window.clearInterval(timer))
           <div v-for="row in latestGroup.rows.slice(0, 3)" :key="row.entryId" class="chip">
             <span class="chip-rank">{{ row.rank ?? '—' }}</span>
             <span class="chip-name">{{ chipName(row) }}</span>
-            <span class="chip-stat">{{ row.resultText }}</span>
+            <span class="chip-stat">{{ displayResult(row) }}</span>
           </div>
         </template>
 

web/src/display/components/pages/EventResultsPage.vue

@@ -2,22 +2,25 @@
 import { computed } from 'vue'
 import type { EventResultRow } from '@/shared'
 import { rowTeamLogos, rowTeamText } from '../../jointTeams'
-import { displayName, displayResult } from '../../results'
+import { displayName, displayResult, eventResultColumns } from '../../results'
 import { useScoreboard } from '../../useScoreboard'
 import PageFrame from '../PageFrame.vue'
 import TeamLogo from '../TeamLogo.vue'
 
-const { latestResults, options, jointTeamOf } = useScoreboard()
+const { latestResults, options, jointTeamOf, squadOf } = useScoreboard()
 
 // 数据口径：服务端只过滤 state='published'（不看项目 status），按发布时间倒序取前 N 个（06 第 5 节）。
-const groups = computed(() => latestResults.value.slice(0, options.value.resultsCount))
+const columns = computed(() =>
+  eventResultColumns(latestResults.value, options.value.resultsCount),
+)
 
 /**
  * 单位列的文案与 logo（devdocs/19）：联队写「A+B联队」并画两个单位的 logo，
+ * 填了队名的写「第一分公司二队」（一个单位两个队时，两行的名字要分得开）；
  * 普通报名与改造前逐字/逐图一致（`shortName ?? teamName` 与单个 TeamLogo）。
  */
 function teamText(row: EventResultRow): string {
-  return rowTeamText(row, jointTeamOf(row.entryId))
+  return rowTeamText(row, jointTeamOf(row.entryId), squadOf(row.entryId))
 }
 
 function teamLogos(row: EventResultRow): (string | null)[] {
@@ -26,16 +29,16 @@ function teamLogos(row: EventResultRow): (string | null)[] {
 </script>
 
 <template>
-  <PageFrame title="分项成绩" :hint="`最新完成 ${groups.length} 项`">
-    <div v-if="groups.length > 0" class="groups">
-      <article v-for="group in groups" :key="`${group.eventId}-${group.categoryId}`" class="group">
+  <PageFrame title="分项成绩" :hint="`最新完成 ${columns.length} 项`">
+    <div v-if="columns.length > 0" class="groups">
+      <article v-for="column in columns" :key="column.key" class="group">
         <header class="group-head">
-          <h3>{{ group.eventName }}</h3>
-          <span class="cat">{{ group.categoryName }}</span>
+          <h3>{{ column.group.eventName }}</h3>
+          <span class="cat">{{ column.group.categoryName }}</span>
         </header>
         <div class="lines">
           <div
-            v-for="row in group.rows.slice(0, 6)"
+            v-for="row in column.rows"
             :key="row.entryId"
             class="line"
             :class="`top-${Math.min(row.rank ?? 99, 4)}`"

web/src/display/components/pages/LivePage.vue

@@ -17,15 +17,24 @@ import { useScoreboard } from '../../useScoreboard'
 import PageFrame from '../PageFrame.vue'
 import TeamLogo from '../TeamLogo.vue'
 
-const { latestResults, settings, events, liveFeed, liveStale, refreshLiveEvents, jointTeamOf } =
-  useScoreboard()
+const {
+  latestResults,
+  settings,
+  events,
+  liveFeed,
+  liveStale,
+  refreshLiveEvents,
+  jointTeamOf,
+  squadOf,
+} = useScoreboard()
 
 /**
- * 联队（devdocs/19）：成绩行里只有主单位，成员单位来自报名表（useScoreboard 会为屏上的小项读一次）。
- * 普通报名下这两件事与改造前完全一样——文案还是 `shortName ?? teamName`，logo 还是刚一张。
+ * 联队与队伍（devdocs/19）：成绩行里只有主单位，成员单位与队名来自报名表
+ * （useScoreboard 会为屏上的小项读一次）。普通报名下这两件事与改造前完全一样——
+ * 文案还是 `shortName ?? teamName`，logo 还是刚一张。
  */
 function teamText(row: EventResultRow): string {
-  return rowTeamText(row, jointTeamOf(row.entryId))
+  return rowTeamText(row, jointTeamOf(row.entryId), squadOf(row.entryId))
 }
 
 function teamLogos(row: EventResultRow): (string | null)[] {
@@ -82,8 +91,8 @@ const layout = computed(() => liveBoardLayout(boards.value.length, rowCount.valu
 const resultTexts = computed(() =>
   boards.value.flatMap((board) => board.rows.map((row) => displayResult(row))),
 )
-// 联队行的单位名更长（两个单位名都写全），列宽预算必须按**实际会写出来的字**算，
-// 否则联队一到屏上就被挤成省略号。
+// 联队行的单位名更长（两个单位名都写全），带队名的行也多出几个字，列宽预算必须按
+// **实际会写出来的字**算（teamText 已经把队名拼进去了），否则一到屏上就被挤成省略号。
 const teamTexts = computed(() =>
   boards.value.flatMap((board) => board.rows.map((row) => teamText(row))),
 )

web/src/display/jointTeams.ts

@@ -1,17 +1,17 @@
-import { isJointTeam, jointTeamLabel, normalizeTeamShares } from '@/shared'
+import { isJointTeam, jointTeamLabel, normalizeSquad, normalizeTeamShares, teamSquadLabel } from '@/shared'
 import type { EntryTeamShare, Team, TeamShareView } from '@/shared'
 
 /**
- * 大屏侧的联队渲染（devdocs/19）。
+ * 大屏侧的联队 / 队伍渲染（devdocs/19）。
  *
  * 大屏拿到的成绩行（分项成绩 / 实时赛况 / 底栏）里只有**主单位**的 teamId 与名字，
- * 一条报名挂在几个单位下这件事只存在于报名表（`GET /api/events/{id}/entries` 的 teamShares）。
- * 所以这里做两件事：
- *   1. 把那个接口的读数收敛成 `entryId → 成员单位`（名字取自份额，logo 取自快照的单位表——
- *      entries 接口不下发 logoPath）；
+ * 而「一条报名挂在几个单位下」与「这是单位的第几支队」只存在于报名表
+ * （`GET /api/events/{id}/entries` 的 teamShares 与 squad）。所以这里做两件事：
+ *   1. 把那个接口的读数收敛成 `entryId → 成员单位` 与 `entryId → 队名`（名字取自份额，
+ *      logo 取自快照的单位表——entries 接口不下发 logoPath）；
  *   2. 把「一行该怎么念、放几个 logo」抽成纯函数，页面只负责把结果画出来。
  *
- * 单单位（普通报名）时这些函数一律退回调用方原来的表达式，屏上逐像素不变。
+ * 单单位且不填队名（普通报名）时这些函数一律退回调用方原来的表达式，屏上逐像素不变。
  */
 
 /** 大屏侧的一条份额：展示字段之外补上 logo（从快照单位表里取）。 */
@@ -61,13 +61,40 @@ export function entryShareIndex(
   return out
 }
 
+/** 解析 entries 接口里一项报名的 squad；缺字段 / 类型不对时是空串（= 不区分队伍）。 */
+export function readEntrySquad(source: unknown): string {
+  if (typeof source !== 'object' || source === null) return ''
+  return normalizeSquad((source as { squad?: unknown }).squad)
+}
+
+/**
+ * 一批报名 → `entryId → 队名`，**只收填了队名的**（空串不进表）。
+ *
+ * 与 entryShareIndex 同一个理由：取不到就是「按原来那样渲染」，于是老数据与单队单位的成绩行
+ * 与大屏改造前完全一致（连一个多余的字符串拼接都不做）。
+ * 队名与成员单位来自同一次 `GET /api/events/{id}/entries`，所以大屏不为它多发一个请求。
+ */
+export function entrySquadIndex(entries: readonly unknown[]): Map<number, string> {
+  const out = new Map<number, string>()
+  for (const entry of entries) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const entryId = (entry as { id?: unknown }).id
+    if (typeof entryId !== 'number' || entryId <= 0) continue
+    const squad = readEntrySquad(entry)
+    if (squad === '') continue
+    out.set(entryId, squad)
+  }
+  return out
+}
+
 /** 一行成绩（分项成绩页 / 实时赛况页）在单位列里的文案。 */
 export function rowTeamText(
   row: { shortName: string | null; teamName: string },
   members: readonly TeamShareView[] | null,
+  squad: string | null = null,
 ): string {
-  if (members === null) return row.shortName ?? row.teamName
-  return jointTeamLabel(members)
+  const base = members === null ? (row.shortName ?? row.teamName) : jointTeamLabel(members)
+  return teamSquadLabel(base, squad)
 }
 
 /**
@@ -75,13 +102,15 @@ export function rowTeamText(
  *
  * 团体行是联队时写「A+B联队」——底栏只有一行字，写不下两个 logo，
  * 但两个单位的名字必须都在，否则现场会以为只有一个单位参赛。
+ * 队名跟着一起写：同一个单位的两个队都进了名次时，两行只差队名，少了它就分不出哪一行是谁。
  */
 export function tickerRowText(
   row: { athleteName: string | null; shortName: string | null; teamName: string },
   members: readonly TeamShareView[] | null,
+  squad: string | null = null,
 ): string {
   if (row.athleteName !== null && row.athleteName.trim() !== '') return row.athleteName
-  return rowTeamText(row, members)
+  return rowTeamText(row, members, squad)
 }
 
 /**

web/src/display/results.ts

@@ -1,22 +1,44 @@
 import { formatResultText } from '@/shared'
-import type { EventResultRow, ResultStatus } from '@/shared'
+import type { EventResultGroup, EventResultRow, ResultStatus } from '@/shared'
 
 /**
- * 成绩行的展示口径：分项成绩页与实时赛况页共用，避免同一行数据在两页显示成两种样子。
+ * 成绩行的展示口径：分项成绩页、实时赛况页、底栏轮播与积分明细覆盖层共用，
+ * 避免同一行数据在几处显示成两种样子（尤其「一格破折号、一格空白」）。
  */
 
-const STATUS_LABELS: Record<ResultStatus, string> = {
-  ok: '',
+/** 分项成绩页一栏（一个小项 + 一个组别）显示几个名次（06 第 5 节：每个项目显示前 6 名）。 */
+export const RESULT_ROWS_PER_COLUMN = 6
+
+/**
+ * 成绩列拿不到内容时写的占位，与名次列（`row.rank ?? '—'`）同一个字符：
+ * 两列一处是破折号、一处是空白，现场只会当成那一格没渲染出来。
+ */
+export const RESULT_PLACEHOLDER = '—'
+
+/** 异常状态在成绩列里的写法。`ok` 不在表里：正常成绩要按数值 + 单位格式化，不是一句文案。 */
+const STATUS_LABELS: Record<Exclude<ResultStatus, 'ok'>, string> = {
   dq: 'DQ',
   dns: 'DNS',
   dnf: 'DNF',
   withdrawn: '退赛',
 }
 
+/**
+ * 服务端给的成绩原文 → 能写进格子的字。
+ *
+ * 类型上它写的是 `string`，运行时并不保证：**手录名次的项目**（台球、篮球那类，只录名次、
+ * 没有成绩值）两种值都拿不到，旧快照还可能补成 null。判空不碰字符串方法（不 `trim`），
+ * 拿不到内容就给占位——空着的那一格在大屏上看着像渲染坏了。
+ */
+export function resultTextOrPlaceholder(text: string | null | undefined): string {
+  if (typeof text !== 'string' || text === '') return RESULT_PLACEHOLDER
+  return text
+}
+
 /** 成绩列：异常状态优先，其次按数值 + 单位格式化，最后退回服务端给的原文。 */
 export function displayResult(row: EventResultRow): string {
   if (row.status !== 'ok') return STATUS_LABELS[row.status]
-  if (row.resultValue === null) return row.resultText
+  if (row.resultValue === null) return resultTextOrPlaceholder(row.resultText)
   return formatResultText(row.resultValue, row.unit, row.unit === 's' ? 'time' : 'none')
 }
 
@@ -26,3 +48,55 @@ export function displayName(row: EventResultRow): string {
   if (row.memberNames !== null) return row.memberNames.join(' / ')
   return row.shortName ?? row.teamName
 }
+
+/** 分项成绩页的一栏：一个小项 + 一个组别，外加这一栏要画的名次行。 */
+export interface EventResultColumn {
+  /** 组标识，与页面的 `:key` 同口径。 */
+  key: string
+  group: EventResultGroup
+  rows: EventResultRow[]
+}
+
+/**
+ * 一栏要画的名次行：先按名次收口，再取前 N 名。
+ *
+ * 不能直接 `group.rows.slice(0, N)`：服务端下发的行**通常是**名次序，但「平铺成绩行」老契约、
+ * 本地缓存、示例数据都不保证——那时前 N 条就不是前 N 名。现场第 3 栏看到的就是这个形状：
+ * 第 1 名不在先到的那 6 行里就整行不显示、剩下的名次看着是跳的（3、6、9、14、15、16）。
+ * 名次只能由名次自己说了算（实时赛况页的 liveRows 同一套口径）。
+ *
+ * ⚠️ 服务端**根本没下发**的行补不回来：那是快照 20 行窗口（`realtime/snapshot.go` 的
+ * `latestResultsLimit`）截断的问题，不在这层；这一层只保证「拿到的行按名次画」。
+ *
+ * 并列名次保持原有先后（`sort` 在 ES2019 起是稳定的）：服务端按发布时间给出的并列行
+ * 不许在这里被换位置，否则前两栏的观感就变了。无名次（延迟结算）的行排最后。
+ */
+export function eventResultRows(
+  group: EventResultGroup | null,
+  limit: number = RESULT_ROWS_PER_COLUMN,
+): EventResultRow[] {
+  if (group === null) return []
+  return [...group.rows].sort(byRank).slice(0, limit)
+}
+
+function byRank(a: EventResultRow, b: EventResultRow): number {
+  if (a.rank === null && b.rank === null) return 0
+  if (a.rank === null) return 1
+  if (b.rank === null) return -1
+  return a.rank - b.rank
+}
+
+/**
+ * 页面要画的栏：最新的 N 个「小项 + 组别」各一栏。
+ */
+export function eventResultColumns(
+  groups: readonly EventResultGroup[],
+  count: number,
+  limit: number = RESULT_ROWS_PER_COLUMN,
+): EventResultColumn[] {
+  return groups.slice(0, count).map((group) => ({
+    key: `${group.eventId}-${group.categoryId}`,
+    group,
+    rows: eventResultRows(group, limit),
+  }))
+}

web/src/display/tests/detail-overlay-athlete.test.ts

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { parse } from 'vue/compiler-sfc'
 import { breakdownAthleteName, breakdownRevisionLine, breakdownSourceTag, type BreakdownItem } from '@/shared'
+import { resultTextOrPlaceholder } from '../results'
 
 /**
  * 大屏积分明细覆盖层的「运动员」列。
@@ -95,7 +96,8 @@ test('项目 / 名次 / 成绩 / 积分四列原样保留（是加列不是改
   const cells = cellsOf(BODY_ROW)
   assert.match(cells[0]?.inner ?? '', /item\.eventName \?\? '人工调整'/)
   assert.equal(cells[2]?.inner, "{{ item.rank ?? '—' }}")
-  assert.equal(cells[3]?.inner, "{{ item.resultText ?? '—' }}")
+  // 成绩格与分项成绩页 / 实时赛况页同一个口径：`??` 只挡 null，手录名次的项目给空串就画成空白。
+  assert.equal(cells[3]?.inner, '{{ resultTextOrPlaceholder(item.resultText) }}')
   assert.equal(cells[4]?.inner, '{{ item.points }}')
 })
 
@@ -105,7 +107,7 @@ test('个人流水那一行大屏上看得见是谁：运动员格是姓名，
     row.eventName ?? '人工调整',
     breakdownAthleteName(row, '第一分公司'),
     row.rank ?? '—',
-    row.resultText ?? '—',
+    resultTextOrPlaceholder(row.resultText),
     row.points,
   ]
   assert.deepEqual(rendered, ['100米跑', '张伟', 1, '11.58', 10])

web/src/display/tests/event-results-rows.test.ts

@@ -0,0 +1,162 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { compileTemplate, parse } from 'vue/compiler-sfc'
+import type { EventResultGroup, EventResultRow } from '@/shared'
+import { RESULT_ROWS_PER_COLUMN, eventResultColumns, eventResultRows } from '../results'
+
+// 现场缺陷：分项成绩页原来把「先到达的前 6 行」当成「前 6 名」画（`group.rows.slice(0, 6)`），
+// 数据一旦不是名次序（平铺契约 / 本地缓存 / 服务端只回了一段窗口内的行），
+// 第 1 名就不在画出来的那 6 行里、名次看着是跳的（现场报的第 3 栏是 3、6、9、14、15、16）。
+// 这里把「一栏画哪些行」收口成纯函数（与实时赛况页的 liveRows 同一套口径），逐条钉住。
+
+function row(entryId: number, rank: number | null): EventResultRow {
+  return {
+    entryId,
+    rank,
+    teamId: entryId % 5,
+    teamCode: `T${entryId % 5}`,
+    teamName: `单位${entryId % 5}`,
+    shortName: null,
+    logoPath: null,
+    athleteId: entryId,
+    athleteName: `运动员${entryId}`,
+    memberNames: null,
+    resultText: '11.58',
+    resultValue: 11.58,
+    unit: 's',
+    isTie: false,
+    status: 'ok',
+  }
+}
+
+/** 一个「小项 + 组别」组，`ranks` 就是**行到达的先后**（不是名次序）。 */
+function group(eventId: number, ranks: readonly (number | null)[], categoryId = 1): EventResultGroup {
+  return {
+    eventId,
+    eventCode: `E${eventId}`,
+    eventName: `项目${eventId}`,
+    categoryId,
+    categoryName: '青年组',
+    publishedAt: '2026-09-14T10:00:00+08:00',
+    rows: ranks.map((rank, index) => row(eventId * 1000 + index + 1, rank)),
+  }
+}
+
+function ranksOf(rows: readonly EventResultRow[]): (number | null)[] {
+  return rows.map((item) => item.rank)
+}
+
+function entryIds(rows: readonly EventResultRow[]): number[] {
+  return rows.map((item) => item.entryId)
+}
+
+test('行按到达顺序给过来时，名次仍从第 1 名开始且连续（现场报的 3、6、9、14、15、16）', () => {
+  // 100 米跑：16 行都在，但到达顺序是「先到的那几行名次靠后」——正是现场第 3 栏看到的样子。
+  const race = group(1, [3, 6, 9, 14, 15, 16, 1, 2, 4, 5, 7, 8, 10, 11, 12, 13])
+  assert.deepEqual(
+    ranksOf(eventResultRows(race)),
+    [1, 2, 3, 4, 5, 6],
+    '画出来的必须是前 6 名，而不是先到的 6 行',
+  )
+
+  // 羽毛球单打：第 1 名排在第 7 位才到达（原来整行都不显示，看着「从第 2 名开始」）。
+  const badminton = group(2, [2, 3, 4, 5, 6, 7, 1])
+  assert.deepEqual(ranksOf(eventResultRows(badminton)), [1, 2, 3, 4, 5, 6])
+})
+
+test('同一批数据放进第 1 / 2 / 3 栏，各栏拿到的行与名次完全一致、且都从第 1 名开始', () => {
+  const target = group(7, [3, 6, 9, 14, 15, 16, 1, 2, 4, 5, 7, 8, 10, 11, 12, 13])
+  const other = group(8, [2, 1])
+
+  // 同一个组分别落在第 1 / 2 / 3 栏：位置不该影响它画出来的行。
+  const first = eventResultColumns([target], 1)[0]?.rows ?? []
+  const second = eventResultColumns([other, target], 2)[1]?.rows ?? []
+  const third = eventResultColumns([other, other, target], 3)[2]?.rows ?? []
+
+  assert.deepEqual(ranksOf(first), [1, 2, 3, 4, 5, 6])
+  assert.deepEqual(entryIds(second), entryIds(first), '第 2 栏拿到的行必须与第 1 栏一致')
+  assert.deepEqual(entryIds(third), entryIds(first), '第 3 栏拿到的行必须与第 1 栏一致')
+  // 三栏各画各的组：同一批数据在三栏里都能从第 1 名开始。
+  const columns = eventResultColumns([target, target, target], 3)
+  for (const column of columns) {
+    assert.deepEqual(ranksOf(column.rows), [1, 2, 3, 4, 5, 6])
+    assert.deepEqual(entryIds(column.rows), entryIds(first))
+  }
+})
+
+test('栏数 1 / 2 / 3 / 4 都不漏行、不串栏', () => {
+  const groups = [group(1, [2, 1]), group(2, [1, 2, 3]), group(3, [5, 1, 4, 2, 3]), group(4, [1])]
+  for (const count of [1, 2, 3, 4]) {
+    const columns = eventResultColumns(groups, count)
+    assert.equal(columns.length, count, `要 ${count} 栏`)
+    columns.forEach((column, index) => {
+      const source = groups[index]
+      assert.equal(column.key, `${source?.eventId}-${source?.categoryId}`, '栏与小项按顺序一一对应')
+      // 每栏都是自己那一组的行：一个 entryId 都不许串到别的栏去。
+      const own = new Set((source?.rows ?? []).map((item) => item.entryId))
+      for (const item of column.rows) assert.ok(own.has(item.entryId), '栏里的行必须来自本组的行')
+      assert.equal(column.rows[0]?.rank ?? null, 1, '每栏都从第 1 名开始（该组有第 1 名时）')
+    })
+  }
+})
+
+test('服务端已按名次排好的数据（现网口径）逐行不变', () => {
+  // 现网快照已按名次升序下发，这条钉住「前两栏现在的表现一个字都不能变」：
+  // 选出来的行必须与改造前的 `group.rows.slice(0, 6)` 完全一致。
+  const sorted = group(1, [1, 2, 3, 4, 5, 6, 7, 8])
+  assert.deepEqual(entryIds(eventResultRows(sorted)), entryIds(sorted.rows.slice(0, 6)))
+  assert.deepEqual(
+    ranksOf(eventResultRows(sorted)),
+    ranksOf(sorted.rows.slice(0, 6)),
+  )
+
+  // 并列名次（服务端按发布时间给出先后）不许被重排：屏幕上是「谁先出现谁在上面」。
+  const tied = group(2, [1, 2, 2, 4, 5, 6, 7])
+  assert.deepEqual(entryIds(eventResultRows(tied)), entryIds(tied.rows.slice(0, 6)))
+})
+
+test('无名次的行排在最后，够 6 行时名次行不占位置', () => {
+  // 延迟结算的组名次是 NULL，服务端已把它们排在最后；换序到达时同样要落到底部。
+  const mixed = group(1, [null, 3, 1, null, 2])
+  assert.deepEqual(ranksOf(eventResultRows(mixed)), [1, 2, 3, null, null])
+
+  const full = group(2, [null, 1, 2, 3, 4, 5, 6])
+  assert.deepEqual(ranksOf(eventResultRows(full)), [1, 2, 3, 4, 5, 6])
+  assert.equal(RESULT_ROWS_PER_COLUMN, 6)
+})
+
+test('录取人数不足 6 行时不补行，空组给空数组', () => {
+  const short = group(1, [1, 2, 3])
+  assert.deepEqual(ranksOf(eventResultRows(short)), [1, 2, 3])
+  assert.deepEqual(eventResultRows(null), [])
+  assert.deepEqual(eventResultRows(group(2, [])), [])
+})
+
+test('分项成绩页按「一栏」渲染：用 eventResultColumns 取名次行，不再按到达顺序切前 6 行', () => {
+  const source = readFileSync(
+    new URL('../components/pages/EventResultsPage.vue', import.meta.url),
+    'utf8',
+  )
+  const { descriptor, errors } = parse(source, { filename: 'EventResultsPage.vue' })
+  assert.equal(errors.length, 0, 'EventResultsPage.vue 应能被解析')
+  const template = descriptor.template
+  assert.ok(template != null, 'EventResultsPage.vue 缺少 <template>')
+  assert.deepEqual(
+    compileTemplate({ source: template.content, filename: 'EventResultsPage.vue', id: 'EventResultsPage.vue' }).errors,
+    [],
+    '模板应能编译',
+  )
+
+  assert.match(
+    source,
+    /eventResultColumns\(latestResults\.value, options\.value\.resultsCount\)/,
+    '栏要由 eventResultColumns 收口（含每栏的名次行）',
+  )
+  assert.match(source, /v-for="row in column\.rows"/, '名次行必须来自收口后的 column.rows')
+  assert.doesNotMatch(
+    source,
+    /group\.rows\.slice\(0, 6\)/,
+    '不许再按到达顺序切前 6 行——第 1 名不在前 6 行里就会整行不显示',
+  )
+})

web/src/display/tests/fitFont.test.ts

@@ -206,6 +206,40 @@ test('短单位名不受这条改动影响：字号与不带单位名时一模
   }
 })
 
+// 队伍（迁移 0025）：大屏拿到的是拼好的「单位名 + 队名」（display/jointTeams.ts 的 rowTeamText），
+// 宽度预算必须把队名一起算进去——队名正是用来区分同一个单位的两个队的，被截成省略号就白填了。
+test('队名一起进单位列的宽度预算：列宽跟着内容长，队名不会被省略号截掉', () => {
+  const font = 56
+  const plain = '第一分公司'
+  for (const layout of LAYOUTS) {
+    const base = liveTeamColumnPx([plain], layout, font)
+    for (const name of ['第一分公司一队', '第一分公司青年队']) {
+      const column = liveTeamColumnPx([name], layout, font)
+      assert.ok(column >= base, `${layout}：队名不该让单位列变窄（${column} < ${base}）`)
+      const ink = textEm(name) * 0.78 * font
+      assert.ok(ink <= column, `${layout}：「${name}」墨迹 ${ink}px > 列宽 ${column}px，仍会省略`)
+    }
+  }
+})
+
+test('队名让名字更长时只收字号，不会把名字挤成省略号', () => {
+  const results = ['1:06.33']
+  const plain = ['第一分公司']
+  const squads = ['第一分公司一队', '第一分公司二队']
+  for (const layout of LAYOUTS) {
+    const withSquad = fitLiveRowFontPx(6, layout, results, squads)
+    assert.ok(withSquad <= fitLiveRowFontPx(6, layout, results, plain), `${layout}：长名字只该收字号`)
+    // 收完字号之后，最长的那个队名仍然要装得进它分到的列宽。
+    for (const name of squads) {
+      const ink = textEm(name) * 0.78 * withSquad
+      assert.ok(
+        ink <= liveTeamColumnPx(squads, layout, withSquad),
+        `${layout}：${withSquad}px 字号下「${name}」仍被截`,
+      )
+    }
+  }
+})
+
 test('单位列宽的下限与预算：短名字观感不变，极端长度不再撑破一行', () => {
   for (const layout of LAYOUTS) {
     const geo = liveRowGeometry(layout)

web/src/display/tests/joint-teams.test.ts

@@ -4,6 +4,8 @@ import { readFileSync } from 'node:fs'
 import type { Team } from '@/shared'
 import {
   entryShareIndex,
+  entrySquadIndex,
+  readEntrySquad,
   readEntryTeamShares,
   rowLogoCount,
   rowTeamLogos,
@@ -12,11 +14,13 @@ import {
 } from '../jointTeams'
 
 /**
- * 大屏的联队渲染（devdocs/19）。要钉住的是：
+ * 大屏的联队与队伍渲染（devdocs/19、迁移 0025）。要钉住的是：
  *   1. **单单位（普通报名）时逐字/逐图不变**：文案还是 `shortName ?? teamName`，logo 还是刚那一张，
- *      联队成员表里根本没有这条报名的位置；
+ *      联队成员表与队伍表里根本没有这条报名的位置；
  *   2. 联队时写「A+B联队」（两个单位的名字都写全），单位列两个 logo 都画；
- *   3. 成员单位的 logo 只能从快照的单位表里取（entries 接口不下发 logoPath），
+ *   3. 填了队名时写「第一分公司二队」（不加括号），没填时一个字不变——一个单位两个队
+ *      各自占一个名次，两行必须分得开；
+ *   4. 成员单位的 logo 只能从快照的单位表里取（entries 接口不下发 logoPath），
  *      取不到时那个位置是 null，TeamLogo 不渲染，不会留空洞。
  */
 
@@ -89,10 +93,16 @@ test('普通报名（单单位 / 老服务端没有 teamShares）不进表 = 屏
   assert.equal(index.get(11), undefined)
 })
 
-test('单位列文案：单单位与改造前逐字一致，联队写「A+B联队」', () => {
+test('单位列文案：单单位与改造前逐字一致，联队写「A+B联队」，填了队名写「第一分公司二队」', () => {
   const row = { shortName: '一司', teamName: '第一分公司' }
   assert.equal(rowTeamText(row, null), '一司')
   assert.equal(rowTeamText({ shortName: null, teamName: '第一分公司' }, null), '第一分公司')
+  // 老服务端不下发 squad（null）与空串都走同一条路：一个字符都不多。
+  assert.equal(rowTeamText(row, null, ''), '一司')
+  assert.equal(rowTeamText(row, null, null), '一司')
+  // 队名直接拼在单位名后面，不加括号（大屏单位列宽紧张）。
+  assert.equal(rowTeamText(row, null, '二队'), '一司二队')
+  assert.equal(rowTeamText({ shortName: null, teamName: '第一分公司' }, null, '青年队'), '第一分公司青年队')
   const members = entryShareIndex(
     [
       {
@@ -110,9 +120,32 @@ test('单位列文案：单单位与改造前逐字一致，联队写「A+B联
   assert.ok(members !== null && members !== undefined)
   // 联队写全称：两个单位名一个不少（简称在别的单位的人眼里认不出来）。
   assert.equal(rowTeamText(row, members), '第一分公司+第二分公司联队')
+  assert.equal(rowTeamText(row, members, '二队'), '第一分公司+第二分公司联队二队')
 })
 
-test('底栏一行：有运动员写运动员；团体行的联队写「A+B联队」', () => {
+test('队名索引：只收填了队名的报名，空串 / 缺字段 / 脏数据一律不进表', () => {
+  const index = entrySquadIndex([
+    { id: 11, squad: '一队' },
+    { id: 12, squad: '' },
+    { id: 13 },
+    { id: 14, squad: ' 二队 ' },
+    { id: 15, squad: 2 },
+    { id: 0, squad: '一队' },
+    null,
+  ])
+  assert.equal(index.get(11), '一队')
+  assert.equal(index.get(14), '二队', '两侧空白去掉后再上屏')
+  assert.equal(index.size, 2, '不填队名的报名不在表里 = 按原来那样渲染')
+  assert.equal(index.has(0), false, '没有合法 id 的报名项丢掉')
+  assert.deepEqual(entrySquadIndex([]), new Map())
+
+  assert.equal(readEntrySquad({ squad: '一队' }), '一队')
+  assert.equal(readEntrySquad({ squad: null }), '')
+  assert.equal(readEntrySquad({}), '')
+  assert.equal(readEntrySquad(null), '')
+})
+
+test('底栏一行：有运动员写运动员；团体行的联队写「A+B联队」，带队伍时队名也在', () => {
   const members = entryShareIndex(
     [
       {
@@ -140,6 +173,16 @@ test('底栏一行：有运动员写运动员；团体行的联队写「A+B联
     tickerRowText({ athleteName: null, shortName: '一司', teamName: '第一分公司' }, null),
     '一司',
   )
+  // 底栏一行只差队名时，队名就是唯一的分辨依据（同一个单位的两个队都进了名次）。
+  assert.equal(
+    tickerRowText({ athleteName: null, shortName: '一司', teamName: '第一分公司' }, null, '一队'),
+    '一司一队',
+  )
+  assert.equal(
+    tickerRowText({ athleteName: '', shortName: '一司', teamName: '第一分公司' }, null, '二队'),
+    '一司二队',
+    'athleteName 为空串（团体行）时同样带上队名',
+  )
 })
 
 test('单位列的 logo：普通报名只有行的那一张，联队把两个单位都放上', () => {
@@ -190,6 +233,23 @@ test('大屏为屏上的小项读报名表：读失败静默（屏上仍是主
   const source = readFileSync(new URL('../useScoreboard.ts', import.meta.url), 'utf8')
   assert.match(source, /api\.events\.entries\(eventId\)/, '成员单位只能来自报名表')
   assert.match(source, /entryShareIndex\(entries, teams\.value\)/, 'logo 要从快照单位表里补')
+  assert.match(source, /entrySquadIndex\(entries\)/, '队名与成员单位同一次请求，不为它多发一个请求')
   assert.match(source, /catch \{/, '拿不到报名表时按单单位渲染，不能弹错或清屏')
   assert.match(source, /jointTeamOf/, '页面通过 jointTeamOf 取成员单位')
+  assert.match(source, /squadOf/, '页面通过 squadOf 取队名')
+})
+
+// 三处渲染点都要把队名接上：少接一处，那一页上同一个单位的两个队就分不开了。
+test('分项成绩 / 实时赛况 / 底栏三处都把队名传进单位列文案', () => {
+  const call = /rowTeamText\(row, jointTeamOf\(row\.entryId\), squadOf\(row\.entryId\)\)/
+  const pages: [string, RegExp][] = [
+    ['../components/pages/EventResultsPage.vue', call],
+    ['../components/pages/LivePage.vue', call],
+    ['../components/TickerBar.vue', /tickerRowText\(row, jointTeamOf\(row\.entryId\), squadOf\(row\.entryId\)\)/],
+  ]
+  for (const [file, pattern] of pages) {
+    const source = readFileSync(new URL(file, import.meta.url), 'utf8')
+    assert.match(source, pattern, `${file} 没把队名接进单位列`)
+    assert.match(source, /squadOf/, `${file} 要从 useScoreboard 取 squadOf`)
+  }
 })

web/src/display/tests/live-page.test.ts

@@ -332,10 +332,14 @@ test('单位列宽同样由内容算出来，长单位名不再被写死列宽
   // 单栏与拆两块：单位列写成 minmax(内容宽, 1fr)，短名字时与运动员列一样宽，观感不变。
   assert.match(source, /minmax\(var\(--team-width, 300px\), 1fr\)/)
   assert.match(source, /minmax\(var\(--team-width, 150px\), 1fr\)/)
-  // 页面必须把单位名（联队时是「A+B联队」）与 logo 一起喂给字号计算，
-  // 否则又变成「算完字号再被单位名挤破」；logo 的份数也要喂（联队一行两个 logo）。
+  // 页面必须把单位名（联队时是「A+B联队」，填了队名时是「第一分公司二队」）与 logo 一起喂给
+  // 字号计算，否则又变成「算完字号再被单位名挤破」；logo 的份数也要喂（联队一行两个 logo）。
   assert.match(source, /liveTeamColumnPx/)
-  assert.match(source, /rowTeamText\(row, jointTeamOf\(row\.entryId\)\)/)
+  assert.match(
+    source,
+    /rowTeamText\(row, jointTeamOf\(row\.entryId\), squadOf\(row\.entryId\)\)/,
+    '队名要一起进单位列文案：宽度预算按实际写出来的字算',
+  )
   assert.match(source, /rowLogoCount\(row, jointTeamOf\(row\.entryId\)\)/)
   assert.match(source, /'--team-width': `\$\{liveTeamColumnPx/)
   assert.match(

web/src/display/tests/results.test.ts

@@ -0,0 +1,119 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import type { EventResultRow } from '@/shared'
+import { parseEventResultGroups } from '../guards'
+import { RESULT_PLACEHOLDER, displayResult, eventResultColumns, resultTextOrPlaceholder } from '../results'
+
+// 现场缺陷：分项成绩页每一栏的行里只有名次、没有成绩。原因是这些项目「手动录名次」
+// （台球、篮球那类，只录名次、没有成绩值）：服务端 resultValue 给 null、resultText 给空串，
+// 原来 displayResult 就把空串原样画了出去——大屏上那一格空着，看着像渲染坏了。
+// 这里把「成绩列写什么字」收口成一条口径：拿不到内容时与名次列 `row.rank ?? '—'` 同一个占位字符。
+
+function row(over: Partial<EventResultRow> = {}): EventResultRow {
+  return {
+    entryId: 1,
+    rank: 1,
+    teamId: 1,
+    teamCode: 'T1',
+    teamName: '第一分公司',
+    shortName: null,
+    logoPath: null,
+    athleteId: 1,
+    athleteName: '张伟',
+    memberNames: null,
+    resultText: '11.58',
+    resultValue: 11.58,
+    unit: 's',
+    isTie: false,
+    status: 'ok',
+    ...over,
+  }
+}
+
+test('手录名次的项目没有成绩值：成绩列给占位，不是空串（现场看到的那一格空白）', () => {
+  // 台球：只录了名次，resultValue 与 resultText 都拿不到内容。
+  const billiards = row({ resultValue: null, resultText: '' })
+  assert.notEqual(displayResult(billiards), '', '空串会让大屏那一格看起来像渲染坏了')
+  assert.equal(displayResult(billiards), '—', '占位字符要与名次列一致')
+})
+
+test('服务端下发的手录名次行走完整条链路（解析 → 分栏 → 成绩列）也写占位', () => {
+  // 服务端形状：台球只录名次，result_value 与 result_text 都写空。
+  const snapshot = [
+    {
+      eventId: 21,
+      eventCode: 'BILLIARD',
+      eventName: '台球男子组',
+      categoryId: 3,
+      categoryName: '青年组',
+      publishedAt: '2026-09-14T10:00:00+08:00',
+      rows: [
+        {
+          entryId: 501,
+          rank: 1,
+          teamId: 2,
+          teamCode: 'T2',
+          teamName: '第一分公司',
+          athleteName: '张伟',
+          resultText: '',
+          resultValue: null,
+          unit: '',
+          status: 'ok',
+        },
+      ],
+    },
+  ]
+  const columns = eventResultColumns(parseEventResultGroups(snapshot), 1)
+  const drawn = columns[0]?.rows.map((item) => displayResult(item)) ?? []
+  assert.deepEqual(drawn, ['—'], '手录名次的项目画出来的是占位，不是空串')
+})
+
+test('有成绩值时逐字不变（数值 + 单位的原有格式）', () => {
+  assert.equal(displayResult(row({ resultValue: 11.58, unit: 's' })), '11.58')
+  assert.equal(displayResult(row({ resultValue: 6.12, unit: 'm' })), '6.12米')
+  assert.equal(displayResult(row({ resultValue: 10, unit: 'pts' })), '10分')
+  assert.equal(displayResult(row({ resultValue: 3, unit: '次' })), '3次')
+  assert.equal(displayResult(row({ resultValue: 12.5, unit: '' })), '12.5')
+  // 没有比较值但有原文（老契约）：原文照旧，不被占位顶掉。
+  assert.equal(displayResult(row({ resultValue: null, resultText: '4:10.88', unit: 's' })), '4:10.88')
+})
+
+test('非 ok 状态仍然是状态文案，不许回归', () => {
+  assert.equal(displayResult(row({ status: 'dq' })), 'DQ')
+  assert.equal(displayResult(row({ status: 'dns' })), 'DNS')
+  assert.equal(displayResult(row({ status: 'dnf' })), 'DNF')
+  assert.equal(displayResult(row({ status: 'withdrawn' })), '退赛')
+  // 异常状态优先于数值：有成绩也写状态文案。
+  assert.equal(displayResult(row({ status: 'dq', resultValue: 11.58 })), 'DQ')
+})
+
+test('底栏「最新完成项目」的成绩格走同一口径，不再直接绑 resultText', () => {
+  const source = readFileSync(new URL('../components/TickerBar.vue', import.meta.url), 'utf8')
+  assert.match(source, /<span class="chip-stat">\{\{ displayResult\(row\) \}\}<\/span>/)
+  assert.doesNotMatch(source, /\{\{ row\.resultText \}\}/)
+})
+
+test('积分明细的成绩格：空串也退成占位，不出现空白格', () => {
+  const source = readFileSync(new URL('../components/DetailOverlay.vue', import.meta.url), 'utf8')
+  assert.doesNotMatch(source, /item\.resultText \?\? '—'/, '`??` 只挡 null，空串照样画成空白')
+  assert.match(source, /\{\{ resultTextOrPlaceholder\(item\.resultText\) \}\}/)
+})
+
+test('占位字符与名次列写的必须是同一个字，且原文照旧透传', () => {
+  // 不写死字面量：从名次列现取，改了那边这条就会红，两列不会再各写各的。
+  const page = readFileSync(
+    new URL('../components/pages/EventResultsPage.vue', import.meta.url),
+    'utf8',
+  )
+  const rankCell = /<span class="rk">\{\{ row\.rank \?\? '(.)' \}\}<\/span>/.exec(page)
+  assert.ok(rankCell !== null, '分项成绩页的名次列应写 `row.rank ?? 占位`')
+  assert.equal(RESULT_PLACEHOLDER, rankCell[1])
+
+  assert.equal(resultTextOrPlaceholder('4:10.88'), '4:10.88')
+  assert.equal(resultTextOrPlaceholder(''), RESULT_PLACEHOLDER)
+  assert.equal(resultTextOrPlaceholder(null), RESULT_PLACEHOLDER)
+  assert.equal(resultTextOrPlaceholder(undefined), RESULT_PLACEHOLDER)
+  // 类型上写的是 string、运行时混进非字符串时也不许把 null 画进格子。
+  assert.equal(resultTextOrPlaceholder(42 as unknown as string), RESULT_PLACEHOLDER)
+})

web/src/display/useScoreboard.ts

@@ -21,7 +21,7 @@ import {
   parseTeamBreakdown,
 } from './guards'
 import type { DisplayLiveFeed, DisplaySettings, DisplaySnapshot } from './guards'
-import { entryShareIndex } from './jointTeams'
+import { entryShareIndex, entrySquadIndex } from './jointTeams'
 import type { DisplayTeamShare } from './jointTeams'
 import { DEFAULT_ANNOUNCE_SECONDS, createAnnouncement, resolveAnnounceText } from './announce'
 import { applyDisplayFonts } from './fonts'
@@ -258,7 +258,7 @@ function reportLiveFailure(wasStale: boolean, reason: string): void {
 }
 
 // ---------------------------------------------------------------------------
-// 联队成员（一条报名挂在多个单位下，devdocs/19）
+// 联队成员与队伍（一条报名挂在多个单位下 / 是单位的第几支队，devdocs/19）
 // ---------------------------------------------------------------------------
 
 /**
@@ -270,6 +270,12 @@ function reportLiveFailure(wasStale: boolean, reason: string): void {
  */
 const entryShares = ref<Map<number, DisplayTeamShare[]>>(new Map())
 
+/**
+ * `entryId → 队名`（只收填了队名的）。与 entryShares 同一次请求、同一份 TTL，
+ * 所以「一个单位两个队」不需要大屏多发一个请求；取不到就是空串 = 名字与改造前逐字相同。
+ */
+const entrySquads = ref<Map<number, string>>(new Map())
+
 /** 每个小项上次成功拉到报名表的时间；为 0 表示没拉过。 */
 const sharesFetchedAt = new Map<number, number>()
 /** 正在飞的小项，避免定时刷新把同一个请求叠成好几份。 */
@@ -291,18 +297,31 @@ async function loadEventShares(eventId: number): Promise<void> {
   try {
     const entries = await api.events.entries(eventId)
     const index = entryShareIndex(entries, teams.value)
-    const next = new Map(entryShares.value)
-    for (const id of shareEntryIds.get(eventId) ?? []) next.delete(id)
-    const ids: number[] = []
-    for (const [entryId, members] of index) {
-      next.set(entryId, members)
-      ids.push(entryId)
+    const squads = entrySquadIndex(entries)
+    const nextShares = new Map(entryShares.value)
+    const nextSquads = new Map(entrySquads.value)
+    // 重读要先删掉上次读回来的那些报名：改成单单位 / 清掉队名后，旧值不能留在屏上。
+    const previousIds = shareEntryIds.get(eventId) ?? []
+    for (const id of previousIds) {
+      nextShares.delete(id)
+      nextSquads.delete(id)
     }
-    shareEntryIds.set(eventId, ids)
-    entryShares.value = next
+    const ids = new Set<number>()
+    for (const [entryId, members] of index) {
+      nextShares.set(entryId, members)
+      ids.add(entryId)
+    }
+    for (const [entryId, squad] of squads) {
+      nextSquads.set(entryId, squad)
+      // 只有队名的报名同样要记住 id，下次重读才删得掉。
+      ids.add(entryId)
+    }
+    shareEntryIds.set(eventId, [...ids])
+    entryShares.value = nextShares
+    entrySquads.value = nextSquads
     sharesFetchedAt.set(eventId, Date.now())
   } catch {
-    // 静默：没有联队信息时屏上仍是主单位，与升级前一致。
+    // 静默：没有联队 / 队伍信息时屏上仍是主单位，与升级前一致。
   } finally {
     sharesInFlight.delete(eventId)
   }
@@ -332,6 +351,11 @@ function jointTeamOf(entryId: number): DisplayTeamShare[] | null {
   return entryShares.value.get(entryId) ?? null
 }
 
+/** 某个报名项的队名；没填 / 没读到都是 null，调用方渲染出与升级前逐字相同的单位名。 */
+function squadOf(entryId: number): string | null {
+  return entrySquads.value.get(entryId) ?? null
+}
+
 watch(sharesKey, () => {
   void ensureEntryShares(sharesEventIds.value)
 })
@@ -733,6 +757,7 @@ export function useScoreboard() {
     events,
     teams,
     jointTeamOf,
+    squadOf,
     liveFeed,
     liveStale,
     page,