diff --git a/architecture/notes/pebrel_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md b/architecture/notes/pebrel_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md new file mode 100644 index 000000000..fde1b1d0d --- /dev/null +++ b/architecture/notes/pebrel_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md @@ -0,0 +1,59 @@ +# 显示快照的有界解码与宽字符边界 + +## Status + +#235 的候选审计修正,待审核。沿用现有 JSON 字段,不改变后台发布协议。 + +## Context + +编码文件的字节限额不能代替解码对象限额。先反序列化嵌套 Vec 再 validate, +会在拒绝输入前分配大量空行、单元格或组合字符。宽字符占位参与文本提取和 +重排;行首孤立占位会使文本提取回退到负列。另一方面,终端删除半个宽字符 +后的重排可能留下孤立标志,严格拒绝会让正常编辑后的输出无法恢复。 + +## Evidence + +- [解码器](../../../../pebrel_terminal/src/grid/snapshot/serialization.rs)原先先生成完整 WireSnapshot。 +- [快照回归测试](../../../../pebrel_terminal/src/grid/snapshot.rs)用超限有效元素后接畸形尾部,证明解码必须先因预算失败;包括跨单元格累计组合字符。 +- 同处真实解析器测试覆盖中文、组合字符以及删除、插入、擦除后三种列宽的重排。 + +## Decision + +通过 serde DeserializeSeed 按行读取,每读入一个单元格即扣减预算。不信任 +size_hint,不按输入提示预分配。行、单元格与单格组合字符在读取中计数,累计组合 +字符在每个单元格读完后扣减;各项均不超过 262_144。后续 validate 仍检查尺寸和 +控制数据。保留 JSON 对象字段顺序无关的合同。 + +捕获与导入共用同一规范化:清除互斥宽字符标志、未配对的宽字符/占位以及错误位置 +的跨行前导占位,保留字符、颜色、组合字符和其他标志;末行跨行占位可以没有下一行。 +倒序处理确保前导占位看到已规范化的下一行。行首孤立占位因此不会进入文本提取; +活终端不变。 + +## Rejected alternatives + +- 只在整个 Vec 建成后校验:拒绝太晚,不能限制解码期间分配。 +- 每个单元格单独限制组合字符:无法限制所有单元格的累计量。 +- 导入严格拒绝畸形宽字符标志:需与捕获分设两套规则,且一个无效标志即丢弃整段输出。 +- 依赖 columns 已先读取:会破坏已有 JSON 字段顺序无关的格式。 +- 所有跨行占位必须有下一行:误拒绝合法的有界裁剪。 +- 直接修活网格:改变正常终端编辑行为。 + +## Consequences + +资源与结构校验属于 terminal 快照边界,不增加应用依赖、数据迁移或新配置。 +旧格式的正常快照继续可读;超预算或尺寸/控制数据畸形的快照拒绝,应用降级为无旧 +输出。无效宽字符标志仅从快照副本移除,不承诺修复终端核心的编辑行为。 + +## Validation + +`cargo test --offline --locked -p nebula_terminal --features serde` 全套通过。 +新测试在原解码器上失败(超限尾部被读取、孤立占位保留),并用真实解析器覆盖中文 +半字符删除/插入/擦除后在三种列宽下重排的正常快照不被改动。 + +## Supersedes + +None。 + +## Revisit when + +改变 wire 格式、快照资源上限、宽字符布局或主屏捕获边界时重新核验。 diff --git a/pebrel_terminal/AGENTS.md b/pebrel_terminal/AGENTS.md index a8a898b64..b576e11b6 100644 --- a/pebrel_terminal/AGENTS.md +++ b/pebrel_terminal/AGENTS.md @@ -9,6 +9,7 @@ - 不为 UI 需求在终端核心增加产品概念。确需新接口时,公开最小命令/结果并保持状态私有。 - 重大协议、缓冲、线程、所有权或兼容性决策写入 `architecture/notes/pebrel_terminal//`;普通回归修复只需测试和变更说明。 - 快照中的 DIM 与反色颜色归属见 [`render`](../architecture/notes/pebrel_terminal/render/);颜色保持未解析,前端统一处理调色板和 OSC 覆盖。 +- 滚动历史显示快照的解码预算和宽字符边界见 [静态网格快照](../architecture/notes/pebrel_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md)。 - ZMODEM(rz/sz)只做识别并自动取消,不实现传输;依据见 [`zmodem`](../architecture/notes/pebrel_terminal/zmodem/2026-11-05-cancel-unsupported-zmodem.md)。 - OSC 7501 记录、PTY 生命周期和 GPUI 投影的边界见 [`program_status`](../architecture/notes/pebrel_terminal/program_status/)。 - 有界输出载荷、命令捕获与网格标记的所有权见 [`inline_content`](../architecture/notes/pebrel_terminal/inline_content/2026-10-21-bounded-output-store.md);前端分类命令,核心不解释 MIME 正文。 diff --git a/pebrel_terminal/src/grid/mod.rs b/pebrel_terminal/src/grid/mod.rs index a8d1d648e..6339cd4c4 100644 --- a/pebrel_terminal/src/grid/mod.rs +++ b/pebrel_terminal/src/grid/mod.rs @@ -12,6 +12,7 @@ use crate::vte::ansi::{CharsetIndex, StandardCharset}; pub mod resize; mod row; +pub mod snapshot; mod storage; #[cfg(test)] mod tests; diff --git a/pebrel_terminal/src/grid/snapshot.rs b/pebrel_terminal/src/grid/snapshot.rs new file mode 100644 index 000000000..db4792b46 --- /dev/null +++ b/pebrel_terminal/src/grid/snapshot.rs @@ -0,0 +1,335 @@ +//! 安全显示数据快照:不保存终端协议、链接动作或运行状态。 + +use super::{Dimensions, Grid}; +use crate::index::{Column, Line}; +use crate::term::cell::{Cell, Flags}; + +#[cfg(feature = "serde")] +mod serialization; + +// 解码后的防灾上限;持久化层还须独立限制每条记录的编码字节数。 +const MAX_SNAPSHOT_CELLS: usize = 262_144; +const WIDE_FLAGS: Flags = + Flags::WIDE_CHAR.union(Flags::WIDE_CHAR_SPACER).union(Flags::LEADING_WIDE_CHAR_SPACER); + +#[derive(Clone, Debug, Default)] +pub struct DisplaySnapshot { + columns: usize, + rows: Vec>, +} + +impl DisplaySnapshot { + pub fn capture(grid: &Grid, range: std::ops::Range, max_cells: usize) -> Self { + let max_cells = max_cells.min(MAX_SNAPSHOT_CELLS); + let columns = grid.columns(); + let end = range.end.0.min(grid.screen_lines() as i32); + let start = range.start.0.max(-(grid.history_size() as i32)); + let start = + start.max(end.saturating_sub((max_cells / columns).min(i32::MAX as usize) as i32)); + let rows: Vec> = (start..end) + .map(|line| { + (0..columns) + .map(|column| { + let mut cell = grid[Line(line)][Column(column)].clone(); + cell.set_hyperlink(None); + cell + }) + .collect() + }) + .collect(); + let mut snapshot = Self { columns, rows }; + snapshot.sanitize_wide_flags(); + snapshot + } + + /// 删半个宽字符等编辑或外部文件会留下孤立标志;只清理副本,不动活终端。 + fn sanitize_wide_flags(&mut self) { + for line in (0..self.rows.len()).rev() { + for column in (0..self.rows[line].len()).rev() { + let row = &self.rows[line]; + let is = |cell: Option<&Cell>, flags| { + cell.is_some_and(|cell| cell.flags & WIDE_FLAGS == flags) + }; + let valid = match row[column].flags & WIDE_FLAGS { + Flags::WIDE_CHAR => is(row.get(column + 1), Flags::WIDE_CHAR_SPACER), + Flags::WIDE_CHAR_SPACER => { + is(column.checked_sub(1).and_then(|c| row.get(c)), Flags::WIDE_CHAR) + }, + Flags::LEADING_WIDE_CHAR_SPACER => { + column + 1 == self.columns + && row[column].flags.contains(Flags::WRAPLINE) + && self + .rows + .get(line + 1) + .is_none_or(|next| is(next.first(), Flags::WIDE_CHAR)) + }, + flags => flags.is_empty(), + }; + if !valid { + self.rows[line][column].flags.remove(WIDE_FLAGS); + } + } + } + } + + fn validate(&self) -> Result<(), &'static str> { + if self.columns == 0 + || self.rows.len() > MAX_SNAPSHOT_CELLS / self.columns + || self.rows.iter().any(|row| { + row.len() != self.columns + || row.iter().any(|cell| { + (cell.c.is_control() && cell.c != '\t') + || cell.hyperlink().is_some() + || cell + .zerowidth() + .is_some_and(|chars| chars.iter().any(|c| c.is_control())) + }) + }) + { + return Err("invalid display snapshot"); + } + Ok(()) + } + + pub fn restore_scrollback(&self, grid: &mut Grid) -> Result<(), &'static str> { + self.validate()?; + if self.rows.is_empty() { + return Ok(()); + } + if self.columns != grid.columns() { + // 只重排快照,不 resize 活终端;复用已有宽字符/软换行规则。 + let reflow_capacity = self.rows.len().saturating_mul(self.columns); + let mut staging = Grid::::new(1, self.columns, reflow_capacity); + self.restore_scrollback(&mut staging)?; + staging.resize(true, 1, grid.columns()); + let reflowed = Self::capture( + &staging, + Line(-(staging.history_size() as i32))..Line(0), + usize::MAX, + ); + return reflowed.restore_scrollback(grid); + } + let old_history = grid.history_size(); + let count = self.rows.len().min(grid.max_scroll_limit.saturating_sub(old_history)); + grid.raw.initialize(count, grid.columns()); + let top = -((old_history + count) as i32); + for (index, row) in self.rows.iter().rev().take(count).rev().enumerate() { + for (column, cell) in row.iter().enumerate() { + grid[Line(top + index as i32)][Column(column)] = cell.clone(); + } + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::event::VoidListener; + use crate::term::{Config, Term, test::TermSize}; + use crate::vte::ansi; + + #[test] + fn restores_reflowed_unicode_before_existing_history_without_touching_prompt() { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "ab中文e\u{301}XYZ\r\n".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(2), 100); + let mut target = Term::new(Config::default(), &TermSize::new(5, 2), VoidListener); + parser.advance(&mut target, b"keep\r\nlast\r\nnew>"); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 4); + let text: String = (-4..-1) + .flat_map(|line| (0..5).map(move |col| (line, col))) + .filter_map(|(line, col)| { + let cell = &target.grid()[Line(line)][Column(col)]; + (!cell.flags.intersects( + crate::term::cell::Flags::WIDE_CHAR_SPACER + | crate::term::cell::Flags::LEADING_WIDE_CHAR_SPACER, + ) && cell.c != ' ') + .then_some(cell.c) + }) + .collect(); + assert_eq!(text, "ab中文eXYZ"); + assert_eq!(target.grid()[Line(-3)][Column(2)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'k'); + assert_eq!(target.grid()[Line(1)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, crate::index::Point::new(Line(1), Column(4))); + } + + #[cfg(feature = "serde")] + #[test] + fn serialized_snapshot_round_trips_display_only_and_rejects_actions() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "\x1b[38;2;12;34;56me\u{301}中".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 4); + let value = serde_json::to_value(&snapshot).unwrap(); + let decoded: DisplaySnapshot = serde_json::from_value(value.clone()).unwrap(); + let mut target = Grid::::new(2, 4, 10); + decoded.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target[Line(-1)][Column(1)].c, '中'); + assert_eq!( + target[Line(-1)][Column(0)].fg, + ansi::Color::Spec(crate::vte::ansi::Rgb { r: 12, g: 34, b: 56 }) + ); + assert!(value["rows"][0][0].get("extra").is_none()); + let mut invalid = value; + invalid["rows"][0][0]["hyperlink"] = serde_json::json!("https://example.invalid"); + assert!(serde_json::from_value::(invalid).is_err()); + } + + #[cfg(feature = "serde")] + #[test] + fn deserialization_rejects_invalid_dimensions_and_control_data() { + for value in [ + serde_json::json!({ "columns": 0, "rows": [[]] }), + serde_json::json!({ "columns": 4, "rows": [[]] }), + serde_json::json!({ "columns": 262145, "rows": [[]] }), + ] { + assert!(serde_json::from_value::(value).is_err()); + } + let snapshot = DisplaySnapshot { + columns: 1, + rows: vec![vec![Cell { c: '\u{1b}', ..Cell::default() }]], + }; + let value = serde_json::to_value(&snapshot).unwrap(); + assert!(serde_json::from_value::(value).is_err()); + } + + #[cfg(feature = "serde")] + #[test] + fn decoding_stops_at_budget_before_reading_malformed_tail() { + let one = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]] }; + let cell = serde_json::to_value(&one).unwrap()["rows"][0][0].to_string(); + let cell = cell.trim_end_matches('}'); + let chars = |n| "\"a\",".repeat(n); + let half = format!(r#"{cell},"combining":[{}"a"]}}"#, chars(131_071)); + for input in [ + format!(r#"{{"columns":1,"rows":[{}"bad"]}}"#, "[],".repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{}"bad"]]}}"#, format!("{cell}}},").repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{cell},"combining":[{}"bad"]}}]]}}"#, chars(262_145)), + format!(r#"{{"columns":3,"rows":[[{half},{half},{cell},"combining":["a"]}},"bad"]]}}"#), + ] { + let error = serde_json::from_str::(&input).unwrap_err(); + assert!(error.to_string().contains("decode budget"), "{error}"); + } + } + + #[cfg(feature = "serde")] + #[test] + fn strips_orphan_wide_flags_from_files_and_edited_screens() { + let flags = [Flags::WIDE_CHAR_SPACER, Flags::WIDE_CHAR | Flags::WIDE_CHAR_SPACER]; + let malformed = DisplaySnapshot { + columns: 2, + rows: vec![flags.map(|flags| Cell { flags, ..Cell::default() }).to_vec()], + }; + let decoded: DisplaySnapshot = + serde_json::from_value(serde_json::to_value(&malformed).unwrap()).unwrap(); + assert!(decoded.rows[0].iter().all(|cell| !cell.flags.intersects(WIDE_FLAGS))); + for edit in ["", "\x1b[1;6H\x1b[P", "\x1b[1;5H\x1b[@", "\x1b[1;6H\x1b[K"] { + for columns in [3, 5, 12] { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, format!("abcd中文e\u{301}\r\n{edit}").as_bytes()); + source.resize(TermSize::new(columns, 3)); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-10)..Line(3), 100); + let mut copy = snapshot.clone(); + copy.sanitize_wide_flags(); + assert_eq!(format!("{copy:?}"), format!("{snapshot:?}"), "{edit:?} {columns}"); + let json = serde_json::to_value(&snapshot).unwrap(); + let rows_first = format!(r#"{{"rows":{},"columns":{columns}}}"#, json["rows"]); + serde_json::from_str::(&rows_first).unwrap(); + } + } + } + + #[test] + fn rejects_malformed_rows_before_changing_live_grid() { + let mut target = Grid::::new(2, 4, 10); + target[Line(0)][Column(0)].c = 'x'; + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![Cell::default(); 5]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + assert_eq!(target[Line(0)][Column(0)].c, 'x'); + } + + #[test] + fn rejects_actions_and_control_characters_before_restoring() { + let mut target = Grid::::new(2, 4, 10); + for cell in [Cell { c: '\u{1b}', ..Cell::default() }, { + let mut cell = Cell::default(); + cell.set_hyperlink(Some(crate::term::cell::Hyperlink::new( + None::, + "https://example.invalid".into(), + ))); + cell + }] { + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![cell; 4]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + } + + #[test] + fn restores_parser_tab_cells_as_inert_display_data() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"a\tb"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 12); + let mut target = Grid::::new(2, 12, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].c, 'a'); + assert_eq!(target[Line(-1)][Column(8)].c, 'b'); + } + + #[test] + fn rejects_oversized_snapshot_before_allocating_history() { + let snapshot = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]; 262_145] }; + let mut target = Grid::::new(2, 4, 10); + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + + #[test] + fn capture_keeps_only_complete_tail_rows_within_budget() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"one\r\ntwo\r\nend"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-100)..Line(100), 9); + let mut target = Grid::::new(2, 4, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + assert_eq!(target[Line(-2)][Column(0)].c, 't'); + assert_eq!(target[Line(-1)][Column(0)].c, 'e'); + let empty = DisplaySnapshot::capture(source.grid(), Line(2)..Line(1), 9); + empty.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + } + + #[test] + fn restores_display_without_replaying_hyperlink_or_changing_live_screen() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance( + &mut source, + b"\x1b]8;;https://example.invalid\x1b\\\x1b[31mold\x1b]8;;\x1b\\\r\n", + ); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 100); + let mut target = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + parser.advance(&mut target, b"new>"); + let cursor = target.grid().cursor.clone(); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 1); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'o'); + assert_eq!( + target.grid()[Line(-1)][Column(0)].fg, + ansi::Color::Named(ansi::NamedColor::Red) + ); + assert!(target.grid()[Line(-1)][Column(0)].hyperlink().is_none()); + assert_eq!(target.grid()[Line(0)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, cursor.point); + assert_eq!(target.grid().cursor.template, cursor.template); + } +} diff --git a/pebrel_terminal/src/grid/snapshot/serialization.rs b/pebrel_terminal/src/grid/snapshot/serialization.rs new file mode 100644 index 000000000..538890da6 --- /dev/null +++ b/pebrel_terminal/src/grid/snapshot/serialization.rs @@ -0,0 +1,173 @@ +//! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 + +use serde::de::{DeserializeSeed, Error, SeqAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use super::{DisplaySnapshot, MAX_SNAPSHOT_CELLS}; +use crate::term::cell::{Cell, Flags}; +use crate::vte::ansi::Color; + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct DisplayCell { + c: char, + fg: Color, + bg: Color, + flags: Flags, + #[serde(default, deserialize_with = "decode_combining", skip_serializing_if = "Vec::is_empty")] + combining: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + underline: Option, +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct WireSnapshot { + columns: usize, + #[serde(deserialize_with = "decode_rows")] + rows: Vec>, +} + +// 解码中计数:字节上限挡不住 `[]` 空行等在内存中的放大。 +fn over() -> E { + E::custom("display snapshot exceeds decode budget") +} + +fn decode_combining<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + struct Chars; + impl<'de> Visitor<'de> for Chars { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("combining characters") + } + + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + let mut chars = Vec::new(); + while let Some(c) = seq.next_element()? { + if chars.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + chars.push(c); + } + Ok(chars) + } + } + deserializer.deserialize_seq(Chars) +} + +struct Budget { + cells: usize, + combining: usize, +} + +impl<'de> DeserializeSeed<'de> for &mut Budget { + type Value = Vec; + + fn deserialize>(self, deserializer: D) -> Result { + deserializer.deserialize_seq(self) + } +} + +impl<'de> Visitor<'de> for &mut Budget { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display row") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut row = Vec::new(); + while let Some(cell) = seq.next_element::()? { + self.cells = self.cells.checked_sub(1).ok_or_else(over)?; + self.combining = self.combining.checked_sub(cell.combining.len()).ok_or_else(over)?; + row.push(cell); + } + Ok(row) + } +} + +fn decode_rows<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result>, D::Error> { + struct Rows; + impl<'de> Visitor<'de> for Rows { + type Value = Vec>; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display rows") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut budget = Budget { cells: MAX_SNAPSHOT_CELLS, combining: MAX_SNAPSHOT_CELLS }; + let mut rows = Vec::new(); + while let Some(row) = seq.next_element_seed(&mut budget)? { + if rows.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + rows.push(row); + } + Ok(rows) + } + } + deserializer.deserialize_seq(Rows) +} + +impl Serialize for DisplaySnapshot { + fn serialize(&self, serializer: S) -> Result { + WireSnapshot { + columns: self.columns, + rows: self + .rows + .iter() + .map(|row| { + row.iter() + .map(|cell| DisplayCell { + c: cell.c, + fg: cell.fg, + bg: cell.bg, + flags: cell.flags, + combining: cell.zerowidth().unwrap_or_default().to_vec(), + underline: cell.underline_color(), + }) + .collect() + }) + .collect(), + } + .serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for DisplaySnapshot { + fn deserialize>(deserializer: D) -> Result { + let wire = WireSnapshot::deserialize(deserializer)?; + let mut snapshot = Self { + columns: wire.columns, + rows: wire + .rows + .into_iter() + .map(|row| { + row.into_iter() + .map(|value| { + let mut cell = Cell { + c: value.c, + fg: value.fg, + bg: value.bg, + flags: value.flags, + extra: None, + }; + for character in value.combining { + cell.push_zerowidth(character); + } + cell.set_underline_color(value.underline); + cell + }) + .collect() + }) + .collect(), + }; + snapshot.sanitize_wide_flags(); + snapshot.validate().map_err(Error::custom)?; + Ok(snapshot) + } +}