Repository navigation
perf(layout): pane content takes its pointer from the screen's one tracking area; a moving pane costs AppKit no cursor-rect walk - #36485
Merged
Conversation
…ng-area or drag-margin work (red, inventory) RESIZE MAIN BUDGET (cmux-ad m16 item 5), fix 2 (coordinator: Chrome's model, one pointer path per window). With the app's real pane content (PaneContentView, tab strip, terminal) in a 2x2 layout, the frames of one key resize count, by class, AppKit's cursor-rect invalidations, updateTrackingAreas calls and drag-margin rebuilds (_resetDragMargins, counted only). Prints the inventory (HPA-COUNT); fails on this commit. Needs a display worker.
…ble window (red) A borderless window has no resize edges, so it counted no drag-margin rebuilds (inventory, step 3fab694b: 480 / 510 cursor-rect invalidations, all TerminalSurfaceView; 935 updateTrackingAreas calls; 0 drag-margin rebuilds). The rig's layout now runs in a ShellWindow as the app's does. Still red on this commit.
…acking area; a moving pane costs AppKit no cursor-rect walk RESIZE MAIN BUDGET (cmux-ad m16 item 5), fix 2 PR 1 (coordinator: Chrome's model, one pointer path per window; the divider path extended, no second one). Each moved pane-content view that owned a tracking area or cursor rects made AppKit invalidate cursor rects, walk the window's views and rebuild its structural regions in the display cycle: about 2.1-2.4 ms of a median keys-held STRESS frame with S4 ON (job b6c9633c). Inventory (2x2 terminals, 27 key-resize frames): 480 / 510 cursor-rect invalidations, all from TerminalSurfaceView. - CmuxNextDesign PanePointer: PanePointerFollowing (a view hit-tested by the area: its cursor, enter, move, exit), PanePointerRegion (a region by geometry: a probe that takes no clicks, a rect over two views), PanePointerArea. - ScreenDividerPointer (the screen's one area, which does not move): after the divider hover, the content under the pointer (hit test) hears it come in, move and leave and shows its cursor unless a divider shows its resize cursor; leaving content that set a cursor gives it back (the arrow, then the cursor rects around, once). Regions hear inside and outside from their current geometry. The area is always active, as the terminal's was. - Inside a screen: TerminalSurfaceView has no tracking area and no cursor rect (its I-beam or Ghostty's shape comes from the area; a shape change sets it at once); TabStripView has no tracking area; HoverRevealProbe and the toolbar's corner are regions, not areas re-added at every layout. Outside a screen each keeps its own, as before. Tests: PaneMotionPointerAreasTests (red at the previous commits; adds the cursor over a terminal and its strip before and after a key resize).
…ot AppKit's updateTrackingAreas hook AppKit calls -[NSView updateTrackingAreas] on every view of a subtree that moved, whether it owns an area or not (PaneClipView and PaneHostView own none: step 221f75c7 counted them too), so no view can stop that call. What an own area costs per frame is its removal and re-addition at each call: the test now counts -[NSView addTrackingArea:] in the motion frames (0 wanted) and prints the hook calls. Cursor-rect invalidations: 480 / 510 on the base, 0 with the fix (steps 2baf3ca1 / 221f75c7).
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 11:28 — with 
GitHub Actions
Inactive
GitHub Actions
Inactive
Contributor
|
cmux status (one comment, edited in place; each line is updated by the job that owns it) Review App of this head (app.zip, kept 1 day)
red: cmux-next checks (god files, concurrency, crash safety, l10n); no finished base run on c4c07d2 to compare; do not merge until green; see lane-rules Shipped in:
|
…4 PageWebView fix #36290)
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 12:08 — with
GitHub Actions
Inactive
GitHub Actions
Inactive
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 12:08 — with
GitHub Actions
Inactive
GitHub Actions
Inactive
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 12:08 — with
GitHub Actions
Inactive
GitHub Actions
Inactive
|
Found 7 test failures on Blacksmith runners: Failures
|
![Fix with [code]smith](https://pr-comments-assets.blacksmith.sh/codesmith/fix-with-codesmith-light-3x.png)
Contributor
Author
|
Review (claude-review-subagent): SHIP at 8672fcd Independent read-only review subagent, started by the RESIZE PR WORKER (not by the author), on the PR's own three-dot diff at this exact head. No blocking defect. Evidence:
Non-blocking notes from the reviewer (follow-up candidates): |
lawrencecchen
added
the
ready-to-land
lawrencecchen
added a commit
that referenced
this pull request
Nov 6, 2026
…eOwner.terminals off arm (compile red at 3d656a1) PaneMotionPointerAreasTests (#36485, from feat in 21f0fe8) called PaneGroundCoversPaneTests.ownFrames/releaseFrames, which this branch deleted with the switch (cmux-ad m19). Step 2553c18b: 'type PaneGroundCoversPaneTests has no member ownFrames'. The case now runs once, frames owned by the commit (the former true arm); its assertions are unchanged.
lawrencecchen
added a commit
that referenced
this pull request
Nov 6, 2026
…rom the screen's one tracking area; a moving pane rebuilds no drag margins RESIZE MAIN BUDGET (cmux-ad m36). After #36485 and #36547 a STRESS drag frame (S4 + pages ON, cmux19-perf, 120 Hz, job f1ade771) still spent 0.85 ms in AppKit's structural-region pass: _resetDragMargins 0.56 ms and the tracking-area update 0.28 ms. PaneHostView.setFrameSize marked the moved panes' tracking areas dirty (_recursiveSetTrackingAreasDirty). The owners (PaneTrackingAreaOwnersTests, 2x2 terminals): PaneTypeMenuButton 4 and NewTabButtonView 4 (themed tooltips), TitlebarBandButton 4 (PointerHover), StripScrollbarView 1 (PointerHover). Chrome's model, as #36485 did for terminals and strips: inside a layout screen these targets own no tracking area. - PanePointerTargets (CmuxNextDesign): the screen's one area tells it each move; it finds the served hover targets and tooltips under the pointer by geometry and, when that set changes, refreshes PointerHover and enters or exits the tooltip, as the targets' own enter and exit did. No allocation per view; the tooltip shows only in the active app, as before. - PointerHover and TooltipTracker start served when made inside a screen; the screen adopts the targets of its subtree when it joins a window and when a motion starts (never per frame). A target that leaves every screen takes its own area back at its next refresh or track. - Not changed: TerminalScroller (an NSScrollView; AppKit owns its scroller areas, 0.10 ms per STRESS frame). Tests: PaneTrackingAreaOwnersTests (red at the previous commit): no view in the screen owns a tracking area through a key resize; a strip button in a moved pane lights under the pointer and clears when it leaves, from the screen's area alone.
lawrencecchen
added a commit
that referenced
this pull request
Nov 6, 2026
…size in every frame (drawn ahead, never stretched); PTY size coalesced 25 ms; no key hold; switch deleted (#36478) * test(next): S4 m14 (c1): a low-prompt terminal draws the grid its pane fits in every frame of a key spring (red) cmux-ad m14 with motion.frameOwner.terminals on: in every frame each terminal shows pixels drawn at its pane's size, with the prompt in view. Two failures remain for a terminal whose prompt is low (pixel-perfect films jjk-3kz): - F2: a pane a press grows keeps its surface at the final size on its bottom edge (the low prompt's bottom hold), taller than its pane: its top rows are cut; - H3: a pane that shrinks draws the owner's grid from its top-left (the reflow preview is off while the final grid does not fit), so its prompt is cut until the owner announces the new grid. TerminalKeyResizeFrameTests (display): p1 over p2 with low prompts and an IO that announces each grid it is asked for, as the daemon does (MANUAL_MIRROR). J, K, and J J K on p1. After each frame's sizes land: each surface has its area's frame, and the grid Ghostty drew is the grid the shown frame fits. Switch-on expectations of F2's hold change to m14's (the surface has its area's frame and holds nothing): - PaneContentPolicyTests: aPromptOnTheLastRowRidesTheBottomOfAPaneAKeyGrowsDown (now ...StaysInViewInAPaneAKeyGrowsDown; the switch-off arm is unchanged), aLowPromptBottomHoldAfterAPressOnTheOtherAxisKeepsItsPanesWidth (now aLowPromptPressOnTheOtherAxisKeepsTheSurfaceOnItsArea), aLowPromptBottomHoldNeverLeavesABandAboveTheTerminal (now aLowPromptGrowDownTwiceThenUpKeepsTheSurfaceOnItsArea), and the switch-on arm of aReversePressAfterALowPromptGrowsDownFollowsItsPane; - TerminalSurfaceCommitSizeTests: aKeptFrameOfALowPromptHoldNotTallerThanItsAreaStaysTopLeft (now aFollowedSurfaceTakesItsAreasFrameWhateverItsHold): a hold taller than the area no longer moves the surface to the bottom edge. * fix(next): S4 m14 (c1): with the switch on, a key spring draws each terminal's reflow preview at its pane's grid; no low-prompt bottom hold cmux-ad m14 (switch motion.frameOwner.terminals on): in every frame each terminal shows pixels drawn at its pane's size, with its prompt in view. F2: restAt held a low prompt's surface at the press's final size on its pane's bottom edge (#35470, #35914): taller than its pane, its top rows cut for the whole spring. H3: TerminalGridPolicy.previewsViewGrid turned the reflow preview off while a reported final grid did not fit the view (the old m6 rule), so a shrinking pane drew the owner's grid from its top-left, its prompt cut until the owner announced the new grid. One decision now drives the frame, the hold and the preview: TerminalHostView.surfaceFollowsArea (the host follows its pane through a key hold with the switch on). - followedSurfaceFrame gives the surface its area's frame, whatever hold it has; the low-prompt branch of #35914 had no key-spring use left and is gone. - restAt holds nothing for a following host and lets go of an earlier hold (a join's), whatever the anchor (G1 released only for .top). The final grid still goes once per press (reportFinalGrid). - updateReflowPreview passes it to previewsViewGrid(followingPane:), which keeps the preview on: Ghostty's ReflowPreview reflows a copy of the terminal to the view's grid with Terminal.resize, which keeps the cursor row in view. Switch off, and splits, closes, zooms and divider releases (no following host): unchanged. TerminalGridPolicyHoldTests covers the new parameter. * test(next): S4 m14 (c1): a key press during a close spring follows only the panes that were at rest The join question of c1, with motion.frameOwner.terminals on: a close spring holds a terminal at its final size and a key press comes before it lands. ScreenContentView.applyPresentation starts a key hold only for a pane not on a layout spring, so the pane still on the close spring does not follow: its surface keeps the close's hold (moved to the key press's final size) until the spring lands. The pane at rest when the key came follows the key hold and has its area's frame in every frame. Both rest at their areas after the landing. * test(next): S4 m18 (T-KEYS): every committed turn of a key resize shows each terminal at its pane's size (red) From draft #36158 (test/frame-owner-s4-m14-window-sync-red, a35e159 + bd7ae3a's messages): cases 1-3 of TerminalWindowFrameSyncTests. The fence/deadline case and its seam protocol are dropped (the fence is off m18's path). m18 (Lead, STATUS 13889): no keep and no main-thread wait, so a frame Ghostty has not drawn by its commit lands late: its new bounds go in that commit with the last frame, top-left. The presenter now counts those (Stats.lateLandings, lateLandings(of:), isLate(_:); at the base only a keep-limit fallback lands late). Check (a), the layer is its pane's area, holds in every committed turn; check (b), the shown frame is the layer's size, holds in every turn except while that terminal's frame is late; each case prints the late turns and the longest late streak (ms and 120 Hz refreshes), and every terminal must show its own frame at rest. Cases 1 and 3 require a pass of the presenter (a new size went through it) instead of a present or a waiting turn: with no keep both can be zero. Red at this commit: (a) fails in the turns ready-or-keep keeps a terminal's old bounds. * test(next): S4 m18 (T-KEYS): key resizes follow the pane with the switch on or off, no grid at the press, no keep (red) m18 (Lead, STATUS 13889) replaces m6's 'pixels per frame, program size per press' and ready-or-keep: - KeyboardResizeContentHoldTests: the terminal case no longer expects one grid per terminal at the press; it expects no grid in the key's turn and each PTY's last grid = its view's grid at rest (the coalesced reports end at the landing). The switch-off case (one surface size per press) becomes 'the producer follows its pane with the switch off too': m18 deletes the key hold in both states, the switch only picks who presents. - KeyboardResizeReflowAfterLandingTests: 'final grid by the first frame tick' becomes 'no grid by the first frame tick, PTY ends at the view's grid'; the switch-off case follows its pane. - TabStripFollowsPaneTickTests (terminal case): the surface is on its area in every frame in both switch states (it took one size per press off). - TerminalSurfaceCommitSizeTests: a new size's bounds are in the commit of its layout (never kept); a turn whose frame is not the layer's size is allowed only while the presenter has that frame late; the kept-frame test becomes 'a followed surface takes its new area in the turn it changes'; fallback counts become late landings. - TerminalKeyResizeFrameTests.showsItsOwnFrame reads the presenter instead of the deleted in-flight size. Kept as they are: KeyboardResizeContentHoldTests lines 34-71 and TabStripFollowsPaneTickTests 195-216 test generic held content (pages, chats: PaneHostView's K3 hold, B-PAGES under m18), not terminals. * fix(next): S4 m18 (T-KEYS): key resizes give each terminal its pane's size in every frame; no key hold, no keep; switch on cmux-ad m18 (Lead, STATUS 13889). - No key hold: TerminalHostView.surfaceFollowsArea no longer reads the switch. A host that follows its pane through a key resize gives its surface the area in every frame with motion.frameOwner.terminals on or off (off = the kill switch: Ghostty's renderer presents). restAt for a following host reports no final grid and holds nothing; the view's grid goes to the PTY as for any spring (held to the landing here; coalesced in the next commit). Split, close and zoom springs keep their final grid at the start and their final-size hold. - No keep: TerminalSurfaceView.place(_:) sets the view's frame at once (any layout, AppKit's display cycle included), so ghostty_surface_set_size gets the pane's pixel size in that turn and the reflow preview re-wraps the text at it. The presenter's pass presents a frame Ghostty drew by the pass with those bounds in the same commit; one not drawn yet is a late landing (Stats.lateLandings, isLate, lateLandings(of:)): the last frame shows top-left in the new bounds and the watch presents the new frame in the first commit after it is drawn. Deleted: keepLimit, the fallback, the keep counter, the in-flight and wanted sizes, keepOrigin and anchoredFrame, and the group present (groupTicks, groupWaits): with no keep every request lands in its first pass, so a group could only delay a ready frame. A held display scale goes to the layer with its frame or at the pass. - TerminalDragTunables.framesOwnedByCommit defaults to true (kept as the kill switch). holdsSurfaceDuringDrag is frame-owner-s2's and unchanged. Green for the red tests of the two commits before. * feat(next): TerminalGridReportCoalescer: one PTY grid report per 25 ms window, the newest (Ghostty's min_ms rule) T-KEYS (frame-owner-s4, STATUS 13889): a key resize or divider drag changes a terminal's fit grid on almost every frame, and each report resized the PTY and sent SIGWINCH. The coalescer follows Ghostty.app's src/termio/Thread.zig (min_ms 25): the first new grid opens a 25 ms DemandTimer window, later grids replace the waiting one, the fire sends the newest once; a grid equal to the last sent one sends nothing. flush() ends the window at once (gesture end), reportNow(_:) is the forced report, cancel() drops the waiting grid. Not wired yet: the T-KEYS key-path change calls it from the grid-report path. Tests: TerminalGridReportCoalescerTests (manual clock), run on the fleet. * test(next): TerminalGridReportCoalescerTests: per-frame test compares sends to the newest grid in order (no Duration-keyed dictionary) * fix(next): S4 m18 (T-KEYS): a key resize's PTY size goes coalesced, 25 ms, ending at the landing's grid Wires TerminalGridReportCoalescer (the two commits before, from fix/frame-owner-s4-t-keys-coalescer) into the one grid report path, TerminalSurfaceView.updateSurfaceSize: - live (the host follows its pane through a key resize, or isFollowingResizeGesture): viewSized(grid), the first change opens a 25 ms window and the newest goes when it ends (Ghostty.app Thread.zig min_ms). The view's grid is no longer held to the landing for a key resize; a split's, close's or zoom's spring still holds it. - forced (a new owner): reportNow. At rest: viewSized then flush, so the report goes now unless the PTY already has it. - endPaneMotion flushes: the landing's grid goes at the landing. - reportFinalGrid (split, close) goes through reportNow too, so the coalescer's last-sent grid is always the PTY's. - sendGridReport(_:) reads the cell size when it sends; gridReports counts sends. isGridReportPending (held or in a window) settles TerminalSizeSample. The reflow preview stays on while a grid waits. Drags: frame-owner-s2's drag PR drops isFollowingResizeGesture from the holding: argument; its reports then go through the same coalescer with no call of its own. Tests of m6's 'final grid by the press's first frame' move with it: PaneContentPolicyTests.grids flushes the window before it reads (a waiting grid counts as asked for); the held-key cases allow one grid per read plus the landing, last = final; the press-and-reverse case ends at the start grid; TerminalKeyResizeFrameTests bounds the grids per terminal by the 25 ms windows of the press and checks each PTY ends at its view's grid. * test(next): S4 m18 (T-KEYS): PaneContentPolicyTests run each key-resize case in both switch states, to the m18 contract m18 deletes the key hold in both states of motion.frameOwner.terminals and sends the view's grid coalesced (25 ms) instead of one final grid at the press. Each test below asserted that removed behavior; each is rewritten (none dropped) so it fails if the hold or the press-time grid comes back: - aKeyPressShowsEachSurfaceAtItsPanesSizeAndSendsOneGrid -> ...AndItsPTYEndsAtItsFinalGrid(direction:switchOn:): now also runs with the switch off; no grid in the key's turn; PTY ends at the final grid. Replaces aKeyPressSizesEachSurfaceOnceWithTheSwitchOff (asserted one surface size per press, the key hold). - aHeldKeyShowsEachSurfaceAtItsPanesSizeAndSendsAtMostOneGridPerPress -> ...AndItsPTYEndsAtTheFinalGrid(switchOn:): one grid per read plus the landing, last = final. Replaces aHeldKeySizesEachSurfaceOnlyInAPressTurn WithTheSwitchOff (surface sized only in press turns: the key hold). - aPressAndItsReverseInOneHoldSendEachGridInItsTurn -> aPressAndItsReverseInOneHoldEndsAtTheStartGrid(switchOn:): surface on its pane every frame, rests at the start size, PTY ends at the start grid. Replaces aPressAndItsReverseRestsAtTheStartSizeWithTheSwitchOff. - aParkedTerminalShownDuringAKeyHoldFollowsFromItsFirstFrame: the switch- off arm now requires the area's size in every frame (was <= 1 new size). - aPromptOnTheLastRowStaysInViewInAPaneAKeyGrowsDown and aReversePressAfterALowPromptGrowsDownFollowsItsPane: the switch-off arm now requires no bottom hold (was: the hold must exist). - aTerminalThatJoinsAKeyHoldGetsOneGridPerPressThroughASecondPress: each read gets at most one grid, the last is the final grid, none after it (was: the second press's final grid at its first frame, none at landing). - aLowPromptPressOnTheOtherAxisKeepsTheSurfaceOnItsArea and aLowPromptGrowDownTwiceThenUpKeepsTheSurfaceOnItsArea: a setup check that the prompt is in the lower half (review N2 of #36199). - grids(_:_:) ends the coalescer's window before it reads. * test(next): S4 m18 (T-KEYS): keep PaneContentPolicyTests.grids, which the switch-off section removal took with it 00471ab removed the ...WithTheSwitchOff section and the grids(_:_:) helper that sat inside it; the other suites call it (compile error at step 2dfd615d48e54adee09a2e9d). Restored unchanged (it flushes the coalescer's window before it reads). * test(next): S4 m18 (T-KEYS): two 'one grid per press' tests move to the 25 ms coalescer rule; a tab shown mid key hold follows from its first frame m18 replaces 'one grid per press' with TerminalGridReportCoalescer's rule (at most one grid per 25 ms window of the press plus the landing's flush; the last grid is the view's grid at rest): - TerminalKeyResizeFrameTests.aTerminalWhoseFrameWaitsAtTheLandingGetsOne GridForThePress -> aTerminalWhoseFrameIsLateAtTheLandingEndsAtTheLandings Grid: the mode-2026 terminal's frame is waiting or late at the landing (setup check, read after the frame's commit), grids bounded by the 25 ms windows, PTY ends at the view's grid (step f5645d6c failed its setup require: with no keep nothing waits). - PaneContentPolicyTests.aTerminalThatJoinsAKeyHoldGetsOneGridPerPress ThroughASecondPress: grids bounded by the 25 ms windows from the press, last = final, none after it; the reads no longer flush the window. Code (measured at step d8948371, 2 grids in one read): a parked tab shown mid key hold joined (restAt) before its area handed it the follow, so it sent a final grid outside the coalescer and then coalesced ones. TerminalHostView.joinsAreaKeyHold: restAt treats it as following. * fix(next): S4 m26 (T-KEYS): bounds change only with their drawn frame; key springs draw the next refresh's size ahead; motion.frameOwner.terminals deleted Measured at 10abcfd (step f5645d6c): c102749 removed the keep and let the layer take its new bounds before Ghostty drew that size, so the old frame showed stretched in the new bounds (TerminalKeyResizeFrameTests:101 "frame 1 p2: layer 547x572, frame 549x572", TerminalSurfaceCommitSizeTests :48, :217, :220). The resize owner chose draw ahead (m26); a synchronous main-thread draw is refused. The contract, the Chromium model (the browser compositor shows a new size only with a frame the renderer submitted for it, and the renderer gets the size before the compositor needs its frame): 1. A terminal's bounds change only in the commit that presents a frame drawn at those bounds. TerminalFramePresenter's ready-or-keep is back (feat's pass at order 1_999_999, the group present included: with keeps a group lands its two terminals together). Its keepLimit fallback, which set the bounds without the frame (a stretch), is deleted; long keeps are counted as data (Stats.longKeeps, more than 2 refreshes). 2. Key springs draw ahead: ScreenContentView.step steps a copy of each moving pane's spring once more, by MotionClock.nextFrameInterval (the display link's refresh period: 8.33 ms at 120 Hz, 16.7 ms at 60 Hz), and hands the size change down PaneHostView -> PaneContentAreaView -> PaneMotionHoldFollowing.drawAhead(nextHostSize:) -> TerminalHostView. After this turn's pass the surface gives Ghostty that size, render only (TerminalSurfaceView.applyAhead: no grid report; the reflow preview re-wraps at it); one whose frame still waits gets it when that frame lands. The next refresh's place() finds the size drawn ahead, and the pass presents it with its bounds. An ahead size no layout takes within 2 refreshes goes back (dropAhead). set_size is not repeated at the size Ghostty already has (it would drop the drawn frame). 3. A divider drag, a Reduce Motion jump and hidden panes draw nothing ahead: the last bounds and frame stay, clipped or beside the terminal ground, until the new frame is drawn. 4. The pass never draws and never waits. Off-main presents of a frame drawn ahead cannot reach the old bounds: the fork's offMainDecisionLocked routes a frame whose size differs from the shown frame through main (IOSurfaceLayer.zig:292, pin 12ec155e1), and embedderDrops drops it there while the bounds do not have its size. motion.frameOwner.terminals is deleted (m19/m21: no switches): every surface presents through its window's commit from creation (ownFramesByCommit); the renderer-present path and the switch-off key hold are gone. holdsSurfaceDuringDrag is unchanged (frame-owner-s2's; #36311 set it off). No code or test writes the key any more, which also removes the cross-suite TunableStore reset (step f933b493). Tests: - TerminalWindowFrameSyncTests: (b) strict in every committed turn (no stretch, no excuse); case 2 paces one refresh per spring frame with output in both terminals and requires (a) from the spring's second frame on (frames kept = 0 after the first commit) and drawnAhead > 0; case 1 (Reduce Motion jump, rule 3) allows a keep for 2 refreshes. - TerminalSurfaceCommitSizeTests back to feat's assertions; fallback counts become longKeeps (data). - Switch-off cases removed with the path: KeyboardResizeContentHoldTests.theProducerFollowsItsPaneWithTheSwitchOffToo, KeyboardResizeReflowAfterLandingTests.theProducerFollowsItsPaneWithTheSwitchOffToo(direction:), and the switchOn: false arm of PaneContentPolicyTests (aKeyPressShows..., aHeldKeyShows..., aPressAndItsReverse..., aParkedTerminalShown..., aPromptOnTheLastRow..., aReversePressAfterALowPrompt..., aTerminalThatJoinsAKeyHold...), PaneGroundCoversPaneTests (2 cases), KeyResizeFirstTickPinTests (2), TabStripFollowsPaneTickTests (1) and TerminalLaunchFrameKeeperTests (2). Their switch-on assertions stay. PaneGroundCoversPaneTests.ownFrames/releaseFrames are deleted. * test(next): S4 m26 (T-KEYS): a drawn-ahead frame is held, not discarded; a key spring's last frames and landing show their own frames with the new text Resize owner's two tests (TerminalWindowFrameSyncTests): - Case 2 (paced key spring, output every frame): no committed turn after the spring's first frame has a terminal waiting for its frame. A frame drawn at S(n+1) in refresh n must be the one commit n+1 presents with bounds S(n+1); a discarded ahead frame makes every spring frame wait. - Case 4 (spring end): the last 3 spring frames and the turns up to one refresh after the landing show each terminal's own frame at its bounds and its pane's area, with nothing waiting; output written after the landing shows in a newer frame of the rest size. The fork holds the frame (Metal.zig embedderShowsKeptFrame keeps it in 'fresh'; hostFrame(show:) presents it with presentFresh at the host size); only a host-size change drops a kept frame, even back to an equal size, which setSurfacePixels never makes. Red evidence: these run at a no-draw-ahead copy of this head (fix/frame-owner-s4-t-keys-noahead-nomerge, applyAhead returns at once). * test(next): S4 m26 (T-KEYS): keep PaneGroundCoversPaneTests.aCloseLeavesNoHoleWhereThePaneWas's columns arguments 372ff9e's switch-off cleanup removed '@test(arguments: [false, true])' from every test, also this one, whose parameter is columns:, not switchOn: (compile error at step f3a717ae). * test(next): S4 m26 (T-KEYS): a held key resize gives the PTY only grids its pane showed, at most every 25 ms (red) Resize owner's film finding (STATUS 14461): the PTY must get only sizes the pane SHOWED, through the 25 ms coalescer. At b6a7e1e updateSurfaceSize reads the grid from ghostty_surface_size after set_size(inFlight ?? ahead ?? bounds), so a call while a size is drawn ahead (the owner's announcement arriving between the pass and the next frame) puts the ahead grid into geometry and the coalescer: a grid the pane may never show (a press that retargets the spring). TerminalWindowFrameSyncTests case 5, aHeldKeyResizeGivesThePTYOnlyGridsThePaneShowedAtMostEvery25ms: 3 presses 4 frames apart, paced one refresh per frame, output in both terminals, an owner that announces each grid (AnnouncingTerminalIO now records each report and its main-thread time in resizeOnMain). Checks (a) in every committed turn the view's grid (fittedGrid) is the grid its committed layer bounds fit; (b) every PTY grid is one a committed turn showed; (c) grids at least 25 ms apart before the landing; (d) a changed shown grid reaches the PTY within 25 ms + 2 refreshes + 8 ms; (e) the last grid is the rest grid. The recorder samples shownGrid and viewGrid per terminal per turn; the spring helper takes presses/framesBetweenPresses (default one press). * fix(next): S4 m26 (T-KEYS): the PTY gets the grid its pane showed, never a size drawn ahead updateSurfaceSize gave geometry and the coalescer the grid of ghostty_surface_size after set_size(inFlight ?? ahead ?? bounds). A call while a size was asked and not shown, or drawn ahead for the next refresh (the owner's announcement arriving between the pass and the next frame), sent that grid: one a press that retargets the spring may never show. Now the grid comes from the view's committed bounds (TerminalSurfaceView.shownGrid: ghostty_surface_fit_grid of their pixel size, or ghostty_surface_size's grid when Ghostty has the bounds' size). The presenter's landing (frameDidLand -> updateSurfaceSize) gives the coalescer each shown grid as the bounds commit. The inFlight and ahead sizes still go to set_size only (Ghostty's render, its reflow preview). The model's grid follows the same shown grid. Drags are unchanged (the holding: rule stays; frame-owner-s2's PR moves drags to the coalescer). Green for TerminalWindowFrameSyncTests case 5 (11324e0, red step 19cd7b71). * fix(terminal): keep a drawn-ahead size until its hold ends; end grid-report windows at the first refresh at or after 25 ms B1 (diag bf2b674a): the presenter dropped a size drawn ahead after 2 display ticks (8.3 ms each) with no layout. A spring step can come 16.6 ms later, so the drop set Ghostty back to the bounds, threw away the frame drawn for the next refresh, and that refresh waited for its frame again (trace +1183.36 applyAhead, +1199.51 set_size, +1200.13 pass aheadHit false). The tick timeout is deleted. A size drawn ahead goes only when its followed hold ends (followPaneMotion(nil)) and the final placement did not take it (TerminalHostView placeSurface). A retarget miss keeps today's path (place asks for the wanted size). B3 (diag bf2b674a): the coalescer's 25 ms DemandTimer fired up to 124 ms late on a loaded runner; the sizes reached it on every frame. An open window is now also ticked by its view window's presenter (TerminalGridReportTicks, injected): it ends at the first refresh at or after 25 ms. The timer stays armed as the backstop (no frames run, or frames stepped by hand as in frame-owner-s2's drag tests); whichever comes first sends the grid, once. Public API unchanged (viewSized, flush, reportNow, cancel). The view cancels a waiting grid when it is hidden, its session closes, or a surface swap detaches it, and then reports its grid (forced) when shown again, so the PTY never keeps a grid only the dropped window had. Tests: TerminalGridReportCoalescerTests (7) a window ends at the first refresh at or after 25 ms with a late timer, (8) no refresh: the timer ends it, once, (9) refresh and timer for one window: one send. ManualClock, no wall clock. Not run yet: on the fleet next (display suites of 5dcf9835 at this head). * docs(terminal): drop comments that still name the deleted motion.frameOwner.terminals switch Comments only (frame-owner-s4 review of #36478): TerminalPaneFollow, TerminalSurfaceView+PaneMotion, KeyResizeFirstTickPinTests, PaneContentPolicyTests, TerminalWindowFrameSyncTests, TerminalKeyResizeFrameTests and bench-terminal-resize.py. No assertion changes. * T-KEYS: resend a dropped grid only if the PTY lacks it; B2 commit timing; B4 drawn grid read at the present - cancelGridReport (frame-owner-s4 review): a hide marks a resend only when the dropped window's grid is not the PTY's (lastSent). Shown again, the view's grid goes as a grid at rest (viewSized + flush, which skips the PTY's grid), not a forced report: a hide and show with nothing dropped sends nothing (no PTY resize per tab switch). Test TerminalHiddenResizeTests: hide during a 25 ms window, show at the same size: one send, the newest grid; hide and show with no change: 0 sends. - B2 (test support only, no assertion change): TurnRecorder splits each awake turn into before-commit and commit spans (an observer just before the presenter's pass), each with its off-CPU time, plus the task's context switches. A main-thread violation message now names where the blocked time went. - B4 option (ii) (resize owner): TerminalFramePresenter.presentedHook (DEBUG/bench builds) runs in the pass right after a request's frame becomes the layer's contents, before the turn's draw-ahead sizes go to Ghostty. The low-prompt test reads Ghostty's drawn grid there, checks in the same pass that the frame read has the pixel size the pass gave the layer, and samples each frame from the record of the frame on screen. The grid-fit assertion is unchanged. Not run yet: fleet steps next. * T-KEYS: #36478 wires only key springs live; a divider drag keeps feat's held grid; keep feat's stale in-flight guard Decision (resize owner and lead, via frame-owner-s4): #36631 (frame-owner-s2) owns the drag grid path. In updateSurfaceSize, `live` is the host following its pane's key hold only (no `|| isFollowingResizeGesture`); `holding:` keeps `|| isFollowingResizeGesture`, so a drag's grid is held to the release as on feat. Feat's `stale` term is back in `holding:` (review F1 of #35470: an in-flight size that is not the wanted size sends no grid). The grid here is the committed bounds' (shownGrid), so the in-flight size's grid cannot be sent; the guard is kept anyway, as asked when not sure. No other drag code changes (followResizeGesture, isHeldGridPending, stopFollowingResizeGesture untouched). Not run yet: the 4 display suites at this head, next. * test(next): PaneMotionPointerAreasTests: drop the deleted motion.frameOwner.terminals off arm (compile red at 3d656a1) PaneMotionPointerAreasTests (#36485, from feat in 21f0fe8) called PaneGroundCoversPaneTests.ownFrames/releaseFrames, which this branch deleted with the switch (cmux-ad m19). Step 2553c18b: 'type PaneGroundCoversPaneTests has no member ownFrames'. The case now runs once, frames owned by the commit (the former true arm); its assertions are unchanged. * test(next): T-KEYS: a grid a hidden view keeps for its show never goes after a newer grid (frame-owner-s2's rule) Point 2 of frame-owner-s2's check on 5b3c0af. A hide drops a waiting grid and keeps one for the show; then a spring's final grid, or a forced report, goes while hidden; then the view shows. The PTY's last grid must be the view's fit, and the show sends at most one grid. No red: the code already meets the rule. Step 27ff8556 (non-display, 5b3c0af + this test, without the proposed 124b857535e) passed both arms: final arm hidden [40x12], shown [86x27], fit 86x27; forced arm hidden [], shown [86x27]. The show's resend sends fittedGrid after the show's own updateSurfaceSize, so it is never an older grid; a forced report does not go while hidden. 124b857535e is dropped; this test stays as a guard. * test(next): T-KEYS review of 5840aea: draw-ahead at the app's cadence, a hidden grid in a spring, hide/show in a spring (red) - P1 #1 TerminalWindowFrameSyncTests.atTheAppsCadenceAKeySpringShowsEachTerminalAtItsPaneSizeFromItsThirdFrame: one commit per refresh after the step and its layout, then a sleep to the next refresh with no extra main turns; check (a) from the spring's third frame. The paced case's extra commits hid a draw-ahead that stops after one late frame. - P1 #2 TerminalHiddenResizeTests.aGridAHideDropsReachesThePTYWhenTheViewShowsDuringASpringAndLands: G1 waits during a key spring (PTY at G0), hide, show while on the spring, land: the PTY must end at G1. - P2 #3 TerminalWindowFrameSyncTests.aHideAndShowInsideAKeySpringNeverShowsAFrameDrawnAheadInTheOldBounds: p2 hidden and shown inside a key spring; check (b) in every committed turn. Red on the fleet at this commit (never-merge branch) before the fix. * fix(next): T-KEYS review of 5840aea: draw-ahead survives a late frame, a hidden grid reaches the PTY, a hide drops the size drawn ahead - P1 #1: a frame that landed late in a key spring asked for the size wanted now before this turn's size drawn ahead went to Ghostty (`landed` -> `requestWantedFrame` before `applyAheads`), so every later frame was drawn a refresh late. Now the landing leaves the next refresh's size to `applyAheads` (`drawsAheadAfterLanding`); the next layout takes it, as Chromium gives the renderer the size before the compositor needs its frame. - P1 #2: a grid a hide dropped (`cancelGridReport`) was lost when the view showed inside a key spring: the show's resend ran only at rest and cleared its flag. `resendShownGrid(atRest:)` sends it at rest, coalesced in a key spring or a drag, else at the landing (`endPaneMotion`, a drag's end). - P2 #3: a hide kept the size drawn ahead, so the show's present showed that frame in the old bounds. A hide drops it (`dropAheadForHide`); shown, Ghostty gets the view's size back. - TerminalDragShownGridTests (fleet 990efb42, 2 of 38 grids "before any commit showed it"): the test sampled shown sizes only after the commits it drove; sizes the presenter's own refresh turns showed during the drag's 12 ms pace were missed. It now also records each present in the pass (`presentedHook`), with the bounds the pass gave it. * test(next): T-KEYS P1 #1 made deterministic: a late frame in a key spring costs its own refreshes, not the rest of the spring The app-cadence case (b697e21) passed on the old product at fleet df16ac19 (no frame came late on that runner: keeps 0), so it is no red for P1 #1. Case 2d holds both programs' frames with synchronized output (mode 2026, kept across a locked grid's resize) for spring frames 2 to 5, so a frame lands late with a newer size wanted; check (a) from frame 11 on. * test(next): T-KEYS: take out case 2d: mode 2026 held no frame on the fleet (no red) Fleet c547fa88 at 153afb9 (old product): its SETUP failed, longKeeps 0: synchronized output did not hold the frames of a resize, so no frame came late and the case proves nothing. Takes back aa792cc only (a test). * fix(next): T-KEYS merge: the pane check counts long keeps, not fallbacks (S4 has none) #37049 on feat reads TerminalFramePresenter.Stats.fallbacks, which S4 m18 (c102749) took out: S4 never shows bounds without their frame. follow_presenter now reports long_keeps (passes that kept a late frame past longKeepTicks refreshes). test_bench_terminal_resize passes locally (python unittest).
This branch was previously deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
RESIZE MAIN BUDGET (cmux-ad m16 item 5 / m18 SMOOTH), pointer areas PR 1. Each pane-content view that owned an
NSTrackingAreaor cursor rects (the terminal surface, the tab strip, the hover-reveal probe, the pane toolbar's corner) made AppKit invalidate cursor rects when its pane moved, walk the window's views and rebuild the window's structural regions in that display cycle. A spring or a drag moves panes in every frame, so this ran in every motion frame: 480 to 510 cursor-rect invalidations and 136 re-added tracking areas in one 27-frame key resize of a 2x2 terminal layout.The fix follows Chrome's model (one native pointer area per window that does not move; the pointer is hit-tested against the current frames). It extends the divider path that already worked this way (
ScreenDividerPointer), with no second path:CmuxNextDesign/PanePointer.swift:PanePointerFollowing(a view the area hit-tests: its cursor, enter, move, exit),PanePointerRegion(a region by geometry: a probe that takes no clicks),PanePointerArea.ScreenDividerPointer: after the divider hover, the content under the pointer hears it come in, move and leave, and shows its cursor unless a divider shows its resize cursor. Leaving content that set a cursor gives it back (the arrow, then the cursor rects around, once). The area is.activeAlways, as the terminal's was.TerminalSurfaceViewhas no tracking area and no cursor rect (its I-beam or Ghostty's shape comes from the area; a shape change sets it at once).TabStripViewhas no tracking area.HoverRevealProbeand the pane toolbar's corner are regions. Outside a screen each view keeps its own area, as before.Owners told: PL-ghostty (terminal), PL-instant (tabs), PL-motion-core (layout).
Tests
Focused command:
scripts/ci/package-test-lane.sh suite Packages/macOS/CmuxNext PaneMotionPointerAreasTests(display worker).invalidations=480 [TerminalSurfaceView:480] areas_added=136 [TerminalSurfaceView:68,TabStripView:68](own frames off), 510 and 136 (own frames on).Bench (same mini cmux19-perf, 120 Hz virtual display,
motion.frameOwner.terminalsON)Main-thread ms per motion frame, rounds with background daemons over 1 s CPU dropped.
Jobs: keys, keys-held, light, stress from ba53f9ae (before) / 4e9aca87 (after); keys-stress rows from eec91eb1 (before) / b0a5f31c (after), because mediaanalysisd used 2.6-4.7 s CPU in each keys-stress round of 4e9aca87.
Not yet under 8.33 ms p99: the rest is browser chrome cursor rects (PR 2, stacked on this one), the tab strip layout (SMOOTH-STRIP) and the per-pane layout cost (next PR).
Changelog
none
Observed / Not run
Open in [code]smith · Need help on this PR? Tag
@codesmith-botwith what you need.Summary by cubic
Moves pane content's pointer tracking to each layout screen's single, stationary tracking area, so a moving pane costs AppKit no cursor-rect invalidation or window-region rebuild.
Pane content that owned its own tracking area or cursor rects — the terminal surface, the tab strip, the hover-reveal probe, and the pane toolbar's corner — made AppKit invalidate cursor rects, walk the window's views, and rebuild structural regions in every motion frame. Now the screen's one tracking area (
ScreenDividerPointer, already the divider hover path) hit-tests the current frames and delivers enter/move/exit and the cursor through the newPanePointerFollowingandPanePointerRegionprotocols; the area stays.activeAlwaysas the terminal's was. Views outside a layout screen keep their own tracking areas and cursor rects as before, and the terminal's cursor still updates immediately on shape change.Benchmarks
motion.frameOwner.terminalson): stress drag p50 12.04→5.67, keys-stress p50 10.69→4.54; missed frames drop 257→49 (stress) and 65→8 (keys-stress).PaneMotionPointerAreasTestscounts zero cursor-rect invalidations, tracking-area additions, and drag-margin rebuilds across a key-resize spring; on the base commit those counts were 480/510 and 136.Written for commit 8672fcd. Summary will update on new commits.