fix: reduce memory retention after closing tabs

- Clear changeManager state and pluginDriver reference in teardown
- Cancel redisDatabaseSwitchTask in teardown
- Clear cachedTableColumnTypes/Names, tableMetadata, filterState in teardown
- Release editor closures and heavy state (tree-sitter, highlighter) on destroy
- Add releaseHeavyState() to TextViewController for early resource cleanup
- Make InMemoryRowProvider.rowBuffer weak with safe fallback
- Add releaseData() to InMemoryRowProvider for explicit cleanup
- Clear tabProviderCache, sortCache, cachedChangeManager in onTeardown
- Hint malloc to return freed pages after disconnect
- Add deinit logging for RowBuffer and QueryTabManager

Author: datlechin

LocalPackages/CodeEditSourceEditor/Sources/CodeEditSourceEditor/Controller/TextViewController.swift

@@ -290,9 +290,30 @@ public class TextViewController: NSViewController {
         self.gutterView.setNeedsDisplay(self.gutterView.frame)
     }
 
+    /// Release heavy resources (tree-sitter, highlighter, text storage) early,
+    /// without waiting for deinit. Call when the editor is no longer visible but
+    /// SwiftUI may keep the controller alive in @State.
+    public func releaseHeavyState() {
+        if let highlighter {
+            textView?.removeStorageDelegate(highlighter)
+        }
+        highlighter = nil
+        treeSitterClient = nil
+        highlightProviders.removeAll()
+        textCoordinators.values().forEach { $0.destroy() }
+        textCoordinators.removeAll()
+        cancellables.forEach { $0.cancel() }
+        cancellables.removeAll()
+        if let localEventMonitor {
+            NSEvent.removeMonitor(localEventMonitor)
+        }
+        localEventMonitor = nil
+        textView?.setText("")
+    }
+
     deinit {
         if let highlighter {
-            textView.removeStorageDelegate(highlighter)
+            textView?.removeStorageDelegate(highlighter)
         }
         highlighter = nil
         highlightProviders.removeAll()

TablePro/Models/Query/QueryTab.swift

@@ -7,6 +7,7 @@
 
 import Foundation
 import Observation
+import os
 import TableProPluginKit
 
 /// Type of tab
@@ -269,6 +270,11 @@ final class RowBuffer {
         self.rows = newRows
         isEvicted = false
     }
+
+    deinit {
+        Logger(subsystem: "com.TablePro", category: "RowBuffer")
+            .debug("RowBuffer deallocated — columns: \(self.columns.count), evicted: \(self.isEvicted)")
+    }
 }
 
 /// Represents a single tab (query or table)
@@ -676,4 +682,9 @@ final class QueryTabManager {
             tabs[index] = tab
         }
     }
+
+    deinit {
+        Logger(subsystem: "com.TablePro", category: "QueryTabManager")
+            .debug("QueryTabManager deallocated")
+    }
 }

TablePro/Models/Query/RowProvider.swift

@@ -66,7 +66,12 @@ final class TableRowData {
 /// Direct-access methods `value(atRow:column:)` and `rowValues(at:)` avoid
 /// heap allocations by reading straight from the source `[String?]` array.
 final class InMemoryRowProvider: RowProvider {
-    private let rowBuffer: RowBuffer
+    private weak var rowBuffer: RowBuffer?
+    /// Strong reference only when the provider created its own buffer (convenience init).
+    /// External buffers are owned by QueryTab, so we hold them weakly.
+    private var ownedBuffer: RowBuffer?
+    private static let emptyBuffer = RowBuffer()
+    private var safeBuffer: RowBuffer { rowBuffer ?? Self.emptyBuffer }
     private var sortIndices: [Int]?
     private var appendedRows: [[String?]] = []
     private(set) var columns: [String]
@@ -86,7 +91,7 @@ final class InMemoryRowProvider: RowProvider {
 
     /// Number of rows coming from the buffer (respecting sort indices count when present)
     private var bufferRowCount: Int {
-        sortIndices?.count ?? rowBuffer.rows.count
+        sortIndices?.count ?? safeBuffer.rows.count
     }
 
     init(
@@ -130,6 +135,7 @@ final class InMemoryRowProvider: RowProvider {
             columnEnumValues: columnEnumValues,
             columnNullable: columnNullable
         )
+        ownedBuffer = buffer
     }
 
     func fetchRows(offset: Int, limit: Int) -> [TableRowData] {
@@ -157,7 +163,7 @@ final class InMemoryRowProvider: RowProvider {
         guard rowIndex < totalRowCount else { return }
         let sourceIndex = resolveSourceIndex(rowIndex)
         if let bufferIdx = sourceIndex.bufferIndex {
-            rowBuffer.rows[bufferIdx][columnIndex] = value
+            safeBuffer.rows[bufferIdx][columnIndex] = value
             displayCache.removeValue(forKey: bufferIdx)
         } else if let appendedIdx = sourceIndex.appendedIndex {
             appendedRows[appendedIdx][columnIndex] = value
@@ -215,9 +221,17 @@ final class InMemoryRowProvider: RowProvider {
         displayCache.removeAll()
     }
 
+    /// Release cached data to free memory when this provider is no longer active.
+    func releaseData() {
+        displayCache.removeAll()
+        appendedRows.removeAll()
+        sortIndices = nil
+        ownedBuffer = nil
+    }
+
     /// Update rows by replacing the buffer contents and clearing appended rows
     func updateRows(_ newRows: [[String?]]) {
-        rowBuffer.rows = newRows
+        safeBuffer.rows = newRows
         appendedRows.removeAll()
         sortIndices = nil
         displayCache.removeAll()
@@ -242,15 +256,15 @@ final class InMemoryRowProvider: RowProvider {
         } else {
             if let sorted = sortIndices {
                 let bufferIdx = sorted[index]
-                rowBuffer.rows.remove(at: bufferIdx)
+                safeBuffer.rows.remove(at: bufferIdx)
                 var newIndices = sorted
                 newIndices.remove(at: index)
                 for i in newIndices.indices where newIndices[i] > bufferIdx {
                     newIndices[i] -= 1
                 }
                 sortIndices = newIndices
             } else {
-                rowBuffer.rows.remove(at: index)
+                safeBuffer.rows.remove(at: index)
             }
         }
         displayCache.removeAll()
@@ -297,9 +311,9 @@ final class InMemoryRowProvider: RowProvider {
             return appendedRows[displayIndex - bCount]
         }
         if let sorted = sortIndices {
-            return rowBuffer.rows[sorted[displayIndex]]
+            return safeBuffer.rows[sorted[displayIndex]]
         }
-        return rowBuffer.rows[displayIndex]
+        return safeBuffer.rows[displayIndex]
     }
 }
 

TablePro/Resources/Localizable.xcstrings

@@ -27181,6 +27181,9 @@
           }
         }
       }
+    },
+    "SSH Connection Test Failed" : {
+
     },
     "SSH connection timed out" : {
       "localizations" : {

TablePro/Views/Editor/SQLEditorCoordinator.swift

@@ -146,7 +146,22 @@ final class SQLEditorCoordinator: TextViewCoordinator {
         inlineSuggestionManager?.uninstall()
         inlineSuggestionManager = nil
 
+        // Release closure captures to break potential retain cycles
+        onCloseTab = nil
+        onExecuteQuery = nil
+        onAIExplain = nil
+        onAIOptimize = nil
+        onSaveAsFavorite = nil
+        schemaProvider = nil
+        contextMenu = nil
+        vimEngine = nil
+        vimCursorManager = nil
+
+        // Release editor controller heavy state
+        controller?.releaseHeavyState()
+
         EditorEventRouter.shared.unregister(self)
+        Self.logger.debug("SQLEditorCoordinator destroyed")
         cleanupMonitors()
     }
 

TablePro/Views/Editor/SQLEditorView.swift

@@ -126,6 +126,7 @@ struct SQLEditorView: View {
         .onDisappear {
             teardownFavoritesObserver()
             coordinator.destroy()
+            completionAdapter = nil
         }
         .onChange(of: coordinator.vimMode) { _, newMode in
             vimMode = newMode

TablePro/Views/Main/Child/MainEditorContentView.swift

@@ -147,6 +147,11 @@ struct MainEditorContentView: View {
             if let tab = tabManager.selectedTab {
                 cacheRowProvider(for: tab)
             }
+            coordinator.onTeardown = { [self] in
+                tabProviderCache.removeAll()
+                sortCache.removeAll()
+                cachedChangeManager = nil
+            }
         }
         .onChange(of: tabManager.selectedTab?.resultVersion) { _, newVersion in
             guard let tab = tabManager.selectedTab, newVersion != nil else { return }

TablePro/Views/Main/MainContentCoordinator.swift

@@ -46,6 +46,10 @@ enum ActiveSheet: Identifiable {
 final class MainContentCoordinator {
     static let logger = Logger(subsystem: "com.TablePro", category: "MainContentCoordinator")
 
+    /// Posted during teardown so DataGridView coordinators can release cell views.
+    /// Object is the connection UUID.
+    static let teardownNotification = Notification.Name("MainContentCoordinator.teardown")
+
     // MARK: - Dependencies
 
     let connection: DatabaseConnection
@@ -125,6 +129,9 @@ final class MainContentCoordinator {
     /// (e.g. save-then-close). Set before calling `saveChanges`, resumed by `executeCommitStatements`.
     @ObservationIgnored internal var saveCompletionContinuation: CheckedContinuation<Bool, Never>?
 
+    /// Called during teardown to let the view layer release cached row providers and sort data.
+    @ObservationIgnored var onTeardown: (() -> Void)?
+
     /// True while a database switch is in progress. Guards against
     /// side-effect window creation during the switch cascade.
     var isSwitchingDatabase = false
@@ -334,6 +341,7 @@ final class MainContentCoordinator {
     /// synchronously on MainActor so we don't depend on deinit + Task scheduling.
     func teardown() {
         _didTeardown.withLock { $0 = true }
+
         unregisterFromPersistence()
         for observer in urlFilterObservers {
             NotificationCenter.default.removeObserver(observer)
@@ -351,18 +359,44 @@ final class MainContentCoordinator {
         currentQueryTask = nil
         changeManagerUpdateTask?.cancel()
         changeManagerUpdateTask = nil
+        redisDatabaseSwitchTask?.cancel()
+        redisDatabaseSwitchTask = nil
         for task in activeSortTasks.values { task.cancel() }
         activeSortTasks.removeAll()
 
+        // Let the view layer release cached row providers before we drop RowBuffers.
+        // Called synchronously here because SwiftUI onChange handlers don't fire
+        // reliably on disappearing views.
+        onTeardown?()
+        onTeardown = nil
+
+        // Notify DataGridView coordinators to release NSTableView cell views
+        NotificationCenter.default.post(
+            name: Self.teardownNotification,
+            object: connection.id
+        )
+
         // Release heavy data so memory drops even if SwiftUI delays deallocation
         for tab in tabManager.tabs {
             tab.rowBuffer.evict()
         }
         querySortCache.removeAll()
+        cachedTableColumnTypes.removeAll()
+        cachedTableColumnNames.removeAll()
 
         tabManager.tabs.removeAll()
         tabManager.selectedTabId = nil
 
+        // Release change manager state — pluginDriver holds a strong reference
+        // to the entire database driver which prevents deallocation
+        changeManager.clearChanges()
+        changeManager.pluginDriver = nil
+
+        // Release metadata and filter state
+        tableMetadata = nil
+        filterStateManager.filters.removeAll()
+        filterStateManager.appliedFilters.removeAll()
+
         SchemaProviderRegistry.shared.release(for: connection.id)
         SchemaProviderRegistry.shared.purgeUnused()
     }

TablePro/Views/Main/MainContentView.swift

@@ -272,7 +272,11 @@ struct MainContentView: View {
                     // If no more windows for this connection, disconnect.
                     // Tab state is NOT cleared here — it's preserved for next reconnect.
                     // Only handleTabsChange(count=0) clears state (user explicitly closed all tabs).
-                    guard !WindowLifecycleMonitor.shared.hasWindows(for: connectionId) else { return }
+                    guard !WindowLifecycleMonitor.shared.hasWindows(for: connectionId) else {
+                        // Hint malloc to return freed pages to the OS
+                        malloc_zone_pressure_relief(nil, 0)
+                        return
+                    }
 
                     let hasVisibleWindow = NSApp.windows.contains { window in
                         window.isVisible && (window.subtitle == connectionName
@@ -281,6 +285,11 @@ struct MainContentView: View {
                     if !hasVisibleWindow {
                         await DatabaseManager.shared.disconnectSession(connectionId)
                     }
+
+                    // Give SwiftUI/AppKit time to deallocate view hierarchies,
+                    // then hint malloc to return freed pages to the OS
+                    try? await Task.sleep(for: .seconds(2))
+                    malloc_zone_pressure_relief(nil, 0)
                 }
             }
             .onChange(of: pendingChangeTrigger) {

TablePro/Views/Results/DataGridView.swift

@@ -166,6 +166,9 @@ struct DataGridView: NSViewRepresentable {
 
         scrollView.documentView = tableView
         context.coordinator.tableView = tableView
+        if let connectionId {
+            context.coordinator.observeTeardown(connectionId: connectionId)
+        }
 
         return scrollView
     }
@@ -632,6 +635,7 @@ struct DataGridView: NSViewRepresentable {
             NotificationCenter.default.removeObserver(observer)
             coordinator.themeObserver = nil
         }
+        coordinator.rowProvider = InMemoryRowProvider(rows: [], columns: [])
     }
 
     func makeCoordinator() -> TableViewCoordinator {
@@ -839,13 +843,64 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         }
     }
 
+    /// Subscribe to coordinator teardown to release NSTableView cell views.
+    func observeTeardown(connectionId: UUID) {
+        teardownObserver = NotificationCenter.default.addObserver(
+            forName: MainContentCoordinator.teardownNotification,
+            object: connectionId,
+            queue: nil
+        ) { [weak self] _ in
+            guard let self else { return }
+            MainActor.assumeIsolated {
+                self.releaseData()
+            }
+        }
+    }
+
+    /// Release all data and cell views from the NSTableView.
+    /// Called during coordinator teardown to free memory while SwiftUI holds the view.
+    private func releaseData() {
+        overlayEditor?.dismiss(commit: false)
+        rowProvider = InMemoryRowProvider(rows: [], columns: [])
+        rowVisualStateCache.removeAll()
+        cachedRowCount = 0
+        cachedColumnCount = 0
+        // Remove columns and reload to release cell views
+        if let tableView {
+            while let col = tableView.tableColumns.last {
+                tableView.removeTableColumn(col)
+            }
+            tableView.reloadData()
+        }
+        // Release closures
+        onRefresh = nil
+        onCellEdit = nil
+        onDeleteRows = nil
+        onCopyRows = nil
+        onPasteRows = nil
+        onUndo = nil
+        onRedo = nil
+        onSort = nil
+        onAddRow = nil
+        onUndoInsert = nil
+        onFilterColumn = nil
+        onHideColumn = nil
+        onNavigateFK = nil
+        getVisualState = nil
+    }
+
+    private var teardownObserver: NSObjectProtocol?
+
     deinit {
         if let observer = settingsObserver {
             NotificationCenter.default.removeObserver(observer)
         }
         if let observer = themeObserver {
             NotificationCenter.default.removeObserver(observer)
         }
+        if let observer = teardownObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
     }
 
     func updateCache() {