Repository navigation
test(next): m14 window frame sync: every committed frame shows each terminal at its pane size (red) - #36158
Draft
lawrencecchen wants to merge 3 commits into
Draft
test(next): m14 window frame sync: every committed frame shows each terminal at its pane size (red)#36158lawrencecchen wants to merge 3 commits into
lawrencecchen wants to merge 3 commits into
Conversation
…erminal at its pane size (red) cmux-ad m14 (Lead, 2026-11-05; design note PIXEL-PERFECT/WINDOW-FRAME-SYNC.md): in every committed frame every visible terminal shows pixels drawn at that frame's pane size, and the main thread never waits for a terminal's frame. With motion.frameOwner.terminals on, TerminalFramePresenter (ready-or-keep) keeps a terminal's old bounds and frame until its new-size frame is ready, while the rest of the window already moved (film rk-3t on-reduce, frames 114 and 152). TerminalWindowFrameSyncTests (display suite, real Ghostty surfaces in the app's PaneContentView, TerminalKeyResizeFrameTests.PaneScreen), sampled after Core Animation's commit in every main turn from the press to rest: 1. Reduce Motion one-jump shrink (Ctrl-Shift-L on p2): (a) each surface layer's bounds equal its pane's surface area (1 px), (b) the shown frame's size equals the layer's bounds. Expected red today on (a) for the kept turns. 2. A key spring: the same checks in every committed turn of the spring. 3. No committed turn of a jump or a spring is awake longer than 2 refreshes at 60 Hz or off the CPU longer than 1 refresh at 60 Hz. Test only, no fix.
…turns per terminal Each bounds failure line names the layer, the pane area and the shown frame (px); each summary gives, per terminal, the committed turns with old bounds and the time of the last one after the press. A sampled turn is a main run-loop pass that ended with Core Animation's commit pass, not a display refresh (the rest loop asks for commit after commit), so the time says how long the old bounds stayed. Red at a35e159 (fleet job 5bd938939a29a1fa2c63c764, cmux11): case 1 fails in 8 turns (p1 layer 450x572 px, area 500x572; p2 549x572, area 499x572), case 2 fails in 19 turns of a 27-frame spring, case 3 passes (awake max 1.43 ms, blocked max 0.06 ms).
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 05:38 — with 
GitHub Actions
Inactive
GitHub Actions
Inactive
|
Found 3 test failures on Blacksmith runners: Failures
|
![Fix with [code]smith](https://pr-comments-assets.blacksmith.sh/codesmith/fix-with-codesmith-light-3x.png)
Contributor
|
cmux status (one comment, edited in place; each line is updated by the job that owns it) web and size checks: green |
…ts releases the fence within 1 refresh (disabled)
The Lead's hard rule for the sync's deadline: a terminal that joins the window's
sync and never presents holds the fence for at most 1 refresh of the window's
display; then the fence is released, debug.frames counts sync_deadline_missed once
for that terminal and not for the one that presented, the presented terminal is at
its pane's size in every committed turn, and no main turn waits for the stalled one.
The base has no window frame sync, so the case is disabled ("needs the window frame
sync") and written against WindowFrameSyncDeadlineSeam, declared in the suite with
deadlineSeam = nil. The implementation provides the adapter, sets deadlineSeam and
removes the trait, with the assertion texts unchanged.
lawrencecchen
temporarily deployed
to
ci-routing-agent
November 5, 2026 06:29 — with
GitHub Actions
Inactive
GitHub Actions
Inactive
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
Red test for cmux-ad m14, window frame sync (Lead, 2026-11-05; design note
PIXEL-PERFECT/WINDOW-FRAME-SYNC.md). Test only, no fix.Contract. In every committed frame, every visible terminal shows pixels drawn at that frame's pane size. An old frame kept at a new pane size is a failure, also for one refresh. The main thread never waits for a terminal's frame.
Today, with
motion.frameOwner.terminalson,TerminalFramePresenter(ready-or-keep) keeps a terminal's old bounds and frame until its new-size frame is ready (at mostkeepLimit, 6 refreshes), while the rest of the window already moved. pixel-perfect's film rk-3t on-reduce shows it: Reduce Motion, one-jump shrink, p2 shows its old wider frame for one refresh (frames 114 and 152).The test
New suite
Packages/macOS/CmuxNext/Tests/CmuxNextAppTests/TerminalWindowFrameSyncTests.swift(display suite). Rig:TerminalKeyResizeFrameTests.PaneScreen(p1 | p2, the app'sPaneContentViewwith a real Ghostty surface each, borderless window on screen, switch on), the app's presses (PaneResize.press). An observer right after Core Animation's commit (CommitBoundary.order, asTerminalSurfaceCommitSizeTests.Fixturesamples) reads every committed main turn from the press to rest. A second observer at the run loop's wake stamps each turn (wall clock and the main thread's CPU time).TerminalHostView.surfaceSize(forHostSize:)of the host bounds, in px, 1 px tolerance), and (b) the shown frame's pixel size equals the layer bounds. Not vacuous: at most 2 frames (no spring), at least 3 turns, p2 narrower and p1 wider by at least 10 px, a frame came through the presenter..disabled("needs the window frame sync"). Reduce Motion, Ctrl-Shift-L on p2, both terminals join the sync, p2 never presents: the fence is released within 1 refresh of the window's display (measured by the sync from its commit to the release),debug.framescountssync_deadline_missedexactly once for p2 and not for p1, p1 is at its pane's size in every committed turn, and no main turn is blocked longer than 1 refresh at 60 Hz. The base has no fence, so the case is written againstWindowFrameSyncDeadlineSeam, declared in the suite withdeadlineSeam = nil. The implementation provides the adapter, setsdeadlineSeamand removes the trait; the assertion texts stay as they are.Draft on purpose. A test that fails at the base lands in the same PR as its fix, so the window-sync implementation branch starts from these commits. Do not mark this PR ready on its own.
Failure messages name the turn number (1 = the press's turn), its time after the press, the terminal, which check failed and the sizes.
Red step
Fleet job
5bd938939a29a1fa2c63c764(cmux11, display, gui-session-v1) ata35e159ffbf465d33f678a0f9ab051034f71cff9:TerminalWindowFrameSyncTestsfailed (exit 1), 2 of 3 tests red.The rerun at the head
efbbe8dfe65(failure messages with kept turns per terminal and the shown frame size, and case 4 disabled) is fleet job789c145ca378ebf722c47d89; its result will go into a comment here. The earlier rerun atbd7ae3ad5b1was cancelled before it ran, because the new head includes it.Observed / Not run
Observed: the fleet run above (display worker cmux11), and
python3 scripts/cmux-next/prepush-gate.py(no new violations) before each push.Not run: no local Swift build or test (repo rule). A sampled turn is a run-loop pass that ended with Core Animation's commit pass, not a display refresh: the rig's rest loop asks for commit after commit, so the turn counts are larger than refresh counts; the messages give the time after the press for that reason. Case 3 measures off-CPU time per turn, not the
BlockingViolationTabledetector.Changelog
none