@jxsuite/studio 6.1.2 → 8.0.0

package/src/workspace/workspace-switch.ts

@@ -0,0 +1,372 @@
+/**
+ * Switching workspaces — the tab half of `view.setWorkspace`, and the rule that keeps the workspace
+ * on screen and the tab on screen in agreement.
+ *
+ * Two invariants, both stated in `docs/studio/interface.md`, "Workspaces":
+ *
+ * 1. **Activating a tab enters its workspace.** Whatever activated it — a click in the Files tree,
+ *    "Open" on a Content row, a search result, session restore — the workspace follows the tab, so
+ *    opening a page from Content lands in Design without anybody asking for Design. This is an
+ *    EFFECT over the active tab rather than a line in every opener, so no opener can forget it.
+ * 2. **Showing a workspace shows its tabs.** `view.setWorkspace` activates the workspace's most
+ *    recently used tab, or opens its home when it has none: the Content, Media and Publish homes,
+ *    `project.json` in its stylebook editor for Styles. Design has no home; with no design tab open
+ *    its stage is empty, which is the home a canvas has.
+ *
+ * Every pane follows the switch, the side pane included: a pane shows its own most recent tab of
+ * the workspace, or none, and its strip draws only that workspace's tabs (`panels/tab-strip.ts`).
+ * Nothing is closed by a switch. A tab of another workspace keeps its place in its pane's strip and
+ * comes back when its workspace does.
+ *
+ * The rule holds for the panes the author is NOT in as well. A read into another pane (a session
+ * restore, `pane.compareWith`) can put a tab of another workspace on that pane's stage without
+ * activating anything the follow sees, and the pane would draw a document under a strip that hides
+ * it. A second effect re-points such a pane at its own tab of the workspace, or clears it
+ * ({@link alignHiddenPanes}); `pane.compareWith` asks for the comparison to be SHOWN, so it enters
+ * the compared document's workspace instead ({@link revealInPane}).
+ *
+ * @docs studio/interface
+ */
+
+import { effect, effectScope, pauseTracking, resetTracking } from "../reactivity";
+import {
+  WORKSPACE_PRESETS,
+  enterWorkspace,
+  presetInspectorOpen,
+  setDockCollapsed,
+  shell,
+} from "../shell";
+import {
+  activateTab,
+  activeTab,
+  clearPaneActiveTab,
+  closeTab,
+  paneById,
+  paneOfTab,
+  setCloseLanding,
+  setEmptyPaneFallback,
+  setTabScope,
+  workspace,
+} from "./workspace";
+import { homeWorkspaceOfTabId, isHomeWorkspace, workspaceHomeTabId } from "./workspace-ids";
+import {
+  isTabInWorkspace,
+  lastTabOfWorkspace,
+  paneTabOfWorkspace,
+  workspaceOfTab,
+  writesOnCanvas,
+} from "./tab-workspace";
+import type { WorkspaceDeps } from "../shell";
+import type { HomeWorkspaceId, WorkspaceId } from "./workspace-ids";
+import type { EffectScope } from "@vue/reactivity";
+
+/**
+ * What a switch needs that this module may not import: the opener of the home that belongs to
+ * another module (the configuration document), the generic homes' opener, and the Inspector's tab
+ * writer.
+ */
+export interface WorkspaceSwitchDeps extends WorkspaceDeps {
+  /** Open (or reveal) `project.json` in its stylebook editor: the Styles workspace's home. */
+  openStyles: () => void;
+  /** Open (or activate) a generic home tab (`workspace/workspace-home.ts`). */
+  openHome: (id: HomeWorkspaceId) => void;
+}
+
+/** What the follow needs: the frame's deps, and the writers that keep a home within reach. */
+export interface WorkspaceFollowDeps extends WorkspaceDeps {
+  /** Put a home in a pane's strip without showing it (`workspace-home.ts` `placeWorkspaceHome`). */
+  placeHome?: (id: HomeWorkspaceId, paneId: string) => void;
+  /** Reopen `project.json` in the Styles home view, when a close left Styles with nothing open. */
+  openStyles?: () => void;
+}
+
+/**
+ * Whether entering `id` on `tab` should put the workspace's home beside it: a workspace with a home
+ * and no tab strip, entered on a tab that is not that home. The pane context bar's Back control
+ * (`workspace/workspace-back.ts`) closes the view and lands on the home, so the home has to be
+ * there to land on: a view of such a workspace never stands in its pane alone.
+ */
+export function wantsHomeBeside(id: WorkspaceId, tabId: string): id is HomeWorkspaceId {
+  return (
+    isHomeWorkspace(id) && !WORKSPACE_PRESETS[id].tabStrip && homeWorkspaceOfTabId(tabId) !== id
+  );
+}
+
+/**
+ * The views a newly shown view replaces in `paneId`: in a workspace with a home and no tab strip,
+ * every other view of that workspace in the pane that can go without losing anything (not its home,
+ * not pinned, nothing unsaved in it).
+ *
+ * A strip-less pane holds its home and ONE view beside it (`workspace/workspace-back.ts`). With no
+ * strip, a second viewer opened from the Site panel, or a viewer left by a workspace switch rather
+ * than by Back, would otherwise stay open where nothing draws it: reachable only by ⌃Tab, and the
+ * tab the next visit to the workspace landed on instead of its home.
+ */
+export function viewsReplacedBy(
+  paneId: string,
+  tabId: string,
+  id: WorkspaceId = shell.workspace,
+): string[] {
+  const pane = paneById(paneId);
+  if (!pane || !wantsHomeBeside(id, tabId)) {
+    return [];
+  }
+  return pane.tabOrder.filter((other) => {
+    const tab = workspace.tabs.get(other);
+    return (
+      other !== tabId &&
+      tab !== undefined &&
+      homeWorkspaceOfTabId(other) !== id &&
+      workspaceOfTab(tab) === id &&
+      !tab.pinned &&
+      !tab.doc.dirty
+    );
+  });
+}
+
+/**
+ * Where closing a pane's active tab lands in a workspace with no tab strip: its home, when the home
+ * is in that pane. `null` everywhere else, which leaves the most recently used tab in charge.
+ */
+export function stripLessLanding(paneId: string, id: WorkspaceId = shell.workspace): string | null {
+  if (!isHomeWorkspace(id) || WORKSPACE_PRESETS[id].tabStrip) {
+    return null;
+  }
+  const home = workspaceHomeTabId(id);
+  return paneById(paneId)?.tabOrder.includes(home) === true ? home : null;
+}
+
+/**
+ * Point every pane except `except` at the workspace: its own most recent tab there, or none.
+ *
+ * `except` is the pane whose active tab the caller has just chosen, so the pane being switched into
+ * is not second-guessed.
+ */
+function alignPanes(id: WorkspaceId, except: string | null): void {
+  for (const pane of workspace.panes) {
+    if (pane.id === except || pane.derived) {
+      continue;
+    }
+    const target = paneTabOfWorkspace(pane, id);
+    if (target === pane.activeTabId) {
+      continue;
+    }
+    if (target) {
+      activateTab(target, { focus: false });
+    } else {
+      clearPaneActiveTab(pane.id);
+    }
+  }
+}
+
+/**
+ * Point every pane the author is not in, whose active tab belongs to another workspace, at its own
+ * tab of the workspace on screen, or at none. The focused pane is the follow's: its active tab
+ * DECIDES the workspace rather than disagreeing with it. A derived pane follows its source.
+ */
+function alignHiddenPanes(): void {
+  const id = shell.workspace;
+  const focused = workspace.activePaneId;
+  for (const pane of workspace.panes) {
+    const tabId = pane.activeTabId;
+    if (pane.id === focused || pane.derived || !tabId || isTabInWorkspace(tabId, id)) {
+      continue;
+    }
+    // The writes below are this effect's own correction, not something it should track.
+    pauseTracking();
+    try {
+      const target = paneTabOfWorkspace(pane, id);
+      if (target) {
+        activateTab(target, { focus: false });
+      } else {
+        clearPaneActiveTab(pane.id);
+      }
+    } finally {
+      resetTracking();
+    }
+  }
+}
+
+/**
+ * Show what a read put into `paneId` at `path` when it belongs to another workspace: activate it
+ * (moving the keyboard there), which enters its workspace through the follow. A tab of the
+ * workspace on screen is left exactly as the read left it.
+ *
+ * `pane.compareWith` is the caller: comparing is a request to SEE the other document, and leaving
+ * it hidden in a strip that filters it out would be a command that visibly did nothing.
+ */
+export function revealInPane(paneId: string, path: string): void {
+  const pane = paneById(paneId);
+  const tabId = pane?.tabOrder.find((id) => workspace.tabs.get(id)?.documentPath === path);
+  if (tabId && !isTabInWorkspace(tabId)) {
+    activateTab(tabId);
+  }
+}
+
+/** The active tab is being written on the canvas: what opens Content's Inspector. */
+function activeWritesOnCanvas(): boolean {
+  const tab = activeTab.value;
+  return tab ? writesOnCanvas(tab) : false;
+}
+
+/** The deps a frame is laid out with: the caller's, plus the rule that reads the active tab. */
+function frameDeps(deps: WorkspaceDeps): WorkspaceDeps {
+  return { ...deps, writingOnCanvas: activeWritesOnCanvas };
+}
+
+/** Open a workspace's home. Design has none, and answers `false`. */
+function openHome(id: WorkspaceId, deps: WorkspaceSwitchDeps): boolean {
+  if (id === "styles") {
+    deps.openStyles();
+    return true;
+  }
+  if (isHomeWorkspace(id)) {
+    deps.openHome(id);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Show a workspace: enter its frame and put its tabs on screen.
+ *
+ * Idempotent. Showing the workspace already on screen re-activates its most recent tab, which is
+ * the tab already showing, so a second ⌘2 changes nothing.
+ */
+export function switchWorkspace(id: WorkspaceId, deps: WorkspaceSwitchDeps): void {
+  /* The TAB first, the frame second. Activating the workspace's tab enters the workspace through
+     the follow below, with that tab already active, which is what lets the preset's Inspector tab
+     land on the document it is for: entering first would write Styles' "Style" tab onto whatever
+     Design document was showing. The explicit entry after it covers the two cases no activation
+     reports: a tab that was ALREADY active, and Design with nothing open. */
+  const recent = lastTabOfWorkspace(id);
+  if (recent) {
+    activateTab(recent);
+  } else {
+    openHome(id, deps);
+  }
+  enterWorkspace(id, frameDeps(deps));
+  const tab = activeTab.value;
+  const kept = tab && isTabInWorkspace(tab.id, id) ? (paneOfTab(tab.id)?.id ?? null) : null;
+  alignPanes(id, kept);
+}
+
+let _scope: EffectScope | null = null;
+
+/**
+ * Start the rule that activating a tab enters its workspace. Idempotent; the bootstrap calls it
+ * once, after the shell has mounted. Returns the function that stops it again and drops the
+ * fallback scope, which a window never needs and a test does.
+ *
+ * It also scopes the panes' fallback (`workspace.ts`'s `setTabScope`), so closing a workspace's
+ * last tab never switches the workspace under the author: the pane is left empty, or, in a
+ * workspace with no tab strip, shows its home (`setEmptyPaneFallback`, {@link fallBackToHome}).
+ */
+export function installWorkspaceFollow(deps: WorkspaceFollowDeps): () => void {
+  if (_scope) {
+    return stopWorkspaceFollow;
+  }
+  setTabScope((tabId) => isTabInWorkspace(tabId));
+  setEmptyPaneFallback((paneId) => fallBackToHome(paneId, deps));
+  setCloseLanding((paneId) => stripLessLanding(paneId));
+  const scope = effectScope();
+  _scope = scope;
+  const withTab = frameDeps(deps);
+  /* Whether the active tab was being written on the canvas at the last run, so a `whileWriting`
+     Inspector (Content's) opens and closes on the TRANSITION, from the Content home into an
+     entry and back, and an author's own toggle on the same tab is left alone. */
+  let writing: boolean | null = null;
+  scope.run(() => {
+    effect(() => {
+      const tab = activeTab.value;
+      if (!tab) {
+        return;
+      }
+      // What the tab IS is tracked — its identity, its editor, its path — because `project.json`
+      // Moves between Design and Styles with its mode. Nothing else is.
+      const id = workspaceOfTab(tab);
+      const nowWriting = writesOnCanvas(tab);
+      /* The entry runs UNTRACKED. It reads `shell.workspace` and the panes, and an effect that
+         depended on them would re-run the moment `switchWorkspace` entered a workspace and, finding
+         the OLD tab still active for one more statement, enter the old workspace straight back. */
+      pauseTracking();
+      try {
+        const paneId = paneOfTab(tab.id)?.id ?? null;
+        // The view on screen replaces the ones beside it nobody can see (a strip-less pane only).
+        if (paneId !== null) {
+          for (const replaced of viewsReplacedBy(paneId, tab.id, id)) {
+            closeTab(replaced);
+          }
+        }
+        if (enterWorkspace(id, withTab)) {
+          alignPanes(id, paneId);
+          if (paneId !== null && wantsHomeBeside(id, tab.id)) {
+            deps.placeHome?.(id, paneId);
+          }
+        } else if (
+          writing !== null &&
+          nowWriting !== writing &&
+          WORKSPACE_PRESETS[id].inspector.whileWriting === true
+        ) {
+          setDockCollapsed("right", !presetInspectorOpen(id, nowWriting));
+        }
+      } finally {
+        resetTracking();
+      }
+      writing = nowWriting;
+    });
+    /* The panes the author is not in. DEFERRED to a microtask, because a switch moves the active
+       tab and the focused pane in two writes, and an effect run between them would see the pane
+       being switched INTO as a hidden pane showing the wrong workspace, and point it straight
+       back. By the microtask every synchronous switch has finished. */
+    let queued = false;
+    const runner = effect(alignHiddenPanes, {
+      scheduler: () => {
+        if (queued) {
+          return;
+        }
+        queued = true;
+        queueMicrotask(() => {
+          queued = false;
+          if (_scope === scope) {
+            runner();
+          }
+        });
+      },
+    });
+  });
+  return stopWorkspaceFollow;
+}
+
+/**
+ * A close left `paneId` with no tab of the workspace on screen: in a workspace with no tab strip,
+ * show its home there. Media, Styles and Publish have no strip to reach another tab from, so an
+ * empty stage there is a dead end (closing the home itself, or the viewer beside a home closed
+ * earlier), where Design's empty stage is its home and Content's strip and Collections panel are
+ * the way back. Styles' home is `project.json` itself, reopened in the view it was left in.
+ */
+function fallBackToHome(paneId: string, deps: WorkspaceFollowDeps): void {
+  const id = shell.workspace;
+  const pane = paneById(paneId);
+  if (!pane || pane.derived || WORKSPACE_PRESETS[id].tabStrip) {
+    return;
+  }
+  if (id === "styles") {
+    deps.openStyles?.();
+    return;
+  }
+  if (!deps.placeHome || !isHomeWorkspace(id)) {
+    return;
+  }
+  deps.placeHome(id, paneId);
+  activateTab(workspaceHomeTabId(id));
+}
+
+/** Stop the follow and drop the fallback scope. */
+function stopWorkspaceFollow(): void {
+  _scope?.stop();
+  _scope = null;
+  setTabScope(null);
+  setEmptyPaneFallback(null);
+  setCloseLanding(null);
+}

package/src/workspace/workspace.ts

@@ -578,9 +578,15 @@ export function closePane(paneId: string) {
      for the side pane's: focused=primary showing=a became focused=primary showing=b, and the only
      way back was the tab strip. Nothing is lost either way, because the closing pane's tabs have
      just been moved into the survivor above; this only decides which of them is on screen. */
+  /* …unless it belongs to another workspace than the one on screen. A derived pane follows the
+     author into every workspace, still showing its source's document, so Close Side Pane run from
+     its own menu in Media would hand the survivor a Design document and carry the author off to
+     Design. The survivor's own tab of the workspace stays in front instead. */
+  const closingShows =
+    pane.activeTabId !== null && _tabScope(pane.activeTabId) ? pane.activeTabId : null;
   survivor.activeTabId =
     workspace.activePaneId === pane.id
-      ? (pane.activeTabId ?? survivor.activeTabId)
+      ? (closingShows ?? survivor.activeTabId ?? pane.activeTabId)
       : (survivor.activeTabId ?? pane.activeTabId);
   workspace.activePaneId = survivor.id;
   /* Invariant D4, and it goes HERE — after the survivor has inherited the tabs and the focus, and
@@ -621,6 +627,72 @@ export function paneIsEmpty(pane: Pane): boolean {
    live panes now (§18.3), so a zoom is buildable, but no section of studio.md asks for one; it
    comes back with the section that does, and not one release earlier. */
 
+/**
+ * Which tabs a fallback may land on: the tabs of the workspace on screen.
+ *
+ * When the active tab leaves a pane (closed, or moved), the pane falls back to another of its tabs.
+ * A fallback onto a tab of a DIFFERENT workspace would switch the workspace under the author, who
+ * closed a tab and did not ask to go anywhere — so the fallback is scoped, and a pane with no tab
+ * of the workspace left shows none. The predicate is INJECTED by `workspace/workspace-switch.ts`,
+ * because the rule that says which workspace a tab is in reads the project's collections, and this
+ * module sits below all of that. Unset, every tab qualifies, which is the model before workspaces.
+ */
+let _tabScope: (tabId: string) => boolean = () => true;
+
+/** Install the fallback scope. `workspace/workspace-switch.ts` calls it once at boot. */
+export function setTabScope(scope: ((tabId: string) => boolean) | null): void {
+  _tabScope = scope ?? (() => true);
+}
+
+/**
+ * What a pane shows when a close leaves it no tab in scope, or nothing (the stage stays empty).
+ *
+ * Injected by `workspace/workspace-switch.ts` for the same reason {@link setTabScope} is: the answer
+ * (a Navigator-less workspace falls back to its home) is a workspace rule, and this module sits
+ * below the workspaces. Only {@link closeTab} asks, because only a close is the author emptying a
+ * pane; a project switch's {@link closeAllTabs} empties every pane on its way to a new project and
+ * must not plant a home in it.
+ */
+let _emptyFallback: ((paneId: string) => void) | null = null;
+
+/** Install the empty-pane fallback. `workspace/workspace-switch.ts` calls it once at boot. */
+export function setEmptyPaneFallback(fallback: ((paneId: string) => void) | null): void {
+  _emptyFallback = fallback;
+}
+
+/**
+ * Where a close of the ACTIVE tab lands in a pane, ahead of the most recently used tab: a tab id,
+ * or `null` for no preference.
+ *
+ * Injected by `workspace/workspace-switch.ts`, for the reason {@link setTabScope} is. A workspace
+ * that draws no tab strip (Media, Publish) shows its home and one view opened beside it, and
+ * closing that view is the author going back to the home: the most recently used tab could be
+ * another view the strip-less pane is not drawing, which would put the author somewhere they did
+ * not ask to go and cannot see the way out of.
+ */
+let _closeLanding: ((paneId: string) => string | null) | null = null;
+
+/** Install the close landing. `workspace/workspace-switch.ts` calls it once at boot. */
+export function setCloseLanding(landing: ((paneId: string) => string | null) | null): void {
+  _closeLanding = landing;
+}
+
+/** How many open tabs are in scope: the workspace on screen's, which is what ⌃Tab walks. */
+export function scopedTabCount(): number {
+  let count = 0;
+  for (const id of workspace.tabs.keys()) {
+    if (_tabScope(id)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+/** The rightmost tab of a pane that is in scope: the safe default when its active tab leaves. */
+function rightmostInScope(pane: Pane): string | null {
+  return pane.tabOrder.findLast((id) => _tabScope(id)) ?? null;
+}
+
 /**
  * Remove a tab id from whichever pane holds it, without touching the tab itself.
  *
@@ -636,7 +708,7 @@ export function detachTab(tabId: string) {
     }
     pane.tabOrder = pane.tabOrder.filter((id) => id !== tabId);
     if (pane.activeTabId === tabId) {
-      pane.activeTabId = pane.tabOrder.at(-1) ?? null;
+      pane.activeTabId = rightmostInScope(pane);
     }
     /* The PRIMARY is exempt HERE and only here. `splitRight` moves the tab out of the source pane
        through this function, so a lone document split from the primary empties it — and that state
@@ -789,6 +861,22 @@ function syncTreeSelection(tab: Tab) {
   }
 }
 
+/**
+ * Show no tab in a pane, leaving its strip exactly as it is.
+ *
+ * What a pane shows when the workspace on screen has no tab in it: its other tabs are another
+ * workspace's, and they come back when that workspace does. Written only by
+ * `workspace/workspace-switch.ts`; nothing about the tabs, the MRU order or the focus changes.
+ *
+ * @param {string} paneId
+ */
+export function clearPaneActiveTab(paneId: string) {
+  const pane = paneById(paneId);
+  if (pane) {
+    pane.activeTabId = null;
+  }
+}
+
 /**
  * Make `tabId` the active tab OF ITS OWN PANE. The one place activation happens.
  *
@@ -878,7 +966,28 @@ export function openTab(opts: {
   paneId?: string;
   focus?: boolean;
   layout?: JsonLayout | null;
+  /** The text a format-class file was read as (`createTab`'s `source`). */
+  source?: string | null;
+  /** The mode it opens in, when not its first declared one (`createTab`). */
+  canvasMode?: string;
+  /**
+   * Put a NEW tab in the pane's strip without activating it; a tab already open is left exactly as
+   * it is. For a tab that belongs beside the one on screen rather than in front of it: a
+   * workspace's home kept within reach of a document of that workspace.
+   */
+  background?: boolean;
 }) {
+  if (opts.background === true) {
+    const open = workspace.tabs.get(opts.id);
+    if (open) {
+      return open;
+    }
+    const tab = createTab({ ...opts, preview: false });
+    const pane = (opts.paneId === undefined ? undefined : paneById(opts.paneId)) ?? activePane();
+    insertIntoPane(pane, tab.id);
+    workspace.tabs.set(tab.id, tab);
+    return tab;
+  }
   const previous = workspace.tabs.get(opts.id);
   const preview = opts.preview === true && previous?.pinned !== true;
   const tab = createTab({ ...opts, preview });
@@ -1058,12 +1167,15 @@ export function closeTab(tabId: string) {
   // It, which is almost never the rightmost tab in the strip. `detachTab` has already put the
   // Rightmost there as the safe default, so this only ever improves on it.
   const survivor = activePane();
+  const landing = _closeLanding?.(survivor.id) ?? null;
   const next =
-    workspace.mruOrder.find((id) => survivor.tabOrder.includes(id)) ??
-    survivor.tabOrder.at(-1) ??
-    null;
+    (landing !== null && survivor.tabOrder.includes(landing) ? landing : null) ??
+    workspace.mruOrder.find((id) => survivor.tabOrder.includes(id) && _tabScope(id)) ??
+    rightmostInScope(survivor);
   if (next) {
     setActiveTab(next);
+  } else {
+    _emptyFallback?.(survivor.id);
   }
 }
 
@@ -1144,7 +1256,8 @@ export function takeClosedTabPath(): string | undefined {
  */
 export function cycleTab(step: number): string | undefined {
   if (!_cycleList) {
-    _cycleList = workspace.mruOrder.filter((id) => workspace.tabs.has(id));
+    // The workspace on screen's tabs: ⌃Tab walks what the strips draw, never into another workspace.
+    _cycleList = workspace.mruOrder.filter((id) => workspace.tabs.has(id) && _tabScope(id));
     _cycleIndex = 0;
   }
   const list = _cycleList;
@@ -1344,9 +1457,10 @@ export function registerTabCommands(registry: CommandRegistry, deps: TabCommandD
  * @returns {AnyCommand[]}
  */
 export function tabCommands(deps: TabCommandDeps): AnyCommand[] {
-  // The MRU list is workspace-wide, so cycling is available whenever a second document is open —
-  // In either pane, not just the focused one's strip.
-  const twoOrMoreTabs = () => workspace.tabs.size > 1;
+  /* Cycling walks the workspace on screen's tabs, in either pane, not just the focused one's strip
+     (`cycleTab`), so it is available when that workspace has a second tab open. In a workspace
+     with no strip that is its home and a view opened beside it: ⌃Tab moves between the two. */
+  const twoOrMoreTabs = () => scopedTabCount() > 1;
   return [
     {
       id: "document.nextTab",
@@ -1358,7 +1472,7 @@ export function tabCommands(deps: TabCommandDeps): AnyCommand[] {
       group: "2_navigate",
       when: (ctx) => ctx.document.open,
       enablement: twoOrMoreTabs,
-      requires: "a second open document",
+      requires: "a second open document in this workspace",
       run: () => {
         cycleTab(1);
       },
@@ -1373,7 +1487,7 @@ export function tabCommands(deps: TabCommandDeps): AnyCommand[] {
       group: "2_navigate",
       when: (ctx) => ctx.document.open,
       enablement: twoOrMoreTabs,
-      requires: "a second open document",
+      requires: "a second open document in this workspace",
       run: () => {
         cycleTab(-1);
       },

package/styles/shell-frame.css

@@ -51,15 +51,17 @@
   container-type: inline-size;
   container-name: toolbar;
 }
-#toolbar.electrobun-webkit-app-region-drag {
+/* A window handle under the frameless desktop window: the Command Bar (#toolbar) and the
+   boot-failure strip carry it, and the Electron shell drags the window by any area it covers.
+   Unscoped because the class name is self-describing. A no-op in a browser tab. */
+.app-region-drag {
   -webkit-app-region: drag;
 }
-/* The mirror of #toolbar's own drag class above: every interactive control inside the Command Bar
-   carries this (commandbar.json) so Electrobun's ancestry walk finds a working no-drag signal on
-   the button itself instead of falling through to the toolbar's drag region. Unscoped, like
-   .resize-edge below, because the class name is self-describing and used nowhere else. A no-op
-   outside Electrobun. */
-.electrobun-webkit-app-region-no-drag {
+/* The mirror of the drag class above: it marks an interactive control inside a drag region
+   (commandbar.json) so a press on the button reaches the button instead of dragging the window.
+   Unscoped, like .resize-edge below, because the class name is self-describing. A no-op outside a
+   frameless desktop window. */
+.app-region-no-drag {
   -webkit-app-region: no-drag;
 }
 /* Resize edge zones */
@@ -201,6 +203,27 @@
 #app.bottom-collapsed #resize-bottom {
   display: none;
 }
+/* The rail column, out of the grid. `src/shell.ts`'s applyDockLayout() stamps the class from the
+   active workspace's preset: the rail is Design's, and every other workspace gives its 56px to the
+   pane. The column is zero rather than removed so every named line below keeps its place. */
+#app.rail-hidden {
+  grid-template-columns: [rail] 0px [nav] var(--panel-w-left) [pane] 1fr [insp] var(--panel-w-right);
+}
+#app.rail-hidden #activity-bar {
+  display: none;
+}
+/* Every pane's document tab strip, out of the cell. `src/shell.ts`'s applyDockLayout() stamps the
+   class from the active workspace's preset (`tabStrip`): Design and Content draw strips, and
+   Media, Styles and Publish draw their home surface alone, with the pane context bar's Back
+   control leading out of anything opened beside it. The strip stays mounted underneath, so
+   returning to a workspace with strips repaints nothing. A DERIVED pane's strip is the exception,
+   whenever it draws the derivation chip: the chip says what the side pane is a projection of, and
+   its trailing ✕ (Close Side Pane) is a lens's only visible exit, since a lens's context bar draws
+   neither the preset menu nor a Back control. Derived panes follow the author into every
+   workspace, so hiding that row would leave a pane nobody can name or close. */
+#app.tabs-hidden #pane-grid [data-pane-id] > [part="strip"]:not(:has([part="derivation"])) {
+  display: none;
+}
 /* ⑫ Status bar Three fields in the shell's own level order, separated by a rule rather than by a
    run of "|" characters: the boundary between PROJECT, DOCUMENT and SELECTION is structural, and
    the eye should be able to find it without reading. */

package/styles/shell-frame.json

@@ -32,11 +32,12 @@
       "container-type": "inline-size",
       "container-name": "toolbar"
     },
-    "#toolbar.electrobun-webkit-app-region-drag": {
+    ".app-region-drag": {
+      "$description": "A window handle under the frameless desktop window: the Command Bar (#toolbar) and the boot-failure strip carry it, and the Electron shell drags the window by any area it covers. Unscoped because the class name is self-describing. A no-op in a browser tab.",
       "-webkit-app-region": "drag"
     },
-    ".electrobun-webkit-app-region-no-drag": {
-      "$description": "The mirror of #toolbar's own drag class above: every interactive control inside the Command Bar carries this (commandbar.json) so Electrobun's ancestry walk finds a working no-drag signal on the button itself instead of falling through to the toolbar's drag region. Unscoped, like .resize-edge below, because the class name is self-describing and used nowhere else. A no-op outside Electrobun.",
+    ".app-region-no-drag": {
+      "$description": "The mirror of the drag class above: it marks an interactive control inside a drag region (commandbar.json) so a press on the button reaches the button instead of dragging the window. Unscoped, like .resize-edge below, because the class name is self-describing. A no-op outside a frameless desktop window.",
       "-webkit-app-region": "no-drag"
     },
     ".resize-edge": {
@@ -169,6 +170,17 @@
     "#app.bottom-collapsed #bottom-dock, #app.bottom-collapsed #resize-bottom": {
       "display": "none"
     },
+    "#app.rail-hidden": {
+      "$description": "The rail column, out of the grid. `src/shell.ts`'s applyDockLayout() stamps the class from the active workspace's preset: the rail is Design's, and every other workspace gives its 56px to the pane. The column is zero rather than removed so every named line below keeps its place.",
+      "grid-template-columns": "[rail] 0px [nav] var(--panel-w-left) [pane] 1fr [insp] var(--panel-w-right)"
+    },
+    "#app.rail-hidden #activity-bar": {
+      "display": "none"
+    },
+    "#app.tabs-hidden #pane-grid [data-pane-id] > [part=\"strip\"]:not(:has([part=\"derivation\"]))": {
+      "$description": "Every pane's document tab strip, out of the cell. `src/shell.ts`'s applyDockLayout() stamps the class from the active workspace's preset (`tabStrip`): Design and Content draw strips, and Media, Styles and Publish draw their home surface alone, with the pane context bar's Back control leading out of anything opened beside it. The strip stays mounted underneath, so returning to a workspace with strips repaints nothing. A DERIVED pane's strip is the exception, whenever it draws the derivation chip: the chip says what the side pane is a projection of, and its trailing ✕ (Close Side Pane) is a lens's only visible exit, since a lens's context bar draws neither the preset menu nor a Back control. Derived panes follow the author into every workspace, so hiding that row would leave a pane nobody can name or close.",
+      "display": "none"
+    },
     "#statusbar": {
       "$description": "\u246b Status bar Three fields in the shell's own level order, separated by a rule rather than by a run of \"|\" characters: the boundary between PROJECT, DOCUMENT and SELECTION is structural, and the eye should be able to find it without reading.",
       "grid-row": "4",