@x1a0f3n9/dsh-client-ui-dockkit 0.1.5-rc.3

package/lib/types/components/DockSurface.d.ts

@@ -0,0 +1,60 @@
+import type { ReactNode } from 'react';
+import type { DockIntents, DockLabels, TabMenuExtras, TabRenderer } from '../contract/adapter.ts';
+import type { LayoutState, PaneId, TabId } from '../contract/types.ts';
+import type { HalvesFit } from '../engine/geometry.ts';
+/** What the docked surface needs: the layout, its limits, and the outward contracts. */
+export interface DockSurfaceProps {
+    readonly state: LayoutState;
+    /**
+     * Whether another pane may still be created: the pane budget. Width is the
+     * kit's own concern — a pane too narrow for two working halves keeps its
+     * split control disabled with `labels.splitPaneNarrow` (see README).
+     */
+    readonly canSplit: boolean;
+    /** Hide a blocked split control — pane budget spent or pane too narrow — instead of rendering it disabled; defaults to false. */
+    readonly hideSplitWhenBlocked?: boolean;
+    /** Body drop geometry: all edge bands, or left/right halves with whole-pane moves once splitting is unavailable. */
+    readonly dropZones?: 'edges' | 'horizontal';
+    /** Smallest share a divider may leave a pane; defaults to the kit's fraction. */
+    readonly minPaneFraction?: number;
+    /**
+     * Whether a pane's strip draws the add control. Called per docked pane on
+     * every render; omit to draw one in every pane. `false` leaves the strip's
+     * end controls where they are and the chips as the only shrinking part.
+     */
+    readonly canAddTab?: (paneId: PaneId) => boolean;
+    /**
+     * Whether a tab draws its close control and its menu's close item. Called
+     * per rendered chip on every render; omit to keep every tab closable.
+     * `false` removes both routes without moving the chip: the close control
+     * paints over the title's end rather than beside it, so the chip is the same
+     * width either way. The menu still opens and carries the embedder's items.
+     */
+    readonly canCloseTab?: (tabId: TabId) => boolean;
+    readonly intents: DockIntents;
+    readonly labels: DockLabels;
+    readonly renderTab: TabRenderer;
+    /**
+     * What a tab's chip shows as its title; omit to show the record's `title`
+     * text. An embedder-internal seam: the Sidebar dispatches it to a per-kind
+     * slot, and nothing outside that embedder is expected to supply it.
+     */
+    readonly renderTabTitle?: TabRenderer;
+    /** Extra items for a tab's context menu; omit for the kit's own item only. */
+    readonly renderTabMenuItems?: TabMenuExtras;
+    /**
+     * Surface-wide controls, drawn at the far end of the top-right pane's tab
+     * strip so the surface needs no header of its own. The kit places them; what
+     * they do is the embedder's.
+     */
+    readonly chrome?: ReactNode;
+    /**
+     * Called with the room rule's latest readings whenever they change, so an
+     * embedder driving splits programmatically can honour the same rule the
+     * split control does. A pane absent from the map has not been measured.
+     */
+    readonly onRoom?: (fits: ReadonlyMap<PaneId, HalvesFit>) => void;
+}
+/** The split tree and the gestures over it. */
+export declare function DockSurface({ state, canSplit, canAddTab, canCloseTab, intents, labels, renderTab, renderTabTitle, renderTabMenuItems, chrome, onRoom, dropZones, minPaneFraction, hideSplitWhenBlocked, }: DockSurfaceProps): ReactNode;
+//# sourceMappingURL=DockSurface.d.ts.map

package/lib/types/components/FloatLayer.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+import type { DockIntents, DockLabels, TabRenderer } from '../contract/adapter.ts';
+import type { LayoutState, TabId } from '../contract/types.ts';
+/** The layout whose `floats` this layer draws. */
+export interface FloatLayerProps {
+    readonly state: LayoutState;
+    readonly intents: DockIntents;
+    readonly labels: DockLabels;
+    readonly renderTab: TabRenderer;
+    /** Whether a floating tab offers its close control; defaults to true. Called per tab on every render. */
+    readonly canCloseTab?: (tabId: TabId) => boolean;
+    /** The panel header's title content; omit to show the record's `title` text (see `DockSurfaceProps`). */
+    readonly renderTabTitle?: TabRenderer;
+}
+/** Every floating panel, in z order. */
+export declare function FloatLayer({ state, intents, labels, renderTab, renderTabTitle, canCloseTab }: FloatLayerProps): ReactNode;
+//# sourceMappingURL=FloatLayer.d.ts.map

package/lib/types/components/PaneTree.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { LayoutState, NodeId, SplitId } from '../contract/types.ts';
+import type { PaneCallbacks } from './render.ts';
+/** Fractions a live divider drag is previewing for one split. */
+export interface SizePreview {
+    readonly splitId: SplitId;
+    readonly sizes: readonly number[];
+}
+/** One subtree of the docked layout. */
+export interface PaneTreeProps {
+    readonly state: LayoutState;
+    readonly nodeId: NodeId;
+    readonly callbacks: PaneCallbacks;
+    readonly preview: SizePreview | undefined;
+}
+/** Render a split or pane node and everything under it. */
+export declare function PaneTree({ state, nodeId, callbacks, preview }: PaneTreeProps): ReactNode;
+//# sourceMappingURL=PaneTree.d.ts.map

package/lib/types/components/TabMenu.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+import type { DockLabels } from '../contract/adapter.ts';
+/** What the menu offers, where it anchors, and how it closes. */
+export interface TabMenuProps {
+    readonly labels: DockLabels;
+    /** The control that opened the menu; the menu hangs below its left edge. */
+    readonly anchor: HTMLElement;
+    /** Close the tab; `undefined` removes the kit's item, leaving the extras only. */
+    readonly onClose: (() => void) | undefined;
+    /** Dismiss without acting. */
+    readonly onDismiss: () => void;
+    /** Embedder items, rendered after the kit's own; absent means none. */
+    readonly extras: ReactNode;
+}
+/** The actions menu body, anchored to the control that opened it. */
+export declare function TabMenu({ labels, anchor, onClose, onDismiss, extras }: TabMenuProps): ReactNode;
+//# sourceMappingURL=TabMenu.d.ts.map

package/lib/types/components/TabPanel.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { LayoutState, PaneNode } from '../contract/types.ts';
+import type { PaneCallbacks } from './render.ts';
+/** A pane and the live layout it reads its tabs from. */
+export interface TabPanelProps {
+    readonly state: LayoutState;
+    readonly pane: PaneNode;
+    readonly callbacks: PaneCallbacks;
+}
+/** The pane's tab strip, split control, and body. */
+export declare function TabPanel({ state, pane, callbacks }: TabPanelProps): ReactNode;
+//# sourceMappingURL=TabPanel.d.ts.map

package/lib/types/components/TabTitle.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+/** The title span of a strip chip or a floating panel's header chip. */
+export declare function TabTitle({ children }: {
+    readonly children: ReactNode;
+}): ReactNode;
+//# sourceMappingURL=TabTitle.d.ts.map

package/lib/types/components/measure.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DOM side of the room rule: read each docked pane's rectangles after a commit
+ * and ask `halvesFit` whether a split would leave two working halves. Pixels
+ * live here and in `geometry.ts`; the engine's planners never see them.
+ */
+import type { PaneId } from '../contract/types.ts';
+import type { HalvesFit } from '../engine/geometry.ts';
+/**
+ * Every docked pane element under `root`, in document order, with the pane id
+ * each carries.
+ * @param root - the docked surface's element.
+ * @returns pane ids paired with their elements.
+ */
+export declare function paneElements(root: HTMLElement): readonly (readonly [PaneId, HTMLElement])[];
+/**
+ * Measure every docked pane under `root`.
+ * @param root - the docked surface's element.
+ * @param splitHiddenWhenBlocked - whether the embedder hides blocked split
+ * controls (`hideSplitWhenBlocked`); the room rule then leaves the control's
+ * footprint out of each strip's fixed part, so the reading cannot flip with
+ * the control's visibility (see `PaneMeasure.splitControlWidth`).
+ * @returns each pane's fit, keyed by pane id.
+ */
+export declare function measurePaneFits(root: HTMLElement, splitHiddenWhenBlocked?: boolean): ReadonlyMap<PaneId, HalvesFit>;
+/**
+ * One pane's latest reading. A pane the map does not name has not been
+ * measured and fits: the rule only blocks on a positive reading.
+ * @param fits - the latest measurement.
+ * @param paneId - the pane asked about.
+ * @returns whether each split axis leaves two working halves.
+ */
+export declare function fitOf(fits: ReadonlyMap<PaneId, HalvesFit>, paneId: PaneId): HalvesFit;
+/**
+ * Whether two measurements agree, so a re-measure that changed nothing re-renders nothing.
+ * @param a - one measurement.
+ * @param b - the other.
+ * @returns whether both name the same panes with the same readings.
+ */
+export declare function sameFits(a: ReadonlyMap<PaneId, HalvesFit>, b: ReadonlyMap<PaneId, HalvesFit>): boolean;
+//# sourceMappingURL=measure.d.ts.map

package/lib/types/components/pointer.d.ts

@@ -0,0 +1,47 @@
+/** The three window listeners one gesture installs. */
+export interface PointerFollowers {
+    readonly move: (event: PointerEvent) => void;
+    readonly up: (event: PointerEvent) => void;
+    readonly cancel: () => void;
+}
+/**
+ * Take ownership of the pointer for the rest of the gesture.
+ * @param element - the element the gesture started on.
+ * @param pointerId - the pointer to capture.
+ */
+export declare function capturePointer(element: HTMLElement, pointerId: number): void;
+/**
+ * Capture the pointer, then follow it on the window until release or cancel.
+ * Only that pointer's events count: a second finger or a pen beside the mouse
+ * neither moves nor ends the gesture. The listeners remove themselves before
+ * `up` or `cancel` runs; the returned callback ends the gesture early, for an
+ * unmount or a superseding press.
+ * @param element - the element the gesture started on.
+ * @param pointerId - the pointer to capture and follow.
+ * @param followers - listeners for move, release, and cancel.
+ * @returns detach callback removing the three listeners.
+ */
+export declare function followPointer(element: HTMLElement, pointerId: number, followers: PointerFollowers): () => void;
+/** What one gesture does while it lasts and when it settles. */
+export interface GestureFollowers {
+    readonly move: (event: PointerEvent) => void;
+    /** The release. The gesture has already ended, and its preview reset, when this runs. */
+    readonly up: (event: PointerEvent) => void;
+}
+/**
+ * Start a gesture from the element a press landed on.
+ * @param element - the pressed element; the pointer is captured on it.
+ * @param pointerId - the pressing pointer.
+ * @param followers - what the gesture does.
+ */
+export type BeginGesture = (element: HTMLElement, pointerId: number, followers: GestureFollowers) => void;
+/**
+ * One pointer gesture at a time for a component. A gesture ends on release, on
+ * cancel, or when a new press supersedes it; `reset` runs at each of those ends
+ * so the component clears its preview. Unmounting mid-gesture removes the
+ * listeners without resetting anything.
+ * @param reset - clears the component's gesture preview.
+ * @returns the gesture starter, called from a pointer-down handler.
+ */
+export declare function useGesture(reset: () => void): BeginGesture;
+//# sourceMappingURL=pointer.d.ts.map

package/lib/types/components/render.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Prop shares the kit's own components pass among themselves. These are internal
+ * to the package — the outward contracts are in `adapter.ts`.
+ */
+import type { PointerEvent as ReactPointerEvent, ReactNode } from 'react';
+import type { DockLabels, TabMenuExtras, TabRenderer } from '../contract/adapter.ts';
+import type { PaneId, SplitId, TabId } from '../contract/types.ts';
+import type { DropTarget } from '../engine/geometry.ts';
+/** Why a pane's split control is disabled: the pane budget, or too little width for two halves. */
+export type SplitBlock = 'budget' | 'width';
+/** What a pane subtree needs: settled callbacks, gesture starters, and live preview. */
+export interface PaneCallbacks {
+    readonly onFocusTab: (tabId: TabId) => void;
+    readonly onFocusPane: (paneId: PaneId) => void;
+    readonly onSplitPane: (paneId: PaneId) => void;
+    readonly onAddTab: (paneId: PaneId) => void;
+    readonly onCloseTab: (tabId: TabId) => void;
+    /** Begin dragging a tab; the surface owns the gesture from here. */
+    readonly onTabPressed: (tabId: TabId, event: ReactPointerEvent<HTMLElement>) => void;
+    /** Begin dragging a divider inside `splitId`, at the boundary after `index`. */
+    readonly onDividerPressed: (splitId: SplitId, index: number, event: ReactPointerEvent<HTMLElement>) => void;
+    /** Why a pane cannot split right now, or `undefined` while it can. */
+    readonly splitBlock: (paneId: PaneId) => SplitBlock | undefined;
+    /** Hide blocked split controls instead of rendering them disabled. */
+    readonly hideSplitWhenBlocked?: boolean;
+    /** Whether a pane's strip draws the add control. */
+    readonly canAddTab: (paneId: PaneId) => boolean;
+    /** Whether a tab draws its close control and its menu's close item. */
+    readonly canCloseTab: (tabId: TabId) => boolean;
+    /** Live drop preview, or `undefined` while nothing is being dragged. */
+    readonly dropTarget: DropTarget | undefined;
+    /** Show both horizontal landing regions while a body split is being targeted. */
+    readonly horizontalDrops?: boolean;
+    /** Tab currently being dragged, so its chip can render as lifted. */
+    readonly draggingTabId: TabId | undefined;
+    readonly labels: DockLabels;
+    readonly renderTab: TabRenderer;
+    /** A chip's or panel header's title content; absent means the record's `title` text. */
+    readonly renderTabTitle: TabRenderer | undefined;
+    /** Embedder items appended to a tab's context menu; absent means the kit's item only. */
+    readonly renderTabMenuItems: TabMenuExtras | undefined;
+    /** The pane whose strip hosts the embedder's surface-wide controls. */
+    readonly chromePaneId: PaneId;
+    /** Those controls; absent means the strip ends at the kit's own split control. */
+    readonly chrome: ReactNode;
+}
+//# sourceMappingURL=render.d.ts.map

package/lib/types/contract/adapter.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The kit's outward contracts: state in, intents out.
+ *
+ * Everything host-specific arrives through these — every rendered string, every
+ * tab body, and every net gesture result. The kit itself holds no copy, no icon
+ * set, and no knowledge of what a tab's `kind` means.
+ */
+import type { ReactNode } from 'react';
+import type { DockZone, FloatRect, PaneId, SplitId, TabId, TabRecord } from './types.ts';
+/**
+ * Every string the kit renders, already localized by the embedder.
+ *
+ * Accessible names are included: a control with no visible text still needs
+ * one, and the kit must not invent it.
+ */
+export interface DockLabels {
+    /** Body of a pane holding no tabs. */
+    readonly emptyPane: string;
+    /** The split control, while splitting is allowed. */
+    readonly splitPane: string;
+    /** The split control, once the pane budget is spent. */
+    readonly splitPaneDisabled: string;
+    /** The split control, while the pane is too narrow for two working halves. */
+    readonly splitPaneNarrow: string;
+    /** Destroy a tab: the chip's close control and the menu's close item. */
+    readonly closeTab: string;
+    /** The strip's add control, which seats the embedder's seeded tab. */
+    readonly addTab: string;
+    /** Send a floating panel back into the docked tree. */
+    readonly dockFloat: string;
+    /** Close a floating panel. */
+    readonly closeFloat: string;
+    /** The drop hint's caption for each body zone a dragged tab can land on. */
+    readonly dropZone: Readonly<Record<DockZone, string>>;
+}
+/**
+ * Renders one tab's body. The embedder dispatches on `tab.kind`, which is the
+ * only place that string carries meaning.
+ */
+export type TabRenderer = (tab: TabRecord) => ReactNode;
+/**
+ * Renders extra items at the end of one tab's context menu (opened by a
+ * secondary press on the chip).
+ *
+ * The kit's own item is the close gesture; anything that means something about
+ * the tab's content comes from here. An item that acts MUST call `dismiss`,
+ * because the menu closes on its own items only. Every rendered item MUST
+ * carry `role="menuitem"`: the kit probes for that role to dismiss a menu
+ * that would paint empty, so items without it count as an empty menu.
+ * @param tab - the tab whose menu is open.
+ * @param dismiss - close the menu without acting.
+ * @returns extra actions with ARIA menuitem, menuitemcheckbox, or menuitemradio roles, or nothing.
+ */
+export type TabMenuExtras = (tab: TabRecord, dismiss: () => void) => ReactNode;
+/**
+ * Net gesture results the kit reports. Each call is one settled intent — never a
+ * drag frame — so an embedder recording them produces one operation per gesture.
+ *
+ * `DockController` satisfies this contract as-is; an embedder that routes
+ * through its own store implements the same names.
+ */
+export interface DockIntents {
+    /** Focus a tab and its pane. */
+    readonly focusTab: (tabId: TabId) => void;
+    /** Focus a pane, raising it when it floats. */
+    readonly focusPane: (paneId: PaneId) => void;
+    /** Split a pane and seed the new one. */
+    readonly splitPane: (paneId: PaneId) => void;
+    /** Add the embedder's seeded tab to a pane (the strip's `+`). */
+    readonly addTab: (paneId: PaneId) => void;
+    /** Destroy a tab. */
+    readonly closeTab: (tabId: TabId) => void;
+    /** Copy a tab beside itself. No kit control drives this; embedders reach it through their own API. */
+    readonly duplicateTab: (tabId: TabId) => void;
+    /** Float a tab, at `rect` when the release point decided one (a drag released clear of the surface). */
+    readonly floatTab: (tabId: TabId, rect?: FloatRect) => void;
+    /** Return a floating panel's tab to the docked tree. */
+    readonly unfloatPane: (paneId: PaneId) => void;
+    /**
+     * Put a tab at an explicit strip slot: a reorder, a move, or a return. `index`
+     * is the caret slot counted over the destination strip's chips as drawn, the
+     * dragged chip included when the strip is its own.
+     */
+    readonly placeTab: (tabId: TabId, toPaneId: PaneId, index: number) => void;
+    /** Resolve a release on a pane body: the centre moves in, an edge splits. */
+    readonly dropTab: (tabId: TabId, paneId: PaneId, zone: DockZone) => void;
+    /** Net position of a floating-panel drag; the operation it records focuses and raises the panel too. */
+    readonly moveFloat: (paneId: PaneId, x: number, y: number) => void;
+    /** Net rectangle of a floating-panel resize; the operation it records focuses and raises the panel too. */
+    readonly resizeFloat: (paneId: PaneId, rect: FloatRect) => void;
+    /** Net fractions of a divider drag. */
+    readonly resizeSplit: (splitId: SplitId, sizes: readonly number[]) => void;
+}
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1,255 @@
+/**
+ * Layout model and operation vocabulary. Types only: no runtime code, no React,
+ * no DOM, and no host concepts — a tab's `kind` is an opaque string this kit
+ * never interprets, so the embedder owns what content families exist.
+ *
+ * The model is a normalized recursive split tree. `nodes` holds every split and
+ * pane keyed by id; `rootId` names the docked root; `floats` lists floating
+ * panes bottom-to-top. A floating panel is not a second concept — it is a pane
+ * whose `host` is `'float'`, capacity 1 tab, drawn without a tab strip.
+ *
+ * Ids are branded: a pane, a split, and a tab id never stand in for one another
+ * or for a bare string, and only a mint (or a DOM round trip of an id the kit
+ * wrote itself) produces one.
+ */
+import type { Branded } from '@x1a0f3n9/dsh-brand';
+/** Identity of a pane node in `LayoutState.nodes`. */
+export type PaneId = Branded<'PaneId'>;
+/** Identity of a split node in `LayoutState.nodes`. */
+export type SplitId = Branded<'SplitId'>;
+/** Identity of any node in `LayoutState.nodes`. */
+export type NodeId = PaneId | SplitId;
+/** Identity of one open tab; distinct copies of one content share `contentId`, never `TabId`. */
+export type TabId = Branded<'TabId'>;
+/** Direction a split lays its children out in. */
+export type SplitAxis = 'row' | 'column';
+/** Which side of the reference pane a new pane takes. */
+export type SplitDirection = 'before' | 'after';
+/** The five drop regions a pane offers a dragged tab. */
+export type DockZone = 'center' | 'top' | 'right' | 'bottom' | 'left';
+/**
+ * How the docked area is presented.
+ *
+ * `push` takes room from its neighbours; `fullscreen` covers the viewport. The kit
+ * records the choice but does not implement either — the embedder reads this and
+ * positions the surface. It lives here, beside `expanded`, because switching is a
+ * recorded operation the user can step back through. The values are the kit's
+ * own words and no service interface repeats them.
+ */
+export type DockMode = 'push' | 'fullscreen';
+/** Viewport rectangle of a floating pane, in CSS pixels. */
+export interface FloatRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Interior node: an ordered run of children along one axis with fractional sizes. */
+export interface SplitNode {
+    readonly kind: 'split';
+    readonly id: SplitId;
+    readonly axis: SplitAxis;
+    /** At least two children; a one-child split collapses into that child. */
+    readonly children: readonly NodeId[];
+    /** Same length as `children`, each above zero, summing to 1. */
+    readonly sizes: readonly number[];
+}
+/** Where a pane is drawn: inside the docked split tree, or as a viewport overlay. */
+export type PaneHost = 'dock' | 'float';
+/** Leaf node: an ordered tab list with at most one active tab. */
+export interface PaneNode {
+    readonly kind: 'pane';
+    readonly id: PaneId;
+    readonly host: PaneHost;
+    readonly tabs: readonly TabId[];
+    /** `undefined` exactly when `tabs` is empty. */
+    readonly activeTabId: TabId | undefined;
+    /** Set exactly when `host` is `'float'`. */
+    readonly rect: FloatRect | undefined;
+}
+/** Either kind of tree node. */
+export type LayoutNode = SplitNode | PaneNode;
+/**
+ * One open tab.
+ *
+ * `kind` selects the embedder's content family and is never interpreted here.
+ * `contentId` is the identity `openContent` de-duplicates against, so two tabs
+ * sharing it are deliberate copies of one thing.
+ */
+export interface TabRecord {
+    readonly id: TabId;
+    readonly kind: string;
+    readonly contentId: string;
+    readonly title: string;
+}
+/**
+ * The whole layout of one docking surface. Every field is replaced rather than
+ * mutated, and untouched sub-objects keep their identity so consumers can
+ * compare by reference.
+ */
+export interface LayoutState {
+    readonly nodes: Readonly<Record<NodeId, LayoutNode>>;
+    readonly tabs: Readonly<Record<TabId, TabRecord>>;
+    /** Root of the docked tree; always a split or pane that exists in `nodes`. */
+    readonly rootId: NodeId;
+    /** Floating panes, bottom-to-top; the last entry is on top. */
+    readonly floats: readonly PaneId[];
+    /** Focused pane, docked or floating. */
+    readonly activePaneId: PaneId;
+    /** Whether the docked area is expanded; floating panes ignore it. */
+    readonly expanded: boolean;
+    /** How the docked area is presented; floating panes ignore it. */
+    readonly mode: DockMode;
+}
+/** Recipe for putting a pane back where it was, used by `insertPane`. */
+export type PaneAttachment = 
+/** Re-insert as a child of an existing split, restoring that split's sizes verbatim. */
+{
+    readonly mode: 'child';
+    readonly parentId: SplitId;
+    readonly index: number;
+    readonly sizes: readonly number[];
+}
+/** Re-create a collapsed split in `targetId`'s slot; `split` already lists both children. */
+ | {
+    readonly mode: 'wrap';
+    readonly targetId: NodeId;
+    readonly split: SplitNode;
+}
+/** Re-insert a floating pane at its former z index. */
+ | {
+    readonly mode: 'float';
+    readonly index: number;
+};
+/**
+ * One recorded layout mutation. Ids that an operation creates are carried in
+ * the operation itself, so replaying a sequence from the same initial state
+ * reproduces the same ids without any minting during apply.
+ *
+ * `insertPane`, `insertTab`, and `restoreFocus` exist to express inverses
+ * exactly; they are applied like any other operation.
+ */
+export type LayoutOp = 
+/** Give `paneId` a new empty sibling pane along `axis`. */
+{
+    readonly type: 'split';
+    readonly paneId: PaneId;
+    readonly axis: SplitAxis;
+    readonly direction: SplitDirection;
+    readonly newPaneId: PaneId;
+    /** Used only when the reference pane's parent cannot host `axis` directly. */
+    readonly newSplitId: SplitId;
+}
+/** Drop an empty docked pane and collapse the split it leaves behind. */
+ | {
+    readonly type: 'merge';
+    readonly paneId: PaneId;
+}
+/** Add a new tab to a docked pane and focus it. */
+ | {
+    readonly type: 'openTab';
+    readonly paneId: PaneId;
+    readonly tab: TabRecord;
+    readonly index: number;
+}
+/** Destroy a tab and its content state; a floating host pane goes with it. */
+ | {
+    readonly type: 'closeTab';
+    readonly tabId: TabId;
+}
+/** Move a tab to a different docked pane. */
+ | {
+    readonly type: 'moveTab';
+    readonly tabId: TabId;
+    readonly toPaneId: PaneId;
+    readonly index: number;
+}
+/** Move a tab within its own pane. */
+ | {
+    readonly type: 'reorderTab';
+    readonly tabId: TabId;
+    readonly index: number;
+}
+/** Focus a tab, its owning pane, and raise that pane when floating. */
+ | {
+    readonly type: 'focusTab';
+    readonly tabId: TabId;
+}
+/** Focus a pane and raise it when floating. */
+ | {
+    readonly type: 'focusPane';
+    readonly paneId: PaneId;
+}
+/** Net result of a divider drag. */
+ | {
+    readonly type: 'resize';
+    readonly splitId: SplitId;
+    readonly sizes: readonly number[];
+}
+/** Take a tab out of the docked tree into a new floating pane. */
+ | {
+    readonly type: 'float';
+    readonly tabId: TabId;
+    readonly newPaneId: PaneId;
+    readonly rect: FloatRect;
+}
+/** Return a floating pane's only tab to a docked pane and destroy the floating pane. */
+ | {
+    readonly type: 'unfloat';
+    readonly paneId: PaneId;
+    readonly toPaneId: PaneId;
+    readonly index: number;
+}
+/** Net result of dragging a floating pane; the pane is focused and raised with it. */
+ | {
+    readonly type: 'moveFloat';
+    readonly paneId: PaneId;
+    readonly x: number;
+    readonly y: number;
+}
+/** Net result of resizing a floating pane; the pane is focused and raised with it. */
+ | {
+    readonly type: 'resizeFloat';
+    readonly paneId: PaneId;
+    readonly rect: FloatRect;
+}
+/** Expand or collapse the docked area. */
+ | {
+    readonly type: 'setExpanded';
+    readonly expanded: boolean;
+}
+/** Switch how the docked area is presented. */
+ | {
+    readonly type: 'setMode';
+    readonly mode: DockMode;
+}
+/** Put a pane back, with the tab records it owned. */
+ | {
+    readonly type: 'insertPane';
+    readonly pane: PaneNode;
+    readonly tabs: readonly TabRecord[];
+    readonly attach: PaneAttachment;
+}
+/** Put one tab record back into a docked pane. */
+ | {
+    readonly type: 'insertTab';
+    readonly paneId: PaneId;
+    readonly tab: TabRecord;
+    readonly index: number;
+}
+/** Restore focus facts an operation displaced. */
+ | {
+    readonly type: 'restoreFocus';
+    readonly activePaneId: PaneId;
+    readonly floats: readonly PaneId[];
+    /** Active tab per pane, for the panes the inverted operation touched. */
+    readonly paneActiveTabs: Readonly<Record<PaneId, TabId | undefined>>;
+};
+/** Operation kinds that only move focus; `Sequencer` collapses runs of these into one undo step. */
+export type FocusOpType = 'focusTab' | 'focusPane' | 'restoreFocus';
+/** Result of applying one operation: the next state plus the operations that undo it, in order. */
+export interface ApplyResult {
+    readonly state: LayoutState;
+    readonly inverse: readonly LayoutOp[];
+}
+//# sourceMappingURL=types.d.ts.map