react-x11 2.21.2 → 2.22.1

package/src/nodes/scrollblit.js

@@ -8,20 +8,28 @@
 // viewport, so the fast path can cost correctness nothing.
 
 import { EMPTY_STYLE, resolveBorderWidths } from '../styles.js';
-import { DAMAGE_SLOP, addDamageRect } from './damage.js';
+import {
+  DAMAGE_SLOP,
+  MAX_DAMAGE_RECTS,
+  addDamageRect,
+  addDamageRects,
+} from './damage.js';
 import {
   rectContains,
   isIntegerRect,
   insetRect,
   innerPixels,
+  outerPixels,
   intersectRects,
   unionRect,
   rectArea,
-  cornerSquaresOverlap,
+  cornerSquares,
   rectsOverlap,
+  outside,
 } from './rects.js';
 import { isPaintedColor } from './boxpaint.js';
 import { scrollbarTrackRect } from './scrollbars.js';
+import { DEV } from './util.js';
 import { debugPaint } from './window/debugpaint.js';
 
 // --- scroll blitting (issue #138) ---------------------------------------
@@ -58,6 +66,15 @@ const SCROLL_BLIT_MIN_KEEP = 0.5;
 // Past this the blit is buying a shift and paying for the viewport anyway.
 const SCROLL_BLIT_MAX_REPAINT = 0.75;
 
+// The rects an element blit may leave its frame to paint: the strips the
+// shift exposed, on top of a frame's usual allowance. A diagonal pan of a
+// rounded pane with furniture in two corners owes two strips, two pieces of
+// furniture and four corner repairs; held to four rects they merged into
+// boxes a third of the pane, and a graph panned diagonally at 41fps on
+// XQuartz and 52 on macOS where two more rects make it 60 and 78 (issue
+// #691). Eight bought nothing past six.
+const CONTENTS_BLIT_MAX_RECTS = MAX_DAMAGE_RECTS + 2;
+
 // A scroll that must not blit this frame: content inside the viewport
 // already changed (see the arming check in scrollTo, and the claim-time
 // cancel in WindowNode.invalidate — react-x11#295). Truthy on purpose, so
@@ -201,6 +218,98 @@ function unionIsBox(a, b) {
   );
 }
 
+/** Is `rect` inside one of `pins`, the furniture an element blit pinned —
+ * repaired whole after the copy, whatever changed in it (issue #682)? */
+function insidePinned(rect, pins) {
+  if (!pins) return false;
+  for (const pin of pins) {
+    if (rectContains(pin, rect)) return true;
+  }
+  return false;
+}
+
+/** Does every corner square of a rounded `box` that reaches into `vp` lie
+ * inside one of `pins` — repaired after the copy rather than dragged along
+ * by it (issue #691)? True when none reaches in. */
+function cornersPinned(box, radius, vp, pins) {
+  for (const square of cornerSquares(box, radius)) {
+    if (!rectsOverlap(square, vp)) continue;
+    const inside = intersectRects(outerPixels(square), vp);
+    if (inside && !insidePinned(inside, pins)) return false;
+  }
+  return true;
+}
+
+/** One of `scrollContents`' lists as an array, read once — an iterable may
+ * be a generator — null when it was left out, and undefined when it is not
+ * a list at all. */
+function asList(value) {
+  if (value == null) return null;
+  return typeof value[Symbol.iterator] === 'function' ? [...value] : undefined;
+}
+
+/** The first entry of `list` that `ok` refuses, the value itself when it is
+ * not a list, or undefined when there is nothing wrong with it. */
+function strayIn(value, list, ok) {
+  if (list === undefined) return value;
+  return list?.find((entry) => entry != null && !ok(entry));
+}
+
+const isNode = (value) => typeof value.paintBounds === 'function';
+
+const isRect = (value) =>
+  Number.isFinite(value.x) &&
+  Number.isFinite(value.y) &&
+  Number.isFinite(value.width) &&
+  Number.isFinite(value.height) &&
+  value.width >= 0 &&
+  value.height >= 0;
+
+/**
+ * The furniture one `scrollContents` call pins: the whole pixels each rect
+ * touches inside `rect`, rounded outward because repairing a pixel more
+ * costs nothing and a pixel less is a sliver of stale furniture the pan
+ * drags along. A rect beside `rect` has no pixels the copy moves, and is
+ * left out, as is an empty one. Null when nothing is left.
+ */
+function pinnedRects(rect, list) {
+  let out = null;
+  for (const pin of list ?? []) {
+    if (pin == null || pin.width === 0 || pin.height === 0) continue;
+    const inside = intersectRects(outerPixels(pin), rect);
+    if (inside) (out ??= []).push(inside);
+  }
+  return out;
+}
+
+/** A value from a caller, short enough for a warning. An object that will
+ * not serialize — a node's tree is a cycle — is named by its keys. */
+function describe(value) {
+  if (typeof value?.paintBounds === 'function') {
+    return `the node <${value.kind}>`;
+  }
+  // the likeliest mistake of all, from a React component
+  if (typeof value?.current?.paintBounds === 'function') {
+    return `a ref to <${value.current.kind}> rather than the node, its .current`;
+  }
+  if (value === null || typeof value !== 'object') return String(value);
+  try {
+    const json = JSON.stringify(value);
+    return json.length > 120 ? `${json.slice(0, 117)}...` : json;
+  } catch {
+    return `an object with ${Object.keys(value).join(', ') || 'no keys'}`;
+  }
+}
+
+const warned = new Set();
+/** A development warning, once per kind of mistake rather than per value:
+ * the value is new on every frame of a pan. */
+function warnOnce(key, message) {
+  if (!DEV || warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
+
 /** Node's half of the scroll blit, installed onto `Node.prototype` by node.js. */
 export class NodeScrollBlit {
   /**
@@ -215,8 +324,10 @@ export class NodeScrollBlit {
    * away, so the paths that make them take a finer route while this is true.
    *
    * `scrollContents` is out: an element blit already tests foreign claims
-   * against the rect it handed over (issue #309), and its region is not a
-   * viewport whose children *are* the scrolled content.
+   * against the rect it handed over (issue #309), its region is not a
+   * viewport whose children *are* the scrolled content, and what changes
+   * inside it on a pan frame is furniture the element names up front as
+   * pinned (issue #682, `_pinnedHolds`).
    */
   _blitLedgerOpen() {
     const from = this._pendingBlitFrom;
@@ -277,6 +388,18 @@ export class NodeScrollBlit {
     return true;
   }
 
+  /**
+   * Is `rect` inside furniture this node's pending element blit pinned
+   * (issue #682)? A claim there is the element's own and costs the blit
+   * nothing: the frame repaints the pinned rect after the copy, and the
+   * rect the copy dragged its old pixels to, so the change is covered
+   * whichever side of the shift the claim was named on — where the
+   * furniture stays, or where the content under it was before it moved.
+   */
+  _pinnedHolds(rect) {
+    return insidePinned(rect, this._pendingBlitContents?.pinned);
+  }
+
   /**
    * How far the blit this viewport has pending moves the pixels it keeps:
    * the delta `_applyScrollBlits` hands `scrollRegion`, from the offsets
@@ -330,12 +453,24 @@ export class NodeScrollBlit {
    * moved something — and each of them falls back to repainting the rect,
    * which is the behaviour without this call at all.
    *
-   * All of those are about `rect`, not about this node (issue #309). An
-   * element with furniture pinned to a corner of its pane — a minimap, zoom
-   * controls, a HUD strip that has to repaint on a pan frame and whose
-   * pixels must not ride the blit — carves it out of the region it shifts
-   * and claims it as ordinary damage. Those claims land beside the rect and
-   * the frame stays a blit.
+   * All of those are about `rect`, not about this node (issue #309): a
+   * claim beside the rect leaves the frame a blit, so an element can carve
+   * a HUD strip along the pane's edge out of the region it shifts and claim
+   * the strip as ordinary damage.
+   *
+   * Furniture in a corner does better as `pinned` (issue #682): rects inside
+   * `rect`, in the same coordinates, that stay put while everything around
+   * them moves — a minimap, zoom controls, drawn by the element over its
+   * own drawing or laid out over it as nodes. Carved out instead, a corner
+   * takes the rows beside it too, since what shifts is one rectangle, and
+   * two bottom corners carve a band the pane's full width, repainted every
+   * frame. Pinned, the copy drags a stale image of each piece of furniture
+   * by (dx, dy), and the frame repaints the pinned rect and that image —
+   * two small rects, whether the furniture changed or not, so a minimap's
+   * viewport box can follow the pan without claiming a thing. A claim
+   * inside a pinned rect is the element's own rather than a reason to
+   * decline, and so is a node that lies inside one: its pixels are
+   * repaired with the rest of the rect.
    *
    * `riders` are the other way round: nodes that are not this one whose
    * pixels in `rect` are part of what moves — a layer of widgets an element
@@ -352,7 +487,7 @@ export class NodeScrollBlit {
    * arrives as `paintDamage()`, because most of the gates cannot be decided
    * until the frame closes; a `false` here is only the ones that can.
    */
-  scrollContents(rect, dx, dy, riders) {
+  scrollContents(rect, dx, dy, riders, pinned) {
     const root = this.root;
     if (
       !root ||
@@ -367,6 +502,33 @@ export class NodeScrollBlit {
     // rounding a gesture to whole pixels lands here on most events.
     if (!dx && !dy) return true;
     const pending = this._pendingBlitContents;
+    // Two lists, one of nodes and one of rects, and the cost of mixing them
+    // up is not a slow frame but a wrong one: furniture handed over as a
+    // rider is dragged along by the pan and repaired by nobody. So each has
+    // to be what it says, or the frame repaints.
+    const riderList = asList(riders);
+    const pinList = asList(pinned);
+    const strayRider = strayIn(riders, riderList, isNode);
+    const strayPin = strayIn(pinned, pinList, isRect);
+    if (strayRider !== undefined) {
+      warnOnce(
+        'riders',
+        'react-x11: scrollContents() takes the nodes a pan carries as a ' +
+          `list of riders, and got ${describe(strayRider)}. Furniture that ` +
+          'stays put while the pan moves around it is pinned — a list of ' +
+          'rects, the argument after riders. This frame repaints the region ' +
+          'instead of blitting it.',
+      );
+    } else if (strayPin !== undefined) {
+      warnOnce(
+        'pinned',
+        'react-x11: scrollContents() takes the furniture it pins as a list ' +
+          'of rects — { x, y, width, height }, in window coordinates like ' +
+          `the region — and got ${describe(strayPin)}. This frame repaints ` +
+          'the region instead of blitting it, since a blit would drag the ' +
+          'furniture along with the pan.',
+      );
+    }
     // The rect has to be the same one all frame: two different regions of
     // one node shifting by different deltas is not one CopyArea, and the
     // second claim would coalesce into the first past the point either can
@@ -374,12 +536,14 @@ export class NodeScrollBlit {
     // offsets this frame — two shifts of the same pixels, and a frame can
     // only have one.
     if (
-      this._pendingBlitFrom != null &&
-      (!pending ||
-        pending.rect.x !== rect.x ||
-        pending.rect.y !== rect.y ||
-        pending.rect.width !== rect.width ||
-        pending.rect.height !== rect.height)
+      strayRider !== undefined ||
+      strayPin !== undefined ||
+      (this._pendingBlitFrom != null &&
+        (!pending ||
+          pending.rect.x !== rect.x ||
+          pending.rect.y !== rect.y ||
+          pending.rect.width !== rect.width ||
+          pending.rect.height !== rect.height))
     ) {
       this._pendingBlitFrom = BLIT_POISONED;
     } else if (this._pendingBlitFrom == null && Array.isArray(root._damage)) {
@@ -394,11 +558,13 @@ export class NodeScrollBlit {
       // claim it could swallow has to overlap it, and every claim carries
       // its own slop already — `paintBounds` inflates a node's region by
       // `DAMAGE_SLOP` on every side, so ink that bleeds into `rect` is
-      // claimed overlapping it. Furniture *beside* the rect — a minimap in
-      // a corner the element carved out and repaints itself — is not a
-      // change to the pixels about to move.
+      // claimed overlapping it. Furniture *beside* the rect — a strip the
+      // element carved out and repaints itself — is not a change to the
+      // pixels about to move, and nor is furniture this call pins inside
+      // it (issue #682): the frame repaints that whole, blit or no blit.
+      const pins = pinnedRects(rect, pinList);
       for (const claimed of root._damage) {
-        if (rectsOverlap(claimed, rect)) {
+        if (rectsOverlap(claimed, rect) && !insidePinned(claimed, pins)) {
           this._pendingBlitFrom = BLIT_POISONED;
           break;
         }
@@ -415,13 +581,22 @@ export class NodeScrollBlit {
     // coalescing scrollTo gets from recording an origin
     state.dx += dx;
     state.dy += dy;
-    if (riders) {
-      for (const rider of riders) {
+    if (strayRider === undefined) {
+      for (const rider of riderList ?? []) {
         if (!rider || rider === this || rider.destroyed) continue;
         (state.riders ??= new Set()).add(rider);
         rider._ridesBlitOf = this;
       }
     }
+    // …and the furniture of every call this frame: a pan that moved its
+    // minimap names both places, and the frame repairs both. Kept in whole
+    // pixels inside the rect, once each.
+    if (strayPin === undefined) {
+      for (const pin of pinnedRects(state.rect, pinList) ?? []) {
+        const pins = (state.pinned ??= []);
+        if (!pins.some((held) => rectContains(held, pin))) pins.push(pin);
+      }
+    }
     this._pendingBlitFrom ??= BLIT_CONTENTS;
     (root._pendingScrolls ??= new Set()).add(this);
     // ...and the claim about to be recorded is the shift itself, not a
@@ -842,10 +1017,15 @@ export class WindowScrollBlit {
    * the L of exposed strips overlaps the scrollbar rects and the merges
    * balloon back towards the whole viewport. With no bars the L is two
    * disjoint rects and stays two.
+   *
+   * Furniture the element pinned (issue #682) is the one thing inside the
+   * region that does not move: the copy drags a stale image of it along,
+   * so each pinned rect is repaired where it is and where the image landed,
+   * and a node inside one is furniture too rather than a reason to refuse.
    */
   _applyContentsBlit(
     node,
-    { rect: vp, dx, dy, riders },
+    { rect: vp, dx, dy, riders, pinned },
     width,
     height,
     target,
@@ -888,66 +1068,39 @@ export class WindowScrollBlit {
     // A scroll container's children *are* the scrolled content, which is
     // why _scrollBlitSafe skips that subtree. An element's are not: it
     // draws the region in paintContent and its children are laid out on
-    // top, so one reaching in would have its pixels dragged along.
+    // top, so one reaching in would have its pixels dragged along — unless
+    // it lies inside furniture the element pinned, which is repaired after
+    // the copy whoever drew it.
     for (const child of node.children) {
       if (child.isWindow || !child.yoga || child.hidden) continue;
       if (child.style?.display === 'none') continue;
-      if (rectsOverlap(child._subtreeBounds(), vp)) return;
+      const reach = child._subtreeBounds();
+      if (rectsOverlap(reach, vp) && !insidePinned(reach, pinned)) return;
     }
     const keep = this._blitKeptDamage(vp, true, target.damage);
     if (!keep) return;
-    // An ancestor's rounded corners reach into the top and bottom rows of
-    // the region (a graph pane inside a rounded card is the common shape):
-    // those rows do not translate, so they leave the blit and get repainted
-    // as bands — the same carve the element does for its own furniture —
-    // and the band that shifts is what is left between them.
-    const bands = this._cornerBands(node, vp, target.top);
-    const shifted =
-      bands.top || bands.bottom
-        ? {
-            x: vp.x,
-            y: vp.y + bands.top,
-            width: vp.width,
-            height: vp.height - bands.top - bands.bottom,
-          }
-        : vp;
-    if (shifted.height <= 0 || Math.abs(dy) >= shifted.height) return;
-    if (
-      (shifted.width - Math.abs(dx)) * (shifted.height - Math.abs(dy)) <
-      area * SCROLL_BLIT_MIN_KEEP
-    ) {
-      return;
-    }
-    if (!this._scrollBlitSafe(node, shifted, target.top, riders)) return;
-    // the element's deltas are already how far the pixels moved, the sense
-    // scrollRegion takes (0 + x rather than x: a caller's -0 would survive
-    // into request buffers and test comparisons)
-    if (!target.blit({ ...shifted }, 0 + dx, 0 + dy)) return;
-    let rects = keep;
-    if (bands.top) {
-      rects = addDamageRect(rects, {
-        x: vp.x,
-        y: vp.y,
-        width: vp.width,
-        height: bands.top,
-      });
-    }
-    if (bands.bottom) {
-      rects = addDamageRect(rects, {
-        x: vp.x,
-        y: shifted.y + shifted.height,
-        width: vp.width,
-        height: bands.bottom,
-      });
-    }
-    vp = shifted;
+    // An ancestor's rounded corners reach into the region (a graph pane
+    // inside a rounded card is the common shape). Their arcs do not
+    // translate, but they live in four small squares and nowhere else, so
+    // they are pinned like the element's own furniture (issue #691): the
+    // whole region shifts, and each square is repaired where it is and where
+    // the copy dragged its image. Carved out as the rows they reach into,
+    // they took the region's full width at the top and at the bottom —
+    // every card and edge in those rows repainted through the rounded clip
+    // on every frame — and next to furniture in two corners, one rect more
+    // than the damage cap has room for.
+    const corners = this._cornerPins(node, vp, target.top);
+    const pins =
+      corners && pinned ? [...pinned, ...corners] : (corners ?? pinned);
+    if (!this._scrollBlitSafe(node, vp, target.top, riders, pins)) return;
     // The strips the shift exposed, on the sides the pixels came from. The
     // horizontal one takes the full width and the vertical one takes what
     // is left, so a diagonal shift claims two rects that do not overlap —
     // overlapping claims merge into their box, and the box of an L is the
     // whole region again.
+    const strips = [];
     if (dy !== 0) {
-      rects = addDamageRect(rects, {
+      strips.push({
         x: vp.x,
         y: dy > 0 ? vp.y : vp.y + vp.height + dy,
         width: vp.width,
@@ -955,38 +1108,73 @@ export class WindowScrollBlit {
       });
     }
     if (dx !== 0) {
-      rects = addDamageRect(rects, {
+      strips.push({
         x: dx > 0 ? vp.x : vp.x + vp.width + dx,
         y: dy > 0 ? vp.y + dy : vp.y,
         width: Math.abs(dx),
         height: vp.height - Math.abs(dy),
       });
     }
+    const pieces = [...strips];
+    if (pins) {
+      // Each piece of furniture where it stays, and where the copy put the
+      // image of it it dragged along — one box, since a pan step moves it a
+      // few pixels, and inside the region, since the copy wrote nothing
+      // outside. Less the strips, which repaint anyway: furniture flush
+      // against the side the pixels came from would otherwise merge with
+      // the strip down that side into the box of the two, most of the
+      // region's height.
+      for (const pin of pins) {
+        const image = { ...pin, x: pin.x + dx, y: pin.y + dy };
+        const repair = intersectRects(unionRect(pin, image), vp);
+        if (!repair) continue;
+        let cut = [repair];
+        for (const strip of strips) {
+          cut = cut.flatMap((piece) => outside(piece, strip));
+        }
+        pieces.push(...cut);
+      }
+    }
+    // in one call, so the small pieces find their neighbours before the
+    // cap makes anything merge (`addDamageRects`)
+    const rects = addDamageRects(keep, pieces, CONTENTS_BLIT_MAX_RECTS);
+    if (pins) {
+      // Furniture can be most of a pane, and the damage cap can merge a
+      // repair with a strip into the box of the two: past this, the blit is
+      // buying a shift and paying for the region anyway.
+      let painted = 0;
+      for (const rect of rects) {
+        const inside = intersectRects(rect, vp);
+        if (inside) painted += rectArea(inside);
+      }
+      if (painted > area * SCROLL_BLIT_MAX_REPAINT) return;
+    }
+    // the element's deltas are already how far the pixels moved, the sense
+    // scrollRegion takes (0 + x rather than x: a caller's -0 would survive
+    // into request buffers and test comparisons)
+    if (!target.blit({ ...vp }, 0 + dx, 0 + dy)) return;
     target.damage = rects;
   }
 
   /**
-   * How many rows at the top and at the bottom of `vp` an ancestor's rounded
-   * corners reach into — the rows an element blit has to leave behind and
-   * repaint, so that what shifts stays clear of every corner square
-   * (`_scrollBlitSafe`). Whole pixels, and zero when no corner reaches in.
+   * The squares of `vp` an ancestor's rounded corners reach into — the only
+   * pixels of a rounded outline a translation cannot keep — in whole pixels,
+   * for an element blit to pin (issue #691). Null when no corner reaches in.
    * Ancestors below `upTo`, the node the blit's surface belongs to
    * (`_blitTarget`): a pane is a rectangle no corner above it clips.
    */
-  _cornerBands(node, vp, upTo = this) {
-    let top = 0;
-    let bottom = 0;
+  _cornerPins(node, vp, upTo = this) {
+    let out = null;
     for (let n = node.parent; n && n !== upTo; n = n.parent) {
       const radius = n.style?.borderRadius ?? 0;
       if (!(radius > 0) || !n.abs) continue;
-      if (!cornerSquaresOverlap(n.abs, radius, vp)) continue;
-      top = Math.max(top, Math.ceil(n.abs.y + radius - vp.y));
-      bottom = Math.max(
-        bottom,
-        Math.ceil(vp.y + vp.height - (n.abs.y + n.abs.height - radius)),
-      );
+      for (const square of cornerSquares(n.abs, radius)) {
+        if (!rectsOverlap(square, vp)) continue;
+        const inside = intersectRects(outerPixels(square), vp);
+        if (inside) (out ??= []).push(inside);
+      }
     }
-    return { top: Math.max(0, top), bottom: Math.max(0, bottom) };
+    return out;
   }
 
   /**
@@ -1002,7 +1190,7 @@ export class WindowScrollBlit {
    * only its own children — what the window draws under the surface was
    * never in the pane's pixels.
    */
-  _scrollBlitSafe(scroller, vp, top = this, riders = null) {
+  _scrollBlitSafe(scroller, vp, top = this, riders = null, pinned = null) {
     // the window itself scrolls: everything inside it *is* the scrolled
     // content, so there is nothing that could be dragged along
     if (scroller === this) return true;
@@ -1041,10 +1229,11 @@ export class WindowScrollBlit {
           // radius-sized squares at the corners, and the straight run of
           // the edge between them is the border ring already excluded
           // above. A viewport that reaches the edge but stays clear of the
-          // squares — an element that carved the corner rows into bands it
-          // repaints (`_cornerBands`) — is translation-safe.
+          // squares is translation-safe, and so is an element blit that
+          // pins the squares it reaches into (`_cornerPins`) — repaired
+          // where they are and where the copy dragged them.
           const radius = child.style?.borderRadius ?? 0;
-          if (radius > 0 && cornerSquaresOverlap(child.abs, radius, vp)) {
+          if (radius > 0 && !cornersPinned(child.abs, radius, vp, pinned)) {
             return false;
           }
           if (typeof child._scrollbars === 'function') {
@@ -1063,7 +1252,11 @@ export class WindowScrollBlit {
         // …and a node the blit carries has pixels that move with it
         // (`scrollContents`'s riders)
         if (riders?.has(child)) continue;
-        if (!rectsOverlap(child._subtreeBounds(), vp)) continue;
+        const reach = child._subtreeBounds();
+        if (!rectsOverlap(reach, vp)) continue;
+        // …and one inside furniture an element blit pinned is repaired
+        // where it is and where the copy dragged it, like the element's own
+        if (insidePinned(reach, pinned)) continue;
         // A box that paints nothing of its own is its children, and as
         // safe as they are: the box that clips a rider to its element.
         if (child._paintsNothingOwn() && check(child)) continue;

package/src/nodes/window/flush.js

@@ -210,6 +210,8 @@ export class WindowFlush {
           if (this._claimLayoutMove(rect, node, cap)) layoutMoved = true;
         };
       }
+      // the moves this walk hands over to be copied are this frame's alone
+      this._rigidMoves = null;
       try {
         // `_absolutizeChildren`, not the loop it wraps: a `<window
         // style={{overflow: 'scroll'}}>` is a scroll container like any box,
@@ -279,6 +281,16 @@ export class WindowFlush {
     this.window.prepareFrame?.(this, layoutRan);
     // any node this pass laid out may be what an open popup is anchored to
     if (layoutRan) this._notifyAnchorChange();
+    // A subtree that only moved and covers its box opaquely is copied where
+    // it went, and the frame paints around the copy — or its move is
+    // claimed, where it was and where it is (nodes/moveblit.js). Once every
+    // other claim of the frame is in: what the copy leaves to paint depends
+    // on what else changed around it.
+    const moves = layoutRan ? this._rigidMoves : null;
+    this._rigidMoves = null;
+    if (moves !== null && this._settleRigidMoves(moves, width, height)) {
+      layoutMoved = true;
+    }
     // after layout (the claims above included), before the damage is taken:
     // a frame that turns out to be a pure scroll blits the surviving band
     // and narrows its claim to the exposed strip

package/src/nodes/window/window.js

@@ -18,6 +18,7 @@ import { NO_DAMAGE } from '../damage.js';
 import { installMethods } from '../install.js';
 import { WindowInvalidate } from '../invalidate.js';
 import { WindowLayoutHost } from '../layouthost.js';
+import { WindowMoveBlit } from '../moveblit.js';
 import { DEVTOOLS_FAKE_DOCUMENT, Node } from '../node.js';
 import { WindowPaint } from '../paint.js';
 import { WindowPosition } from '../position.js';
@@ -209,6 +210,12 @@ export class WindowNode extends Scrollable(Node) {
     // each claim goes to one or both by what it can reach (`_paneReach`).
     // Null with nothing owed.
     this._paneDamage = null;
+    // The claims the window's list took this frame, each with the node that
+    // made it — null once there are too many to be worth keeping — and the
+    // subtrees this frame's layout moved that the window may copy rather
+    // than repaint, settled once the pass is over (nodes/moveblit.js).
+    this._claimLog = [];
+    this._rigidMoves = null;
     this.events = new EventManager(this);
     // ids of the child windows in the order the *server* stacks them,
     // bottom to top — see _restackWindowChildren
@@ -979,6 +986,7 @@ installMethods(
   WindowPosition,
   WindowInvalidate,
   WindowScrollBlit,
+  WindowMoveBlit,
   WindowPaint,
   WindowListeners,
   WindowHints,