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

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

@@ -0,0 +1,24 @@
+/**
+ * The way into a hidden panel: one button in the conversation header's corner
+ * seat, shown only while the panel is collapsed.
+ *
+ * It lives in the conversation's own header rather than in the frame's right
+ * column so that a collapsed Sidebar costs the conversation nothing — no rail,
+ * no width, and the transcript's scrollbar stays at the column's edge. The
+ * corner seat is its own, past the utilities' edge, so the button neither joins
+ * the utilities row nor moves it: while the panel is shown this renders a
+ * same-size placeholder, and the seat's width stays reserved. It shares the
+ * panel's per-session store, which the slot runtime allows because both seats
+ * are session-scoped.
+ *
+ * The glyph is the left sidebar's collapse icon mirrored: the same affordance,
+ * on the other edge.
+ */
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { createSidebarRightStore } from '../stores.ts';
+/** The button's props: the header corner seat, the shared store, and copy. */
+export type ExpandButtonProps = PropsRuntime<'conversation.session.header.corner'> & PropsStore<ReturnType<typeof createSidebarRightStore>> & PropsLocale<'sidebarRight'>;
+/** The expand control while the panel is collapsed; its footprint while it is shown. */
+export declare function ExpandButton({ sessionId, useStore, actions, t }: ExpandButtonProps): ReactNode;
+//# sourceMappingURL=ExpandButton.d.ts.map

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

@@ -0,0 +1,99 @@
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { DockIntents, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { HalvesFit, PaneId } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SidebarRightOpenTabOptions } from '../service.ts';
+import type { SidebarRightTabDefinition } from '../tab-registry.ts';
+import type { createSidebarRightStore, SurfaceState } from '../stores.ts';
+import type { TabOccurrence } from '../tab-domain.ts';
+import type { SidebarRightTabNavigation } from '../contract/slots.ts';
+/** The store share the seat receives. */
+type Store = PropsStore<ReturnType<typeof createSidebarRightStore>>;
+/** The child seats this component renders. */
+type Children = PropsRenderSlots<'sidebar.right.pane.tab' | 'sidebar.right.pane.tab.title' | 'sidebar.right.tab.menu.item'>;
+/** What the panel reports to the frame: drawn or not, and whether it wants a track. */
+export interface SidebarRightPresentation {
+    /** Whether the panel is drawn at all. */
+    readonly shown: boolean;
+    /** Whether the drawn panel wants the conversation to make room for it. */
+    readonly track: boolean;
+    /** Whether the panel fills the viewport, independently of its retained track. */
+    readonly fullscreen: boolean;
+}
+/** What this package needs from its host beyond the framework shares. */
+export interface SidebarRightInjected {
+    /**
+     * Report the panel's presentation to the frame.
+     *
+     * The frame sizes the track and places the resize handle; this only tells it
+     * the composition of the facts this package owns, and is called whenever that
+     * composition changes.
+     */
+    readonly syncPresentation: (presentation: SidebarRightPresentation) => void;
+    /**
+     * Publish this seat's session, actions, and the store's surfaces to `ctx.sidebarRight`.
+     *
+     * 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.
+     * @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.
+     */
+    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;
+    }) => () => 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.
+     */
+    readonly openTab: (kind: string, options?: SidebarRightOpenTabOptions) => void;
+    readonly hooks: {
+        readonly tabTypes: HostObservable<readonly SidebarRightTabDefinition[]>;
+    };
+    readonly keyedHooks: {
+        readonly tabNavigation: (key: string) => HostObservable<SidebarRightTabNavigation>;
+    };
+    /** Read a committed record's lifetime; never creates an occurrence. */
+    readonly occurrence: (tab: Pick<TabRecord, 'id'>) => TabOccurrence;
+}
+/** The column seat's props: session scope, so the session arrives as a standard prop. */
+export type RightbarSeatProps = PropsRuntime<'rightbar'> & Children & Store & PropsLocale<'sidebarRight'> & InjectFace<SidebarRightInjected>;
+/** Everything the panel needs, already bound to one session. */
+interface PanelProps {
+    readonly sessionId: SessionId;
+    readonly surface: SurfaceState;
+    readonly actions: Store['actions'];
+    readonly t: RightbarSeatProps['t'];
+    readonly renderSlot: Children['renderSlot'];
+    readonly openTab: SidebarRightInjected['openTab'];
+    readonly useTabTypes: RightbarSeatProps['useTabTypes'];
+    readonly useTabNavigation: RightbarSeatProps['useTabNavigation'];
+    readonly useStore: Store['useStore'];
+    readonly occurrence: SidebarRightInjected['occurrence'];
+    readonly fullscreen: boolean;
+    readonly autoFullscreen: boolean;
+    /** Receives the kit's room-rule readings for the service's `split`. */
+    readonly reportRoom: (fits: ReadonlyMap<PaneId, HalvesFit>) => void;
+}
+/**
+ * Build the kit's intent face for one session out of the store's actions.
+ * @param sessionId - the session the seat draws; every action is bound to it.
+ * @param actions - the seat's bound store actions.
+ * @param openTab - the navigation face's `openTab`, which the strip's add control asks for a guide through.
+ * @returns the intents the kit reports gestures to.
+ */
+export declare function intentsFor(sessionId: SessionId, actions: Store['actions'], openTab: PanelProps['openTab']): DockIntents;
+/**
+ * The right column's occupant: the panel, anchored to the column's edge and
+ * shown or hidden by sliding, plus the floating layer. 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.
+ */
+export declare function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, useTabTypes, useTabNavigation, occurrence, }: RightbarSeatProps): ReactNode;
+export {};
+//# sourceMappingURL=SidebarRight.d.ts.map

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

@@ -0,0 +1,100 @@
+/**
+ * The store shell over the docking kit: one surface per session, held as plain
+ * data so the kit's pure functions are the only thing that ever computes a
+ * layout.
+ *
+ * Every action follows the same steps — mint the ids the intent needs, ask the
+ * kit's planner what operations carry it out, let the settle planner keep every
+ * pane populated, record it all as one history entry — and then assigns the
+ * session's whole surface back in one go. Nothing here reaches into a draft to
+ * edit a layout in place, which is what keeps the kit testable without a store
+ * and keeps snapshot identity honest.
+ *
+ * The settle step is this product's rule, not the kit's: a docked pane never
+ * stays empty, and the last pane reseeds the guide tab, so there is always at
+ * least one tab to look at.
+ *
+ * A focus that changes nothing — a tab already active in its already-active
+ * pane, a pane already active — plans nothing and records nothing, whoever
+ * asks: the kit's chip click and `ctx.sidebarRight.focus` alike.
+ *
+ * So is the guide's uniqueness: a pane holds at most one guide tab. Opening the
+ * guide into a pane that has one focuses it, and a guide dragged, dropped, or
+ * docked into such a pane merges into it — the arriving guide closes and the
+ * pane's own is focused. The kit plans none of this; it is decided here before
+ * its planners run.
+ */
+import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
+import type { DockMode, DockZone, FloatRect, History, LayoutState, PaneId, SplitId, TabId } from '@deepseek-ai/dsh-client-ui-dockkit';
+/** One session's docking surface: the layout, its sequence, and the id counter. */
+export interface SurfaceState {
+    readonly layout: LayoutState;
+    readonly history: History;
+    /** How many ids this surface has minted; carried so replay stays reproducible. */
+    readonly minted: number;
+}
+/**
+ * Every session's surface, keyed by session id.
+ *
+ * Written mutable because an action receives this type as its draft; the
+ * immutability that matters is behavioural — actions only ever assign a whole
+ * new map, never reach into one.
+ */
+export interface SidebarRightState {
+    bySession: Record<string, SurfaceState>;
+}
+/**
+ * What the navigation controller asks the store to open, the address already
+ * claimed. Placement is by `replaceTab` first, then `paneId`, then the active pane.
+ */
+export interface OpenContentIntent {
+    readonly kind: string;
+    readonly contentId: string;
+    readonly title: string;
+    /** Land a new tab in this pane. */
+    readonly paneId?: PaneId;
+    /** Take this tab's pane and slot, and close it in the same entry. */
+    readonly replaceTab?: TabId;
+    /** `false` opens another tab even when the identity is already shown; defaults to `true`. */
+    readonly revealIfOpened?: boolean;
+}
+/**
+ * The surface a session starts with: collapsed, one pane, one guide tab.
+ * @param seedTitle - the guide type's display name at mint time.
+ * @returns the initial surface.
+ */
+export declare function createSurface(seedTitle: () => string): SurfaceState;
+/** Declared write set; each entry is one settled intent. */
+type SidebarRightActions = {
+    open: (draft: SidebarRightState, sessionId: string) => void;
+    setExpanded: (draft: SidebarRightState, sessionId: string, expanded: boolean) => void;
+    toggleExpanded: (draft: SidebarRightState, sessionId: string) => void;
+    setMode: (draft: SidebarRightState, sessionId: string, mode: DockMode) => void;
+    splitPane: (draft: SidebarRightState, sessionId: string, paneId?: PaneId, settled?: (paneId: PaneId) => void) => void;
+    openContent: (draft: SidebarRightState, sessionId: string, intent: OpenContentIntent, settled: (tabId: TabId) => void) => void;
+    duplicateTab: (draft: SidebarRightState, sessionId: string, tabId: TabId) => void;
+    closeTab: (draft: SidebarRightState, sessionId: string, tabId: TabId) => void;
+    focusTab: (draft: SidebarRightState, sessionId: string, tabId: TabId) => void;
+    focusPane: (draft: SidebarRightState, sessionId: string, paneId: PaneId) => void;
+    placeTab: (draft: SidebarRightState, sessionId: string, tabId: TabId, toPaneId: PaneId, index: number) => void;
+    dropTab: (draft: SidebarRightState, sessionId: string, tabId: TabId, paneId: PaneId, zone: DockZone) => void;
+    floatTab: (draft: SidebarRightState, sessionId: string, tabId: TabId, rect?: FloatRect) => void;
+    unfloatPane: (draft: SidebarRightState, sessionId: string, paneId: PaneId) => void;
+    moveFloat: (draft: SidebarRightState, sessionId: string, paneId: PaneId, x: number, y: number) => void;
+    resizeFloat: (draft: SidebarRightState, sessionId: string, paneId: PaneId, rect: FloatRect) => void;
+    resizeSplit: (draft: SidebarRightState, sessionId: string, splitId: SplitId, sizes: readonly number[]) => void;
+    undo: (draft: SidebarRightState, sessionId: string) => void;
+    redo: (draft: SidebarRightState, sessionId: string) => void;
+};
+/**
+ * Create the Sidebar store handle.
+ *
+ * The seed title arrives as a thunk rather than a string: a pane is seeded
+ * whenever one is created, which can be long after the store was built and in a
+ * language the user has since changed to.
+ * @param seedTitle - the guide type's display name, read at each mint.
+ * @returns the handle (spec, type, identity, and factory in one).
+ */
+export declare function createSidebarRightStore(seedTitle: () => string): EngineStoreHandle<SidebarRightState, SidebarRightActions>;
+export {};
+//# sourceMappingURL=stores.d.ts.map

package/lib/types/client/tab-domain.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The Tab domain: what a tab record carries that the layout does not.
+ *
+ * One `TabOccurrence` per open record, keyed by (session, tab id): where the
+ * tab was navigated to, an abort signal spanning the record's life, and the
+ * actions the tab may take on itself. Holding a record also pins its address in
+ * the resource model, so switching tabs unmounts a body without dropping its
+ * content.
+ *
+ * `sync` reconciles occurrences against one session's layout after every
+ * commit: a record that appeared is pinned, one that vanished (closed, or its
+ * open undone) is aborted and dropped. A record restored by undo is a new
+ * occurrence and is fetched again if the resource model already let it go. The
+ * controller syncs each session from that session's adopted store on every
+ * commit, on screen or not, so a record closed from another session's seat is
+ * aborted on that commit. The slot framework binds the navigation sources for
+ * each record's `useTabInfo` reader.
+ */
+import type { LayoutState, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SidebarRightNavigationParams } from './contract/params.ts';
+import type { SidebarRightTabActions, SidebarRightTabNavigation } from './contract/slots.ts';
+import type { SidebarRightOpenResourceOptions, SidebarRightOpenTabOptions } from './service.ts';
+/**
+ * The navigation face a tab's actions call back into, aimed at the session the
+ * tab is in; nothing happens for a session whose store is not adopted.
+ */
+export interface SidebarRightNavigator {
+    /** Open a resource in one session; see `ISidebarRight.openResource`. */
+    openResourceIn(sessionId: SessionId, address: string, options?: SidebarRightOpenResourceOptions): void;
+    /** Open a page type in one session; see `ISidebarRight.openTab`. */
+    openTabIn(sessionId: SessionId, kind: string, options?: SidebarRightOpenTabOptions): void;
+    /** Close a tab of one session. */
+    closeIn(sessionId: SessionId, tabId: TabId): void;
+}
+/** `ctx.resources.pin`: hold an address's content open for as long as `signal` lives. */
+export type PinResource = (address: string, signal: AbortSignal) => void;
+/** What one open tab record holds beyond its layout entry. */
+export interface TabOccurrence {
+    readonly sessionId: SessionId;
+    readonly tabId: TabId;
+    /** Aborted when the record disappears or this package unloads. */
+    readonly signal: AbortSignal;
+    /** The latest navigation aimed at the record; `set` on every `navigate`. */
+    readonly navigation: SnapshotStore<SidebarRightTabNavigation>;
+    /** Stable for the occurrence's life, so a body may hold it. */
+    readonly tabActions: SidebarRightTabActions;
+}
+/** Every session's occurrences. */
+export declare class TabDomain {
+    private readonly navigator;
+    private readonly pin;
+    private readonly bySession;
+    /**
+     * @param navigator - where tab actions go, aimed at the tab's session; the navigation controller.
+     * @param pin - `ctx.resources.pin`, called once per occurrence at its first sync.
+     */
+    constructor(navigator: SidebarRightNavigator, pin: PinResource);
+    /**
+     * Reconcile one session's occurrences with its committed layout.
+     *
+     * Called by the seat after every commit, and only then: aborting a vanished
+     * record runs the types' cleanup, which writes their stores.
+     * @param sessionId - the session whose layout committed.
+     * @param layout - that session's layout as committed.
+     */
+    sync(sessionId: SessionId, layout: LayoutState): void;
+    /**
+     * Read an occurrence created by navigation or committed-store reconciliation.
+     * @param sessionId - the session the record is in.
+     * @param tab - the record being drawn.
+     * @returns its occurrence.
+     * @throws when the record has not been reconciled or has disappeared.
+     */
+    occurrence(sessionId: SessionId, tab: Pick<TabRecord, 'id'>): TabOccurrence;
+    /**
+     * Record that an `open` settled on a tab.
+     *
+     * A record the layout has not yet shown the seat gets its occurrence here, so
+     * the body's first render already carries the opener's `params`.
+     * @param sessionId - the session opened into.
+     * @param tabId - the tab the open settled on.
+     * @param target - the address and the opener's params.
+     */
+    navigate(sessionId: SessionId, tabId: TabId, target: {
+        address: string;
+        params: SidebarRightNavigationParams;
+    }): void;
+    /** Abort every occurrence of every session; the package is unloading. */
+    dispose(): void;
+    private session;
+    private hold;
+}
+//# sourceMappingURL=tab-domain.d.ts.map

package/lib/types/client/tab-info.d.ts

@@ -0,0 +1,29 @@
+import type { TabId } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { KeyedSnapshotSelectorHook, PropsStore, SlotHookFactory } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SidebarRightTabActions, SidebarRightTabNavigation, UseSidebarRightTabInfo } from './contract/slots.ts';
+import type { createSidebarRightStore } from './stores.ts';
+/** Stable dispatch identity and framework hooks; never passed as tab component props. */
+export interface TabHookContext {
+    readonly tabId: TabId;
+    readonly title: boolean;
+    readonly fullscreen: boolean;
+    readonly signal: AbortSignal;
+    readonly actions: SidebarRightTabActions;
+    readonly useStore: PropsStore<ReturnType<typeof createSidebarRightStore>>['useStore'];
+    readonly useTabNavigation: KeyedSnapshotSelectorHook<SidebarRightTabNavigation>;
+}
+/**
+ * Bind a tab occurrence without subscribing or creating records during factory evaluation.
+ * @param standard - framework session identity.
+ * @param context - stable record lifetime and framework-bound readers.
+ * @returns the tab information hook.
+ */
+export declare const tabInfoFactory: SlotHookFactory<'sidebar.right.pane.tab', UseSidebarRightTabInfo>;
+/**
+ * Forward the framework-bound tab hook to a guide replacement.
+ * @param _standard - the guide's framework standard props.
+ * @param useTabInfo - the enclosing tab's framework-bound reader.
+ * @returns the same reader for the replacement.
+ */
+export declare const guideTabInfoFactory: SlotHookFactory<'sidebar.right.tab.guide', UseSidebarRightTabInfo>;
+//# sourceMappingURL=tab-info.d.ts.map

package/lib/types/client/tab-registry.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Stage one of tab-type registration: what a type IS.
+ *
+ * A registration is purely static — which addresses the type recognizes, how it
+ * ranks against other types that recognize the same one, what the tab chip says,
+ * and whether the type offers an entry box on the guide page. Nothing here is
+ * per-tab, per-session, or a runtime hook: stage two is the keyed
+ * `sidebar.right.pane.tab` registration that supplies the body under the same
+ * `kind`, and everything a body needs at runtime arrives in its props.
+ *
+ * Address recognition follows VS Code's editor resolver: a glob declaration
+ * narrows the candidates, an optional `canOpen` predicate vetoes, and the
+ * survivors are ranked by priority band, then by matched-pattern length, then by
+ * registration order. Addresses are `scheme://` URIs; the one local change to
+ * VS Code's glob rule is that a pattern containing `:` matches the whole address
+ * (`dsh-resource://file/**`, `sidebar://guide`) rather than the URI's path.
+ *
+ * A kind may carry one `builtin` and one `extension` registration at once: the
+ * extension is the one in force — claims, `get`, the guide page, and the body
+ * and title, which the seat finds under the definition's own `id` — and the
+ * builtin resumes when the extension unregisters. Everything else colliding on
+ * a kind throws, as does a second registration of an `id`.
+ *
+ * Thunked copy (`title`, `guide[].title`) is read again on every use, so a
+ * language change needs no re-registration.
+ */
+import type { ComponentType } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { IconProps } from '@deepseek-ai/dsh-client-ui-primitives';
+/**
+ * How strongly a type wants an address it recognizes, as one of three literal
+ * bands (a string, not an imported constant, so a type shipped from another
+ * package needs no runtime import from here).
+ *
+ * - `extension` — a type from outside the product, and the highest: a type that
+ *   declares nothing outranks every viewer shipped here, exactly as in VS Code.
+ *   It is also the band that may take over a `builtin` kind.
+ * - `builtin` — the ordinary band for types shipped with the product.
+ * - `fallback` — plain-content viewers that anything more specific should beat.
+ *   VS Code's text editor holds this position implicitly; ours is a separate
+ *   package, so it says so.
+ */
+export type SidebarRightTabPriority = 'extension' | 'builtin' | 'fallback';
+/** One entry box the guide page offers, contributed by the type it opens (picking it opens that type as a page). */
+export interface SidebarRightGuideEntry {
+    /** Ascending position among every registered type's entries. */
+    readonly order: number;
+    /**
+     * The box's heading.
+     * @returns the heading in the current language.
+     */
+    readonly title: () => string;
+    /**
+     * One line under the heading.
+     * @returns the line in the current language.
+     */
+    readonly description: () => string;
+    /** Optional glyph, drawn at the box's leading edge. */
+    readonly icon?: ComponentType<IconProps>;
+}
+/** A guide entry as the registry lists it: with the kind of the type that contributed it, which is what picking it opens. */
+export interface SidebarRightGuideBox extends SidebarRightGuideEntry {
+    readonly kind: string;
+}
+/** One registered tab type: its static face, and nothing else. */
+export interface SidebarRightTabDefinition {
+    /**
+     * This implementation's identity in the tab system, unique across every
+     * registration (a package name is the natural value). A kind is not unique —
+     * an extension may take a builtin's over — so the implementation carries its
+     * own name, and it is the key its body and title register under in the
+     * `sidebar.right.pane.tab` and `sidebar.right.pane.tab.title` seats.
+     */
+    readonly id: string;
+    /** Type discriminator: what the tabs of this type are, and what `openTab` names. */
+    readonly kind: string;
+    /**
+     * Resource-address globs this type recognizes; omit for a page type, which is
+     * opened by kind and recognizes no address.
+     *
+     * A pattern containing `:` is matched against the whole address
+     * (`dsh-resource://file/**`); one without is matched against the URI's path at
+     * any depth (`*.md` matches `dsh-resource://file/session/s1/home/me/notes.md`),
+     * and an address that is not a URI matches no such pattern. Matching ignores
+     * case and does not hide dotfiles.
+     */
+    readonly patterns?: readonly string[];
+    /** Defaults to `extension`: a type that says nothing is one from outside the product. */
+    readonly priority?: SidebarRightTabPriority;
+    /**
+     * Veto an address this type's globs matched.
+     *
+     * Synchronous and cheap: it runs on every routing decision. Omit it to accept
+     * every match.
+     * @param address - the matched address.
+     * @returns whether this type will open it.
+     */
+    readonly canOpen?: (address: string) => boolean;
+    /**
+     * The tab chip's initial text, captured into the layout record at open time.
+     * @param address - the address being opened.
+     * @returns the title in the current language.
+     */
+    readonly title: (address: string) => string;
+    /** Entry boxes for the guide page. Omit to stay off it. */
+    readonly guide?: readonly SidebarRightGuideEntry[];
+}
+/** What a routing decision settles on: who draws the address, and as what. */
+export interface SidebarRightTabClaim {
+    /** The claiming type. */
+    readonly kind: string;
+    /**
+     * Stable identity of the content, which is the address itself.
+     *
+     * Two opens of the same address are the same tab, which is what makes opening
+     * idempotent.
+     */
+    readonly contentId: string;
+    /** Title for the tab chip. */
+    readonly title: string;
+}
+/**
+ * The registered tab types.
+ *
+ * Registration order is part of the contract: it breaks ties between types that
+ * recognize an address equally well.
+ */
+export declare class SidebarRightTabRegistry {
+    private readonly ctx;
+    private readonly kinds;
+    private readonly ids;
+    private readonly listeners;
+    private registrations;
+    private cached;
+    private guideEntries;
+    /** @param ctx - Context whose effects own the contributed types. */
+    constructor(ctx: Context);
+    /**
+     * Register one tab type for the caller's lifetime.
+     *
+     * The caller holds the returned disposer inside its own `ctx.effect`, so a
+     * type's registration lives exactly as long as the plugin that contributed it.
+     * An `extension` may register a kind a `builtin` already holds and takes it
+     * over until it unregisters; a second registration in the same band, or any
+     * registration meeting a `fallback` of the same kind, is a wiring mistake, and
+     * so is an `id` already in use.
+     * @param definition - the contributed type.
+     * @returns idempotent disposer.
+     * @throws when the id is taken, or the kind is already registered in a way this one cannot coexist with.
+     */
+    register(definition: SidebarRightTabDefinition): () => void;
+    /** Add a registration to its kind's slot, the higher band in force; `coexists` has already admitted it. */
+    private enter;
+    /** Remove a registration from its kind's slot: a shadowed builtin resumes, and an emptied kind is freed. */
+    private leave;
+    /** Every kind's registration in force, in registration order. */
+    private active;
+    /**
+     * Registered types in registration order.
+     * @returns reference-stable entries.
+     */
+    entries(): readonly SidebarRightTabDefinition[];
+    /**
+     * Every type in force's guide entries, in `order`, each naming the kind it opens.
+     * @returns reference-stable entries.
+     */
+    guide(): readonly SidebarRightGuideBox[];
+    /**
+     * The type in force for a kind.
+     * @param kind - the type discriminator.
+     * @returns the type, or `undefined` when nothing registered it.
+     */
+    get(kind: string): SidebarRightTabDefinition | undefined;
+    /**
+     * Every type that would open an address, best first.
+     *
+     * Ranked by priority band, then by the length of the pattern that matched,
+     * then by registration order. Types whose `canOpen` vetoes are absent.
+     * @param address - the address a caller wants opened.
+     * @returns the ranked types; empty when nothing recognizes the address.
+     */
+    candidates(address: string): readonly SidebarRightTabDefinition[];
+    /**
+     * Decide which type opens an address, and as what.
+     *
+     * Without `kind`, the best candidate wins. With `kind`, that type opens the
+     * address if its `canOpen` agrees — its globs are not consulted, because
+     * naming the type IS the decision.
+     *
+     * An address no type will open is a wiring mistake, not a user error, so this
+     * throws rather than reporting absence.
+     * @param address - the address a caller wants opened.
+     * @param kind - a type named by the caller, overriding the ranking.
+     * @returns the claiming type and the record to open.
+     */
+    claim(address: string, kind?: string): SidebarRightTabClaim;
+    /**
+     * Observe low-frequency registry changes.
+     * @param listener - synchronous invalidation callback.
+     * @returns unsubscribe callback.
+     */
+    subscribe(listener: () => void): () => void;
+    private refresh;
+}
+//# sourceMappingURL=tab-registry.d.ts.map

package/lib/types/client/tabs/guide/GuideBody.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The guide tab's body: a chain host, and the guide it falls back to.
+ *
+ * The chain is the replacement seam. A product with its own idea of what an
+ * empty sidebar should say registers into `sidebar.right.tab.guide`, and its entry
+ * takes the whole body; with no entry, or with every entry declining, the guide
+ * below renders. The shipped guide is the owner's fallback rather than a chain
+ * entry of its own, so there is always exactly one body and the shipped one
+ * cannot be outvoted by accident.
+ *
+ * The shipped guide is a centred title, one line under it, and the entry boxes
+ * every registered type contributed. Picking a box opens that type as a page in
+ * this tab's place, so the guide is a doorway rather than a page that stays open.
+ */
+import type { ReactNode } from 'react';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SidebarRightGuideBox } from '../../tab-registry.ts';
+/** What the guide body needs from its host beyond the framework shares. */
+export interface GuideInjected {
+    /** The registry's guide entries in `order`; observable, so a type registering later appears. */
+    readonly hooks: {
+        readonly guideEntries: ObservableSnapshot<readonly SidebarRightGuideBox[]>;
+    };
+}
+/** The guide body's composed props: the tab it draws, its chain child, its copy, and the entries. */
+export type GuideBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsRenderSlots<'sidebar.right.tab.guide'> & PropsLocale<'sidebarRight'> & InjectFace<GuideInjected>;
+/** The guide tab's body, replaceable through its chain child. */
+export declare function GuideBody({ useTabInfo, useGuideEntries, renderSlotChain, t }: GuideBodyProps): ReactNode;
+//# sourceMappingURL=GuideBody.d.ts.map

package/lib/types/client/tabs/guide/definition.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Stage one of the guide type's registration: what it IS.
+ */
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+import type { SidebarRightTabDefinition } from '../../tab-registry.ts';
+/** The shipped guide implementation's identity: the key its body registers under. */
+export declare const GUIDE_ID = "@deepseek-ai/dsh-client-ui-sidebar-right/guide";
+/**
+ * The guide type's registry definition.
+ *
+ * A page type: it recognizes no resource address, because a guide views
+ * nothing, and is opened by kind; `builtin` is the ordinary band for a type
+ * shipped here.
+ * @param t - namespace-bound translate, read fresh on every title call.
+ * @returns the definition to register.
+ */
+export declare function guideDefinition(t: TranslateNS<'sidebarRight'>): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Pure host half; the whole Sidebar lives in the browser export. */
+/** Host plugin body: the Sidebar contributes nothing to the host tree. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map