@n-uf/hypr-tiling 26.7.0

package/dist/engine.d.mts

@@ -0,0 +1,314 @@
+export { G as GroupLeavesOptions, M as MULTI_SELECT_GROUP_MIN_MEMBERS, T as TILING_KEYMAP_DEFAULTS, a as TilingKeymapActionGuards, c as canGroupMultiSelection, b as chordRequiresModifier, d as collectGroups, e as collectSplitNodes, f as commandRequiredCapability, g as findLeafByDirection, h as findLeafById, i as groupLeaves, j as hasAnyModifier, k as insertLeafAdjacent, l as isCssEasing, m as isResizeAxisEnabled, n as isStructurallyValidLayout, o as keyboardActionToCommand, p as matchKeyChord, q as matchKeymapAction, r as moveLeafToRoot, s as moveLeafToSplitContainer, t as pruneMultiSelection, u as readLeafNodeIds, v as removeLeafTile, w as resolveDragEasing, x as resolveKeymap, y as resolveMaximizeToggle, z as resolveMultiSelectGroupCommand, A as resolveMultiSelectGroupHost, B as setLeafSizing, C as siblingSubtreeForLeaf, D as swapLeafTiles, E as tileOrderByLeafId, F as toggleLeafMultiSelection, H as toggleSplitAxis, I as ungroupNode, J as updateSplitRatio } from './drag-easing-KxPPNNZT.mjs';
+import { r as TilingLeafDropZone, s as TilingDropAction, t as TilingSplitAxis, j as TilingDropIntentTuningState, u as ResolvedTilingKeymap, v as TilingKeyBinding, w as TilingKeyboardEventLike, x as TilingCommand, T as TilingLayoutNode, y as TilingDimension, z as TilingPaneSizing, A as TilingPaneSizingMode } from './tiling-renderer-kTlSm4H4.mjs';
+export { B as BASELINE_DRAG_HOP_DURATION_MS, I as INSTANT_DRAG_DURATION_MS, C as TilingAccentHue, D as TilingKeyboardAction, E as TilingKeyboardModifierState, F as TilingMoveModeState, G as TilingPaneSwitcherState, H as accentHue } from './tiling-renderer-kTlSm4H4.mjs';
+import 'react';
+
+/** A pane's four directional insert edges (the drop zones excluding `"center"`). */
+type TilingEdgeZone = Exclude<TilingLeafDropZone, "center">;
+/** Base drop hit-zone geometry: center swap fraction, floor, and hysteresis. */
+interface TilingDropIntentBaseConfig {
+    /**
+     * Fraction of each pane axis spanned by the center (swap) rectangle. Acts as
+     * the SYMMETRIC value: it sizes both axes unless a per-axis override
+     * (`centerRatioX` / `centerRatioY`) is supplied for that axis.
+     */
+    centerRatio: number;
+    /** Per-axis HORIZONTAL (width) swap-zone fraction; falls back to `centerRatio`. */
+    centerRatioX?: number;
+    /** Per-axis VERTICAL (height) swap-zone fraction; falls back to `centerRatio`. */
+    centerRatioY?: number;
+    /** Floor for the center rectangle extent so tiny panes keep a usable swap zone. */
+    centerMinPx: number;
+    /** Boundary stickiness (pane-local px) used to suppress sub-pixel flicker. */
+    hysteresisPx: number;
+}
+/**
+ * The resolver's full drop-intent result for one pane hover: the resolved zone
+ * and action plus the geometry/diagnostic fields that explain how it was
+ * reached. Emitted (as {@link TilingDropIntentDebugState}) to `onDropIntentChange`.
+ */
+interface TilingDropIntentState {
+    /** The hovered leaf this resolution targets. */
+    leafId: string;
+    /** The resolved drop zone under the cursor. */
+    zone: TilingLeafDropZone;
+    /** The resolved drop action. */
+    action: TilingDropAction;
+    /** The nearest edge the cursor points toward (pre-fallback). */
+    dominantEdge: TilingEdgeZone;
+    /** The edge finally selected after fallbacks, or `null`. */
+    finalEdge: TilingEdgeZone | null;
+    /** Why the dominant edge was replaced by a fallback, or `null`. */
+    fallbackReason: string | null;
+    /** Why the action was blocked, or `null` when unblocked. */
+    blockedReason: string | null;
+    /** Split axes from the root to the target (containment path). */
+    axisPath: ReadonlyArray<TilingSplitAxis>;
+    /** Edge threshold fraction in effect. */
+    edgeThresholdRatio: number;
+    /** Center rectangle width (CSS px). */
+    centerRectWidthPx: number;
+    /** Center rectangle height (CSS px). */
+    centerRectHeightPx: number;
+    /** Cursor distance to the center rectangle (CSS px). */
+    centerDistancePx: number;
+    /** Cursor distance to the nearest edge (CSS px). */
+    nearestEdgeDistancePx: number;
+    /** Pane-local cursor X (CSS px). */
+    paneLocalX: number;
+    /** Pane-local cursor Y (CSS px). */
+    paneLocalY: number;
+    /** The ancestor split chosen for a split-container insert, or `null`. */
+    targetSplitId: string | null;
+    /** Which child slot of that split the insert targets, or `null`. */
+    targetSplitPlacement: "first" | "second" | null;
+    /** The edge zone selected on the chosen split, or `null`. */
+    selectedSplitZone: TilingEdgeZone | null;
+    /** Cursor distance to the selected split edge (CSS px), or `null`. */
+    selectedSplitDistancePx: number | null;
+    /** Reasons candidate splits were rejected during resolution. */
+    rejectedSplitReasons: ReadonlyArray<string>;
+    /** The tuning knobs that shaped this resolution. */
+    tuning: TilingDropIntentTuningState;
+}
+/**
+ * The default drop hit-zone geometry: a `0.34` center swap fraction, a `24`px
+ * center floor, and `6`px boundary hysteresis. The baseline
+ * `dropHitZoneGeometry` capability resolves to these values.
+ */
+declare const TILING_DROP_INTENT_CONFIG: TilingDropIntentBaseConfig;
+
+/**
+ * The resolved hover target the FSM tracks. Structurally a `TilingDropIntentState`
+ * (the resolver output the renderer already produces), so the renderer can store
+ * the full resolved intent verbatim and the candidate-tree derivation / commit
+ * both read the SAME object the preview render reads — no second resolution path.
+ */
+type DragResolvedTarget = TilingDropIntentState;
+
+/**
+ * Public keyboard-binding registry (HT-API-COMMAND-KEYBOARD-SURFACE, half B).
+ *
+ * The chord→command registration surface — the Hyprland `bind` analog. Distinct
+ * from the fixed `TilingKeymap` chord overrides (which only RE-CHORD the built-in
+ * action set): a binding maps an ARBITRARY chord to an ARBITRARY `TilingCommand`,
+ * so a consumer can wire any shortcut to any tiler action (including programmatic
+ * commands like swap / split-ratio).
+ *
+ * Pure + DOM-less. The renderer's keydown resolves a command in this order:
+ * consumer bindings (first match wins, so they augment / override defaults) →
+ * default keymap bindings (unless `replaceDefaults`) → the jump-to-pane Alt+1..9
+ * family (kept in the keymap path since the digit is dynamic) → capability gate.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §3; `commands.ts`
+ * (`keyboardActionToCommand` + `isCommandEnabled`); `pane-switching.ts`
+ * (`matchKeyChord` + `matchKeymapAction`).
+ */
+
+/**
+ * The command of the FIRST binding whose chord matches `event` (exact modifier
+ * match on the physical `event.code`), or `null` when none match. First-match
+ * semantics make binding order significant: an earlier binding wins a chord
+ * collision. Capability gating is applied by the caller (`isCommandEnabled`),
+ * not here — this is pure chord resolution.
+ */
+declare function matchKeyBinding(event: TilingKeyboardEventLike, bindings: ReadonlyArray<TilingKeyBinding>): TilingCommand | null;
+/**
+ * The default chord→command bindings derived from a resolved keymap — the
+ * built-in action set expressed as the binding registry (so a consumer can
+ * introspect / extend it). The jump-to-pane Alt+1..9 family is intentionally
+ * EXCLUDED: its digit is dynamic, so it stays in the `matchKeymapAction` path
+ * rather than being enumerated as nine static bindings.
+ */
+declare function defaultKeyBindings(keymap: ResolvedTilingKeymap): ReadonlyArray<TilingKeyBinding>;
+
+/**
+ * MRU focus history — the pure model behind the "focus current-or-last" toggle
+ * (HT-NAV-MRU-FOCUS-TOGGLE; Hyprland `focuscurrentorlast` analog).
+ *
+ * hypr-tiling cycles a fixed reading-order ring (`resolveCycledPaneId`) with no
+ * memory of WHICH pane was focused before the current one. This module adds a
+ * most-recently-used stack so a consumer (or the `focus-current-or-last`
+ * command) can jump back to the previously-focused pane and toggle between the
+ * two — independent of tree order.
+ *
+ * Pure + DOM-less (the renderer holds the `FocusHistory` in a ref and pushes on
+ * every focus change); unit-tested in the `node` jest environment.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §4;
+ * `_agent/comparative-analysis/parity-report.md` §5 #8 (MRU focus-toggle gap);
+ * `_agent/programme-debt/D-a11y-navigation.md` (HT-NAV-MRU-FOCUS-TOGGLE).
+ */
+/**
+ * An ordered most-recently-used focus list. `entries` is oldest-first /
+ * MOST-RECENT-LAST; the final entry is the currently-focused pane once it has
+ * been pushed. Each leaf id appears at most once (a re-focus moves it to the
+ * end rather than duplicating).
+ */
+interface FocusHistory {
+    /** Leaf ids in MRU order: oldest-first, most-recently-focused last. */
+    readonly entries: ReadonlyArray<string>;
+}
+/** Default cap on retained history entries (older entries are dropped from the front). */
+declare const FOCUS_HISTORY_DEFAULT_LIMIT: number;
+/** An empty focus history (no panes focused yet). */
+declare const EMPTY_FOCUS_HISTORY: FocusHistory;
+/**
+ * Push `leafId` as the most-recent focus. If it already appears it is MOVED to
+ * the end (de-dupe, not duplicate), so the history stays a clean MRU ordering.
+ * The list is capped to `limit` by dropping the oldest (front) entries. A
+ * `limit <= 0` clamps to `1` (the current focus is always retained).
+ */
+declare function pushFocusHistory(history: FocusHistory, leafId: string, limit?: number): FocusHistory;
+/**
+ * Resolve the "current-or-last" target: the most-recent entry that is NOT
+ * `currentLeafId` (the previously-focused distinct pane). Returns `null` when
+ * there is no such pane (empty history, or only the current pane is recorded).
+ *
+ * `currentLeafId == null` returns the most-recent entry outright (no current
+ * focus to skip). Because focusing the returned pane pushes it to most-recent,
+ * repeated toggles bounce between the two panes naturally.
+ */
+declare function resolveFocusCurrentOrLast(history: FocusHistory, currentLeafId: string | null): string | null;
+/**
+ * Drop history entries whose leaf id is no longer present in the live tree
+ * (`validLeafIds`), preserving MRU order. Called after a layout change so a
+ * removed pane is never returned by `resolveFocusCurrentOrLast`.
+ */
+declare function pruneFocusHistory(history: FocusHistory, validLeafIds: ReadonlyArray<string>): FocusHistory;
+
+/** Resolve the sizing mode for a single dimension; undefined defaults to flexible. */
+declare function resolveSizingMode(sizing: TilingPaneSizing | undefined, dimension: TilingDimension): TilingPaneSizingMode;
+/** True when the node is content-sized (static) in the given dimension. */
+declare function isStaticInDimension(node: TilingLayoutNode, dimension: TilingDimension): boolean;
+/**
+ * True when the node is static ALONG the split's main axis → it is content-sized
+ * along that axis, excluded from the split's ratio, and removes the divider on
+ * that boundary.
+ */
+declare function isStaticAlongSplitAxis(node: TilingLayoutNode, axis: TilingSplitAxis): boolean;
+/**
+ * True when the node is static on the split's CROSS axis → it content-sizes on
+ * the cross axis (no stretch) but still participates in the split-axis ratio.
+ */
+declare function isStaticOnCrossAxis(node: TilingLayoutNode, axis: TilingSplitAxis): boolean;
+/**
+ * True when the layout tree contains ANY node declared static in either
+ * dimension — a generic whole-tree predicate. NOTE: this is no longer the drag
+ * gate. The drag/rearrange gate is now PER-SUBTREE (`drop-validity.ts`
+ * `collectStaticGatedLeafIds`) and the footprint geometry is static-aware
+ * (`leaf-geometry.ts`), so a pinned static pane no longer freezes the whole tree
+ * (HT-SIZING-STATIC-DRAG-GATING). Retained as a reusable predicate.
+ */
+declare function layoutContainsStaticPane(node: TilingLayoutNode): boolean;
+/** Inputs deciding whether a split boundary renders a draggable resize divider. */
+interface SplitBoundaryStaticFlags {
+    /** Whether divider resize is enabled for this boundary. */
+    resizeEnabled: boolean;
+    /** Whether the first child is static along the split axis. */
+    firstStaticAlongAxis: boolean;
+    /** Whether the second child is static along the split axis. */
+    secondStaticAlongAxis: boolean;
+}
+/**
+ * A resize divider is placed ONLY between two boundaries that are both flexible
+ * along the split axis. If resize is disabled, or either adjacent child is
+ * static along the split axis, no draggable handle is rendered there.
+ */
+declare function shouldRenderSplitDivider({ resizeEnabled, firstStaticAlongAxis, secondStaticAlongAxis, }: SplitBoundaryStaticFlags): boolean;
+/** One child's ratio + static-along-axis flag, input to ratio renormalization. */
+interface FlexibleRatioChild {
+    /** The child's declared split-axis ratio. */
+    ratio: number;
+    /** Whether the child is static along the split axis (weight 0 in distribution). */
+    staticAlongAxis: boolean;
+}
+/**
+ * Renormalize split-axis ratios over the FLEXIBLE children only. Static children
+ * receive weight 0 (content-sized, excluded from distribution); flexible children
+ * share `1.0` proportionally to their declared ratios. When the flexible ratios
+ * sum to zero (or there are no positive ratios), flexible children split evenly.
+ */
+declare function renormalizeFlexibleRatios(children: ReadonlyArray<FlexibleRatioChild>): number[];
+
+/**
+ * Custom-rendered drag cursor (interaction tier "c"). A single `position: fixed`
+ * sibling of the cursor-following ghost (`DragPaneOverlay`) that REPLACES the OS
+ * cursor during an active live drag, transform-pinned to the pointer in the same
+ * coalesced rAF/render path as the ghost so it never lags the hardware cursor.
+ *
+ * This module is the PURE, DOM-less core: it maps the drag FSM's resolved target
+ * (`DragResolvedTarget` = the resolver's `TilingDropIntentState`) plus the drop
+ * validity onto a small SEMANTIC presentation descriptor — the OPERATION the
+ * release would perform (grab / insert / swap) or its rejection (invalid) — NOT
+ * an edge direction. The found slot itself already shows where the pane lands;
+ * the cursor only confirms what kind of drop is under the pointer. The renderer's
+ * `DragCursorOverlay` consumes these outputs and owns the actual SVG/Tailwind +
+ * reduced-motion transitions.
+ */
+/**
+ * The semantic cursor states, driven by the drag FSM + resolver operation type +
+ * validity (NOT by edge direction):
+ * - `grab` — dragging with no committable target (ghost free-following) OR
+ *   hovering the drag source itself; neutral "carrying" look.
+ * - `insert` — a committable edge-insert slot is resolved; a "drop/place here"
+ *   target affordance in the valid accent color. No direction — the found slot
+ *   already shows where the pane lands.
+ * - `swap` — a committable center/swap target is resolved; a distinct exchange
+ *   indicator in the valid accent color (swap is a different operation).
+ * - `invalid` — the hovered target is rejected (`blockedReason` set); a
+ *   `not-allowed`-style indicator in the warning color.
+ */
+type DragCursorKind = "grab" | "insert" | "swap" | "invalid";
+/** Color tone the cursor adopts, derived from drop validity. */
+type DragCursorTone = "neutral" | "valid" | "invalid";
+/** The semantic presentation of the custom drag cursor: its state plus its tone. */
+interface DragCursorPresentation {
+    /** The semantic operation/validity state the cursor conveys (drives the glyph). */
+    kind: DragCursorKind;
+    /** Validity tone the cursor adopts (drives the color). */
+    tone: DragCursorTone;
+}
+/**
+ * Derive the custom cursor's semantic presentation from the FSM-resolved target +
+ * the drag source. Pure (no DOM, no time) so the operation+validity → kind
+ * mapping is unit-testable. Precedence mirrors the commit gate
+ * (`isCommittableTarget`) so the cursor's "valid" look is shown for EXACTLY the
+ * targets a release would commit:
+ * - no target / self-target → `grab` (neutral).
+ * - committable `swap` (center) → `swap` (valid).
+ * - committable `edge-insert` (a resolved, valid edge) → `insert` (valid).
+ * - otherwise, a rejected hovered target (`blockedReason` set) → `invalid`.
+ * - any remaining non-committable, non-blocked hover → `grab` (neutral).
+ */
+declare function resolveDragCursorPresentation(resolvedTarget: DragResolvedTarget | null, sourceLeafId: string): DragCursorPresentation;
+/** A pointer point in viewport (client) coordinates. */
+interface DragCursorPoint {
+    /** Client X (CSS px). */
+    x: number;
+    /** Client Y (CSS px). */
+    y: number;
+}
+/** Viewport edge bounds (client coords) used to clamp the pinned cursor point. */
+interface DragCursorViewportBounds {
+    /** Left edge (client X). */
+    left: number;
+    /** Top edge (client Y). */
+    top: number;
+    /** Right edge (client X). */
+    right: number;
+    /** Bottom edge (client Y). */
+    bottom: number;
+}
+/**
+ * Clamp the pinned pointer point so the custom cursor element stays fully within
+ * the viewport at the edges — the analog of the ghost overlay's off-viewport
+ * clamp. `marginPx` reserves room for the cursor element's own extent (so the
+ * badge at the right/bottom edge is not clipped). When the bounds are narrower
+ * than `2 * marginPx` on an axis (degenerate / tiny viewport), the point snaps
+ * to that axis's midpoint rather than inverting. Pure so the clamp is testable
+ * without a DOM.
+ */
+declare function clampCursorPointToViewport(point: DragCursorPoint, bounds: DragCursorViewportBounds, marginPx: number): DragCursorPoint;
+
+export { type DragCursorKind, type DragCursorPoint, type DragCursorPresentation, type DragCursorTone, type DragCursorViewportBounds, type DragResolvedTarget, EMPTY_FOCUS_HISTORY, FOCUS_HISTORY_DEFAULT_LIMIT, type FlexibleRatioChild, type FocusHistory, type SplitBoundaryStaticFlags, TILING_DROP_INTENT_CONFIG, TilingDimension, type TilingDropIntentBaseConfig, type TilingDropIntentState, type TilingEdgeZone, TilingKeyboardEventLike, clampCursorPointToViewport, defaultKeyBindings, isStaticAlongSplitAxis, isStaticInDimension, isStaticOnCrossAxis, layoutContainsStaticPane, matchKeyBinding, pruneFocusHistory, pushFocusHistory, renormalizeFlexibleRatios, resolveDragCursorPresentation, resolveFocusCurrentOrLast, resolveSizingMode, shouldRenderSplitDivider };

package/dist/engine.d.ts

@@ -0,0 +1,314 @@
+export { G as GroupLeavesOptions, M as MULTI_SELECT_GROUP_MIN_MEMBERS, T as TILING_KEYMAP_DEFAULTS, a as TilingKeymapActionGuards, c as canGroupMultiSelection, b as chordRequiresModifier, d as collectGroups, e as collectSplitNodes, f as commandRequiredCapability, g as findLeafByDirection, h as findLeafById, i as groupLeaves, j as hasAnyModifier, k as insertLeafAdjacent, l as isCssEasing, m as isResizeAxisEnabled, n as isStructurallyValidLayout, o as keyboardActionToCommand, p as matchKeyChord, q as matchKeymapAction, r as moveLeafToRoot, s as moveLeafToSplitContainer, t as pruneMultiSelection, u as readLeafNodeIds, v as removeLeafTile, w as resolveDragEasing, x as resolveKeymap, y as resolveMaximizeToggle, z as resolveMultiSelectGroupCommand, A as resolveMultiSelectGroupHost, B as setLeafSizing, C as siblingSubtreeForLeaf, D as swapLeafTiles, E as tileOrderByLeafId, F as toggleLeafMultiSelection, H as toggleSplitAxis, I as ungroupNode, J as updateSplitRatio } from './drag-easing-5WbK3T82.js';
+import { r as TilingLeafDropZone, s as TilingDropAction, t as TilingSplitAxis, j as TilingDropIntentTuningState, u as ResolvedTilingKeymap, v as TilingKeyBinding, w as TilingKeyboardEventLike, x as TilingCommand, T as TilingLayoutNode, y as TilingDimension, z as TilingPaneSizing, A as TilingPaneSizingMode } from './tiling-renderer-kTlSm4H4.js';
+export { B as BASELINE_DRAG_HOP_DURATION_MS, I as INSTANT_DRAG_DURATION_MS, C as TilingAccentHue, D as TilingKeyboardAction, E as TilingKeyboardModifierState, F as TilingMoveModeState, G as TilingPaneSwitcherState, H as accentHue } from './tiling-renderer-kTlSm4H4.js';
+import 'react';
+
+/** A pane's four directional insert edges (the drop zones excluding `"center"`). */
+type TilingEdgeZone = Exclude<TilingLeafDropZone, "center">;
+/** Base drop hit-zone geometry: center swap fraction, floor, and hysteresis. */
+interface TilingDropIntentBaseConfig {
+    /**
+     * Fraction of each pane axis spanned by the center (swap) rectangle. Acts as
+     * the SYMMETRIC value: it sizes both axes unless a per-axis override
+     * (`centerRatioX` / `centerRatioY`) is supplied for that axis.
+     */
+    centerRatio: number;
+    /** Per-axis HORIZONTAL (width) swap-zone fraction; falls back to `centerRatio`. */
+    centerRatioX?: number;
+    /** Per-axis VERTICAL (height) swap-zone fraction; falls back to `centerRatio`. */
+    centerRatioY?: number;
+    /** Floor for the center rectangle extent so tiny panes keep a usable swap zone. */
+    centerMinPx: number;
+    /** Boundary stickiness (pane-local px) used to suppress sub-pixel flicker. */
+    hysteresisPx: number;
+}
+/**
+ * The resolver's full drop-intent result for one pane hover: the resolved zone
+ * and action plus the geometry/diagnostic fields that explain how it was
+ * reached. Emitted (as {@link TilingDropIntentDebugState}) to `onDropIntentChange`.
+ */
+interface TilingDropIntentState {
+    /** The hovered leaf this resolution targets. */
+    leafId: string;
+    /** The resolved drop zone under the cursor. */
+    zone: TilingLeafDropZone;
+    /** The resolved drop action. */
+    action: TilingDropAction;
+    /** The nearest edge the cursor points toward (pre-fallback). */
+    dominantEdge: TilingEdgeZone;
+    /** The edge finally selected after fallbacks, or `null`. */
+    finalEdge: TilingEdgeZone | null;
+    /** Why the dominant edge was replaced by a fallback, or `null`. */
+    fallbackReason: string | null;
+    /** Why the action was blocked, or `null` when unblocked. */
+    blockedReason: string | null;
+    /** Split axes from the root to the target (containment path). */
+    axisPath: ReadonlyArray<TilingSplitAxis>;
+    /** Edge threshold fraction in effect. */
+    edgeThresholdRatio: number;
+    /** Center rectangle width (CSS px). */
+    centerRectWidthPx: number;
+    /** Center rectangle height (CSS px). */
+    centerRectHeightPx: number;
+    /** Cursor distance to the center rectangle (CSS px). */
+    centerDistancePx: number;
+    /** Cursor distance to the nearest edge (CSS px). */
+    nearestEdgeDistancePx: number;
+    /** Pane-local cursor X (CSS px). */
+    paneLocalX: number;
+    /** Pane-local cursor Y (CSS px). */
+    paneLocalY: number;
+    /** The ancestor split chosen for a split-container insert, or `null`. */
+    targetSplitId: string | null;
+    /** Which child slot of that split the insert targets, or `null`. */
+    targetSplitPlacement: "first" | "second" | null;
+    /** The edge zone selected on the chosen split, or `null`. */
+    selectedSplitZone: TilingEdgeZone | null;
+    /** Cursor distance to the selected split edge (CSS px), or `null`. */
+    selectedSplitDistancePx: number | null;
+    /** Reasons candidate splits were rejected during resolution. */
+    rejectedSplitReasons: ReadonlyArray<string>;
+    /** The tuning knobs that shaped this resolution. */
+    tuning: TilingDropIntentTuningState;
+}
+/**
+ * The default drop hit-zone geometry: a `0.34` center swap fraction, a `24`px
+ * center floor, and `6`px boundary hysteresis. The baseline
+ * `dropHitZoneGeometry` capability resolves to these values.
+ */
+declare const TILING_DROP_INTENT_CONFIG: TilingDropIntentBaseConfig;
+
+/**
+ * The resolved hover target the FSM tracks. Structurally a `TilingDropIntentState`
+ * (the resolver output the renderer already produces), so the renderer can store
+ * the full resolved intent verbatim and the candidate-tree derivation / commit
+ * both read the SAME object the preview render reads — no second resolution path.
+ */
+type DragResolvedTarget = TilingDropIntentState;
+
+/**
+ * Public keyboard-binding registry (HT-API-COMMAND-KEYBOARD-SURFACE, half B).
+ *
+ * The chord→command registration surface — the Hyprland `bind` analog. Distinct
+ * from the fixed `TilingKeymap` chord overrides (which only RE-CHORD the built-in
+ * action set): a binding maps an ARBITRARY chord to an ARBITRARY `TilingCommand`,
+ * so a consumer can wire any shortcut to any tiler action (including programmatic
+ * commands like swap / split-ratio).
+ *
+ * Pure + DOM-less. The renderer's keydown resolves a command in this order:
+ * consumer bindings (first match wins, so they augment / override defaults) →
+ * default keymap bindings (unless `replaceDefaults`) → the jump-to-pane Alt+1..9
+ * family (kept in the keymap path since the digit is dynamic) → capability gate.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §3; `commands.ts`
+ * (`keyboardActionToCommand` + `isCommandEnabled`); `pane-switching.ts`
+ * (`matchKeyChord` + `matchKeymapAction`).
+ */
+
+/**
+ * The command of the FIRST binding whose chord matches `event` (exact modifier
+ * match on the physical `event.code`), or `null` when none match. First-match
+ * semantics make binding order significant: an earlier binding wins a chord
+ * collision. Capability gating is applied by the caller (`isCommandEnabled`),
+ * not here — this is pure chord resolution.
+ */
+declare function matchKeyBinding(event: TilingKeyboardEventLike, bindings: ReadonlyArray<TilingKeyBinding>): TilingCommand | null;
+/**
+ * The default chord→command bindings derived from a resolved keymap — the
+ * built-in action set expressed as the binding registry (so a consumer can
+ * introspect / extend it). The jump-to-pane Alt+1..9 family is intentionally
+ * EXCLUDED: its digit is dynamic, so it stays in the `matchKeymapAction` path
+ * rather than being enumerated as nine static bindings.
+ */
+declare function defaultKeyBindings(keymap: ResolvedTilingKeymap): ReadonlyArray<TilingKeyBinding>;
+
+/**
+ * MRU focus history — the pure model behind the "focus current-or-last" toggle
+ * (HT-NAV-MRU-FOCUS-TOGGLE; Hyprland `focuscurrentorlast` analog).
+ *
+ * hypr-tiling cycles a fixed reading-order ring (`resolveCycledPaneId`) with no
+ * memory of WHICH pane was focused before the current one. This module adds a
+ * most-recently-used stack so a consumer (or the `focus-current-or-last`
+ * command) can jump back to the previously-focused pane and toggle between the
+ * two — independent of tree order.
+ *
+ * Pure + DOM-less (the renderer holds the `FocusHistory` in a ref and pushes on
+ * every focus change); unit-tested in the `node` jest environment.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §4;
+ * `_agent/comparative-analysis/parity-report.md` §5 #8 (MRU focus-toggle gap);
+ * `_agent/programme-debt/D-a11y-navigation.md` (HT-NAV-MRU-FOCUS-TOGGLE).
+ */
+/**
+ * An ordered most-recently-used focus list. `entries` is oldest-first /
+ * MOST-RECENT-LAST; the final entry is the currently-focused pane once it has
+ * been pushed. Each leaf id appears at most once (a re-focus moves it to the
+ * end rather than duplicating).
+ */
+interface FocusHistory {
+    /** Leaf ids in MRU order: oldest-first, most-recently-focused last. */
+    readonly entries: ReadonlyArray<string>;
+}
+/** Default cap on retained history entries (older entries are dropped from the front). */
+declare const FOCUS_HISTORY_DEFAULT_LIMIT: number;
+/** An empty focus history (no panes focused yet). */
+declare const EMPTY_FOCUS_HISTORY: FocusHistory;
+/**
+ * Push `leafId` as the most-recent focus. If it already appears it is MOVED to
+ * the end (de-dupe, not duplicate), so the history stays a clean MRU ordering.
+ * The list is capped to `limit` by dropping the oldest (front) entries. A
+ * `limit <= 0` clamps to `1` (the current focus is always retained).
+ */
+declare function pushFocusHistory(history: FocusHistory, leafId: string, limit?: number): FocusHistory;
+/**
+ * Resolve the "current-or-last" target: the most-recent entry that is NOT
+ * `currentLeafId` (the previously-focused distinct pane). Returns `null` when
+ * there is no such pane (empty history, or only the current pane is recorded).
+ *
+ * `currentLeafId == null` returns the most-recent entry outright (no current
+ * focus to skip). Because focusing the returned pane pushes it to most-recent,
+ * repeated toggles bounce between the two panes naturally.
+ */
+declare function resolveFocusCurrentOrLast(history: FocusHistory, currentLeafId: string | null): string | null;
+/**
+ * Drop history entries whose leaf id is no longer present in the live tree
+ * (`validLeafIds`), preserving MRU order. Called after a layout change so a
+ * removed pane is never returned by `resolveFocusCurrentOrLast`.
+ */
+declare function pruneFocusHistory(history: FocusHistory, validLeafIds: ReadonlyArray<string>): FocusHistory;
+
+/** Resolve the sizing mode for a single dimension; undefined defaults to flexible. */
+declare function resolveSizingMode(sizing: TilingPaneSizing | undefined, dimension: TilingDimension): TilingPaneSizingMode;
+/** True when the node is content-sized (static) in the given dimension. */
+declare function isStaticInDimension(node: TilingLayoutNode, dimension: TilingDimension): boolean;
+/**
+ * True when the node is static ALONG the split's main axis → it is content-sized
+ * along that axis, excluded from the split's ratio, and removes the divider on
+ * that boundary.
+ */
+declare function isStaticAlongSplitAxis(node: TilingLayoutNode, axis: TilingSplitAxis): boolean;
+/**
+ * True when the node is static on the split's CROSS axis → it content-sizes on
+ * the cross axis (no stretch) but still participates in the split-axis ratio.
+ */
+declare function isStaticOnCrossAxis(node: TilingLayoutNode, axis: TilingSplitAxis): boolean;
+/**
+ * True when the layout tree contains ANY node declared static in either
+ * dimension — a generic whole-tree predicate. NOTE: this is no longer the drag
+ * gate. The drag/rearrange gate is now PER-SUBTREE (`drop-validity.ts`
+ * `collectStaticGatedLeafIds`) and the footprint geometry is static-aware
+ * (`leaf-geometry.ts`), so a pinned static pane no longer freezes the whole tree
+ * (HT-SIZING-STATIC-DRAG-GATING). Retained as a reusable predicate.
+ */
+declare function layoutContainsStaticPane(node: TilingLayoutNode): boolean;
+/** Inputs deciding whether a split boundary renders a draggable resize divider. */
+interface SplitBoundaryStaticFlags {
+    /** Whether divider resize is enabled for this boundary. */
+    resizeEnabled: boolean;
+    /** Whether the first child is static along the split axis. */
+    firstStaticAlongAxis: boolean;
+    /** Whether the second child is static along the split axis. */
+    secondStaticAlongAxis: boolean;
+}
+/**
+ * A resize divider is placed ONLY between two boundaries that are both flexible
+ * along the split axis. If resize is disabled, or either adjacent child is
+ * static along the split axis, no draggable handle is rendered there.
+ */
+declare function shouldRenderSplitDivider({ resizeEnabled, firstStaticAlongAxis, secondStaticAlongAxis, }: SplitBoundaryStaticFlags): boolean;
+/** One child's ratio + static-along-axis flag, input to ratio renormalization. */
+interface FlexibleRatioChild {
+    /** The child's declared split-axis ratio. */
+    ratio: number;
+    /** Whether the child is static along the split axis (weight 0 in distribution). */
+    staticAlongAxis: boolean;
+}
+/**
+ * Renormalize split-axis ratios over the FLEXIBLE children only. Static children
+ * receive weight 0 (content-sized, excluded from distribution); flexible children
+ * share `1.0` proportionally to their declared ratios. When the flexible ratios
+ * sum to zero (or there are no positive ratios), flexible children split evenly.
+ */
+declare function renormalizeFlexibleRatios(children: ReadonlyArray<FlexibleRatioChild>): number[];
+
+/**
+ * Custom-rendered drag cursor (interaction tier "c"). A single `position: fixed`
+ * sibling of the cursor-following ghost (`DragPaneOverlay`) that REPLACES the OS
+ * cursor during an active live drag, transform-pinned to the pointer in the same
+ * coalesced rAF/render path as the ghost so it never lags the hardware cursor.
+ *
+ * This module is the PURE, DOM-less core: it maps the drag FSM's resolved target
+ * (`DragResolvedTarget` = the resolver's `TilingDropIntentState`) plus the drop
+ * validity onto a small SEMANTIC presentation descriptor — the OPERATION the
+ * release would perform (grab / insert / swap) or its rejection (invalid) — NOT
+ * an edge direction. The found slot itself already shows where the pane lands;
+ * the cursor only confirms what kind of drop is under the pointer. The renderer's
+ * `DragCursorOverlay` consumes these outputs and owns the actual SVG/Tailwind +
+ * reduced-motion transitions.
+ */
+/**
+ * The semantic cursor states, driven by the drag FSM + resolver operation type +
+ * validity (NOT by edge direction):
+ * - `grab` — dragging with no committable target (ghost free-following) OR
+ *   hovering the drag source itself; neutral "carrying" look.
+ * - `insert` — a committable edge-insert slot is resolved; a "drop/place here"
+ *   target affordance in the valid accent color. No direction — the found slot
+ *   already shows where the pane lands.
+ * - `swap` — a committable center/swap target is resolved; a distinct exchange
+ *   indicator in the valid accent color (swap is a different operation).
+ * - `invalid` — the hovered target is rejected (`blockedReason` set); a
+ *   `not-allowed`-style indicator in the warning color.
+ */
+type DragCursorKind = "grab" | "insert" | "swap" | "invalid";
+/** Color tone the cursor adopts, derived from drop validity. */
+type DragCursorTone = "neutral" | "valid" | "invalid";
+/** The semantic presentation of the custom drag cursor: its state plus its tone. */
+interface DragCursorPresentation {
+    /** The semantic operation/validity state the cursor conveys (drives the glyph). */
+    kind: DragCursorKind;
+    /** Validity tone the cursor adopts (drives the color). */
+    tone: DragCursorTone;
+}
+/**
+ * Derive the custom cursor's semantic presentation from the FSM-resolved target +
+ * the drag source. Pure (no DOM, no time) so the operation+validity → kind
+ * mapping is unit-testable. Precedence mirrors the commit gate
+ * (`isCommittableTarget`) so the cursor's "valid" look is shown for EXACTLY the
+ * targets a release would commit:
+ * - no target / self-target → `grab` (neutral).
+ * - committable `swap` (center) → `swap` (valid).
+ * - committable `edge-insert` (a resolved, valid edge) → `insert` (valid).
+ * - otherwise, a rejected hovered target (`blockedReason` set) → `invalid`.
+ * - any remaining non-committable, non-blocked hover → `grab` (neutral).
+ */
+declare function resolveDragCursorPresentation(resolvedTarget: DragResolvedTarget | null, sourceLeafId: string): DragCursorPresentation;
+/** A pointer point in viewport (client) coordinates. */
+interface DragCursorPoint {
+    /** Client X (CSS px). */
+    x: number;
+    /** Client Y (CSS px). */
+    y: number;
+}
+/** Viewport edge bounds (client coords) used to clamp the pinned cursor point. */
+interface DragCursorViewportBounds {
+    /** Left edge (client X). */
+    left: number;
+    /** Top edge (client Y). */
+    top: number;
+    /** Right edge (client X). */
+    right: number;
+    /** Bottom edge (client Y). */
+    bottom: number;
+}
+/**
+ * Clamp the pinned pointer point so the custom cursor element stays fully within
+ * the viewport at the edges — the analog of the ghost overlay's off-viewport
+ * clamp. `marginPx` reserves room for the cursor element's own extent (so the
+ * badge at the right/bottom edge is not clipped). When the bounds are narrower
+ * than `2 * marginPx` on an axis (degenerate / tiny viewport), the point snaps
+ * to that axis's midpoint rather than inverting. Pure so the clamp is testable
+ * without a DOM.
+ */
+declare function clampCursorPointToViewport(point: DragCursorPoint, bounds: DragCursorViewportBounds, marginPx: number): DragCursorPoint;
+
+export { type DragCursorKind, type DragCursorPoint, type DragCursorPresentation, type DragCursorTone, type DragCursorViewportBounds, type DragResolvedTarget, EMPTY_FOCUS_HISTORY, FOCUS_HISTORY_DEFAULT_LIMIT, type FlexibleRatioChild, type FocusHistory, type SplitBoundaryStaticFlags, TILING_DROP_INTENT_CONFIG, TilingDimension, type TilingDropIntentBaseConfig, type TilingDropIntentState, type TilingEdgeZone, TilingKeyboardEventLike, clampCursorPointToViewport, defaultKeyBindings, isStaticAlongSplitAxis, isStaticInDimension, isStaticOnCrossAxis, layoutContainsStaticPane, matchKeyBinding, pruneFocusHistory, pushFocusHistory, renormalizeFlexibleRatios, resolveDragCursorPresentation, resolveFocusCurrentOrLast, resolveSizingMode, shouldRenderSplitDivider };