react-x11 2.40.0 → 2.41.1

package/src/cocoa/panewindow.js

@@ -21,6 +21,15 @@
 // (src/cocoa/panehost.js), because nothing in a pane process runs AppKit.
 import { BackendContext2D } from '../backend/context2d.js';
 
+// How long a pane counts on the host's `pane-shown` for a present before it
+// stops waiting for one (`_answerOverdue`). A host that is only busy answers
+// well inside it — in the browser example on a Mac, a present was looked up
+// under a millisecond after it went at the median, and 180ms after at
+// worst, the host laying out a page at each width of a drag on its first
+// run — and one that never answers, a host stalled or gone, must not stop
+// the pane drawing.
+const ANSWER_TIMEOUT_MS = 250;
+
 let nextPaneId = 1;
 
 export class CocoaPaneWindow {
@@ -57,7 +66,23 @@ export class CocoaPaneWindow {
     this._dirty = false;
     this._flushDamage = 'full';
     this._seq = 0;
+    // a size from the host not yet presented (`pane-sized`)
+    this._owesSized = false;
     this._presentedAt = -Infinity;
+    // the window's own frame clock (`CocoaApp._frameDue`), at the app's
+    // interval: a pane has no display of its own to pace by
+    this._rafLast = 0;
+    // The newest present the host has looked up (`pane-shown`), and the
+    // buffers of retired rings still named by a present it has not: freed
+    // as it does (`_releaseRing`).
+    this._shownSeq = 0;
+    this._shownAt = -Infinity;
+    // what it had looked up before its latest answers, whose buffer the
+    // screen may still show (`_takeBack`)
+    this._shownBefore = 0;
+    this._pollTimer = null;
+    this._kickQueued = false;
+    this._retired = [];
     this._reactX11Node = null;
     // Where the pane's corner is on the screen, in device pixels, as the
     // host last said (`setPaneSize`): what a popup the pane anchors to one
@@ -89,6 +114,10 @@ export class CocoaPaneWindow {
     const moved =
       screen != null && (screen.x !== this.x || screen.y !== this.y);
     const resized = w !== this.width || h !== this.height;
+    // The host sends the next rect when this one is painted (`pane-sized`,
+    // src/frame/index.js): one that changes no size is painted already.
+    if (resized) this._owesSized = true;
+    else this._post({ type: 'pane-sized' });
     if (!moved && !resized) return;
     if (moved) {
       this.x = screen.x;
@@ -143,8 +172,10 @@ export class CocoaPaneWindow {
     this.app._paneSend?.(msg);
   }
 
+  /** On this window's clock, which the clock asks before it runs a frame
+   *  (`frameHeld`). */
   requestAnimationFrame(cb) {
-    return this.app._requestFrame(cb);
+    return this.app._requestFrame(cb, this);
   }
 
   /** A `<glarea>`'s frame, after this pane's own (`CocoaWindow`'s). */
@@ -152,34 +183,140 @@ export class CocoaPaneWindow {
     return this.app._requestFrame(cb, null, true);
   }
 
+  /** The clock's period (`CocoaApp._frameDue`): the app's, a pane having no
+   *  display of its own. */
+  get _frameInterval() {
+    return this.app.frameIntervalFor(null);
+  }
+
+  /** What is on glass is the host's to know; a pane draws what it is
+   *  asked to (`CocoaApp._tickFrames`). */
+  _visible() {
+    return true;
+  }
+
   /**
    * Whether the host may still be showing the frame before the last one —
    * the gate `flushPendingFrames` (src/frames.js) is written around: a
    * discrete input paints on the spot only when the last frame has landed,
    * which is what folds a burst into one paced frame instead of a frame per
-   * event. On X11 the server says when a present was shown; a pane hears
-   * nothing back from the host, which flips the layer on its next pump tick
-   * and has Core Animation scan it out at the following refresh — so a
-   * present counts as in flight for one frame interval. Without a gate here
-   * every message the host queued while the pane was busy was answered
-   * with a full frame of its own: a forty-tick resize of a pane whose frame
-   * costs 300ms stepped through forty sizes for twelve seconds after the
-   * drag had ended, each one the previous surface stretched to the layer.
+   * event. Without a gate here every message the host queued while the
+   * pane was busy was answered with a full frame of its own: a forty-tick
+   * resize of a pane whose frame costs 300ms stepped through forty sizes
+   * for twelve seconds after the drag had ended, each one the previous
+   * surface stretched to the layer.
+   *
+   * On X11 the server says when a present was shown. Here the host says
+   * when it has looked one up (`pane-shown`), which is half of it: the host
+   * commits on its own thread and the screen shows the frame at the
+   * refresh after. So a present is in flight until it is answered, and for
+   * a frame interval after it went: measured in the browser example on a
+   * 120Hz panel, the answer alone answered an input 4ms sooner, and gave
+   * input faster than the display a frame each — 245 a second at 250
+   * inputs a second, 355 at 1000 — where the interval keeps it at 118, and
+   * the frames that outran the WindowServer drew into buffers it still
+   * read. Nothing the pane can ask says when a frame is on glass: a buffer
+   * reads in use from the host's lookup, not from the refresh. And no frame
+   * is drawn while one is held (`frameHeld`), whatever asks.
    */
   frameInFlight() {
+    if (this.frameHeld()) return true;
+    if (this._seq > this._shownSeq && !this._answerOverdue()) return true;
     return (
       performance.now() - this._presentedAt < this.app.frameIntervalFor(null)
     );
   }
 
+  /**
+   * Whether this pane's next frame has no buffer to go into, which holds it
+   * on the clock (`CocoaApp._tickFrames`): every buffer but the one it last
+   * presented is named by a present the host is showing or has yet to look
+   * up, or the host is done with one and the WindowServer is still reading
+   * it. A frame drawn into one of those anyway was a frame half drawn on
+   * glass — the host showed the buffer the pane was drawing into, or looked
+   * it up after the pane had started, and showed that.
+   *
+   * The second is the host coming back from a long frame of its own. Its
+   * answers say it has looked the queued presents up, not that they are on
+   * glass: that is its UI thread's commit and the refresh after, and until
+   * then the buffer it showed all along is still what the screen shows —
+   * and which buffer that is, the answers cannot say, since a host that
+   * stalled between a lookup and its commit left the one before on glass.
+   * The WindowServer can: a buffer is taken once it has let go of one, which
+   * is asked every millisecond (`_pollHeld`), and for a frame interval after
+   * the host's answer at most, since it reads a buffer it no longer shows
+   * for as long as it likes and a pane must not wait on that.
+   *
+   * A new size is never held: it draws into a new ring, which nothing
+   * names. Nor is a host that stopped answering (`_answerOverdue`).
+   */
+  frameHeld() {
+    if (!this._ring || this._surface) return false;
+    if (
+      this._surfaceSize?.width !== this.width ||
+      this._surfaceSize?.height !== this.height
+    ) {
+      return false;
+    }
+    let done = false;
+    for (let i = 0; i < this._ring.length; i += 1) {
+      const s = this._ring[i];
+      if (i === this._shownIndex || !this._done(s)) continue;
+      if (!this._held(s)) return false;
+      done = true;
+    }
+    if (!done) return !this._answerOverdue();
+    const wait =
+      this._shownAt + this.app.frameIntervalFor(null) - performance.now();
+    if (!(wait > 0)) return false;
+    this._pollHeld();
+    return true;
+  }
+
+  /**
+   * Ask again in a millisecond whether the WindowServer has let go of a
+   * buffer (`frameHeld`): it says so by no event, and the pump's next tick
+   * is up to 8ms off — a frame held that long for a buffer let go of a
+   * millisecond later was a frame late.
+   */
+  _pollHeld() {
+    if (this._pollTimer) return;
+    this._pollTimer = setTimeout(() => {
+      this._pollTimer = null;
+      const app = this.app;
+      if (!this.destroyed && app._rafQueue.some((e) => e.wnd === this)) {
+        app._tickFrames();
+        app._presentAll();
+      }
+    }, 1);
+    this._pollTimer.unref?.();
+  }
+
+  /** Whether the host has looked up a present after the last one that named
+   *  `buffer`, or none ever did: nothing will show it again. */
+  _done(buffer) {
+    return !buffer.presentedSeq || buffer.presentedSeq < this._shownSeq;
+  }
+
+  /** A present the host has not answered for longer than it would if it
+   *  were answering at all (`ANSWER_TIMEOUT_MS`). */
+  _answerOverdue() {
+    return (
+      this._seq > this._shownSeq &&
+      performance.now() - this._presentedAt >= ANSWER_TIMEOUT_MS
+    );
+  }
+
   // Three buffers, not two. A pane is cross-process: the host keeps
   // scanning the last buffer it was handed until it processes the next
-  // present message, and nothing here waits for that. With two buffers the
-  // next paint (and the catch-up copy) lands in the very buffer the host is
-  // still displaying — every present tears it, the flash. A third buffer is
-  // always at least two presents behind what the host shows, so the pane
-  // never writes a buffer the host might still be reading. Same-process
-  // windows need only two because Core Animation latches the front buffer.
+  // present message. With two buffers the next paint (and the catch-up
+  // copy) lands in the very buffer the host is still displaying — every
+  // present tears it, the flash. With three, one present may be on its way
+  // while the next frame draws: the buffer the host shows, the one the
+  // present on its way names, and the one the host has let go of. A host
+  // two presents behind leaves none, and the frame waits for its answer
+  // (`frameHeld`, `_takeBack`). Same-process windows need only two because
+  // Core Animation latches the front buffer.
   static RING = 3;
 
   /**
@@ -188,11 +325,26 @@ export class CocoaPaneWindow {
    * drag resizes the pane a tick at a time, and each tick retires a ring
    * that the finalizer would have held until a collection happened to run.
    * The host keeps its own reference to whichever buffer its layer shows,
-   * so the frame on glass survives the free; a present of a retired buffer
-   * still in the channel finds no surface, and the host drops it
-   * (`CocoaPaneHost.present`) — the next present is the full frame on the
-   * new ring anyway. Bridges before 0.4 have no `releaseSurface`; there the
-   * finalizer is still the only owner, and this is the drop it always was.
+   * so the frame on glass survives the free.
+   *
+   * All but a buffer a present names that the host has not looked up yet.
+   * The host finds a buffer by its IOSurface id, and the system hands a
+   * freed id to the next surface anyone makes — the three this ring's
+   * successor is about to make, the ring of another pane resized in the
+   * same layout, the host's own window. A present still in the channel
+   * named the id, not the surface, so the host scanned out whatever had it
+   * by the time it looked: a frame of this pane's next ring, cleared or
+   * half drawn, or another tab's page, for a frame at every few steps of a
+   * drag. So that buffer is kept (`_retired`) until the host says it has
+   * looked it up (`pane-shown`, `_shown`), and only then freed: its id
+   * stays its own until nothing can ask for it. That is the buffers of
+   * the presents in flight — one, as a rule, since a present goes a frame
+   * at a time and the host answers on its next turn — and never more than
+   * a ring's worth: a host that stops answering has the oldest freed
+   * anyway, the one it is likeliest to have looked up already.
+   *
+   * Bridges before 0.4 have no `releaseSurface`; there the finalizer is
+   * still the only owner, and this is the drop it always was.
    */
   _releaseRing() {
     const ring = this._ring;
@@ -201,7 +353,58 @@ export class CocoaPaneWindow {
     if (!ring) return;
     const release = this._native.releaseSurface;
     if (typeof release !== 'function') return;
-    for (const s of ring) release.call(this._native, s.handle);
+    for (const s of ring) {
+      if (s.presentedSeq > this._shownSeq) this._retired.push(s);
+      else release.call(this._native, s.handle);
+    }
+    while (this._retired.length > CocoaPaneWindow.RING) {
+      release.call(this._native, this._retired.shift().handle);
+    }
+  }
+
+  /**
+   * The host has looked up every present up to `seq` (`pane-shown`): the
+   * retired buffers they named are its now, or nobody's, and go.
+   */
+  _shown(seq) {
+    if (!(seq > this._shownSeq)) return;
+    // the first of a run of answers: what was looked up before it
+    if (!this._kickQueued) this._shownBefore = this._shownSeq;
+    this._shownSeq = seq;
+    this._shownAt = performance.now();
+    if (this._retired.length > 0) {
+      const release = this._native.releaseSurface;
+      this._retired = this._retired.filter((s) => {
+        if (s.presentedSeq > seq) return true;
+        release.call(this._native, s.handle);
+        return false;
+      });
+    }
+    // A frame the clock held for want of a buffer (`frameHeld`) goes now,
+    // not on the next pump tick — once every answer that came with this one
+    // is in. A host back from a long frame answers a run of presents at
+    // once, the channel hands them over in one turn, and a frame run on the
+    // first found only the buffer the host had shown all along.
+    if (this._kickQueued) return;
+    this._kickQueued = true;
+    queueMicrotask(() => {
+      this._kickQueued = false;
+      const app = this.app;
+      if (!this.destroyed && app._rafQueue.some((e) => e.wnd === this)) {
+        app._tickFrames();
+        app._presentAll();
+      }
+    });
+  }
+
+  /** Every retired buffer, answered or not: the window is going, and so is
+   *  the layer the host showed it on. */
+  _releaseRetired() {
+    const retired = this._retired;
+    this._retired = [];
+    const release = this._native.releaseSurface;
+    if (typeof release !== 'function') return;
+    for (const s of retired) release.call(this._native, s.handle);
   }
 
   _ensureSurface() {
@@ -230,10 +433,88 @@ export class CocoaPaneWindow {
       // decided when the flush reports its rects — see CocoaWindow's
       // `_ensureSurface` for why not a queued full frame from here
       if (hadSurface) this._freshSurface = true;
+    } else if (!this._surface) {
+      this._takeBack();
     }
     return this._surface;
   }
 
+  /**
+   * The buffer the frame about to be drawn goes into, taken at its first
+   * draw rather than at the present before it, so the host has had as long
+   * as it can to answer — CocoaWindow's `_takeBack`, over a ring the host
+   * reads from another process.
+   *
+   * One the host is done with (`_done`): a present after the last one that
+   * named it has been looked up, so it is neither on the layer nor on its
+   * way there. Of those, one the WindowServer has let go of as well —
+   * `surfaceIsInUse` false: it reads a buffer for a refresh or two after
+   * the layer has another, 8ms after the pane hears the answer at the
+   * median and 22 at the 90th percentile in the browser example — and of
+   * those the one presented longest ago. The clock holds a frame that would
+   * find none (`frameHeld`). One that comes anyway, once the WindowServer
+   * has held on for a frame interval, takes one it still reads — but the
+   * one the screen showed before the host's latest answers last, which a
+   * host back from a long frame has yet to commit the replacement for; and
+   * once the host is overdue, it takes a buffer whose present the host has
+   * yet to look up
+   * rather than the one on the layer: a host that comes back looks up
+   * everything queued in one turn, and only the last of it reaches glass,
+   * where the buffer on the layer is on glass now.
+   *
+   * Then the frame just presented, copied across whole: in a ring of three
+   * the buffer taken was last drawn two presents ago or more, and is stale
+   * everywhere. After a full frame as much as a partial one: what a frame
+   * was says nothing of what the next will be, and skipping the copy there
+   * had a partial frame after a full one — a status line, a hover's
+   * underline — drawn over the page as it was two frames back. The copy is
+   * wasted only where the next frame is full as well.
+   */
+  _takeBack() {
+    const ring = this._ring;
+    const last = ring[this._shownIndex];
+    let pick = -1;
+    let rank = Infinity;
+    for (let i = 0; i < ring.length; i += 1) {
+      const s = ring[i];
+      if (s === last) continue;
+      // done and let go of, then done, then on its way, then on the layer:
+      // the oldest of the best — but of the done, the one the screen showed
+      // before the host's latest answers last
+      const kind = this._done(s)
+        ? this._held(s)
+          ? 1 + Number(s.presentedSeq === this._shownBefore)
+          : 0
+        : s.presentedSeq > this._shownSeq
+          ? 3
+          : 4;
+      const r = kind * 2 ** 32 + (s.presentedSeq ?? 0);
+      if (r < rank) {
+        rank = r;
+        pick = i;
+      }
+    }
+    const back = ring[pick];
+    this._drawIndex = pick;
+    this._surface = back.handle;
+    // a different native surface owns the graphics state now — the context
+    // re-syncs its sticky state off the generation
+    this._surfaceGen++;
+    this._native.surfaceLock(back.handle);
+    if (last) this._native.copySurfaceRegion(last.handle, back.handle, null);
+  }
+
+  /** Whether the WindowServer still reads `buffer`: `IOSurfaceIsInUse`,
+   *  which counts the host's render server from this process too. A bridge
+   *  that cannot say (before 0.10) is answered no. */
+  _held(buffer) {
+    const inUse = this._native.surfaceIsInUse;
+    return (
+      typeof inUse === 'function' &&
+      inUse.call(this._native, buffer.handle) === true
+    );
+  }
+
   getContext() {
     if (!this._ctx) {
       this._ctx = new BackendContext2D(
@@ -278,10 +559,12 @@ export class CocoaPaneWindow {
   }
 
   scrollRegion(rect, dx, dy) {
-    if (!this._surface) return false;
+    if (!this._ring) return false;
     if (!Number.isInteger(dx) || !Number.isInteger(dy)) return false;
+    // the frame's first draw, which takes its buffer (`_takeBack`)
+    const surface = this._ensureSurface();
     const moved = this._native.scrollSurface(
-      this._surface,
+      surface,
       Math.round(rect.x),
       Math.round(rect.y),
       Math.round(rect.width),
@@ -301,33 +584,28 @@ export class CocoaPaneWindow {
     const shown = this._ring[this._drawIndex];
     this._native.surfaceUnlock(shown.handle);
     this._flushDamage = null;
+    // the buffer is named in the channel until the host says otherwise
+    // (`_releaseRing`, `_done`)
+    shown.presentedSeq = ++this._seq;
+    this._presentedAt = performance.now();
+    this._shownIndex = this._drawIndex;
+    // the next frame takes its buffer when it draws (`_takeBack`)
+    this._drawIndex = -1;
+    this._surface = null;
+    // last: the answer runs a held frame (`_shown`), which must find this
+    // present made
     this._post({
       type: 'pane-present',
-      seq: ++this._seq,
+      seq: this._seq,
       id: shown.iosurfaceId,
       width: this.width,
       height: this.height,
     });
-    this._presentedAt = performance.now();
-    this._shownIndex = this._drawIndex;
-    // the next buffer round the ring — two behind what the host will be
-    // showing, so it is safe to write even before the host has switched
-    this._drawIndex = (this._drawIndex + 1) % CocoaPaneWindow.RING;
-    const next = this._ring[this._drawIndex];
-    this._surface = next.handle;
-    this._surfaceGen++;
-    this._native.surfaceLock(next.handle);
-    // The next frame may paint only its damage, so `next` must first hold
-    // the last complete frame underneath — and the WHOLE of it, not just
-    // this frame's rects, because in a three-buffer ring `next` was last
-    // drawn two presents ago and is stale everywhere. A full copy of the
-    // just-shown buffer is the complete background; the safe target is what
-    // triple buffering buys. After a full frame as much as a partial one:
-    // what a frame was says nothing of what the next will be, and skipping
-    // the copy there had a partial frame after a full one — a status line,
-    // a hover's underline — drawn over the page as it was two frames back.
-    // The copy is wasted only where the next frame is full as well.
-    this._native.copySurfaceRegion(shown.handle, next.handle, null);
+    // and the size the host last sent is on screen (`pane-sized`)
+    if (this._owesSized) {
+      this._owesSized = false;
+      this._post({ type: 'pane-sized' });
+    }
   }
 
   snapshot() {
@@ -338,7 +616,10 @@ export class CocoaPaneWindow {
     if (this.destroyed) return;
     this.destroyed = true;
     this.app._unregisterWindow(this);
+    clearTimeout(this._pollTimer);
+    this._pollTimer = null;
     this._releaseRing();
+    this._releaseRetired();
   }
 }
 

package/src/cocoa/window.js

@@ -975,7 +975,15 @@ export class CocoaWindow {
    * painting a state the next event in the same batch replaces.
    */
   frameInFlight() {
-    if (this.app._batching) return true;
+    return this.app._batching || this.frameHeld();
+  }
+
+  /**
+   * Whether the frame clock holds this window's next frame
+   * (`CocoaApp._tickFrames`): the fence half of `frameInFlight`, without the
+   * batch, which the clock never ticks inside.
+   */
+  frameHeld() {
     return (
       this._awaiting != null &&
       this._surfaceSize?.width === this.width &&

package/src/events.js

@@ -1672,6 +1672,18 @@ export class EventManager {
         // its ordinary turn.
         if (step.consumed) return;
       }
+      // A key that typed more than one character has no code point to type
+      // them with: a backend whose keyboard layout composes on its own says
+      // so with `text` — the accent and a letter it does not combine with,
+      // `´s` (src/cocoa/keymap.js). Committed the way an input method's text
+      // is, a composition that opens and closes on this key, which is where
+      // an element that types inserts it — and like a composed key, it is
+      // the key's whole answer.
+      if (native.text && target.composes !== false) {
+        this._composition('Start', target, '', native);
+        this._composition('End', target, String(native.text), native);
+        return;
+      }
       // The element's own behaviour first, focus traversal after it — Tab is
       // an ordinary defaultable key rather than one the focus manager eats on
       // the way past. Cycling first meant an editor could only keep Tab as an

package/src/frame/index.js

@@ -192,6 +192,11 @@ function shallowEqual(a, b) {
 
 const EMPTY_PROPS = {};
 
+/** How long a rect sent to a pane that acknowledges sizes waits for its
+ *  `pane-sized` before the newest is sent anyway: a frame of a slow page,
+ *  several times over, so a lost answer costs a pause and not the size. */
+export const PANE_SIZED_WAIT_MS = 500;
+
 /**
  * A module of this application, mounted in its own process, its window
  * embedded here.
@@ -552,7 +557,54 @@ function PaneHostView({
     // moves when the box does and when the window does, so it is sent on
     // layout, on a scroll that shifts the box, and on every anchor change
     // of the window, which a move of the window is.
+    //
+    // **The newest rect wins.** A drag sends the host a size a frame, and a
+    // pane whose page takes longer than that to lay out was sent them
+    // faster than it could take them: a pipe hands a pane process one
+    // message a turn of its loop, with a frame in between, so the pane laid
+    // out and painted every size the drag passed through, one a frame, and
+    // went on resizing seconds after the edge stopped. A pane that says it
+    // has painted a size (`pane-sized`) is sent one rect at a time: what
+    // the host comes to while one is out replaces what was waiting, and goes
+    // when the pane says it has painted the last. A pane that never says so
+    // is sent every rect, as before, and one that goes quiet is sent the
+    // newest anyway after `PANE_SIZED_WAIT_MS`.
     let sent = null;
+    let pending = null;
+    let acks = false;
+    let inFlight = false;
+    let waiting = null;
+    const transmit = (rect) => {
+      sent = rect;
+      s.trySend?.({
+        type: 'pane-rect',
+        width: rect.width,
+        height: rect.height,
+        scale: rect.scale,
+        ...(rect.screen && { screen: rect.screen }),
+      });
+      if (!acks) return;
+      inFlight = true;
+      if (waiting) clearTimeout(waiting);
+      waiting = setTimeout(sized, PANE_SIZED_WAIT_MS);
+    };
+    const sameRect = (a, b) =>
+      !!a &&
+      !!b &&
+      a.width === b.width &&
+      a.height === b.height &&
+      a.scale === b.scale &&
+      a.screen?.x === b.screen?.x &&
+      a.screen?.y === b.screen?.y;
+    const sized = () => {
+      if (waiting) clearTimeout(waiting);
+      waiting = null;
+      inFlight = false;
+      const next = pending;
+      pending = null;
+      // a drag that came back to where it was sent from waits for nothing
+      if (next && !sameRect(next, sent)) transmit(next);
+    };
     const syncSize = () => {
       host.setRect(node.abs);
       const sc = node.scale ?? 1;
@@ -565,23 +617,10 @@ function PaneHostView({
             y: Math.round(origin.y + node.abs.y),
           }
         : null;
-      if (
-        sent &&
-        sent.width === width &&
-        sent.height === height &&
-        sent.screen?.x === screen?.x &&
-        sent.screen?.y === screen?.y
-      ) {
-        return;
-      }
-      sent = { width, height, screen };
-      s.trySend?.({
-        type: 'pane-rect',
-        width,
-        height,
-        scale: sc,
-        ...(screen && { screen }),
-      });
+      const rect = { width, height, scale: sc, screen };
+      if (sameRect(rect, pending ?? sent)) return;
+      if (inFlight) pending = rect;
+      else transmit(rect);
     };
     const origAbsolutize = node.absolutize.bind(node);
     node.absolutize = (ox, oy) => {
@@ -625,6 +664,11 @@ function PaneHostView({
       } else if (msg?.type === 'pane-present') {
         host.setRect(node.abs);
         host.present(msg.id, msg);
+      } else if (msg?.type === 'pane-sized') {
+        // the pane has painted the rect it was last sent: the newest one
+        // waiting goes now, and from here on one is out at a time
+        acks = true;
+        sized();
       } else if (msg?.type === 'pane-cursor') {
         // The pane names its cursor as an element that draws names one for
         // a point: this box is the node the host's pointer is over, so the
@@ -637,6 +681,8 @@ function PaneHostView({
     });
     return () => {
       off();
+      if (waiting) clearTimeout(waiting);
+      waiting = null;
       offAnchor?.();
       offFocus?.();
       node.defaultCursor = undefined;