@deepseek-ai/dsh-client-ui-sidebar-right 0.2.0-rc.1 → 0.2.1-alpha.1

package/README.i18n.yaml

@@ -21,8 +21,8 @@
   en: 6d7f145ecb1fd140
   zh: 666d142ef249f6cb
 /deepseek-ai-dsh-client-ui-sidebar-right/the-expand-button:
-  en: 28b0bc3d4050b0e0
-  zh: 733b44ad9309f49a
+  en: 2614d3f179290606
+  zh: 88c08ee260ba57b7
 /deepseek-ai-dsh-client-ui-sidebar-right/state:
   en: 2b15cdf5f1383291
   zh: 57018036d77363ba
@@ -30,8 +30,8 @@
   en: ef2af36136c4a919
   zh: 48d992e2c923a130
 /deepseek-ai-dsh-client-ui-sidebar-right/ctx-sidebarright:
-  en: 8cffef22360aa177
-  zh: a09eef5bb7fdbd61
+  en: 4519c4633d160c2a
+  zh: e4019a62532f885a
 /deepseek-ai-dsh-client-ui-sidebar-right/the-tab-domain:
   en: 717b86e05b44ebdd
   zh: 0f4f694d0ea1d7f8
@@ -51,5 +51,5 @@
   en: 76a763b4dd71babd
   zh: fdc966dd427a82fb
 /deepseek-ai-dsh-client-ui-sidebar-right/known-limitations-and-deferred-work/dev-note:
-  en: 33274d681fac9a21
-  zh: e024c1c4766b289f
+  en: e67f633dc6fe7773
+  zh: e88aeb617ffb74ea

package/README.md

@@ -58,7 +58,7 @@ While the panel is hidden, one button in the conversation header's corner seat (
 
 The panel takes the conversation's ground colour and content font sizes rather than a raised layer of its own: it is a column of the page, not a card over it.
 
-The root-scoped `rightbar` entry renders the selected Session and background Sessions with initialized `keepMounted` bodies through separate `rightbar.session` subtrees. Each View owns its Session reference. Only the foreground Conversation reports a frame track and binds public navigation; other subtrees stay hidden without deleting tab state.
+The root-scoped `rightbar` entry renders the selected Session and background Sessions with initialized `keepMounted` bodies through separate `rightbar.session` subtrees. Each View owns its Session reference. Only the foreground subtree reports a frame track; other subtrees stay hidden without deleting tab state.
 
 <a id="state"></a>
 ## State
@@ -94,9 +94,9 @@ Two more seats extend what is already there: `sidebar.right.tab.guide` (chain) r
 
 `preferNewPane: true` first asks the target docked pane to split under the normal two-pane and room rules, then falls back to that pane when no split is available. `replaceTab` takes precedence and disables this preference.
 
-`close(tabId)` closes a tab; `active()` reads the active tab. `isExpanded()` and `toggleExpanded()` read and drive the column's expansion; `toggleFullscreen(target)` applies the panel control’s display-mode action to a captured dock pane. Layout operations, for callers that arrange the column programmatically, each recorded like the gesture it stands in for: `focus(tabId)` focuses a tab and its pane; `split(paneId?)` splits a docked pane (the active one by default) under the same pane budget and room rule as the strip's control and returns the new pane's id, or `undefined` — recording nothing — when it cannot; `float(tabId, rect?)` takes a docked tab out into a panel; `dock(paneId)` returns a floating panel to the active docked pane. A tab or pane that does not exist, or already is where the call would put it, is left alone. The face exposes operations only: no layout snapshot, no operation log, no lookup by address. `_undo()` / `_redo()` step the mounted surface's history; they are `@internal` — the sequence has no user-facing control, and these exist for tests. Commands need a mounted session surface; with none, they throw rather than write into a surface nobody draws. `mounted` is the observable of the session whose seat is on screen, `undefined` while a global panel replaces the Conversation or no session is selected. A component that opens content from its own mount effect reads it through a bound hook and acts once it is defined: the frame mounts the Conversation column ahead of this seat, and the seat publishes its binding from a passive effect of the same commit, so an effect that assumed a bound seat would run first and throw. The plan review's automatic open reads it this way.
+`close(tabId)` closes a tab; `active()` reads the active tab. `isExpanded()` and `toggleExpanded()` read and drive the column's expansion; `toggleFullscreen(target)` applies the panel control’s display-mode action to a captured dock pane. Layout operations, for callers that arrange the column programmatically, each recorded like the gesture it stands in for: `focus(tabId)` focuses a tab and its pane; `split(paneId?)` splits a docked pane (the active one by default) under the same pane budget and room rule as the strip's control and returns the new pane's id, or `undefined` — recording nothing — when it cannot; `float(tabId, rect?)` takes a docked tab out into a panel; `dock(paneId)` returns a floating panel to the active docked pane. A tab or pane that does not exist, or already is where the call would put it, is left alone. The face exposes operations only: no layout snapshot, no operation log, no lookup by address. `_undo()` / `_redo()` step the on-screen surface's history; they are `@internal` — the sequence has no user-facing control, and these exist for tests. Commands act on the on-screen Session through its adopted store; with no Session on screen, or before the runtime mints its store, they throw rather than write into a surface nobody draws. `mounted` is the observable of the Session on screen: the selected Session while the Conversation fills the main column, `undefined` while a global panel replaces it or no Session is selected. The plugin derives it from the Session selection and `ctx.layout.panelInfo`, and it changes before React renders the change that causes it, so a component rendered in that commit reads the arriving Session and may act on it from its effects: the frame renders that Session's seat in the same pass, which mints its store. Seats never publish it; each reports only what it renders with: the room its docking kit measured, which `split` and `preferNewPane` apply to that Session's panes (unmeasured panes have room), and whether its frame width presents the panel fullscreen automatically, which the fullscreen command applies. The plan review's automatic open reads `mounted` through a bound hook.
 
-`focusedTarget(element?)` resolves the current DOM pane and tab, including an embedding iframe; outside focus returns no page. `commandTarget(element?)` additionally allows an outside open to use the mounted Session's active dock pane. Captures include the occurrence and navigation revision; `isTargetCurrent(target)` rejects changed Sessions, moved or reopened tabs, and intervening navigation. Focus and pointer activation remain separate from persisted layout selection.
+`focusedTarget(element?)` resolves the current DOM pane and tab, including an embedding iframe; outside focus returns no page. `commandTarget(element?)` additionally allows an outside open to use the on-screen Session's active dock pane. Captures include the occurrence and navigation revision; `isTargetCurrent(target)` rejects changed Sessions, moved or reopened tabs, and intervening navigation. Focus and pointer activation remain separate from persisted layout selection.
 
 <a id="the-tab-domain"></a>
 ## The Tab domain
@@ -155,5 +155,3 @@ None; this package neither assembles nor sends a provider request.
 None.
 
 </details>
-
-**Runtime invariant:** No companion is published. The two services (`sidebarRight`, `sidebarRightTabs`) are provided through `ctx.reflect.provide` inside one effect and torn down with it; the seat's binding and the Tab domain's occurrence lifetimes are asserted directly by this package's specs, and no independent observation exists to diverge from them.

package/README.zh.md

@@ -58,7 +58,7 @@ kind: "package-reference"
 
 面板取会话区的底色与正文字号，而不是自成一层浮起的表面：它是页面的一列，不是压在页面上的卡片。
 
-root 作用域的 `rightbar` 入口通过独立的 `rightbar.session` 子树渲染选中的 Session，以及拥有已初始化 `keepMounted` 正文的后台 Session。每个 View 拥有自身的 Session reference。只有前台 Conversation 上报框架列宽并绑定公共导航；其他子树保持隐藏，不删除 tab 状态。
+root 作用域的 `rightbar` 入口通过独立的 `rightbar.session` 子树渲染选中的 Session，以及拥有已初始化 `keepMounted` 正文的后台 Session。每个 View 拥有自身的 Session reference。只有前台子树上报框架列宽；其他子树保持隐藏，不删除 tab 状态。
 
 <a id="state"></a>
 ## 状态
@@ -94,9 +94,9 @@ tab 类型分两阶段注册，随包发布的引导类型走的正是别的包
 
 `preferNewPane: true` 会先按普通的两格上限与空间规则尝试分割目标停靠格，无法分栏时回退到该格。`replaceTab` 优先并会禁用这项偏好。
 
-`close(tabId)` 关闭一个 tab；`active()` 读取活动 tab。`isExpanded()` 与 `toggleExpanded()` 读取并驱动该列的展开；`toggleFullscreen(target)` 对捕获的停靠分栏执行面板控件的显示模式操作。布局操作供以编程方式安排该列的调用方使用，每个都像它替代的手势一样被记录：`focus(tabId)` 聚焦一个 tab 及其格；`split(paneId?)` 在与 tab 条控件相同的格预算与空间规则下分栏一个停靠格（默认活跃格），返回新格的 id，做不到时返回 `undefined`——且不记录任何东西；`float(tabId, rect?)` 把停靠 tab 浮出为浮窗；`dock(paneId)` 把浮窗放回活跃停靠格。不存在的 tab 或格、或已处于调用目标状态的，都原样不动。该接口只暴露操作：没有布局快照、没有操作日志、没有按地址查找。`_undo()` / `_redo()` 步进已挂载停靠面的历史；它们是 `@internal`——序列没有面向用户的控件，这两个只为测试存在。命令需要一个已挂载的会话停靠面；没有时它们 throw，而不是写进一个没人绘制的面里。`mounted` 是「席位正在屏幕上的那个会话」的可观察值，全局面板替代 Conversation 或没有选中会话时为 `undefined`。要在自己的挂载 effect 里打开内容的组件通过绑定的 hook 读取它，并在它有值后再行动：框架把 Conversation 列挂载在这个席位之前，而席位在同一次提交的 passive effect 里才发布绑定，一个假定席位已绑定的 effect 会先运行并 throw。计划审阅的自动打开就是这样读取它的。
+`close(tabId)` 关闭一个 tab；`active()` 读取活动 tab。`isExpanded()` 与 `toggleExpanded()` 读取并驱动该列的展开；`toggleFullscreen(target)` 对捕获的停靠分栏执行面板控件的显示模式操作。布局操作供以编程方式安排该列的调用方使用，每个都像它替代的手势一样被记录：`focus(tabId)` 聚焦一个 tab 及其格；`split(paneId?)` 在与 tab 条控件相同的格预算与空间规则下分栏一个停靠格（默认活跃格），返回新格的 id，做不到时返回 `undefined`——且不记录任何东西；`float(tabId, rect?)` 把停靠 tab 浮出为浮窗；`dock(paneId)` 把浮窗放回活跃停靠格。不存在的 tab 或格、或已处于调用目标状态的，都原样不动。该接口只暴露操作：没有布局快照、没有操作日志、没有按地址查找。`_undo()` / `_redo()` 步进屏幕上停靠面的历史；它们是 `@internal`——序列没有面向用户的控件，这两个只为测试存在。命令通过屏幕上会话已采用的 store 作用于该会话；没有会话在屏幕上、或运行时尚未创建它的 store 时，命令 throw，而不是写进一个没人绘制的面里。`mounted` 是「屏幕上的会话」的可观察值：Conversation 占据主栏时为选中的会话，全局面板替代它或没有选中会话时为 `undefined`。插件从会话选择与 `ctx.layout.panelInfo` 推导它，它在 React 渲染引起变化的那次更新之前就已改变，因此同一次提交里渲染的组件读到的是到来的会话，并可以在自己的 effect 里对它行动：框架在同一轮渲染里渲染该会话的席位，席位随之创建它的 store。席位从不发布它；每个席位只上报它渲染时依据的事实：停靠套件测得的空间，`split` 与 `preferNewPane` 把它用于该会话的分栏（未测量的分栏视为有空间）；以及框架宽度是否让面板自动全屏，全屏命令据此执行。计划审阅的自动打开通过绑定的 hook 读取 `mounted`。
 
-`focusedTarget(element?)` 解析当前 DOM 分栏和标签页，也接受嵌入 iframe；焦点位于外部时不返回页面。`commandTarget(element?)` 另外允许外部打开动作使用已挂载会话的活动停靠分栏。捕获值包含 occurrence 和导航版本；`isTargetCurrent(target)` 拒绝会话变更、已移动或重新打开的标签页，以及期间发生的导航。焦点和指针激活独立于持久化的布局选择。
+`focusedTarget(element?)` 解析当前 DOM 分栏和标签页，也接受嵌入 iframe；焦点位于外部时不返回页面。`commandTarget(element?)` 另外允许外部打开动作使用屏幕上会话的活动停靠分栏。捕获值包含 occurrence 和导航版本；`isTargetCurrent(target)` 拒绝会话变更、已移动或重新打开的标签页，以及期间发生的导航。焦点和指针激活独立于持久化的布局选择。
 
 <a id="the-tab-domain"></a>
 ## Tab 域
@@ -155,5 +155,3 @@ Tab 域按（Session，Tab id）保留品牌化 occurrence id、导航、中止
 无。
 
 </details>
-
-**运行时不变量：** 不发布 companion。两个服务（`sidebarRight`、`sidebarRightTabs`）在同一个 effect 内经 `ctx.reflect.provide` 提供并随之拆除；席位绑定与 Tab 域 occurrence 的生命周期由本包的 spec 直接断言，不存在会与之分歧的独立观察。

package/lib/client.js

@@ -5426,38 +5426,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"unavailable": "P3OORG_unavailable"
 		};
 		//#endregion
-		//#region lib/types/client/shell/close-focus.js
-		/** Focus continuity after page operations replace docked or floating pane elements. */
-		/**
-		* Focus the page selected by an open or split after its DOM has committed.
-		* @param document - product document owning the input focus.
-		* @param sessionId - Session whose page is opening.
-		* @param open - synchronous operation returning its selected pane, or undefined when unchanged.
-		*/
-		function openWithPaneFocus(document, sessionId, open) {
-			let paneId;
-			(0, react_dom.flushSync)(() => {
-				paneId = open();
-			});
-			if (paneId !== void 0) visibleSidebarPane(document, sessionId, paneId)?.focus({ preventScroll: true });
-		}
-		/**
-		* Commit a focused page's removal before focusing a surviving visible pane.
-		* @param document - product document owning the input focus.
-		* @param sessionId - Session whose page is closing.
-		* @param paneId - pane whose page is closing; preferred if it survives.
-		* @param close - synchronous cleanup and layout removal; errors preserve focus.
-		*/
-		function closeWithPaneFocus(document, sessionId, paneId, close) {
-			const before = document.activeElement;
-			const owner = before?.closest("[data-sidebar-right-session]");
-			const source = before?.closest("[data-dockkit-pane], [data-dockkit-float]");
-			const retain = owner?.dataset.sidebarRightSession === sessionId && (source?.dataset.dockkitPane ?? source?.dataset.dockkitFloat) === paneId;
-			(0, react_dom.flushSync)(close);
-			if (!retain || document.activeElement !== document.body && document.activeElement !== before) return;
-			visibleSidebarPane(document, sessionId, paneId)?.focus({ preventScroll: true });
-		}
-		//#endregion
 		//#region lib/types/client/shell/SidebarRight.js
 		/**
 		* The Sidebar's seat in the frame, and the panel it draws.
@@ -5589,12 +5557,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				"data-sidebar-right-tab": tab.id,
 				"data-sidebar-right-occurrence": id,
 				children: content
-			}) : (0, react_jsx_runtime.jsx)("div", {
+			}, id) : (0, react_jsx_runtime.jsx)("div", {
 				className: SidebarRight_module_css_default.tabBody,
 				"data-sidebar-right-tab": tab.id,
 				"data-sidebar-right-occurrence": id,
 				children: content
-			});
+			}, id);
 		}
 		/**
 		* Dispatch a tab's body to its registered type.
@@ -5712,7 +5680,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				"data-sidebar-right-session": sessionId,
 				"data-sidebar-right-panel": fullscreen ? "fullscreen" : "push",
 				"data-sidebar-right-open": expanded || void 0,
-				"aria-hidden": !expanded || void 0,
+				"aria-hidden": !expanded && surface.layout.floats.length === 0 || void 0,
 				children: (0, react_jsx_runtime.jsx)("div", {
 					className: SidebarRight_module_css_default.panelBody,
 					children: (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_dockkit.DockLayout, {
@@ -5747,22 +5715,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		}
 		/**
 		* The right column's occupant: stable tab containers, docked or floating.
-		* It is also where the
-		* frame learns the panel's presentation, and where `ctx.sidebarRight` learns
-		* which session it is acting on, because this is the seat that knows both.
+		* It is also where the frame learns the panel's presentation, because this is
+		* the seat that knows it. `ctx.sidebarRight` names the on-screen Session
+		* itself; this seat reports only what it renders with: the room its kit
+		* measured and the automatic fullscreen rule of its frame width.
 		*/
-		function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, closeTab, useTabTypes, useTabNavigation, occurrence, retainTab, active, useShortcuts, splitPane, toggleFullscreen }) {
+		function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, measureRoom, reportAutoFullscreen, openTab, closeTab, useTabTypes, useTabNavigation, occurrence, retainTab, active, useShortcuts, splitPane, toggleFullscreen }) {
 			const shortcuts = useShortcuts((entries) => entries);
-			const surfaces = useStore((state) => state.bySession);
-			const surface = surfaces[sessionId];
+			const surface = useStore((state) => state.bySession[sessionId]);
 			const shown = active && surface !== void 0 && surface.layout.expanded;
 			const autoFullscreen = viewportWidth < 768;
 			const fullscreen = autoFullscreen || surface?.layout.mode === "fullscreen";
 			const panelRef = (0, react.useRef)(null);
-			const room = (0, react.useRef)(/* @__PURE__ */ new Map());
 			const reportRoom = (0, react.useCallback)((fits) => {
-				room.current = fits;
-			}, []);
+				measureRoom((paneId) => fits.get(paneId)?.row !== false);
+			}, [measureRoom]);
 			const track = shown && !autoFullscreen;
 			(0, react.useEffect)(() => {
 				if (active && surface === void 0) actions.open(sessionId);
@@ -5781,6 +5748,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				fullscreen,
 				canShow
 			]);
+			(0, react.useLayoutEffect)(() => {
+				reportAutoFullscreen(autoFullscreen);
+			}, [reportAutoFullscreen, autoFullscreen]);
 			(0, react.useLayoutEffect)(() => {
 				if (!active) return;
 				let disposed = false;
@@ -5816,26 +5786,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					fullscreen: false
 				});
 			} : void 0, [syncPresentation, active]);
-			(0, react.useEffect)(() => active ? bindService({
-				sessionId,
-				actions,
-				surfaces,
-				autoFullscreen,
-				closeWithFocus: (paneId, close) => {
-					closeWithPaneFocus(document, sessionId, paneId, close);
-				},
-				openWithFocus: (open) => {
-					openWithPaneFocus(document, sessionId, open);
-				},
-				canSplitPane: (paneId) => room.current.get(paneId)?.row !== false
-			}) : void 0, [
-				bindService,
-				sessionId,
-				actions,
-				surfaces,
-				autoFullscreen,
-				active
-			]);
 			if (surface === void 0) return null;
 			return (0, react_jsx_runtime.jsx)(SidebarPanel, {
 				sessionId,
@@ -5862,6 +5812,38 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			});
 		}
 		//#endregion
+		//#region lib/types/client/shell/close-focus.js
+		/** Focus continuity after page operations replace docked or floating pane elements. */
+		/**
+		* Focus the page selected by an open or split after its DOM has committed.
+		* @param document - product document owning the input focus.
+		* @param sessionId - Session whose page is opening.
+		* @param open - synchronous operation returning its selected pane, or undefined when unchanged.
+		*/
+		function openWithPaneFocus(document, sessionId, open) {
+			let paneId;
+			(0, react_dom.flushSync)(() => {
+				paneId = open();
+			});
+			if (paneId !== void 0) visibleSidebarPane(document, sessionId, paneId)?.focus({ preventScroll: true });
+		}
+		/**
+		* Commit a focused page's removal before focusing a surviving visible pane.
+		* @param document - product document owning the input focus.
+		* @param sessionId - Session whose page is closing.
+		* @param paneId - pane whose page is closing; preferred if it survives.
+		* @param close - synchronous cleanup and layout removal; errors preserve focus.
+		*/
+		function closeWithPaneFocus(document, sessionId, paneId, close) {
+			const before = document.activeElement;
+			const owner = before?.closest("[data-sidebar-right-session]");
+			const source = before?.closest("[data-dockkit-pane], [data-dockkit-float]");
+			const retain = owner?.dataset.sidebarRightSession === sessionId && (source?.dataset.dockkitPane ?? source?.dataset.dockkitFloat) === paneId;
+			(0, react_dom.flushSync)(close);
+			if (!retain || document.activeElement !== document.body && document.activeElement !== before) return;
+			visibleSidebarPane(document, sessionId, paneId)?.focus({ preventScroll: true });
+		}
+		//#endregion
 		//#region lib/types/client/shell/RightbarRoot.js
 		/** Root-scoped controller for the right Sidebar's Session content. */
 		function SessionView({ view, visible, SessionProvider, renderSlot, mountView, width, viewportWidth, canShow }) {
@@ -6260,19 +6242,22 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		*
 		* The surface is per session and its state lives in that session's store
 		* instance, which the slot runtime mints per session and a root service cannot
-		* reach on its own. Two paths lead in. The mounted seat publishes its binding —
-		* session id, bound actions, its surface — for exactly as long as it is mounted,
-		* and every command on the public face goes through that binding; a command
-		* arriving with no seat mounted has no session to act on and fails loudly rather
-		* than writing into a surface nobody is drawing. `mounted` publishes that
-		* binding's session as an observable, so a consumer that wants to open content
-		* as soon as a seat is on screen subscribes to it instead of assuming one is
-		* bound when its own effect runs. And the plugin adopts each
-		* session's store instance as the runtime mints it, so the controller reaches
-		* any session's store by id and syncs the Tab domain from that store's commits.
+		* reach on its own. The plugin adopts each session's store instance as the
+		* runtime mints it, so the controller reaches any session's store by id and
+		* syncs the Tab domain from that store's commits, on screen or not.
+		*
+		* The plugin also names the Session on screen — the selected Session while the
+		* Conversation fills the main column — from the selection and the main panel,
+		* before React renders either change, and publishes it as `mounted`. Every
+		* command on the public face acts on that Session through its adopted store; a
+		* command with no Session on screen, or with one whose store the runtime has not
+		* minted, has nothing to act on and fails loudly rather than writing into a
+		* surface nobody is drawing. The seats never publish which Session they draw:
+		* they report only what they render with, the room their docking kit measured
+		* and the automatic fullscreen rule of their frame width.
 		*
 		* A tab's own actions (`tabActions`) aim at the session the tab is in, not at
-		* the mounted one: they run through that session's adopted store, so a callback
+		* the on-screen one: they run through that session's adopted store, so a callback
 		* fired after the user switched sessions still lands where its tab is, and they
 		* do nothing for a session whose store was never minted.
 		*
@@ -6284,24 +6269,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* hand the store one settled intent and record the navigation in the Tab
 		* domain. Placement is the caller's option, never a type's property.
 		*
-		* The registration adopts Session stores and injects the mounted seat binding;
-		* callers use the service's navigation methods.
+		* The registration adopts Session stores, names the on-screen Session, and
+		* forwards the seats' reports; callers use the service's navigation methods.
 		*/
 		/**
-		* Create the public controller and the plugin-private store adoption callback.
+		* Create the public controller and the plugin-private Session callbacks.
 		* Adoption reconciles restored records before any seat renders, then follows commits.
 		* @param tabs - registered tab types.
 		* @param pin - resource retention for an occurrence's lifetime.
-		* @returns the controller and plugin-owned adoption and scope-removal callbacks.
+		* @param host - the viewport rule and focus continuity the commands use.
+		* @returns the controller; store adoption and scope removal; naming the on-screen Session; and recording a seat's room rule.
 		*/
-		function createSidebarRightController(tabs, pin) {
+		function createSidebarRightController(tabs, pin, host) {
 			const adopted = /* @__PURE__ */ new Map();
+			const rooms = /* @__PURE__ */ new Map();
+			const onScreen = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(void 0);
 			const inventory = new SidebarTabInventory();
-			const controller = new SidebarRightController(tabs, pin, adopted, inventory.source);
+			const controller = new SidebarRightController(tabs, pin, host, {
+				adopted,
+				rooms,
+				onScreen,
+				openTabs: inventory.source
+			});
 			return {
 				controller,
 				forget: (sessionId) => {
 					inventory.remove(sessionId);
+					rooms.delete(sessionId);
+				},
+				show: (sessionId) => {
+					if (onScreen.getSnapshot() !== sessionId) onScreen.set(sessionId);
+				},
+				measure: (sessionId, canSplitPane) => {
+					rooms.set(sessionId, canSplitPane);
 				},
 				adopt(sessionId, store) {
 					adopted.get(sessionId)?.unsubscribe();
@@ -6328,13 +6328,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** Cross-plugin right-Sidebar face (ctx.sidebarRight). */
 		var SidebarRightController = class {
 			tabs;
-			adopted;
+			host;
 			/** Open tab metadata across saved and adopted Sessions, independent of visible seats. */
 			openTabs;
-			mountedSession = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(void 0);
-			/** The mounted seat's session; see {@link ISidebarRight.mounted}. */
-			mounted = this.mountedSession;
-			binding;
+			/** The on-screen Session; see {@link ISidebarRight.mounted}. */
+			mounted;
+			adopted;
+			rooms;
 			closeHandlers = /* @__PURE__ */ new Map();
 			/**
 			* Register resource cleanup before explicit removal. Failure preserves the tab.
@@ -6357,13 +6357,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			/**
 			* @param tabs - the tab-type registry consulted to claim an address.
 			* @param pin - `ctx.resources.pin`, which the Tab domain holds addresses with.
-			* @param adopted - plugin-owned session stores used by occurrence actions.
-			* @param openTabs - plugin-owned metadata source across saved and adopted layouts.
+			* @param host - the viewport rule and focus continuity the commands use.
+			* @param sessions - plugin-owned adopted stores, room rules, on-screen Session, and open tab metadata.
 			*/
-			constructor(tabs, pin, adopted = /* @__PURE__ */ new Map(), openTabs = new SidebarTabInventory().source) {
+			constructor(tabs, pin, host, sessions) {
 				this.tabs = tabs;
-				this.adopted = adopted;
-				this.openTabs = openTabs;
+				this.host = host;
+				this.adopted = sessions.adopted;
+				this.rooms = sessions.rooms;
+				this.mounted = sessions.onScreen;
+				this.openTabs = sessions.openTabs;
 				this.tabDomain = new TabDomain(this, pin);
 			}
 			/**
@@ -6375,27 +6378,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				return Object.values(this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId]?.layout.tabs ?? {});
 			}
 			/**
-			* Adopt the mounted seat's binding, replacing any previous one.
-			*
-			* Called from the seat while it is mounted, and released when it leaves.
-			* @param binding - the mounted seat's session, actions, and the store's surfaces.
-			* @returns a release callback that clears exactly this binding.
-			*/
-			bind(binding) {
-				this.binding = binding;
-				this.publishMounted();
-				return () => {
-					if (this.binding !== binding) return;
-					this.binding = void 0;
-					this.publishMounted();
-				};
-			}
-			/** Publish the mounted session only when it changes; a republished binding for the same session is silent. */
-			publishMounted() {
-				const next = this.binding?.sessionId;
-				if (this.mountedSession.getSnapshot() !== next) this.mountedSession.set(next);
-			}
-			/**
 			* Open a resource: claim it, place it, reveal the column, record the navigation.
 			* @param address - a `dsh-resource://<type>/…` address.
 			* @param options - placement, the opening type, and navigation parameters.
@@ -6476,10 +6458,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}
 			/** The steps both opens share: one store intent, and the navigation record for the tab it settles on. */
 			place(sessionId, actions, claim, address, placement, params) {
-				const surface = this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId] ?? (this.binding?.sessionId === sessionId ? this.binding.surfaces[sessionId] : void 0);
+				const surface = this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId];
 				const targetPane = surface === void 0 ? void 0 : placement.paneId ?? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(surface.layout);
 				const target = targetPane === void 0 ? void 0 : surface?.layout.nodes[targetPane];
-				const preferNewPane = placement.preferNewPane === true && placement.replaceTab === void 0 && surface !== void 0 && target?.kind === "pane" && target.host === "dock" && target.tabs.length > 0 && (0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(surface.layout) && (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(surface.layout).length < 2 && this.binding?.sessionId === sessionId && this.binding.canSplitPane(target.id);
+				const preferNewPane = placement.preferNewPane === true && placement.replaceTab === void 0 && surface !== void 0 && target?.kind === "pane" && target.host === "dock" && target.tabs.length > 0 && (0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(surface.layout) && (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(surface.layout).length < 2 && this.mounted.getSnapshot() === sessionId && this.canSplitPane(sessionId, target.id);
 				const commit = () => {
 					actions.openContent(sessionId, {
 						kind: claim.kind,
@@ -6498,7 +6480,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				};
 				const layout = surface?.layout;
 				const replaced = placement.replaceTab === void 0 ? void 0 : layout?.tabs[placement.replaceTab];
-				const revealed = layout === void 0 || placement.revealIfOpened === false ? void 0 : (0, _deepseek_ai_dsh_client_ui_dockkit.findContentTab)(layout, claim.contentId, claim.kind);
+				const replacementPane = replaced === void 0 || layout === void 0 ? void 0 : (0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(layout, replaced.id);
+				const revealed = layout === void 0 ? void 0 : claim.contentId === pageAddress(claim.kind) ? (0, _deepseek_ai_dsh_client_ui_dockkit.findPaneContentTab)(layout, replacementPane?.host === "dock" ? replacementPane.id : placement.paneId ?? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(layout), claim.contentId, claim.kind) : placement.revealIfOpened === false ? void 0 : (0, _deepseek_ai_dsh_client_ui_dockkit.findContentTab)(layout, claim.contentId, claim.kind);
 				if (replaced === void 0 || replaced.id === revealed) {
 					commit();
 					return;
@@ -6506,20 +6489,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				this.removeAfterCleanup(sessionId, replaced, commit);
 			}
 			/**
-			* Close one tab of the mounted session; the sole docked guide remains open.
+			* Close one tab of the on-screen Session; the sole docked guide remains open.
 			* @param tabId - the tab to close.
 			*/
 			close(tabId) {
-				const { sessionId, actions } = this.require();
-				if (this.adopted.has(sessionId)) {
-					this.closeIn(sessionId, tabId);
-					return;
-				}
-				actions.closeTab(sessionId, tabId);
+				this.closeIn(this.require().sessionId, tabId);
 			}
 			/**
 			* The active tab of the active pane.
-			* @returns the record, or `undefined` with no mounted surface.
+			* @returns the record, or `undefined` without an on-screen surface.
 			*/
 			active() {
 				const layout = this.mountedSurface()?.layout;
@@ -6529,15 +6507,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}
 			/**
 			* Whether the column is currently showing its panel.
-			* @returns `true` while expanded; `false` while collapsed or with no mounted surface.
+			* @returns `true` while expanded; `false` while collapsed or without an on-screen surface.
 			*/
 			isExpanded() {
 				return this.mountedSurface()?.layout.expanded ?? false;
 			}
 			/** Collapse the column, or expand it and focus its active dock pane after rendering. */
 			toggleExpanded() {
-				const { sessionId, actions, openWithFocus } = this.require();
-				openWithFocus(() => {
+				const { sessionId, actions } = this.require();
+				this.host.openWithFocus(sessionId, () => {
 					actions.toggleExpanded(sessionId);
 					const layout = this.mountedSurface()?.layout;
 					return layout?.expanded ? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(layout) : void 0;
@@ -6558,26 +6536,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			* @returns current focused page identity, or undefined outside a visible sidebar page.
 			*/
 			focusedTarget(element = document.activeElement) {
-				const binding = this.binding;
-				const surface = this.mountedSurface();
-				return binding === void 0 || surface === void 0 ? void 0 : sidebarTargetFromElement(element, binding.sessionId, surface.layout, (tabId) => this.tabDomain.occurrence(binding.sessionId, { id: tabId }));
+				const screen = this.screen();
+				return screen === void 0 ? void 0 : sidebarTargetFromElement(element, screen.sessionId, screen.surface.layout, (tabId) => this.tabDomain.occurrence(screen.sessionId, { id: tabId }));
 			}
 			/**
-			* Choose a focused sidebar pane, or the mounted Session's active dock pane for an outside open.
+			* Choose a focused sidebar pane, or the on-screen Session's active dock pane for an outside open.
 			* @param element - live command input target; stale sidebar markup never falls back to another pane.
-			* @returns captured target, or undefined without a mounted Session.
+			* @returns captured target, or undefined without an on-screen surface.
 			*/
 			commandTarget(element = document.activeElement) {
 				const focused = this.focusedTarget(element);
 				if (focused !== void 0 || element?.closest("[data-sidebar-right-session]")) return focused;
-				const binding = this.binding;
-				const layout = this.mountedSurface()?.layout;
-				if (binding === void 0 || layout === void 0) return void 0;
+				const screen = this.screen();
+				if (screen === void 0) return void 0;
+				const { sessionId, surface: { layout } } = screen;
 				const pane = (0, _deepseek_ai_dsh_client_ui_dockkit.getPane)(layout, (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(layout));
 				const tabId = pane.activeTabId;
-				const held = tabId === void 0 ? void 0 : this.tabDomain.occurrence(binding.sessionId, { id: tabId });
+				const held = tabId === void 0 ? void 0 : this.tabDomain.occurrence(sessionId, { id: tabId });
 				return {
-					sessionId: binding.sessionId,
+					sessionId,
 					paneId: pane.id,
 					host: pane.host,
 					tabId,
@@ -6592,10 +6569,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			*/
 			openTabFromTarget(kind, target) {
 				if (!this.isTargetCurrent(target)) return;
-				this.require().openWithFocus(() => {
+				const { sessionId, actions } = this.require();
+				this.host.openWithFocus(sessionId, () => {
 					const tab = target.tabId === void 0 ? void 0 : this.mountedSurface()?.layout.tabs[target.tabId];
 					if (target.host === "float" && tab?.kind === kind && this.tabs.get(kind)?.multiple !== true) {
-						this.require().actions.setExpanded(target.sessionId, true);
+						actions.setExpanded(sessionId, true);
 						this.focus(tab.id);
 					} else this.openTab(kind, {
 						...target.host === "dock" ? { paneId: target.paneId } : {},
@@ -6623,20 +6601,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				const surface = this.mountedSurface();
 				if (surface === void 0 || target.tabId === void 0) return "unavailable";
 				const tabId = target.tabId;
-				const binding = this.require();
-				binding.closeWithFocus(target.paneId, () => {
+				const { sessionId, actions } = this.require();
+				this.host.closeWithFocus(sessionId, target.paneId, () => {
 					if (canCloseTab(surface, tabId)) this.close(tabId);
-					else binding.actions.setExpanded(target.sessionId, false);
+					else actions.setExpanded(sessionId, false);
 				});
 				return "closed";
 			}
 			/**
 			* Check a captured target before acting, including reopened records and intervening navigation.
 			* @param target - identity captured while resolving the input.
-			* @returns whether the mounted Session, pane, tab lifetime and navigation still match.
+			* @returns whether the on-screen Session, pane, tab lifetime and navigation still match.
 			*/
 			isTargetCurrent(target) {
-				if (this.binding?.sessionId !== target.sessionId) return false;
+				if (this.mounted.getSnapshot() !== target.sessionId) return false;
 				const layout = this.mountedSurface()?.layout;
 				const pane = layout?.nodes[target.paneId];
 				if (pane?.kind !== "pane" || pane.host !== target.host) return false;
@@ -6658,7 +6636,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				if (!layout.expanded) return "collapsed";
 				if ((0, _deepseek_ai_dsh_client_ui_dockkit.getPane)(layout, target.paneId).tabs.length === 0) return "empty";
 				if (!(0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(layout) || (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(layout).length >= 2) return "budget";
-				if (!this.require().canSplitPane(target.paneId)) return "width";
+				if (!this.canSplitPane(target.sessionId, target.paneId)) return "width";
 			}
 			/**
 			* Toggle the right panel's display mode through the same action as its chrome button.
@@ -6666,9 +6644,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			*/
 			toggleFullscreen(target) {
 				if (!this.isTargetCurrent(target) || target.host === "float" || !this.isExpanded()) return;
-				const { sessionId, actions, autoFullscreen } = this.require();
-				const fullscreen = autoFullscreen === true || this.mountedSurface()?.layout.mode === "fullscreen";
-				if (fullscreen && autoFullscreen === true) actions.setExpanded(sessionId, false);
+				const { sessionId, actions } = this.require();
+				const autoFullscreen = this.host.autoFullscreen();
+				const fullscreen = autoFullscreen || this.mountedSurface()?.layout.mode === "fullscreen";
+				if (fullscreen && autoFullscreen) actions.setExpanded(sessionId, false);
 				actions.setMode(sessionId, fullscreen ? "push" : "fullscreen");
 			}
 			/**
@@ -6677,15 +6656,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			* @returns the new pane's id, or `undefined` when nothing was split.
 			*/
 			split(paneId) {
-				const { sessionId, actions, canSplitPane } = this.require();
+				const { sessionId, actions } = this.require();
 				const layout = this.mountedSurface()?.layout;
 				if (layout === void 0) return void 0;
 				const target = paneId ?? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(layout);
 				const node = layout.nodes[target];
 				if (node === void 0 || node.kind !== "pane" || node.host !== "dock") return void 0;
-				if (!(0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(layout) || (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(layout).length >= 2 || !canSplitPane(target)) return void 0;
+				if (!(0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(layout) || (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(layout).length >= 2 || !this.canSplitPane(sessionId, target)) return void 0;
 				let created;
-				this.require().openWithFocus(() => {
+				this.host.openWithFocus(sessionId, () => {
 					actions.splitPane(sessionId, target, (id) => {
 						created = id;
 					});
@@ -6716,7 +6695,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				actions.unfloatPane(sessionId, paneId);
 			}
 			/**
-			* Step the mounted session's surface back one intent.
+			* Step the on-screen Session's surface back one intent.
 			*
 			* @internal Not part of the product: the sequence is an architectural fact
 			* with no user-facing control yet. Kept reachable for tests.
@@ -6726,7 +6705,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				actions.undo(sessionId);
 			}
 			/**
-			* Step the mounted session's surface forward one intent.
+			* Step the on-screen Session's surface forward one intent.
 			*
 			* @internal See `_undo`.
 			*/
@@ -6734,10 +6713,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				const { sessionId, actions } = this.require();
 				actions.redo(sessionId);
 			}
-			/** The mounted session's surface; `undefined` without a seat or before its first open. */
+			/**
+			* The on-screen Session and its committed surface; `undefined` with no Session
+			* on screen, before the runtime mints its store, or before its first open.
+			*/
+			screen() {
+				const sessionId = this.mounted.getSnapshot();
+				if (sessionId === void 0) return void 0;
+				const surface = this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId];
+				return surface === void 0 ? void 0 : {
+					sessionId,
+					surface
+				};
+			}
+			/** The on-screen Session's surface; see {@link SidebarRightController.screen}. */
 			mountedSurface() {
-				const { binding } = this;
-				return binding === void 0 ? void 0 : this.adopted.get(binding.sessionId)?.store.getSnapshot().bySession[binding.sessionId] ?? binding.surfaces[binding.sessionId];
+				return this.screen()?.surface;
+			}
+			/** Whether a Session's docked pane has room for two working halves, as its seat last measured; unmeasured panes do. */
+			canSplitPane(sessionId, paneId) {
+				return this.rooms.get(sessionId)?.(paneId) ?? true;
 			}
 			/**
 			* The store actions a tab's own action on `sessionId` runs through: that
@@ -6748,8 +6743,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				return this.adopted.get(sessionId)?.store.actions;
 			}
 			require() {
-				if (this.binding === void 0) throw new Error("sidebarRight: no session surface is mounted");
-				return this.binding;
+				const sessionId = this.mounted.getSnapshot();
+				const actions = sessionId === void 0 ? void 0 : this.actionsFor(sessionId);
+				if (sessionId === void 0 || actions === void 0) throw new Error("sidebarRight: no session surface is mounted");
+				return {
+					sessionId,
+					actions
+				};
 			}
 		};
 		//#endregion
@@ -9044,9 +9044,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					views.dispose();
 				};
 			}, "ui-sidebar-right: retained Session views");
-			const { controller, adopt, forget } = createSidebarRightController(tabs, (address, signal) => {
+			const layout = ctx.layout;
+			let autoFullscreen = false;
+			const { controller, adopt, forget, show, measure } = createSidebarRightController(tabs, (address, signal) => {
 				ctx.resources.pin(address, signal);
+			}, {
+				autoFullscreen: () => autoFullscreen,
+				openWithFocus: (sessionId, open) => {
+					openWithPaneFocus(document, sessionId, open);
+				},
+				closeWithFocus: (sessionId, paneId, close) => {
+					closeWithPaneFocus(document, sessionId, paneId, close);
+				}
 			});
+			ctx.effect(() => {
+				const sync = () => {
+					const selected = views.source.getSnapshot().find((view) => view.selected);
+					show(layout.panelInfo.getSnapshot().activePanelId === null ? selected?.sessionId : void 0);
+				};
+				const unsubscribeViews = views.source.subscribe(sync);
+				const unsubscribePanel = layout.panelInfo.subscribe(sync);
+				sync();
+				return () => {
+					unsubscribeViews();
+					unsubscribePanel();
+					show(void 0);
+				};
+			}, "ui-sidebar-right: on-screen Session");
 			const disposeRegistry = ctx.reflect.provide("sidebarRightTabs", tabs);
 			const disposeService = ctx.reflect.provide("sidebarRight", controller);
 			ctx.effect(() => () => {
@@ -9085,13 +9109,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						};
 					}
 				};
-				const layout = ctx.layout;
 				const injected = {
 					syncPresentation({ shown, track, fullscreen }) {
 						if (shown) layout.openRightbar(track, fullscreen);
 						else layout.closeRightbar();
 					},
-					bindService: (binding) => controller.bind(binding),
+					reportAutoFullscreen: (value) => {
+						autoFullscreen = value;
+					},
 					splitPane: (paneId) => {
 						controller.split(paneId);
 					},
@@ -9145,6 +9170,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						store,
 						inject: (sessionId) => ({
 							...injected,
+							measureRoom: (canSplitPane) => {
+								measure(sessionId, canSplitPane);
+							},
 							closeTab: (tabId) => {
 								try {
 									controller.closeIn(sessionId, tabId);

package/lib/types/client/index.d.ts

@@ -6,7 +6,7 @@ export type { RightbarSeatProps, SidebarRightInjected, SidebarRightPresentation
 export type { GuideBodyProps, GuideInjected } from './tabs/guide/GuideBody.tsx';
 export type { ExpandButtonProps } from './shell/ExpandButton.tsx';
 export type { SidebarRightState, SurfaceState } from './stores.ts';
-export type { ISidebarRight, SidebarRightBinding, SidebarRightOpenResourceOptions, SidebarRightOpenTabOptions, SidebarRightPlacement, SidebarRightCloseHandler, SurfaceActions, } from './service.ts';
+export type { ISidebarRight, SidebarRightOpenResourceOptions, SidebarRightOpenTabOptions, SidebarRightPlacement, SidebarRightCloseHandler, SurfaceActions, } from './service.ts';
 export type { SidebarRightGuideBox, SidebarRightGuideEntry, SidebarRightTabClaim, SidebarRightTabDefinition, SidebarRightTabPriority, } from './tab-registry.ts';
 export type { SidebarRightTabInfo, SidebarRightTabInjected, UseSidebarRightTabInfo, SidebarRightTabActions, SidebarRightTabMenuOwnerProps, SidebarRightTabNavigation, SidebarRightTabPlacement, SidebarRightGuideEntryOwnerProps, } from './contract/slots.ts';
 export type { SidebarRightNavigationParams, SidebarRightResourceParams, SidebarRightResourceParamsMap, SidebarRightTabParams, SidebarRightTabParamsFor, SidebarRightTabParamsMap, } from './contract/params.ts';

package/lib/types/client/service.d.ts

@@ -3,19 +3,22 @@
  *
  * The surface is per session and its state lives in that session's store
  * instance, which the slot runtime mints per session and a root service cannot
- * reach on its own. Two paths lead in. The mounted seat publishes its binding —
- * session id, bound actions, its surface — for exactly as long as it is mounted,
- * and every command on the public face goes through that binding; a command
- * arriving with no seat mounted has no session to act on and fails loudly rather
- * than writing into a surface nobody is drawing. `mounted` publishes that
- * binding's session as an observable, so a consumer that wants to open content
- * as soon as a seat is on screen subscribes to it instead of assuming one is
- * bound when its own effect runs. And the plugin adopts each
- * session's store instance as the runtime mints it, so the controller reaches
- * any session's store by id and syncs the Tab domain from that store's commits.
+ * reach on its own. The plugin adopts each session's store instance as the
+ * runtime mints it, so the controller reaches any session's store by id and
+ * syncs the Tab domain from that store's commits, on screen or not.
+ *
+ * The plugin also names the Session on screen — the selected Session while the
+ * Conversation fills the main column — from the selection and the main panel,
+ * before React renders either change, and publishes it as `mounted`. Every
+ * command on the public face acts on that Session through its adopted store; a
+ * command with no Session on screen, or with one whose store the runtime has not
+ * minted, has nothing to act on and fails loudly rather than writing into a
+ * surface nobody is drawing. The seats never publish which Session they draw:
+ * they report only what they render with, the room their docking kit measured
+ * and the automatic fullscreen rule of their frame width.
  *
  * A tab's own actions (`tabActions`) aim at the session the tab is in, not at
- * the mounted one: they run through that session's adopted store, so a callback
+ * the on-screen one: they run through that session's adopted store, so a callback
  * fired after the user switched sessions still lands where its tab is, and they
  * do nothing for a session whose store was never minted.
  *
@@ -27,8 +30,8 @@
  * hand the store one settled intent and record the navigation in the Tab
  * domain. Placement is the caller's option, never a type's property.
  *
- * The registration adopts Session stores and injects the mounted seat binding;
- * callers use the service's navigation methods.
+ * The registration adopts Session stores, names the on-screen Session, and
+ * forwards the seats' reports; callers use the service's navigation methods.
  */
 import { type SidebarRightTarget } from './focus.ts';
 import { type ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
@@ -37,7 +40,7 @@ import type { BoundActions } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SidebarRightResourceParams, SidebarRightTabParamsFor } from './contract/params.ts';
 import type { SidebarRightTabRegistry } from './tab-registry.ts';
-import { type SidebarRightState, type SurfaceState } from './stores.ts';
+import { type SidebarRightState } from './stores.ts';
 import type { createSidebarRightStore } from './stores.ts';
 import { TabDomain, type PinResource } from './tab-domain.ts';
 import { SidebarTabInventory } from './tab-inventory.ts';
@@ -54,41 +57,54 @@ interface Adoption {
     readonly store: SidebarRightSurfaceStore;
     readonly unsubscribe: () => void;
 }
+/** The room rule's verdict for a docked pane, as a seat's docking kit last measured it: whether two working halves would fit. */
+type RoomRule = (paneId: PaneId) => boolean;
+/** Plugin-owned Session state the controller reads; the plugin writes it through the factory's callbacks. */
+interface SidebarRightSessions {
+    /** Each Session's latest adopted store. */
+    readonly adopted: ReadonlyMap<SessionId, Adoption>;
+    /** Each Session's room rule as its seat last reported it; a Session without one has room in every pane. */
+    readonly rooms: ReadonlyMap<SessionId, RoomRule>;
+    /** The Session the plugin names as on screen. */
+    readonly onScreen: ObservableSnapshot<SessionId | undefined>;
+    /** Open tab metadata across saved and adopted Sessions. */
+    readonly openTabs: SidebarTabInventory['source'];
+}
 /**
- * Create the public controller and the plugin-private store adoption callback.
+ * Create the public controller and the plugin-private Session callbacks.
  * Adoption reconciles restored records before any seat renders, then follows commits.
  * @param tabs - registered tab types.
  * @param pin - resource retention for an occurrence's lifetime.
- * @returns the controller and plugin-owned adoption and scope-removal callbacks.
+ * @param host - the viewport rule and focus continuity the commands use.
+ * @returns the controller; store adoption and scope removal; naming the on-screen Session; and recording a seat's room rule.
  */
-export declare function createSidebarRightController(tabs: SidebarRightTabRegistry, pin: PinResource): {
+export declare function createSidebarRightController(tabs: SidebarRightTabRegistry, pin: PinResource, host: SidebarRightHost): {
     controller: SidebarRightController;
     adopt: (sessionId: SessionId, store: SidebarRightSurfaceStore) => () => void;
     forget: (sessionId: SessionId) => void;
+    show: (sessionId: SessionId | undefined) => void;
+    measure: (sessionId: SessionId, canSplitPane: RoomRule) => void;
 };
-/** Everything a command needs, as the mounted seat sees it. */
-export interface SidebarRightBinding {
-    /** The session the mounted seat is drawing. */
-    readonly sessionId: SessionId;
-    /** The seat's store's bound actions; every action names the session it acts on. */
-    readonly actions: SurfaceActions;
+/** What the controller needs from the page around it: the viewport rule and focus continuity. */
+export interface SidebarRightHost {
     /**
-     * The seat's store surfaces as last committed, keyed by session id; the
-     * mounted session's is `surfaces[sessionId]`, absent before the seat's first
-     * open. The runtime mints one store per session, so this holds that session.
+     * Whether the viewport is narrow enough that an expanded panel is presented fullscreen.
+     * @returns the rule's verdict for the frame width the seats last rendered at.
      */
-    readonly surfaces: Readonly<Record<string, SurfaceState>>;
+    readonly autoFullscreen: () => boolean;
     /**
-     * The room rule's verdict for a docked pane, as the kit last measured it:
-     * whether two working halves would fit. Unmeasured panes fit.
+     * Commit a page operation and focus the pane it selects.
+     * @param sessionId - the Session whose page is opening.
+     * @param open - the synchronous operation; returns the selected pane, or `undefined` when unchanged.
      */
-    readonly canSplitPane: (paneId: PaneId) => boolean;
-    /** Commit a keyboard/menu close and retain focus on a surviving visible pane. */
-    readonly closeWithFocus: (paneId: PaneId, close: () => void) => void;
-    /** Commit a page operation and focus the pane it selects. */
-    readonly openWithFocus: (open: () => PaneId | undefined) => void;
-    /** Narrow viewports present an expanded panel fullscreen. */
-    readonly autoFullscreen?: boolean;
+    readonly openWithFocus: (sessionId: SessionId, open: () => PaneId | undefined) => void;
+    /**
+     * Commit a keyboard/menu close and retain focus on a surviving visible pane.
+     * @param sessionId - the Session whose page is closing.
+     * @param paneId - the pane whose page is closing.
+     * @param close - the synchronous cleanup and removal.
+     */
+    readonly closeWithFocus: (sessionId: SessionId, paneId: PaneId, close: () => void) => void;
 }
 /** Where an open lands; every field is optional and the defaults are the common case. */
 export interface SidebarRightPlacement {
@@ -121,12 +137,13 @@ export type SidebarRightCloseHandler = (sessionId: SessionId, tab: TabRecord) =>
 /** The outward right-Sidebar face (`ctx.sidebarRight`). */
 export interface ISidebarRight {
     /**
-     * The session whose seat is mounted, or `undefined` while no seat is on
-     * screen (a global panel is active, or no session is selected). Moves when a
-     * seat binds or releases, so a component that opens content from its own
-     * mount effect reads it through a bound hook and acts once it is defined:
-     * the frame mounts the Conversation column ahead of the seat, and the seat
-     * publishes its binding from a passive effect of the same commit.
+     * The Session on screen, or `undefined` while none is (a global panel fills
+     * the main column, or no Session is selected). It changes before React
+     * renders the selection or panel change that causes it, so every component
+     * rendered in that commit reads the arriving Session, and the commands act on
+     * it from that commit's effects: its seat mints its store in the same render.
+     * Moves only when the on-screen Session changes; the Session's own store
+     * commits are silent.
      */
     readonly mounted: ObservableSnapshot<SessionId | undefined>;
     /**
@@ -150,13 +167,13 @@ export interface ISidebarRight {
      */
     openTab<K extends string>(kind: K, options?: SidebarRightOpenTabOptions<K>): void;
     /**
-     * Close one tab of the mounted session; the sole docked guide remains open.
+     * Close one tab of the on-screen Session; the sole docked guide remains open.
      * @param tabId - the tab to close.
      */
     close(tabId: TabId): void;
     /**
      * The active tab of the active pane.
-     * @returns the record, or `undefined` when no seat is mounted.
+     * @returns the record, or `undefined` with no Session on screen.
      */
     active(): TabRecord | undefined;
     /**
@@ -195,13 +212,13 @@ export interface ISidebarRight {
 /** Cross-plugin right-Sidebar face (ctx.sidebarRight). */
 export declare class SidebarRightController implements ISidebarRight {
     private readonly tabs;
-    private readonly adopted;
+    private readonly host;
     /** Open tab metadata across saved and adopted Sessions, independent of visible seats. */
     readonly openTabs: SidebarTabInventory['source'];
-    private readonly mountedSession;
-    /** The mounted seat's session; see {@link ISidebarRight.mounted}. */
+    /** The on-screen Session; see {@link ISidebarRight.mounted}. */
     readonly mounted: ObservableSnapshot<SessionId | undefined>;
-    private binding;
+    private readonly adopted;
+    private readonly rooms;
     private readonly closeHandlers;
     /**
      * Register resource cleanup before explicit removal. Failure preserves the tab.
@@ -218,26 +235,16 @@ export declare class SidebarRightController implements ISidebarRight {
     /**
      * @param tabs - the tab-type registry consulted to claim an address.
      * @param pin - `ctx.resources.pin`, which the Tab domain holds addresses with.
-     * @param adopted - plugin-owned session stores used by occurrence actions.
-     * @param openTabs - plugin-owned metadata source across saved and adopted layouts.
+     * @param host - the viewport rule and focus continuity the commands use.
+     * @param sessions - plugin-owned adopted stores, room rules, on-screen Session, and open tab metadata.
      */
-    constructor(tabs: SidebarRightTabRegistry, pin: PinResource, adopted?: Map<SessionId, Adoption>, openTabs?: SidebarTabInventory['source']);
+    constructor(tabs: SidebarRightTabRegistry, pin: PinResource, host: SidebarRightHost, sessions: SidebarRightSessions);
     /**
      * Read the committed tabs of a Session so providers can restore their content.
      * @param sessionId - Session whose layout has been adopted.
      * @returns its open records, or an empty list before adoption.
      */
     tabsIn(sessionId: SessionId): readonly TabRecord[];
-    /**
-     * Adopt the mounted seat's binding, replacing any previous one.
-     *
-     * Called from the seat while it is mounted, and released when it leaves.
-     * @param binding - the mounted seat's session, actions, and the store's surfaces.
-     * @returns a release callback that clears exactly this binding.
-     */
-    bind(binding: SidebarRightBinding): () => void;
-    /** Publish the mounted session only when it changes; a republished binding for the same session is silent. */
-    private publishMounted;
     /**
      * Open a resource: claim it, place it, reveal the column, record the navigation.
      * @param address - a `dsh-resource://<type>/…` address.
@@ -284,18 +291,18 @@ export declare class SidebarRightController implements ISidebarRight {
     /** The steps both opens share: one store intent, and the navigation record for the tab it settles on. */
     private place;
     /**
-     * Close one tab of the mounted session; the sole docked guide remains open.
+     * Close one tab of the on-screen Session; the sole docked guide remains open.
      * @param tabId - the tab to close.
      */
     close(tabId: TabId): void;
     /**
      * The active tab of the active pane.
-     * @returns the record, or `undefined` with no mounted surface.
+     * @returns the record, or `undefined` without an on-screen surface.
      */
     active(): TabRecord | undefined;
     /**
      * Whether the column is currently showing its panel.
-     * @returns `true` while expanded; `false` while collapsed or with no mounted surface.
+     * @returns `true` while expanded; `false` while collapsed or without an on-screen surface.
      */
     isExpanded(): boolean;
     /** Collapse the column, or expand it and focus its active dock pane after rendering. */
@@ -312,9 +319,9 @@ export declare class SidebarRightController implements ISidebarRight {
      */
     focusedTarget(element?: Element | null): SidebarRightTarget | undefined;
     /**
-     * Choose a focused sidebar pane, or the mounted Session's active dock pane for an outside open.
+     * Choose a focused sidebar pane, or the on-screen Session's active dock pane for an outside open.
      * @param element - live command input target; stale sidebar markup never falls back to another pane.
-     * @returns captured target, or undefined without a mounted Session.
+     * @returns captured target, or undefined without an on-screen surface.
      */
     commandTarget(element?: Element | null): SidebarRightTarget | undefined;
     /**
@@ -339,7 +346,7 @@ export declare class SidebarRightController implements ISidebarRight {
     /**
      * Check a captured target before acting, including reopened records and intervening navigation.
      * @param target - identity captured while resolving the input.
-     * @returns whether the mounted Session, pane, tab lifetime and navigation still match.
+     * @returns whether the on-screen Session, pane, tab lifetime and navigation still match.
      */
     isTargetCurrent(target: SidebarRightTarget): boolean;
     /**
@@ -371,20 +378,27 @@ export declare class SidebarRightController implements ISidebarRight {
      */
     dock(paneId: PaneId): void;
     /**
-     * Step the mounted session's surface back one intent.
+     * Step the on-screen Session's surface back one intent.
      *
      * @internal Not part of the product: the sequence is an architectural fact
      * with no user-facing control yet. Kept reachable for tests.
      */
     _undo(): void;
     /**
-     * Step the mounted session's surface forward one intent.
+     * Step the on-screen Session's surface forward one intent.
      *
      * @internal See `_undo`.
      */
     _redo(): void;
-    /** The mounted session's surface; `undefined` without a seat or before its first open. */
+    /**
+     * The on-screen Session and its committed surface; `undefined` with no Session
+     * on screen, before the runtime mints its store, or before its first open.
+     */
+    private screen;
+    /** The on-screen Session's surface; see {@link SidebarRightController.screen}. */
     private mountedSurface;
+    /** Whether a Session's docked pane has room for two working halves, as its seat last measured; unmeasured panes do. */
+    private canSplitPane;
     /**
      * The store actions a tab's own action on `sessionId` runs through: that
      * session's adopted store. `undefined` — nothing to act on — for a session

package/lib/types/client/shell/SidebarRight.d.ts

@@ -33,27 +33,21 @@ export interface SidebarRightInjected {
      */
     readonly syncPresentation: (presentation: SidebarRightPresentation) => void;
     /**
-     * Publish this seat's session, actions, and the store's surfaces to `ctx.sidebarRight`.
+     * Record this seat's room rule for `ctx.sidebarRight`'s splits, replacing its previous one.
      *
-     * The service is root-scoped and cannot read a per-entry store, so the only
-     * honest source is the mounted seat. Held for as long as the seat is mounted;
-     * the service publishes the bound session through `ctx.sidebarRight.mounted`.
-     * @param binding - what a command needs to act on this session, and what a tab's own action needs to act on its.
-     * @returns a release callback.
+     * The docking kit measures its panes after it renders; the seat forwards each
+     * reading, and the service applies it when it splits this seat's Session.
+     * @param canSplitPane - whether two working halves of a docked pane would fit; unmeasured panes fit.
      */
-    readonly bindService: (binding: {
-        sessionId: SessionId;
-        actions: Store['actions'];
-        /** Every session's surface as last committed; the mounted one is `surfaces[sessionId]`. */
-        surfaces: Readonly<Record<string, SurfaceState>>;
-        /** The room rule's verdict for a docked pane, as the kit last measured it. */
-        canSplitPane: (paneId: PaneId) => boolean;
-        /** Commit a keyboard/menu close and retain focus on a surviving visible pane. */
-        closeWithFocus: (paneId: PaneId, close: () => void) => void;
-        /** Commit a page operation and focus the pane it selects. */
-        openWithFocus: (open: () => PaneId | undefined) => void;
-        autoFullscreen?: boolean;
-    }) => () => void;
+    readonly measureRoom: (canSplitPane: (paneId: PaneId) => boolean) => void;
+    /**
+     * Record whether the frame width this seat renders at presents an expanded panel fullscreen automatically.
+     *
+     * The fullscreen command reads the latest report: while it holds, the command
+     * closes the panel instead of switching its recorded mode.
+     * @param autoFullscreen - whether the frame is narrower than the automatic fullscreen width.
+     */
+    readonly reportAutoFullscreen: (autoFullscreen: boolean) => void;
     /**
      * The navigation face's `openTab`, for the strip's add control: a new tab is
      * the guide opened by kind, through the same path as every other open.
@@ -110,10 +104,11 @@ interface PanelProps {
 export declare function intentsFor(sessionId: SessionId, actions: Store['actions'], openTab: PanelProps['openTab'], closeTab?: PanelProps['closeTab'], splitPane?: PanelProps['splitPane']): DockIntents;
 /**
  * The right column's occupant: stable tab containers, docked or floating.
- * It is also where the
- * frame learns the panel's presentation, and where `ctx.sidebarRight` learns
- * which session it is acting on, because this is the seat that knows both.
+ * It is also where the frame learns the panel's presentation, because this is
+ * the seat that knows it. `ctx.sidebarRight` names the on-screen Session
+ * itself; this seat reports only what it renders with: the room its kit
+ * measured and the automatic fullscreen rule of its frame width.
  */
-export declare function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, closeTab, useTabTypes, useTabNavigation, occurrence, retainTab, active, useShortcuts, splitPane, toggleFullscreen, }: RightbarSeatProps): ReactNode;
+export declare function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, measureRoom, reportAutoFullscreen, openTab, closeTab, useTabTypes, useTabNavigation, occurrence, retainTab, active, useShortcuts, splitPane, toggleFullscreen, }: RightbarSeatProps): ReactNode;
 export {};
 //# sourceMappingURL=SidebarRight.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-sidebar-right",
   "description": "Right Sidebar: the docking surface's session-bound state, its panel and header expand control, and the navigation service over it",
-  "version": "0.2.0-rc.1",
+  "version": "0.2.1-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -40,7 +40,7 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.4"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1"
   },
   "devDependencies": {
     "@testing-library/react": "^16.1.0",
@@ -52,23 +52,23 @@
     "picomatch": "^4.0.4",
     "clsx": "^2.0.0",
     "zod": "^4.4.3",
-    "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-api-session-controller": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-resources": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-store": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-test-runtime": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-dockkit": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-layout": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-session": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-session": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-util-crypto": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-shortcuts": "0.2.0-rc.1",
-    "@deepseek-ai/dsh-brand": "0.2.0-rc.1"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-locale": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-resources": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-test-runtime": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-store": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-dockkit": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-layout": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-util-crypto": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-shortcuts": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-brand": "0.2.1-alpha.1"
   },
   "files": [
     "lib/index.js",