perf: reduce Loro projection time and peak memory

.cargo/audit.toml

@@ -4,7 +4,15 @@
 # quick-xml 0.41; the remaining old copies in Cargo.lock are pinned by the
 # LATEST releases of third-party crates (xcb 0.30, docx-rs 0.36,
 # rdocx-opc/oxml 0.37, citationberg-via-typst 0.38, wayland-scanner 0.39) and
-# cannot be bumped without vendoring them. Mirrors the deny.toml ignore list —
-# keep the two in sync. Re-check on dependency upgrades.
+# cannot be bumped without vendoring them.
+#
+# rkyv 0.7 is pinned by mitex 0.2.4 and only reads mitex's generated
+# specification data. The affected 0.7 series has no patched release; mitex
+# must migrate to rkyv >= 0.8.17. Mirrors the vulnerability entries in
+# deny.toml; keep them in sync and re-check on dependency upgrades.
 [advisories]
-ignore = ["RUSTSEC-2026-0194", "RUSTSEC-2026-0195"]
+ignore = [
+  "RUSTSEC-2026-0194",
+  "RUSTSEC-2026-0195",
+  "RUSTSEC-2026-0235",
+]

crates/flowstate-collab/src/crdt_runtime.rs

@@ -11,8 +11,8 @@ use std::{
 use anyhow::{Context as _, Result};
 use flowstate_document::{
   AssetId, AssetRecord, BLOCKS_BY_ID, Block, BlockId, CellId, ColumnId, DEFAULT_UPDATE_SEGMENT_COMPACTION_THRESHOLD, DocumentPackage,
-  DocumentProjection, FLOW_ATTRS_KEY, FLOW_ID_KEY, FLOW_KIND_KEY, FLOW_TEXT_KEY, FLOWS_BY_ID, ImportedLoroDocument, InputBlock,
-  InputBlockAlignment, InputEquationDisplay, InputImageSizing, InputParagraph, InputTableBlock, InputTableCell, InputTableCellBlock,
+  DocumentProjection, FLOW_ID_KEY, FLOW_KIND_KEY, FLOW_TEXT_KEY, FLOWS_BY_ID, ImportedLoroDocument, InputBlock, InputBlockAlignment,
+  InputEquationDisplay, InputEquationSyntax, InputImageSizing, InputParagraph, InputTableBlock, InputTableCell, InputTableCellBlock,
   InputTableColumnWidth, MAIN_BODY_BLOCK_ID, MARK_DIRECT_UNDERLINE, MARK_HIGHLIGHT_STYLE, MARK_PARAGRAPH_STYLE, MARK_RUN_SEMANTIC_STYLE,
   MARK_STRIKETHROUGH, OBJECT_REPLACEMENT, PARAGRAPHS_BY_ID, Paragraph, ParagraphId, ParagraphStyle, ProjectionDefect, ProjectionPatch,
   ProjectionStructuralBlock, ROOT, ROOT_BODY_FLOW_ID, ROOT_FIRST_PARAGRAPH_ID, RowId, RunSemanticStyle, RunStyles, SENTINEL_NEWLINE, SectionId,
@@ -5973,9 +5973,34 @@ fn replace_equation_block_from_input(doc: &LoroDoc, block: &LoroMap, equation: &
   block.insert("source_flow_id", source_flow_id.as_str())?;
   let source_flow = ensure_flow(doc, &source_flow_id, "equation_source")?;
   replace_text(&source_flow.ensure_mergeable_text(FLOW_TEXT_KEY)?, &equation.source)?;
-  let attrs = block.ensure_mergeable_map("attrs")?;
-  attrs.insert("syntax", "latex")?;
-  attrs.insert("display", equation_display_name(equation.display))?;
+  write_equation_attrs(block, equation.syntax, equation.display)?;
+  Ok(())
+}
+
+fn write_equation_attrs(block: &LoroMap, syntax: InputEquationSyntax, display: InputEquationDisplay) -> Result<()> {
+  // Match the import writer's sparse canonical form: Latex + display are
+  // projection defaults, so only the non-default inline display needs storage.
+  match syntax {
+    InputEquationSyntax::Latex => {},
+  }
+  let attrs = match display {
+    InputEquationDisplay::Display => child_map(block, "attrs"),
+    InputEquationDisplay::InlineLikeParagraph => Some(block.ensure_mergeable_map("attrs")?),
+  };
+  let Some(attrs) = attrs else {
+    return Ok(());
+  };
+  if attrs.get("syntax").is_some() {
+    attrs.delete("syntax")?;
+  }
+  match display {
+    InputEquationDisplay::Display => {
+      if attrs.get("display").is_some() {
+        attrs.delete("display")?;
+      }
+    },
+    InputEquationDisplay::InlineLikeParagraph => attrs.insert("display", equation_display_name(display))?,
+  }
   Ok(())
 }
 
@@ -6667,7 +6692,6 @@ fn ensure_paragraph_metadata_at_boundary_with_keys(
     paragraph.insert("start_cursor", encoded.clone())?;
     paragraph.insert("boundary_cursor", encoded.clone())?;
   }
-  let _paragraph_attrs = paragraph.ensure_mergeable_map("attrs")?;
 
   let block_id = forced_block_id
     .or_else(|| paragraph_block_key_at_boundary(doc, body, &blocks, boundary))
@@ -6680,8 +6704,6 @@ fn ensure_paragraph_metadata_at_boundary_with_keys(
   if let Some(encoded) = boundary_cursor {
     block.insert("anchor_cursor", encoded)?;
   }
-  let _block_attrs = block.ensure_mergeable_map("attrs")?;
-  let _nested_refs = block.ensure_mergeable_map("nested_refs")?;
   Ok(())
 }
 
@@ -7382,9 +7404,7 @@ fn insert_equation_block(doc: &LoroDoc, unicode_index: usize, source: &str, disp
   block.insert("source_flow_id", source_flow_id.as_str())?;
   let source_flow = ensure_flow(doc, &source_flow_id, "equation_source")?;
   replace_text(&source_flow.ensure_mergeable_text(FLOW_TEXT_KEY)?, source)?;
-  let attrs = block.ensure_mergeable_map("attrs")?;
-  attrs.insert("syntax", "latex")?;
-  attrs.insert("display", equation_display_name(display))?;
+  write_equation_attrs(&block, InputEquationSyntax::Latex, display)?;
   Ok(())
 }
 
@@ -7493,7 +7513,6 @@ fn ensure_flow(doc: &LoroDoc, flow_id: &str, kind: &str) -> loro::LoroResult<Lor
   flow.insert(FLOW_ID_KEY, flow_id)?;
   flow.insert(FLOW_KIND_KEY, kind)?;
   let text = flow.ensure_mergeable_text(FLOW_TEXT_KEY)?;
-  let _attrs = flow.ensure_mergeable_map(FLOW_ATTRS_KEY)?;
   flow.insert("text_container_id", text.id().to_string())?;
   Ok(flow)
 }
@@ -7513,8 +7532,6 @@ fn ensure_block_with_id(doc: &LoroDoc, id: &str, kind: &str, flow_id: &str, text
   if let Some(cursor) = text.get_cursor(pos, Side::Left) {
     block.insert("anchor_cursor", cursor.encode())?;
   }
-  let _attrs = block.ensure_mergeable_map("attrs")?;
-  let _nested_refs = block.ensure_mergeable_map("nested_refs")?;
   Ok(block)
 }
 

crates/flowstate-collab/tests/vendored_patch_guards.rs

@@ -12,6 +12,7 @@
 use anyhow::Result;
 use flowstate_collab::crdt_runtime::CrdtRuntime;
 use flowstate_collab::local_write::{GateHolder, InsertTextIntent, LocalDocHandle, LocalWriteConfig, TextAnchor};
+use loro::ValueOrContainer;
 use std::time::Instant;
 
 /// One peer builds a large single-fragment body; a forked peer splits it with
@@ -177,6 +178,47 @@ fn styled_divergence_cost(edits: usize) -> (std::time::Duration, std::time::Dura
 mod tests {
   use super::*;
 
+  #[test]
+  fn mergeable_marker_fast_path_round_trips_all_enabled_container_kinds() -> Result<()> {
+    // Marker creation still uses loro-common; reading after a snapshot import
+    // routes through the vendored allocation-free parser. Non-ASCII and marker
+    // separator/escape characters guard the exact length-prefixed wire encoding.
+    let doc = loro::LoroDoc::new();
+    let root = doc.get_map("marker/root");
+    root.ensure_mergeable_map(r"map/é>\child")?;
+    root.ensure_mergeable_list(r"list/é>\child")?;
+    root.ensure_mergeable_movable_list(r"movable/é>\child")?;
+    root.ensure_mergeable_text(r"text/é>\child")?;
+    root.ensure_mergeable_tree(r"tree/é>\child")?;
+    let nested = root.ensure_mergeable_map(r"nested/é>\parent")?;
+    nested.ensure_mergeable_map(r"child/🤝>\map")?;
+    doc.commit();
+
+    let snapshot = doc.export(loro::ExportMode::Snapshot)?;
+    let reopened = loro::LoroDoc::new();
+    reopened.import(&snapshot)?;
+    let root = reopened.get_map("marker/root");
+    macro_rules! assert_container_kind {
+      ($parent:expr, $key:expr, $conversion:ident) => {
+        let Some(ValueOrContainer::Container(container)) = $parent.get($key) else {
+          panic!("{} marker did not translate into a container", $key);
+        };
+        assert!(container.$conversion().is_ok(), "{} translated to the wrong container kind", $key);
+      };
+    }
+    assert_container_kind!(root, r"map/é>\child", into_map);
+    assert_container_kind!(root, r"list/é>\child", into_list);
+    assert_container_kind!(root, r"movable/é>\child", into_movable_list);
+    assert_container_kind!(root, r"text/é>\child", into_text);
+    assert_container_kind!(root, r"tree/é>\child", into_tree);
+    let Some(ValueOrContainer::Container(nested)) = root.get(r"nested/é>\parent") else {
+      panic!("nested marker did not translate into a container");
+    };
+    let nested = nested.into_map().expect("nested marker kind");
+    assert_container_kind!(nested, r"child/🤝>\map", into_map);
+    Ok(())
+  }
+
   /// §stylemap pass (2026-07-09, follow-on to act-eleven A11.5): pins the
   /// LAYERED `StyleValue` representation in the vendored `style_range_map.rs`
   /// (persistent `im::OrdSet` base + small owned overlay + one-side-reuse

crates/flowstate-document/src/loro_import.rs

@@ -11,9 +11,9 @@ use rustc_hash::FxHashMap;
 use uuid::Uuid;
 
 use crate::{
-  AssetChunk, BLOCKS_BY_ID, BODY_FLOW_ID, FLOW_ATTRS_KEY, FLOW_ID_KEY, FLOW_KIND_KEY, FLOW_TEXT_KEY, FLOWS_BY_ID, MARK_DIRECT_UNDERLINE,
-  MARK_HIGHLIGHT_STYLE, MARK_PARAGRAPH_STYLE, MARK_RUN_SEMANTIC_STYLE, MARK_STRIKETHROUGH, MARK_VERT_ALIGN, OBJECT_REPLACEMENT,
-  PARAGRAPHS_BY_ID, ROOT, ROOT_BODY_FLOW_ID, SECTIONS_BY_ID,
+  AssetChunk, BLOCKS_BY_ID, BODY_FLOW_ID, FLOW_ID_KEY, FLOW_KIND_KEY, FLOW_TEXT_KEY, FLOWS_BY_ID, MARK_DIRECT_UNDERLINE, MARK_HIGHLIGHT_STYLE,
+  MARK_PARAGRAPH_STYLE, MARK_RUN_SEMANTIC_STYLE, MARK_STRIKETHROUGH, MARK_VERT_ALIGN, OBJECT_REPLACEMENT, PARAGRAPHS_BY_ID, ROOT,
+  ROOT_BODY_FLOW_ID, SECTIONS_BY_ID,
   loro_schema::{
     ASSETS_BY_ID, REVISIONS, SectionPageAttrs, TABLE_CELLS_BY_ID, TABLE_COLUMN_ORDER, TABLE_COLUMNS_BY_ID, TABLE_KEY, TABLE_ROW_ORDER,
     TABLE_ROWS_BY_ID, cell_flow_loro_id, cell_loro_id, column_loro_id, row_loro_id, write_section_page_attrs,
@@ -80,7 +80,11 @@ fn fidelity_report_import(doc: &LoroDoc, document: &DocumentProjection) {
 /// `ensure_mergeable_map`, this never creates the container, so a fidelity
 /// invariant cannot fabricate the very structure it is meant to verify.
 fn read_root_child_map(doc: &LoroDoc, key: &str) -> Option<LoroMap> {
-  match doc.get_map(ROOT).get(key)? {
+  read_child_map(&doc.get_map(ROOT), key)
+}
+
+fn read_child_map(parent: &LoroMap, key: &str) -> Option<LoroMap> {
+  match parent.get(key)? {
     ValueOrContainer::Container(container) => container.into_map().ok(),
     ValueOrContainer::Value(_) => None,
   }
@@ -181,9 +185,7 @@ pub(crate) fn replace_body_from_document(doc: &LoroDoc, document: &DocumentProje
         block.insert("source_flow_id", source_flow_id.as_str())?;
         let source_flow = ensure_flow(&flows, &source_flow_id, "equation_source")?;
         replace_text(&source_flow.ensure_mergeable_text(FLOW_TEXT_KEY)?, equation.source.as_ref())?;
-        let attrs = block.ensure_mergeable_map("attrs")?;
-        attrs.insert("syntax", equation_syntax_name(equation.syntax))?;
-        attrs.insert("display", equation_display_name(equation.display))?;
+        write_equation_attrs(&block, equation.syntax, equation.display)?;
       },
       (Block::Table(table), FlowBlockPosition::Object { anchor_pos }) => {
         let durable_block_id = projection_block_id(document, block_ix, "table");
@@ -435,13 +437,9 @@ fn import_paragraph_record(
       paragraph_map.insert("boundary_cursor", cursor.encode())?;
     }
   });
-  // §perf-heaven T8.2: the `attrs` container is kept (the projection reads it and
-  // the invalidation whitelist expects it), but the `*_container_id` MIRROR
-  // values are dropped. They duplicated `map.id()` — write-only (no reader in the
-  // projection or collab), yet each was a long flattened-cid `String` stored as a
-  // map value AND minted as an op, ×5 per paragraph ×N paragraphs (a large slice
-  // of the 38.7 KB/record). Derivable from the container itself if ever needed.
-  paragraph_map.ensure_mergeable_map("attrs")?;
+  // §perf: optional child maps are materialized only when they contain a value.
+  // Paragraph attributes currently live in text marks, so an eager empty `attrs`
+  // map adds a container/op per paragraph without encoding document semantics.
   ensure_block(blocks, block_id, "paragraph", flow_id, body_text, text_op_base, boundary_pos)?;
   Ok(())
 }
@@ -901,7 +899,6 @@ fn ensure_flow(flows: &LoroMap, flow_id: &str, kind: &str) -> LoroResult<LoroMap
   flow.insert(FLOW_ID_KEY, flow_id)?;
   flow.insert(FLOW_KIND_KEY, kind)?;
   let text = flow.ensure_mergeable_text(FLOW_TEXT_KEY)?;
-  let _attrs = flow.ensure_mergeable_map(FLOW_ATTRS_KEY)?;
   flow.insert("text_container_id", text.id().to_string())?;
   Ok(flow)
 }
@@ -922,10 +919,9 @@ fn ensure_block(
   if let Some(cursor) = body_cursor_at(text, text_op_base, pos, Side::Left) {
     block.insert("anchor_cursor", cursor.encode())?;
   }
-  // §perf-heaven T8.2: keep the `attrs`/`nested_refs` containers (read + whitelisted),
-  // drop the write-only `*_container_id` mirror strings (duplicated `map.id()`).
-  block.ensure_mergeable_map("attrs")?;
-  block.ensure_mergeable_map("nested_refs")?;
+  // Optional child maps are created by the specialized writers that put values
+  // in them. Eager empty `attrs` and `nested_refs` maps otherwise cost two CRDT
+  // containers and two marker ops for every block.
   Ok(block)
 }
 
@@ -991,10 +987,33 @@ fn alignment_name(alignment: BlockAlignment) -> &'static str {
   }
 }
 
-fn equation_syntax_name(syntax: EquationSyntax) -> &'static str {
+fn write_equation_attrs(block: &LoroMap, syntax: EquationSyntax, display: EquationDisplay) -> LoroResult<()> {
+  // Latex + display are the projection's documented defaults. Encoding those
+  // defaults created an otherwise-unneeded map plus two values per equation.
+  // Existing maps are retained (they may contain future/unknown fields), but
+  // legacy default keys are removed when this writer revisits the block.
   match syntax {
-    EquationSyntax::Latex => "latex",
+    EquationSyntax::Latex => {},
+  }
+  let attrs = match display {
+    EquationDisplay::Display => read_child_map(block, "attrs"),
+    EquationDisplay::InlineLikeParagraph => Some(block.ensure_mergeable_map("attrs")?),
+  };
+  let Some(attrs) = attrs else {
+    return Ok(());
+  };
+  if attrs.get("syntax").is_some() {
+    attrs.delete("syntax")?;
   }
+  match display {
+    EquationDisplay::Display => {
+      if attrs.get("display").is_some() {
+        attrs.delete("display")?;
+      }
+    },
+    EquationDisplay::InlineLikeParagraph => attrs.insert("display", equation_display_name(display))?,
+  }
+  Ok(())
 }
 
 fn equation_display_name(display: EquationDisplay) -> &'static str {
@@ -1037,6 +1056,96 @@ mod tests {
     Ok(())
   }
 
+  #[test]
+  fn canonical_import_omits_empty_optional_maps_and_default_equation_attrs() -> io::Result<()> {
+    for (display, expected_display_attr) in [
+      (gpui_flowtext::InputEquationDisplay::Display, None),
+      (gpui_flowtext::InputEquationDisplay::InlineLikeParagraph, Some("inline_like_paragraph")),
+    ] {
+      let source = gpui_flowtext::document_from_input_blocks(
+        crate::flowstate_document_theme(),
+        vec![
+          gpui_flowtext::InputBlock::Paragraph(gpui_flowtext::InputParagraph {
+            style: ParagraphStyle::Normal,
+            runs: vec![gpui_flowtext::InputRun {
+              text: "before".to_string(),
+              styles: RunStyles::default(),
+            }],
+          }),
+          gpui_flowtext::InputBlock::Equation(gpui_flowtext::InputEquationBlock {
+            source: "x^2".to_string(),
+            syntax: gpui_flowtext::InputEquationSyntax::Latex,
+            display,
+          }),
+        ],
+      );
+      let paragraph_key = projection_block_id(&source, 0, "paragraph_block");
+      let equation_key = projection_block_id(&source, 1, "equation");
+      let paragraph_id = projection_paragraph_id(&source, 0);
+      let equation_flow_id = nested_flow_id("equation_source", &equation_key);
+      let doc = document_to_loro(&source, "Sparse defaults")?;
+
+      let blocks = read_root_child_map(&doc, BLOCKS_BY_ID).expect("blocks map");
+      let paragraph_block = read_child_map(&blocks, &paragraph_key).expect("paragraph block");
+      assert!(paragraph_block.get("attrs").is_none());
+      assert!(paragraph_block.get("nested_refs").is_none());
+      let equation_block = read_child_map(&blocks, &equation_key).expect("equation block");
+      assert!(equation_block.get("nested_refs").is_none());
+      let equation_attrs = read_child_map(&equation_block, "attrs");
+      assert_eq!(
+        equation_attrs
+          .as_ref()
+          .and_then(|attrs| attrs.get("display"))
+          .and_then(|value| match value {
+            ValueOrContainer::Value(LoroValue::String(value)) => Some(value.to_string()),
+            _ => None,
+          })
+          .as_deref(),
+        expected_display_attr
+      );
+      assert!(
+        equation_attrs
+          .as_ref()
+          .is_none_or(|attrs| attrs.get("syntax").is_none())
+      );
+
+      let paragraphs = read_root_child_map(&doc, PARAGRAPHS_BY_ID).expect("paragraphs map");
+      assert!(
+        read_child_map(&paragraphs, &paragraph_id)
+          .expect("paragraph record")
+          .get("attrs")
+          .is_none()
+      );
+      let flows = read_root_child_map(&doc, FLOWS_BY_ID).expect("flows map");
+      assert!(
+        read_child_map(&flows, ROOT_BODY_FLOW_ID)
+          .expect("body flow")
+          .get("attrs")
+          .is_none()
+      );
+      assert!(
+        read_child_map(&flows, &equation_flow_id)
+          .expect("equation flow")
+          .get("attrs")
+          .is_none()
+      );
+
+      let projected = crate::document_from_loro(&doc)?;
+      let Block::Equation(equation) = &projected.blocks[1] else {
+        panic!("second block should remain an equation");
+      };
+      assert_eq!(equation.source.as_ref(), "x^2");
+      assert_eq!(
+        equation.display,
+        match display {
+          gpui_flowtext::InputEquationDisplay::Display => EquationDisplay::Display,
+          gpui_flowtext::InputEquationDisplay::InlineLikeParagraph => EquationDisplay::InlineLikeParagraph,
+        }
+      );
+    }
+    Ok(())
+  }
+
   #[test]
   fn custom_paragraph_style_slot_zero_round_trips() -> io::Result<()> {
     let source = gpui_flowtext::document_from_input_blocks(