react-x11 2.8.3 → 2.9.1

package/src/cocoa/window.js

@@ -574,13 +574,28 @@ export class CocoaWindow {
     return this.app._requestFrame(cb, this);
   }
 
-  /** Push the backing surface at the WindowServer, if anything drew. */
+  /**
+   * Push the backing surface at the WindowServer, if anything drew — and
+   * tell the window node what it cost. The flip is cheap; the catch-up
+   * copy behind it is a damage-sized memcpy, and on a window whose every
+   * frame repaints most of itself that is a millisecond of the JS thread
+   * per frame that the flush never saw. The frame pacer prices the frame
+   * by the thread's time, so the present reports in (src/pacing.js,
+   * `WindowNode._notePresentCost`).
+   */
   present() {
-    if (this._presenter) return; // layers upload as they sync
-    if (!this._dirty || !this._surface || this.destroyed) return;
+    const started = performance.now();
+    if (!this._presentNow()) return;
+    this._reactX11Node?._notePresentCost?.(performance.now() - started);
+  }
+
+  /** The present itself: true when a frame reached the layer. */
+  _presentNow() {
+    if (this._presenter) return false; // layers upload as they sync
+    if (!this._dirty || !this._surface || this.destroyed) return false;
     // …and if anyone would see it. `_dirty` stays set, so the pump asks
     // again next tick and the frame goes out the moment the window is back.
-    if (this._holdPresent || !this._visible()) return;
+    if (this._holdPresent || !this._visible()) return false;
     this._dirty = false;
     if (this._chain) {
       const shown = this._chain.back;
@@ -608,7 +623,7 @@ export class CocoaWindow {
             ]),
       );
       if (this._transparentWindow) this.app._shadowStale.add(this);
-      return;
+      return true;
     }
     this._native.surfaceToLayer(this._surface, this._layer);
     // AppKit derives a transparent window's shadow from the content's
@@ -619,6 +634,7 @@ export class CocoaWindow {
     // the frame BEFORE this one and keeps the square rim for menus that
     // paint once and are only hovered after.
     if (this._transparentWindow) this.app._shadowStale.add(this);
+    return true;
   }
 
   snapshot(path) {

package/src/debug.js

@@ -399,7 +399,7 @@ function createSession({ sink, path }) {
       }
     },
 
-    frame({ rects, reasons, start, end, landed }) {
+    frame({ rects, reasons, start, end, landed, waited }) {
       frames += 1;
       const full = !rects;
       const area = full
@@ -421,7 +421,12 @@ function createSession({ sink, path }) {
         // timings cannot show. Either way it is paint-vs-everything-else.
         const wait =
           typeof landed === 'number' ? ` landed=${landed.toFixed(1)}ms` : '';
-        line(`frame ${frames}: ${where}${why}${wait}`);
+        // How long the frame pacer held this frame's claim before letting
+        // the clock have it (src/pacing.js) — only under an adaptive
+        // `frameRate`, and only for a frame that was held, so the default
+        // path's lines are the lines they always were.
+        const held = waited > 0 ? ` waited=${waited.toFixed(1)}ms` : '';
+        line(`frame ${frames}: ${where}${why}${wait}${held}`);
       }
       record({
         name: 'frame',
@@ -437,6 +442,7 @@ function createSession({ sink, path }) {
           area,
           reasons: reasons ?? [],
           landedMs: typeof landed === 'number' ? +landed.toFixed(2) : undefined,
+          waitedMs: waited > 0 ? +waited.toFixed(2) : undefined,
         },
       });
     },