test: start reload cases from a settled configuration coordinator

Sources/GhosttyTerminalView.swift

@@ -2206,6 +2206,56 @@ class GhosttyApp {
         configurationReloadCoordinator.isReloadActive
     }
 
+#if DEBUG
+    /// Whether no configuration reload is active, queued, or waiting behind
+    /// font work, and no outstanding font work would defer the next one.
+    @MainActor
+    var isConfigurationReloadSettledForVerification: Bool {
+        guard configurationReloadCoordinator
+                .isSettledForVerification else {
+            return false
+        }
+        guard let arbiter =
+                AppDelegate.shared?
+                    .workspaceTerminalFontSizeArbiter else {
+            return true
+        }
+        return arbiter.isFontSizeWorkIdleForVerification
+    }
+
+    /// Finishes any configuration reload left in flight by earlier work so a
+    /// caller starts from a known idle coordinator.
+    ///
+    /// Surface fanout is cancelled the same way a newer reload cancels it, so
+    /// the transaction unwinds through its normal completion path instead of
+    /// waiting one main-actor turn per registered surface. Returns `false` if
+    /// work remained after `timeout`, which means the font-size arbiter never
+    /// went idle.
+    @MainActor
+    @discardableResult
+    func settleConfigurationReloadForVerification(
+        timeout: TimeInterval = 5
+    ) -> Bool {
+        let deadline = Date(timeIntervalSinceNow: timeout)
+        while !isConfigurationReloadSettledForVerification {
+            guard Date() < deadline else { return false }
+            if terminalConfigurationApplyScheduler.hasPendingWork {
+                terminalConfigurationApplyScheduler
+                    .cancelPendingWork()
+                continue
+            }
+            RunLoop.main.run(
+                mode: .default,
+                before: min(
+                    deadline,
+                    Date(timeIntervalSinceNow: 0.01)
+                )
+            )
+        }
+        return true
+    }
+#endif
+
     @MainActor
     func terminalFontConfigurationSnapshot()
         -> WorkspaceTerminalFontConfigurationSnapshot {

Sources/TerminalConfigurationReloadCoordinator.swift

@@ -39,6 +39,17 @@ final class TerminalConfigurationReloadCoordinator {
         phase == .waitingForFontWork
     }
 
+#if DEBUG
+    /// Whether no transaction is active, queued, or waiting for font work.
+    ///
+    /// Tests share one process-wide coordinator, so a case that depends on
+    /// taking the font-work barrier must be able to observe that an earlier
+    /// case left nothing in flight.
+    var isSettledForVerification: Bool {
+        phase == .idle && pendingRequest == nil
+    }
+#endif
+
     /// Queues a request while bounding commit and post-fanout callbacks across
     /// the active and pending transactions. Reload semantics are retained even
     /// when excess callbacks are rejected.

Sources/WorkspaceTerminalFontSizeArbiter.swift

@@ -834,6 +834,14 @@ final class WorkspaceTerminalFontSizeArbiter {
             && extendedFontSizeWorkIdleBarrierTokens.isEmpty
     }
 
+#if DEBUG
+    /// Whether a configuration reload requested now would take the font-work
+    /// barrier immediately instead of queueing behind outstanding font work.
+    var isFontSizeWorkIdleForVerification: Bool {
+        isFontSizeWorkIdleBeforeBarrier && !hasFontSizeWorkIdleBarrier
+    }
+#endif
+
     @discardableResult
     private func appendDeferredCoordinatorJoin(
         _ join: DeferredWorkspaceTerminalFontSizeCoordinatorJoin,

cmuxTests/AppDelegateEqualizeSplitsShortcutTests.swift

@@ -367,6 +367,26 @@ private func waitWhileSuspended(
     }
 }
 
+#if DEBUG
+/// Drives any configuration reload left in flight by an earlier case to
+/// completion.
+///
+/// `GhosttyApp.shared` owns one process-wide reload coordinator, and a reload
+/// now spans several main-actor turns, so a case that depends on taking the
+/// font-work barrier cannot assume the previous case left it idle.
+@MainActor
+private func settleConfigurationReload(
+    _ app: GhosttyApp,
+    sourceLocation: SourceLocation = #_sourceLocation
+) {
+    XCTAssertTrue(
+        app.settleConfigurationReloadForVerification(),
+        "Earlier work left a configuration reload or font-size work in flight",
+        sourceLocation: sourceLocation
+    )
+}
+#endif
+
 @MainActor
 private extension TabManager {
     @discardableResult
@@ -5502,8 +5522,16 @@ final class AppDelegateEqualizeSplitsShortcutTests {
         throws {
 #if DEBUG
         let app = GhosttyApp.shared
+        settleConfigurationReload(app)
         let originalProfile =
             GhosttyStartupAppearancePreviewState.profile
+        // Hold one transaction open so the staged reload below is the queued
+        // case this test is about. It reloads the unchanged configuration, so
+        // the appearance captured next is still the one to restore.
+        app.reloadConfiguration(
+            source: "test.stageAppearance.active",
+            reloadSettingsFromFile: false
+        )
         let originalBackgroundHex =
             app.defaultBackgroundColor.hexString()
         let targetProfile: GhosttyStartupAppearancePreviewProfile =
@@ -5568,7 +5596,7 @@ final class AppDelegateEqualizeSplitsShortcutTests {
         XCTAssertEqual(
             app.defaultBackgroundColor.hexString(),
             originalBackgroundHex,
-            "A pending full reload must not publish its new background before the matching Ghostty config commits"
+            "A full reload queued behind an active transaction must not publish its new background before its own Ghostty config commits"
         )
         wait(for: [reloadCompleted], timeout: 5)
         XCTAssertNotEqual(
@@ -5586,6 +5614,7 @@ final class AppDelegateEqualizeSplitsShortcutTests {
         throws {
 #if DEBUG
         let app = GhosttyApp.shared
+        settleConfigurationReload(app)
         let retainedPanels = (0..<16).map { _ in
             TerminalPanel(
                 workspaceId: UUID(),
@@ -5704,6 +5733,7 @@ final class AppDelegateEqualizeSplitsShortcutTests {
         throws {
 #if DEBUG
         let app = GhosttyApp.shared
+        settleConfigurationReload(app)
         let retainedPanels = (0..<16).map { _ in
             TerminalPanel(
                 workspaceId: UUID(),
@@ -6232,6 +6262,9 @@ final class AppDelegateEqualizeSplitsShortcutTests {
             XCTFail("Expected AppDelegate.shared")
             return
         }
+#if DEBUG
+        settleConfigurationReload(GhosttyApp.shared)
+#endif
         let manager = TabManager()
         guard let workspace = manager.selectedWorkspace,
               let panelId = workspace.focusedPanelId,
@@ -6280,12 +6313,16 @@ final class AppDelegateEqualizeSplitsShortcutTests {
         XCTAssertEqual(applyAttemptCount, 2)
 
         var didUpdateGhosttyAppConfig = false
+        let configUpdated = expectation(
+            description: "ghostty app config update published"
+        )
         let observer = NotificationCenter.default.addObserver(
             forName: .ghosttyConfigDidReload,
             object: nil,
             queue: .main
         ) { _ in
             didUpdateGhosttyAppConfig = true
+            configUpdated.fulfill()
         }
         defer {
             NotificationCenter.default.removeObserver(observer)
@@ -6305,6 +6342,9 @@ final class AppDelegateEqualizeSplitsShortcutTests {
             scheduler.fire(at: 2)
         }
         XCTAssertEqual(applyAttemptCount, 3)
+        // Releasing the barrier commits the app configuration; the reload
+        // publishes this notification once its bounded surface fanout drains.
+        wait(for: [configUpdated], timeout: 5)
         XCTAssertTrue(didUpdateGhosttyAppConfig)
     }