fix: release memory when closing tabs (#434)

* 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

* fix: set isKeyWindow when WindowAccessor captures window

WindowAccessor.viewDidMoveToWindow fires after didBecomeKeyNotification,
so isKeyWindow was never set to true. This blocked sidebar table clicks
(guarded by isKeyWindow) and caused new tabs to open as separate windows
instead of attaching to the connection's tab group.

* fix: explicitly attach new windows to existing tab group

openWindow creates the window before tabbingIdentifier is set, so macOS
automatic tabbing doesn't group them. Use addTabbedWindow to explicitly
attach new windows to the connection's existing tab group.

* fix: add diagnostic logging for tab grouping

* fix: add NSLog diagnostic for windowDidBecomeKey

* fix: match SwiftUI window identifiers with hasPrefix instead of exact match

SwiftUI appends -AppWindow-N to the WindowGroup id, so window.identifier
is "main-AppWindow-1" not "main". The exact match from PR #441 broke
isMainWindow, preventing tab grouping and window lifecycle handling.

* fix: use prefix matching for window identifiers across all call sites

SwiftUI appends -AppWindow-N to WindowGroup IDs. Fixed remaining spots
that used .contains("main") or exact match:
- closeRestoredMainWindows: use isMainWindow helper
- closeWindows(withId:): prefix match instead of contains
- ContentView notification filter: prefix match instead of contains

* fix: address code review feedback

- Use queue: .main instead of assumeIsolated in DataGridView teardown observer
- Apply hasPrefix matching to isWelcomeWindow and isConnectionFormWindow
- Gate RowBuffer/QueryTabManager deinit logging behind #if DEBUG
- Add CHANGELOG entries for memory, tab grouping, and sidebar fixes

* fix: guard buffer writes against nil to avoid mutating shared emptyBuffer

* docs: simplify changelog entries

Author: datlechin

CHANGELOG.md

@@ -16,6 +16,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Health monitor now detects stuck queries beyond the configured timeout
 - SSH tunnel closure errors now logged instead of silently discarded
 - Schema/database restore errors during reconnect now logged
+- Memory not released after closing tabs
+- New tabs opening as separate windows instead of joining the connection tab group
+- Clicking tables in sidebar not opening table tabs
 
 ## [0.23.1] - 2026-03-24
 

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

@@ -290,9 +290,31 @@ 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()
+        // Don't call textCoordinators.destroy() here — the caller (coordinator.destroy())
+        // is already a coordinator, so calling back into destroy() causes infinite recursion.
+        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/AppDelegate+WindowConfig.swift

@@ -107,15 +107,18 @@ extension AppDelegate {
     }
 
     func isMainWindow(_ window: NSWindow) -> Bool {
-        window.identifier?.rawValue == WindowId.main
+        guard let rawValue = window.identifier?.rawValue else { return false }
+        return rawValue == WindowId.main || rawValue.hasPrefix("\(WindowId.main)-")
     }
 
     func isWelcomeWindow(_ window: NSWindow) -> Bool {
-        window.identifier?.rawValue == WindowId.welcome
+        guard let rawValue = window.identifier?.rawValue else { return false }
+        return rawValue == WindowId.welcome || rawValue.hasPrefix("\(WindowId.welcome)-")
     }
 
     private func isConnectionFormWindow(_ window: NSWindow) -> Bool {
-        window.identifier?.rawValue == WindowId.connectionForm
+        guard let rawValue = window.identifier?.rawValue else { return false }
+        return rawValue == WindowId.connectionForm || rawValue.hasPrefix("\(WindowId.connectionForm)-")
     }
 
     // MARK: - Welcome Window
@@ -239,15 +242,26 @@ extension AppDelegate {
             let existingIdentifier = NSApp.windows
                 .first { $0 !== window && isMainWindow($0) && $0.isVisible }?
                 .tabbingIdentifier
-            window.tabbingIdentifier = TabbingIdentifierResolver.resolve(
+            let resolvedIdentifier = TabbingIdentifierResolver.resolve(
                 pendingConnectionId: pendingId,
                 existingIdentifier: existingIdentifier
             )
+            window.tabbingIdentifier = resolvedIdentifier
             configuredWindows.insert(windowId)
 
             if !NSWindow.allowsAutomaticWindowTabbing {
                 NSWindow.allowsAutomaticWindowTabbing = true
             }
+
+            // Explicitly attach to existing tab group — automatic tabbing
+            // doesn't work when tabbingIdentifier is set after window creation.
+            if let existingWindow = NSApp.windows.first(where: {
+                $0 !== window && isMainWindow($0) && $0.isVisible
+                    && $0.tabbingIdentifier == resolvedIdentifier
+            }) {
+                existingWindow.addTabbedWindow(window, ordered: .above)
+                window.makeKeyAndOrderFront(nil)
+            }
         }
     }
 
@@ -317,8 +331,8 @@ extension AppDelegate {
     }
 
     func closeRestoredMainWindows() {
-        DispatchQueue.main.async {
-            for window in NSApp.windows where window.identifier?.rawValue.contains("main") == true {
+        DispatchQueue.main.async { [weak self] in
+            for window in NSApp.windows where self?.isMainWindow(window) == true {
                 window.close()
             }
         }

TablePro/ContentView.swift

@@ -114,7 +114,8 @@ struct ContentView: View {
                 // Match by checking if the window is registered for our connectionId
                 // in WindowLifecycleMonitor (subtitle may not be set yet on first appear).
                 guard let notificationWindow = notification.object as? NSWindow,
-                      notificationWindow.identifier?.rawValue.contains("main") == true,
+                      let windowId = notificationWindow.identifier?.rawValue,
+                      windowId == "main" || windowId.hasPrefix("main-"),
                       let connectionId = payload?.connectionId
                 else { return }
 

TablePro/Extensions/NSApplication+WindowManagement.swift

@@ -10,12 +10,14 @@
 import AppKit
 
 extension NSApplication {
-    /// Close all windows whose identifier contains the given ID.
-    /// Legacy workaround from when the minimum was macOS 13. Now that macOS 14+ is the minimum,
-    /// callers could use SwiftUI's `dismissWindow(id:)` instead.
+    /// Close all windows whose identifier matches the given ID (exact or SwiftUI-suffixed).
+    /// SwiftUI appends "-AppWindow-N" to WindowGroup IDs, so we match by prefix.
     func closeWindows(withId id: String) {
-        for window in windows where window.identifier?.rawValue.contains(id) == true {
-            window.close()
+        for window in windows {
+            guard let rawValue = window.identifier?.rawValue else { continue }
+            if rawValue == id || rawValue.hasPrefix("\(id)-") {
+                window.close()
+            }
         }
     }
 }

TablePro/Models/Query/QueryTab.swift

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

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,8 @@ final class InMemoryRowProvider: RowProvider {
         guard rowIndex < totalRowCount else { return }
         let sourceIndex = resolveSourceIndex(rowIndex)
         if let bufferIdx = sourceIndex.bufferIndex {
-            rowBuffer.rows[bufferIdx][columnIndex] = value
+            guard let buffer = rowBuffer else { return }
+            buffer.rows[bufferIdx][columnIndex] = value
             displayCache.removeValue(forKey: bufferIdx)
         } else if let appendedIdx = sourceIndex.appendedIndex {
             appendedRows[appendedIdx][columnIndex] = value
@@ -215,9 +222,18 @@ 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
+        guard let buffer = rowBuffer else { return }
+        buffer.rows = newRows
         appendedRows.removeAll()
         sortIndices = nil
         displayCache.removeAll()
@@ -240,17 +256,18 @@ final class InMemoryRowProvider: RowProvider {
             guard appendedIdx < appendedRows.count else { return }
             appendedRows.remove(at: appendedIdx)
         } else {
+            guard let buffer = rowBuffer else { return }
             if let sorted = sortIndices {
                 let bufferIdx = sorted[index]
-                rowBuffer.rows.remove(at: bufferIdx)
+                buffer.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)
+                buffer.rows.remove(at: index)
             }
         }
         displayCache.removeAll()
@@ -297,9 +314,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