fix(ui): three defects found in visual review

Every tab showed the same file. SourceEditor pushes text into its text
view exactly once, in makeNSViewController; updateNSViewController
diffs language, configuration and highlight providers, never the text
behind the Binding<String>. Switching tabs therefore kept the previous
document on screen. DocumentTextCoordinator captures the controller in
prepareCoordinator — the one hook that hands it out — and CodeEditorView
reloads it when the document changes. Verified in the running app:
switching tabs now changes the editor from README content to index.html
content.

A folder's chevron stopped working once the folder was selected.
Expansion hangs off the selection change, and clicking an already
selected row changes nothing, so no toggle fired. The chevron is a real
Button again; it selects the row first so the two paths cannot cancel.

The line-number gutter bled onto the tab labels while rubber-band
scrolling. The strip sits flush against the editor and a translucent
material lets an overscroll NSScrollView draw through it. Both bars now
carry an opaque canvas base under the material.

Also: the tab label was rendering both a dirty dot and the " *" that
Document.title appends. One state, one indicator.

Author: yan

Sources/CodeEditorUI/Sources/Chrome/StatusBarView.swift

@@ -47,12 +47,13 @@ public struct StatusBarView: View {
         }
     }
 
+    /// Opaque base first, then material: the status bar also sits flush against a scroll view,
+    /// and a translucent fill lets overscrolled content bleed through. See `TabBarView.stripFill`.
     @ViewBuilder
     private var backgroundFill: some View {
+        Rectangle().fill(appState.theme.background.color)
         if appState.theme.chrome.usesMaterials {
             Rectangle().fill(.thinMaterial)
-        } else {
-            Rectangle().fill(appState.theme.chrome.barBackground.color)
         }
     }
 

Sources/CodeEditorUI/Sources/Chrome/TabBarView.swift

@@ -63,13 +63,18 @@ public struct TabBarView: View {
 
     // MARK: - Strip
 
-    /// Materials when the palette allows them; the token fill otherwise.
+    /// An opaque canvas-coloured base under the material.
+    ///
+    /// The strip sits directly above the editor with no separator, and an `NSScrollView`
+    /// draws its content outside its bounds while rubber-band scrolling. A translucent
+    /// material lets that overscrolled content — including the gutter — show through and
+    /// appear to overlap the tab labels. The base kills the bleed-through while keeping the
+    /// material's tint and the window-focus response.
     @ViewBuilder
     private var stripFill: some View {
+        Rectangle().fill(theme.background.color)
         if theme.chrome.usesMaterials {
             Rectangle().fill(.thinMaterial)
-        } else {
-            Rectangle().fill(theme.chrome.barBackground.color)
         }
     }
 
@@ -105,7 +110,9 @@ public struct TabBarView: View {
                     .help("Unsaved changes")
             }
 
-            Text(document.title)
+            // `name`, not `title`: title appends " *" when modified, and the dot
+            // beside the label already says that. Two indicators for one state.
+            Text(document.name)
                 .font(Typography.tabLabel)
                 .lineLimit(1)
                 .truncationMode(.middle)

Sources/CodeEditorUI/Sources/Editor/CodeEditorView.swift

@@ -13,6 +13,7 @@ public struct CodeEditorView: View {
     let editorState: EditorState
 
     @State private var sourceEditorState = SourceEditorState()
+    @State private var textCoordinator = DocumentTextCoordinator()
 
     public init(document: CodeEditorCore.Document, theme: Theme, editorState: EditorState) {
         self.document = document
@@ -26,13 +27,18 @@ public struct CodeEditorView: View {
             language: document.language.codeLanguage,
             configuration: configuration,
             state: $sourceEditorState,
-            undoManager: undoManager
+            undoManager: undoManager,
+            coordinators: [textCoordinator]
         )
         .background(theme.background.color)
         .onChange(of: sourceEditorState.cursorPositions) { _, positions in
             syncSelection(with: positions)
         }
         .onChange(of: document.id) { _, _ in
+            // SourceEditor does not diff text on update — only language, configuration
+            // and highlight providers. Without this, switching tabs keeps the previous
+            // document on screen.
+            textCoordinator.reload(text: document.content)
             editorState.syncSelection(of: document)
         }
         .task {

Sources/CodeEditorUI/Sources/Editor/DocumentTextCoordinator.swift

@@ -0,0 +1,33 @@
+import CodeEditSourceEditor
+
+/// Keeps the text view's contents in step with the document it is showing.
+///
+/// `SourceEditor` pushes text into its text view exactly once, in
+/// `makeNSViewController`. `updateNSViewController` diffs language, configuration and
+/// highlight providers — **it never diffs the text behind the `Binding<String>`**. Switching
+/// tabs therefore leaves the previously opened document on screen, and every tab shows the
+/// same file.
+///
+/// `prepareCoordinator` is the one hook that hands out the live controller, and it runs once
+/// per controller, so this holds it weakly and `CodeEditorView` calls `reload(text:)` when
+/// the document changes.
+///
+/// This is a workaround for upstream, not a design preference. If a future version diffs the
+/// text on update, this type should go away — see [MEMORY.md](../../../docs/MEMORY.md).
+@MainActor
+final class DocumentTextCoordinator: TextViewCoordinator {
+    private weak var controller: TextViewController?
+
+    func prepareCoordinator(controller: TextViewController) {
+        self.controller = controller
+    }
+
+    /// Replace the editor's contents, unless it is already showing them.
+    ///
+    /// Safe either way: the change flows back through the binding, and `Document.setContent`
+    /// guards on equality, so reloading the same text records no edit and no undo entry.
+    func reload(text: String) {
+        guard let controller, controller.textView.string != text else { return }
+        controller.setText(text)
+    }
+}

Sources/CodeEditorUI/Sources/Sidebar/FileExplorerView.swift

@@ -187,16 +187,25 @@ public struct FileExplorerView: View {
         }
     }
 
-    /// The disclosure chevron. Decorative, not a control: selecting the row is what
-    /// expands a folder, so a second tap target here would toggle it twice.
+    /// The disclosure chevron. A real control: expansion hangs off the selection change,
+    /// so a folder that is *already* selected produces no change and nothing would toggle.
+    /// Selecting it first also makes the row selection agree with the chevron, which is
+    /// what stops the two from cancelling out.
     @ViewBuilder
     private func disclosureControl(for item: FileSystemItem) -> some View {
         if item.isDirectory {
-            Image(systemName: fileSystemManager.isExpanded(item.url) ? "chevron.down" : "chevron.right")
-                .font(.system(size: 9, weight: .bold))
-                .foregroundStyle(.tertiary)
-                .frame(width: 12, height: 12)
-                .accessibilityHidden(true)
+            Button {
+                selection = item
+                fileSystemManager.toggleExpansion(of: item)
+            } label: {
+                Image(systemName: fileSystemManager.isExpanded(item.url) ? "chevron.down" : "chevron.right")
+                    .font(.system(size: 9, weight: .bold))
+                    .foregroundStyle(.tertiary)
+                    .frame(width: 12, height: 12)
+                    .contentShape(Rectangle())
+            }
+            .buttonStyle(.plain)
+            .help(fileSystemManager.isExpanded(item.url) ? "Collapse" : "Expand")
         } else {
             Color.clear.frame(width: 12, height: 12)
         }