react-x11 2.39.0 → 2.41.0

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/components/Menu.js

@@ -24,9 +24,11 @@ import {
   useDismissOnWindowBlur,
 } from './anchor.js';
 import { typeAheadChar, useTypeAhead } from './typeahead.js';
-import { useGlobalMenu } from '../globalmenu.js';
+import { useGlobalMenuExport } from '../globalmenu.js';
 import { acceleratedItem } from '../accelerators.js';
 import { useAcceleratorEntry } from '../acceleratorhooks.js';
+import { useAppOrNull } from '../appcontext.js';
+import { primaryModifier } from '../keysyms.js';
 import { useTopLevelWindow } from '../windowid.js';
 import { MENU_TEXT_WEIGHT } from '../faces.js';
 import {
@@ -121,12 +123,17 @@ function menuMetrics(theme, native, fontSize) {
   };
 }
 
+// `primary` rides along with the sizes because it is one too: the shortcut
+// column is measured from the same string the row then draws — `⌘S` on the
+// Cocoa backend, `Ctrl+S` elsewhere — and the binding matches the key that
+// string names (`useMenuAccelerators`).
 function useMenuMetrics(fontSize) {
   const theme = useTheme();
   const native = useNativeControls();
+  const primary = primaryModifier(useAppOrNull());
   return useMemo(
-    () => menuMetrics(theme, native, fontSize),
-    [theme, native, fontSize],
+    () => ({ ...menuMetrics(theme, native, fontSize), primary }),
+    [theme, native, fontSize, primary],
   );
 }
 
@@ -272,7 +279,9 @@ function menuListWidth(node, items, metrics) {
       size: metrics.fontSize,
       weight: metrics.weight,
     }).width;
-    const accelerator = formatShortcut(item.shortcut);
+    const accelerator = formatShortcut(item.shortcut, {
+      primary: metrics.primary,
+    });
     const shortcut = accelerator
       ? measureLabel(node, accelerator, {
           size: metrics.fontSize,
@@ -471,7 +480,9 @@ function MenuRow({
   }
   const dim = !isEnabled(item);
   const submenu = hasSubmenu(item);
-  const accelerator = formatShortcut(item.shortcut);
+  const accelerator = formatShortcut(item.shortcut, {
+    primary: metrics.primary,
+  });
   const rowInk = dim ? theme.textMuted : active ? theme.hoverText : theme.text;
   if (process.env.NODE_ENV !== 'production') checkShortcut(item);
   return h(
@@ -489,7 +500,9 @@ function MenuRow({
       // the label alone: without it, name-from-contents would read the
       // shortcut and the submenu arrow into the name ("New Ctrl+N")
       'aria-label': typeof item.label === 'string' ? item.label : undefined,
-      'aria-keyshortcuts': ariaKeyShortcuts(item.shortcut),
+      'aria-keyshortcuts': ariaKeyShortcuts(item.shortcut, {
+        primary: metrics.primary,
+      }),
       'aria-checked': item.toggleType
         ? ariaChecked(item.toggleState)
         : undefined,
@@ -922,17 +935,40 @@ function handleMenuKey(
  * `anchorRef` is what the binding hangs off — the bar, or the window when
  * there is no bar to hang off — and decides what a modal `<popup>` takes it
  * away from (`EventManager._runAccelerators`).
+ *
+ * `primary` is the app's primary modifier, so a chord's `Control` is ⌘ on
+ * the Cocoa backend — the key the row prints, and the key the macOS menu
+ * bar installs. Which is where the one exception comes from:
+ * `answeredElsewhere(shortcut)` names the chords a delegate fires the item
+ * for by itself. The bridge hands JS every key *before* AppKit dispatches
+ * it, so ⌘S reaches the window's bindings and then the menu bar's key
+ * equivalent; selecting here too would save twice. So such a chord is
+ * *reserved*: spent before any binding in the window is offered it, this
+ * one included, and left to the menu bar — a `useAccelerator` on ⌘S
+ * mounted after the bar would otherwise be the same double run by another
+ * route. A chord the menu bar cannot spell (F5, a second alternative,
+ * `plus`) is not one, and stays this binding's.
  */
-function useMenuAccelerators(items, select, anchorRef, enabled) {
+function useMenuAccelerators(
+  items,
+  select,
+  anchorRef,
+  { enabled, primary, answeredElsewhere },
+) {
   useAcceleratorEntry(
     anchorRef,
     (ev) => {
-      const item = acceleratedItem(items, ev);
+      const item = acceleratedItem(items, ev, { primary });
       if (!item) return false;
       select(item);
       return true;
     },
     enabled,
+    answeredElsewhere &&
+      ((ev) => {
+        const item = acceleratedItem(items, ev, { primary });
+        return Boolean(item && answeredElsewhere(item.shortcut));
+      }),
   );
 }
 
@@ -970,7 +1006,10 @@ export function ContextMenu({
     onSelect?.(item);
   };
 
-  useMenuAccelerators(items, select, ref, accelerators);
+  useMenuAccelerators(items, select, ref, {
+    enabled: accelerators,
+    primary: metrics.primary,
+  });
 
   // the wrapper keeps the focus the right-click gave it, so `onBlur` below
   // never fires when the *window* loses focus — and the menu is holding a
@@ -1101,7 +1140,10 @@ export function MenuBar({
   // `visible` as a property, so hiding one there is a patch the panel applies
   // rather than a structural change that renumbers everything after it.
   const bar = useMemo(() => visibleItems(menus), [menus]);
-  const delegated = useGlobalMenu(menus, { onSelect, enabled: globalMenu });
+  const { delegated, answersShortcut } = useGlobalMenuExport(menus, {
+    onSelect,
+    enabled: globalMenu,
+  });
 
   // What the bar turned out to be, which is the one thing here that cannot
   // be worked out in a render: layout runs on the frame clock, after the
@@ -1263,7 +1305,11 @@ export function MenuBar({
     }),
     [owner],
   );
-  useMenuAccelerators(menus, select, acceleratorAnchor, accelerators);
+  useMenuAccelerators(menus, select, acceleratorAnchor, {
+    enabled: accelerators,
+    primary: metrics.primary,
+    answeredElsewhere: delegated ? answersShortcut : null,
+  });
 
   const moveMenu = (dir) => {
     if (!entries.length) return;