flexdesk 0.16.1 → 0.17.0

package/src/tiling/wm.js

@@ -9,8 +9,12 @@
  *   wm.closeFocused()                 close the focused tile
  *   wm.focusDir(dir) / wm.moveFocused(dir)
  *   wm.toggleManagedFocused()         tile <-> managed window
- *   wm.togglePanel(side)              left | right | bottom
- *   wm.isPanelOpen(side)              boolean
+ *   wm.togglePanel(side)              left | right | bottom; false if withheld
+ *   wm.isPanelOpen(side)              boolean (open AND available)
+ *   wm.isPanelAvailable(side)         boolean
+ *   wm.getPanelAvailability(side)     { available, reason }
+ *   wm.setPanelAvailability(side, o)  runtime override; null clears it
+ *   wm.onPanelAvailabilityChange(fn)  subscribe; returns an unsubscribe
  *   wm.switchDesktop(idx) / wm.addDesktop() / wm.moveFocusedToDesktop(idx)
  */
 
@@ -22,6 +26,7 @@ import { installPanelKeyRouter } from './panel_keys.js';
 import { ManagedWindow } from '../ui/components/managed_window.js';
 import { showContextMenu } from '../ui/components/context_menu.js';
 import { createTabStrip } from './tab_strip.js';
+import { PANEL_OFFERED, PANEL_SIDES, assertPanelSide, readPanelOffer } from './panel_availability.js';
 
 const PANEL_KINDS = new Set(['panel:left', 'panel:right', 'panel:bottom']);
 
@@ -58,6 +63,17 @@ export class WindowManager {
         this.ctx = ctx || {};
         this.eventBus = eventBus || null;
         this.onChange = onChange || (() => {});
+        // Panel availability. Runtime overrides (`setPanelAvailability`) win
+        // over the primary kind's declaration (`KindDef.panels`); the last
+        // availability announced, so a change is announced once; and who
+        // wants to hear about it. Before anything is mounted every side is
+        // offered, so a first primary that withholds one is announced.
+        this._panelOverrides = {};
+        this._panelAvailability = Object.fromEntries(PANEL_SIDES.map((s) => [s, PANEL_OFFERED]));
+        this._panelAvailabilityListeners = new Set();
+        this._reconcilingPanels = false;
+        /** >0 while a composite verb runs: see `_revealAt`. */
+        this._quietDepth = 0;
         // C34. Whether the tile's float gesture takes only the tab on screen.
         this.floatActiveTab = !!floatActiveTab;
 
@@ -132,6 +148,7 @@ export class WindowManager {
             },
             onFocusChange: () => this._notifyChange(),
             onAfterRender: () => this._rehomeContainedWindows(),
+            onSplitResized: (splitId) => this._onSplitResized(splitId),
         });
         this._persistTimer = null;
         // Window-id → leaf-id mapping so a managed-window demote can
@@ -201,6 +218,13 @@ export class WindowManager {
      *  so other surfaces (palette, top-bar toggles, page shortcuts) can
      *  subscribe through the existing event system. */
     _notifyChange(reason = null) {
+        // A composite verb (a single-kind reveal) is ONE change: the verbs it
+        // is built from stay quiet while it runs, and it notifies once.
+        if (this._quietDepth > 0) return;
+        // Whatever changed may have changed the primary kind, and with it which
+        // panels are offered: put the tree and the announcement right FIRST,
+        // so every listener below sees the panels as they now are.
+        this._reconcilePanels();
         try { this.onChange(reason); } catch (err) { console.error('[wm] onChange threw', err); }
         try { this.eventBus?.emit?.('wm:changed', { reason, wm: this }); }
         catch (err) { console.warn('[wm] event emit failed', err); }
@@ -244,10 +268,13 @@ export class WindowManager {
                     }
                 }
             }
-            this._canonicalize(d.tree, d);
         }
+        // A single kind is open once, whatever the saved layout says.
+        const deduped = this._dropDuplicateSingles();
+        for (const d of this.desktops.desktops) this._canonicalize(d.tree, d);
         this.renderer.tree = this.desktops.active().tree;
         this.renderer.render();
+        if (deduped) this._persist();
         this._notifyChange();
     }
 
@@ -259,6 +286,275 @@ export class WindowManager {
         }, 500);
     }
 
+    // ── Single-instance kinds (KindDef `single`) ────────────────────
+    //
+    // Some content holds heavy app-wide state and must exist once. The
+    // taxonomy says which kinds (`single: true`, or `single: '<prop>'` for one
+    // per value of that prop); the WM keeps three promises about them:
+    //
+    //   - every OPEN path reveals the instance that exists — it switches to
+    //     its desktop, activates its tab (restoring an archived page if that is
+    //     where it is) and focuses its tile, or raises its window — instead of
+    //     mounting a second one;
+    //   - the COPY verbs (Alt+T / Alt+N / Alt+Shift+H / Alt+Shift+V, the tile
+    //     menu's "Open in new tab" and "Open a copy in a window", the palette's
+    //     split and window modes) are refused, the menus greyed with a reason;
+    //   - a restored layout holding duplicates keeps the FIRST (desktop order,
+    //     then tile order; live tabs before archived pages).
+    //
+    // MOVE verbs (float, dock, drag a tab, move to desktop) carry the one
+    // instance somewhere else and are untouched.
+
+    /** The instance key of a tab spec, or null when its kind is not single. */
+    _instanceKey(kind, props) {
+        return this.taxonomy.instanceKey(kind, props);
+    }
+
+    /** Whether `kind` exists once, and so refuses the copy verbs. */
+    isSingleKind(kind) {
+        return this.taxonomy.isSingle(kind);
+    }
+
+    /** Where the one instance of a single kind is open, or null — also null
+     *  for a kind that is not single. 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 key = this._instanceKey(kind, props);
+        if (key == null) return null;
+        const same = (t) => !!t && this._instanceKey(t.kind, t.props) === key;
+        for (const [windowId, rec] of this._windowToLeaf) {
+            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 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 leaf of d.tree.leaves()) {
+                for (const [page, arc] of this._archivedPages(leaf)) {
+                    const idx = arc.tabs.findIndex(same);
+                    if (idx >= 0) return { where: 'archive', desktopIdx, leafId: leaf.id, page, idx };
+                }
+            }
+        }
+        return null;
+    }
+
+    /** Reveal the instance of a single kind that is open: answers whether
+     *  there was one. Every open path asks this first. */
+    revealInstance(kind, props = {}) {
+        const loc = this.findInstance(kind, props);
+        return loc ? this._revealAt(loc) : false;
+    }
+
+    /** A leaf's archived pages that can come back — every `pageTabs` entry
+     *  but the CURRENT page's. `swapToPage` restores an archive without
+     *  deleting it, so the current page's entry is a stale copy of the live
+     *  tabs, overwritten the next time the tile leaves the page; counting it
+     *  would find every live instance twice. */
+    _archivedPages(leaf) {
+        const kind = leaf?.content?.kind;
+        const current = kind ? this.taxonomy.topNavFor(kind) || null : null;
+        return Object.entries(leaf?.pageTabs || {})
+            .filter(([page, arc]) => page !== current && Array.isArray(arc?.tabs));
+    }
+
+    /** Reveal `loc` with ONE change notification. The verbs a reveal is made
+     *  of — `showWindowTab`, `switchDesktop` (directly or via `revealWindow`)
+     *  — each notify on their own; inside a reveal they are quiet, and the
+     *  reveal notifies once, as every other verb does. */
+    _revealAt(loc) {
+        this._quietDepth += 1;
+        let shown = false;
+        try { shown = this._revealAtQuietly(loc); }
+        finally { this._quietDepth -= 1; }
+        if (shown) this._notifyChange('single-reveal');
+        return shown;
+    }
+
+    _revealAtQuietly(loc) {
+        if (loc.where === 'window') {
+            const rec = this._windowToLeaf.get(loc.windowId);
+            if (!rec) return false;
+            if (Array.isArray(rec.tabs) && rec.tabs.length) this.showWindowTab(loc.windowId, loc.idx);
+            // A window contained to a pane lives on that pane's desktop;
+            // `revealWindow` switches there. An uncontained one floats over
+            // every desktop and is already on screen.
+            this.revealWindow(rec.window);
+            // `show()` restores a minimised window and raises a visible one.
+            try { rec.window.show(); } catch (err) { console.warn('[wm] reveal: show failed', err); }
+            return true;
+        }
+        const tree = this.desktops.desktops[loc.desktopIdx]?.tree;
+        const leaf = tree?.get(loc.leafId);
+        if (!leaf || leaf.kind !== 'leaf') return false;
+        if (loc.where === 'archive') {
+            const tab = leaf.pageTabs[loc.page].tabs[loc.idx];
+            const key = this._instanceKey(tab.kind, tab.props);
+            const curKind = leaf.content?.kind;
+            const current = curKind ? this.taxonomy.topNavFor(curKind) || null : null;
+            this._swapToPage(tree, loc.leafId,
+                { kind: tab.kind, props: tab.props || {}, title: tab.title },
+                current, loc.page, { recordHistory: false });
+            const at = (leaf.tabs || []).findIndex((t) => this._instanceKey(t.kind, t.props) === key);
+            if (at >= 0) tree.setActiveLeafTab(loc.leafId, at);
+        } else {
+            tree.setActiveLeafTab(loc.leafId, loc.idx);
+        }
+        tree.focus(loc.leafId);
+        // The tree is settled BEFORE the switch, so the switch's one repaint
+        // mounts the instance and nothing else first.
+        if (loc.desktopIdx !== this.desktops.activeIdx) {
+            this.switchDesktop(loc.desktopIdx);
+        } else {
+            this.renderer.render();
+            this._persist();
+        }
+        return true;
+    }
+
+    /** `TileTree.swapToPage`, and then no restored tab is a second copy of a
+     *  single kind. Every page restore in the WM goes through here.
+     *
+     *  A page archive (`pageTabs`) is a snapshot: the instance it lists can
+     *  have moved to another tile or a window since — and the current page's
+     *  own entry is a stale copy of the live tabs that comes back into play as
+     *  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. */
+    _swapToPage(tree, leafId, target, currentTopNav, targetTopNav, opts) {
+        const done = tree.swapToPage(leafId, target, currentTopNav, targetTopNav, opts);
+        if (done) this._dropRestoredCopies(tree, leafId, targetTopNav, target);
+        return done;
+    }
+
+    _dropRestoredCopies(tree, leafId, page, target) {
+        const leaf = tree.get(leafId);
+        const tabs = Array.isArray(leaf?.tabs) ? leaf.tabs : null;
+        if (!tabs) return;
+        const elsewhere = this._liveInstanceKeys(tree, leafId);
+        const keeper = () => {
+            const seen = new Set();
+            return (t) => {
+                const k = t ? this._instanceKey(t.kind, t.props) : null;
+                if (k == null) return true;
+                if (elsewhere.has(k) || seen.has(k)) return false;
+                seen.add(k);
+                return true;
+            };
+        };
+        const arc = leaf.pageTabs?.[page];
+        if (arc && Array.isArray(arc.tabs)) {
+            const kept = arc.tabs.filter(keeper());
+            if (kept.length !== arc.tabs.length) {
+                arc.tabs = kept;
+                arc.activeTabIdx = Math.max(0, Math.min(kept.length - 1, arc.activeTabIdx || 0));
+            }
+        }
+        const keep = keeper();
+        let active = leaf.activeTabIdx || 0;
+        let changed = false;
+        for (let i = 0; i < tabs.length;) {
+            if (keep(tabs[i])) { i++; continue; }
+            tabs.splice(i, 1);
+            if (i < active) active -= 1;
+            changed = true;
+        }
+        if (!changed) return;
+        if (!tabs.length) {
+            // Everything the archive held lives elsewhere: the tile shows
+            // what was asked for. (A single target that is live elsewhere was
+            // revealed before any restore, so this tab is never a copy.)
+            tabs.push({
+                kind: target.kind, props: target.props || {},
+                title: target.title || _tabTitle(target.kind, target.props), history: [],
+            });
+            active = 0;
+        }
+        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. */
+    _liveInstanceKeys(tree, leafId) {
+        const keys = new Set();
+        const add = (t) => {
+            const k = t ? this._instanceKey(t.kind, t.props) : null;
+            if (k != null) keys.add(k);
+        };
+        for (const [, rec] of this._windowToLeaf) _windowTabSpecs(rec).forEach(add);
+        for (const d of this.desktops.desktops) {
+            for (const leaf of d.tree.leaves()) {
+                if (d.tree === tree && leaf.id === leafId) continue;
+                (leaf.tabs || []).forEach(add);
+            }
+        }
+        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. */
+    _dropDuplicateSingles() {
+        const seen = new Set();
+        let dropped = false;
+        const keep = (t) => {
+            const k = t ? this._instanceKey(t.kind, t.props) : null;
+            if (k == null) return true;
+            if (seen.has(k)) return false;
+            seen.add(k);
+            return true;
+        };
+        for (const d of this.desktops.desktops) {
+            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; }
+                    tabs.splice(i, 1);
+                    if (i < active) active -= 1;
+                    changed = true;
+                }
+                if (!changed) continue;
+                dropped = true;
+                if (tabs.length) {
+                    tree.setActiveLeafTab(leaf.id, Math.max(0, Math.min(tabs.length - 1, active)));
+                    continue;
+                }
+                tree.close(leaf.id);
+                if (!tree.rootId) tree.setRoot(makeLeaf(this._rootLeaf()));
+                if (!tree.leaves().some((l) => !String(l.content?.kind || '').startsWith('panel:'))) {
+                    const spawned = this._spawnContentLeaf(tree);
+                    if (spawned) this._seedHome(tree, spawned);
+                }
+            }
+        }
+        for (const d of this.desktops.desktops) {
+            for (const leaf of d.tree.leaves()) {
+                for (const [page, arc] of this._archivedPages(leaf)) {
+                    const kept = arc.tabs.filter(keep);
+                    if (kept.length === arc.tabs.length) continue;
+                    dropped = true;
+                    if (!kept.length) { delete leaf.pageTabs[page]; continue; }
+                    arc.tabs = kept;
+                    arc.activeTabIdx = Math.max(0, Math.min(kept.length - 1, arc.activeTabIdx || 0));
+                }
+            }
+        }
+        return dropped;
+    }
+
     // ── Content loading ─────────────────────────────────────────────
     /** Load content into the primary tile (last-active non-panel leaf).
     /** Walk back one step. Bound to Backspace.
@@ -485,13 +781,16 @@ export class WindowManager {
         const tree = this._tree();
         const prior = tree.popActiveTabHistory?.(id);
         if (!prior || !prior.kind) return false;
+        // 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;
         // Cross-page back entries carry a `topNav` marker — pop
         // routes via swapToPage so we land on the correct page.
         const curKind = tree.get(id)?.content?.kind;
         const curTopNav = curKind ? this.taxonomy.topNavFor(curKind) : null;
         const title = prior.title || _tabTitle(prior.kind, prior.props);
         if (prior.topNav && curTopNav && prior.topNav !== curTopNav) {
-            tree.swapToPage?.(id, { kind: prior.kind, props: prior.props || {}, title },
+            this._swapToPage(tree, id, { kind: prior.kind, props: prior.props || {}, title },
                 curTopNav, prior.topNav, { recordHistory: false });
         } else {
             tree.replaceActiveTabContent(id, { kind: prior.kind, props: prior.props || {} },
@@ -593,6 +892,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.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leaf = tree.get(leafId);
         if (!leaf || leaf.kind !== 'leaf') {
@@ -648,6 +948,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.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leaf = tree.get(leafId);
         if (!leaf || leaf.kind !== 'leaf') {
@@ -665,6 +966,7 @@ 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;
         const rec = this._windowToLeaf.get(winId);
         if (!rec) { this.openInPrimary(kind, props); return; }
         try { rec.mountInfo?.destroy?.(); } catch {}
@@ -706,6 +1008,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.revealInstance(kind, props)) return;
         const tree = this._tree();
         let leafId = tree.primaryLeafId();
         let spawned = false;
@@ -726,7 +1029,7 @@ export class WindowManager {
             : null;
         const targetTopNav  = this.taxonomy.topNavFor(kind) || kind;
         const title = _tabTitle(kind, props);
-        tree.swapToPage(leafId,
+        this._swapToPage(tree, leafId,
             { kind, props, title },
             currentTopNav, targetTopNav);
         // C35. THE SAME PAGE WITH DIFFERENT PROPS IS A DIFFERENT VIEW. swapToPage
@@ -788,6 +1091,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.revealInstance(kind, props)) return null;
         const tree = this._tree();
         leafId = this._contentLeafId(leafId);
         const src = leafId ? tree.get(leafId) : null;
@@ -826,10 +1130,11 @@ export class WindowManager {
         return { leafId: id, kind, props: leaf.content.props || {}, title: leaf.title };
     }
 
-    /** Alt+T — open the focused tile's content in a new tab on that tile. */
+    /** Alt+T — open the focused tile's content in a new tab on that tile.
+     *  A copy verb, so a single kind refuses it (and Alt+N, Alt+Shift+H/V). */
     openFocusedInTab() {
         const c = this._focusedContent();
-        if (!c) return;
+        if (!c || this.isSingleKind(c.kind)) return;
         this.openInTabFromContext({ leafId: c.leafId }, c.kind, c.props);
     }
 
@@ -837,7 +1142,7 @@ export class WindowManager {
      *  Unlike Alt+F (promote) this DUPLICATES: the source tile stays put. */
     openFocusedInWindow() {
         const c = this._focusedContent();
-        if (!c) return;
+        if (!c || this.isSingleKind(c.kind)) return;
         this._navigateWindow(c.kind, c.props);
     }
 
@@ -847,6 +1152,7 @@ export class WindowManager {
     splitFocusedWith(dir) {
         const c = this._focusedContent();
         if (!c) { this.split(dir); return; }
+        if (this.isSingleKind(c.kind)) return;
         this.splitLeafWith(c.leafId, dir, c.kind, c.props, c.title);
     }
 
@@ -3138,16 +3444,97 @@ export class WindowManager {
      *  edge (a recursive split) or closes that leaf. */
     isPanelOpen(side) {
         const d = this.desktops.active();
-        return !!d.panels[side];
+        return !!d.panels[side] && this.isPanelAvailable(side);
     }
 
+    /** Flip a panel. A withheld panel is not flipped: answers `false` and
+     *  touches nothing — not the remembered open state, not the layout, not
+     *  what is persisted. Answers `true` when it flipped. */
     togglePanel(side) {
+        if (!this.isPanelAvailable(side)) return false;
         const d = this.desktops.active();
         d.panels[side] = !d.panels[side];
         this._canonicalize(this._tree(), d);
         this.renderer.render();
         this._persist();
         this._notifyChange();
+        return true;
+    }
+
+    // ── Panel availability ──────────────────────────────────────────
+    /** Whether the panel on `side` is offered on the active desktop right now:
+     *  `{ available, reason }`. A runtime override wins; else the primary
+     *  tile's kind says (`KindDef.panels`, see kind_taxonomy.js); else it is
+     *  offered. `desktops.panels` is untouched by any of this — it remembers
+     *  what the user OPENED, so a panel withheld while it was open comes back
+     *  open once it is offered again. */
+    getPanelAvailability(side, tree = this._tree()) {
+        assertPanelSide(side, 'getPanelAvailability');
+        const override = this._panelOverrides[side];
+        if (override) return override;
+        const id = tree.primaryLeafId();
+        const content = id ? tree.get(id)?.content : null;
+        // A tile holding a floated window's place still stands for that content.
+        const kind = content?.kind === PLACEHOLDER_KIND
+            ? content.props?.originalKind
+            : content?.kind;
+        return this.taxonomy.panelOffer(kind, side);
+    }
+
+    isPanelAvailable(side) {
+        return this.getPanelAvailability(side).available;
+    }
+
+    /** Content's say, at runtime: `offer` is `true`, `false` or `{ reason }`
+     *  and beats the kind's declaration until it is cleared with `null`. The
+     *  override belongs to the shell, not to a tile — content that sets one
+     *  clears it when it goes (its `destroy`). */
+    setPanelAvailability(side, offer) {
+        assertPanelSide(side, 'setPanelAvailability');
+        if (offer === null || offer === undefined) delete this._panelOverrides[side];
+        else this._panelOverrides[side] = readPanelOffer(offer, 'setPanelAvailability');
+        this._notifyChange('panel-availability');
+    }
+
+    /** Subscribe to availability changes. `fn({ panels, changed })` runs ONCE
+     *  per change, however many sides changed in it: `panels` is every side's
+     *  `{ available, reason }`, `changed` the sides that differ from the last
+     *  call. The same payload goes out on the bus as `wm:panels:availability`.
+     *  Returns the unsubscribe. */
+    onPanelAvailabilityChange(fn) {
+        this._panelAvailabilityListeners.add(fn);
+        return () => this._panelAvailabilityListeners.delete(fn);
+    }
+
+    /** Bring the active desktop's panel leaves in line with what is offered,
+     *  and announce a change of availability. Called from `_notifyChange`, so
+     *  every path that can change the primary kind passes through it. */
+    _reconcilePanels() {
+        if (this._reconcilingPanels || !this.desktops) return;
+        this._reconcilingPanels = true;
+        try {
+            const d = this.desktops.active();
+            const panels = {};
+            for (const side of PANEL_SIDES) panels[side] = this.getPanelAvailability(side, d.tree);
+            const shown = (side) => !!d.panels[side] && panels[side].available;
+            if (d.tree.rootId && PANEL_SIDES.some((s) => shown(s) !== !!this._findPanelLeaf(s))) {
+                this._canonicalize(d.tree, d);
+                this.renderer.render();
+            }
+            const last = this._panelAvailability;
+            const changed = PANEL_SIDES.filter((s) => last[s].available !== panels[s].available
+                || last[s].reason !== panels[s].reason);
+            if (!changed.length) return;
+            this._panelAvailability = panels;
+            const payload = Object.freeze({ panels: Object.freeze(panels), changed, wm: this });
+            for (const fn of [...this._panelAvailabilityListeners]) {
+                try { fn(payload); } catch (err) { console.error('[wm] panel availability listener threw', err); }
+            }
+            try { this.eventBus?.emit?.('wm:panels:availability', payload); }
+            catch (err) { console.warn('[wm] event emit failed', err); }
+        } finally {
+            this._reconcilingPanels = false;
+        }
     }
 
     /** Rebuild the tree so panel:* leaves sit in the canonical positions:
@@ -3162,16 +3549,30 @@ export class WindowManager {
      *  Existing panel leaves are detached + re-attached (same id), so the
      *  renderer cache keeps the mounted content (nav filter state, etc.). */
     _canonicalize(tree, desktop) {
-        // 1. Find existing panel leaves.
-        const panel = {};
-        for (const leaf of tree.leaves()) {
-            const kind = leaf.content?.kind;
-            if (kind === 'panel:left')   panel.left   = leaf;
-            else if (kind === 'panel:right')  panel.right  = leaf;
-            else if (kind === 'panel:bottom') panel.bottom = leaf;
+        // 0. Which panels this tree shows: the ones the user has open AND the
+        //    primary content offers. A withheld panel is left out without
+        //    forgetting it was open (`desktop.panels` is not written).
+        const open = {};
+        for (const side of PANEL_SIDES) {
+            open[side] = !!desktop.panels[side] && this.getPanelAvailability(side, tree).available;
         }
 
-        // 2. Detach each panel leaf from its current parent. (We don't
+        // 1. Find existing panel leaves.
+        const panel = _panelLeaves(tree);
+
+        // 2. Measure each panel that has no share yet BEFORE anything is
+        //    detached. Detaching collapses the panel's split, so this is the
+        //    last moment a size the tree still holds can be read: a panel
+        //    still at its default, or a stored blob that predates
+        //    `panelShares`. A panel that has a share keeps it: the tree holds
+        //    what was BUILT from that share, which the drag range may have
+        //    held back (step 5), and only a drag (_onSplitResized) changes
+        //    what the user asked for. A tree a structural change has just
+        //    left non-canonical measures nothing; see _recordPanelShares.
+        this._recordPanelShares(tree, desktop);
+        const share = desktop.panelShares;
+
+        // 3. Detach each panel leaf from its current parent. (We don't
         //    use tree.close because that deletes the node; we want to
         //    preserve identity so the renderer keeps the mounted body.)
         const detach = (leaf) => {
@@ -3194,15 +3595,15 @@ export class WindowManager {
         };
         detach(panel.left); detach(panel.right); detach(panel.bottom);
 
-        // 3. The content subtree may legitimately be empty — the user
+        // 4. The content subtree may legitimately be empty — the user
         //    is allowed to close the last main tile and let panels
         //    take over the entire WM area. If so, seed root from the
         //    first requested panel; otherwise content stays as root.
         let seededSide = null;
         if (!tree.rootId) {
-            seededSide = desktop.panels.left   ? 'left'
-                       : desktop.panels.bottom ? 'bottom'
-                       : desktop.panels.right  ? 'right'
+            seededSide = open.left   ? 'left'
+                       : open.bottom ? 'bottom'
+                       : open.right  ? 'right'
                        : null;
             if (seededSide) {
                 const seed = panel[seededSide] || makeLeaf({
@@ -3221,8 +3622,30 @@ export class WindowManager {
             // the "Empty desktop" placeholder).
         }
 
-        // 4. Wrap content row with left + right (h-split), then wrap
+        // 5. Wrap content row with left + right (h-split), then wrap
         //    that with bottom (v-split) so bottom spans full width.
+        //
+        //    Sizes: a panel with a share from step 2 gets back the same
+        //    share of the WM area; only a panel that has never had one (opened
+        //    for the first time on this desktop) takes the default 1:4. Left
+        //    sits INSIDE the right panel's split, so its slot share of that
+        //    inner split is its area share divided by the slot the right panel
+        //    leaves over, which keeps the Navigator's width when the right
+        //    panel is toggled. The drag range is applied here, to the slot
+        //    share of the split being built, for every side: a share taken at
+        //    a different time (the right panel dragged wide while the left was
+        //    closed) can ask for a slot past it, and no split is built that a
+        //    splitter drag could not produce. A canonical tree built from its
+        //    own measured shares therefore comes back at the same sizes.
+        const willWrap = (side) => open[side] && seededSide !== side && !!tree.rootId;
+        const DEFAULT_SHARE = 1 / 5;
+        const slotShare = (side) => {
+            const own = share[side];
+            if (own == null) return null;
+            if (side !== 'left' || !willWrap('right')) return _clampSlotShare(own);
+            const right = _clampSlotShare(share.right ?? DEFAULT_SHARE);
+            return _clampSlotShare(own / (1 - right));
+        };
         const wrap = (panelLeaf, side) => {
             // Re-register the leaf if it was orphaned by detach.
             if (panelLeaf && !tree.nodes.has(panelLeaf.id)) {
@@ -3240,9 +3663,9 @@ export class WindowManager {
             const before = (side === 'left');
             const dir = (side === 'bottom') ? 'v' : 'h';
             const children = before ? [leaf.id, tree.rootId] : [tree.rootId, leaf.id];
-            const sizes = (side === 'bottom') ? [4, 1]
-                        : (side === 'left')   ? [1, 4]
-                        :                       [4, 1];
+            const kept = slotShare(side);
+            const sizes = (kept != null) ? (before ? [kept, 1 - kept] : [1 - kept, kept])
+                        : before ? [1, 4] : [4, 1];
             const split = {
                 id: `split-panel-${side}-${Math.random().toString(36).slice(2, 7)}`,
                 kind: 'split', parentId: null, dir, children, sizes,
@@ -3256,12 +3679,12 @@ export class WindowManager {
         // Skip the side already consumed as the seed root (would
         // otherwise wrap a fresh duplicate leaf around the existing
         // panel-as-root).
-        if (desktop.panels.left   && seededSide !== 'left'   && tree.rootId) wrap(panel.left,   'left');
-        if (desktop.panels.right  && seededSide !== 'right'  && tree.rootId) wrap(panel.right,  'right');
-        if (desktop.panels.bottom && seededSide !== 'bottom' && tree.rootId) wrap(panel.bottom, 'bottom');
+        if (willWrap('left'))   wrap(panel.left,   'left');
+        if (willWrap('right'))  wrap(panel.right,  'right');
+        if (willWrap('bottom')) wrap(panel.bottom, 'bottom');
 
-        // GC orphaned nodes (panel leaves whose `panels.X` flipped to
-        // false stayed in tree.nodes after detach).
+        // GC orphaned nodes (panel leaves whose side is no longer shown —
+        // closed, or withheld — stayed in tree.nodes after detach).
         const reachable = new Set();
         const walk = (id) => {
             if (!id || reachable.has(id)) return;
@@ -3275,6 +3698,72 @@ export class WindowManager {
         }
     }
 
+    /** A finished splitter drag of split `splitId` is a layout change like
+     *  any other: record the shares of the panels that split sizes (the ones
+     *  inside it; the Navigator sits inside the right panel's split) while
+     *  the tree is still canonical (a drag never changes its structure), then
+     *  save, so the dragged size is what the next load, or the next
+     *  structural change, gives back. */
+    _onSplitResized(splitId) {
+        this._recordPanelShares(this._tree(), this.desktops.active(), splitId);
+        this._persist();
+        this._notifyChange('split-resized');
+    }
+
+    /** Keep `desktop.panelShares` current: each panel's share of the WM area
+     *  along its own axis (width for left/right, height for bottom), kept on
+     *  the desktop record and serialized with it, so a panel the user closes
+     *  comes back at the size it had, even across a reload while it was
+     *  closed. With `resizedSplitId`, the panels inside that split are
+     *  measured (a drag); without, the panels that have no share yet are.
+     *  A panel that measures nothing (not on the tree, the root, or under a
+     *  split that is not one of its canonical panel splits) keeps the share
+     *  it last had. A share is recorded as measured, never clamped: the drag
+     *  range belongs to the slot of the split being built (step 5 of
+     *  _canonicalize), not to an area share. A stored value that is not a
+     *  share at all (not a finite number strictly between 0 and 1) is
+     *  dropped, so that panel opens at the default again. */
+    _recordPanelShares(tree, desktop, resizedSplitId = null) {
+        const panel = _panelLeaves(tree);
+        for (const side of PANEL_SIDES) {
+            const kept = _validShare(desktop.panelShares[side]);
+            const measure = resizedSplitId == null ? kept == null
+                          : _isInside(tree, panel[side], resizedSplitId);
+            const v = (measure ? this._panelShare(tree, panel[side], side) : null) ?? kept;
+            if (v == null) delete desktop.panelShares[side];
+            else desktop.panelShares[side] = v;
+        }
+    }
+
+    /** The share (0..1) of the WM area the `side` panel leaf takes along its
+     *  axis: the product of its shares in every ancestor split running that
+     *  way (splits across the axis do not change it). Only a CANONICAL
+     *  placement measures: the leaf's own parent is its `split-panel-<side>`
+     *  split and every ancestor is a panel split. Any other tree is one a
+     *  structural change has left in passing (the last content tile closed,
+     *  or a spawned content leaf wrapping the whole root), whose sizes are
+     *  not the user's; that, a missing or root leaf, or a degenerate split
+     *  gives null. */
+    _panelShare(tree, leaf, side) {
+        if (!leaf?.parentId) return null;
+        if (!String(leaf.parentId).startsWith(`split-panel-${side}-`)) return null;
+        const axis = side === 'bottom' ? 'v' : 'h';
+        let frac = 1;
+        let node = leaf;
+        while (node.parentId) {
+            const parent = tree.get(node.parentId);
+            if (!parent || !String(parent.id).startsWith('split-panel-')) return null;
+            if (parent.dir === axis) {
+                const idx = parent.children.indexOf(node.id);
+                const total = parent.sizes.reduce((a, b) => a + b, 0);
+                if (idx < 0 || !(total > 0) || !(parent.sizes[idx] > 0)) return null;
+                frac *= parent.sizes[idx] / total;
+            }
+            node = parent;
+        }
+        return (frac > 0 && frac < 1) ? frac : null;
+    }
+
     _findPanelLeaf(side) {
         const kind = `panel:${side}`;
         for (const leaf of this._tree().leaves()) {
@@ -3692,6 +4181,7 @@ export class WindowManager {
     /** Spawn a fresh ManagedWindow with the requested content. No
      *  source leaf — closing the window just disposes the content. */
     _navigateWindow(kind, props) {
+        if (this.revealInstance(kind, props)) return;
         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';
@@ -3820,6 +4310,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.revealInstance(kind, props)) return;
         // Managed-window content: just open in the window — managed
         // windows aren't tabbed (one window = one content).
         if (ctx?.windowId && this._windowToLeaf.has(ctx.windowId)) {
@@ -3855,6 +4346,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.revealInstance(kind, props)) return;
         const tree = this._tree();
         const leafId = tree.primaryLeafId();
         // No content tile on this desktop (e.g. a panels-only layout) —
@@ -3874,6 +4366,39 @@ export class WindowManager {
 }
 
 
+/** The panel leaves of `tree`, by side. */
+function _panelLeaves(tree) {
+    const panel = {};
+    for (const leaf of tree.leaves()) {
+        const kind = leaf.content?.kind;
+        if (kind === 'panel:left')        panel.left   = leaf;
+        else if (kind === 'panel:right')  panel.right  = leaf;
+        else if (kind === 'panel:bottom') panel.bottom = leaf;
+    }
+    return panel;
+}
+
+/** Whether `node` sits (at any depth) inside the split `splitId`. */
+function _isInside(tree, node, splitId) {
+    for (let id = node?.parentId; id; id = tree.get(id)?.parentId) {
+        if (id === splitId) return true;
+    }
+    return false;
+}
+
+/** `v` if it is a share (a finite number strictly between 0 and 1), else
+ *  null. */
+function _validShare(v) {
+    return (typeof v === 'number' && Number.isFinite(v) && v > 0 && v < 1) ? v : null;
+}
+
+/** A slot share of a split being built, held to the range a splitter drag
+ *  allows a slot: [MIN_SLOT_FRACTION, 1 - MIN_SLOT_FRACTION]. */
+function _clampSlotShare(v) {
+    const min = TileRenderer.MIN_SLOT_FRACTION;
+    return Math.min(Math.max(v, min), 1 - min);
+}
+
 /** Derive a tab's display title from the content it carries — entity
  *  label first, then id, then the bare kind. Used everywhere a tab is
  *  created, so the bar names what the user opened rather than the kind
@@ -3886,6 +4411,13 @@ function _tabTitle(kind, props) {
     return kind || '';
 }
 
+/** The tab specs a window record holds: a floated pane's list, or the one
+ *  content an Alt+N / adopted window carries. */
+function _windowTabSpecs(rec) {
+    if (Array.isArray(rec?.tabs) && rec.tabs.length) return rec.tabs;
+    return rec?.original ? [rec.original] : [];
+}
+
 /** R8. A leaf's tabs as the plain specs a window record holds — deep enough
  *  that editing one afterwards cannot reach back into the tree, which matters
  *  because a floated tab keeps being edited (`openInWindow` renames it) while