react-x11 2.15.1 → 2.15.3

package/src/dbusmenuexport.js

@@ -0,0 +1,243 @@
+// Serving `com.canonical.dbusmenu`: the half of the protocol that is the same
+// wherever the menu is hung.
+//
+// `dbusmenu.js` is the pure part — ids, snapshots, the diff — and says why
+// each of those is hard. This is the object that answers for it on a bus:
+// `GetLayout`, the property reads, `Event`, `AboutToShow`, and the two update
+// signals. Nothing here knows *why* a menu is exported, and that is the point.
+//
+// It was extracted from `GlobalMenuExport` when the tray arrived
+// (react-x11#353), because a panel menu and a tray menu differ only in how the
+// desktop is told where the menu is:
+//
+//   - a **global menu** registers a *window* with `AppMenu.Registrar`, and
+//     follows the registrar's ownership so the bar moves back into the window
+//     when the panel exits (`globalmenu.js`);
+//   - a **tray menu** is named by the `Menu` property of a StatusNotifierItem
+//     and has no window at all (`statusnotifier.js`).
+//
+// Both serve the identical tree. Subclasses own the bus lifecycle — when to
+// export, what to register, when to withdraw — and inherit everything below.
+
+import {
+  DBUSMENU_IFACE,
+  PROPERTY_TYPES,
+  diffSnapshots,
+  groupProperties,
+  layoutOf,
+  snapshot,
+  IdAllocator,
+} from './dbusmenu.js';
+
+/** dbusmenu's recursive layout struct: `(id, properties, children)`. */
+export const LAYOUT_SIGNATURE = '(ia{sv}av)';
+
+/**
+ * A menu tree, serialised and served.
+ *
+ * `getMenus()` is read at construction and on every `update()`; `onSelect` and
+ * `onAboutToShow` receive the *item object* the app authored, not an id, so a
+ * caller never deals in dbusmenu's numbering.
+ */
+export class DbusMenuExport {
+  constructor({ getMenus, onSelect, onAboutToShow }) {
+    this.getMenus = getMenus;
+    this.onSelect = onSelect;
+    this.onAboutToShow = onAboutToShow;
+
+    this.alloc = new IdAllocator();
+    this.nodes = snapshot(getMenus(), this.alloc);
+    this.revision = 1;
+
+    /** Set by the subclass once the object is actually on a bus: until then
+     *  `update()` must not emit, because nobody is listening and the
+     *  revision would run ahead of the first `GetLayout`. */
+    this.exported = false;
+    this.iface = null;
+    this.dbus = null;
+  }
+
+  // ----------------------------------------------------------------- update
+
+  /**
+   * A new `menus` array. Serialise, diff, and send the *narrower* of the two
+   * signals the protocol has — see `diffSnapshots`, where the choice is made
+   * and why it matters.
+   */
+  update(menus) {
+    const next = snapshot(menus, this.alloc);
+    const change = diffSnapshots(this.nodes, next);
+    this.nodes = next;
+    if (!this.exported || change.kind === 'none') return;
+
+    if (change.kind === 'properties') {
+      this.iface?.emit.ItemsPropertiesUpdated(
+        change.updated.map(([id, props]) => [id, this.wrap(props)]),
+        change.removed,
+      );
+      return;
+    }
+    this.revision += 1;
+    this.iface?.emit.LayoutUpdated(this.revision, change.parent);
+  }
+
+  /** Plain property values → the `a{sv}` the wire wants. */
+  wrap(props) {
+    const out = {};
+    for (const [name, value] of Object.entries(props)) {
+      const type = PROPERTY_TYPES[name];
+      if (type) out[name] = new this.dbus.Variant(type, value);
+    }
+    return out;
+  }
+
+  /** `layoutOf`'s plain tree → the recursive `(ia{sv}av)`. */
+  wrapLayout(node) {
+    const [id, props, children] = node;
+    return [
+      id,
+      this.wrap(props),
+      children.map(
+        (child) =>
+          new this.dbus.Variant(LAYOUT_SIGNATURE, this.wrapLayout(child)),
+      ),
+    ];
+  }
+
+  // --------------------------------------------------------------- protocol
+
+  itemFor(id) {
+    return this.nodes.get(id)?.item ?? null;
+  }
+
+  defineMenu(dbus) {
+    this.dbus = dbus;
+    const fire = (id, eventId) => {
+      const item = this.itemFor(id);
+      if (!item) return;
+      if (eventId === 'clicked') this.onSelect?.(item);
+      else if (eventId === 'opened') this.onAboutToShow?.(item);
+    };
+
+    return dbus.defineInterface({
+      name: DBUSMENU_IFACE,
+      methods: {
+        GetLayout: {
+          in: { parentId: 'i', recursionDepth: 'i', propertyNames: 'as' },
+          out: { revision: 'u', layout: LAYOUT_SIGNATURE },
+          handler: ({ parentId, recursionDepth, propertyNames }) => {
+            const tree = layoutOf(
+              this.nodes,
+              parentId,
+              recursionDepth ?? -1,
+              propertyNames,
+            );
+            // An id the shell remembers from before a structural change is the
+            // normal way to arrive here, not a protocol violation: answer with
+            // an empty item rather than an error, and let the LayoutUpdated it
+            // has already been sent bring it back for the real tree.
+            return {
+              revision: this.revision,
+              layout: this.wrapLayout(tree ?? [parentId, {}, []]),
+            };
+          },
+        },
+        GetGroupProperties: {
+          in: { ids: 'ai', propertyNames: 'as' },
+          out: { properties: 'a(ia{sv})' },
+          handler: ({ ids, propertyNames }) =>
+            groupProperties(this.nodes, ids, propertyNames).map(
+              ([id, props]) => [id, this.wrap(props)],
+            ),
+        },
+        GetProperty: {
+          in: { id: 'i', name: 's' },
+          out: { value: 'v' },
+          handler: ({ id, name }) => {
+            const props = this.nodes.get(id)?.props;
+            // `hasOwn` on both, so a name like `constructor` reads as absent
+            // rather than as a function that then fails to marshal.
+            const known = Object.hasOwn(PROPERTY_TYPES, name);
+            const value =
+              props && Object.hasOwn(props, name) ? props[name] : undefined;
+            // A property this item does not carry is at its default, and the
+            // spec's own advice is to answer with it rather than to error.
+            if (value === undefined || !known) return new dbus.Variant('s', '');
+            return new dbus.Variant(PROPERTY_TYPES[name], value);
+          },
+        },
+        Event: {
+          in: { id: 'i', eventId: 's', data: 'v', timestamp: 'u' },
+          out: {},
+          handler: ({ id, eventId }) => fire(id, eventId),
+        },
+        EventGroup: {
+          in: { events: 'a(isvu)' },
+          out: { idErrors: 'ai' },
+          handler: ({ events }) => {
+            const errors = [];
+            for (const [id, eventId] of events ?? []) {
+              if (this.itemFor(id)) fire(id, eventId);
+              else errors.push(id);
+            }
+            return errors;
+          },
+        },
+        AboutToShow: {
+          in: { id: 'i' },
+          out: { needUpdate: 'b' },
+          handler: ({ id }) => this.aboutToShow(id),
+        },
+        AboutToShowGroup: {
+          in: { ids: 'ai' },
+          out: { updatesNeeded: 'ai', idErrors: 'ai' },
+          handler: ({ ids }) => {
+            const errors = [];
+            for (const id of ids ?? []) {
+              if (this.itemFor(id)) this.aboutToShow(id);
+              else errors.push(id);
+            }
+            return { updatesNeeded: [], idErrors: errors };
+          },
+        },
+      },
+      properties: {
+        Version: { type: 'u', access: 'read', get: () => 3 },
+        Status: { type: 's', access: 'read', get: () => 'normal' },
+        TextDirection: { type: 's', access: 'read', get: () => 'ltr' },
+        // Empty, and not a placeholder: `icon-name` is looked up in the
+        // desktop's own theme, which is where an app's icons should come from.
+        // A path here would be for icons shipped beside the app.
+        IconThemePath: { type: 'as', access: 'read', get: () => [] },
+      },
+      signals: {
+        LayoutUpdated: { args: { revision: 'u', parent: 'i' } },
+        ItemsPropertiesUpdated: {
+          args: { updated: 'a(ia{sv})', removed: 'a(ias)' },
+        },
+        ItemActivationRequested: { args: { id: 'i', timestamp: 'u' } },
+      },
+    });
+  }
+
+  /**
+   * The reply has to go out **now**, and React has not rendered yet.
+   *
+   * `setState` from here does not produce a new tree before this function
+   * returns, so there is no honest way to answer `true` — and answering `true`
+   * dishonestly is worse than answering `false`: the shell then blocks on a
+   * `GetLayout` for a subtree that has not been built, gets the old one, and
+   * caches it.
+   *
+   * So: answer `false`, let the handler run, and let the ordinary update path
+   * emit `LayoutUpdated` when the new items actually serialise. Shells listen
+   * for that unconditionally — it is the same signal a menu changing while
+   * open produces — so a lazily-built submenu still fills in, one round trip
+   * later than a synchronous toolkit would manage.
+   */
+  aboutToShow(id) {
+    const item = this.itemFor(id);
+    if (item) this.onAboutToShow?.(item);
+    return false;
+  }
+}

package/src/desktopcapabilityhooks.js

@@ -0,0 +1,137 @@
+// `useDesktopCapability()` — what this desktop can do, as render state.
+//
+// The vocabulary and the probes are `capabilities.js`; this is the part that
+// makes them safe to branch on inside a component. Three things it has to get
+// right, and each is a bug an app would otherwise hit:
+//
+//   1. **The first frame has no answer.** Probing takes a bus round trip, so
+//      the hook returns `NO_CAPABILITY` — available false, empty features —
+//      until one arrives. An app therefore renders its fallback first and
+//      upgrades, which is the right way round: the opposite order flashes a
+//      feature that turns out not to exist.
+//
+//   2. **The answer changes.** A panel restarts, an AppIndicator extension is
+//      toggled, a notification daemon is installed. The hook follows
+//      `NameOwnerChanged` for the whole session rather than sampling once, for
+//      the same reason `globalmenu.js` does: a cached "no" outlives the fix.
+//
+//   3. **The object identity must be stable.** A probe that returned a fresh
+//      object every time would re-render every consumer on every bus event,
+//      and a `features` object in a dependency array would never compare
+//      equal. Results are frozen and replaced only when they differ by value.
+
+import { useEffect, useState } from 'react';
+
+import { sessionBus } from './bus.js';
+import { NO_CAPABILITY, desktopCapability } from './capabilities.js';
+
+/** Value equality over the two levels a capability result has. */
+function same(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.available !== b.available || a.backend !== b.backend) return false;
+  if (a.reason !== b.reason) return false;
+  const ka = Object.keys(a.features);
+  const kb = Object.keys(b.features);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => a.features[k] === b.features[k]);
+}
+
+/**
+ * What this desktop can do for one feature, as a value a component branches
+ * on.
+ *
+ * ```jsx
+ * const notifications = useDesktopCapability('notifications');
+ *
+ * // The portable question is about the feature, never about the platform.
+ * if (notifications.features.actions) {
+ *   return <ReplyFromBanner />;
+ * }
+ * return <OpenAppToReply available={notifications.available} />;
+ * ```
+ *
+ * `{ available, backend, features }`, starting at
+ * {@link NO_CAPABILITY} and settling a tick later — see the header for why
+ * that order is deliberate. It re-probes whenever a name appears or vanishes
+ * on the session bus, so a panel that starts after the app does is picked up.
+ *
+ * Capability names: `'notifications'`, `'tray'`, `'launcher'`.
+ */
+export function useDesktopCapability(name) {
+  const [state, setState] = useState(NO_CAPABILITY);
+
+  useEffect(() => {
+    let cancelled = false;
+    let subscription = null;
+    let ref = null;
+    let onChanged = null;
+
+    const probe = () => {
+      desktopCapability(name)
+        .then((next) => {
+          if (cancelled) return;
+          // Replaced only when it differs by value: see the header.
+          setState((prev) => (same(prev, next) ? prev : next));
+        })
+        .catch(() => {});
+    };
+
+    probe();
+
+    // Follow the session for anything appearing or going away. Deliberately
+    // *not* narrowed by `arg0`: one capability can depend on several names
+    // (the tray watcher, the notification daemon, a launcher), and the set is
+    // a detail of `capabilities.js` rather than of this hook. The handler is
+    // a re-probe, so the cost of a wide match is a bus round trip on an event
+    // that is rare in a settled session.
+    void (async () => {
+      ref = await sessionBus();
+      if (!ref || cancelled) {
+        await ref?.release();
+        ref = null;
+        return;
+      }
+      try {
+        subscription = await ref.bus.watch(
+          "type='signal',sender='org.freedesktop.DBus'," +
+            "interface='org.freedesktop.DBus',member='NameOwnerChanged'",
+        );
+      } catch {
+        return;
+      }
+      // The mount/unmount race `AddMatch` always has — see
+      // `GlobalMenuExport.watchRegistrar` for the long version.
+      if (cancelled) {
+        await subscription.remove().catch(() => {});
+        subscription = null;
+        return;
+      }
+      const key = ref.bus.mangle(
+        '/org/freedesktop/DBus',
+        'org.freedesktop.DBus',
+        'NameOwnerChanged',
+      );
+      onChanged = () => probe();
+      ref.bus.signals.on(key, onChanged);
+    })();
+
+    return () => {
+      cancelled = true;
+      void (async () => {
+        if (ref && onChanged) {
+          const key = ref.bus.mangle(
+            '/org/freedesktop/DBus',
+            'org.freedesktop.DBus',
+            'NameOwnerChanged',
+          );
+          ref.bus.signals.removeListener(key, onChanged);
+        }
+        await subscription?.remove().catch(() => {});
+        await ref?.release();
+      })();
+    };
+  }, [name]);
+
+  return state;
+}

package/src/globalmenu.js

@@ -58,15 +58,7 @@ import { useEffect, useRef, useState } from 'react';
 
 import { loadTransport, sessionBus } from './bus.js';
 import { desktopIntegrationEnabled } from './desktopintegration.js';
-import {
-  DBUSMENU_IFACE,
-  PROPERTY_TYPES,
-  diffSnapshots,
-  groupProperties,
-  layoutOf,
-  snapshot,
-  IdAllocator,
-} from './dbusmenu.js';
+import { DbusMenuExport } from './dbusmenuexport.js';
 import { useAppOrNull } from './appcontext.js';
 import { useTopLevelWindow, windowIdOf } from './windowid.js';
 
@@ -76,9 +68,6 @@ export const REGISTRAR_PATH = '/com/canonical/AppMenu/Registrar';
 const KDE_SERVICE_PROPERTY = '_KDE_NET_WM_APPMENU_SERVICE_NAME';
 const KDE_PATH_PROPERTY = '_KDE_NET_WM_APPMENU_OBJECT_PATH';
 
-/** dbusmenu's recursive layout struct: `(id, properties, children)`. */
-const LAYOUT_SIGNATURE = '(ia{sv}av)';
-
 /**
  * How long the registrar gets to answer.
  *
@@ -162,20 +151,13 @@ function ntkWindowOf(target) {
  * it, and the parts that are awkward (a panel restarting, a window closing
  * mid-call, no bus at all) are awkward in ways React has nothing to say about.
  */
-export class GlobalMenuExport {
+export class GlobalMenuExport extends DbusMenuExport {
   constructor({ getMenus, onSelect, onAboutToShow, target, onChange }) {
-    this.getMenus = getMenus;
-    this.onSelect = onSelect;
-    this.onAboutToShow = onAboutToShow;
+    super({ getMenus, onSelect, onAboutToShow });
     this.target = target;
     this.onChange = onChange ?? (() => {});
 
-    this.alloc = new IdAllocator();
-    this.nodes = snapshot(getMenus(), this.alloc);
-    this.revision = 1;
-
     this.stopped = false;
-    this.exported = false;
     /** The in-flight `sync()`, which the next one queues behind. */
     this.syncing = null;
     this.ref = null;
@@ -443,190 +425,6 @@ export class GlobalMenuExport {
     await this.ref?.release();
     this.ref = null;
   }
-
-  // ----------------------------------------------------------------- update
-
-  /**
-   * A new `menus` array. Serialise, diff, and send the *narrower* of the two
-   * signals the protocol has — see `diffSnapshots`, where the choice is made
-   * and why it matters.
-   */
-  update(menus) {
-    const next = snapshot(menus, this.alloc);
-    const change = diffSnapshots(this.nodes, next);
-    this.nodes = next;
-    if (!this.exported || change.kind === 'none') return;
-
-    if (change.kind === 'properties') {
-      this.iface?.emit.ItemsPropertiesUpdated(
-        change.updated.map(([id, props]) => [id, this.wrap(props)]),
-        change.removed,
-      );
-      return;
-    }
-    this.revision += 1;
-    this.iface?.emit.LayoutUpdated(this.revision, change.parent);
-  }
-
-  /** Plain property values → the `a{sv}` the wire wants. */
-  wrap(props) {
-    const out = {};
-    for (const [name, value] of Object.entries(props)) {
-      const type = PROPERTY_TYPES[name];
-      if (type) out[name] = new this.dbus.Variant(type, value);
-    }
-    return out;
-  }
-
-  /** `layoutOf`'s plain tree → the recursive `(ia{sv}av)`. */
-  wrapLayout(node) {
-    const [id, props, children] = node;
-    return [
-      id,
-      this.wrap(props),
-      children.map(
-        (child) =>
-          new this.dbus.Variant(LAYOUT_SIGNATURE, this.wrapLayout(child)),
-      ),
-    ];
-  }
-
-  // --------------------------------------------------------------- protocol
-
-  itemFor(id) {
-    return this.nodes.get(id)?.item ?? null;
-  }
-
-  defineMenu(dbus) {
-    this.dbus = dbus;
-    const fire = (id, eventId) => {
-      const item = this.itemFor(id);
-      if (!item) return;
-      if (eventId === 'clicked') this.onSelect?.(item);
-      else if (eventId === 'opened') this.onAboutToShow?.(item);
-    };
-
-    return dbus.defineInterface({
-      name: DBUSMENU_IFACE,
-      methods: {
-        GetLayout: {
-          in: { parentId: 'i', recursionDepth: 'i', propertyNames: 'as' },
-          out: { revision: 'u', layout: LAYOUT_SIGNATURE },
-          handler: ({ parentId, recursionDepth, propertyNames }) => {
-            const tree = layoutOf(
-              this.nodes,
-              parentId,
-              recursionDepth ?? -1,
-              propertyNames,
-            );
-            // An id the shell remembers from before a structural change is the
-            // normal way to arrive here, not a protocol violation: answer with
-            // an empty item rather than an error, and let the LayoutUpdated it
-            // has already been sent bring it back for the real tree.
-            return {
-              revision: this.revision,
-              layout: this.wrapLayout(tree ?? [parentId, {}, []]),
-            };
-          },
-        },
-        GetGroupProperties: {
-          in: { ids: 'ai', propertyNames: 'as' },
-          out: { properties: 'a(ia{sv})' },
-          handler: ({ ids, propertyNames }) =>
-            groupProperties(this.nodes, ids, propertyNames).map(
-              ([id, props]) => [id, this.wrap(props)],
-            ),
-        },
-        GetProperty: {
-          in: { id: 'i', name: 's' },
-          out: { value: 'v' },
-          handler: ({ id, name }) => {
-            const props = this.nodes.get(id)?.props;
-            // `hasOwn` on both, so a name like `constructor` reads as absent
-            // rather than as a function that then fails to marshal.
-            const known = Object.hasOwn(PROPERTY_TYPES, name);
-            const value =
-              props && Object.hasOwn(props, name) ? props[name] : undefined;
-            // A property this item does not carry is at its default, and the
-            // spec's own advice is to answer with it rather than to error.
-            if (value === undefined || !known) return new dbus.Variant('s', '');
-            return new dbus.Variant(PROPERTY_TYPES[name], value);
-          },
-        },
-        Event: {
-          in: { id: 'i', eventId: 's', data: 'v', timestamp: 'u' },
-          out: {},
-          handler: ({ id, eventId }) => fire(id, eventId),
-        },
-        EventGroup: {
-          in: { events: 'a(isvu)' },
-          out: { idErrors: 'ai' },
-          handler: ({ events }) => {
-            const errors = [];
-            for (const [id, eventId] of events ?? []) {
-              if (this.itemFor(id)) fire(id, eventId);
-              else errors.push(id);
-            }
-            return errors;
-          },
-        },
-        AboutToShow: {
-          in: { id: 'i' },
-          out: { needUpdate: 'b' },
-          handler: ({ id }) => this.aboutToShow(id),
-        },
-        AboutToShowGroup: {
-          in: { ids: 'ai' },
-          out: { updatesNeeded: 'ai', idErrors: 'ai' },
-          handler: ({ ids }) => {
-            const errors = [];
-            for (const id of ids ?? []) {
-              if (this.itemFor(id)) this.aboutToShow(id);
-              else errors.push(id);
-            }
-            return { updatesNeeded: [], idErrors: errors };
-          },
-        },
-      },
-      properties: {
-        Version: { type: 'u', access: 'read', get: () => 3 },
-        Status: { type: 's', access: 'read', get: () => 'normal' },
-        TextDirection: { type: 's', access: 'read', get: () => 'ltr' },
-        // Empty, and not a placeholder: `icon-name` is looked up in the
-        // desktop's own theme, which is where an app's icons should come from.
-        // A path here would be for icons shipped beside the app.
-        IconThemePath: { type: 'as', access: 'read', get: () => [] },
-      },
-      signals: {
-        LayoutUpdated: { args: { revision: 'u', parent: 'i' } },
-        ItemsPropertiesUpdated: {
-          args: { updated: 'a(ia{sv})', removed: 'a(ias)' },
-        },
-        ItemActivationRequested: { args: { id: 'i', timestamp: 'u' } },
-      },
-    });
-  }
-
-  /**
-   * The reply has to go out **now**, and React has not rendered yet.
-   *
-   * `setState` from here does not produce a new tree before this function
-   * returns, so there is no honest way to answer `true` — and answering `true`
-   * dishonestly is worse than answering `false`: the shell then blocks on a
-   * `GetLayout` for a subtree that has not been built, gets the old one, and
-   * caches it.
-   *
-   * So: answer `false`, let the handler run, and let the ordinary update path
-   * emit `LayoutUpdated` when the new items actually serialise. Shells listen
-   * for that unconditionally — it is the same signal a menu changing while
-   * open produces — so a lazily-built submenu still fills in, one round trip
-   * later than a synchronous toolkit would manage.
-   */
-  aboutToShow(id) {
-    const item = this.itemFor(id);
-    if (item) this.onAboutToShow?.(item);
-    return false;
-  }
 }
 
 /**

package/src/imagesource.js

@@ -250,7 +250,7 @@ export function acquireImageSource(app, key, load) {
         entry.promise = null;
         // every holder unmounted while it decoded — free, don't adopt
         if (entry.released) {
-          image?.destroy();
+          freeImage(app, image);
           return null;
         }
         entry.image = image;
@@ -269,10 +269,23 @@ export function releaseImageSource(app, entry) {
   if (--entry.refs > 0) return;
   sourceCaches.get(app)?.delete(entry.key);
   entry.released = true;
-  entry.image?.destroy();
+  freeImage(app, entry.image);
   entry.image = null;
 }
 
+/**
+ * Free an `Image` this module or a node owns, on every backend it may have
+ * been drawn on: ntk's `destroy()` frees the pixmaps it uploaded per X
+ * connection, and knows nothing of an upload a backend keeps for itself —
+ * the Cocoa app's CG bitmap — which that app's `releaseImage` seam frees.
+ * An X app has no such seam, so there it is `destroy()` alone.
+ */
+export function freeImage(app, image) {
+  if (!image) return;
+  image.destroy();
+  app?.releaseImage?.(image);
+}
+
 // --- server-side sources ----------------------------------------------------
 
 /** RENDER's depth-implied standard formats — the ones a drawable can be

package/src/index.d.ts

@@ -25,6 +25,7 @@ export * from './types/screencolor.js';
 export * from './types/appearance.js';
 export * from './types/fonts.js';
 export * from './types/system.js';
+export * from './types/capabilities.js';
 export * from './types/launcher.js';
 export * from './types/tray.js';
 export * from './types/permissions.js';

package/src/index.js

@@ -14,9 +14,15 @@ export {
   registerApplication,
 } from './application.js';
 export { useAppActivate, useAppOpen } from './apphooks.js';
-export { setBadge } from './launcher.js';
-export { useBadge, useDockMenu } from './launcherhooks.js';
+export { setBadge, setProgress, setQuicklist, setUrgent } from './launcher.js';
+export { useBadge, useDockMenu, useProgress } from './launcherhooks.js';
 export { useTray } from './trayhooks.js';
+export {
+  CAPABILITIES,
+  NO_CAPABILITY,
+  desktopCapability,
+} from './capabilities.js';
+export { useDesktopCapability } from './desktopcapabilityhooks.js';
 export {
   NoPermissionServiceError,
   openPrivacySettings,