@termix-ssh/plugin-sdk 1.0.10 → 1.0.12

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 {};

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

@@ -0,0 +1,28 @@
+import { type LayoutNode, type SplitState } from "./split-tree";
+/** Starting layouts offered in the layout picker. Any pane can be split further. */
+export type SplitPresetId = "columns-2" | "rows-2" | "columns-3" | "main-left-3" | "main-bottom-3" | "grid-4" | "grid-5" | "grid-6";
+export interface SplitPreset {
+    id: SplitPresetId;
+    titleKey: string;
+    panes: number;
+}
+export declare const SPLIT_PRESETS: SplitPreset[];
+type Sizes = {
+    outer?: number[];
+    inner?: number[][];
+};
+/**
+ * Builds a preset's tree, filling panes in reading order from `tabIds`.
+ * `sizes` lets the legacy mapping keep the user's divider positions.
+ */
+export declare function buildPreset(id: SplitPresetId, tabIds?: (string | null)[], sizes?: Sizes): LayoutNode;
+/**
+ * Re-lays an existing split out as a preset, keeping its tabs in reading
+ * order. Tabs past the preset's pane count drop out of the split.
+ */
+export declare function applyPreset(state: SplitState, id: SplitPresetId): SplitState;
+/** Split modes from before the layout tree, still found in storage and old workspaces. */
+export type LegacySplitMode = "2-way" | "2-way-horizontal" | "3-way" | "3-way-horizontal" | "4-way" | "5-way" | "6-way";
+/** Maps an old fixed-mode split onto the tree, keeping sizes where they fit. */
+export declare function fromLegacyConfig(mode: string, paneTabIds: (string | null)[], rowSizes?: unknown, rowColSizes?: unknown): LayoutNode | null;
+export {};

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

@@ -0,0 +1,95 @@
+import type { LayoutNode, SplitState, Tab } from "../../../types/ui-types";
+import { type SplitPresetId } from "./split-presets";
+/**
+ * Split tabs as they live in the shell's tab list. A split tab owns its
+ * layout tree; every tab shown in one of its panes carries parentSplitTabId
+ * so the tab bar hides it. These keep the two in step.
+ */
+export declare const SPLIT_TAB_TYPE = "split-screen";
+export type SplitTab = Tab & {
+    split: SplitState;
+};
+export declare function isSplitTab(tab: Tab | undefined | null): tab is SplitTab;
+/** Tabs a pane may hold: anything but the dashboard and other splits. */
+export declare function canJoinSplit(tab: Tab | undefined | null): boolean;
+export declare function splitTabOf(tabs: Tab[], tabId: string): SplitTab | undefined;
+/**
+ * Makes parentSplitTabId match the trees. Pane tab ids that no longer exist
+ * are emptied, and a tab claimed by two splits stays with the first.
+ */
+export declare function syncSplitChildren(tabs: Tab[]): Tab[];
+/**
+ * Applies `fn` to one split's state. Returning null closes the split and
+ * sends its tabs back to the tab bar.
+ */
+export declare function updateSplit(tabs: Tab[], splitTabId: string, fn: (state: SplitState) => SplitState | null): Tab[];
+export declare function makeSplitTab(instanceId: string, label: string, split: SplitState, openedAt?: number): SplitTab;
+/** Adds a split tab, taking its tabs out of any other split. */
+export declare function addSplitTab(tabs: Tab[], splitTab: SplitTab): Tab[];
+/** Removes a split tab. Its tabs go back to the tab bar. */
+export declare function closeSplitTab(tabs: Tab[], splitTabId: string): Tab[];
+/**
+ * Removes a closed tab. A pane that held it stays, empty and focused, so the
+ * next thing the user opens can go straight into it.
+ */
+export declare function removeTab(tabs: Tab[], tabId: string): Tab[];
+/** Puts a tab in a pane of a split and focuses that pane. */
+export declare function placeTabInPane(tabs: Tab[], splitTabId: string, paneId: string, tabId: string): Tab[];
+/** What the tab bar asks the shell to do with splits. */
+export type TabSplitAction = {
+    kind: "split";
+    tabId: string;
+    edge: "right" | "bottom";
+} | {
+    kind: "addToPane";
+    tabId: string;
+    splitTabId: string;
+    paneId: string;
+} | {
+    kind: "addPane";
+    tabId: string;
+    splitTabId: string;
+    edge: "right" | "bottom";
+} | {
+    kind: "unsplit";
+    splitTabId: string;
+} | {
+    kind: "splitActive";
+    edge: "right" | "bottom";
+} | {
+    kind: "preset";
+    presetId: SplitPresetId;
+};
+/** The lowest N not already used by a "Split N" style label. */
+export declare function nextSplitNumber(tabs: Tab[], labelFor: (n: number) => string): number;
+export interface SplitPaneSummary {
+    id: string;
+    /** 1-based, in reading order. */
+    index: number;
+    tabId: string | null;
+    /** The tab's label, or null for an empty pane. */
+    label: string | null;
+}
+export interface SplitSummary {
+    id: string;
+    label: string;
+    panes: SplitPaneSummary[];
+    full: boolean;
+}
+export declare function summarizeSplits(tabs: Tab[], maxPanes: number): SplitSummary[];
+/** Saved in localStorage; pane tab ids are tab instanceIds, which survive a reload. */
+export type PersistedSplitTab = {
+    version: 2;
+    instanceId: string;
+    label: string;
+    root: LayoutNode;
+    focusedPaneId: string;
+};
+export declare function serializeSplitTabs(tabs: Tab[]): PersistedSplitTab[];
+/**
+ * Rebuilds a saved split's tree with live tab ids. `resolve` maps whatever
+ * the save used (instanceIds, workspace slotIds) to a live tab id. Null when
+ * the entry is unreadable or none of its tabs came back.
+ */
+export declare function restoreSplitState(entry: unknown, resolve: (savedId: string) => string | null): SplitState | null;
+export declare function restoreSplitTabs(persisted: unknown[], tabs: Tab[], openedAt?: number): Tab[];

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

@@ -0,0 +1,30 @@
+import type { SplitSummary } from "./split-tabs";
+/**
+ * Lets menus outside the shell (the host list) offer "Open in split" without
+ * threading split state through every sidebar component. The shell publishes
+ * its splits here and registers how to aim the next opened tab at a pane.
+ */
+export type SplitOpenTarget = {
+    kind: "pane";
+    splitTabId: string;
+    paneId: string;
+} | {
+    kind: "newPane";
+    splitTabId: string;
+}
+/** A new split holding the active tab and the opened one. */
+ | {
+    kind: "newSplit";
+};
+export interface SplitTargetsSnapshot {
+    splits: SplitSummary[];
+    /** The active tab can start a new split. */
+    canStartSplit: boolean;
+}
+type Opener = (target: SplitOpenTarget, open: () => void) => void;
+export declare function publishSplitTargets(next: SplitTargetsSnapshot): void;
+export declare function setSplitOpener(next: Opener): () => void;
+/** Runs `open` so whatever tab it opens lands in `target`. */
+export declare function openInSplit(target: SplitOpenTarget, open: () => void): void;
+export declare function useSplitTargets(): SplitTargetsSnapshot;
+export {};