flexdesk 0.17.15 → 0.17.17

package/src/tiling/wm.js

@@ -303,8 +303,14 @@ export class WindowManager {
                 }
             }
         }
-        // A single kind is open once, whatever the saved layout says.
-        const deduped = this._dropDuplicateSingles();
+        // A window-only kind is never in a tile, and a single kind is open
+        // once, whatever the saved layout says.
+        const windowOnlyDropped = this._dropWindowOnlyTabs();
+        if (windowOnlyDropped.length) {
+            (this.logger ?? console).warn?.(`[wm] the saved layout held ${windowOnlyDropped.length} tile tab(s) `
+                + `of window-only kind(s) ${[...new Set(windowOnlyDropped)].join(', ')}; they open in a window when asked for`);
+        }
+        const deduped = this._dropDuplicateSingles() || windowOnlyDropped.length > 0;
         for (const d of this.desktops.desktops) this._canonicalize(d.tree, d);
         this.renderer.tree = this.desktops.active().tree;
         this.renderer.render();
@@ -338,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) {
@@ -350,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);
@@ -381,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.
      *
@@ -394,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;
@@ -510,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);
@@ -521,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);
@@ -563,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);
@@ -581,28 +660,67 @@ export class WindowManager {
         return keys;
     }
 
-    /** 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. */
+    /** Open a window-only kind (KindDef `windowOnly`) in its window — the one
+     *  that is open, or a new one — and say so; any other kind: false, and the
+     *  caller opens it where it asked (STORY-0127). */
+    _openWindowOnly(kind, props) {
+        if (!this.taxonomy.isWindowOnly?.(kind)) return false;
+        this._navigateWindow(kind, props);
+        return true;
+    }
+
+    /** Whether a window record holds a window-only kind: such a window never
+     *  docks into a tile (Back to tile, maximize, drag-to-dock). */
+    _holdsWindowOnly(rec) {
+        return !!this.taxonomy.isWindowOnly
+            && _windowTabSpecs(rec).some((t) => this.taxonomy.isWindowOnly(t?.kind));
+    }
+
+    /** A restored layout never holds a window-only kind in a tile: its tabs,
+     *  and its tabs archived under a page, go. Windows are not restored, so
+     *  the content simply opens in a window the next time it is asked for.
+     *  Returns the kinds of the tabs that went, one entry per tab. */
+    _dropWindowOnlyTabs() {
+        if (!this.taxonomy.isWindowOnly) return [];
+        const dropped = [];
+        this._pruneRestoredTabs((t) => {
+            if (!t || !this.taxonomy.isWindowOnly(t.kind)) return true;
+            dropped.push(t.kind);
+            return false;
+        });
+        return 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();
-        let dropped = false;
-        const keep = (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);
             return true;
-        };
-        for (const d of this.desktops.desktops) {
+        });
+    }
+
+    /** 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 [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;
@@ -621,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; }
@@ -862,6 +980,9 @@ export class WindowManager {
         const tree = this._tree();
         const prior = tree.popActiveTabHistory?.(id);
         if (!prior || !prior.kind) return false;
+        // A window-only kind in a tab's history (a layout saved before the kind
+        // was one) goes back to its window, never into this tile.
+        if (this._openWindowOnly(prior.kind, prior.props || {})) return true;
         // A single kind opened elsewhere since this entry was pushed is
         // revealed there, not put back here as a second copy.
         if (this.revealInstance(prior.kind, prior.props || {})) return true;
@@ -973,6 +1094,7 @@ export class WindowManager {
      *  the leaf. Used by Backspace + breadcrumb segments + anything
      *  else that should walk WITHIN the tile rather than reset it. */
     navigateActiveTab(leafId, kind, props = {}) {
+        if (this._openWindowOnly(kind, props)) return;
         if (this.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leaf = tree.get(leafId);
@@ -1029,6 +1151,7 @@ export class WindowManager {
      *  tab feature shipped), the behavior is identical to the old
      *  setLeafContent: one tab in, one tab out. */
     openInLeaf(leafId, kind, props = {}) {
+        if (this._openWindowOnly(kind, props)) return;
         if (this.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leaf = tree.get(leafId);
@@ -1047,9 +1170,16 @@ export class WindowManager {
      *  previous mount, mounts the new kind into the same body element,
      *  and updates the window's title. */
     openInWindow(winId, kind, props = {}) {
-        if (this.revealInstance(kind, props)) return;
+        if (this._openWindowOnly(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` —
@@ -1089,6 +1219,7 @@ export class WindowManager {
      *  If only panel tiles exist (or the tree is empty), spawn a new
      *  content leaf and canonicalize so the panels wrap it. */
     openInPrimary(kind, props = {}) {
+        if (this._openWindowOnly(kind, props)) return;
         if (this.revealInstance(kind, props)) return;
         const tree = this._tree();
         let leafId = tree.primaryLeafId();
@@ -1172,6 +1303,7 @@ export class WindowManager {
      *  pane in a split never dismounts the original). Returns the new
      *  leaf id, or null if the leaf can't be split. */
     splitLeafWith(leafId, dir, kind, props = {}, title = '') {
+        if (this._openWindowOnly(kind, props)) return null;
         if (this.revealInstance(kind, props)) return null;
         const tree = this._tree();
         leafId = this._contentLeafId(leafId);
@@ -1661,6 +1793,9 @@ export class WindowManager {
             canMaximize: true,
             canResize: true,
             modal: false,
+            // BUG-0053. The id is minted per window and never opens again, so
+            // geometry saved under it could never be restored.
+            persistGeometry: false,
             // C15. Dropping a promoted window on a tile PUTS IT BACK — as that
             // tile's content, as a split of it, or as one of its tabs. Off
             // unless the embedder asked, because it changes what a drag to an
@@ -2273,6 +2408,9 @@ export class WindowManager {
         // false lets the geometric maximise happen instead — the answer every
         // other window manager gives a window with nowhere to go back to.
         if (!rec) return false;
+        // A window-only kind has no tile to go back to (STORY-0127): the
+        // geometric maximise happens instead.
+        if (this._holdsWindowOnly(rec)) return false;
         const tree = this.desktops.desktops[rec.desktopIdx]?.tree;
         const home = rec.homeLeafId ? tree?.get(rec.homeLeafId) : null;
         if (home && home.kind === 'leaf') {
@@ -3092,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
@@ -3138,6 +3281,7 @@ export class WindowManager {
     dockWindowInto(windowId, target) {
         const rec = this._windowToLeaf.get(windowId);
         if (!rec || !target?.leafId) return false;
+        if (this._holdsWindowOnly(rec)) return false;   // never into a tile (STORY-0127)
         rec._dock = { ...target };
         rec._demoting = true;
         try { rec.window.close({ force: true }); }
@@ -3178,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) {
@@ -3343,7 +3489,8 @@ export class WindowManager {
             e.preventDefault();
             const rec = this._windowToLeaf.get(winId);
             if (!rec) return;
-            const items = [
+            // A window-only kind's window has no tile to go back to
+            const items = this._holdsWindowOnly(rec) ? [] : [
                 { label: 'Back to tile', icon: 'close_fullscreen', action: 'back' },
             ];
             // C40. Never onto a fixed desktop — `moveWindowToDesktop` refuses.
@@ -3352,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,
                     });
                 }
             }
@@ -3929,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;
@@ -4007,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
@@ -4223,6 +4377,9 @@ export class WindowManager {
 
     /** The routing behind `navigate`, for a kind known to be registered. */
     _route(kind, props, opts) {
+        // A window-only kind (KindDef `windowOnly`) opens in a window, whatever
+        // the destination asked for.
+        if (this._openWindowOnly(kind, props)) return;
         const { ctx = null, transient = false } = opts;
         // Append the tab but stay where you are. Only meaningful with `newTab`.
         const background = !!opts.background;
@@ -4297,6 +4454,10 @@ export class WindowManager {
      *  source leaf — closing the window just disposes the content. */
     _navigateWindow(kind, props) {
         if (this.revealInstance(kind, props)) return;
+        const size = this.taxonomy.windowSize?.(kind);
+        // A window-only kind's window maximises as any window does and never
+        // snaps into a tile (STORY-0127)
+        const dockable = !this.taxonomy.isWindowOnly?.(kind);
         const winId = `twm-mw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 5)}`;
         const contentEl = document.createElement('div');
         contentEl.className = 'twm-window-content';
@@ -4309,17 +4470,22 @@ export class WindowManager {
             title: mountInfo?.title || title,
             icon: 'web_asset',
             content: contentEl,
+            ...(size?.width ? { defaultWidth: size.width } : {}),
+            ...(size?.height ? { defaultHeight: size.height } : {}),
             canMinimize: true,
             canMaximize: true,
             canResize: true,
             modal: false,
+            // BUG-0053. The id is minted per window and never opens again, so
+            // geometry saved under it could never be restored.
+            persistGeometry: false,
             // C15, and this is the SECOND of the two places the WM builds a
             // window. Alt+N and "Open in new window" produce a window that is
             // every bit as dockable as a promoted one, and a window that can be
             // dragged onto a tile in one case and not the other is a rule
             // nobody can learn.
-            snap: this.snapPromotion,
-            snapController: this.snapPromotion ? this._snapController() : null,
+            snap: dockable && this.snapPromotion,
+            snapController: dockable && this.snapPromotion ? this._snapController() : null,
             // R1. THE PANE IS A BOX WITH `overflow: hidden`. A window contained
             // to one (C21) cannot be dragged a single pixel outside it, so
             // "drag a window from one tile to another" — the gesture all three
@@ -4337,9 +4503,11 @@ export class WindowManager {
             // harder. So the maximize button docks — and the separate demote
             // button the WM used to inject beside it is gone, because two
             // buttons for one verb is how you get a chrome nobody reads.
-            onMaximize: () => this.bringBackWindow(winId),
-            maximizeIcon: 'close_fullscreen',
-            maximizeTitle: 'Back to tile',
+            ...(dockable ? {
+                onMaximize: () => this.bringBackWindow(winId),
+                maximizeIcon: 'close_fullscreen',
+                maximizeTitle: 'Back to tile',
+            } : {}),
             onClose: () => this._onManagedWindowClosed(winId, mountInfo),
         });
         // DECORATED ONCE, below, after the record exists. It was called here as
@@ -4425,6 +4593,7 @@ export class WindowManager {
      *  routing) but uses `appendLeafTab` so the existing content
      *  stays in place as a tab. */
     openInTabFromContext(ctx, kind, props = {}, transient = false, background = false) {
+        if (this._openWindowOnly(kind, props)) return;
         if (this.revealInstance(kind, props)) return;
         // Managed-window content: just open in the window — managed
         // windows aren't tabbed (one window = one content).
@@ -4461,6 +4630,7 @@ export class WindowManager {
      *  "Add row" button, which passes no ctx) reliably lands as a sibling
      *  tab in the main tile rather than swapping its content. */
     openInTabInPrimary(kind, props = {}, transient = false, background = false) {
+        if (this._openWindowOnly(kind, props)) return;
         if (this.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leafId = tree.primaryLeafId();