Fix iOS terminal typing latency

.github/workflows/test-depot.yml

@@ -165,7 +165,11 @@ jobs:
               suite_output=$(run_unit_suite "-only-testing:cmuxTests/$suite") || suite_status=$?
               printf '%s\n' "$suite_output"
               if [ "$suite_status" -ne 0 ]; then return "$suite_status"; fi
-              if ! printf '%s\n' "$suite_output" | grep -Eq 'Test run with [1-9][0-9]* tests|Executed [1-9][0-9]* tests'; then
+              # A pipeline here makes `set -o pipefail` treat grep's normal
+              # early exit as a printf SIGPIPE when the xcodebuild log is
+              # large. Feed grep with a here-string so a passing suite cannot
+              # be reported as empty because of that logging artifact.
+              if ! grep -Eq 'Test run with [1-9][0-9]* tests|Executed [1-9][0-9]* tests' <<<"$suite_output"; then
                 echo "No tests executed for $suite" >&2
                 return 1
               fi

Packages/Shared/CmuxIrohTransport/Sources/CmuxIrohTransport/CmxIrohClientSession.swift

@@ -157,7 +157,7 @@ public actor CmxIrohClientSession {
         priority: Int32
     ) async throws -> CmxIrohBidirectionalStream {
         switch lane {
-        case .terminal, .artifact, .simulatorStream:
+        case .terminal, .terminalInput, .artifact, .simulatorStream:
             break
         case .control, .serverEvents:
             throw CmxIrohClientSessionError.invalidOutgoingLane

Packages/Shared/CmuxIrohTransport/Sources/CmuxIrohTransport/CmxIrohLane.swift

@@ -9,6 +9,12 @@ public enum CmxIrohLane: Equatable, Sendable {
     /// One terminal's ordered stream resumed after the optional byte cursor.
     case terminal(resourceID: CmxIrohResourceID, cursor: UInt64?)
 
+    /// A terminal input-only lane. The host sends one empty replay envelope
+    /// as a readiness baseline, then the stream carries only input frames.
+    /// Render-grid sessions use this lane so keystrokes never wait on RPC
+    /// settlement or compete with the authoritative output event stream.
+    case terminalInput(resourceID: CmxIrohResourceID)
+
     /// A low-priority artifact stream resumed at an exact byte offset.
     case artifact(resourceID: CmxIrohResourceID, offset: UInt64)
 

Packages/Shared/CmuxIrohTransport/Sources/CmuxIrohTransport/CmxIrohServerSession.swift

@@ -197,7 +197,7 @@ public actor CmxIrohServerSession {
                 from: stream.receiveStream
             )
             switch decoded.header.lane {
-            case .terminal, .artifact, .simulatorStream:
+            case .terminal, .terminalInput, .artifact, .simulatorStream:
                 break
             case .control, .serverEvents:
                 throw CmxIrohServerSessionError.invalidPeerLane
@@ -235,7 +235,7 @@ public actor CmxIrohServerSession {
             break
         case .artifact:
             throw CmxIrohServerSessionError.applicationLanesUnavailable
-        case .control, .terminal, .simulatorStream:
+        case .control, .terminal, .terminalInput, .simulatorStream:
             throw CmxIrohServerSessionError.invalidServerLane
         }
         let stream = try await connection.openSendStream()

Packages/Shared/CmuxIrohTransport/Sources/CmuxIrohTransport/CmxIrohStreamHeaderCodec.swift

@@ -78,6 +78,12 @@ public struct CmxIrohStreamHeaderCodec: Sendable {
                 append(cursor, to: &payload)
             }
 
+        case let .terminalInput(resourceID):
+            laneCode = 6
+            credentialCode = 0
+            flags = 0
+            try appendLengthPrefixedString(resourceID.value, lengthByteCount: 1, to: &payload)
+
         case let .artifact(resourceID, offset):
             laneCode = 4
             credentialCode = 0
@@ -201,6 +207,15 @@ public struct CmxIrohStreamHeaderCodec: Sendable {
             }
             let resourceID = try readResourceID(payload: &payload)
             return try CmxIrohStreamHeader(lane: .simulatorStream(resourceID: resourceID))
+        case 6:
+            guard flags == 0 else {
+                throw CmxIrohStreamHeaderCodecError.invalidFlags(flags)
+            }
+            guard credentialCode == 0 else {
+                throw CmxIrohStreamHeaderCodecError.invalidCredentialKind(credentialCode)
+            }
+            let resourceID = try readResourceID(payload: &payload)
+            return try CmxIrohStreamHeader(lane: .terminalInput(resourceID: resourceID))
         default:
             throw CmxIrohStreamHeaderCodecError.unknownLane(laneCode)
         }

Packages/Shared/CmuxIrxTransport/Sources/CmuxIrxTransport/IrxProtocol.swift

@@ -87,6 +87,7 @@ public enum IrxLaneKind: String, Codable, Sendable {
     case keepalive
     case events
     case terminal
+    case terminalInput = "terminal_input"
     case artifact
     case simulatorStream = "simulator_stream"
 }

Packages/iOS/CmuxMobileRPC/Sources/CmuxMobileRPC/MobileSyncRuntime.swift

@@ -42,6 +42,9 @@ public protocol MobileSyncRuntime: Sendable {
     /// Optional source for one independent, sequence-aware terminal lane per
     /// mounted surface. A nil provider preserves control/event delivery.
     var terminalLaneProvider: MobileTerminalLaneProvider? { get }
+    /// Optional source for a terminal input-only lane. It carries one empty
+    /// replay baseline, then fire-and-forget input frames without output.
+    var terminalInputLaneProvider: MobileTerminalLaneProvider? { get }
     /// Optional source for low-priority raw artifact bytes on an admitted Iroh peer.
     var artifactLaneProvider: MobileArtifactLaneProvider? { get }
     /// Optional source for one dedicated simulator-stream v2 video lane per
@@ -69,6 +72,7 @@ public protocol MobileSyncRuntime: Sendable {
 public extension MobileSyncRuntime {
     var independentEventByteStreamProvider: CmxIndependentEventByteStreamProvider? { nil }
     var terminalLaneProvider: MobileTerminalLaneProvider? { nil }
+    var terminalInputLaneProvider: MobileTerminalLaneProvider? { nil }
     var artifactLaneProvider: MobileArtifactLaneProvider? { nil }
     var simulatorStreamLaneProvider: MobileSimulatorStreamLaneProvider? { nil }
 

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+Capabilities.swift

@@ -42,6 +42,14 @@ extension MobileShellComposite {
             && supportedHostCapabilities.contains(Self.terminalVerifiedReplayCapability)
     }
 
+    /// Hybrid sessions subscribe to render-grid events only for screen-state
+    /// tracking and alternate-screen recovery. Primary-screen painting stays
+    /// on the sequence-aware byte lane, so an advisory grid must never impose
+    /// its shared viewport dimensions on the local natural surface.
+    public var usesHybridTerminalOutput: Bool {
+        terminalOutputTransport == .hybrid
+    }
+
     /// Screen-anchored render-grid sessions receive active-area-anchored
     /// frames whose deltas carry exact scrolled-row counts, so this device
     /// keeps a deep local scrollback and scrolls the primary screen locally

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TerminalLane.swift

@@ -10,13 +10,21 @@ extension MobileShellComposite {
         guard !demonstrationOwnsSurface(surfaceID) else { return }
         guard let terminalLaneCoordinator,
               connectionState == .connected,
-              terminalOutputTransport != .renderGrid,
               terminalByteContinuationsBySurfaceID[surfaceID] != nil,
               let activeRoute,
               activeRoute.kind == .iroh,
               let activeTicket else {
             return
         }
+        let laneMode: MobileTerminalLaneCoordinator.LaneMode
+        if terminalOutputTransport == .renderGrid {
+            // Render-grid owns terminal output. Use a separate input-only
+            // stream so every key bypasses ordered RPC settlement.
+            guard runtime?.terminalInputLaneProvider != nil else { return }
+            laneMode = .inputOnly
+        } else {
+            laneMode = .output
+        }
         // A Direct lane request can redial the peer session, so it must carry
         // the same method-pinned allowlist as the control dial or it could
         // ride relay or discovered paths the method forbids. Tailscale
@@ -36,6 +44,7 @@ extension MobileShellComposite {
         let configuration = MobileTerminalLaneCoordinator.Configuration(
             request: request,
             surfaceID: surfaceID,
+            mode: laneMode,
             cursor: { @MainActor [weak self] in
                 guard let self,
                       self.connectionGeneration == connectionGeneration,
@@ -70,7 +79,7 @@ extension MobileShellComposite {
     func resumeTerminalLaneIfSuspended(surfaceID: String) {
         guard let terminalLaneCoordinator,
               connectionState == .connected,
-              terminalOutputTransport != .renderGrid else { return }
+              terminalReplayBarrierTokensBySurfaceID[surfaceID] == nil else { return }
         Task { await terminalLaneCoordinator.resume(surfaceID: surfaceID) }
     }
 
@@ -105,10 +114,22 @@ extension MobileShellComposite {
     }
 
     func reconcileTerminalLanesForOutputTransport() {
-        if terminalOutputTransport == .renderGrid {
-            deactivateAllTerminalLanes()
-        } else {
-            restartTerminalLanesForMountedSurfaces()
+        // Render-grid keeps its authoritative event stream for output, but
+        // retains an input-only lane for fire-and-forget keystrokes.
+        guard let terminalLaneCoordinator else { return }
+        terminalLaneLifecycleID = UUID()
+        let lifecycleID = terminalLaneLifecycleID
+        terminalLaneOutputReadySurfaceIDs.removeAll()
+        let mountedSurfaceIDs = Array(terminalByteContinuationsBySurfaceID.keys)
+        Task { @MainActor [weak self] in
+            await terminalLaneCoordinator.deactivateAll()
+            guard let self,
+                  self.terminalLaneLifecycleID == lifecycleID,
+                  self.connectionState == .connected else { return }
+            for surfaceID in mountedSurfaceIDs
+            where self.terminalByteContinuationsBySurfaceID[surfaceID] != nil {
+                self.ensureTerminalLane(surfaceID: surfaceID)
+            }
         }
     }
 
@@ -119,6 +140,11 @@ extension MobileShellComposite {
         guard terminalByteContinuationsBySurfaceID[surfaceID] != nil else {
             return .stop
         }
+        if terminalOutputTransport == .renderGrid {
+            // The input-only lane's baseline only gates readiness. Its output
+            // half is deliberately ignored because render-grid is authoritative.
+            return .accepted(outputReady: true)
+        }
         if terminalOutputTransport == .hybrid,
            terminalActiveScreenBySurfaceID[surfaceID] == .alternate {
             return .accepted(outputReady: true)

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TerminalOutputDelivery.swift

@@ -604,6 +604,10 @@ extension MobileShellComposite {
                 // so the floor restore is the truthful baseline hand-back.
                 restoreTerminalPreBarrierBaselineIfNeeded(surfaceID: surfaceID)
                 terminalReplayBarrierFollowUpCountsBySurfaceID.removeValue(forKey: surfaceID)
+                // Admission updates the cursor before the renderer acknowledges
+                // the replay. Reopen a backpressured lane only after that ACK
+                // releases the barrier, so its next frame is not dropped again.
+                resumeTerminalLaneIfSuspended(surfaceID: surfaceID)
             }
         }
         guard let next,

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TerminalReplayLifecycle.swift

@@ -226,6 +226,10 @@ extension MobileShellComposite {
         }
         terminalRenderGridBaselineReplayBarrierTokensBySurfaceID.removeValue(forKey: surfaceID)
         terminalReplayBarrierTokensInFlightBySurfaceID.removeValue(forKey: surfaceID)
+        // A terminal lane may have paused on a replay-barrier backpressure
+        // response. The barrier is now resolved, so let it reopen from the
+        // delivered sequence instead of leaving input on the RPC fallback.
+        resumeTerminalLaneIfSuspended(surfaceID: surfaceID)
         MobileDebugLog.anchormux("terminal.output.replay_barrier_cleared_\(reason) surface=\(surfaceID)")
         return true
     }
@@ -342,6 +346,9 @@ extension MobileShellComposite {
         cancelTerminalInputAckResubscribeRetry(surfaceID: surfaceID)
         pendingTerminalByteEndSeqBySurfaceID.removeValue(forKey: surfaceID)
         pendingTerminalInputDroppedRenderGridSurfaceIDs.remove(surfaceID)
+        // Fail-open also releases a lane paused behind a replay that could not
+        // settle. Its next attach will request a fresh bounded cursor replay.
+        resumeTerminalLaneIfSuspended(surfaceID: surfaceID)
         MobileDebugLog.anchormux("terminal.output.replay_barrier_fail_open surface=\(surfaceID) reason=\(reason)")
         return true
     }