react-x11 2.6.1 → 2.8.0

package/src/application.js

@@ -347,6 +347,15 @@ function environmentContext() {
  */
 let current = null;
 
+/**
+ * The schemes the registration declared, kept beside it for the transports
+ * that are not the bus: `deliverOpen` filters an Apple Event's URLs by the
+ * same list an `Open` call is filtered by. Recorded on the no-bus path too —
+ * a Mac with no D-Bus still has a registration's *intent*, and that is the
+ * path the cocoa backend takes.
+ */
+let currentSchemes = null;
+
 const openHandlers = new Set();
 const activateHandlers = new Set();
 
@@ -406,6 +415,36 @@ function drainTo(kind, handler) {
   }
 }
 
+// --------------------------------------------------------------------------
+// The other transports
+// --------------------------------------------------------------------------
+
+/**
+ * A launch that arrived over a transport other than the bus: the cocoa
+ * backend's Apple Events (src/cocoa/app.js), where the OS hands the app its
+ * URLs through `application:openURLs:` and a Dock click on a running app
+ * through `applicationShouldHandleReopen:`. Same scheme filter, same buffer,
+ * same replay to the first handler — one code path in the app whichever
+ * desktop launched it.
+ *
+ * Not public: a transport calls this, an app subscribes with `onAppOpen`.
+ * `platformData` is whatever that transport knows about the launch. Apple
+ * Events carry no startup id and no timestamp, and the context says so with
+ * nulls rather than inventing them — on that backend the raise needs neither
+ * (`activateWindow` is `NSApp.activate` there).
+ */
+export function deliverOpen(uris, platformData = {}) {
+  const accepted = acceptUris(uris, currentSchemes);
+  if (accepted.length === 0) return;
+  debug(`open from the platform: ${accepted.map(redactUri).join(', ')}`);
+  deliver({ kind: 'open', uris: accepted, ctx: launchContext(platformData) });
+}
+
+/** The platform asked this app to come forward with nothing to open. */
+export function deliverActivate(platformData = {}) {
+  deliver({ kind: 'activate', ctx: launchContext(platformData) });
+}
+
 /**
  * Be told when the desktop hands this app URIs to open.
  *
@@ -541,6 +580,7 @@ export async function registerApplication(options = {}) {
   const appId = checkAppId(options.appId);
   const schemes = checkSchemes(options.schemes);
   const objectPath = objectPathForAppId(appId);
+  currentSchemes = schemes;
 
   if (current) {
     // An app has one identity; two registrations would be two RequestNames and
@@ -742,6 +782,7 @@ export function currentRegistration() {
 /** Test seam, not public: forget every handler, buffer and registration. */
 export function _resetApplicationState() {
   current = null;
+  currentSchemes = null;
   openHandlers.clear();
   activateHandlers.clear();
   buffered = [];

package/src/cocoa/app.js

@@ -14,15 +14,22 @@
 // measured upgrade, not the first version.
 import { cssColorStraight } from 'ntk';
 
+import { deliverActivate, deliverOpen } from '../application.js';
 import { flushPendingFrames } from '../frames.js';
+import { flushSyncWork } from '../priority.js';
 import { setCompositingForTests } from '../compositing.js';
 import { setScreensForTests } from '../screens.js';
 import { setScaleForTests } from '../scale.js';
 import { BezelStore } from './bezels.js';
 import { CocoaGLArea, cocoaGLConfig, resolveCocoaGLRuntime } from './glarea.js';
+import { CocoaDockMenu } from './dock.js';
 import { CocoaGlobalMenuExport } from './globalmenu.js';
+import { CocoaStatusItem } from './statusitem.js';
+import { CocoaNotifications } from './notifications.js';
 import { CocoaPaneHost } from './panehost.js';
+import { CocoaPermissions } from './permissions.js';
 import { CocoaPaneWindow } from './panewindow.js';
+import { CocoaFilePanels } from './filepanels.js';
 import { CocoaFontManager } from './fonts.js';
 import { CocoaSurface } from './surface.js';
 import { CocoaWindow } from './window.js';
@@ -55,6 +62,12 @@ export class CocoaApp {
     // window paces itself on its own display (`frameIntervalFor`)
     this._frameInterval = options.cocoa?.frameInterval ?? null;
     this._pumpInterval = PUMP_INTERVAL_MS;
+    // src/desktopsettings.js's subscribers to the accessibility display
+    // options — "reduce motion" — which arrive as a backend event
+    this._a11yListeners = new Set();
+    // the layer presenter's animations, by the id the bridge reports their
+    // end under (`animation-end`, src/cocoa/presenter.js)
+    this._animationEnds = new Map();
     // the one-shot that runs a frame due between two pump ticks, and when
     // it is due (`_armFrameTimer`)
     this._frameTimer = null;
@@ -63,23 +76,82 @@ export class CocoaApp {
     this._shadowStale = new Set();
     this._pump = null;
     this._closed = false;
+    // the DragSession whose gesture an NSDraggingSession is tracking; a drop
+    // on one of our own windows is routed to its live payload
+    this._activeDrag = null;
+    // set by a quit request; read by close() to end the process
+    this._quitting = false;
+
+    // The activation policy has to be fixed before the app finishes
+    // launching — a Regular launch registers a Dock tile, so an agent app
+    // that switched afterwards would already have flashed its icon — and
+    // `listScreens` below is the first native call that launches it. So the
+    // policy goes first, through `initApp`'s option (bridge >= 0.5), and
+    // only when the root asked for one: a bridge without the option, or a
+    // fake, is left alone.
+    const policy = options.cocoa?.activationPolicy;
+    if (policy != null && typeof native.initApp === 'function') {
+      native.initApp({ activationPolicy: policy });
+    }
 
     const screens = native.listScreens();
     this.scale = screens[0]?.scale ?? 1;
     this._screens = screens;
 
+    // The name the Dock, ⌘-Tab and the menu bar print. An unbundled
+    // process is registered with LaunchServices under its executable —
+    // `node` — and this renames that record; a bundle's Info.plist wins
+    // (the bridge answers false and leaves it).
+    const appName = options.cocoa?.appName;
+    if (appName != null && typeof native.setAppName === 'function') {
+      native.setAppName(String(appName));
+    }
+
+    // The Dock menu (src/cocoa/dock.js), installed by `useDockMenu`.
+    this._dockMenu = new CocoaDockMenu(this);
+    // The tray items (src/cocoa/statusitem.js), by the bridge's handle —
+    // which is what a click event names them by.
+    this._statusItems = new Map();
+
     // 'surface' (the measured default) or 'layers' — the retained CALayer
     // presenter, opt-in while docs/macos.md's measure-first gate is open.
     this._presenterMode =
       options.cocoa?.presenter ??
       process.env.REACT_X11_COCOA_PRESENTER ??
       'surface';
+    // With the surface presenter, whether the nodes that animate get a
+    // layer of their own above the bitmap (src/cocoa/promotion.js). On by
+    // default — an animation the render server runs survives a busy JS
+    // thread, and the bitmap keeps the frame for everything else — where
+    // the bridge draws a layer's colour and a rastered one the same, which
+    // it says with `colorSpace()` (@windowkit/appkit >= 0.5.1, the range
+    // package.json asks for): before it a layer's colour was Generic RGB
+    // against sRGB surfaces, and a node moving between its layer and the
+    // bitmap changed shade on the way.
+    // Off (`cocoa.promote: false`, REACT_X11_COCOA_PROMOTE=0) keeps every
+    // animation on the frame clock, which is what the presenter bench's
+    // `surface` column measures; on (`true`, `=1`) is on regardless.
+    const promoteEnv = process.env.REACT_X11_COCOA_PROMOTE;
+    this._promote =
+      options.cocoa?.promote ??
+      (promoteEnv === '1' ||
+        (promoteEnv !== '0' && native.colorSpace?.() === 'sRGB'));
 
     // the app's own bridge, so an app over a fake one (the tests) needs no
     // real bridge on the machine — the manager's default loads it only when
     // it is built standalone
     this.fonts = new CocoaFontManager(native);
 
+    // Native open/save panels (src/cocoa/filepanels.js). Present exactly
+    // when the bridge has them (>= 0.5), and its presence is what puts the
+    // top rung on src/filedialog.js's ladder for this app — a fake bridge
+    // without `openPanel`, or an older one, leaves the ladder as it was.
+    this.filePanels =
+      typeof native.openPanel === 'function' &&
+      typeof native.savePanel === 'function'
+        ? new CocoaFilePanels(this)
+        : null;
+
     // AppKit-rendered control bezels. Its *presence* is the capability:
     // `useSupports('nativeControls')` and the widget set's `controls:
     // 'auto'` policy both test for this property, so a backend without it
@@ -87,6 +159,24 @@ export class CocoaApp {
     // branching.
     this.nativeBezels = new BezelStore(native);
 
+    // macOS privacy authorizations (src/cocoa/permissions.js). Present
+    // exactly when the bridge has them (>= 0.5), and its presence is the
+    // rung src/permissions.js finds for this app.
+    this.permissions =
+      typeof native.authorizationStatus === 'function' &&
+      typeof native.requestAuthorization === 'function'
+        ? new CocoaPermissions(native)
+        : null;
+
+    // The notification centre (src/cocoa/notifications.js). Present exactly
+    // when the bridge has it (>= 0.5); whether it can *deliver* — a bundle
+    // id — is its own `available()`, the second gate the ladder asks.
+    this.notifications =
+      typeof native.postNotification === 'function' &&
+      typeof native.notificationSettings === 'function'
+        ? new CocoaNotifications(this)
+        : null;
+
     // The GL policy, glbackend.js's shape. No GLX exists here, so the
     // default is 'auto' (the direct backend where the runtime loads);
     // useSupports('shaders') stays false until the first <glarea> resolves
@@ -293,6 +383,87 @@ export class CocoaApp {
     return fps > 0 ? 1000 / fps : RAF_INTERVAL_MS;
   }
 
+  /**
+   * Bring this app and one of its windows to the front — the cocoa answer to
+   * `activateWindow()` (src/activate.js), the raise a deep link's
+   * `useAppOpen`/`useAppActivate` handler performs.
+   *
+   * There is no window manager here and no `_NET_ACTIVE_WINDOW` to send:
+   * `activateApp()` is `NSApp.activate` and `showWindow(h, true)` re-issues
+   * `makeKeyAndOrderFront:`, which is the whole of a raise on this backend.
+   * The X11 path weighs a launch timestamp against focus-stealing
+   * prevention; macOS has no such negotiation from a client, so the
+   * timestamp is not a parameter here.
+   *
+   * `target` is whatever `activate.js` resolved — a `CocoaWindow`, the
+   * `WindowNode` that owns one, or nothing when there is no window to raise.
+   * Returns whether a window was actually raised, matching the X path's
+   * "was the request issued" contract (and so *not* the false success the
+   * no-op `X.SendClientMessage` stub would report).
+   */
+  raiseWindow(target) {
+    if (this._closed) return false;
+    const wnd = target && target._h != null ? target : (target?.window ?? null);
+    if (!wnd || wnd.destroyed || wnd._h == null) return false;
+    this._native.activateApp();
+    this._native.showWindow(wnd._h, true);
+    return true;
+  }
+
+  // --- the Dock tile ---------------------------------------------------------
+
+  /**
+   * The badge on the Dock tile — `setBadge()`'s first rung (src/launcher.js),
+   * which finds it by this method's presence. `null` clears.
+   */
+  setDockBadge(label) {
+    this._native.setDockBadge(label == null ? null : String(label));
+  }
+
+  /** The menu behind a right-click on the Dock icon — `useDockMenu()`. */
+  setDockMenu(items) {
+    this._dockMenu.update(items);
+  }
+
+  /**
+   * Bounce the Dock icon until the app is activated — the cocoa answer to a
+   * window's `demands_attention` state (src/cocoa/window.js `setWmState`).
+   * AppKit ignores the request while the app is already active, which is
+   * the same outcome a window manager gives a focused window's urgency.
+   */
+  requestAttention() {
+    return this._native.requestUserAttention('critical');
+  }
+
+  cancelAttention(requestId) {
+    this._native.cancelUserAttention(requestId);
+  }
+
+  // --- the tray --------------------------------------------------------------
+
+  /**
+   * An `NSStatusItem` — `useTray()`'s mechanism, found by this method's
+   * presence (the X11 backend has none, and the hook says so). Returns the
+   * item; `remove()` on it is the whole of its teardown.
+   */
+  createStatusItem(options) {
+    const item = new CocoaStatusItem(this, options);
+    this._statusItems.set(item.handle, item);
+    const remove = item.remove.bind(item);
+    item.remove = () => {
+      this._statusItems.delete(item.handle);
+      remove();
+    };
+    return item;
+  }
+
+  /** A `menu-activate` tagged `status`: the item whose menu owns the id. */
+  _routeStatusMenu(id) {
+    for (const item of this._statusItems.values()) {
+      if (item.owns(id)) return item.activate(id);
+    }
+  }
+
   /**
    * The pane's end of the frame channel (childmain hands it over,
    * feature-detected so the X11 pane path never notices): geometry and
@@ -485,9 +656,21 @@ export class CocoaApp {
     for (const wnd of this._windows.values()) wnd.present();
   }
 
-  /** After any synchronously dispatched input: paint the response now (the
-   * same early flush a discrete event gets on X11) and put it on glass. */
+  /**
+   * After any synchronously dispatched input: land React's half of the
+   * response, paint it (the same early flush a discrete event gets on X11 —
+   * `discrete` in events.js) and put it on glass.
+   *
+   * `flushSyncWork` is not belt and braces. A discrete-priority update is
+   * committed on a **microtask**, and a microtask does not run until the
+   * call that dispatched the event returns to Node — which, inside one of
+   * AppKit's modal loops (a live resize, menu tracking, a dragging
+   * session), is after the whole gesture. Without it a handler's own
+   * `setState` reaches the screen when the gesture ends, and the gesture is
+   * exactly when it was worth showing.
+   */
   _afterInput() {
+    flushSyncWork();
     flushPendingFrames();
     this._presentAll();
   }
@@ -523,8 +706,49 @@ export class CocoaApp {
       case 'window-occlusion':
         return this._routeOcclusion(ev);
       case 'menu-activate':
-        this._activeGlobalMenu?.activate(ev.id);
+        // `menu` says which tree the id belongs to (bridge >= 0.5): the
+        // Dock menu and the menu bar allocate ids independently. Absent on
+        // an older bridge, where only the bar exists.
+        if (ev.menu === 'dock') this._dockMenu.activate(ev.id);
+        else if (ev.menu === 'status') this._routeStatusMenu(ev.id);
+        else this._activeGlobalMenu?.activate(ev.id);
+        return this._afterInput();
+      case 'status-item-click':
+        this._statusItems.get(ev.statusItem)?.click(ev);
         return this._afterInput();
+      case 'accessibility-display-changed':
+        return this._routeAccessibility(ev);
+      case 'drag-enter':
+      case 'drag-over':
+      case 'drag-exit':
+      case 'drag-perform':
+        return this._routeDrop(ev);
+      case 'drag-session-began':
+        // `draggingSession:willBeginAtPoint:`, dispatched from inside
+        // `beginDrag` — before the `onDragStart` handler's own render has
+        // been asked for, so there is nothing to flush yet. The frame that
+        // shows the drag beginning goes out from `CocoaWindow.beginDrag`,
+        // on the way back past it.
+        return undefined;
+      case 'drag-session-moved':
+        return this._routeDragMoved(ev);
+      case 'drag-session-ended':
+        return this._routeDragEnded(ev);
+      case 'app-open-urls':
+        return this._routeAppOpen(ev);
+      case 'app-reopen':
+        return this._routeAppReopen(ev);
+      case 'app-quit-request':
+        return this.requestQuit();
+      case 'notification-action':
+      case 'notification-dismissed':
+        this.notifications?.route(ev);
+        return this._afterInput();
+      case 'animation-end':
+        // the presenter that added the animation registered for its id; an
+        // id nobody knows is an animation already forgotten (cancelled, or
+        // its layer dropped), and the bridge's report is just late
+        return this._animationEnds.get(ev.id)?.(ev);
       default:
         return undefined;
     }
@@ -689,6 +913,62 @@ export class CocoaApp {
     wnd._occluded = ev.visible === false;
   }
 
+  _routeAccessibility(ev) {
+    for (const fn of [...this._a11yListeners]) fn(ev);
+  }
+
+  /**
+   * System Settings › Accessibility › Display, as the bridge reports it —
+   * `{ reduceMotion, reduceTransparency, increaseContrast,
+   * differentiateWithoutColor, invertColors }` — or null over a bridge (or
+   * a test fake) that does not answer. The seam src/desktopsettings.js reads
+   * "reduce motion" through; `watchAccessibilityDisplay` is its other half.
+   */
+  accessibilityDisplayOptions() {
+    return this._native.accessibilityDisplayOptions?.() ?? null;
+  }
+
+  /** Subscribe to the options changing while the app runs. */
+  watchAccessibilityDisplay(fn) {
+    this._a11yListeners.add(fn);
+    return () => this._a11yListeners.delete(fn);
+  }
+
+  /**
+   * AppKit's four destination questions, answered inside the callback: the
+   * window's transport (src/cocoa/dnd.js) drives its DropSession and sets
+   * the response before this returns. A frame is flushed on the way out,
+   * like a click's — `:drag-over` is a repaint.
+   */
+  _routeDrop(ev) {
+    const wnd = this._window(ev);
+    if (!wnd || wnd.destroyed) return;
+    wnd._dropTransport?.handle(ev);
+    this._afterInput();
+  }
+
+  /**
+   * `draggingSession:movedToPoint:` — the source's own view of the gesture,
+   * and the only thing that arrives while AppKit tracks it: the pointer's
+   * `mousemove` stops, `pump2` does not return until the drop, and no timer
+   * or microtask of ours runs in between. So the frame belongs to the
+   * callback, like the destination's (`_routeDrop`) — that is what lets a
+   * `<popup dragPreview>` follow the pointer, and an `onDrag` that moves an
+   * insertion marker move it during the drag rather than on the release.
+   */
+  _routeDragMoved(ev) {
+    this._activeDrag?.nativeMoved(ev);
+    this._afterInput();
+  }
+
+  /** The release of a drag AppKit was tracking for us. */
+  _routeDragEnded(ev) {
+    const drag = this._activeDrag;
+    this._activeDrag = null;
+    drag?.nativeEnded(ev);
+    this._afterInput();
+  }
+
   _routeClose(ev) {
     const wnd = this._window(ev);
     if (!wnd) return;
@@ -706,6 +986,82 @@ export class CocoaApp {
     this._afterInput();
   }
 
+  // --- the application as a whole ------------------------------------------
+  //
+  // What the OS asks the app rather than one of its windows, through the
+  // NSApplicationDelegate the bridge installs (>= 0.5). The bridge decides
+  // nothing — it answers `applicationShouldHandleReopen:` NO and
+  // `applicationShouldTerminate:` Cancel and hands the question over — so
+  // each of these is the renderer's decision, and the decisions are the ones
+  // the freedesktop transport already made (src/application.js): a URL is an
+  // `Open`, a second launch is an `Activate`, and quitting is what closing
+  // the app's primary window means. Anything that arrived before the
+  // callback was installed — the launching Apple Event lands inside
+  // `initApp()` — the bridge holds and replays on the first pump.
+
+  /**
+   * `application:openURLs:` — a URL for a scheme the bundle's `Info.plist`
+   * registers, or a document the Finder handed over as `file://`. Delivered
+   * through the same filter, buffer and replay a D-Bus `Open` takes, so
+   * `useAppOpen` fires the same way here.
+   */
+  _routeAppOpen(ev) {
+    const urls = Array.isArray(ev.urls)
+      ? ev.urls.filter((u) => typeof u === 'string')
+      : [];
+    deliverOpen(urls, {});
+  }
+
+  /**
+   * `applicationShouldHandleReopen:` — the user launched the app again while
+   * it was running (a Dock click, `open -a`). AppKit has already brought
+   * the windows forward by the time this arrives; what a second launch
+   * *means* is the app's, through `useAppActivate`, and `has-visible-windows`
+   * on the context is the one fact the OS adds.
+   */
+  _routeAppReopen(ev) {
+    deliverActivate({ 'has-visible-windows': ev.hasVisibleWindows === true });
+  }
+
+  /**
+   * Quit, from wherever macOS says it: the Dock's Quit, ⌘Q on the app menu, a
+   * logout. One route for all of them, and it is the **primary window's
+   * close request** — `onCloseRequest` where the app wrote one (a "save your
+   * work?" dialog is a veto until it decides), the default otherwise, which
+   * unmounts the tree. Quit means what closing the app's window means on
+   * every desktop, rather than a second, faster exit that skips the same
+   * question.
+   *
+   * With no window to ask — an accessory app between windows — the tree
+   * unmounts directly.
+   *
+   * The bridge has already answered `applicationShouldTerminate:` with
+   * Cancel, so the process outliving the tree is this side's to end: when a
+   * quit request leads to the app closing, `close()` exits the process
+   * (`cocoa.exitOnQuit`, on by default — a Regular-policy process that is
+   * still alive is still in the Dock, and a Dock tile for an app whose
+   * windows are all gone is what a user calls a hang).
+   */
+  requestQuit() {
+    if (this._closed) return;
+    this._quitting = true;
+    const windows = [...this._windows.values()].filter(
+      (w) => !w.destroyed && !w._popup,
+    );
+    const primary =
+      windows.find((w) => w._reactX11Node?._isPrimaryWindow?.()) ??
+      windows[0] ??
+      null;
+    if (primary) {
+      primary.emit('close', { preventDefault() {} });
+    } else {
+      Promise.resolve(this._reactX11Root?.unmount?.()).catch((err) => {
+        this.options?.onXError?.(err);
+      });
+    }
+    this._afterInput();
+  }
+
   // --- teardown ------------------------------------------------------------
 
   close() {
@@ -719,6 +1075,14 @@ export class CocoaApp {
     this._cocoaGL = null;
     this._native.setBackendEventCallback(null);
     for (const wnd of [...this._windows.values()]) wnd.destroy();
+    // A quit the app accepted: the tree is down and the connection closed,
+    // and macOS is still waiting on the Cancel the bridge answered with. End
+    // the process on the next turn — after the unmount's own microtasks —
+    // rather than leaving a Dock tile with nothing behind it. `exitOnQuit:
+    // false` is the seam for an embedder that owns the process's lifetime.
+    if (this._quitting && this.options?.cocoa?.exitOnQuit !== false) {
+      setImmediate(() => process.exit(0));
+    }
     return Promise.resolve();
   }
 }

package/src/cocoa/bezels.js

@@ -26,6 +26,22 @@ export class BezelStore {
     this._MAX = 160;
   }
 
+  /**
+   * Forget every rendered bezel. The pixels depend on one thing that is not
+   * a parameter of `get`: the desktop's accent, which AppKit reads for
+   * itself when it draws the cell. After the user picks another accent a
+   * cached bezel is the old colour, and its key still matches — so a bezel
+   * whose state happened to change came up in the new accent while the
+   * ones beside it kept the old, until something else redrew them. The
+   * appearance change forgets them all; the next paint renders each again.
+   *
+   * The measured insets and natural sizes stay: geometry is not coloured.
+   */
+  clear() {
+    // the surfaces are freed by their External finalizer
+    this._cache.clear();
+  }
+
   /**
    * The control's natural size in logical px — the size the bezel is
    * designed at, which layout adopts for the kinds that must not stretch
@@ -40,6 +56,21 @@ export class BezelStore {
     };
   }
 
+  /**
+   * The translucent rows above and below the bezel's solid body, in logical
+   * px — a push button's drop shadow, mostly. They are part of the natural
+   * box (`natural` measures every inked pixel, so the box is the footprint)
+   * and not part of the control: AppKit centres a title in the cell's body,
+   * and a label centred in the footprint sits half the shadow too low.
+   */
+  shadow(kind, controlSize = 'regular') {
+    const c = this._scan(kind, controlSize, 2);
+    return {
+      top: Math.round(c.body.top),
+      bottom: Math.round(c.body.bottom),
+    };
+  }
+
   /**
    * The bezel for one laid-out box: `w`/`h` in device px, blit-ready.
    * Returns `{ surface, sx, sy, sw, sh }` — draw with the 9-arg
@@ -126,14 +157,23 @@ export class BezelStore {
     let y0 = ph;
     let x1 = -1;
     let y1 = -1;
+    // and the solid body inside the footprint: where the bezel is opaque,
+    // which is the control itself rather than its shadow
+    let by0 = ph;
+    let by1 = -1;
     for (let y = 0; y < ph; y++) {
       for (let x = 0; x < pw; x++) {
-        if (buf[(y * pw + x) * 4 + 3] > 8) {
+        const alpha = buf[(y * pw + x) * 4 + 3];
+        if (alpha > 8) {
           if (x < x0) x0 = x;
           if (x > x1) x1 = x;
           if (y < y0) y0 = y;
           if (y > y1) y1 = y;
         }
+        if (alpha >= 250) {
+          if (y < by0) by0 = y;
+          if (y > by1) by1 = y;
+        }
       }
     }
     if (x1 < 0) {
@@ -143,6 +183,12 @@ export class BezelStore {
       x1 = pw - 1;
       y1 = ph - 1;
     }
+    if (by1 < 0) {
+      // no solid pixel at all (a fully translucent bezel): the body is the
+      // footprint
+      by0 = y0;
+      by1 = y1;
+    }
     c = {
       insets: {
         left: x0 / scale,
@@ -154,6 +200,10 @@ export class BezelStore {
         width: (x1 - x0 + 1) / scale,
         height: (y1 - y0 + 1) / scale,
       },
+      body: {
+        top: (by0 - y0) / scale,
+        bottom: (y1 - by1) / scale,
+      },
     };
     this._canonical.set(key, c);
     return c;