fix(chat): stop sizing probes from freezing the chat feed

Opening a busy channel could block the main thread for minutes: stack
layout probes every row at several candidate widths, the probes multiply
through the nested stacks, and each probe re-rendered the live NSTextView
and hashed the whole message for its cache lookups. With 180 mounted
rows that one layout pass never finished.

A sizing probe is now pure and O(1) on repeat: it never touches the live
text view (the view renders once, in setFrameSize, at the width that
won), and each view memoises its built text and measured size per
rounded width, so a probe is a small dictionary hit instead of a
full-text hash through the global caches.

Claude-Session: https://claude.ai/code/session_01PKetCunJwQPgV9SHoJ3i5q

Author: rogeriochaves

Sources/KanbanCode/SelectableMarkdownText.swift

@@ -93,6 +93,19 @@ struct SelectableMarkdownText: NSViewRepresentable {
         private var lineLimit: Int?
         private var renderedWidth: CGFloat = 0
 
+        /// Per-width memos for this view's own text. Stack layout negotiates a
+        /// row's width by probing it at many candidate widths, and the probes
+        /// multiply through nested stacks: answering each one through the
+        /// global caches means hashing the whole message per call, which a
+        /// long feed turns into a multi-minute layout pass. A view holds one
+        /// message, so keying by width alone makes a repeat probe a plain
+        /// dictionary hit.
+        private var attributedByWidth: [CGFloat: NSAttributedString] = [:]
+        private var sizeByWidth: [CGFloat: CGSize] = [:]
+        /// A live width drag can visit many widths; past this the older
+        /// entries are worthless, so the memo starts over.
+        private static let widthMemoLimit = 12
+
         func configure(
             content: ChatTextContent,
             appearance: ChatTextAppearance,
@@ -112,6 +125,8 @@ struct SelectableMarkdownText: NSViewRepresentable {
             if changed {
                 self.renderedWidth = 0
                 self.reportedOverflow = nil
+                self.attributedByWidth.removeAll(keepingCapacity: true)
+                self.sizeByWidth.removeAll(keepingCapacity: true)
             }
             self.textContainer?.maximumNumberOfLines = lineLimit ?? 0
             self.textContainer?.lineBreakMode = lineLimit == nil ? .byWordWrapping : .byTruncatingTail
@@ -145,29 +160,47 @@ struct SelectableMarkdownText: NSViewRepresentable {
             NSSize(width: NSView.noIntrinsicMetric, height: NSView.noIntrinsicMetric)
         }
 
+        /// A pure measurement: it must never touch the live text view. This is
+        /// the answer to a sizing probe, and stack layout probes a row many
+        /// times per pass at widths it will not use — rendering here re-lays
+        /// the text out per probe and turns one pass into minutes. The view
+        /// itself is rendered from `setFrameSize`, at the width that won.
         func fittingSize(forWidth width: CGFloat) -> CGSize {
-            self.render(width: width)
+            let width = width.rounded()
+            if let cached = self.sizeByWidth[width] { return cached }
             let attributed = self.attributedText(width: width)
             let size = ChatTextMeasurement.size(
                 of: attributed, width: width, lineLimit: self.lineLimit)
-            guard self.content.shrinksToFit else {
-                return CGSize(width: width, height: size.height)
-            }
             // Report the text's own width, not the whole proposal. A short row
             // that claims the full width cannot be centred by its container,
             // which is how system notices are laid out, and it stretches a user
             // bubble across the whole column.
-            return CGSize(width: min(width, size.width), height: size.height)
+            let fitting = self.content.shrinksToFit
+                ? CGSize(width: min(width, size.width), height: size.height)
+                : CGSize(width: width, height: size.height)
+            if self.sizeByWidth.count >= Self.widthMemoLimit {
+                self.sizeByWidth.removeAll(keepingCapacity: true)
+            }
+            self.sizeByWidth[width] = fitting
+            return fitting
         }
 
         private func attributedText(width: CGFloat) -> NSAttributedString {
-            ChatAttributedText.make(
+            let width = width.rounded()
+            if let cached = self.attributedByWidth[width] { return cached }
+            let built = ChatAttributedText.make(
                 content: self.content, appearance: self.textAppearance,
                 highlight: self.highlight, links: self.links, width: width
             )
+            if self.attributedByWidth.count >= Self.widthMemoLimit {
+                self.attributedByWidth.removeAll(keepingCapacity: true)
+            }
+            self.attributedByWidth[width] = built
+            return built
         }
 
         private func render(width: CGFloat) {
+            let width = width.rounded()
             guard width > 1, abs(width - self.renderedWidth) > 0.5 else { return }
             self.renderedWidth = width
             self.textContainer?.size = CGSize(

Tests/KanbanCodeTests/SelectableMarkdownTextTests.swift

@@ -33,11 +33,11 @@ struct SelectableMarkdownTextTests {
     }
 
     /// The view is configured before SwiftUI has given it a frame, so its first
-    /// `configure` runs at width zero. Table columns are sized against the
-    /// available width, so rendering at that point collapses every column to a
-    /// single character and draws the message over its neighbours.
-    @Test("renders at the proposed width even before it has a frame")
-    func rendersAtProposedWidthWithoutAFrame() {
+    /// `configure` runs at width zero. Sizing probes measure off screen and
+    /// leave the view alone — a probe width is usually not the width the row
+    /// ends up with — so the columns take their shape when the frame lands.
+    @Test("measures at the proposed width and renders when the frame lands")
+    func rendersWhenTheFrameLands() {
         let view = SelectableMarkdownText.WrappingTextView.make()
         view.configure(
             content: .markdown(Self.tableMarkdown), appearance: Self.appearance, highlight: nil)
@@ -47,6 +47,7 @@ struct SelectableMarkdownTextTests {
         #expect(size.width > 200)
         #expect(size.height > 40)
 
+        view.setFrameSize(NSSize(width: 690, height: size.height))
         let origins = Self.columnOrigins(view)
         #expect(origins.count == 3)
         if origins.count == 3 {
@@ -56,6 +57,22 @@ struct SelectableMarkdownTextTests {
         }
     }
 
+    /// Stack layout probes a row at many candidate widths per pass, and the
+    /// probes multiply through nested stacks. A probe that re-lays the live
+    /// text view out each time turns a long feed's layout pass into minutes of
+    /// blocked main thread, so measuring must leave the view alone.
+    @Test("a sizing probe does not render the live view")
+    func sizingProbeLeavesTheViewAlone() {
+        let view = SelectableMarkdownText.WrappingTextView.make()
+        view.configure(
+            content: .markdown(Self.tableMarkdown), appearance: Self.appearance, highlight: nil)
+
+        for width in [300, 500, 690, 500, 300] {
+            _ = view.fittingSize(forWidth: CGFloat(width))
+        }
+        #expect(view.textStorage?.length == 0)
+    }
+
     /// System notices sit inside a centring `HStack`. A row that reports the
     /// full proposed width leaves the spacers nothing to take, so it drifts to
     /// the leading edge instead of staying centred.
@@ -93,7 +110,7 @@ struct SelectableMarkdownTextTests {
             """
         let view = SelectableMarkdownText.WrappingTextView.make()
         view.configure(content: .markdown(wideTable), appearance: Self.appearance, highlight: nil)
-        _ = view.fittingSize(forWidth: 400)
+        view.setFrameSize(NSSize(width: 400, height: 400))
         let narrow = Self.columnOrigins(view)
 
         view.setFrameSize(NSSize(width: 900, height: 400))