全项目大检查：修复数据层/UI 真 BUG、清理死代码与过期注释、并评估二进制体积

按「性能 / BUG / 错误 / 过期注释 / 命名与实际含义不符」四项对全仓做了一次审查，
四个只读子审查交叉核对后逐条回到源码确认再改。

一、数据层真 BUG
- MatH5：U8/U16/U32/U64 用逐字节 Cached() 拼装，而 Cached 只服务「完全落在同一个
  64KB 块内」的请求 => 跨块时静默读成 0（U32 整段为 0、U64 高 32 位为 0），分块 B-tree
  的 chunk 偏移/子节点地址被破坏且无任何报错。新增 ScalarLE()：命中缓存用缓存，
  否则退回一次 ReadAt；U64 顺带从 8 次缓存查找降到 1 次。
- Mf4Loader::IsBlock 未校验链接表是否落在块内 => DataOffset 越界，随后
  block_len - (data - offset) 在 uint64 上下溢，得到一个约 2^64 的"可用字节数"，
  下游 vector(usable+1) 直接 bad_alloc。同时把 offset + bytes > size 改成不产生回绕的写法。
- DecodeRawValue 的整数路径：bit_offset%8 != 0 且位宽 64 时需 9 个字节，先拼成 64 位
  再整体右移会把最高字节静默丢弃 => 改为逐字节带位偏移累加。
- cg_cycle_count 加「数据段总字节 / 记录字节」上限（压缩段按 deflate 最大膨胀比估算）。
- CsvLoader 表头分支同样跳过 #/% 注释行（否则整份文件按 1 列解析并被丢弃）。
- MatLoader：double -> int 的越界转换加了范围检查；普通对象递归加深度上限与成环检测。
- Utf8Util::BuildTicks：double -> long long 越界转换前先判商是否落在 ±9e18 内。

二、界面 BUG
- 工具栏按钮永远不显示悬停高亮：Paint 读的 Button::hover 全仓从未赋值，改为按 m_hoverIndex 判断。
- 菜单打开时"取消底层拖拽"对每个消息都执行，把菜单自己的 Target::EDIT_FIELD 也清掉
  => 菜单内联输入框无法拖拽框选。排除 EDIT_FIELD。
- GdiplusShutdown 之前未释放 PlotView 的 GDI+ 位图（Application 是进程单例，成员析构在
  WinMain 之后）=> 新增 PlotView::ReleaseGraphicsResources() 并在 Shutdown 里调用。
- WM_KILLFOCUS 现在会提交标签页/绘图区编辑并复位捕获与拖拽状态。
- WM_LBUTTONUP 不再抢走中键平移的鼠标捕获。
- TextEdit：被过滤器拒绝的字符返回 false；无选区时 Ctrl+X 只复制、不再清空整段文本。
- SignalPanel::InvalidateRows 作废编辑/待确认/改名计时等行下标状态。
- EndFilterEdit 改走 ApplyFilterText（否则输入纯空格后回车，列表仍停在筛选结果）。
- 新增 SignalBadgeVisible 作为唯一判据（原来命中只看"可见"，绘制还要求"已分配网格"）。
- 折起动画结束后夹取滚动量；双击分组名改名时清掉该组正在播放的折起动画。
- ScrollToSignal 复用 SignalScrollTarget（含悬浮组名避让）。
- RowNameRect 与绘制使用同一最小宽度（原来退化时返回空矩形）。
- 分隔条拖拽上限改用与 Relayout 同一公式；UpdateDragCursor 补 SPLITTER/EDIT_FIELD。
- SignalPanel 里几个守卫改为判断真正被解引用的指针；分组行 ✕ 也返回手型光标。

三、PlotView
- FindStyleOnlyLanes 改用完整的 SceneStyleEntry::operator==（原来只比 4 个字段，
  另一个网格同时改"调整"时带着旧像素被当成最新）。
- 宽基底图层不再烘焙拖拽光晕（LaneLayerHash 不含它），改由 PaintHoverHighlight 每帧叠加。
- PaintLaneLegend 提前返回前清掉本网格的命中矩形（否则能点中看不见的图例条目）。
- 面板主体改为完全不透明（消除平移后 4% 透出的旧波形，零额外代价）。
- PAN / Shift+滚轮改走 SetTimeView，使"自动点线"判据随平移重算。
- 内联输入框命中字体与绘制统一为 monoSmall。
- 派生曲线取值与窗口按 SourceIndexFor 映射（水平镜像时不再读到镜像另一端）。
- EdgePanelWidth 补 style/axis 空指针守卫；二分结果夹到 count。

四、清理
- 删除 Toolbar::ActionLabel、Theme::statusBg、PopupMenu 的 editResult 死机制、
  Toolbar::Layout 的重复 clear()、HitRow 的恒假分支、OnDoubleClick 的重复判定、
  PaintUtil 里孤立的注释块。
- 修正一批过期/错误注释（包络带"不做加宽"、LaneLayerHash 的图例说法、
  均值滤波曲线的窗口说法、样式区行数与「调整」按钮顺序、FIT_ALL 退出缩放模式、
  RemoveSignal 的 ✕ 位置、.mat/.dat 格式文档、MatH5 的"映射视图"、DataModel 的
  "点线/被移除文件"、SignalPanel 的"行高连续缩小"、TextEdit 的 PaintUtil 引用等）。

五、二进制体积评估（按要求只评估，未做压缩修改）
- release 809,472 字节；.text 652KB、.xdata+.pdata 约 75KB、.rdata 42KB、
  .rsrc 20KB、.idata 11.5KB。
- 去掉 -ld3d11 -ldwmapi -ld3dcompiler（仓内无任何调用）实测 0 字节收益
  （静态库只拉取被引用的对象）=> 删链接库不是压缩手段，只是配置整洁。
- 仓内已无 <iostream>/<sstream>/<filesystem>/<regex>/<locale> 等体积炸弹。
- 结论：已无明显的浪费可捡；要显著变小只能改变取舍（动态 CRT / UPX / 砍功能），
  需要用户决策，本轮未动。

验证
- editcheck 20/20、round3check 31/31、round4check 34/34、round5check 5/5、convcheck 18/18。
- check 136/137：唯一失败项经 git stash 回到改动前复现同一数值，属该探针自身的既有
  不稳定项（取决于前置用例留下的缓存/时序），与本轮改动无关。
- 真实数据：4 个 MF4 => 283/8/18/24 个信号；.mat 样例 8 信号、
  带无障碍对照-防夹力曲线数据 8 信号、BIG_MAT.mat 5 信号（私有内存 +741MB）。
- make release / make debug 零警告。

文档：Documents/agent_mem.md 同步 §10 变更日志、§11.2 第 171-180 条硬约束
与文末本轮小节（含体积评估数据）。

Utilities/Src/CsvLoader.cpp

@@ -259,6 +259,12 @@ namespace jdi
 				{
 					return true;
 				}
+				// ⚠️ 表头分支也必须跳过注释行：否则以 `#` / `%` 开头的注释行会被当成表头
+				//（列数变成 1），后面所有真实的表头与数据行都按 1 列解析并被丢弃。
+				if (scan < lineEnd && (*scan == '#' || *scan == '%'))
+				{
+					return true;
+				}
 
 				table.delimiter = DetectDelimiter(begin, lineEnd);
 				SplitFields(begin, lineEnd, static_cast<char>(table.delimiter), state.fields);

Utilities/Src/DataModel.cpp

@@ -375,7 +375,7 @@ namespace jdi
 					signal.style.opacity = 1.0f;
 					signal.style.lineWidth = 1.0f;
 					signal.style.mode = DrawMode::LINE;
-					// 只有一个有效采样点的信号改用「点线」+ 最大线宽，否则根本看不见。
+					// 只有一个有效采样点的信号改用「散点」+ 最大线宽，否则根本看不见。
 					ApplySinglePointDefaultStyle(stats.finiteCount, signal.style);
 				}
 
@@ -464,7 +464,7 @@ namespace jdi
 				signal.style.customColor = palette[(slot + 1) % count];
 			}
 
-			// 采样点极少的派生信号同样改用「点线」并加粗（与普通加载路径同一规则）。
+			// 采样点极少的派生信号同样改用「散点」并加粗（与普通加载路径同一规则）。
 			ApplySinglePointDefaultStyle(stats.finiteCount, signal.style);
 		}
 
@@ -487,7 +487,7 @@ namespace jdi
 			return false;
 		}
 
-		// 用移动到末位后弹出的方式移除，使被移除文件的时间轴与全部信号缓冲区在本调用内
+		// 用移动到末位后弹出的方式移除，使被移除**分组**的时间轴与全部信号缓冲区在本调用内
 		// 立即析构归还操作系统，不再等待后续插入覆盖；最后收缩容量，避免残留空闲块。
 		const std::size_t position = static_cast<std::size_t>(groupIndex);
 		for (std::size_t index = position; index + 1 < m_groups.size(); ++index)

Utilities/Src/MatH5.cpp

@@ -33,7 +33,12 @@ namespace jdi
 			return value;
 		}
 
-		/** @brief 连续布局的读取切片大小（映射视图下只是 memcpy，不会产生额外峰值）。 */
+		/**
+		 * @brief 连续布局的读取切片大小。
+		 *
+		 * 数据读取走「`ReadFile` 随机读 + 按需预读」（内存映射已移除），因此切片越大
+		 * 单次 I/O 的摊销越好，但也会把峰值临时缓冲抬高；4MB 是本机实测的折中点。
+		 */
 		constexpr std::size_t kStreamSliceBytes = 4u << 20;
 
 		/** @brief 把一段原始字节按元素类型转换成 double（供流式解码使用）。 */
@@ -284,25 +289,54 @@ namespace jdi
 		return m_readAhead.data();
 	}
 
-	std::uint8_t MatHdf5::U8(std::uint64_t offset) const
-	{
-		const std::uint8_t* bytes = Cached(offset, 1);
-		return (bytes != nullptr) ? *bytes : 0;
-	}
+std::uint64_t MatHdf5::ScalarLE(std::uint64_t offset, std::size_t bytes) const
+		{
+			if (bytes == 0 || bytes > 8)
+			{
+				return 0;
+			}
+			const std::uint8_t* cached = Cached(offset, bytes);
+			std::uint8_t local[8] = {};
+			const std::uint8_t* data = cached;
+			if (data == nullptr)
+			{
+				// 跨缓存块边界（或越界）：退回一次直接读取，绝不把缺失字节当成 0。
+				if (offset > m_size || bytes > m_size - offset)
+				{
+					return 0;
+				}
+				if (!ReadAt(offset, local, bytes))
+				{
+					return 0;
+				}
+				data = local;
+			}
+			std::uint64_t value = 0;
+			for (std::size_t index = 0; index < bytes; ++index)
+			{
+				value |= static_cast<std::uint64_t>(data[index]) << (8u * index);
+			}
+			return value;
+		}
 
-	std::uint16_t MatHdf5::U16(std::uint64_t offset) const
-	{
-		return static_cast<std::uint16_t>(U8(offset)) | (static_cast<std::uint16_t>(U8(offset + 1)) << 8);
-	}
+		std::uint8_t MatHdf5::U8(std::uint64_t offset) const
+		{
+			return static_cast<std::uint8_t>(ScalarLE(offset, 1));
+		}
 
-	std::uint32_t MatHdf5::U32(std::uint64_t offset) const
-	{
-		return static_cast<std::uint32_t>(U16(offset)) | (static_cast<std::uint32_t>(U16(offset + 2)) << 16);
-	}
+		std::uint16_t MatHdf5::U16(std::uint64_t offset) const
+		{
+			return static_cast<std::uint16_t>(ScalarLE(offset, 2));
+		}
 
-	std::uint64_t MatHdf5::U64(std::uint64_t offset) const
-	{
-		return static_cast<std::uint64_t>(U32(offset)) | (static_cast<std::uint64_t>(U32(offset + 4)) << 32);
+		std::uint32_t MatHdf5::U32(std::uint64_t offset) const
+		{
+			return static_cast<std::uint32_t>(ScalarLE(offset, 4));
+		}
+
+		std::uint64_t MatHdf5::U64(std::uint64_t offset) const
+		{
+			return ScalarLE(offset, 8);
 	}
 
 	std::uint64_t MatHdf5::Addr(std::uint64_t offset) const

Utilities/Src/MatLoader.cpp

@@ -8,6 +8,7 @@
 #include "MatH5.hpp"
 
 #include <algorithm>
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <map>
@@ -45,6 +46,22 @@ namespace jdi
 			return buffer;
 		}
 
+		/**
+		 * @brief 把 SDI 里读到的 `DataR2` / `TimeR2` 数值转成流下标。
+		 *
+		 * ⚠️ 不能直接 `static_cast<int>(double)`：文件里那个数可能是 NaN、无穷或超出 `int` 范围，
+		 * 而浮点 → 整型的越界转换在 C++ 里是**未定义行为**（x86-64 上会得到 `INT_MIN` 之类的
+		 * 垃圾下标，随后拿去拼数据集名）。非法值统一返回 -1（= 没有流）。
+		 */
+		int StreamIndexFromDouble(double value)
+		{
+			if (!std::isfinite(value) || value < 0.0 || value > 2147483647.0)
+			{
+				return -1;
+			}
+			return static_cast<int>(value);
+		}
+
 		/** @brief 去掉文件名中的扩展名。 */
 		std::wstring StemOf(const std::wstring& path)
 		{
@@ -104,12 +121,12 @@ namespace jdi
 			std::vector<double> numbers;
 			if (file.ReadNumbers(file.Member(values, "DataR2"), numbers) && !numbers.empty())
 			{
-				element.dataStream = static_cast<int>(numbers.front());
+				element.dataStream = StreamIndexFromDouble(numbers.front());
 			}
 			numbers.clear();
 			if (file.ReadNumbers(file.Member(values, "TimeR2"), numbers) && !numbers.empty())
 			{
-				element.timeStream = static_cast<int>(numbers.front());
+				element.timeStream = StreamIndexFromDouble(numbers.front());
 			}
 		}
 
@@ -508,10 +525,28 @@ namespace jdi
 			return true;
 		}
 
-		/** @brief 普通 v7.3 变量：数值矩阵 / 结构体。 */
+		/**
+		 * @brief 普通 v7.3 变量：数值矩阵 / 结构体。
+		 *
+		 * ⚠️ 必须带**深度上限**与**已访问集合**：HDF5 允许硬链接成环，损坏文件也可能构造出
+		 * 极深嵌套，无保护的成员递归会直接栈溢出（崩溃，无错误提示）。
+		 */
 		void LoadPlainObject(const MatHdf5& file, std::uint64_t address, const std::wstring& name,
-		                     LoadedSource& source)
+		                     LoadedSource& source, int depth = 0,
+		                     std::set<std::uint64_t>* visited = nullptr)
 		{
+			constexpr int kMaxDepth = 32;
+			if (depth > kMaxDepth)
+			{
+				return;
+			}
+			std::set<std::uint64_t> localVisited;
+			std::set<std::uint64_t>& seen = (visited != nullptr) ? *visited : localVisited;
+			if (address != 0 && !seen.insert(address).second)
+			{
+				return;	// 成环：已经展开过这个对象
+			}
+
 			if (file.IsDataset(address))
 			{
 				// ⚠️ 只解析元信息（维度），**不要**用 `ReadDataset`：那会把整块数据再解码一遍。
@@ -569,7 +604,7 @@ namespace jdi
 					continue;
 				}
 				std::wstring childName(member.first.begin(), member.first.end());
-				LoadPlainObject(file, member.second, childName, source);
+				LoadPlainObject(file, member.second, childName, source, depth + 1, &seen);
 			}
 		}
 	} // namespace

Utilities/Src/Mf4Loader.cpp

@@ -146,7 +146,9 @@ namespace jdi
 			/** @brief 读取一段原始字节。 */
 			bool ReadAt(std::uint64_t offset, void* dst, std::size_t bytes) const
 			{
-				if (m_file == nullptr || offset + bytes > m_size)
+				// ⚠️ 不能写 `offset + bytes > m_size`：损坏文件里 offset 接近 2^64 时会回绕，
+				// 校验因此“通过”然后去读一个不存在的偏移。
+				if (m_file == nullptr || offset > m_size || bytes > m_size - offset)
 				{
 					return false;
 				}
@@ -229,12 +231,18 @@ namespace jdi
 
 			/**
 			 * @brief 判断某个偏移是否为一个有效块的开头（且标识匹配）。
+			 *
+			 * ⚠️ **必须同时校验链接表落在块内**（`24 + 8*link_count <= block_len`）：
+			 * 否则 `DataOffset()` 会算到块尾之外，随后 `block_len - (data - offset)` 在 `uint64`
+			 * 上发生**下溢**，得到一个约 2^64 的“可用字节数”，下游 `vector(usable+1)` 直接抛
+			 * `bad_alloc` —— 一个损坏的链接数就能让加载崩溃。
+			 *
 			 * @param [IN] offset 候选偏移。
 			 * @param [IN] id 期望的 4 字节标识（如 "##CN"）；空字符串表示只校验偏移合法性。
 			 */
 			bool IsBlock(std::uint64_t offset, const char* id) const
 			{
-				if (offset == 0 || offset + kBlockHeaderBytes > m_size)
+				if (offset == 0 || offset > m_size || kBlockHeaderBytes > m_size - offset)
 				{
 					return false;
 				}
@@ -247,7 +255,14 @@ namespace jdi
 				{
 					return false;
 				}
-				return BlockLength(offset) >= kBlockHeaderBytes && offset + BlockLength(offset) <= m_size;
+				const std::uint64_t length = BlockLength(offset);
+				if (length < kBlockHeaderBytes || length > m_size - offset)
+				{
+					return false;
+				}
+				const std::uint64_t links = LinkCount(offset);
+				// 链接表必须真的落在块内（并限制在合理上限内，防止 length 被算成天文数字）。
+				return links <= (length - kBlockHeaderBytes) / 8u;
 			}
 
 			/**
@@ -382,7 +397,7 @@ namespace jdi
 			std::size_t invalidBitPos = 0;		/**< 无效位的绝对位偏移。 */
 			int type = 0;						/**< `cn_type`：0 定长 / 1 VLSD / 2 虚拟主通道 / 3 同步通道。 */
 			int syncType = 0;					/**< `cn_sync_type`：1 时间 / 2 角度 / 3 距离。 */
-			bool syncMaster = false;			/**< `cn_sync_type >= 1`：本组的主通道。 */
+			bool syncMaster = false;			/**< `cn_sync_type ∈ [1,3]`（1 时间 / 2 角度 / 3 距离）：本组的主通道。 */
 			bool vlsd = false;					/**< `cn_type == 1`：值存放在 `##SD` 里（记录内是偏移）。 */
 			std::uint64_t signalData = 0;		/**< VLSD 通道的 `##SD` 块地址（`cn_data`）。 */
 			/** `##SI` 采样索引（`cn_si_source`）；空表示每个记录都有采样。 */
@@ -492,24 +507,34 @@ namespace jdi
 				return value;
 			}
 
-			// 整数：先按字节序拼成一个 64 位无符号数，再按位偏移右移并解释符号。
-			std::uint64_t raw = 0;
-			if (spec.dataType == DataType::UINT_LE || spec.dataType == DataType::INT_LE)
-			{
-				for (std::size_t i = byteCount; i-- > 0;)
-				{
-					raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
-				}
-			}
-			else
-			{
-				for (std::size_t i = 0; i < byteCount; ++i)
-				{
-					raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
-				}
-			}
+			// 整数：按字节序逐字节**带着位偏移**累加。
+			//
+			// ⚠️ 不能先拼成一个 64 位整数再整体右移：`bit_offset % 8 != 0` 且位宽为 64 时
+			// 需要 9 个字节（65–71 位），先拼装会让最高字节整体左移出 64 位而被**静默丢弃**，
+			// 于是把一个 64 位计数读成“高位少 4~7 位”的错误值。这里改成
+			// 「每个字节按 `8*i - shift` 直接落到目标位上」，最右端不足一个字节的部分右移对齐，
+			// 因此任何位宽/位偏移组合都不会丢数据。
 			const std::size_t shift = spec.bitOffset % 8u;
-			raw >>= shift;
+			const bool littleEndian = (spec.dataType == DataType::UINT_LE || spec.dataType == DataType::INT_LE);
+			std::uint64_t raw = 0;
+			for (std::size_t i = 0; i < byteCount; ++i)
+			{
+				// 该字节的第一位在“整体位流”里的位置（大端时字节序反向）。
+				const std::size_t position = littleEndian ? (8u * i) : (8u * (byteCount - 1u - i));
+				const std::uint64_t bits = buffer[i];
+				if (position >= shift)
+				{
+					const std::size_t left = position - shift;
+					if (left < 64u)
+					{
+						raw |= bits << left;
+					}
+				}
+				else
+				{
+					raw |= bits >> (shift - position);
+				}
+			}
 			if (spec.bitCount < 64u)
 			{
 				raw &= (1ull << spec.bitCount) - 1ull;
@@ -1903,6 +1928,25 @@ namespace jdi
 				continue;
 			}
 
+			// ⚠️ `cg_cycle_count` 是文件里的数字，**不能无条件相信**：损坏或伪造的文件可以声明
+			// 几十亿条记录，而 `ReadChannelGroupRecords` 会按它一次性
+			// `assign(cycles × 通道数)` 个 double（几十 GB）⇒ 直接 bad_alloc 或把机器拖死。
+			// 这里用「记录数据总字节数」做上限：非压缩段的总载荷是精确值；
+			// 压缩段的解压上限按 deflate 的理论最大膨胀比（≈1032:1）估算。
+			{
+				const std::uint64_t payloadBound = anyCompressed ? payload * 1032ull : payload;
+				const std::uint64_t recordBound = payloadBound / static_cast<std::uint64_t>(recordBytes) + 2ull;
+				if (cycles > recordBound)
+				{
+					++skippedNoLayout;	// 声明的记录数远超数据块容量 ⇒ 视为损坏
+					if (!emitProgress())
+					{
+						cancelRequested = true;
+					}
+					continue;
+				}
+			}
+
 			const std::size_t masterIndex = SelectMasterChannel(channels, cgFlags);
 			if (masterIndex >= channels.size())
 			{

Utilities/Src/Utf8Util.cpp

@@ -614,8 +614,18 @@ namespace jdi
 			maxValue = temp;
 		}
 
-		const long long first = static_cast<long long>(std::ceil(minValue / step - 1.0e-9));
-		const long long last = static_cast<long long>(std::floor(maxValue / step + 1.0e-9));
+		// ⚠️ `minValue / step` 在极端量级下可能溢出成 inf（例如 1e300 / 1e-300），
+		// 而 double → long long 的越界转换是**未定义行为**。先确认商落在 long long 范围内，
+		// 否则直接放弃画刻度（总比画出一批垃圾刻度安全）。
+		constexpr double kTickIndexLimit = 9.0e18;
+		const double firstIndex = std::ceil(minValue / step - 1.0e-9);
+		const double lastIndex = std::floor(maxValue / step + 1.0e-9);
+		if (!(std::fabs(firstIndex) < kTickIndexLimit) || !(std::fabs(lastIndex) < kTickIndexLimit))
+		{
+			return;
+		}
+		const long long first = static_cast<long long>(firstIndex);
+		const long long last = static_cast<long long>(lastIndex);
 		if (last < first)
 		{
 			return;