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

package/lib/types/engine/constraints.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Interaction limits and dock geometry. The model itself is unbounded; these
+ * are the V1 rules the interaction layer enforces before it dispatches, kept
+ * pure so they can be asserted without a browser.
+ */
+import type { DockZone, LayoutState, SplitAxis, SplitDirection } from '../contract/types.ts';
+/** V1 caps the docked grid at four panes; floating panes do not count. */
+export declare const MAX_DOCK_PANES = 4;
+/** Smallest fraction a divider drag may leave a pane, as a share of its split. */
+export declare const MIN_PANE_FRACTION = 0.12;
+/** Size a tab takes when it first floats, in CSS pixels. */
+export declare const FLOAT_DEFAULT_SIZE: {
+    readonly width: 380;
+    readonly height: 300;
+};
+/** Smallest size a floating panel may be resized to, in CSS pixels. */
+export declare const FLOAT_MIN_SIZE: {
+    readonly width: 220;
+    readonly height: 140;
+};
+/** Fraction of a pane's width or height that counts as its dock edge. */
+export declare const DOCK_EDGE_FRACTION = 0.25;
+/**
+ * Number of docked panes.
+ * @param state - current layout.
+ * @returns how many panes the docked tree holds; floating panes do not count.
+ */
+export declare function dockPaneCount(state: LayoutState): number;
+/**
+ * Whether another docked pane is allowed.
+ * @param state - current layout.
+ * @returns whether the docked tree is under `MAX_DOCK_PANES`.
+ */
+export declare function canSplit(state: LayoutState): boolean;
+/** The five dock regions a tab can be dropped on. */
+export declare const DOCK_ZONES: readonly DockZone[];
+/**
+ * Which dock region a pointer sits in.
+ * @param x - pointer x as a fraction of pane width.
+ * @param y - pointer y as a fraction of pane height.
+ * @param edge - edge band width as a fraction; defaults to `DOCK_EDGE_FRACTION`.
+ * @returns the closest edge when the pointer is inside its band, else `'center'`.
+ */
+export declare function zoneAt(x: number, y: number, edge?: number): DockZone;
+/**
+ * How a dock region splits the pane it targets.
+ * @param zone - the region the pointer released in.
+ * @returns the split's axis and direction, or `undefined` for `'center'`, which moves the tab into the pane instead.
+ */
+export declare function zoneSplit(zone: DockZone): {
+    axis: SplitAxis;
+    direction: SplitDirection;
+} | undefined;
+/**
+ * Clamp divider sizes so no pane falls under `MIN_PANE_FRACTION`.
+ * @param sizes - candidate fractions from the drag preview.
+ * @param minimum - smallest allowed share; defaults to the kit's pane fraction.
+ * @returns fractions summing to 1 with every entry at or above the minimum.
+ */
+export declare function clampSizes(sizes: readonly number[], minimum?: number): number[];
+//# sourceMappingURL=constraints.d.ts.map

package/lib/types/engine/controller.d.ts

@@ -0,0 +1,191 @@
+/**
+ * The intent layer's stateful embedding: one controller per docking surface,
+ * React-free, and itself the observable source the UI subscribes to
+ * (`subscribe` + `getSnapshot`, whose reference only changes when the layout
+ * does).
+ *
+ * Every method here is a planner call plus recording plus one notification. The
+ * decisions live in `planner.ts` so an embedder holding its layout in an external
+ * store shares them rather than reimplementing them; a planner that returns no
+ * operations records nothing and notifies nobody.
+ *
+ * The controller holds no host concepts: what a seeded tab contains arrives as a
+ * factory, and a tab's `kind` is an opaque string.
+ */
+import type { DockMode, DockZone, FloatRect, LayoutOp, LayoutState, PaneId, SplitId, TabId } from '../contract/types.ts';
+import { type TabFactory } from './initial.ts';
+import { type OpenContentInput } from './planner.ts';
+export type { OpenContentInput } from './planner.ts';
+/** Everything the rendering layer reads, in one immutable value. */
+export interface DockSnapshot {
+    readonly state: LayoutState;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    /** Whether the docked grid still has room for another pane. */
+    readonly canSplit: boolean;
+    /** Recorded operation count, redo branch included. */
+    readonly opCount: number;
+    /** How many recorded intents are applied. */
+    readonly cursor: number;
+}
+/** What the embedder seeds new panes with. */
+export interface DockControllerOptions {
+    /** Builds the tab the starting pane holds; omit to start empty. */
+    readonly makeInitialTab?: TabFactory;
+    /** Builds the tab a pane created by `splitPane` holds; omit to leave it empty. */
+    readonly makePaneTab?: TabFactory;
+    /** Starting presentation; defaults to `push`. */
+    readonly mode?: DockMode;
+}
+/** One docking surface: history, interaction limits, and change notification. */
+export declare class DockController {
+    private readonly minter;
+    private readonly sequencer;
+    private readonly listeners;
+    private readonly makePaneTab;
+    private snapshot;
+    /** @param options - the tab factories this surface seeds panes with. */
+    constructor(options?: DockControllerOptions);
+    /**
+     * Observe layout changes.
+     * @param listener - called after every committed change.
+     * @returns disposer removing the listener.
+     */
+    subscribe: (listener: () => void) => (() => void);
+    /** Current snapshot; the same reference until the layout changes. */
+    getSnapshot: () => DockSnapshot;
+    /** Recorded sequence, for tests and the operation readout. */
+    get ops(): readonly LayoutOp[];
+    private buildSnapshot;
+    private commit;
+    private get state();
+    private get mint();
+    /**
+     * Record a planned intent as one history entry.
+     * @param ops - the planner's operations; empty plans nothing.
+     * @returns whether anything was recorded.
+     */
+    private run;
+    /**
+     * Expand or collapse the docked area. Floating panels are unaffected.
+     * @param expanded - whether the docked area is shown.
+     */
+    setExpanded(expanded: boolean): void;
+    /** Flip the docked area between expanded and collapsed. */
+    toggleExpanded(): void;
+    /**
+     * Switch how the docked area is presented.
+     * @param mode - the presentation to record.
+     */
+    setMode(mode: DockMode): void;
+    /**
+     * Split a pane to its right and seat the embedder's pane tab in the new pane.
+     * @param paneId - pane to split; defaults to the active docked pane.
+     * @returns false when the docked grid is already at `MAX_DOCK_PANES`.
+     */
+    splitPane(paneId?: PaneId): boolean;
+    /**
+     * Seat the pane-tab factory's tab at the end of a pane's strip.
+     * @param paneId - the docked pane whose strip asked.
+     * @returns false when there is no factory or the pane is not docked.
+     */
+    addTab(paneId: PaneId): boolean;
+    /**
+     * Open content, or focus the tab already showing it.
+     * @param input - consistency id, copy, and optional target pane.
+     * @returns the tab now focused.
+     */
+    openContent(input: OpenContentInput): TabId;
+    /**
+     * Open a second, independent tab on the same content.
+     * @param tabId - tab to copy.
+     * @returns the new tab id.
+     */
+    duplicateTab(tabId: TabId): TabId;
+    /**
+     * Destroy a tab and its content state. A floating host panel goes with it.
+     * @param tabId - the tab to close.
+     */
+    closeTab(tabId: TabId): void;
+    /**
+     * Focus a tab, its pane, and raise that pane when it floats.
+     * @param tabId - the tab to focus.
+     */
+    focusTab(tabId: TabId): void;
+    /**
+     * Focus a pane, raising it when it floats.
+     * @param paneId - the pane to focus.
+     */
+    focusPane(paneId: PaneId): void;
+    /**
+     * Move a tab inside its own pane.
+     * @param tabId - the tab to move.
+     * @param index - its position in the strip without it.
+     */
+    reorderTab(tabId: TabId, index: number): void;
+    /**
+     * Put a tab at an explicit slot: a reorder inside its own pane, otherwise a
+     * move (or a return, when it currently floats).
+     * @param tabId - the tab being placed.
+     * @param toPaneId - destination docked pane.
+     * @param index - caret slot in the destination strip, counting the dragged chip when the strip is its own.
+     * @returns false when the placement changes nothing.
+     */
+    placeTab(tabId: TabId, toPaneId: PaneId, index: number): boolean;
+    /**
+     * Resolve a tab drop inside the docked area.
+     * @param tabId - the dragged tab.
+     * @param targetPaneId - pane under the pointer.
+     * @param zone - dock region the pointer released in.
+     * @returns false when the drop changes nothing or the grid is full.
+     */
+    dropTab(tabId: TabId, targetPaneId: PaneId, zone: DockZone): boolean;
+    /**
+     * Take a tab out into a floating panel.
+     * @param tabId - tab to float.
+     * @param rect - explicit rectangle; defaults to a cascade from the last panel.
+     * @returns the new floating pane id.
+     */
+    floatTab(tabId: TabId, rect?: FloatRect): PaneId;
+    /**
+     * Send a floating panel's tab back into the docked tree.
+     * @param paneId - the floating pane.
+     * @param toPaneId - destination docked pane; defaults to the active one.
+     */
+    unfloatPane(paneId: PaneId, toPaneId?: PaneId): void;
+    /**
+     * Record the net position of a floating-panel drag; the panel is focused and raised with it.
+     * @param paneId - the floating pane.
+     * @param x - its new left edge, in viewport pixels.
+     * @param y - its new top edge, in viewport pixels.
+     */
+    moveFloat(paneId: PaneId, x: number, y: number): void;
+    /**
+     * Record the net rectangle of a floating-panel resize; the panel is focused and raised with it.
+     * @param paneId - the floating pane.
+     * @param rect - its new rectangle.
+     */
+    resizeFloat(paneId: PaneId, rect: FloatRect): void;
+    /**
+     * Record the net sizes of a divider drag, clamped to the pane minimum.
+     * @param splitId - the split whose divider moved.
+     * @param sizes - the fractions the drag reached.
+     */
+    resizeSplit(splitId: SplitId, sizes: readonly number[]): void;
+    /**
+     * Step back one intent, or one run of consecutive focus-only intents.
+     * @returns false when there is nothing to undo.
+     */
+    undo(): boolean;
+    /**
+     * Step forward over what the matching undo stepped back.
+     * @returns false when there is nothing to redo.
+     */
+    redo(): boolean;
+    /**
+     * The pane a new tab lands in, for an embedder that needs to name it.
+     * @returns the active pane when docked, else the first docked pane.
+     */
+    activeDockPaneId(): PaneId;
+}
+//# sourceMappingURL=controller.d.ts.map

package/lib/types/engine/geometry.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Pure geometry for the drag interaction: point tests, dock-zone resolution
+ * against a real element rectangle, and tab-strip insertion slots. Kept free of
+ * React and DOM types so the drop rules can be asserted without a browser; the
+ * component layer measures rectangles and calls in.
+ */
+import type { DockZone, FloatRect, PaneId } from '../contract/types.ts';
+/** A measured rectangle in viewport coordinates. */
+export interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Where a drag would land if released now. */
+export type DropTarget = 
+/** Into a tab strip at an explicit slot: a reorder or a cross-pane move. */
+{
+    readonly kind: 'strip';
+    readonly paneId: PaneId;
+    readonly index: number;
+}
+/** Onto a pane body: the centre moves the tab in, an edge splits the pane. */
+ | {
+    readonly kind: 'zone';
+    readonly paneId: PaneId;
+    readonly zone: DockZone;
+};
+/**
+ * Whether a point is inside a rectangle, edges included.
+ * @param rect - the rectangle.
+ * @param x - point x in the same coordinates.
+ * @param y - point y in the same coordinates.
+ * @returns whether the point lies on or inside the rectangle.
+ */
+export declare function containsPoint(rect: Rect, x: number, y: number): boolean;
+/**
+ * Dock region a point falls in, relative to one pane's rectangle.
+ * @param rect - the pane's measured box.
+ * @param x - pointer x in the same coordinates.
+ * @param y - pointer y in the same coordinates.
+ * @param edge - edge band as a fraction; defaults to the model's value.
+ * @returns the region; `'center'` when the point is not in an edge band.
+ */
+export declare function zoneInRect(rect: Rect, x: number, y: number, edge?: number): DockZone;
+/**
+ * Slot a tab would take in a strip, by comparing the pointer with each tab's midpoint.
+ * @param tabRects - the strip's tab boxes in strip order.
+ * @param x - pointer x.
+ * @returns the insertion index, from 0 to `tabRects.length`.
+ */
+export declare function insertionIndex(tabRects: readonly Rect[], x: number): number;
+/** What one pane's strip measured, for the room rule. */
+export interface PaneMeasure {
+    /** The pane's box, borders included. */
+    readonly pane: Rect;
+    /** The strip's box, inside the borders; its height is what a vertical half must carry. */
+    readonly strip: Rect;
+    /** Width of the chip box, the strip's one shrinking part. */
+    readonly chipsWidth: number;
+    /** Width of the fill: free space, not a control. */
+    readonly fillWidth: number;
+    /**
+     * Footprint of the rendered split control (its width plus the strip's gap)
+     * for embedders that hide blocked split controls: a half too narrow to
+     * split hides its own control, so the rule leaves the footprint out of the
+     * fixed part. Leaving it out is also what keeps the reading stable — the
+     * control hiding sheds the same footprint from the strip, and a reading
+     * that counted it would flip with the control's visibility and re-render
+     * forever. Absent or 0 keeps the control in the fixed part, for embedders
+     * that render a blocked control disabled.
+     */
+    readonly splitControlWidth?: number;
+}
+/** Pixel minimums the room rule holds each half to. */
+export interface SplitMinimums {
+    /** The divider a split puts between the halves. */
+    readonly divider: number;
+    /** One chip at its minimum: the smallest strip that still names a tab. */
+    readonly chip: number;
+    /** The smallest body under a strip: one secondary text line inside 12px of the body's own insets. */
+    readonly body: number;
+}
+/**
+ * The minimums where no computed style can be read, mirroring
+ * `dockkit.module.css`: `.splitRow > .divider` takes no layout width (its
+ * hairline is painted over the seam); `.tab` is 80px of content plus
+ * 10px + 10px of padding (content-box), 100px; 12px above and below one 13px
+ * secondary line at 1.6 line-height — the inset a body draws for itself, as
+ * `.empty` does — is 45px, held to 48px.
+ */
+export declare const SPLIT_MINIMUMS: SplitMinimums;
+/** Whether a pane's two halves after an equal split would each still work. */
+export interface HalvesFit {
+    /** A row split: each half holds the strip's fixed controls and one minimum chip. */
+    readonly row: boolean;
+    /** A column split: each half holds the strip and a minimum body. */
+    readonly column: boolean;
+}
+/**
+ * The room rule. After an equal split each half must hold what cannot shrink:
+ * horizontally the strip's fixed part — its width minus the chip box, the
+ * fill, and `splitControlWidth`, which is the padding, the gaps, and every
+ * control a half would still draw — plus one chip at its minimum; vertically
+ * the strip plus a minimum body. The
+ * borders are what the pane's box exceeds the strip's by. An unmeasured pane
+ * (no layout, as under jsdom) fits: the rule only blocks on a positive reading.
+ * @param measure - the pane's rectangles.
+ * @param minimums - the pixel minimums; defaults to the stylesheet's.
+ * @returns whether a row and a column split each leave two working halves.
+ */
+export declare function halvesFit(measure: PaneMeasure, minimums?: SplitMinimums): HalvesFit;
+/** How far a pointer must travel before a press becomes a drag, in pixels. */
+export declare const DRAG_THRESHOLD = 4;
+/**
+ * Whether a press has travelled far enough to be a drag.
+ * @param startX - press x.
+ * @param startY - press y.
+ * @param x - current pointer x.
+ * @param y - current pointer y.
+ * @returns whether either axis moved at least `DRAG_THRESHOLD`.
+ */
+export declare function passedThreshold(startX: number, startY: number, x: number, y: number): boolean;
+/**
+ * Split fractions after a divider drag.
+ * @param sizes - the split's current fractions.
+ * @param index - divider position: the boundary between `index` and `index + 1`.
+ * @param delta - pointer travel along the split axis, as a fraction of the split's extent.
+ * @returns new fractions; the two neighbours absorb the whole change.
+ */
+export declare function dividerSizes(sizes: readonly number[], index: number, delta: number): number[];
+/** A width/height pair used as a floating-panel bound. */
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * A floating panel's rectangle after a drag.
+ * @param rect - the rectangle the gesture started from.
+ * @param dx - pointer travel on x.
+ * @param dy - pointer travel on y.
+ * @returns the moved rectangle; the size is unchanged.
+ */
+export declare function movedRect(rect: FloatRect, dx: number, dy: number): FloatRect;
+/**
+ * A floating panel's rectangle after a bottom-right resize.
+ * @param rect - the rectangle the gesture started from.
+ * @param dx - pointer travel on x.
+ * @param dy - pointer travel on y.
+ * @param min - smallest size the panel may take.
+ * @returns the resized rectangle; the origin is unchanged.
+ */
+export declare function resizedRect(rect: FloatRect, dx: number, dy: number, min: Size): FloatRect;
+/**
+ * Where a panel should appear when a tab is dropped outside the docked area.
+ * @param x - drop point x.
+ * @param y - drop point y.
+ * @param size - the panel's size.
+ * @returns a rectangle whose header sits under the drop point.
+ */
+export declare function floatRectAt(x: number, y: number, size: Size): FloatRect;
+//# sourceMappingURL=geometry.d.ts.map

package/lib/types/engine/initial.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Initial state and the identity mint every operation draws its new ids from.
+ * Ids are minted outside `applyOp` so a recorded sequence replays to the exact
+ * same tree.
+ *
+ * What the first tab *is* belongs to the embedder: pass a factory and this
+ * module only decides where it sits.
+ */
+import type { DockMode, LayoutState, TabId, TabRecord } from '../contract/types.ts';
+import type { Mint } from './planner.ts';
+/** Monotonic id source; one instance belongs to one surface's sequence. */
+export interface IdMinter {
+    /** Next id under `prefix`, unique for the life of this minter; the prefix names the id's kind. */
+    readonly next: Mint;
+}
+/**
+ * Create an id source.
+ * @param seed - number the first id counts from; defaults to 0.
+ * @returns a minter producing `<prefix><n>` ids.
+ */
+export declare function createIdMinter(seed?: number): IdMinter;
+/** Builds the tab record a newly seeded pane should hold. */
+export type TabFactory = (id: TabId) => TabRecord;
+/**
+ * The state a surface starts in: collapsed, one docked pane, and whatever tab
+ * `makeInitialTab` supplies.
+ *
+ * The first tab belongs to the initial state rather than to an operation, so
+ * expanding and collapsing never accumulates copies of it.
+ * @param minter - id source this surface's sequence will keep using.
+ * @param makeInitialTab - builds the starting tab; omit for an empty pane.
+ * @param mode - starting presentation; the embedder's product default.
+ * @returns the collapsed single-pane starting state.
+ */
+export declare function createInitialState(minter: IdMinter, makeInitialTab?: TabFactory, mode?: DockMode): LayoutState;
+//# sourceMappingURL=initial.d.ts.map

package/lib/types/engine/operations.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The operation engine: one pure `applyOp` that returns the next state plus the
+ * operations that undo it. No React, no DOM, no ambient state — replaying the
+ * same operations over the same initial state always yields the same result,
+ * because every id an operation creates travels inside the operation.
+ *
+ * Interaction limits (pane count, drag preview coalescing) are not enforced
+ * here; they belong to the interaction layer (`constraints.ts` and the UI).
+ */
+import type { ApplyResult, LayoutOp, LayoutState } from '../contract/types.ts';
+/**
+ * Apply one operation.
+ * @param state - state the operation reads; never mutated.
+ * @param op - the operation, carrying every id it creates.
+ * @returns the next state and the operations that undo it, applied in order.
+ * @throws when the operation addresses missing nodes or breaks a model rule.
+ */
+export declare function applyOp(state: LayoutState, op: LayoutOp): ApplyResult;
+/**
+ * Fold operations forward, discarding inverses.
+ * @param state - starting state.
+ * @param ops - operations in recorded order.
+ * @returns the state after every operation.
+ */
+export declare function replay(state: LayoutState, ops: readonly LayoutOp[]): LayoutState;
+//# sourceMappingURL=operations.d.ts.map

package/lib/types/engine/planner.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Intent planning: each interaction, as a pure function from the current state to
+ * the operations that carry it out.
+ *
+ * Planners mint the ids their operations create and enforce the interaction
+ * limits, but they hold no state and apply nothing. That split is what lets the
+ * same intent vocabulary serve two embeddings — a `DockController` that keeps the
+ * state itself, and a host store that keeps it and only needs the operations —
+ * without either one reimplementing `openContent`'s identity lookup, `dropTab`'s
+ * region resolution, or the floating cascade.
+ *
+ * A planner returning no operations means the intent changes nothing; the caller
+ * records nothing and notifies nobody.
+ */
+import type { DockMode, DockZone, FloatRect, LayoutOp, LayoutState, PaneId, SplitId, TabId } from '../contract/types.ts';
+import type { TabFactory } from './initial.ts';
+/** Mints ids for the operations a planner produces: the one place a string becomes an id. */
+export interface Mint {
+    (prefix: 'tab'): TabId;
+    (prefix: 'pane' | 'float'): PaneId;
+    (prefix: 'split'): SplitId;
+}
+/** Where a new tab should go and what it should say. */
+export interface OpenContentInput {
+    /** Consistency id: with `kind`, the identity opening twice focuses instead of adding to. */
+    readonly contentId: string;
+    readonly title: string;
+    readonly kind: string;
+    /** Target pane; defaults to the active docked pane. */
+    readonly paneId?: PaneId;
+    /** Strip slot in the target pane; defaults to its end. */
+    readonly index?: number;
+    /**
+     * Whether a tab already showing this (kind, contentId) is focused instead of
+     * a second one being opened. Defaults to `true`.
+     */
+    readonly revealIfOpened?: boolean;
+}
+/** An intent that both acts and names the tab it settled on. */
+export interface PlannedTab {
+    readonly ops: readonly LayoutOp[];
+    /** The tab the intent focused or created. */
+    readonly tabId: TabId;
+}
+/**
+ * First tab in one pane carrying `contentId`, in strip order.
+ * @param state - current layout.
+ * @param paneId - the pane to search, docked or floating.
+ * @param contentId - the content identity.
+ * @param kind - restrict to tabs of this kind; omit to match any kind.
+ * @returns the tab, or `undefined` when that pane shows no such content.
+ */
+export declare function findPaneContentTab(state: LayoutState, paneId: PaneId, contentId: string, kind?: string): TabId | undefined;
+/**
+ * First tab carrying `contentId`, searched docked panes first, in visual order.
+ * @param state - current layout.
+ * @param contentId - the content identity.
+ * @param kind - restrict to tabs of this kind; omit to match any kind.
+ * @returns the tab, or `undefined` when nothing shows the content.
+ */
+export declare function findContentTab(state: LayoutState, contentId: string, kind?: string): TabId | undefined;
+/**
+ * The pane a new tab lands in.
+ * @param state - current layout.
+ * @returns the active pane when docked, else the first docked pane.
+ */
+export declare function activeDockPaneId(state: LayoutState): PaneId;
+/**
+ * Expand or collapse the docked area.
+ * @param state - current layout.
+ * @param expanded - whether the docked area is shown.
+ * @returns the operation, or none when the value is already current.
+ */
+export declare function planSetExpanded(state: LayoutState, expanded: boolean): readonly LayoutOp[];
+/**
+ * Switch the presentation.
+ * @param state - current layout.
+ * @param mode - the presentation to record.
+ * @returns the operation, or none when the value is already current.
+ */
+export declare function planSetMode(state: LayoutState, mode: DockMode): readonly LayoutOp[];
+/**
+ * Split a pane to its right and seed the new pane.
+ * @param state - current layout.
+ * @param mint - id source for the pane, split, and seeded tab.
+ * @param paneId - pane to split; defaults to the active docked pane.
+ * @param makePaneTab - builds the seeded tab; omit to leave the new pane empty.
+ * @returns the operations, or none when the pane budget is spent.
+ */
+export declare function planSplitPane(state: LayoutState, mint: Mint, paneId?: PaneId, makePaneTab?: TabFactory): readonly LayoutOp[];
+/**
+ * Seat the embedder's seeded tab at the end of a docked pane's strip.
+ * @param state - current layout.
+ * @param mint - id source for the new tab.
+ * @param paneId - the pane whose strip asked; must be docked.
+ * @param makeTab - builds the seeded tab; omit to plan nothing.
+ * @returns the operations, or none when there is nothing to seat.
+ */
+export declare function planAddTab(state: LayoutState, mint: Mint, paneId: PaneId, makeTab?: TabFactory): readonly LayoutOp[];
+/**
+ * Open content, or focus the tab already showing it.
+ * @param state - current layout.
+ * @param mint - id source for a newly opened tab.
+ * @param input - identity, copy, and optional placement.
+ * @returns the operations plus the tab they settle on.
+ */
+export declare function planOpenContent(state: LayoutState, mint: Mint, input: OpenContentInput): PlannedTab;
+/**
+ * Open a second, independent tab on the same content, beside the original.
+ * @param state - current layout.
+ * @param mint - id source for the copy.
+ * @param tabId - tab to copy.
+ * @returns the operations plus the new tab's id.
+ */
+export declare function planDuplicateTab(state: LayoutState, mint: Mint, tabId: TabId): PlannedTab;
+/**
+ * Put a tab at an explicit strip slot: a reorder inside its own pane, otherwise a
+ * move, or a return when it currently floats.
+ * @param state - current layout.
+ * @param tabId - the tab being placed.
+ * @param toPaneId - destination docked pane.
+ * @param index - caret slot in the destination strip, counted over the chips as
+ *   drawn — the dragged chip included when the destination is its own pane, so
+ *   the slot just before or just after it is where it already sits.
+ * @returns the operations, or none when the placement changes nothing.
+ */
+export declare function planPlaceTab(state: LayoutState, tabId: TabId, toPaneId: PaneId, index: number): readonly LayoutOp[];
+/**
+ * Resolve a tab release on a pane body: the centre moves the tab in, an edge
+ * splits the pane and seats the tab in the new half. A pane's only tab released
+ * on that pane's centre changes nothing; released on its edge it splits, and
+ * the factory's tab backfills the pane the drag would otherwise empty — without
+ * a factory that release also changes nothing, since the split would empty the
+ * pane and seat the tab beside where it already was.
+ * @param state - current layout.
+ * @param mint - id source for a pane an edge release creates.
+ * @param tabId - the dragged tab.
+ * @param targetPaneId - pane under the pointer.
+ * @param zone - dock region the pointer released in.
+ * @param makeTab - builds the tab that backfills a pane its only tab splits away from.
+ * @returns the operations, or none when the release changes nothing.
+ */
+export declare function planDropTab(state: LayoutState, mint: Mint, tabId: TabId, targetPaneId: PaneId, zone: DockZone, makeTab?: TabFactory): readonly LayoutOp[];
+/**
+ * Take a tab out into a floating panel.
+ * @param state - current layout.
+ * @param mint - id source for the floating pane.
+ * @param tabId - tab to float.
+ * @param rect - explicit rectangle; defaults to a cascade from the last panel.
+ * @returns the operations plus the floating pane's id.
+ */
+export declare function planFloatTab(state: LayoutState, mint: Mint, tabId: TabId, rect?: FloatRect): {
+    readonly ops: readonly LayoutOp[];
+    readonly paneId: PaneId;
+};
+/**
+ * Send a floating panel's tab back into the docked tree.
+ * @param state - current layout.
+ * @param paneId - the floating pane.
+ * @param toPaneId - destination docked pane; defaults to the active one.
+ * @returns the operations.
+ */
+export declare function planUnfloatPane(state: LayoutState, paneId: PaneId, toPaneId?: PaneId): readonly LayoutOp[];
+/**
+ * Record the net sizes of a divider drag, clamped to the pane minimum.
+ * @param splitId - the split whose divider moved.
+ * @param sizes - the fractions the drag reached.
+ * @param minimum - smallest pane share; defaults to the kit's fraction.
+ * @returns the resize operation.
+ */
+export declare function planResizeSplit(splitId: SplitId, sizes: readonly number[], minimum?: number): readonly LayoutOp[];
+/**
+ * Keep the docked area populated after an intent: drop every docked pane the
+ * intent left empty, and when the surviving root pane is itself empty, seed it.
+ *
+ * A pane empties when its last tab is closed, moved out, or floated; each such
+ * pane is merged away, innermost first, until none remains. The root pane cannot
+ * be merged, so it is reseeded instead — with the factory's tab, or left empty
+ * when the embedder supplies none. The returned operations continue the intent
+ * they follow, so a caller records both as one entry.
+ * @param state - the layout after the intent's own operations.
+ * @param mint - id source for the reseeded tab.
+ * @param makeTab - builds the tab an emptied root pane is reseeded with.
+ * @returns the follow-up operations, or none when every docked pane holds a tab.
+ */
+export declare function planSettle(state: LayoutState, mint: Mint, makeTab?: TabFactory): readonly LayoutOp[];
+//# sourceMappingURL=planner.d.ts.map