fix(ios): un-latch memory pressure monitor and gate editor truncation

Author: datlechin

TableProMobile/TableProMobile/Platform/MemoryPressureMonitor.swift

@@ -23,14 +23,21 @@ final class MemoryPressureMonitor {
         guard source == nil else { return }
 
         let newSource = DispatchSource.makeMemoryPressureSource(
-            eventMask: [.warning, .critical],
+            eventMask: [.normal, .warning, .critical],
             queue: .global(qos: .utility)
         )
 
         newSource.setEventHandler { [weak self] in
             let event = newSource.data
-            let level: Level = event.contains(.critical) ? .critical : .warning
-            Self.logger.warning("Memory pressure event: \(String(describing: level), privacy: .public)")
+            let level: Level
+            if event.contains(.critical) {
+                level = .critical
+            } else if event.contains(.warning) {
+                level = .warning
+            } else {
+                level = .normal
+            }
+            Self.logger.log("Memory pressure level: \(String(describing: level), privacy: .public)")
             Task { @MainActor in
                 self?.currentLevel = level
             }
@@ -40,10 +47,6 @@ final class MemoryPressureMonitor {
         source = newSource
     }
 
-    func reset() {
-        currentLevel = .normal
-    }
-
     nonisolated func availableMemoryBytes() -> Int {
         Int(os_proc_available_memory())
     }

TableProMobile/TableProMobile/ViewModels/QueryEditorViewModel.swift

@@ -121,20 +121,18 @@ final class QueryEditorViewModel {
             case .normal:
                 return
             case .warning, .critical:
+                guard case .running = self.phase else { return }
                 Self.logger.warning("Memory pressure: stopping query stream to stay within limits")
                 self.fetchTask?.cancel()
                 guard !self.buffer.isEmpty else { return }
                 self.buffer.markTruncated(.memoryPressure)
-                if case .running = self.phase {
-                    self.phase = .truncated(reason: .memoryPressure)
-                }
+                self.phase = .truncated(reason: .memoryPressure)
             }
         }
     }
 
     private func isMemoryConstrained() -> Bool {
-        if MemoryPressureMonitor.shared.currentLevel != .normal { return true }
-        return !MemoryPressureMonitor.shared.hasHeadroom(forBytes: Self.memorySafetyMarginBytes)
+        !MemoryPressureMonitor.shared.hasHeadroom(forBytes: Self.memorySafetyMarginBytes)
     }
 
     private func resolvePhase() {

TableProMobile/TableProMobileTests/QueryEditorViewModelTests.swift

@@ -53,8 +53,8 @@ struct QueryEditorViewModelTests {
         }
     }
 
-    @Test("handlePressure marks results truncated when rows are present")
-    func pressureMarksTruncated() async {
+    @Test("memory pressure after a clean finish does not relabel the result")
+    func pressureDoesNotRelabelFinishedResult() async {
         let driver = MockDatabaseDriver()
         driver.scriptedExecuteResults = [
             .success(QueryResult(columns: makeColumns(), rows: [["1"], ["2"]], rowsAffected: 0, executionTime: 0))
@@ -67,8 +67,10 @@ struct QueryEditorViewModelTests {
         await vm.handlePressure(.warning)
 
         #expect(vm.legacyRows.count == 2)
-        if case .memoryPressure = vm.truncationReason {} else {
-            Issue.record("expected memoryPressure truncation")
+        #expect(vm.truncationReason == nil)
+        #expect(vm.truncationMessage == nil)
+        if case .finished = vm.phase {} else {
+            Issue.record("a completed result must stay finished after a memory warning")
         }
     }