flexdesk 0.17.16 → 0.17.17

package/docs/components/notifications.md

@@ -120,7 +120,8 @@ background, a left border in the severity's colour (`--color-success`,
 `--color-warning`, `--color-danger`; info keeps the blue) and the entry
 animation `twm-notification-in`, which the sheet now defines. The card sets
 `pointer-events: auto` over the root's `none`, so its buttons and its
-click-to-close work.
+click-to-close work. Since [Copy message](#copy-message), click-to-close takes
+only a click on the card outside its text.
 
 Until 0.17.2 the card carried the bare `notification` / `notification--<severity>`
 classes, which no FlexDesk sheet styled: the card had no background and no
@@ -156,6 +157,27 @@ Until 0.17.3 the bell counted only on bus events, so a toast raised through
 was pushed as a second entry: a toast that timed out was in `history` twice
 and counted twice. `tests/notification_history_follows_center.test.mjs` holds it.
 
+### Copy message
+
+Right-clicking a toast, or its entry in the `NotificationHistory` popover, opens
+the context menu (`showContextMenu`) with **Copy message**. It copies the
+notification's title, message and description, one per line and skipping any
+that is empty, as plain text through `navigator.clipboard.writeText`. The menu
+replaces the browser's native one there. The history popover stays open while
+its menu is used. Every context menu draws on `--z-context-menu` (tokens.css),
+over toasts (`--z-toast`) and managed windows, so the menu opens over the toast
+that was right-clicked.
+
+The text of a toast and of a history entry (title, message, description,
+status) is selectable: the sheets give it `user-select: text` over the body's
+`none`. A click or double-click on a toast's text (title, message,
+description, status) selects it and does not close the toast, nor does a click
+that ends a selection inside it. Only a click on the card outside the text (the
+header's empty space, the padding, the timestamp) closes it, besides the ×
+button. `notificationText(notification)` returns the copied
+text, and `showNotificationMenu(event, notification, logger)` opens the menu.
+Both are exported from `widgets`. `tests/notification_copy.test.mjs` covers it.
+
 ### Alerts with history: a log, a pane, a tab host and a bell (0.14.0)
 
 A toast is the moment. The **alert log** keeps what came in until it is

package/docs/components/panels-and-desktops.md

@@ -10,6 +10,7 @@ The shell's left, right and bottom panels, and its virtual desktops. A kind says
 - [Panels keep the size you dragged them to (0.17.0)](#panels-keep-the-size-you-dragged-them-to-0170)
 - [A navigation panel you drive yourself: `mountNavPanel` (0.17.0)](#a-navigation-panel-you-drive-yourself-mountnavpanel-0170)
 - [Your desktops beside the app's (0.10.0)](#your-desktops-beside-the-apps-0100)
+- [A page that opens on the desktop you are on (0.17.17)](#a-page-that-opens-on-the-desktop-you-are-on-01717)
 - [A saved layout that cannot be read (0.17.14)](#a-saved-layout-that-cannot-be-read-01714)
 
 ## Panels a page does not offer (0.17.0)
@@ -127,6 +128,27 @@ main pane; it used to replace that pane with the active tab alone. A target stil
 holding only its seed is replaced, as before. `dispose()` removes the bar, so a
 rebuilt shell paints a fresh one.
 
+## A page that opens on the desktop you are on (0.17.17)
+
+A desktop is the tiles and panels arranged on it. A kind marked `single: true`
+exists once in the app, so opening it from another desktop switches to the
+desktop that has it. A kind marked `single: 'desktop'` exists once per desktop
+instead: the top-nav button, `navigate` and `openInPrimary` reveal the
+instance on the active desktop, or open one there when that desktop has none,
+and never switch desktop.
+
+```js
+kinds: {
+    model: { label: 'Model', isTopNav: true, single: 'desktop' },
+}
+```
+
+On desktop 2, clicking *Model* opens the model on desktop 2 even while
+desktop 1 shows its own; clicking it again reveals desktop 2's. Each desktop's
+instance is saved with its layout and restored there. The details, and what
+counts as a window on a desktop, are in
+[Shell and navigation](shell.md#a-kind-that-exists-once-per-desktop-single-desktop-01717).
+
 ## A saved layout that cannot be read (0.17.14)
 
 The shell saves its layout through the host's `state` under the key `desktops`

package/docs/components/shell.md

@@ -10,6 +10,7 @@ A complete first boot is in the [quickstart](../quickstart.md#hello-shell). This
 
 - [Opt-in shell features](#opt-in-shell-features)
 - [A kind that exists once: `single` (0.17.0)](#a-kind-that-exists-once-single-0170)
+- [A kind that exists once per desktop: `single: 'desktop'` (0.17.17)](#a-kind-that-exists-once-per-desktop-single-desktop-01717)
 - [An open single instance takes new props: `navigate(props)` (0.17.2)](#an-open-single-instance-takes-new-props-navigateprops-0172)
 - [A link to a kind nobody registered (0.17.2)](#a-link-to-a-kind-nobody-registered-0172)
 - [A pane that names what it shows: `ctx.setTitle` (0.12.1)](#a-pane-that-names-what-it-shows-ctxsettitle-0121)
@@ -74,6 +75,59 @@ with it. The taxonomy answers `isSingle(kind)`, `instanceKey(kind, props)` and
 `singleReason(kind)`; the window manager answers `isSingleKind(kind)`,
 `findInstance(kind, props)` and `revealInstance(kind, props)`.
 
+## A kind that exists once per desktop: `single: 'desktop'` (0.17.17)
+
+A virtual desktop is the tiles and panels the user arranged on it, so a page
+the user opens from the top nav belongs on the desktop they are looking at,
+not on another desktop that already shows it. Mark such a kind
+`single: 'desktop'`: at most one instance per desktop.
+
+```js
+createTaxonomy({
+    root: 'cosmos',
+    kinds: {
+        cosmos:  { label: 'Cosmos', isTopNav: true },
+        chart:   { label: 'Star chart', isTopNav: true, single: 'desktop' },  // one per desktop
+    },
+});
+```
+
+- **Every open path looks only at the active desktop** — `navigate`, the top
+  nav, `openInPrimary`, `openInTab*`, `splitLeafWith`, Back. When the desktop
+  has the instance (in a tile, in a top-nav page a tile switched away from, or
+  in a window on it) it is revealed there, as for `single: true`; when it has
+  none, one is opened there. The open never switches desktop, and the
+  instances on other desktops are left as they are.
+- **A window is on the desktop it was opened on** or moved to. A window
+  contained to a pane (`promoteInPlace`) is shown on that desktop only; a
+  free-floating one (`navigate(kind, props, { dest: 'window' })`) is drawn over
+  every desktop but is still the instance of the one it was opened on, never
+  of another: on desktop 1, *Model* reveals desktop 1's own model even while
+  desktop 2's floats in front of it.
+- **The copy verbs refuse** within the desktop, as for `single: true`.
+- **The move verbs refuse** to carry the kind onto a desktop that already holds
+  it: *Move to desktop N* (Alt+Shift+N and the tile and window menus, whose row
+  is greyed with the reason), and dropping a floating window onto another
+  desktop's tile. `wm.desktopMoveRefusal({ leafId } | { windowId }, idx)`
+  answers that reason, or null. Removing a desktop brings its windows across
+  to the active desktop and never closes one, so that desktop can then hold
+  the kind twice, until a reload keeps the first.
+- **Navigating inside a window looks on the window's own desktop**
+  (`openInWindow`, and the in-window navigation that goes through it): a
+  floating window of desktop 1 navigated to the kind while desktop 2 is on
+  screen reveals desktop 1's instance, and shows the kind itself when desktop
+  1 has none. The window stays on its desktop.
+- **A page restore and a restored layout dedupe per desktop**: a tile's archived
+  page brings its instance back unless that desktop has it live elsewhere, and
+  a reload keeps the first instance on each desktop. Each desktop's instance
+  survives, live or archived.
+
+`single: true` keeps its meaning: one instance in the app, and opening it
+switches to the desktop it is on. Because `'desktop'` names this mode, it is
+not read as a prop name. `findInstance(kind)` answers the active desktop's
+instance; the taxonomy answers `isSinglePerDesktop(kind)`, and
+`instanceKey(kind, props)` is the same for every props.
+
 ## An open single instance takes new props: `navigate(props)` (0.17.2)
 
 Revealing a `single` instance used to drop the props the open asked for: the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flexdesk",
-    "version": "0.17.16",
+    "version": "0.17.17",
     "description": "A tiling window manager and widget set for desktop-class web applications. Zero runtime dependencies.",
     "license": "MIT",
     "repository": {

package/src/tiling/kind_taxonomy.js

@@ -53,15 +53,17 @@
  *               not inserted and their toggles are disabled, showing
  *               `reason`.
  *
- *   single?     `true`, or the name of a prop. The kind exists ONCE: content
- *               that holds heavy app-wide state and must not be mounted
- *               twice. With `true` there is one instance of the kind; with a
- *               prop name there is one per value of that prop (`'id'`: one
- *               tile per record). The window manager makes every open path
- *               reveal the instance that exists, refuses the copy verbs with
- *               a reason, and keeps the first of any duplicates a restored
- *               layout holds. The root kind cannot be single: every new
- *               pane, tab and desktop is seeded with it.
+ *   single?     `true`, `'desktop'`, or the name of a prop. The kind exists
+ *               ONCE: content that holds heavy app-wide state and must not be
+ *               mounted twice. With `true` there is one instance of the kind;
+ *               with `'desktop'` there is one per virtual desktop, found and
+ *               opened on the active one (so `'desktop'` is not a prop name
+ *               here); with a prop name there is one per value of that prop
+ *               (`'id'`: one tile per record). The window manager makes every
+ *               open path reveal the instance that exists, refuses the copy
+ *               verbs with a reason, and keeps the first of any duplicates a
+ *               restored layout holds. The root kind cannot be single: every
+ *               new pane, tab and desktop is seeded with it.
  *
  *   window?     `{ width?, height? }` — the initial size, in px, of a managed
  *               window this kind opens in (`navigate(…, { dest: 'window' })`,
@@ -249,14 +251,19 @@ export function createTaxonomy({ kinds, root } = {}) {
         return s === true || (typeof s === 'string' && s !== '');
     };
 
+    /** Whether `kind` exists once per virtual desktop (`single: 'desktop'`)
+     *  rather than once in the app. */
+    const isSinglePerDesktop = (kind) => _kinds[kind]?.single === 'desktop';
+
     /** The identity of one instance of a single kind: two tab specs with the
-     *  same key are the same instance. `null` for a kind that is not single,
-     *  which is how callers ask both questions at once. Keyed by the kind and,
-     *  for `single: '<prop>'`, that prop's value as a string. */
+     *  same key are the same instance (on one desktop, for
+     *  `single: 'desktop'`). `null` for a kind that is not single, which is
+     *  how callers ask both questions at once. Keyed by the kind and, for
+     *  `single: '<prop>'`, that prop's value as a string. */
     const instanceKey = (kind, props) => {
         if (!isSingle(kind)) return null;
         const by = _kinds[kind].single;
-        if (by === true) return String(kind);
+        if (by === true || by === 'desktop') return String(kind);
         const v = props?.[by];
         return `${kind}\u0000${v == null ? '' : String(v)}`;
     };
@@ -287,6 +294,7 @@ export function createTaxonomy({ kinds, root } = {}) {
         panelOffer,
         topNavEntries,
         isSingle,
+        isSinglePerDesktop,
         instanceKey,
         singleReason,
         isWindowOnly,

package/src/tiling/shell.js

@@ -712,8 +712,11 @@ function _tileContextMenu(wm, leafId, x, y) {
             // `isPanel` above) never a panel: `moveFocusedToDesktop` refuses all
             // three too, because the keyboard reaches it without this menu.
             if (i === wm.desktops.activeIdx || d.fixed) continue;
+            // A desktop holds a `single: 'desktop'` kind once: greyed, saying so.
+            const refusal = wm.desktopMoveRefusal({ leafId }, i);
             items.push({ label: `Move to desktop ${d.label}`, icon: 'sweep',
-                         action: `move:${i}` });
+                         action: `move:${i}`, disabled: !!refusal,
+                         title: refusal || undefined });
         }
     }
     items.push({ separator: true });

package/src/tiling/wm.js

@@ -344,6 +344,29 @@ export class WindowManager {
     //
     // MOVE verbs (float, dock, drag a tab, move to desktop) carry the one
     // instance somewhere else and are untouched.
+    //
+    // `single: 'desktop'` keeps the same promises per virtual desktop: a
+    // desktop is the tiles and panels the user arranged on it, so opening the
+    // kind looks only at the ACTIVE desktop — its tiles, their archived pages
+    // and the windows on it — and opens it there when that desktop has none.
+    // A window is on the desktop it was opened on or moved to (`desktopIdx`):
+    // a free-floating one is drawn over every desktop, but it is that one
+    // desktop's instance, so it never stands in for another desktop's. The
+    // move verbs refuse to carry the kind onto a desktop that already holds
+    // it (`desktopMoveRefusal`). Navigating inside a window looks on the
+    // window's own desktop (`openInWindow`). Removing a desktop brings its
+    // windows across, a window never being destroyed by a tile operation, so
+    // the active desktop can then hold the kind twice until the next reload
+    // keeps the first.
+
+    /** The key a tab's instance is unique under on desktop `desktopIdx`: its
+     *  instance key, scoped to that desktop for a `single: 'desktop'` kind;
+     *  null for a tab that is not single. */
+    _scopedKey(t, desktopIdx) {
+        const k = t ? this._instanceKey(t.kind, t.props) : null;
+        if (k == null || !this.taxonomy.isSinglePerDesktop(t.kind)) return k;
+        return `${desktopIdx}\u0000${k}`;
+    }
 
     /** The instance key of a tab spec, or null when its kind is not single. */
     _instanceKey(kind, props) {
@@ -356,27 +379,38 @@ export class WindowManager {
     }
 
     /** Where the one instance of a single kind is open, or null — also null
-     *  for a kind that is not single. One of:
+     *  for a kind that is not single. A `single: 'desktop'` kind is looked for
+     *  on the active desktop only. One of:
      *    `{ where: 'window',  windowId, idx, desktopIdx }`
      *    `{ where: 'tab',     desktopIdx, leafId, idx }`
      *    `{ where: 'archive', desktopIdx, leafId, page, idx }` — a tab of a
      *      top-nav page the tile has switched away from (`pageTabs`). */
     findInstance(kind, props = {}) {
+        const on = this.taxonomy.isSinglePerDesktop(kind) ? this.desktops.activeIdx : null;
+        return this._findInstance(kind, props, on);
+    }
+
+    /** `findInstance`, looking only at desktop `on` when it is a number, and
+     *  past the window `exceptWindowId`. */
+    _findInstance(kind, props, on, exceptWindowId = null) {
         const key = this._instanceKey(kind, props);
         if (key == null) return null;
         const same = (t) => !!t && this._instanceKey(t.kind, t.props) === key;
+        const desktops = [...this.desktops.desktops.entries()]
+            .filter(([desktopIdx]) => on == null || desktopIdx === on);
         for (const [windowId, rec] of this._windowToLeaf) {
+            if (windowId === exceptWindowId) continue;
+            if (on != null && rec.desktopIdx !== on) continue;
             const idx = _windowTabSpecs(rec).findIndex(same);
             if (idx >= 0) return { where: 'window', windowId, idx, desktopIdx: rec.desktopIdx };
         }
-        const desktops = this.desktops.desktops;
-        for (const [desktopIdx, d] of desktops.entries()) {
+        for (const [desktopIdx, d] of desktops) {
             for (const leaf of d.tree.leaves()) {
                 const idx = (leaf.tabs || []).findIndex(same);
                 if (idx >= 0) return { where: 'tab', desktopIdx, leafId: leaf.id, idx };
             }
         }
-        for (const [desktopIdx, d] of desktops.entries()) {
+        for (const [desktopIdx, d] of desktops) {
             for (const leaf of d.tree.leaves()) {
                 for (const [page, arc] of this._archivedPages(leaf)) {
                     const idx = arc.tabs.findIndex(same);
@@ -387,6 +421,31 @@ export class WindowManager {
         return null;
     }
 
+    /** Why moving a pane's or a window's tabs onto desktop `idx` is refused,
+     *  or null: that desktop already holds one of their `single: 'desktop'`
+     *  kinds (in a tile, an archived page or a window), and a desktop holds
+     *  such a kind once. `source` is `{ leafId }` (a tile of the active
+     *  desktop) or `{ windowId }`. The move verbs ask it, and their menu rows
+     *  are greyed with its sentence. */
+    desktopMoveRefusal(source, idx) {
+        let specs = [];
+        if (source?.windowId) {
+            const rec = this._windowToLeaf.get(source.windowId);
+            specs = rec ? _windowTabSpecs(rec) : [];
+        } else {
+            const leaf = this._tree().get(source?.leafId);
+            specs = leaf?.tabs?.length ? leaf.tabs : (leaf?.content ? [leaf.content] : []);
+        }
+        const d = this.desktops.desktops[idx];
+        if (!d) return null;
+        for (const t of specs) {
+            if (!t || !this.taxonomy.isSinglePerDesktop(t.kind)) continue;
+            if (!this._findInstance(t.kind, t.props, idx, source.windowId ?? null)) continue;
+            return `${this.taxonomy.kinds[t.kind]?.label || t.kind} is open on desktop ${d.label} already`;
+        }
+        return null;
+    }
+
     /** Reveal the instance of a single kind that is open: answers whether
      *  there was one. Every open path asks this first.
      *
@@ -400,7 +459,12 @@ export class WindowManager {
      *  open names no props at all — a top-nav button, `openInPrimary(kind)` —
      *  which asks to SEE the instance, not to empty it. */
     revealInstance(kind, props = {}) {
-        const loc = this.findInstance(kind, props);
+        return this._revealFound(this.findInstance(kind, props), kind, props);
+    }
+
+    /** Reveal the instance at `loc` (a `findInstance` result, or null) and
+     *  hand it `props`. Answers whether there was one to reveal. */
+    _revealFound(loc, kind, props) {
         if (!loc || !this._revealAt(loc)) return false;
         if (props && Object.keys(props).length) this._deliverProps(kind, props);
         return true;
@@ -516,7 +580,8 @@ export class WindowManager {
      *  soon as the tile leaves the page by a path other than `swapToPage`
      *  (`navigateActiveTab`). So a restored tab whose instance is live
      *  anywhere else is dropped from the tile and from the restored archive;
-     *  the instance stays where it is. */
+     *  the instance stays where it is. For a `single: 'desktop'` kind,
+     *  anywhere else on the tile's desktop. */
     _swapToPage(tree, leafId, target, currentTopNav, targetTopNav, opts) {
         const done = tree.swapToPage(leafId, target, currentTopNav, targetTopNav, opts);
         if (done) this._dropRestoredCopies(tree, leafId, targetTopNav, target);
@@ -527,11 +592,12 @@ export class WindowManager {
         const leaf = tree.get(leafId);
         const tabs = Array.isArray(leaf?.tabs) ? leaf.tabs : null;
         if (!tabs) return;
+        const desktopIdx = this.desktops.desktops.findIndex((d) => d.tree === tree);
         const elsewhere = this._liveInstanceKeys(tree, leafId);
         const keeper = () => {
             const seen = new Set();
             return (t) => {
-                const k = t ? this._instanceKey(t.kind, t.props) : null;
+                const k = this._scopedKey(t, desktopIdx);
                 if (k == null) return true;
                 if (elsewhere.has(k) || seen.has(k)) return false;
                 seen.add(k);
@@ -569,16 +635,23 @@ export class WindowManager {
         tree.setActiveLeafTab(leafId, Math.max(0, Math.min(tabs.length - 1, active)));
     }
 
-    /** The instance keys of every LIVE tab — windows, and every leaf of every
-     *  desktop but `leafId` of `tree`. Archived pages are not live. */
+    /** The scoped keys (`_scopedKey`, for `tree`'s desktop) of every LIVE
+     *  tab — windows, and every leaf of every desktop but `leafId` of `tree`;
+     *  a `single: 'desktop'` tab counts only when it is on `tree`'s desktop.
+     *  Archived pages are not live. */
     _liveInstanceKeys(tree, leafId) {
+        const here = this.desktops.desktops.findIndex((d) => d.tree === tree);
         const keys = new Set();
-        const add = (t) => {
-            const k = t ? this._instanceKey(t.kind, t.props) : null;
+        const adder = (onHere) => (t) => {
+            if (!onHere && t && this.taxonomy.isSinglePerDesktop(t.kind)) return;
+            const k = this._scopedKey(t, here);
             if (k != null) keys.add(k);
         };
-        for (const [, rec] of this._windowToLeaf) _windowTabSpecs(rec).forEach(add);
+        for (const [, rec] of this._windowToLeaf) {
+            _windowTabSpecs(rec).forEach(adder(rec.desktopIdx === here));
+        }
         for (const d of this.desktops.desktops) {
+            const add = adder(d.tree === tree);
             for (const leaf of d.tree.leaves()) {
                 if (d.tree === tree && leaf.id === leafId) continue;
                 (leaf.tabs || []).forEach(add);
@@ -618,14 +691,15 @@ export class WindowManager {
         return dropped;
     }
 
-    /** A restored layout keeps the FIRST instance of each single kind: later
-     *  live tabs are dropped (the tile shows the tab that took the dropped
-     *  one's place, or closes when it held nothing else), and so are later
-     *  archived ones. Answers whether anything was dropped. */
+    /** A restored layout keeps the FIRST instance of each single kind (of a
+     *  `single: 'desktop'` kind, on each desktop): later live tabs are
+     *  dropped (the tile shows the tab that took the dropped one's place, or
+     *  closes when it held nothing else), and so are later archived ones.
+     *  Answers whether anything was dropped. */
     _dropDuplicateSingles() {
         const seen = new Set();
-        return this._pruneRestoredTabs((t) => {
-            const k = t ? this._instanceKey(t.kind, t.props) : null;
+        return this._pruneRestoredTabs((t, desktopIdx) => {
+            const k = this._scopedKey(t, desktopIdx);
             if (k == null) return true;
             if (seen.has(k)) return false;
             seen.add(k);
@@ -633,19 +707,20 @@ export class WindowManager {
         });
     }
 
-    /** Drop every tab of the restored layout `keep(tab)` refuses, in the
-     *  tiles and in their archived pages; a tile left empty closes (seeding a
-     *  content tile if none is left). Returns whether anything went. */
+    /** Drop every tab of the restored layout `keep(tab, desktopIdx)` refuses,
+     *  in the tiles and in their archived pages; a tile left empty closes
+     *  (seeding a content tile if none is left). Returns whether anything
+     *  went. */
     _pruneRestoredTabs(keep) {
         let dropped = false;
-        for (const d of this.desktops.desktops) {
+        for (const [desktopIdx, d] of this.desktops.desktops.entries()) {
             const tree = d.tree;
             for (const leaf of tree.leaves()) {
                 const tabs = Array.isArray(leaf.tabs) ? leaf.tabs : [];
                 let active = leaf.activeTabIdx || 0;
                 let changed = false;
                 for (let i = 0; i < tabs.length;) {
-                    if (keep(tabs[i])) { i++; continue; }
+                    if (keep(tabs[i], desktopIdx)) { i++; continue; }
                     tabs.splice(i, 1);
                     if (i < active) active -= 1;
                     changed = true;
@@ -664,10 +739,10 @@ export class WindowManager {
                 }
             }
         }
-        for (const d of this.desktops.desktops) {
+        for (const [desktopIdx, d] of this.desktops.desktops.entries()) {
             for (const leaf of d.tree.leaves()) {
                 for (const [page, arc] of this._archivedPages(leaf)) {
-                    const kept = arc.tabs.filter(keep);
+                    const kept = arc.tabs.filter((t) => keep(t, desktopIdx));
                     if (kept.length === arc.tabs.length) continue;
                     dropped = true;
                     if (!kept.length) { delete leaf.pageTabs[page]; continue; }
@@ -1096,9 +1171,15 @@ export class WindowManager {
      *  and updates the window's title. */
     openInWindow(winId, kind, props = {}) {
         if (this._openWindowOnly(kind, props)) return;
-        if (this.revealInstance(kind, props)) return;
         const rec = this._windowToLeaf.get(winId);
         if (!rec) { this.openInPrimary(kind, props); return; }
+        // A window is on its own desktop, even a free-floating one drawn over
+        // every desktop: a `single: 'desktop'` kind navigated to in it is
+        // looked for on the window's desktop, not the one on screen.
+        const loc = this.taxonomy.isSinglePerDesktop(kind)
+            ? this._findInstance(kind, props, rec.desktopIdx)
+            : this.findInstance(kind, props);
+        if (this._revealFound(loc, kind, props)) return;
         try { rec.mountInfo?.destroy?.(); } catch {}
         // R8. THE BODY, NOT THE CONTENT ELEMENT. A floated pane's window holds
         // a tab strip above its body, and both are children of `contentEl` —
@@ -3149,6 +3230,11 @@ export class WindowManager {
         // The window's home follows the drop. Without this the dock is applied
         // to the tree of the desktop the window was PROMOTED from, and the tile
         // the user aimed at is on the one they are looking at.
+        // A free-floating window is drawn over every desktop, so a drop can
+        // carry it to another one: refused, as the move verbs are, when that
+        // desktop holds its `single: 'desktop'` kind already.
+        if (typeof desktopIdx === 'number' && desktopIdx !== record.desktopIdx
+            && this.desktopMoveRefusal({ windowId: winId }, desktopIdx)) return false;
         if (typeof desktopIdx === 'number') record.desktopIdx = desktopIdx;
 
         // THE DRAG ALREADY ANSWERED, so there is nothing to ask — the probe
@@ -3236,6 +3322,8 @@ export class WindowManager {
         if (rec.desktopIdx === targetIdx) return;
         // C40. A fixed desktop is the embedder's, and nothing is moved onto it.
         if (this.desktops.desktops[targetIdx]?.fixed) return;
+        // A desktop holds a `single: 'desktop'` kind once.
+        if (this.desktopMoveRefusal({ windowId }, targetIdx)) return;
         this.desktops.ensureCount(targetIdx + 1);
         rec.desktopIdx = targetIdx;
         if (!rec.homeContainer && rec.homeLeafId) {
@@ -3411,9 +3499,11 @@ export class WindowManager {
             if (targets.length) {
                 items.push({ separator: true });
                 for (const [i, d] of targets) {
+                    const refusal = this.desktopMoveRefusal({ windowId: winId }, i);
                     items.push({
                         label: `Move to desktop ${d.label}`, icon: 'sweep',
-                        action: `move:${i}`,
+                        action: `move:${i}`, disabled: !!refusal,
+                        title: refusal || undefined,
                     });
                 }
             }
@@ -3988,7 +4078,9 @@ export class WindowManager {
      * ruling is that a tile operation may move a window and never destroy it,
      * and removing a desktop is the largest tile operation there is: they come
      * across to the desktop that ends up active, re-homed onto its ground by
-     * `_rehomeContainedWindows` on the render below.
+     * `_rehomeContainedWindows` on the render below. One holding a
+     * `single: 'desktop'` kind the active desktop already has makes it hold
+     * the kind twice, until a reload keeps the first.
      */
     removeDesktop(idx) {
         const m = this.desktops;
@@ -4066,6 +4158,9 @@ export class WindowManager {
         // Already there. Without this, `tree.close` below removes the tile from
         // the same tree its tabs were just appended to, and it is gone.
         if (idx === this.desktops.activeIdx) return;
+        // A desktop holds a `single: 'desktop'` kind once: a pane carrying one
+        // the target already has stays where it is.
+        if (this.desktopMoveRefusal({ leafId: focused.id }, idx)) return;
         this.desktops.ensureCount(idx + 1);
         const target = this.desktops.desktops[idx];
         // C40. THE PANE'S TABS JOIN THE TARGET'S PRIMARY LEAF, ALL OF THEM. It

package/src/ui/components/notification_history.js

@@ -21,7 +21,11 @@
  *   alertsTab   the tab a click asks for, `bottompanel:show { tab }`; 'alerts'.
  *   onOpen      a click, instead of the bus event — for an embedder with no bus,
  *               or whose panel must be opened before a tab can be chosen.
+ *
+ * A right-click on an entry opens the context menu with "Copy message"
+ * (STORY-0131), the same as on its toast; the popover stays open meanwhile.
  */
+import { showNotificationMenu } from '../notification_center.js';
 
 export class NotificationHistory {
     constructor({ notificationCenter, eventBus, logger, mountPoint = null, alertLog = null,
@@ -209,10 +213,15 @@ export class NotificationHistory {
         };
         this._popoverCleanup = cleanup;
 
+        // The entries' context menu is outside the panel, and using it is not leaving it.
         const onDocDown = (ev) => {
+            if (ev.target.closest?.('.twm-context-menu')) return;
             if (!panel.contains(ev.target) && !this.triggerEl.contains(ev.target)) cleanup();
         };
-        const onKey = (ev) => { if (ev.key === 'Escape') cleanup(); };
+        // Escape closes the innermost layer: an open entry menu closes itself.
+        const onKey = (ev) => {
+            if (ev.key === 'Escape' && !document.querySelector('.twm-context-menu')) cleanup();
+        };
         const onResize = () => cleanup();
 
         document.addEventListener('mousedown', onDocDown, true);
@@ -261,6 +270,7 @@ export class NotificationHistory {
             body.className = 'twm-notification-history__item-body';
             body.textContent = entry.message || '';
             item.appendChild(body);
+            item.addEventListener('contextmenu', (event) => showNotificationMenu(event, entry, this.logger));
 
             fragment.appendChild(item);
         }

package/src/ui/notification_center.js

@@ -35,11 +35,20 @@
  * `log:entry`). A toast that leaves marks its own entry `dismissed` with a
  * `reason`; it adds none. `subscribe(fn)` calls `fn(entry, center)` for each
  * entry added, so a history view follows the centre rather than the bus.
+ *
+ * Copy message (STORY-0131)
+ * -------------------------
+ * A right-click on a toast, or on its entry in the history, opens the context
+ * menu with "Copy message": the title, the message and the description, one
+ * per line, go to the clipboard as plain text. The text is also selectable:
+ * a click on the title, message, description or status, or one that ends a
+ * selection, does not close the toast; only a click on its chrome does.
  */
 import { ComponentBase } from './base/component_base.js';
 import { getSetting } from '../core/settings.js';
 import { setToastBus, getToastBus } from './components/toast.js';
 import { ProgressBar } from './components/progress.js';
+import { showContextMenu } from './components/context_menu.js';
 
 const SEVERITIES = ['info', 'success', 'warn', 'error', 'fatal'];
 
@@ -60,6 +69,39 @@ const DEFAULT_LOG_LEVELS = new Set(['warn', 'error', 'fatal']);
 // Messages from these namespaces are self-descriptive and need no category header.
 const SUPPRESSED_NAMESPACE_TITLES = new Set(['bootstrap', 'app']);
 
+/** A notification as plain text: its title, message and description, one per line. */
+export function notificationText(notification) {
+    return [notification.title, notification.message, notification.description]
+        .filter((part) => part != null && String(part) !== '')
+        .join('\n');
+}
+
+/**
+ * The right-click menu of a toast or a history entry: "Copy message". It takes
+ * the right-click, so the browser's own menu does not open.
+ */
+export function showNotificationMenu(event, notification, logger) {
+    event.preventDefault();
+    event.stopPropagation();
+    showContextMenu(event.clientX, event.clientY,
+        [{ label: 'Copy message', icon: 'content_copy', action: 'copy' }],
+        () => {
+            Promise.resolve()
+                .then(() => navigator.clipboard.writeText(notificationText(notification)))
+                .catch((err) => logger?.warn?.('twm-notification-center', 'Copy message failed', { err }));
+        });
+}
+
+/** The toast's text: clicking it selects, it does not dismiss. */
+const TOAST_TEXT = '.twm-notification__title, .twm-notification__body, '
+    + '.twm-notification__description, .twm-notification__status';
+
+/** A non-empty text selection inside `el`: a click that ends one is not a click on it. */
+function selectsTextIn(el) {
+    const sel = el.ownerDocument.getSelection?.();
+    return Boolean(sel && !sel.isCollapsed && sel.rangeCount && el.contains(sel.getRangeAt(0).commonAncestorContainer));
+}
+
 export class NotificationCenter extends ComponentBase {
     #items;
     #summaryEl;
@@ -752,12 +794,16 @@ export class NotificationCenter extends ComponentBase {
             item.appendChild(actionsEl);
         }
 
+        // A click on the text is the start of selecting it (a double-click's
+        // first click leaves only a caret), so only the toast's chrome closes it.
         item.addEventListener('click', (event) => {
-            if (event.target.closest('button') || NotificationCenter.#isRunning(notification)) {
+            if (event.target.closest(`button, ${TOAST_TEXT}`) || NotificationCenter.#isRunning(notification)
+                || selectsTextIn(item)) {
                 return;
             }
             this.dismiss(notification.id, 'click');
         });
+        item.addEventListener('contextmenu', (event) => showNotificationMenu(event, notification, this.logger));
 
         this.#patchItem(entry, notification);
         return entry;