@jxsuite/studio 6.1.1 → 8.0.0

package/src/workspace/workspace-home.ts

@@ -0,0 +1,133 @@
+/// <reference lib="dom" />
+/**
+ * Workspace homes — the virtual tab a workspace opens on when none of its own tabs is open.
+ *
+ * A home is a tab like a grid is a tab: it sits in a pane's strip, it can be closed, and it has a
+ * canvas mode of its own (`content-home`, `media-home`, `publish-home`) that
+ * `canvas/canvas-render.ts` routes here. It has no document — the tab carries a stub, exactly as
+ * the grid tabs do — and its id is in the `workspace://` space `workspace/workspace-ids.ts`
+ * declares, so it can never collide with a file.
+ *
+ * What a home DRAWS is its workspace's own surface: the Content home is the collection it shows
+ * (`browse/library-pane.ts`, studio.md §22.5), the Media home is the media library
+ * (`media/media-library.ts`, §22.6) and the Publish home is the Publish workspace
+ * (`publish/publish-workspace.ts`, §22.8). The mechanism (the tab, the mode, the routing and the
+ * per-pane mount) is the same for all three, and this module only routes.
+ *
+ * @docs studio/interface
+ */
+
+import { activateTab, openTab, workspace } from "./workspace";
+import { WORKSPACE_HOME_MODES, homeWorkspaceOfTabId, workspaceHomeTabId } from "./workspace-ids";
+import {
+  detachMediaLibrary,
+  mediaLibraryMounted,
+  renderMediaLibrary,
+} from "../media/media-library";
+import { detachLibraryPane, libraryPaneMounted, renderLibraryMode } from "../browse/library-pane";
+import {
+  detachPublishWorkspace,
+  publishWorkspaceMounted,
+  renderPublishWorkspace,
+} from "../publish/publish-workspace";
+import type { HomeWorkspaceId } from "./workspace-ids";
+import type { Tab } from "../tabs/tab";
+import type { CanvasSurface } from "../canvas/canvas-surface";
+
+/** The stub a home tab carries: it is never read, and nothing is ever saved from it. */
+const HOME_STUB_DOCUMENT = { children: [], tagName: "div" };
+
+/** The canvas modes a home draws under. */
+export const WORKSPACE_HOME_MODE_SET: ReadonlySet<string> = new Set(
+  Object.values(WORKSPACE_HOME_MODES),
+);
+
+/** Whether a canvas mode is a workspace home's. */
+export function isWorkspaceHomeMode(mode: string): boolean {
+  return WORKSPACE_HOME_MODE_SET.has(mode);
+}
+
+/**
+ * Open (or activate) a workspace's home.
+ *
+ * Idempotent by construction, which is what lets `view.setWorkspace` say "show me Media" without
+ * caring whether an earlier switch opened its home already.
+ */
+export function openWorkspaceHome(id: HomeWorkspaceId): Tab {
+  const tabId = workspaceHomeTabId(id);
+  const existing = workspace.tabs.get(tabId);
+  if (existing) {
+    activateTab(tabId);
+    return existing;
+  }
+  return openTab({
+    capabilities: { modes: [WORKSPACE_HOME_MODES[id]] },
+    document: structuredClone(HOME_STUB_DOCUMENT),
+    documentPath: null,
+    id: tabId,
+  });
+}
+
+/**
+ * Put a workspace's home in `paneId`'s strip without showing it, unless it is open already.
+ *
+ * A workspace with no Navigator (Media, Publish) has no other way back to its home than its tab: a
+ * media file opened from the Site panel lands in Media on its viewer, and with the home absent the
+ * strip offered that viewer alone and closing it left an empty stage. Keeping the home beside it is
+ * what makes the grid one click away, and what closing the viewer falls back to.
+ */
+export function placeWorkspaceHome(id: HomeWorkspaceId, paneId: string): void {
+  openTab({
+    background: true,
+    capabilities: { modes: [WORKSPACE_HOME_MODES[id]] },
+    document: structuredClone(HOME_STUB_DOCUMENT),
+    documentPath: null,
+    id: workspaceHomeTabId(id),
+    paneId,
+  });
+}
+
+// ─── Mounting ────────────────────────────────────────────────────────────────
+
+/** Whether this tab's home is already mounted in this pane and still in the document. */
+export function workspaceHomeMounted(paneId: string, tab: Tab): boolean {
+  const id = homeWorkspaceOfTabId(tab.id);
+  if (id === "media") {
+    return mediaLibraryMounted(paneId, tab);
+  }
+  if (id === "content") {
+    return libraryPaneMounted(paneId, tab);
+  }
+  return publishWorkspaceMounted(paneId, tab);
+}
+
+/** Tear one pane's home down (mode change, tab switch, project close). Idempotent. */
+export function detachWorkspaceHome(paneId: string): void {
+  detachMediaLibrary(paneId);
+  detachLibraryPane(paneId);
+  detachPublishWorkspace(paneId);
+}
+
+/**
+ * Draw a home tab into its pane's stage.
+ *
+ * @param {CanvasSurface} surface
+ * @param {Tab} tab
+ */
+export function renderWorkspaceHome(surface: CanvasSurface, tab: Tab): void {
+  const { paneId } = surface;
+  if (workspaceHomeMounted(paneId, tab)) {
+    return;
+  }
+  detachWorkspaceHome(paneId);
+  const id = homeWorkspaceOfTabId(tab.id);
+  if (id === "media") {
+    renderMediaLibrary(surface, tab);
+    return;
+  }
+  if (id === "content") {
+    renderLibraryMode(surface, tab);
+    return;
+  }
+  renderPublishWorkspace(surface, tab);
+}

package/src/workspace/workspace-ids.ts

@@ -0,0 +1,129 @@
+/**
+ * The five workspaces, declared where a bare Bun process can read them.
+ *
+ * A workspace is the answer to "what am I doing right now": designing pages, writing content,
+ * managing media, editing the project's styles, or publishing. Studio's top bar switches between
+ * them, and every open tab belongs to exactly one (`workspace/tab-workspace.ts` derives which).
+ *
+ * The ids live in a module with no DOM and no state for the reason `NAVIGATOR_PANEL_IDS` does:
+ * `view.setWorkspace`'s `args` enum is built from {@link WORKSPACE_IDS}, and
+ * `commands/app-commands.ts` must load that enum in the bare Bun process the CI checks run in. A
+ * manifest step naming a workspace this list does not declare is then a red check in the PR that
+ * renamed it, rather than a screenshot of the wrong screen.
+ *
+ * The workspace HOME tab ids are declared here too. A home is a virtual tab (a document the pane
+ * draws that no file backs), and both the derivation that says which workspace a tab belongs to and
+ * the module that opens one must agree on its id, so the id has one definition site that imports
+ * nothing.
+ *
+ * @docs studio/interface
+ */
+
+/** The workspaces, in top-bar order. ⌘1 to ⌘5 follow this order. */
+export const WORKSPACE_IDS = ["design", "content", "media", "styles", "publish"] as const;
+
+export type WorkspaceId = (typeof WORKSPACE_IDS)[number];
+
+/** The workspace a project wakes up in when nothing usable is stored. */
+export const DEFAULT_WORKSPACE: WorkspaceId = "design";
+
+/** One workspace, as the top bar and the palette name it. */
+export interface WorkspaceInfo {
+  id: WorkspaceId;
+  /** What the top-bar tab reads, and what the palette row says after "Show". */
+  title: string;
+  /** A key into the kit's glyph manifest (`@jxsuite/ui/icons`), checked by this module's test. */
+  icon: string;
+}
+
+/** Every workspace, in {@link WORKSPACE_IDS} order. */
+export const WORKSPACES: readonly WorkspaceInfo[] = [
+  {
+    icon: "frame-corners",
+    id: "design",
+    title: "Design",
+  },
+  {
+    icon: "file-text",
+    id: "content",
+    title: "Content",
+  },
+  {
+    icon: "image",
+    id: "media",
+    title: "Media",
+  },
+  {
+    icon: "paint-brush",
+    id: "styles",
+    title: "Styles",
+  },
+  {
+    icon: "paper-plane-tilt",
+    id: "publish",
+    title: "Publish",
+  },
+];
+
+/** Whether a value is a declared workspace id. A stored value is untrusted input. */
+export function isWorkspaceId(value: unknown): value is WorkspaceId {
+  return typeof value === "string" && WORKSPACE_IDS.some((id) => id === value);
+}
+
+/** The record for a workspace id. Total over {@link WorkspaceId}. */
+export function workspaceInfo(id: WorkspaceId): WorkspaceInfo {
+  /* SAFETY of the `!`: WORKSPACES holds one entry per WORKSPACE_IDS member, which this module's
+     test asserts in both directions. */
+  return WORKSPACES.find((entry) => entry.id === id)!;
+}
+
+// ─── Workspace homes ─────────────────────────────────────────────────────────
+
+/**
+ * The scheme a workspace home's tab id carries. Not a path, so it can never collide with a file,
+ * and not `grid://`, which is the grid's id space.
+ */
+const HOME_SCHEME = "workspace://";
+
+/**
+ * The workspaces whose home is a virtual tab of the generic home mechanism, and the canvas mode
+ * that tab draws under.
+ *
+ * Design has no home (an empty stage is its home), and Styles' is `project.json` in its stylebook
+ * editor, opened by the module that owns that document. These three are the generic mechanism's:
+ * Content's home is the collection it shows (`browse/library-pane.ts`), Media's the media library,
+ * and Publish's its own surface.
+ */
+export const WORKSPACE_HOME_MODES = {
+  content: "content-home",
+  media: "media-home",
+  publish: "publish-home",
+} as const satisfies Partial<Record<WorkspaceId, string>>;
+
+/** A workspace whose home is a generic home tab. */
+export type HomeWorkspaceId = keyof typeof WORKSPACE_HOME_MODES;
+
+/** Whether a workspace's home is a generic home tab. */
+export function isHomeWorkspace(id: WorkspaceId): id is HomeWorkspaceId {
+  return Object.hasOwn(WORKSPACE_HOME_MODES, id);
+}
+
+/** The tab id of a workspace's home. */
+export function workspaceHomeTabId(id: HomeWorkspaceId): string {
+  return `${HOME_SCHEME}${id}`;
+}
+
+/** The workspace a home tab id names, or `null` for any other id. */
+export function homeWorkspaceOfTabId(tabId: string): HomeWorkspaceId | null {
+  if (!tabId.startsWith(HOME_SCHEME)) {
+    return null;
+  }
+  const rest = tabId.slice(HOME_SCHEME.length);
+  return isWorkspaceId(rest) && isHomeWorkspace(rest) ? rest : null;
+}
+
+/** The label a home tab's chip reads: the workspace's own title. `null` for any other id. */
+export function workspaceHomeLabel(tabId: string): string | null {
+  const id = homeWorkspaceOfTabId(tabId);
+  return id ? workspaceInfo(id).title : null;
+}

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);
+}