react-x11 2.51.1 → 2.52.0

package/src/desktopsettings.js

@@ -11,17 +11,30 @@
 //
 // `appearance.js` climbs three sources for colour scheme and accent, because
 // those are answered by three different things and the portal is the modern
-// one. Nothing here has a portal equivalent: `org.freedesktop.appearance` has
-// four keys and none of them is a timing. XSETTINGS is the whole story, and
-// where there is no settings daemon — a bare `startx`, most window managers,
-// XQuartz — the defaults below stand.
+// one. Nothing here has a *standard* portal equivalent:
+// `org.freedesktop.appearance` has four keys and none of them is a timing.
+// On X11, XSETTINGS is the whole story, and where there is no settings
+// daemon — a bare `startx`, most window managers, XQuartz — the defaults
+// below stand.
 //
-// So this reads the map `xsettings.js` already maintains, rather than
-// standing up a source of its own. The one exception is macOS, which has no
-// XSETTINGS and answers exactly one of these — "reduce motion", through
-// `NSWorkspace` — so the Cocoa app exposes that behind a two-method seam
-// (`accessibilityDisplayOptions`, `watchAccessibilityDisplay`) and this
-// module reads it the way it reads the map: synchronously, cached, live.
+// So on X11 this reads the map `xsettings.js` already maintains, rather than
+// standing up a source of its own. There are two exceptions, one per backend
+// that has no X server to ask:
+//
+// - **macOS** answers exactly one of these — "reduce motion", through
+//   `NSWorkspace` — so the Cocoa app exposes that behind a two-method seam
+//   (`accessibilityDisplayOptions`, `watchAccessibilityDisplay`) and this
+//   module reads it the way it reads the map: synchronously, cached, live.
+//
+// - **The Wayland backend** has no XSETTINGS either, but the settings portal
+//   is not limited to `org.freedesktop.appearance`: the GNOME and GTK portal
+//   backends pass whole GSettings schemas through it, and
+//   `org.gnome.desktop.interface` and `org.gnome.desktop.peripherals.mouse`
+//   are exactly what gsd-xsettings translates into the XSETTINGS keys this
+//   reads on X11. Same numbers, one hop closer to the source. Read once at
+//   startup and again on `SettingChanged`; a desktop whose portal does not
+//   carry them (KDE, a bare compositor) keeps the defaults, as a bare
+//   `startx` does.
 //
 // ## Two of these are read synchronously, which is what shapes the module
 //
@@ -34,8 +47,26 @@
 // desktop's cadence from the next focus onward; that is the one seam, and it
 // is worth more than the round trips on every app's startup path.
 
+import { sessionBus } from './bus.js';
+import { desktopIntegrationEnabled } from './desktopintegration.js';
+import { PORTAL_NAME, PORTAL_PATH } from './portal.js';
 import { beginXSettings, watchXSettings, xsettings } from './xsettings.js';
 
+const SETTINGS_IFACE = 'org.freedesktop.portal.Settings';
+const INTERFACE_NS = 'org.gnome.desktop.interface';
+const MOUSE_NS = 'org.gnome.desktop.peripherals.mouse';
+
+/** The keys a `SettingChanged` has to name for a re-read to be worth it —
+ *  `org.gnome.desktop.interface` also carries the clock format, the font
+ *  and the icon theme, and none of those is a reason to re-render. */
+const WATCHED = new Set([
+  `${INTERFACE_NS}/cursor-blink`,
+  `${INTERFACE_NS}/cursor-blink-time`,
+  `${INTERFACE_NS}/enable-animations`,
+  `${MOUSE_NS}/double-click`,
+  `${MOUSE_NS}/drag-threshold`,
+]);
+
 /**
  * What is true with no settings daemon to ask.
  *
@@ -71,24 +102,15 @@ const sessions = new WeakMap();
  *  export a key with a string value or a nonsense one, and a caret with a
  *  blink period of `'fast'` would never come back on. */
 function positive(map, key) {
-  const value = map?.get(key);
+  return positiveValue(map?.get(key));
+}
+
+function positiveValue(value) {
   return typeof value === 'number' && Number.isFinite(value) && value > 0
     ? value
     : undefined;
 }
 
-/**
- * An XSETTINGS map → the settings. Pure, and exported for the test: the
- * in-process X server has no settings daemon, so this is the part of the
- * path worth pinning without one.
- *
- * **`Net/CursorBlinkTime` is a full cycle**, on and off together — that is
- * what GTK means by `gtk-cursor-blink-time` and what every daemon writes —
- * and `caretBlinkMs` is how long the caret stays in *each* state, because
- * that is the number that goes into a timer. Halving it is the whole
- * conversion, and forgetting to is a caret that blinks at half speed and
- * looks broken rather than wrong.
- */
 /**
  * macOS's accessibility display options → the settings. Only `animations`
  * comes from the system there: it is the one of these macOS publishes at all
@@ -105,6 +127,18 @@ export function fromMacOS(options) {
   });
 }
 
+/**
+ * An XSETTINGS map → the settings. Pure, and exported for the test: the
+ * in-process X server has no settings daemon, so this is the part of the
+ * path worth pinning without one.
+ *
+ * **`Net/CursorBlinkTime` is a full cycle**, on and off together — that is
+ * what GTK means by `gtk-cursor-blink-time` and what every daemon writes —
+ * and `caretBlinkMs` is how long the caret stays in *each* state, because
+ * that is the number that goes into a timer. Halving it is the whole
+ * conversion, and forgetting to is a caret that blinks at half speed and
+ * looks broken rather than wrong.
+ */
 export function fromXSettings(map) {
   if (!map) return DEFAULTS;
   const cycle = positive(map, 'Net/CursorBlinkTime');
@@ -134,6 +168,39 @@ export function fromXSettings(map) {
   });
 }
 
+/**
+ * The settings portal's GNOME namespaces → the settings. Pure, and exported
+ * for the test. `all` is a `ReadAll` reply, namespace → key → value.
+ *
+ * The same keys gsd-xsettings turns into the XSETTINGS ones above, so the
+ * same rules: `cursor-blink-time` is a full cycle and is halved, only an
+ * explicit `false` turns blinking or animation off, and a value of the wrong
+ * type is no answer. GNOME has no double-click *distance*; GTK's is a
+ * constant there, so the default stands.
+ *
+ * `null` when neither namespace came back — a portal that does not pass
+ * GSettings through has not answered, and the source stays null.
+ */
+export function fromGnomePortal(all) {
+  const iface = all?.[INTERFACE_NS];
+  const mouse = all?.[MOUSE_NS];
+  if (!iface && !mouse) return null;
+  const cycle = positiveValue(iface?.['cursor-blink-time']);
+  return Object.freeze({
+    ...DEFAULTS,
+    caretBlink: iface?.['cursor-blink'] !== false,
+    caretBlinkMs: cycle
+      ? Math.max(1, Math.round(cycle / 2))
+      : DEFAULTS.caretBlinkMs,
+    doubleClickMs:
+      positiveValue(mouse?.['double-click']) ?? DEFAULTS.doubleClickMs,
+    dragThreshold:
+      positiveValue(mouse?.['drag-threshold']) ?? DEFAULTS.dragThreshold,
+    animations: iface?.['enable-animations'] !== false,
+    source: 'portal',
+  });
+}
+
 /**
  * The settings for a connection, **synchronously**. Always a complete answer:
  * the defaults before the daemon has been read, and on a display with none.
@@ -148,7 +215,9 @@ export function desktopSettings(app) {
   if (!session.snapshot) {
     session.snapshot = session.macos
       ? fromMacOS(app.accessibilityDisplayOptions())
-      : fromXSettings(xsettings(app));
+      : session.wayland
+        ? (fromGnomePortal(session.portal) ?? DEFAULTS)
+        : fromXSettings(xsettings(app));
   }
   return session.snapshot;
 }
@@ -173,6 +242,20 @@ export function beginDesktopSettings(app) {
     });
     return;
   }
+  // The Wayland backend: no X server, so no XSETTINGS — the portal instead,
+  // behind the same switch as the appearance ladder that reads the portal
+  // too. `createRoot({ desktop: false })` keeps the defaults, which is what a
+  // test or an embedder that asked for determinism wants.
+  if (app?.backend === 'wayland') {
+    session.wayland = true;
+    if (desktopIntegrationEnabled('appearance')) {
+      portalSettings(app, session).catch(() => {
+        // no bus, no portal, a portal without the GNOME namespaces: the
+        // defaults stand, which is what they are for
+      });
+    }
+    return;
+  }
   beginXSettings(app).then(
     () => {
       if (!sessions.has(app)) return;
@@ -190,6 +273,92 @@ export function beginDesktopSettings(app) {
   );
 }
 
+/**
+ * Read the GNOME namespaces off the settings portal, and again whenever one
+ * of the keys this cares about changes.
+ *
+ * The order is `appearance.js`'s portal rung, for the same reasons: the
+ * match rule and the handler go in **before** the first read, so a change
+ * that lands while it is in flight is not lost; and reads are sequenced, so
+ * a slow reply never publishes over a newer one. The bus ref is released as
+ * soon as the first read settles — the subscription outlives it, and holding
+ * it would keep the process alive for as long as the app cared how fast its
+ * caret blinks.
+ */
+async function portalSettings(app, session) {
+  const ref = await sessionBus();
+  if (!ref) return;
+  const { bus } = ref;
+  let sub = null;
+  let handler = null;
+  const key = bus.mangle(PORTAL_PATH, SETTINGS_IFACE, 'SettingChanged');
+  const stop = () => {
+    if (handler) bus.signals.removeListener(key, handler);
+    handler = null;
+    sub?.remove().catch(() => {});
+    sub = null;
+  };
+  try {
+    sub = await bus.watch(
+      `type='signal',sender='${PORTAL_NAME}',` +
+        `interface='${SETTINGS_IFACE}',member='SettingChanged'`,
+    );
+
+    let started = 0;
+    let published = 0;
+    const refresh = async () => {
+      const mine = ++started;
+      const all = await bus.invoke(
+        {
+          destination: PORTAL_NAME,
+          path: PORTAL_PATH,
+          interface: SETTINGS_IFACE,
+          member: 'ReadAll',
+          signature: 'as',
+          body: [[INTERFACE_NS, MOUSE_NS]],
+        },
+        { timeout: 5_000 },
+      );
+      if (mine <= published || sessions.get(app) !== session) return;
+      published = mine;
+      const next = fromGnomePortal(all);
+      if (!next) return;
+      const before = desktopSettings(app);
+      session.portal = all;
+      session.snapshot = null;
+      // A re-read that changed nothing this reads notifies nobody: the hook
+      // re-renders on identity, and so would every subscriber.
+      if (!sameSettings(before, desktopSettings(app))) notify(session);
+      else session.snapshot = before;
+    };
+
+    handler = ([namespace, name]) => {
+      if (!WATCHED.has(`${namespace}/${name}`)) return;
+      refresh().catch(() => {
+        // the portal went away mid-session; the last answer stands
+      });
+    };
+    bus.signals.on(key, handler);
+
+    // Torn down while the bus was connecting: undo, and publish nothing.
+    if (sessions.get(app) !== session) return stop();
+    session.stop = stop;
+    await refresh();
+  } catch (err) {
+    stop();
+    throw err;
+  } finally {
+    await ref.release();
+  }
+}
+
+function sameSettings(a, b) {
+  for (const key of Object.keys(DEFAULTS)) {
+    if (a[key] !== b[key]) return false;
+  }
+  return true;
+}
+
 function notify(session) {
   for (const fn of [...session.listeners]) {
     try {

package/src/filedialog.js

@@ -46,14 +46,14 @@ import {
   RESPONSE_CANCELLED,
   RESPONSE_OK,
   hasService,
-  parentWindowHandle,
   pathBytes,
+  portalParentFor,
   portalRequest,
   variant,
 } from './portal.js';
 import { sessionBus } from './bus.js';
 import { liveApps } from './trace-registry.js';
-import { windowIdOf, windowOf } from './windowid.js';
+import { windowOf } from './windowid.js';
 
 const FILE_CHOOSER = 'org.freedesktop.portal.FileChooser';
 
@@ -149,7 +149,7 @@ async function portalDialog(kind, opts, ref) {
   const { response, results } = await portalRequest(ref, {
     iface: FILE_CHOOSER,
     member,
-    parentWindow: parentWindowHandle(windowIdOf(opts.parentWindow)),
+    parentWindow: await portalParentFor(opts.parentWindow),
     title: opts.title ?? defaultTitle(kind),
     options: await portalOptions(opts, {
       save: kind === 'save',

package/src/keyboardstate.js

@@ -32,6 +32,18 @@
 // it answers atoms that have to be interned back one round trip each, and
 // what it returns is a description like `English (US)` where an indicator in
 // a status bar wants `us`.
+//
+// ## A backend with no X server
+//
+// The native Wayland backend has no XKB extension to ask, but its seat holds
+// the same three answers: the locked modifiers and the group from
+// `wl_keyboard.modifiers`, and the layout codes from the name of the keymap
+// the compositor sent (src/wayland/xkb.js, `layoutsFromKeymap`). It hands
+// them over through a two-method seam — `keyboardState()` and
+// `watchKeyboardState(fn)` — and this module publishes what it says the way
+// it publishes a StateNotify. The one difference is the protocol's:
+// a compositor tells only the focused client, so the locks are as of the last
+// time this app had the keyboard.
 
 import { requireExtension } from './extensions.js';
 
@@ -71,6 +83,7 @@ class KeyboardSession {
     this.armed = false;
     this.stopped = false;
     this._handler = null;
+    this._unwatch = null;
   }
 
   publish(values) {
@@ -106,6 +119,8 @@ class KeyboardSession {
 
   stop() {
     this.stopped = true;
+    this._unwatch?.();
+    this._unwatch = null;
     if (this._handler && this.app?.X?.off) {
       try {
         this.app.X.off('event', this._handler);
@@ -157,6 +172,19 @@ async function arm(session) {
   if (session.armed) return;
   session.armed = true;
   const app = session.app;
+
+  // A backend that answers for itself (the Wayland seat): subscribe, then
+  // read, for the same reason the XKB path below does.
+  if (typeof app?.watchKeyboardState === 'function') {
+    const read = () => {
+      const state = !session.stopped && app.keyboardState?.();
+      if (state) session.publish(state);
+    };
+    session._unwatch = app.watchKeyboardState(read);
+    read();
+    return;
+  }
+
   const xkb = await requireExtension(app, 'xkb');
   if (!xkb || session.stopped) return;
 

package/src/node.d.ts

@@ -39,12 +39,13 @@ export interface ImageDataLike {
 }
 
 /**
- * The 2d context a node paints into — the canvas-shaped subset **both**
- * backends implement: ntk's `RenderingContext2D` over XRender on X11, and
- * `BackendContext2D` over CoreGraphics on macOS. Declared as the contract an
- * element may rely on rather than as either class: what is here is on
- * both, and a member one backend has and the other does not is optional
- * here or absent. Coordinates are device pixels in the owning window's
+ * The 2d context a node paints into — the canvas-shaped subset **every**
+ * backend implements: ntk's `RenderingContext2D` over XRender on X11, the
+ * Wayland backend's GLES rasterizer, and `BackendContext2D` over CoreGraphics
+ * on macOS and Direct2D on Windows. Declared as the contract an element may
+ * rely on rather than as any one class: what is here is on all of them, and
+ * a member some backends have and others do not is optional here or
+ * absent. Coordinates are device pixels in the owning window's
  * space — `abs`, `contentBox()` — unless a transform says otherwise.
  * Anything ntk documents beyond this is reachable at runtime and is
  * ntk's to change.
@@ -67,10 +68,9 @@ export interface Context2D {
   shadowOffsetY: number;
   shadowColor: string;
   /**
-   * X11 only: XRender's compositing operator — `'source-over'` (the
-   * default), `'copy'`, and the rest ntk documents. Absent on the cocoa
-   * backend, whose bridge has no blend-mode verb yet; test for it with
-   * `'globalCompositeOperation' in ctx`.
+   * The compositing operator — `'source-over'` (the default), `'copy'`,
+   * and the rest ntk documents on X11. A native context (macOS, Windows)
+   * takes only the modes its bridge draws: assign and read back to know.
    */
   globalCompositeOperation?: string;
   /**

package/src/portal.js

@@ -29,6 +29,7 @@
 // re-solve.
 
 import { loadTransport, sessionBus } from './bus.js';
+import { windowIdOf, windowOf } from './windowid.js';
 
 export const PORTAL_NAME = 'org.freedesktop.portal.Desktop';
 export const PORTAL_PATH = '/org/freedesktop/portal/desktop';
@@ -439,6 +440,36 @@ export function parentWindowHandle(xid) {
   return typeof xid === 'number' && xid > 0 ? `x11:${xid.toString(16)}` : '';
 }
 
+/**
+ * The `parent_window` handle for whatever names a window — a ref, a node, a
+ * backend window, an XID — on whichever backend it belongs to.
+ *
+ * - **X11**: `x11:<xid>`, as `parentWindowHandle` spells it.
+ * - **Wayland**: `wayland:<handle>`, from an xdg-foreign export of the
+ *   toplevel (src/wayland/app.js, `exportHandle`) — what the portal needs to
+ *   make the dialog modal to the window and stack it there. `''` where the
+ *   compositor has no xdg-foreign, or the window is a popup; never an `x11:`
+ *   handle, because a Wayland window's id names no X window, and on a desktop
+ *   running Xwayland it could name somebody else's.
+ *
+ * `app` is the fallback for a target that resolves to no window object — a
+ * bare number on Wayland is that app's id for one of its own windows.
+ *
+ * @param {any} target
+ * @param {any} [app]
+ * @returns {Promise<string>}
+ */
+export async function portalParentFor(target, app = null) {
+  let win = windowOf(target);
+  const owner = win?.app ?? app;
+  if (owner?.backend !== 'wayland') {
+    return parentWindowHandle(windowIdOf(target));
+  }
+  if (!win && typeof target === 'number') win = owner.windowById?.(target);
+  const handle = win ? await owner.exportHandle?.(win) : null;
+  return handle ? `wayland:${handle}` : '';
+}
+
 /**
  * `Variant`, from the one copy of the transport the bus layer loaded.
  *

package/src/screencolor.js

@@ -65,12 +65,11 @@ import {
   PortalCancelledError,
   RESPONSE_OK,
   hasService,
-  parentWindowHandle,
+  portalParentFor,
   portalRequest,
   portalVersion,
 } from './portal.js';
 import { liveApps } from './trace-registry.js';
-import { windowIdOf } from './windowid.js';
 
 export const SCREENSHOT_IFACE = 'org.freedesktop.portal.Screenshot';
 /** `PickColor` arrived in version 2 of the Screenshot interface. */
@@ -220,14 +219,10 @@ async function portalPick(opts, ref) {
     // options)` — no title — which is the whole reason portalRequest takes a
     // signature now.
     signature: 'sa{sv}',
-    // The handle names an X window. A Wayland toplevel has none to name —
-    // an xdg-foreign export would be the equivalent — so there the dialog
-    // floats, which the portal allows.
-    args: [
-      appFor(opts)?.backend === 'wayland'
-        ? ''
-        : parentWindowHandle(windowIdOf(opts.parentWindow)),
-    ],
+    // An X window's handle on X11, an xdg-foreign export on Wayland, and
+    // nothing — a floating dialog, which the portal allows — where neither
+    // can be had.
+    args: [await portalParentFor(opts.parentWindow, appFor(opts))],
     options: {},
     signal: opts.signal,
   });

package/src/types/system.d.ts

@@ -253,16 +253,18 @@ export interface DesktopSettings {
   /** How far a press moves before it is a drag rather than a click. */
   readonly dragThreshold: number;
   /** **False means hold still** — the desktop asked for less motion:
-   *  `Gtk/EnableAnimations` off over XSETTINGS, reduce motion on macOS.
+   *  `Gtk/EnableAnimations` off over XSETTINGS, `enable-animations` off on
+   *  the settings portal (Wayland), reduce motion on macOS.
    *  Core's loops do not start then (docs/styling.md, "Loops"); an element
    *  that animates on a timer of its own holds still too, and draws its
    *  resting frame. True wherever the desktop said nothing. */
   readonly animations: boolean;
-  /** `'xsettings'`; `'macos'` on the Cocoa backend, where only `animations`
-   *  comes from the system (reduce motion) and the rest are the defaults; or
-   *  null where no settings daemon answered and these are the renderer's own
-   *  defaults. */
-  readonly source: 'xsettings' | 'macos' | 'test' | null;
+  /** `'xsettings'`; `'portal'` on the Wayland backend, from the settings
+   *  portal's GNOME namespaces; `'macos'` on the Cocoa backend, where only
+   *  `animations` comes from the system (reduce motion) and the rest are the
+   *  defaults; or null where nothing answered and these are the renderer's
+   *  own defaults. */
+  readonly source: 'xsettings' | 'portal' | 'macos' | 'test' | null;
 }
 
 /**

package/src/wayland/app.js

@@ -104,6 +104,9 @@ export class WaylandApp extends EventEmitter {
     this.viewporter = null;
     this.fractionalScale = null;
     this.activation = null;
+    /** xdg-foreign's exporter: a toplevel's handle for another client to
+     *  parent to (`exportHandle`); null where the compositor has none */
+    this.exporter = null;
     /** the monitors, published into src/screens.js (outputs.js) */
     this.outputs = null;
     /** xdg-decoration, layer-shell, shm: null where the compositor has none */
@@ -153,6 +156,7 @@ export class WaylandApp extends EventEmitter {
     app.viewporter = await conn.bind('wp_viewporter');
     app.fractionalScale = await conn.bind('wp_fractional_scale_manager_v1');
     app.activation = await conn.bind('xdg_activation_v1');
+    app.exporter = await conn.bind('zxdg_exporter_v2');
     // The scale session first, so the outputs have a per-monitor map to
     // fill; then the outputs, awaited like the X11 backend's Xinerama tier:
     // an auto-sized window clamps to a monitor synchronously inside
@@ -304,6 +308,9 @@ export class WaylandApp extends EventEmitter {
   }
 
   _forgetWindow(win) {
+    // before the surface goes: the export is a handle *to* it
+    win._exported?.proxy.$.destroy();
+    win._exported = null;
     if (this.windows.get(win.wl.surface.id) === win)
       this.windows.delete(win.wl.surface.id);
     const i = this.toplevels.indexOf(win);
@@ -510,6 +517,37 @@ export class WaylandApp extends EventEmitter {
     return new WaylandOverlayPane(this, attributes);
   }
 
+  /**
+   * A handle another client can parent a window of its own to — the
+   * portal's `parent_window`, spelled `wayland:<handle>` there — or null.
+   *
+   * xdg-foreign's `export_toplevel`, made once per window on first ask and
+   * kept for its lifetime: the handle is valid for as long as the export
+   * object lives, and a file dialog opened twice from one window should name
+   * it the same way both times. Only an xdg_toplevel can be exported — a
+   * popup or a layer surface is a protocol error, so those answer null, as
+   * does a compositor without the protocol. The dialog then floats, which the
+   * portal allows; what it must never get is an `x11:` handle naming a
+   * Wayland window, which is what it got before this existed.
+   */
+  exportHandle(win) {
+    if (!this.exporter || !win?.wl?.surface || win.isPopup || win.isLayer) {
+      return Promise.resolve(null);
+    }
+    if (win._destroyed) return Promise.resolve(null);
+    if (!win._exported) {
+      const proxy = this.exporter.$.export_toplevel(win.wl.surface.id);
+      const handle = new Promise((resolve) => {
+        proxy.on('handle', (value) => resolve(value || null));
+        // the answer is one round trip away; a compositor that never sends
+        // it is a floating dialog, not a hung one
+        setTimeout(() => resolve(null), 1000).unref?.();
+      });
+      win._exported = { proxy, handle };
+    }
+    return win._exported.handle;
+  }
+
   /**
    * Ask the compositor to activate a window. Stacking is the compositor's;
    * xdg-activation lets a client ask with a token from a recent interaction,
@@ -542,6 +580,27 @@ export class WaylandApp extends EventEmitter {
 
   cancelAttention() {}
 
+  /**
+   * `useKeyboardState()`'s source on this backend: there is no XKB extension
+   * to ask, and the seat has the same answers from `wl_keyboard`
+   * (src/keyboardstate.js, `WaylandSeat.keyboardState`).
+   */
+  keyboardState() {
+    return this.seat?.keyboardState() ?? null;
+  }
+
+  /** Call `fn` when the locks, the group or the keymap change. */
+  watchKeyboardState(fn) {
+    const seat = this.seat;
+    if (!seat) return () => {};
+    seat.on('modifiers', fn);
+    seat.on('keymap', fn);
+    return () => {
+      seat.off('modifiers', fn);
+      seat.off('keymap', fn);
+    };
+  }
+
   async close() {
     for (const w of [...this.windows.values()]) w.destroy();
     this.windows.clear();

package/src/wayland/clipboard.js

@@ -67,17 +67,22 @@ class Selection {
     /** our own source while we own the selection */
     this.source = null;
     this.ownData = null;
-    this._pendingOffers = new Map(); // offer id -> types
+    this._pendingOffers = new Map(); // offer id -> { offer, types }
     /** `watch()` handlers, told when the selection changes hands */
     this.watchers = new Set();
 
     device.on('data_offer', (offer) => {
       const types = [];
-      this._pendingOffers.set(offer.id, types);
+      this._pendingOffers.set(offer.id, { offer, types });
       offer.on('offer', (mime) => types.push(mime));
     });
-    device.on('selection', (offer) => {
-      const id = offer?.id ?? offer;
+    // The offer arrives as an id: an `object` argument is a number off the
+    // wire, where `data_offer`'s `new_id` was a proxy. The proxy is what a
+    // read calls `receive` on, so it is found by the id — keeping the number
+    // made every read throw, and nothing another application copied could
+    // be pasted here.
+    device.on('selection', (offerArg) => {
+      const id = offerArg?.id ?? offerArg ?? 0;
       if (this.offer && this.offer.id !== id) {
         try {
           this.offer.$.destroy();
@@ -85,15 +90,17 @@ class Selection {
           /* gone */
         }
       }
-      if (!offer || offer === 0) {
+      const pending = id ? this._pendingOffers.get(id) : null;
+      this._pendingOffers.delete(id);
+      const offer = pending?.offer ?? (offerArg?.$ ? offerArg : null);
+      if (!offer) {
         this.offer = null;
         this.offerTypes = [];
         this._notify('closed');
         return;
       }
       this.offer = offer;
-      this.offerTypes = this._pendingOffers.get(id) ?? [];
-      this._pendingOffers.delete(id);
+      this.offerTypes = pending?.types ?? [];
       // an offer from our own source means we still own it; anyone else's
       // means we lost it
       if (this.source && !this._isOurs(offer)) this._dropSource();

package/src/wayland/connection.js

@@ -65,6 +65,9 @@ export const PROTOCOLS = [
   'cursor-shape-v1',
   'tablet-v2',
   'xdg-activation-v1',
+  // a handle another client can parent a dialog to — the portal's
+  // `parent_window` (src/portal.js, `portalParentFor`)
+  'xdg-foreign-unstable-v2',
   'xdg-decoration-unstable-v1',
   // the older KDE protocol that does the same job, for the compositors that
   // have only that one (ssd.js picks between them)