flexdesk 0.17.15 → 0.17.17

package/dist/wm.js

@@ -8,14 +8,14 @@ import {
 } from "./chunk-REJ5HLIM.js";
 import {
   showContextMenu
-} from "./chunk-AD7FIA3Z.js";
+} from "./chunk-7JI7HHSY.js";
 import {
   openForm
-} from "./chunk-OEG6NPAN.js";
+} from "./chunk-XJNADRGR.js";
 import {
   ManagedWindow,
   isRowActivation
-} from "./chunk-MADMGRX2.js";
+} from "./chunk-PGZ4EHSE.js";
 import "./chunk-HNU6MM2B.js";
 import {
   NotebookTabBar
@@ -2642,6 +2642,28 @@ function createTaxonomy({ kinds, root } = {}) {
         `createTaxonomy: '${kind}'.single must be true or a prop name`
       );
     }
+    if (def.window != null) {
+      const w = def.window;
+      const bad = (v) => v != null && !(typeof v === "number" && Number.isFinite(v) && v > 0);
+      if (typeof w !== "object" || Array.isArray(w) || bad(w.width) || bad(w.height)) {
+        throw new TypeError(
+          `createTaxonomy: '${kind}'.window must be { width?, height? } in positive px`
+        );
+      }
+    }
+    if (def.windowOnly != null && typeof def.windowOnly !== "boolean") {
+      throw new TypeError(`createTaxonomy: '${kind}'.windowOnly must be true or false`);
+    }
+    if (def.windowOnly && def.isTopNav) {
+      throw new Error(
+        `createTaxonomy: '${kind}' is a top-nav page and cannot be windowOnly \u2014 a page lives in tiles`
+      );
+    }
+  }
+  if (kinds[root].windowOnly) {
+    throw new Error(
+      `createTaxonomy: the root kind '${root}' cannot be windowOnly \u2014 every new pane, tab and desktop is seeded with it`
+    );
   }
   if (kinds[root].single) {
     throw new Error(
@@ -2713,13 +2735,19 @@ function createTaxonomy({ kinds, root } = {}) {
     const s = _kinds[kind]?.single;
     return s === true || typeof s === "string" && s !== "";
   };
+  const isSinglePerDesktop = (kind) => _kinds[kind]?.single === "desktop";
   const instanceKey = (kind, props) => {
     if (!isSingle(kind)) return null;
     const by = _kinds[kind].single;
-    if (by === true) return String(kind);
+    if (by === true || by === "desktop") return String(kind);
     const v = props?.[by];
     return `${kind}\0${v == null ? "" : String(v)}`;
   };
+  const isWindowOnly = (kind) => _kinds[kind]?.windowOnly === true;
+  const windowSize = (kind) => {
+    const w = _kinds[kind]?.window;
+    return w ? { width: w.width ?? null, height: w.height ?? null } : null;
+  };
   const singleReason = (kind) => `${_kinds[kind]?.label || kind} is open once: use the one that is open`;
   return Object.freeze({
     root,
@@ -2734,8 +2762,11 @@ function createTaxonomy({ kinds, root } = {}) {
     panelOffer,
     topNavEntries,
     isSingle,
+    isSinglePerDesktop,
     instanceKey,
-    singleReason
+    singleReason,
+    isWindowOnly,
+    windowSize
   });
 }
 
@@ -5461,7 +5492,11 @@ var WindowManager = class _WindowManager {
         }
       }
     }
-    const deduped = this._dropDuplicateSingles();
+    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();
@@ -5493,6 +5528,28 @@ var WindowManager = 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}\0${k}`;
+  }
   /** The instance key of a tab spec, or null when its kind is not single. */
   _instanceKey(kind, props) {
     return this.taxonomy.instanceKey(kind, props);
@@ -5502,27 +5559,36 @@ var WindowManager = class _WindowManager {
     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:
+   *  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);
@@ -5532,6 +5598,30 @@ var WindowManager = 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.
    *
@@ -5545,7 +5635,11 @@ var WindowManager = 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;
@@ -5658,7 +5752,8 @@ var WindowManager = 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);
@@ -5668,11 +5763,12 @@ var WindowManager = 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 = /* @__PURE__ */ 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);
@@ -5711,16 +5807,23 @@ var WindowManager = 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 = /* @__PURE__ */ 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);
@@ -5728,28 +5831,62 @@ var WindowManager = 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 = /* @__PURE__ */ 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])) {
+          if (keep(tabs[i], desktopIdx)) {
             i++;
             continue;
           }
@@ -5771,10 +5908,10 @@ var WindowManager = 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) {
@@ -5981,6 +6118,7 @@ var WindowManager = class _WindowManager {
     const tree = this._tree();
     const prior = tree.popActiveTabHistory?.(id);
     if (!prior || !prior.kind) return false;
+    if (this._openWindowOnly(prior.kind, prior.props || {})) return true;
     if (this.revealInstance(prior.kind, prior.props || {})) return true;
     const curKind = tree.get(id)?.content?.kind;
     const curTopNav = curKind ? this.taxonomy.topNavFor(curKind) : null;
@@ -6097,6 +6235,7 @@ var WindowManager = 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);
@@ -6151,6 +6290,7 @@ var WindowManager = 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);
@@ -6168,12 +6308,14 @@ var WindowManager = 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;
     }
+    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 {
@@ -6207,6 +6349,7 @@ var WindowManager = 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();
@@ -6267,6 +6410,7 @@ var WindowManager = 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);
@@ -6676,6 +6820,9 @@ var WindowManager = 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
@@ -7130,6 +7277,7 @@ var WindowManager = class _WindowManager {
   bringBackWindow(windowId) {
     const rec = this._windowToLeaf.get(windowId);
     if (!rec) return false;
+    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") {
@@ -7718,6 +7866,7 @@ var WindowManager = class _WindowManager {
       win.clearSnapPreview();
       return true;
     }
+    if (typeof desktopIdx === "number" && desktopIdx !== record.desktopIdx && this.desktopMoveRefusal({ windowId: winId }, desktopIdx)) return false;
     if (typeof desktopIdx === "number") record.desktopIdx = desktopIdx;
     const docked = this.dockWindowInto(winId, {
       leafId,
@@ -7748,6 +7897,7 @@ var WindowManager = class _WindowManager {
   dockWindowInto(windowId, target) {
     const rec = this._windowToLeaf.get(windowId);
     if (!rec || !target?.leafId) return false;
+    if (this._holdsWindowOnly(rec)) return false;
     rec._dock = { ...target };
     rec._demoting = true;
     try {
@@ -7790,6 +7940,7 @@ var WindowManager = class _WindowManager {
     if (!rec) return;
     if (rec.desktopIdx === targetIdx) return;
     if (this.desktops.desktops[targetIdx]?.fixed) return;
+    if (this.desktopMoveRefusal({ windowId }, targetIdx)) return;
     this.desktops.ensureCount(targetIdx + 1);
     rec.desktopIdx = targetIdx;
     if (!rec.homeContainer && rec.homeLeafId) {
@@ -7917,17 +8068,20 @@ var WindowManager = class _WindowManager {
       e.preventDefault();
       const rec = this._windowToLeaf.get(winId);
       if (!rec) return;
-      const items = [
+      const items = this._holdsWindowOnly(rec) ? [] : [
         { label: "Back to tile", icon: "close_fullscreen", action: "back" }
       ];
       const targets = [...this.desktops.desktops.entries()].filter(([i, d]) => i !== rec.desktopIdx && !d.fixed);
       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 || void 0
           });
         }
       }
@@ -8426,7 +8580,9 @@ var WindowManager = 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;
@@ -8474,6 +8630,7 @@ var WindowManager = class _WindowManager {
     if (closeChrome === false || closeChrome?.disabled === true) return;
     if (this.desktops.desktops[idx]?.fixed) return;
     if (idx === this.desktops.activeIdx) return;
+    if (this.desktopMoveRefusal({ leafId: focused.id }, idx)) return;
     this.desktops.ensureCount(idx + 1);
     const target = this.desktops.desktops[idx];
     const tabs = Array.isArray(focused.tabs) && focused.tabs.length ? focused.tabs : [{ kind: focused.content.kind, props: focused.content.props, title: focused.title }];
@@ -8657,6 +8814,7 @@ var WindowManager = class _WindowManager {
   }
   /** The routing behind `navigate`, for a kind known to be registered. */
   _route(kind, props, opts) {
+    if (this._openWindowOnly(kind, props)) return;
     const { ctx = null, transient = false } = opts;
     const background = !!opts.background;
     let { dest = "main", newTab = false } = opts;
@@ -8725,6 +8883,8 @@ var WindowManager = 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);
+    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";
@@ -8741,17 +8901,22 @@ var WindowManager = 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
@@ -8769,9 +8934,11 @@ var WindowManager = 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)
     });
     this._windowToLeaf.set(winId, {
@@ -8842,6 +9009,7 @@ var WindowManager = 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;
     if (ctx?.windowId && this._windowToLeaf.has(ctx.windowId)) {
       this.openInWindow(ctx.windowId, kind, props);
@@ -8875,6 +9043,7 @@ var WindowManager = 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();
@@ -9970,10 +10139,13 @@ function _tileContextMenu(wm, leafId, x, y) {
   if (wm.desktops.desktops.length > 1 && !isPanel) {
     for (const [i, d] of wm.desktops.desktops.entries()) {
       if (i === wm.desktops.activeIdx || d.fixed) continue;
+      const refusal = wm.desktopMoveRefusal({ leafId }, i);
       items.push({
         label: `Move to desktop ${d.label}`,
         icon: "sweep",
-        action: `move:${i}`
+        action: `move:${i}`,
+        disabled: !!refusal,
+        title: refusal || void 0
       });
     }
   }