@termix-ssh/plugin-sdk 1.0.11 → 1.0.13

package/dist/host/types/src/ui/settings/appearance/appearance-controls.d.ts

@@ -0,0 +1,53 @@
+import type { FontSizeId, ThemeId, UiFontId } from "../../../types/ui-types";
+import { type ThemeSwatch } from "../../look/theme-registry";
+export declare const DEFAULT_ACCENT = "#f59145";
+/** The built-in themes, with System first. Plugin themes come from useThemeOptions. */
+export declare const THEMES: {
+    id: ThemeId;
+    preview: string;
+}[];
+export interface ThemeOption {
+    id: ThemeId;
+    label: string;
+    /** Null for System, which previews light and dark side by side. */
+    swatch: ThemeSwatch | null;
+}
+/** Every theme to pick from, System first, plugin themes included. */
+export declare function useThemeOptions(): ThemeOption[];
+export declare function isHexColor(value: string): boolean;
+/**
+ * Theme, accent, font and language, applied right away and stored the same
+ * way the profile settings store them.
+ */
+export declare function useAppearanceSettings(): {
+    theme: string;
+    accent: string;
+    fontSize: FontSizeId;
+    uiFont: UiFontId;
+    language: string;
+    setTheme(id: ThemeId): void;
+    setAccent(value: string): void;
+    setFontSize(id: FontSizeId): void;
+    setUiFont(id: UiFontId): void;
+    setLanguage(code: string): void;
+};
+export declare function ThemeGrid({ value, onChange, }: {
+    value: ThemeId;
+    onChange: (id: ThemeId) => void;
+}): import("react").JSX.Element;
+export declare function AccentPicker({ value, onChange, }: {
+    value: string;
+    onChange: (value: string) => void;
+}): import("react").JSX.Element;
+export declare function FontSizePicker({ value, onChange, }: {
+    value: FontSizeId;
+    onChange: (id: FontSizeId) => void;
+}): import("react").JSX.Element;
+export declare function UiFontSelect({ value, onChange, }: {
+    value: UiFontId;
+    onChange: (id: UiFontId) => void;
+}): import("react").JSX.Element;
+export declare function LanguageSelect({ value, onChange, }: {
+    value: string;
+    onChange: (code: string) => void;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/settings/sync/LinkServerDialog.d.ts

@@ -0,0 +1,12 @@
+import { type SyncStatus } from "../../api/sync-api";
+interface LinkServerDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onLinked: (status: SyncStatus) => void;
+    /** Sign back in to the server this desktop is already linked to. */
+    relogin?: {
+        serverUrl: string;
+    };
+}
+export declare function LinkServerDialog({ open, onOpenChange, onLinked, relogin, }: LinkServerDialogProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/settings/sync/ProxySettingsFields.d.ts

@@ -0,0 +1,15 @@
+import type { SyncBasicAuth, SyncProxyHeader } from "../../api/sync-api";
+interface ProxySettingsFieldsProps {
+    customHeaders: SyncProxyHeader[];
+    basicAuth: SyncBasicAuth | null;
+    onChange: (next: {
+        customHeaders?: SyncProxyHeader[];
+        basicAuth?: SyncBasicAuth | null;
+    }) => void;
+}
+/**
+ * What a reverse proxy in front of the server wants: extra headers (a
+ * Cloudflare Access service token, a gateway key) and basic auth.
+ */
+export declare function ProxySettingsFields({ customHeaders, basicAuth, onChange, }: ProxySettingsFieldsProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/settings/sync/saved-servers.d.ts

@@ -0,0 +1,3 @@
+export declare function getSavedServerUrls(): string[];
+export declare function rememberServerUrl(url: string): string[];
+export declare function forgetServerUrl(url: string): string[];

package/dist/host/types/src/ui/shell/controller/ShellControllerProvider.d.ts

@@ -0,0 +1,20 @@
+import { type TabStageStore } from "../stage/tab-stage-store";
+import type { ShellController } from "./types";
+/** The live shell, for core layout code. Throws outside the shell. */
+export declare function useShellController(): ShellController;
+/** The live shell, or null outside it. */
+export declare function useOptionalShellController(): ShellController | null;
+export declare function useTabStageStore(): TabStageStore;
+/**
+ * Hands the main area's confirm to code outside it, like closeTab. A layout
+ * renders it inside the scope its tab-close questions should show in.
+ */
+export declare function ShellConfirmCapture(): null;
+/** Owns every bit of shell state and behaviour a layout draws. */
+export declare function ShellControllerProvider({ username, onLogout, children, }: {
+    username: string;
+    onLogout: (options?: {
+        manual?: boolean;
+    }) => void;
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/shell/controller/plugin-shell.d.ts

@@ -0,0 +1,7 @@
+import type { ShellController as PluginShellController } from "@termix-ssh/plugin-sdk/frontend";
+/**
+ * The shell as a plugin layout sees it, through useShell() in the SDK. Inside
+ * the shell this reads the controller's context; outside (an overlay a
+ * plugin mounted elsewhere) the last published one.
+ */
+export declare function usePluginShell(pluginId: string): PluginShellController | null;

package/dist/host/types/src/ui/shell/controller/shell-store.d.ts

@@ -0,0 +1,4 @@
+import type { ShellController } from "./types";
+export declare function publishShellController(next: ShellController | null): void;
+export declare function getShellController(): ShellController | null;
+export declare function useShellSnapshot(): ShellController | null;

package/dist/host/types/src/ui/shell/controller/types.d.ts

@@ -0,0 +1,156 @@
+import type { MutableRefObject } from "react";
+import type { TabHandle } from "@termix-ssh/plugin-sdk/frontend";
+import type { ConfirmOptions, EditingWidth } from "../../components/surface/surface-scope";
+import type { Host, HostFolder, Tab, TabType } from "../../../types/ui-types";
+import type { OpenTabRecord, UserPreferences } from "../../main-axios";
+import type { TabShellCallbacks } from "../tab-registry";
+import type { SplitViewActions } from "../split/SplitView";
+import type { NewTabOption, PickHostTarget } from "../split/EmptyPanePicker";
+import type { SplitSummary, SplitTab, TabSplitAction } from "../split/split-tabs";
+export interface DockRegion {
+    view: string;
+    open: boolean;
+    width: number;
+    dragging: boolean;
+    editing: EditingWidth;
+    setView: (view: string | ((prev: string) => string)) => void;
+    setOpen: (open: boolean | ((prev: boolean) => boolean)) => void;
+    setWidth: (width: number) => void;
+    startResize: (e: React.MouseEvent) => void;
+    resetWidth: () => void;
+}
+export interface RightDockRegion {
+    view: string | null;
+    open: boolean;
+    width: number;
+    dragging: boolean;
+    setView: (view: string | null | ((prev: string | null) => string | null)) => void;
+    setWidth: (width: number) => void;
+    startResize: (e: React.MouseEvent) => void;
+    resetWidth: () => void;
+}
+export interface ShellRegions {
+    left: DockRegion;
+    right: RightDockRegion;
+    /** What clicking a rail item does: toggles or switches the left dock. */
+    railClick: (view: string) => void;
+    openInRightDock: (view: string) => void;
+    toggleRightDock: () => void;
+    previousView: () => string | null;
+    /** Stable setters a panel reports its wanted sidebar width with. */
+    panelEditingSetter: (view: string) => (editing: EditingWidth) => void;
+    scopeEditingSetter: (view: string) => (editing: EditingWidth) => void;
+}
+export interface OpenTabOptions {
+    data?: Record<string, unknown>;
+    label?: string;
+    forceNewTab?: boolean;
+}
+export interface RestoreTarget {
+    instanceId: string;
+    restoredSessionId: string | null;
+    savedLabel?: string;
+}
+export interface ShellTabs {
+    list: Tab[];
+    /** Tabs shown in a tab bar: everything not sitting inside a split. */
+    topLevel: Tab[];
+    activeId: string;
+    active: Tab | undefined;
+    ready: boolean;
+    /** Tabs panels can type into. */
+    terminalTabs: Tab[];
+    /** The terminal command panels act on right now. */
+    targetTerminal: Tab | undefined;
+    showNumbers: boolean;
+    background: OpenTabRecord[];
+    setBackground: (next: OpenTabRecord[] | ((prev: OpenTabRecord[]) => OpenTabRecord[])) => void;
+    setActive: (id: string) => void;
+    setList: (next: Tab[] | ((prev: Tab[]) => Tab[])) => void;
+    reorder: (topLevel: Tab[]) => void;
+    open: (host: Host, type: TabType, restore?: RestoreTarget, options?: OpenTabOptions) => string;
+    openSingleton: (type: TabType, pendingEvent?: string, host?: Host, data?: Record<string, unknown>, label?: string) => string | undefined;
+    openMultiInstance: (type: TabType, options?: {
+        host?: Host;
+        data?: Record<string, unknown>;
+        label?: string;
+    }) => string;
+    connectHost: (host: Host, type?: TabType, options?: OpenTabOptions) => void;
+    close: (id: string) => Promise<void>;
+    rename: (id: string, label: string) => void;
+    refresh: (id: string) => void;
+    reconnectAll: () => void;
+    handleFor: (id: string) => TabHandle | null | undefined;
+}
+export interface EmptyPaneApi {
+    freeTabs: Tab[];
+    newTabOptions: NewTabOption[];
+    pickTab: (splitTabId: string, paneId: string, tabId: string) => void;
+    pickHost: (splitTabId: string, paneId: string, host: Host, pick: PickHostTarget) => void;
+    openType: (splitTabId: string, paneId: string, type: string) => void;
+    closePane: (splitTabId: string, paneId: string) => void;
+}
+export interface ShellSplit {
+    active: SplitTab | null;
+    /** The pane each on-screen tab sits in, for the active split only. */
+    paneIdByTabId: Map<string, string>;
+    focusedPaneId: string | null;
+    summaries: SplitSummary[];
+    activeFull: boolean;
+    handleAction: (action: TabSplitAction) => void;
+    viewActions: (splitTabId: string) => SplitViewActions;
+    emptyPane: EmptyPaneApi;
+}
+export interface ShellHosts {
+    list: Host[];
+    tree: HostFolder | null;
+    loading: boolean;
+    loaded: boolean;
+    reload: () => Promise<void>;
+    edit: (host: Host) => void;
+}
+export interface ShellPalette {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    setOpen: (open: boolean | ((prev: boolean) => boolean)) => void;
+}
+export interface ShellSettingsProps {
+    username: string;
+    isAdmin: boolean;
+    onLogout: (options?: {
+        manual?: boolean;
+    }) => void;
+    userPrefs: UserPreferences;
+    onPrefsChange: (updates: Partial<UserPreferences>) => void;
+    onOpenHostTab: (host: Host) => void;
+}
+/** Everything the shell knows and can do, minus drawing it. */
+export interface ShellController {
+    username: string;
+    isAdmin: boolean;
+    isMobile: boolean;
+    isElectron: boolean;
+    pluginsSettled: boolean;
+    logout: (options?: {
+        manual?: boolean;
+    }) => void;
+    tabs: ShellTabs;
+    split: ShellSplit;
+    hosts: ShellHosts;
+    regions: ShellRegions;
+    palette: ShellPalette;
+    fullscreen: {
+        active: boolean;
+        toggle: () => void;
+    };
+    /** One stable bag that forwards to the latest shell, for tabs and plugins. */
+    callbacks: TabShellCallbacks;
+    /** Same, but closes the sidebar on mobile after opening a tab. */
+    panelCallbacks: TabShellCallbacks;
+    settings: ShellSettingsProps;
+    /** Where the main area's confirm is captured, see ShellConfirmCapture. */
+    confirmRef: MutableRefObject<((options: ConfirmOptions) => Promise<boolean>) | null>;
+    /** Refits every visible terminal, e.g. after a pane resize ends. */
+    resizeAllTerminals: () => number;
+}

package/dist/host/types/src/ui/shell/controller/use-hosts.d.ts

@@ -0,0 +1,10 @@
+import type { Host, HostFolder } from "../../../types/ui-types";
+/** The saved hosts and their folder tree, kept fresh on change events. */
+export declare function useHostList(): {
+    list: Host[];
+    listRef: import("react").RefObject<Host[]>;
+    tree: HostFolder;
+    loading: boolean;
+    loaded: boolean;
+    reload: () => Promise<void>;
+};

package/dist/host/types/src/ui/shell/controller/use-regions.d.ts

@@ -0,0 +1,5 @@
+import type { ShellRegions } from "./types";
+/** The left sidebar and the right dock: what they show, open state and size. */
+/** A dock's width after Reset width, in Normal-size pixels. */
+export declare const DOCK_DEFAULT_WIDTH = 291;
+export declare function useRegions(isMobile: boolean): ShellRegions;

package/dist/host/types/src/ui/shell/controller/use-shell-keybindings.d.ts

@@ -0,0 +1,12 @@
+import { type MutableRefObject } from "react";
+import type { TabsState } from "./use-tabs";
+import type { SplitActions } from "./use-split";
+import type { ShellPalette, ShellRegions } from "./types";
+/** Every shell-wide shortcut: custom bindings, palette, panes and tabs. */
+export declare function useShellKeybindings({ tabsState, regions, palette, splitActionsRef, toggleFullscreen, }: {
+    tabsState: TabsState;
+    regions: ShellRegions;
+    palette: ShellPalette;
+    splitActionsRef: MutableRefObject<SplitActions | null>;
+    toggleFullscreen: () => void;
+}): void;

package/dist/host/types/src/ui/shell/controller/use-shell-lifecycle.d.ts

@@ -0,0 +1,17 @@
+import { type MutableRefObject } from "react";
+import { type UserPreferences } from "../../main-axios";
+import type { TabType } from "../../../types/ui-types";
+/** Who is signed in and what the shell does around the tabs: prefs, health, logout. */
+export declare function useShellLifecycle({ onLogout, openSingletonTabRef, }: {
+    onLogout: (options?: {
+        manual?: boolean;
+    }) => void;
+    openSingletonTabRef: MutableRefObject<(type: TabType) => string | undefined>;
+}): {
+    isAdmin: boolean;
+    userPrefs: UserPreferences;
+    setUserPrefs: import("react").Dispatch<import("react").SetStateAction<UserPreferences>>;
+    userPrefsLoaded: boolean;
+    isAppFullscreen: boolean;
+    toggleAppFullscreen: () => Promise<void>;
+};

package/dist/host/types/src/ui/shell/controller/use-split.d.ts

@@ -0,0 +1,21 @@
+import type { TabShellCallbacks } from "../tab-registry";
+import { type NavDirection } from "../split/split-tree";
+import { type TabsState } from "./use-tabs";
+import type { ShellSplit } from "./types";
+export interface SplitActions {
+    splitActive: (edge: "right" | "bottom") => void;
+    navigate: (direction: NavDirection) => boolean;
+    zoomFocused: () => boolean;
+    closeFocusedPane: () => void;
+}
+export declare function useSplit({ tabsState, isMobile, paneEls, callbacks, resizeAllTerminals, }: {
+    tabsState: TabsState;
+    isMobile: boolean;
+    paneEls: Map<string, HTMLDivElement>;
+    callbacks: TabShellCallbacks;
+    resizeAllTerminals: () => number;
+}): {
+    split: ShellSplit;
+    splitShapeKey: string;
+    splitActionsRef: import("react").RefObject<SplitActions>;
+};

package/dist/host/types/src/ui/shell/controller/use-tabs.d.ts

@@ -0,0 +1,70 @@
+import { type MutableRefObject } from "react";
+import type { TabHandle } from "@termix-ssh/plugin-sdk/frontend";
+import type { ConfirmOptions } from "../../components/surface/surface-scope";
+import type { Host, Tab, TabType } from "../../../types/ui-types";
+import { type OpenTabRecord, type UserPreferences } from "../../main-axios";
+import type { OpenTabOptions, RestoreTarget } from "./types";
+export declare function dashboardTab(label: string): Tab;
+/** What the tab code needs from the split code, filled in by useSplit. */
+export interface SplitOps {
+    unsplit: (splitTabId: string) => void;
+    closePaneOf: (splitTabId: string, paneId: string) => void;
+}
+export declare function useSplitLabel(): (number: number) => string;
+export declare function useTabs({ hosts, hostsRef, hostsLoaded, reloadHosts, userPrefs, userPrefsLoaded, pluginsSettled, confirmRef, layoutDeps, }: {
+    hosts: Host[];
+    hostsRef: MutableRefObject<Host[]>;
+    hostsLoaded: boolean;
+    reloadHosts: () => Promise<void>;
+    userPrefs: UserPreferences;
+    userPrefsLoaded: boolean;
+    pluginsSettled: boolean;
+    confirmRef: MutableRefObject<((options: ConfirmOptions) => Promise<boolean>) | null>;
+    /** Region state whose change also counts as a layout change for plugins. */
+    layoutDeps: unknown[];
+}): {
+    tabs: Tab[];
+    setTabs: import("react").Dispatch<import("react").SetStateAction<Tab[]>>;
+    activeTabId: string;
+    setActiveTabId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    tabsReady: boolean;
+    backgroundTabRecords: OpenTabRecord[];
+    setBackgroundTabRecords: import("react").Dispatch<import("react").SetStateAction<OpenTabRecord[]>>;
+    tabsRef: import("react").RefObject<Tab[]>;
+    activeTabIdRef: import("react").RefObject<string>;
+    closeActiveTabRef: import("react").RefObject<() => void>;
+    reconnectAllRef: import("react").RefObject<() => void>;
+    terminalRefs: import("react").RefObject<Map<string, import("react").RefObject<unknown>>>;
+    splitOpsRef: import("react").RefObject<SplitOps>;
+    suppressPaneTargetRef: import("react").RefObject<boolean>;
+    pendingPaneTargetRef: import("react").RefObject<{
+        splitTabId: string;
+        paneId: string;
+        at: number;
+        fresh: boolean;
+    }>;
+    openSingletonTabRef: import("react").RefObject<(type: TabType, pendingEvent?: string, host?: Host, data?: Record<string, unknown>, tabLabel?: string) => string | undefined>;
+    hostsRef: MutableRefObject<Host[]>;
+    focusedSessionTabId: () => string | null;
+    targetPane: (splitTabId: string, paneId: string, fresh?: boolean) => void;
+    openTab: (host: Host, type: TabType, restore?: RestoreTarget, options?: OpenTabOptions) => string;
+    connectHost: (host: Host, preferredType?: TabType, options?: OpenTabOptions) => void;
+    saveQuickConnectHost: (tab: Tab, host: Host) => Promise<void>;
+    openMultiInstanceTab: (type: TabType, options?: {
+        host?: Host;
+        data?: Record<string, unknown>;
+        label?: string;
+    }) => string;
+    openSingletonTab: (type: TabType, pendingEvent?: string, host?: Host, data?: Record<string, unknown>, tabLabel?: string) => string | undefined;
+    doCloseTab: (id: string) => void;
+    closeTab: (id: string) => Promise<void>;
+    renameTab: (tabId: string, newLabel: string) => void;
+    refreshTab: (id: string) => void;
+    reconnectAllDisconnected: () => void;
+    reorderTopLevelTabs: (reordered: Tab[]) => void;
+    showTabNumbers: boolean;
+    terminalTabs: Tab[];
+    targetTerminalTab: Tab;
+    handleFor: (id: string) => TabHandle | null | undefined;
+};
+export type TabsState = ReturnType<typeof useTabs>;

package/dist/host/types/src/ui/shell/controller/use-workspace-layout.d.ts

@@ -0,0 +1,4 @@
+import { type TabsState } from "./use-tabs";
+import type { ShellRegions } from "./types";
+/** Saving and applying a whole arrangement, for workspaces and plugins. */
+export declare function useWorkspaceLayout(tabsState: TabsState, regions: ShellRegions): void;

package/dist/host/types/src/ui/shell/reconnect-tabs.d.ts

@@ -0,0 +1,6 @@
+import type { Tab } from "../../types/ui-types";
+/** Includes hidden tabs and split children; each plugin decides whether it is idle. */
+export declare function reconnectDisconnectedTabs(tabs: readonly Tab[]): {
+    reconnected: number;
+    failed: number;
+};

package/dist/host/types/src/ui/shell/shell-layout.d.ts

@@ -0,0 +1,46 @@
+import type { Host, SplitState, Tab, WorkspacePayload, WorkspaceTabSnapshot } from "../../types/ui-types";
+export declare function isCapturableTabType(type: string): boolean;
+/**
+ * Maps live tabs to snapshots, with a fresh slotId per tab. slotId is a
+ * stable key within the saved payload, distinct from Tab.id, which is
+ * regenerated every time a tab opens.
+ */
+export declare function buildLayoutTabSnapshots(tabs: Tab[], genSlotId?: () => string): {
+    snapshots: WorkspaceTabSnapshot[];
+    slotIdByTabId: Map<string, string>;
+};
+/**
+ * The tab's plugin payload. Payloads saved before tabs carried `data` stored
+ * the fleet a fleet-inventory tab showed as a field of its own.
+ */
+export declare function snapshotData(snapshot: WorkspaceTabSnapshot): Record<string, unknown> | undefined;
+/**
+ * How to reopen one saved tab. "singleton" types go through
+ * openSingletonTab with an optional host; "host" types need a resolved host
+ * to open at all.
+ */
+export declare function resolveLayoutTabTarget(snapshot: WorkspaceTabSnapshot, allHosts: Host[]): {
+    kind: "singleton";
+    host?: Host;
+} | {
+    kind: "host";
+    host: Host;
+} | {
+    kind: "skip";
+};
+export declare function buildLayoutPayload(input: {
+    tabs: Tab[];
+    activeTabId: string;
+    genSlotId?: () => string;
+    sidebar?: WorkspacePayload["sidebar"];
+}): WorkspacePayload;
+/**
+ * The splits a saved layout describes, with live tab ids. Version 1 payloads
+ * held one split as a fixed mode; it comes back with no label or slotId, so
+ * the caller names it.
+ */
+export declare function resolveLayoutSplits(payload: WorkspacePayload, slotIdToTabId: Map<string, string>): {
+    slotId: string | null;
+    label: string | null;
+    split: SplitState;
+}[];

package/dist/host/types/src/ui/shell/split/EmptyPanePicker.d.ts

@@ -0,0 +1,32 @@
+import { type HostActionDef } from "../../sidebar/host-contributions";
+import type { Host, Tab } from "../../../types/ui-types";
+export interface NewTabOption {
+    type: string;
+    label: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+}
+export type PickHostTarget = {
+    action: HostActionDef;
+} | {
+    action: HostActionDef;
+    item: {
+        id: string;
+        label: string;
+    };
+};
+/**
+ * What an empty pane shows: the tabs that could move in, new tabs to start,
+ * and every host with the ways to open it. Picking anything fills this pane.
+ */
+export declare function EmptyPanePicker({ paneIndex, freeTabs, hosts, newTabOptions, onPickTab, onPickHost, onOpenType, onClosePane, }: {
+    paneIndex: number;
+    freeTabs: Tab[];
+    hosts: Host[];
+    newTabOptions: NewTabOption[];
+    onPickTab: (tabId: string) => void;
+    onPickHost: (host: Host, target: PickHostTarget) => void;
+    onOpenType: (type: string) => void;
+    onClosePane: () => void;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/shell/split/SplitDropOverlay.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject } from "react";
+/**
+ * Drop zones over the main area while a tab or pane is dragged. Over a
+ * split, each pane offers its four edges (split there) and its center (show
+ * it there). Over a plain tab only the edges count, to start a new split.
+ */
+export declare function SplitDropOverlay({ containerRef, }: {
+    containerRef: RefObject<HTMLElement | null>;
+}): import("react").ReactPortal;

package/dist/host/types/src/ui/shell/split/SplitLayoutMenu.d.ts

@@ -0,0 +1,16 @@
+import { type SplitPresetId } from "./split-presets";
+import { type PaneEdge } from "./split-tree";
+/** A small drawing of a preset's panes. */
+export declare function PresetThumb({ id }: {
+    id: SplitPresetId;
+}): import("react").JSX.Element;
+/**
+ * The tab bar's split button: split the active tab right or down, or lay it
+ * out as one of the presets.
+ */
+export declare function SplitLayoutMenu({ activeIsSplit, canAddPane, onSplit, onPreset, }: {
+    activeIsSplit: boolean;
+    canAddPane: boolean;
+    onSplit: (edge: Extract<PaneEdge, "right" | "bottom">) => void;
+    onPreset: (id: SplitPresetId) => void;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/shell/split/SplitView.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import type { Tab } from "../../../types/ui-types";
+import type { SplitTab } from "./split-tabs";
+import { type PaneEdge } from "./split-tree";
+export interface SplitViewActions {
+    focusPane: (paneId: string) => void;
+    resize: (nodeId: string, sizes: number[]) => void;
+    equalize: (nodeId: string) => void;
+    splitPane: (paneId: string, edge: Extract<PaneEdge, "right" | "bottom">) => void;
+    closePane: (paneId: string) => void;
+    closeSession: (tabId: string) => void;
+    moveToTab: (paneId: string) => void;
+    showInPane: (paneId: string, tabId: string | null) => void;
+    swapPanes: (firstId: string, secondId: string) => void;
+    toggleZoom: (paneId: string) => void;
+    /** A divider drag finished, so sessions can fit their new size. */
+    resizeEnd: () => void;
+}
+/**
+ * A split tab's panes. Each pane with a tab renders an empty host element;
+ * the shell moves the tab's own DOM node into it, so switching panes never
+ * remounts a session.
+ */
+export declare function SplitView({ splitTab, tabs, isMobile, actions, onPaneContentRef, renderEmptyPane, }: {
+    splitTab: SplitTab;
+    tabs: Tab[];
+    isMobile: boolean;
+    actions: SplitViewActions;
+    onPaneContentRef: (paneId: string, el: HTMLDivElement | null) => void;
+    renderEmptyPane: (paneId: string, paneIndex: number) => React.ReactNode;
+}): React.JSX.Element;

package/dist/host/types/src/ui/shell/split/split-drag.d.ts

@@ -0,0 +1,58 @@
+import type { DropTarget } from "./split-tree";
+/**
+ * Dragging a tab or a pane onto the main area to split it. The tab bar and
+ * pane headers start a drag, the drop overlay over the main area answers
+ * where the pointer is, and the shell's handler acts on the drop.
+ */
+export type SplitDragSource = {
+    kind: "tab";
+    tabId: string;
+    label: string;
+} | {
+    kind: "pane";
+    splitTabId: string;
+    paneId: string;
+    label: string;
+};
+export interface SplitDropHover {
+    /** The pane under the pointer, or null over a view that is not split. */
+    paneId: string | null;
+    target: DropTarget;
+    rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}
+export interface SplitDragState {
+    source: SplitDragSource;
+    x: number;
+    y: number;
+    hover: SplitDropHover | null;
+}
+type HitTest = (x: number, y: number, source: SplitDragSource) => SplitDropHover | null;
+type DropHandler = (source: SplitDragSource, hover: SplitDropHover) => void;
+export declare function beginSplitDrag(source: SplitDragSource, x: number, y: number): void;
+export declare function moveSplitDrag(x: number, y: number): void;
+/** Ends the drag, dropping it where it is when `commit` is true. */
+export declare function endSplitDrag(commit: boolean): void;
+export declare function isSplitDragging(): boolean;
+export declare function setSplitDropHitTest(next: HitTest): () => void;
+export declare function setSplitDropHandler(next: DropHandler): () => void;
+export declare function useSplitDrag(): SplitDragState | null;
+/** Which zone of a rect a point falls in: an edge band, else the center. */
+export declare function dropTargetAt(rect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, x: number, y: number): DropTarget;
+/** The part of a rect a drop target covers, for drawing the highlight. */
+export declare function dropTargetRect(rect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, target: DropTarget): SplitDropHover["rect"];
+export {};