@deepseek-ai/dsh-client-ui-sidebar-right 0.1.5-alpha.1

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Pure host half; the whole Sidebar lives in the browser export. */
+/** Host plugin body: the Sidebar contributes nothing to the host tree. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/types/client/contract/params.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Navigation parameters, typed by what is being opened.
+ *
+ * Two declaration-merged maps. `SidebarRightResourceParamsMap` is keyed by
+ * resource type — the segment after `dsh-resource://` — and filled by the
+ * package that owns that type (the `file` provider adds `file: { line?: number }`);
+ * `SidebarRightTabParamsMap` is keyed by tab kind and filled by a page type that
+ * takes parameters (neither shipped page does). Values are JSON-shaped by
+ * convention; nothing validates them at run time, because caller and body meet
+ * at a typed same-process boundary. A body narrows `navigation.params` by the
+ * scheme and type of `navigation.address`.
+ *
+ * The unions below are spelled as indexed accesses over a record rather than as
+ * `A | B`: in a program where no package has augmented a map, both sides of such
+ * a union resolve to `undefined`, which the type-aware lint reads as a duplicated
+ * constituent. The indexed access names the same union without the pair.
+ */
+/** The values of a record, as one union. */
+type ValuesOf<T> = T[keyof T];
+/** Resource type → the parameters a resource of that type accepts. Merge-extensible. */
+export interface SidebarRightResourceParamsMap {
+}
+/** What `openResource` accepts as `params`: a declared resource type's parameters, or `undefined` for none. */
+export type SidebarRightResourceParams = ValuesOf<{
+    declared: SidebarRightResourceParamsMap[keyof SidebarRightResourceParamsMap];
+    none: undefined;
+}>;
+/** Tab kind → the parameters a page of that kind accepts. Merge-extensible. */
+export interface SidebarRightTabParamsMap {
+}
+/**
+ * What `openTab(kind)` accepts as `params` for one kind: its declared parameters,
+ * or `undefined` for none; a kind that declares none accepts only `undefined`.
+ */
+export type SidebarRightTabParamsFor<K extends string> = (K extends keyof SidebarRightTabParamsMap ? SidebarRightTabParamsMap[K] : never) | undefined;
+/** Every declared page kind's parameters, or `undefined` for none. */
+export type SidebarRightTabParams = ValuesOf<{
+    declared: SidebarRightTabParamsMap[keyof SidebarRightTabParamsMap];
+    none: undefined;
+}>;
+/** What a body may find in `navigation.params`: either map's values, or `undefined` when the opener gave none. */
+export type SidebarRightNavigationParams = ValuesOf<{
+    resource: SidebarRightResourceParams;
+    tab: SidebarRightTabParams;
+}>;
+export {};
+//# sourceMappingURL=params.d.ts.map

package/lib/types/client/contract/seed.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The guide tab's identity, the page-address scheme, and the seed factory.
+ *
+ * These live in the contract because two sides need them and neither may read
+ * the other: the store seeds every new pane with a guide tab, and the guide
+ * domain registers the type under the same kind.
+ *
+ * The docking kit treats `kind` as opaque, so these strings mean something only
+ * here and in the registry. Both types go through the same two stages any other
+ * type would use — the guide is not special in the machinery, only in being
+ * always available.
+ */
+import type { TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+/** The guide tab's kind. */
+export declare const GUIDE_KIND = "guide";
+/**
+ * The address a page tab is recorded under: `sidebar://<kind>`. The scheme is
+ * this package's bookkeeping for `openTab`, spelled here and nowhere else; a
+ * caller names the kind and never sees or composes the address.
+ * @param kind - the page type's kind.
+ * @returns the page's address.
+ */
+export declare function pageAddress(kind: string): string;
+/**
+ * Build the guide tab a new pane is seeded with.
+ *
+ * The title is captured at mint time because it goes into the surface's
+ * operation sequence, which records what happened and must not change meaning
+ * later. A language change relabels the type, not tabs already open.
+ * @param id - tab id minted by the caller.
+ * @param title - the guide type's display name at mint time.
+ * @returns the guide tab record.
+ */
+export declare function makeGuideTab(id: TabId, title: string): TabRecord;
+//# sourceMappingURL=seed.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -0,0 +1,152 @@
+import type { PaneId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { SlotHookFactory } from '@deepseek-ai/dsh-client-ui-slots';
+import type { TabHookContext } from '../tab-info.ts';
+import type { SidebarRightKey } from '../locales.ts';
+import type { SidebarRightNavigationParams, SidebarRightResourceParams, SidebarRightTabParamsFor } from './params.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Right-Sidebar chrome, docking-kit vocabulary, and guide copy. */
+        sidebarRight: SidebarRightKey;
+    }
+    interface SlotMap {
+        /**
+         * One tab's body, dispatched with the `id` of the type in force for
+         * `tab.kind`. A tab type registers here under its definition's `id` and
+         * receives every tab of that kind, in every pane, docked or floating. A kind
+         * with no type in force renders the owner's "nothing can view this" notice
+         * rather than an empty pane.
+         */
+        'sidebar.right.pane.tab': {
+            kind: 'keyed';
+            scope: 'session';
+            hookContext: TabHookContext;
+            inject: SidebarRightTabInjected;
+        };
+        /**
+         * A tab's title as its chip (and a floating panel's header) shows it,
+         * dispatched with the same key and information hook as the body. A type with a
+         * live title — a terminal named after its shell, a chat after its first
+         * line — registers here and reads its own store; one without registers
+         * nothing and the chip shows the registry's `title(address)` text captured
+         * at open time.
+         */
+        'sidebar.right.pane.tab.title': {
+            kind: 'keyed';
+            scope: 'session';
+            hookContext: TabHookContext;
+            inject: SidebarRightTabInjected;
+        };
+        /**
+         * The guide tab's body. Selectors run in chain order and the first
+         * non-declining entry replaces the shipped guide entirely; with no entry, or
+         * with every entry declining, the shipped guide renders.
+         */
+        'sidebar.right.tab.guide': {
+            kind: 'chain';
+            scope: 'session';
+            hookContext: UseSidebarRightTabInfo;
+            inject: {
+                hooks: {
+                    tabInfo: SlotHookFactory<'sidebar.right.tab.guide', UseSidebarRightTabInfo>;
+                };
+            };
+        };
+        /**
+         * Extra items at the end of one tab's actions menu, in registration order.
+         * Entries decide their own visibility from the tab they are given. Without a
+         * registrant the menu shows only the kit's own layout actions.
+         */
+        'sidebar.right.tab.menu.item': {
+            kind: 'list';
+            scope: 'session';
+            owner: SidebarRightTabMenuOwnerProps;
+        };
+    }
+}
+/** Where a tab was last navigated to: what the `open` that created or revealed it carried. */
+export interface SidebarRightTabNavigation {
+    /** The address opened; for a tab record this is its `contentId`. */
+    readonly address: string;
+    /** The opener's `params` (see `contract/params.ts`); `undefined` when it gave none. */
+    readonly params: SidebarRightNavigationParams;
+    /**
+     * Incremented on every navigation to this tab, whether or not `params`
+     * changed, so a body can act on "navigated again" alone. `0` for a record
+     * nobody opened by address: a seeded guide, or a tab restored by undo.
+     */
+    readonly revision: number;
+}
+/** Where an open from a tab lands. Without any of these it lands in the pane holding the tab at call time. */
+export interface SidebarRightTabPlacement {
+    /** Land a new tab in this pane instead. */
+    readonly paneId?: PaneId;
+    /** Defaults to `true`: a tab already showing the same content is focused instead of a second one opening. */
+    readonly revealIfOpened?: boolean;
+    /** `true` opens in this tab's place — its pane and strip slot — and closes this tab in the same step. */
+    readonly replaceTab?: boolean;
+}
+/** The actions one tab may take on itself; each acts on the session the tab is in. */
+export interface SidebarRightTabActions {
+    /**
+     * Open a resource from this tab; see `ISidebarRight.openResource`.
+     * @param address - a `dsh-resource://` address.
+     * @param options - placement and the resource's navigation parameters.
+     */
+    openResource(address: string, options?: SidebarRightTabPlacement & {
+        readonly params?: SidebarRightResourceParams;
+    }): void;
+    /**
+     * Open a page type from this tab; see `ISidebarRight.openTab`.
+     * @param kind - the page type's kind.
+     * @param options - placement and that kind's navigation parameters.
+     */
+    openTab<K extends string>(kind: K, options?: SidebarRightTabPlacement & {
+        readonly params?: SidebarRightTabParamsFor<K>;
+    }): void;
+    /** Close this tab. */
+    close(): void;
+}
+/** Live information shared by a tab's body, title, and guide replacement. */
+export interface SidebarRightTabInfo {
+    readonly sidebar: {
+        readonly expanded: boolean;
+        /** Presentation selected by manual mode or viewport width; preserved while collapsed. */
+        readonly fullscreen: boolean;
+    };
+    readonly panel: {
+        readonly id: PaneId;
+    };
+    readonly tab: TabRecord & {
+        /** Docked bodies need an expanded sidebar and an active tab; expanded titles include inactive tabs. Floats stay visible. */
+        readonly visible: boolean;
+        readonly navigation: SidebarRightTabNavigation;
+        /** Aborted only when the record disappears or this plugin unloads, not on hide or session switch. */
+        readonly signal: AbortSignal;
+        readonly actions: SidebarRightTabActions;
+    };
+}
+/**
+ * Read current tab information through the slot framework's subscriptions.
+ * @returns the sidebar presentation, containing pane, and live tab record.
+ */
+export type UseSidebarRightTabInfo = () => SidebarRightTabInfo;
+/** The slot-owned hook shared by every tab body and title registration. */
+export interface SidebarRightTabInjected {
+    hooks: {
+        tabInfo: SlotHookFactory<'sidebar.right.pane.tab', UseSidebarRightTabInfo>;
+    };
+}
+/** Owner share of one tab-menu item occurrence. */
+export interface SidebarRightTabMenuOwnerProps {
+    /** The tab whose menu is open. */
+    tab: TabRecord;
+    /**
+     * Dismiss the menu.
+     *
+     * An item that acts MUST call this: the menu is the kit's, and it closes on
+     * its own actions only. An item that leaves it open leaves a menu floating
+     * over content the action may have just replaced.
+     */
+    dismiss: () => void;
+}
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1,56 @@
+/**
+ * Browser half: fill the frame's right column with the panel, put the expand
+ * button in the conversation header, and own the seats a tab type registers
+ * into.
+ *
+ * Two seats share one session-scoped store, which the slot runtime allows
+ * because both are session-scoped (a handle may not span scopes). The panel seat
+ * in the frame draws the surface normally or fullscreen, retaining the track
+ * on wide viewports; the header's corner seat draws the way back in
+ * while the panel is hidden. The store is the layout's only source of truth; the docking
+ * kit's pure planners compute every change and the store records them, one
+ * history entry per intent.
+ *
+ * The frame is a base package and never injects this one. What it needs —
+ * whether the panel is shown and whether it wants a track — arrives through its
+ * own `ctx.layout` action face, reported by the seat that knows both facts.
+ *
+ * Tab types register in two stages: the type itself into `ctx.sidebarRightTabs`,
+ * its body into the keyed `sidebar.right.pane.tab` seat under the same kind. The
+ * guide registers through those stages unmodified, exactly as a type shipped
+ * from another package does — `ui-sidebar-textpreview` is the live proof.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import { type SidebarRightController } from './service.ts';
+import { SidebarRightTabRegistry } from './tab-registry.ts';
+export type { RightbarSeatProps, SidebarRightInjected, SidebarRightPresentation } from './shell/SidebarRight.tsx';
+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, SurfaceActions, } from './service.ts';
+export type { SidebarRightGuideBox, SidebarRightGuideEntry, SidebarRightTabClaim, SidebarRightTabDefinition, SidebarRightTabPriority, } from './tab-registry.ts';
+export type { SidebarRightTabInfo, SidebarRightTabInjected, UseSidebarRightTabInfo, SidebarRightTabActions, SidebarRightTabMenuOwnerProps, SidebarRightTabNavigation, SidebarRightTabPlacement, } from './contract/slots.ts';
+export type { SidebarRightNavigationParams, SidebarRightResourceParams, SidebarRightResourceParamsMap, SidebarRightTabParams, SidebarRightTabParamsFor, SidebarRightTabParamsMap, } from './contract/params.ts';
+export type { FloatRect, PaneId, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+export type { PinResource, SidebarRightNavigator, TabOccurrence } from './tab-domain.ts';
+export type { SidebarRightKey } from './locales.ts';
+export type { OpenContentIntent } from './stores.ts';
+/** Required browser services: the slot registry, the frame's panel actions, copy, and the resource model. */
+export declare const inject: string[];
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Right-Sidebar navigation and presentation face. */
+        sidebarRight: SidebarRightController;
+        /** Right-Sidebar tab-type registry (stage one of a tab type's registration). */
+        sidebarRightTabs: SidebarRightTabRegistry;
+    }
+}
+/**
+ * Client plugin body: provide the registry and the navigation face, register the
+ * panel seat and the rail seat over one store with their extension children, and
+ * register the guide type through the same public two-stage path any other type
+ * uses.
+ * @param ctx - client root context carrying the slot registry, the frame's face, and copy.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * The docking kit's vocabulary, in the product's language.
+ *
+ * The kit renders no string of its own, so every word a user reads inside it is
+ * handed over from here. This is a projection of the dictionary, not a second
+ * home for copy: the strings live in `locales.ts`.
+ */
+import type { DockLabels } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+/**
+ * Project the dictionary into the kit's label contract.
+ *
+ * Called during render, so a language change reaches the kit with the next one —
+ * the kit caches no copy to invalidate.
+ * @param t - namespace-bound translate.
+ * @returns every string the kit renders.
+ */
+export declare function dockLabels(t: TranslateNS<'sidebarRight'>): DockLabels;
+//# sourceMappingURL=labels.d.ts.map

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

@@ -0,0 +1,48 @@
+/**
+ * `sidebarRight` namespace dictionaries.
+ *
+ * Everything a user reads in this column is here, including the strings handed
+ * to the docking kit — the kit renders no copy of its own, so its whole
+ * vocabulary is this package's to own and translate.
+ */
+/** Simplified Chinese dictionary and key-set source of truth. */
+export declare const zh: {
+    'chrome.expand': string;
+    'chrome.collapse': string;
+    'chrome.toFullscreen': string;
+    'chrome.exitFullscreen': string;
+    'dock.emptyPane': string;
+    'dock.splitPane': string;
+    'dock.splitPaneDisabled': string;
+    'dock.splitPaneNarrow': string;
+    'dock.closeTab': string;
+    'dock.addTab': string;
+    'dock.dockFloat': string;
+    'dock.closeFloat': string;
+    'tab.guide.title': string;
+    'tab.unavailable': string;
+    'guide.lead': string;
+    'guide.body': string;
+};
+/** Right-Sidebar dictionary key union. */
+export type SidebarRightKey = keyof typeof zh;
+/** English dictionary, checked against the Chinese key set. */
+export declare const en: {
+    'chrome.expand': string;
+    'chrome.collapse': string;
+    'chrome.toFullscreen': string;
+    'chrome.exitFullscreen': string;
+    'dock.emptyPane': string;
+    'dock.splitPane': string;
+    'dock.splitPaneDisabled': string;
+    'dock.splitPaneNarrow': string;
+    'dock.closeTab': string;
+    'dock.addTab': string;
+    'dock.dockFloat': string;
+    'dock.closeFloat': string;
+    'tab.guide.title': string;
+    'tab.unavailable': string;
+    'guide.lead': string;
+    'guide.body': string;
+};
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1,300 @@
+/**
+ * `ctx.sidebarRight`: what other plugins may ask of this column.
+ *
+ * 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. 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.
+ *
+ * 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
+ * fired after the user switched sessions still lands where its tab is, and they
+ * do nothing for a session whose store was never minted.
+ *
+ * `openResource` and `openTab` are the navigation controller, and every way
+ * into the column is a call to one of them: the conversation's file links, a
+ * tool row's line reference, the strip's add control, a guide entry box, a file
+ * tree's rows. A resource is claimed through the registry by address; a page is
+ * named by kind and recorded at the address this package composes for it. Both
+ * 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.
+ *
+ * Wiring follows `LayoutController.attachPanels`: the registration hands the
+ * service its store actions, and the service is the face other plugins hold.
+ */
+import type { FloatRect, PaneId, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+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, SurfaceState } from './stores.ts';
+import type { createSidebarRightStore } from './stores.ts';
+import { TabDomain, type PinResource } from './tab-domain.ts';
+/** The seat's bound action set. */
+export type SurfaceActions = BoundActions<ReturnType<typeof createSidebarRightStore>>;
+/** One session's store instance as the slot runtime minted it: its actions and its observable snapshot. */
+export interface SidebarRightSurfaceStore {
+    readonly actions: SurfaceActions;
+    getSnapshot(): SidebarRightState;
+    subscribe(listener: () => void): () => void;
+}
+/** One adoption of a session's store; the token a release compares against. */
+interface Adoption {
+    readonly store: SidebarRightSurfaceStore;
+    readonly unsubscribe: () => void;
+}
+/**
+ * Create the public controller and the plugin-private store adoption callback.
+ * Adoption subscribes without reconciling; the first store commit creates occurrences.
+ * @param tabs - registered tab types.
+ * @param pin - resource retention for an occurrence's lifetime.
+ * @returns the controller and a callback releasing exactly its own adoption.
+ */
+export declare function createSidebarRightController(tabs: SidebarRightTabRegistry, pin: PinResource): {
+    controller: SidebarRightController;
+    adopt: (sessionId: SessionId, store: SidebarRightSurfaceStore) => () => 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;
+    /**
+     * 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.
+     */
+    readonly surfaces: Readonly<Record<string, SurfaceState>>;
+    /**
+     * The room rule's verdict for a docked pane, as the kit last measured it:
+     * whether two working halves would fit. Unmeasured panes fit.
+     */
+    readonly canSplitPane: (paneId: PaneId) => boolean;
+}
+/** Where an open lands; every field is optional and the defaults are the common case. */
+export interface SidebarRightPlacement {
+    /** Land a new tab in this pane instead of the active docked one. */
+    readonly paneId?: PaneId;
+    /** Take this tab's place — its pane and its strip slot — and close it in the same step. */
+    readonly replaceTab?: TabId;
+    /**
+     * Defaults to `true`: a tab already showing the same (kind, contentId) is
+     * focused and handed `params`. `false` opens another tab regardless.
+     */
+    readonly revealIfOpened?: boolean;
+}
+/** How a caller wants a resource opened. */
+export interface SidebarRightOpenResourceOptions extends SidebarRightPlacement {
+    /** Name the opening type instead of letting the registry rank claims; its `canOpen` still applies. */
+    readonly kind?: string;
+    /** The resource's navigation parameters, typed by resource type; delivered as `navigation.params`. */
+    readonly params?: SidebarRightResourceParams;
+}
+/** How a caller wants a page type opened. */
+export interface SidebarRightOpenTabOptions<K extends string = string> extends SidebarRightPlacement {
+    /** That kind's navigation parameters, typed by kind; delivered as `navigation.params`. */
+    readonly params?: SidebarRightTabParamsFor<K>;
+}
+/** The outward right-Sidebar face (`ctx.sidebarRight`). */
+export interface ISidebarRight {
+    /**
+     * Open a resource: claim it, place it, reveal the column, record the navigation.
+     *
+     * Without `options.kind` the registry ranks the types whose globs and
+     * `canOpen` accept the address and the best band wins; with it, that kind's
+     * type in force opens the address (its `canOpen` still applies). An address
+     * outside `dsh-resource://`, or one no type will open, is a wiring mistake,
+     * not a user error, so it throws. The column expands in the same step,
+     * because content the user cannot see is not opened.
+     * @param address - a `dsh-resource://<type>/…` address.
+     * @param options - placement, the opening type, and navigation parameters.
+     */
+    openResource(address: string, options?: SidebarRightOpenResourceOptions): void;
+    /**
+     * Open a page type by kind: the type in force for it, at the address this
+     * package records pages under. A kind nothing registered throws.
+     * @param kind - the page type's kind.
+     * @param options - placement and that kind's navigation parameters.
+     */
+    openTab<K extends string>(kind: K, options?: SidebarRightOpenTabOptions<K>): void;
+    /**
+     * Close one tab of the mounted session.
+     * @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.
+     */
+    active(): TabRecord | undefined;
+    /**
+     * Whether the column is currently showing its panel.
+     * @returns `true` while expanded; `false` while collapsed to its rail.
+     */
+    isExpanded(): boolean;
+    /** Collapse an expanded column, or expand a collapsed one. Recorded in the sequence. */
+    toggleExpanded(): void;
+    /**
+     * Focus a tab and the pane holding it, raising a floating one. Recorded.
+     * @param tabId - the tab; one that does not exist is left alone.
+     */
+    focus(tabId: TabId): void;
+    /**
+     * Split a docked pane to its right and seed the new pane, under the same
+     * pane budget and room rule as the strip's split control. Recorded when it
+     * splits.
+     * @param paneId - the pane to split; defaults to the active docked pane.
+     * @returns the new pane's id, or `undefined` when nothing was split: the pane
+     *   is missing or floating, the budget is spent, or two halves would not fit.
+     */
+    split(paneId?: PaneId): PaneId | undefined;
+    /**
+     * Take a docked tab out into a floating panel. Recorded.
+     * @param tabId - the tab; one that is missing or already floating is left alone.
+     * @param rect - the panel's rectangle; defaults to the cascade from the last panel.
+     */
+    float(tabId: TabId, rect?: FloatRect): void;
+    /**
+     * Return a floating panel's tab to the active docked pane. Recorded.
+     * @param paneId - the floating pane; one that is missing or docked is left alone.
+     */
+    dock(paneId: PaneId): void;
+}
+/** Cross-plugin right-Sidebar face (ctx.sidebarRight). */
+export declare class SidebarRightController implements ISidebarRight {
+    private readonly tabs;
+    private readonly adopted;
+    private binding;
+    /**
+     * The Tab domain this controller navigates into; synced from each adopted
+     * store's commits, read by the seat for each body's owner share.
+     */
+    readonly tabDomain: TabDomain;
+    /**
+     * @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.
+     */
+    constructor(tabs: SidebarRightTabRegistry, pin: PinResource, adopted?: Map<SessionId, Adoption>);
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    openResource(address: string, options?: SidebarRightOpenResourceOptions): void;
+    /**
+     * Open a page type by kind at the address this package records pages under.
+     * @param kind - the page type's kind.
+     * @param options - placement and that kind's navigation parameters.
+     */
+    openTab<K extends string>(kind: K, options?: SidebarRightOpenTabOptions<K>): void;
+    /**
+     * Open a resource in one session, for a tab's own action; nothing happens
+     * for a session whose store was never adopted or whose adoption was released.
+     * Not part of `ISidebarRight`: the Tab domain's path.
+     * @param sessionId - the session the acting tab is in.
+     * @param address - a `dsh-resource://<type>/…` address.
+     * @param options - placement, the opening type, and navigation parameters.
+     */
+    openResourceIn(sessionId: SessionId, address: string, options?: SidebarRightOpenResourceOptions): void;
+    /**
+     * Open a page type in one session, for a tab's own action; nothing happens
+     * for a session whose store was never adopted or whose adoption was released.
+     * Not part of `ISidebarRight`: the Tab domain's path.
+     * @param sessionId - the session the acting tab is in.
+     * @param kind - the page type's kind.
+     * @param options - placement and that kind's navigation parameters.
+     */
+    openTabIn<K extends string>(sessionId: SessionId, kind: K, options?: SidebarRightOpenTabOptions<K>): void;
+    /**
+     * Close a tab of one session, for the tab's own action; nothing happens
+     * for a session whose store was never adopted or whose adoption was released.
+     * Not part of `ISidebarRight`: the Tab domain's path.
+     * @param sessionId - the session the tab is in.
+     * @param tabId - the tab to close.
+     */
+    closeIn(sessionId: SessionId, tabId: TabId): void;
+    /** Claim a resource and place it in one session; an address outside the scheme or one no type claims throws. */
+    private placeResource;
+    /** Place a page type in one session at the address pages are recorded under; an unregistered kind throws. */
+    private placeTab;
+    /** 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.
+     * @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.
+     */
+    active(): TabRecord | undefined;
+    /**
+     * Whether the column is currently showing its panel.
+     * @returns `true` while expanded; `false` while collapsed or with no mounted surface.
+     */
+    isExpanded(): boolean;
+    /** Collapse an expanded column, or expand a collapsed one. */
+    toggleExpanded(): void;
+    /**
+     * Focus a tab and the pane holding it; a missing tab is left alone.
+     * @param tabId - the tab to focus.
+     */
+    focus(tabId: TabId): void;
+    /**
+     * Split a docked pane to its right when the budget and the room rule allow.
+     * @param paneId - the pane to split; defaults to the active docked pane.
+     * @returns the new pane's id, or `undefined` when nothing was split.
+     */
+    split(paneId?: PaneId): PaneId | undefined;
+    /**
+     * Take a docked tab out into a floating panel; a missing or floating tab is left alone.
+     * @param tabId - the tab to float.
+     * @param rect - the panel's rectangle; defaults to the cascade from the last panel.
+     */
+    float(tabId: TabId, rect?: FloatRect): void;
+    /**
+     * Return a floating panel's tab to the active docked pane; a missing or docked pane is left alone.
+     * @param paneId - the floating pane.
+     */
+    dock(paneId: PaneId): void;
+    /**
+     * Step the mounted 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.
+     *
+     * @internal See `_undo`.
+     */
+    _redo(): void;
+    /** The mounted session's surface; `undefined` without a seat or before its first open. */
+    private mounted;
+    /**
+     * 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
+     * whose store was never minted or whose adoption was released.
+     */
+    private actionsFor;
+    private require;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map