flexdesk 0.17.13 → 0.17.14

package/src/tiling/desktops.js

@@ -27,6 +27,25 @@ const DEFAULT_PANEL_STATE = {
     bottom: true,
 };
 
+/** An object that is not an array: what a saved desktop or map is. */
+function _isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/** Throw a `TypeError` saying what the saved layout was expected to hold at
+ *  `path` and what it held instead (see the same helper in tile_tree.js, which
+ *  reads the trees these desktops hold). */
+function _expect(ok, path, want, got) {
+    if (ok) return;
+    let shown;
+    if (got === undefined) shown = 'nothing';
+    else {
+        try { shown = JSON.stringify(got); } catch { shown = String(got); }
+        if (shown.length > 40) shown = `${shown.slice(0, 37)}...`;
+    }
+    throw new TypeError(`${path}: expected ${want}, found ${shown}`);
+}
+
 /**
  * `seed()` yields the leaf a fresh (or emptied) desktop starts with. It comes
  * from the taxonomy's root kind — see WindowManager, which supplies it. The
@@ -178,23 +197,65 @@ export class DesktopManager {
         };
     }
 
+    /**
+     * Rebuild the manager from what `serialize()` wrote. `null`/`undefined` is
+     * nothing saved and gives the fresh manager.
+     *
+     * The blob is whatever the host's `state` held under `DESKTOPS_KEY`: a file
+     * anyone can truncate or edit, which is valid JSON of any shape. So it is
+     * read STRICTLY, and a blob that `serialize()` could not have written throws
+     * a `TypeError` naming the path and what was expected there. It builds only
+     * objects of its own and touches nothing its caller holds, which is what lets
+     * `WindowManager.load` treat a throw as "nothing saved" with nothing to undo.
+     *
+     * Strict about SHAPE, not about every value. What the loader, the tree
+     * operations and the renderer index, iterate or branch on has to be what they
+     * need (containers, node and tab kinds, `dir`, `children`, `sizes`,
+     * `activeTabIdx`). What is only drawn or coerced is taken as it is: a desktop's
+     * `id`, `label`, `group` and `fixed`, a panel's flag, a tab's title and props,
+     * `activeIdx`. A layout that fails on one of those would be thrown away for
+     * nothing, and an app can put almost anything in a title.
+     *
+     * And strict is not hostile to an old blob. A key the loader has always given
+     * a default may be absent: a desktop's `id`, `label` and `panels`, the keys
+     * later releases added (`panelShares`, `group`, `fixed`), and a leaf's `tabs`
+     * and `pageTabs`. What `serialize()` has always written and the loader cannot
+     * do without (`desktops`, a desktop's `tree`, a split's `dir`, `children` and
+     * `sizes`) may not.
+     */
     static deserialize(blob, { seed, panelDefaults = null } = {}) {
         const m = new DesktopManager({ seed, panelDefaults });
-        if (!blob || !Array.isArray(blob.desktops) || blob.desktops.length === 0) return m;
-        m.desktops = blob.desktops.map((raw) => ({
-            id: raw.id || `desk-${Math.random().toString(36).slice(2,8)}`,
-            label: raw.label || '?',
-            tree: raw.tree ? TileTree.deserialize(raw.tree) : new TileTree(),
-            windows: [],
-            // A RESTORED desktop's own answer wins over the default: the user
-            // closed that panel, and re-opening it on every reload is the bug
-            // this merge order avoids. The default only fills a key the stored
-            // blob predates.
-            panels: { ...m.panelDefaults, ...(raw.panels || {}) },
-            panelShares: { ...(raw.panelShares || {}) },
-            group: raw.group || null,
-            fixed: !!raw.fixed,
-        }));
+        if (blob == null) return m;
+        _expect(Array.isArray(blob.desktops) && blob.desktops.length > 0,
+            'desktops', 'a non-empty array of desktops', blob.desktops);
+        m.desktops = blob.desktops.map((raw, i) => {
+            const at = `desktops[${i}]`;
+            _expect(_isRecord(raw), at, 'a desktop, an object', raw);
+            // `null` is a desktop with nothing on it (serialize() writes that);
+            // a desktop with no `tree` key at all is not one serialize() writes.
+            _expect(raw.tree === null || (_isRecord(raw.tree) && _isRecord(raw.tree.root)),
+                `${at}.tree`, '{ root }, or null for an empty desktop', raw.tree);
+            _expect(raw.panels == null || _isRecord(raw.panels), `${at}.panels`, 'an object', raw.panels);
+            // The VALUES of `panels` and `panelShares` are not checked: the loader
+            // already coerces a flag (`!!`) and `_validShare` drops a share that
+            // is not one, so the panel opens at its default.
+            _expect(raw.panelShares == null || _isRecord(raw.panelShares),
+                `${at}.panelShares`, 'an object', raw.panelShares);
+            return {
+                id: raw.id || `desk-${Math.random().toString(36).slice(2,8)}`,
+                label: raw.label || '?',
+                tree: raw.tree ? TileTree.deserialize(raw.tree, `${at}.tree`) : new TileTree(),
+                windows: [],
+                // A RESTORED desktop's own answer wins over the default: the user
+                // closed that panel, and re-opening it on every reload is the bug
+                // this merge order avoids. The default only fills a key the stored
+                // blob predates.
+                panels: { ...m.panelDefaults, ...(raw.panels || {}) },
+                panelShares: { ...(raw.panelShares || {}) },
+                group: raw.group || null,
+                fixed: !!raw.fixed,
+            };
+        });
         // Empty tree → seed with the taxonomy root so the desktop is usable.
         for (const d of m.desktops) {
             if (!d.tree.rootId) d.tree.setRoot(makeLeaf(seed()));
@@ -212,7 +273,9 @@ export class DesktopManager {
  * against a host that cannot persist (e.g. the standalone demo).
  */
 
-const DESKTOPS_KEY = 'desktops';
+/** The logical state key the layout is saved under. Exported so a warning about
+ *  a layout that could not be read can name it. */
+export const DESKTOPS_KEY = 'desktops';
 
 export async function loadDesktops(state) {
     if (!state) return null;

package/src/tiling/keymap.js

@@ -287,6 +287,70 @@ function _compose(mods, key) {
     return [...used, k].join('+');
 }
 
+/** What counts as "focus is in an editable field": a key press aimed at one of
+ *  these may be typing. */
+const TEXT_FIELDS = 'input, textarea, select, [contenteditable="true"]';
+
+/**
+ * Whether Alt on this machine is a key that TYPES: Option on a Mac (and on an
+ * iPad with a keyboard). Option changes the character on every Mac layout, so
+ * Option+digit is how a programmer types `{ } [ ] | \ @ #` on a German,
+ * Spanish, Swedish or French keyboard, where Windows and Linux keep Alt for
+ * shortcuts and type those with AltGr. Nothing in the event tells the two
+ * apart (a US Windows Alt+Shift+2 and a German Mac Option+8 both arrive as
+ * `altKey` with a printable `key`), so this is read from the platform, at the
+ * key press so that it is never stale.
+ */
+function _altTypes() {
+    const nav = globalThis.navigator;
+    return /^(mac|iphone|ipad|ipod)/i.test(nav?.userAgentData?.platform || nav?.platform || '');
+}
+
+/**
+ * The digit ('1'..'9') a keydown on the digit row stands for, or null.
+ *
+ * `e.key` is what the layout and the modifiers TYPE, and `Alt+Shift+2` names a
+ * key, not a character. With Shift held a US keyboard's 2 types "@" and a
+ * German one's '"'; Option on a Mac types "™" or "€"; and an AZERTY keyboard's
+ * digit row types "&", "é", '"' and the like with no modifier at all and the
+ * digits only with Shift. Read `e.key` and Alt+Shift+2 is never seen from a
+ * real key press (only from a synthetic event that sets `key: '2'`, which is
+ * how the tests hid it), and on AZERTY it is the unshifted Alt+1..9 that never
+ * fire. `e.code` is the key's position (`Digit2`), which neither Shift nor the
+ * layout changes.
+ *
+ * `e.key` is still read in three cases:
+ *
+ *  - An event with no `Digit` code: a synthetic one that carries only `key`,
+ *    and the numpad (`Numpad2`), whose `key` is the digit itself with NumLock
+ *    on and a navigation key ("ArrowDown") with it off. The numpad is left to
+ *    say which it is, so a numpad used as arrows still moves focus.
+ *  - AltGr. Windows reports it as Ctrl+Alt, and a German, French or Spanish
+ *    layout types `{ [ ] @ # |` on its digit row with it. Taking those events
+ *    for Alt+digit would switch desktops, and swallow the character in a
+ *    field (the Alt chords work in fields), instead of typing it.
+ *  - Option on a Mac, with focus in an editable field. It types the same
+ *    characters AltGr does (German Option+8 is "{"), but arrives as a bare
+ *    `altKey` with no Ctrl and no AltGraph state, so the AltGr test above does
+ *    not see it. Out of a field nothing is typed, so there the key's position
+ *    is read as everywhere else and Option+2 switches desktop; in a field the
+ *    character is typed, as it was before the position was read, and the
+ *    chord waits for focus to leave the field. The test is the platform, not
+ *    "does `key` look like a character": US Windows Alt+Shift+2 types "@" in
+ *    the same way and is the very press this function exists to read.
+ *
+ * This is for the digit row only. Letter keys move with the layout (AZERTY and
+ * QWERTZ swap some, Dvorak most), so `KeyW` is not "the W key" there: a letter
+ * chord stays named by the character its key types.
+ */
+function _digitOfEvent(e) {
+    const typesCharacter = e.getModifierState?.('AltGraph') || (e.ctrlKey && e.altKey)
+        || (_altTypes() && !!e.target?.closest?.(TEXT_FIELDS));
+    const byPosition = typesCharacter ? null : /^Digit([1-9])$/.exec(e.code ?? '');
+    if (byPosition) return byPosition[1];
+    return /^[1-9]$/.test(e.key) ? e.key : null;
+}
+
 /**
  * The chord id a keydown event is read as, in `DEFAULT_CHORDS`' spelling, or
  * null. This is NOT an exact match on the modifier set: it reads an event the
@@ -303,6 +367,9 @@ function _compose(mods, key) {
  *   F1..F12, Shift+Left/Right, Ctrl+Left/Right     exactly those modifiers
  *   with Alt held, Ctrl and Meta are ignored:
  *     Alt(+Shift)+1..9, +H, +V, +Arrow             Shift picks the Alt+Shift+… row
+ *                                                  (1..9 by the key's position,
+ *                                                  not the character it types:
+ *                                                  see `_digitOfEvent`)
  *     Alt+T / N / W / F                            Shift ignored
  *     any other Alt+letter                         Alt+Letter
  *
@@ -330,7 +397,8 @@ function _chordOfEvent(e) {
         return null;
     }
     const sh = shift ? 'Shift+' : '';
-    if (/^[1-9]$/.test(key)) return `Alt+${sh}${key}`;
+    const digit = _digitOfEvent(e);
+    if (digit) return `Alt+${sh}${digit}`;
     if (lower === 'h' || lower === 'v') return `Alt+${sh}${lower.toUpperCase()}`;
     if (lower === 't' || lower === 'n' || lower === 'w' || lower === 'f') return `Alt+${lower.toUpperCase()}`;
     if (ARROWS.includes(key)) return `Alt+${sh}${key}`;
@@ -442,7 +510,7 @@ export function installKeymap({ wm, palette, navSelector = null, bindings = null
         if (!chord) return;
         const b = table.get(chord);
         if (!b || b.disabled) return;
-        if (!b.inField && e.target?.closest?.('input, textarea, select, [contenteditable="true"]')) return;
+        if (!b.inField && e.target?.closest?.(TEXT_FIELDS)) return;
         if (b.run(ctx, e) !== false) e.preventDefault();
     };
 

package/src/tiling/shell.js

@@ -62,7 +62,11 @@ import { openForm } from '../ui/components/modal.js';
  *                                     it through (the palette + tile tab menu
  *                                     hand it to the entity catalog's fetchers).
  * @param {object}     [cfg.eventBus]
- * @param {object}     [cfg.logger]
+ * @param {object}     [cfg.logger]     `{ warn? }`. Told of problems the shell
+ *                                      carries on from: a keymap binding it
+ *                                      does not know, a saved layout it cannot
+ *                                      read (the default one opens instead).
+ *                                      Else `console`.
  * @param {object}     [cfg.tableStore] threaded into ctx for table persistence
  * @param {object}     [cfg.events]     bus-event NAMES the WM listens for
  * @param {object}     [cfg.rootCrumb]  the breadcrumb's leading segment
@@ -237,6 +241,7 @@ export async function createShell({
         host,
         taxonomy,
         events,
+        logger,
         panelDefaults: panels,
         snapPromotion,
         promoteInPlace,
@@ -703,7 +708,9 @@ function _tileContextMenu(wm, leafId, x, y) {
     ];
     if (wm.desktops.desktops.length > 1 && !isPanel) {
         for (const [i, d] of wm.desktops.desktops.entries()) {
-            // C40. Never onto a fixed desktop — `moveFocusedToDesktop` refuses.
+            // C40. Never onto a fixed desktop, nor the one you are on, and (see
+            // `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;
             items.push({ label: `Move to desktop ${d.label}`, icon: 'sweep',
                          action: `move:${i}` });

package/src/tiling/tile_tree.js

@@ -21,6 +21,25 @@
 let _idCounter = 1;
 function _newId(prefix) { return `${prefix}-${_idCounter++}`; }
 
+/** An object that is not an array: what a saved node, tab or map is. */
+function _isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/** Throw a `TypeError` saying what the saved layout was expected to hold at
+ *  `path` and what it held instead. The value is shown short: a layout can be
+ *  large, and the line is read in a console. */
+function _expect(ok, path, want, got) {
+    if (ok) return;
+    let shown;
+    if (got === undefined) shown = 'nothing';
+    else {
+        try { shown = JSON.stringify(got); } catch { shown = String(got); }
+        if (shown.length > 40) shown = `${shown.slice(0, 37)}...`;
+    }
+    throw new TypeError(`${path}: expected ${want}, found ${shown}`);
+}
+
 function _isPanel(leaf) {
     return String(leaf?.content?.kind || '').startsWith('panel:');
 }
@@ -939,11 +958,42 @@ export class TileTree {
         };
     }
 
-    static deserialize(blob) {
+    /** Rebuild a tree from what `serialize()` wrote. A blob with no root is an
+     *  empty tree, as it always was. Anything else is read STRICTLY: a node that
+     *  `serialize()` could not have written throws a `TypeError` naming where
+     *  (`at` is the path of the blob, for the message only) and what it wanted,
+     *  rather than building half a tree or failing later, inside the renderer,
+     *  with `node.sizes.reduce is not a function`. The caller decides what a
+     *  tree that cannot be read means; see `WindowManager.load`. */
+    static deserialize(blob, at = 'tree') {
         const t = new TileTree();
         if (!blob || !blob.root) return t;
-        const build = (raw) => {
+        // A tab, and the legacy `content` a leaf mirrors its active tab into, are
+        // the same shape: what `makeLeaf` and `_syncActiveTab` read. Its `title` and
+        // `props` are NOT checked. A title is only drawn, and is whatever a content
+        // factory returned (a number, say); props are the app's, and a factory that
+        // cannot use them is told so by the registry's mount-error tile, not by a
+        // layout thrown away.
+        const checkTab = (tab, path) => {
+            _expect(_isRecord(tab) && typeof tab.kind === 'string', path, 'a tab, { kind, props, title }', tab);
+        };
+        const build = (raw, path) => {
+            _expect(_isRecord(raw), path, 'a node, an object', raw);
+            _expect(raw.kind === 'leaf' || raw.kind === 'split', `${path}.kind`, '"leaf" or "split"', raw.kind);
             if (raw.kind === 'leaf') {
+                if (raw.content != null) checkTab(raw.content, `${path}.content`);
+                _expect(raw.tabs == null || Array.isArray(raw.tabs), `${path}.tabs`, 'an array of tabs', raw.tabs);
+                (raw.tabs || []).forEach((tab, i) => checkTab(tab, `${path}.tabs[${i}]`));
+                _expect(raw.activeTabIdx == null || Number.isFinite(raw.activeTabIdx),
+                    `${path}.activeTabIdx`, 'a number', raw.activeTabIdx);
+                _expect(raw.pageTabs == null || _isRecord(raw.pageTabs), `${path}.pageTabs`, 'an object', raw.pageTabs);
+                for (const [page, arc] of Object.entries(raw.pageTabs || {})) {
+                    const where = `${path}.pageTabs[${JSON.stringify(page)}]`;
+                    _expect(_isRecord(arc) && Array.isArray(arc.tabs), where, '{ tabs, activeTabIdx }', arc);
+                    arc.tabs.forEach((tab, i) => checkTab(tab, `${where}.tabs[${i}]`));
+                    _expect(arc.activeTabIdx == null || Number.isFinite(arc.activeTabIdx),
+                        `${where}.activeTabIdx`, 'a number', arc.activeTabIdx);
+                }
                 // Forward-compat with the pre-tabs layout: an old
                 // serialized leaf carries `content` but no `tabs`.
                 // makeLeaf will derive a single-tab list from `content`.
@@ -961,7 +1011,6 @@ export class TileTree {
                 if (raw.pageTabs && typeof raw.pageTabs === 'object') {
                     leaf.pageTabs = {};
                     for (const [k, v] of Object.entries(raw.pageTabs)) {
-                        if (!v || !Array.isArray(v.tabs)) continue;
                         leaf.pageTabs[k] = {
                             tabs: v.tabs.map((t) => ({
                                 kind:  t.kind,
@@ -974,7 +1023,16 @@ export class TileTree {
                 }
                 return leaf;
             }
-            const children = raw.children.map(build);
+            // `sizes` run parallel to `children`: the renderer, `setSplitSizes`,
+            // `swapSiblings` and the panel canonicalizer all index one by the
+            // other, and none of them looks at a length first.
+            _expect(raw.dir === 'h' || raw.dir === 'v', `${path}.dir`, '"h" or "v"', raw.dir);
+            _expect(Array.isArray(raw.children) && raw.children.length > 0,
+                `${path}.children`, 'a non-empty array of nodes', raw.children);
+            _expect(Array.isArray(raw.sizes) && raw.sizes.length === raw.children.length
+                    && raw.sizes.every((n) => Number.isFinite(n) && n >= 0),
+                `${path}.sizes`, `${raw.children.length} non-negative numbers, one per child`, raw.sizes);
+            const children = raw.children.map((c, i) => build(c, `${path}.children[${i}]`));
             const split = makeSplit({
                 dir: raw.dir, children: children.map((c) => c.id),
                 sizes: raw.sizes,
@@ -982,7 +1040,7 @@ export class TileTree {
             children.forEach((c) => t._register(c));
             return split;
         };
-        const root = build(blob.root);
+        const root = build(blob.root, `${at}.root`);
         t.setRoot(root);
         return t;
     }

package/src/tiling/wm.js

@@ -18,7 +18,7 @@
  *   wm.switchDesktop(idx) / wm.addDesktop() / wm.moveFocusedToDesktop(idx)
  */
 
-import { DesktopManager, saveDesktops, loadDesktops } from './desktops.js';
+import { DesktopManager, saveDesktops, loadDesktops, DESKTOPS_KEY } from './desktops.js';
 import { TileRenderer } from './tile_renderer.js';
 import { makeLeaf } from './tile_tree.js';
 import { PLACEHOLDER_KIND } from './content_registry.js';
@@ -38,7 +38,7 @@ const PANEL_TITLES = {
 
 export class WindowManager {
     constructor({ rootEl, api, ctx, onChange, eventBus, host, taxonomy, events, content,
-                  panelDefaults = null, snapPromotion = false,
+                  logger = null, panelDefaults = null, snapPromotion = false,
                   promoteInPlace = false, tabLayout = null, backToOpenList = false,
                   floatActiveTab = false, newTabButton = true }) {
         if (!taxonomy) throw new Error('WindowManager: a taxonomy is required');
@@ -62,6 +62,9 @@ export class WindowManager {
         this.events = events || {};
         this.ctx = ctx || {};
         this.eventBus = eventBus || null;
+        // Where load() reports a saved layout it could not read; else `console`,
+        // as the keymap does.
+        this.logger = logger || null;
         this.onChange = onChange || (() => {});
         // Panel availability. Runtime overrides (`setPanelAvailability`) win
         // over the primary kind's declaration (`KindDef.panels`); the last
@@ -250,10 +253,41 @@ export class WindowManager {
     // ── Persistence ─────────────────────────────────────────────────
     async load() {
         const blob = await loadDesktops(this.host?.state);
-        if (blob) {
-            this.desktops = DesktopManager.deserialize(blob, {
-                seed: this._rootLeaf, panelDefaults: this.panelDefaults });
-            this.renderer.tree = this.desktops.active().tree;
+        // A SAVED LAYOUT THAT CANNOT BE READ IS NO LAYOUT. The state is a file that
+        // can be truncated or edited into valid JSON of the wrong shape, and a boot
+        // that dies on it dies on every start until someone deletes the file by
+        // hand. `deserialize` reads the blob strictly and throws before anything the
+        // WM holds has been touched, so recovering is doing nothing: `this.desktops`
+        // and the renderer are as they were, and the rest of this method runs as it
+        // does for a host with nothing saved. The catch stops there on purpose. The
+        // canonicalize and the render below only ever see a layout that WAS read, so
+        // a throw from them is a bug that has to reach the embedder, not a bad file
+        // to be answered by discarding what the user saved.
+        //
+        // The bad blob is LEFT in the store. Deleting it here would destroy the only
+        // copy of whatever the user was trying to restore; the next `_persist` (any
+        // layout change) overwrites it, and until then each boot warns again, which
+        // is the reminder.
+        if (blob != null) {
+            let restored = null;
+            try {
+                restored = DesktopManager.deserialize(blob, {
+                    seed: this._rootLeaf, panelDefaults: this.panelDefaults });
+            } catch (err) {
+                // ONE string, as the keymap's warning is. The embedder's logger is
+                // usually a LoggingService, whose `scoped()` loggers read two leading
+                // strings as (subcategory, message) and keep only the second, and
+                // whose own warn(message, metadata) keeps the first string and files
+                // the rest as metadata: spread over several arguments, the key would
+                // be the whole recorded message and the cause would be gone. The
+                // console prints one string the same as several.
+                (this.logger ?? console).warn?.(`[wm] bad layout for state key ${DESKTOPS_KEY} `
+                    + `(opening the default layout): ${err?.message ?? err}`);
+            }
+            if (restored) {
+                this.desktops = restored;
+                this.renderer.tree = this.desktops.active().tree;
+            }
         }
         // Normalize: managed windows don't survive a reload, so any
         // window-placeholder leaves restore their original content.
@@ -3941,10 +3975,26 @@ export class WindowManager {
         return true;
     }
 
+    /**
+     * Move the focused tile, with every tab it holds, to desktop `idx` (from 0).
+     * A refused move returns `undefined` and changes nothing; the callers (the
+     * keymap's `toDesktop:N`, the tile menu's *Move to desktop*) read no result.
+     *
+     * The tile menu (`shell.js`, `_tileContextMenu`) never offers a panel, a
+     * fixed desktop or the desktop you are on, and this method refuses all
+     * three itself, because the menu is one door and Alt+Shift+N is another.
+     * A fixed desktop it always refused; a panel and the desktop you are on it
+     * did not, and the move to the desktop you are on destroys the tile: source
+     * and target are one tree, so the tabs are appended to its primary tile and
+     * then the focused tile is closed. A stray Shift on Alt+N reaches that.
+     */
     moveFocusedToDesktop(idx) {
         const tree = this._tree();
         const focused = tree.focused();
         if (!focused || !focused.content) return;
+        // A panel is chrome, not content (the menu's `isPanel`). Moved, it would
+        // replace the target desktop's home ground.
+        if (String(focused.content.kind || '').startsWith('panel:')) return;
         // C20. IT DESTROYS A LEAF, SO IT ANSWERS TO THE SAME VETO `closeFocused`
         // does. A move is not a close from the pane's point of view, but it is
         // exactly a close from the PAGE's: this was the fourth door out of a
@@ -3954,6 +4004,9 @@ export class WindowManager {
         if (closeChrome === false || closeChrome?.disabled === true) return;
         // C40. A fixed desktop is the embedder's, and nothing is moved onto it.
         if (this.desktops.desktops[idx]?.fixed) return;
+        // 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;
         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