@n-uf/hypr-tiling 26.7.0

package/dist/drag-easing-KxPPNNZT.d.mts

@@ -0,0 +1,605 @@
+import { T as TilingLayoutNode, ab as TilingGroupNode, f as TilingSplitNode, g as TilingFocusDirection, ak as TilingLeafNode, ap as TilingMovePlacement, aR as TilingInsertionOptions, z as TilingPaneSizing, x as TilingCommand, D as TilingKeyboardAction, u as ResolvedTilingKeymap, W as ResolvedTilingKeyChord, X as ResolvedTilingKeyChordModifiers, w as TilingKeyboardEventLike, ah as TilingKeymap, ay as TilingResizeCapability, t as TilingSplitAxis, ad as TilingInteractionCapabilities, R as ResolvedTilingInteractionCapabilities } from './tiling-renderer-kTlSm4H4.mjs';
+
+/**
+ * Return a copy of the tree with split node `splitId`'s divider `ratio` set
+ * (clamped to the legal range). Unchanged when no split with that id exists.
+ */
+declare function updateSplitRatio(node: TilingLayoutNode, splitId: string, ratio: number): TilingLayoutNode;
+/**
+ * Immutably set (or clear) the per-dimension `sizing` on a single leaf. Passing
+ * `undefined` (or a `sizing` with no static dimensions) leaves the leaf
+ * flexible. Used by the showcase per-pane static control. The result is passed
+ * through `normalizeStaticAxisFill` so a static switch can never store a
+ * both-static-along-axis edge (the second along-axis sibling lands as
+ * cross-axis-static + along-axis-fill instead) — closing the reachable
+ * static-switch gap trigger at the data layer.
+ */
+declare function setLeafSizing(node: TilingLayoutNode, leafId: string, sizing: TilingPaneSizing | undefined): TilingLayoutNode;
+/** Find the leaf with id `leafId` anywhere in the tree (including inside a group), or `null`. */
+declare function findLeafById(node: TilingLayoutNode, leafId: string): TilingLeafNode | null;
+/**
+ * Return a copy of the tree with the two leaves' tiles exchanged in place.
+ * Unchanged when the ids are equal or either leaf is missing.
+ */
+declare function swapLeafTiles(node: TilingLayoutNode, firstLeafId: string, secondLeafId: string): TilingLayoutNode;
+/** Every split node in the tree (depth-first, reading order). */
+declare function collectSplitNodes(node: TilingLayoutNode): ReadonlyArray<TilingSplitNode>;
+/**
+ * The leaf ids the OUTER layout sees: a leaf contributes its id; a group
+ * contributes ONLY its active member id (the group presents as one pane to the
+ * outer layout — pane-cycle / jump / directional focus see the active member).
+ * Use `readGroupMemberIds` / `collectGroups` to enumerate ALL members for tab UI.
+ */
+declare function readLeafNodeIds(node: TilingLayoutNode): ReadonlyArray<string>;
+/** Every group in the tree (depth-first, reading order) — the tab-strip source. */
+declare function collectGroups(node: TilingLayoutNode): ReadonlyArray<TilingGroupNode>;
+/**
+ * Flatten a layout tree to the tile ids it renders, in reading order (group
+ * members reported in tab order). Handy for driving tile-order-dependent UI
+ * (e.g. a tab strip or an external index).
+ */
+declare function tileOrderByLeafId(node: TilingLayoutNode): ReadonlyArray<string>;
+/**
+ * A read-only structural view of a {@link TilingLayoutNode} tree, aggregating
+ * the queries an app typically needs to drive layout-aware UI (shortcut chips,
+ * pane counters, directional focus) without walking the tree by hand or
+ * reaching for the low-level `./engine` walkers.
+ *
+ * @public
+ */
+interface TilingLayoutQuery {
+    /**
+     * The leaf ids the OUTER layout sees, in reading order — a leaf contributes
+     * its id; a group contributes ONLY its active member id (the group presents
+     * as one pane to the outer layout).
+     */
+    readonly leafIds: ReadonlyArray<string>;
+    /**
+     * The tile ids the tree renders, in reading order (group members reported in
+     * tab order). Drives tile-order-dependent UI such as a tab strip.
+     */
+    readonly tileOrder: ReadonlyArray<string>;
+    /** Every group in the tree (depth-first, reading order) — the tab-strip source. */
+    readonly groups: ReadonlyArray<TilingGroupNode>;
+    /** Every split node in the tree (depth-first, reading order). */
+    readonly splits: ReadonlyArray<TilingSplitNode>;
+    /** Whether any split node is in `"master"` layout mode. */
+    readonly hasMasterSplit: boolean;
+    /**
+     * The leaf id reached from `fromLeafId` in the given `direction` (spatial
+     * neighbor by pane geometry), or `null` when there is no pane that way.
+     */
+    readonly neighborLeafId: (fromLeafId: string, direction: TilingFocusDirection) => string | null;
+}
+/**
+ * Build a read-only {@link TilingLayoutQuery} over `layout`. The single
+ * higher-level layout-inspection helper on the public API: it composes the
+ * low-level tree walkers (which stay on the `./engine` escape hatch) into the
+ * leaf/tile/group/split views and directional-neighbor lookup an app needs to
+ * render layout-aware controls.
+ *
+ * @example
+ * Inspect the tree you own in state — count panes, list groups, or find a
+ * directional neighbor — without walking it by hand:
+ *
+ * ```ts
+ * import { queryTilingLayout, type TilingLayoutNode } from "@n-uf/hypr-tiling";
+ *
+ * function paneCount(layout: TilingLayoutNode): number {
+ *   return queryTilingLayout(layout).leafIds.length;
+ * }
+ *
+ * const query = queryTilingLayout(layout);
+ * const rightOfFocus = query.neighborLeafId(focusedLeafId, "right");
+ * ```
+ *
+ * @public
+ */
+declare function queryTilingLayout(layout: TilingLayoutNode): TilingLayoutQuery;
+/**
+ * Structural validity check for a layout tree — the commit-time backstop that
+ * guarantees a drag never persists a corrupt tree (orphaned / duplicated /
+ * empty-id leaf, missing split child, NaN ratio). Pure + recursive:
+ *
+ * - every leaf has a non-empty `id` and `tileId`;
+ * - every split has BOTH children present and individually valid, with a finite
+ *   `ratio` in the open interval `(0, 1)`;
+ * - NO leaf id appears more than once across the whole tree (the single-instance
+ *   invariant at the data layer — a duplicated dragged leaf is exactly the BUG-1
+ *   class this rejects).
+ *
+ * The renderer calls this on the derived candidate BEFORE `onLayoutChange`; an
+ * invalid tree is refused (the drag falls back to cancel) so a broken commit can
+ * never reach consumer state.
+ */
+declare function isStructurallyValidLayout(node: TilingLayoutNode): boolean;
+/**
+ * The subtree that gets promoted into a leaf's vacated cell when that leaf is
+ * extracted by `insertLeafAdjacent` / `moveLeafTo*`.
+ *
+ * When a leaf is removed from its parent split, `extractLeafNode` collapses the
+ * parent and the leaf's former sibling branch takes the parent's slot, absorbing
+ * the released space. That sibling branch is the "successor" of the extracted
+ * leaf. Returns `null` for a root leaf (no parent) or an unknown id.
+ */
+declare function siblingSubtreeForLeaf(node: TilingLayoutNode, leafId: string): TilingLayoutNode | null;
+/**
+ * Move `sourceLeafId` adjacent to `targetLeafId`, wrapping them in a new split
+ * on the resolved axis with the source on the `placement` side. Unchanged when
+ * the source and target are the same or the source cannot be extracted.
+ */
+declare function insertLeafAdjacent(layout: TilingLayoutNode, sourceLeafId: string, targetLeafId: string, placement: TilingMovePlacement, options?: Partial<TilingInsertionOptions>): TilingLayoutNode;
+/**
+ * Remove a leaf from the tree and collapse its now-single-child parent split so
+ * the leaf's former sibling subtree takes the parent's slot and absorbs the
+ * released space — the standard tiling gap-close. Returns a NEW tree (the input
+ * is never mutated).
+ *
+ * Removal + parent collapse reuses the same `extractLeafNode` machinery that
+ * `insertLeafAdjacent` / `moveLeafTo*` already rely on; this reducer exposes the
+ * gap-closed remainder directly (it is `insertLeafAdjacent` minus the re-insert).
+ * It is the pickup step of the Hyprland-style "live" drag: the dragged leaf is
+ * detached once on pickup and the remaining tree reflows once to close the gap.
+ *
+ * Returns the layout UNCHANGED when the leaf id is absent, or when it is the
+ * root leaf (a root with no parent cannot be removed without emptying the tree).
+ */
+declare function removeLeafTile(layout: TilingLayoutNode, leafId: string): TilingLayoutNode;
+/**
+ * Move `sourceLeafId` out to a new root-level split, placing it on the
+ * `placement` side alongside the remainder of the tree. Unchanged when the
+ * source cannot be extracted.
+ */
+declare function moveLeafToRoot(layout: TilingLayoutNode, sourceLeafId: string, placement: "first" | "second", options?: Partial<TilingInsertionOptions>): TilingLayoutNode;
+/**
+ * Move `sourceLeafId` into the existing split container `targetSplitId` on the
+ * `placement` side. Unchanged when the source cannot be extracted.
+ */
+declare function moveLeafToSplitContainer(layout: TilingLayoutNode, sourceLeafId: string, targetSplitId: string, placement: "first" | "second", options?: Partial<TilingInsertionOptions>): TilingLayoutNode;
+/**
+ * Return a copy of the tree with split node `splitId`'s axis flipped
+ * (horizontal ↔ vertical). Unchanged when no split with that id exists.
+ */
+declare function toggleSplitAxis(node: TilingLayoutNode, splitId: string): TilingLayoutNode;
+/** Options for `groupLeaves`: an explicit host/anchor + an explicit group id. */
+interface GroupLeavesOptions {
+    /**
+     * The pane whose slot the merged group occupies and whose tile is the active
+     * tab — the clicked pane for the header Group button, or the resolved host for
+     * Alt+G. Defaults to the FIRST resolvable id in `leafIds` when omitted.
+     */
+    hostLeafId?: string;
+    /** Explicit group id; defaults to `group-<hostLeafId>`. */
+    groupId?: string;
+}
+/**
+ * Fold a selection of leaves and/or group members into ONE flat tabbed group
+ * occupying the HOST pane's slot. Any existing group the selection touches is
+ * DISSOLVED and its full membership folded into the single result — there is
+ * never a nested group-within-a-group nor a partial group, and selecting any one
+ * member of a group pulls in the whole group (see `flatGroupMemberOrder`). The
+ * host pane's tile is the active tab and its slot hosts the merged group; every
+ * other involved slot closes and the tree reflows. Returns the layout UNCHANGED
+ * when fewer than two distinct resolvable leaves result (a group needs ≥2
+ * members) or the host is unresolvable.
+ *
+ * @remarks
+ * The no-op return (same reference) is load-bearing: gate a "Group" control on
+ * {@link canGroupMultiSelection}, which detects groupability by checking whether
+ * this operation would actually change the tree. Pass `options.hostLeafId` to
+ * pin which pane keeps the slot and becomes the active tab; otherwise the first
+ * resolvable id in `leafIds` is the host.
+ *
+ * @example
+ * ```ts
+ * import { groupLeaves, canGroupMultiSelection } from "@n-uf/hypr-tiling";
+ *
+ * // `selection` is a ReadonlySet<string> of leaf ids in insertion order.
+ * if (canGroupMultiSelection(layout, selection)) {
+ *   const next = groupLeaves(layout, [...selection]);
+ *   setLayout(next);
+ * }
+ * ```
+ *
+ * @see {@link canGroupMultiSelection} to test groupability before calling.
+ * @see {@link GroupLeavesOptions} for the host-pinning option.
+ */
+declare function groupLeaves(layout: TilingLayoutNode, leafIds: ReadonlyArray<string>, options?: GroupLeavesOptions): TilingLayoutNode;
+/**
+ * Explode a group back into a dwindle split chain of its members (the inverse of
+ * `groupLeaves`). A 1-member group collapses to the bare leaf. Returns the
+ * layout unchanged when `groupId` is absent.
+ */
+declare function ungroupNode(layout: TilingLayoutNode, groupId: string): TilingLayoutNode;
+/**
+ * Id of the nearest focusable leaf from `fromLeafId` in the given spatial
+ * `direction` (geometric nearest-neighbour over the laid-out rectangles), or
+ * `null` when no leaf lies that way. Powers directional keyboard focus.
+ */
+declare function findLeafByDirection(layout: TilingLayoutNode, fromLeafId: string, direction: TilingFocusDirection): string | null;
+
+/**
+ * Public command contract (HT-API-COMMAND-KEYBOARD-SURFACE, half A).
+ *
+ * `TilingCommand` (in `types.ts`) is the public API's typed dispatch-style command set
+ * — the Hyprland `dispatch` analog. This module holds the PURE logic around it:
+ * the command→capability gate (so a command targeting a disabled capability is a
+ * safe no-op, reproducing the old `matchKeymapAction` "leave the key alone"
+ * behavior) and the bridge from the internal fixed-keymap `TilingKeyboardAction`
+ * to a command, so the default keymap path and the public binding registry both
+ * funnel to the SAME renderer router.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §2; `keybindings.ts` (the
+ * chord→command registry); `pane-switching.ts` (`matchKeymapAction` /
+ * `TilingKeyboardAction`).
+ */
+
+/**
+ * The capability enable-flags a command may require. Superset of
+ * `TilingKeymapActionGuards` (which only covers the keyboard-reachable actions)
+ * with the sizing / acquire-space / resize gates the programmatic command set
+ * also touches. The renderer builds this from its resolved capabilities.
+ */
+interface TilingCommandGates {
+    /** Maximize / restore commands. */
+    maximizeEnabled: boolean;
+    /** Pane-switching (focus-cycle / focus-jump) commands. */
+    paneSwitchingEnabled: boolean;
+    /** Focus selection commands. */
+    focusEnabled: boolean;
+    /** Drag/keyboard rearrange (move / swap / insert) commands. */
+    rearrangeEnabled: boolean;
+    /** Per-pane title-bar sizing (`set-sizing`) command. */
+    sizingEnabled: boolean;
+    /** Directional acquire-space command. */
+    acquireSpaceEnabled: boolean;
+    /** Divider resize (`set-split-ratio` / `toggle-split-axis`) commands. */
+    resizeEnabled: boolean;
+    /** Master/stack layout-mode commands (HT-LAYOUT-MASTER-STACK). */
+    layoutEnabled: boolean;
+    /** Group / tabbed-stacking commands (HT-GROUP-TABBED-STACKING). */
+    groupingEnabled: boolean;
+}
+/**
+ * The single capability gate a command requires, or `null` when the command is
+ * unconditionally available. Used by `isCommandEnabled` to decide whether a
+ * dispatch (keyboard or imperative) should run or stay a no-op.
+ */
+declare function commandRequiredCapability(command: TilingCommand): keyof TilingCommandGates | null;
+/**
+ * Whether `command` would do anything given the current capability gates: `true`
+ * when the command's required capability is enabled (or it requires none). A
+ * keyboard binding to a disabled-capability command stays browser-graceful (the
+ * caller does not `preventDefault`); an imperative `dispatch` of one is a no-op.
+ *
+ * @example
+ * Build your own command bar / keyboard shortcut that only fires (and only
+ * renders its button) when the target command is actually enabled — the gate the
+ * renderer itself uses for its shortcut chips:
+ *
+ * ```tsx
+ * import {
+ *   resolveInteractionCapabilities,
+ *   isCommandEnabled,
+ *   type TilingCommand,
+ *   type TilingCommandGates,
+ *   type TilingCommandHandle,
+ *   type TilingInteractionCapabilities,
+ * } from "@n-uf/hypr-tiling";
+ *
+ * function gatesFor(interaction?: TilingInteractionCapabilities): TilingCommandGates {
+ *   const caps = resolveInteractionCapabilities(interaction);
+ *   return {
+ *     maximizeEnabled: caps.maximize.enable,
+ *     paneSwitchingEnabled: caps.paneSwitching.enable,
+ *     focusEnabled: caps.focus,
+ *     rearrangeEnabled: caps.rearrange,
+ *     sizingEnabled: caps.paneTitleBarControls.sizing,
+ *     acquireSpaceEnabled: caps.paneTitleBarControls.acquireSpace,
+ *     resizeEnabled: caps.resize !== "none",
+ *     layoutEnabled: caps.masterLayout,
+ *     groupingEnabled: caps.grouping.enable,
+ *   };
+ * }
+ *
+ * function MaximizeButton(props: {
+ *   handle: React.RefObject<TilingCommandHandle | null>;
+ *   interaction?: TilingInteractionCapabilities;
+ * }) {
+ *   const command: TilingCommand = { kind: "toggle-maximize" };
+ *   if (!isCommandEnabled(command, gatesFor(props.interaction))) {
+ *     return null; // maximize is disabled — don't render a dead control
+ *   }
+ *   return <button onClick={() => props.handle.current?.dispatch(command)}>Maximize</button>;
+ * }
+ * ```
+ */
+declare function isCommandEnabled(command: TilingCommand, gates: TilingCommandGates): boolean;
+/**
+ * Bridge an internal fixed-keymap `TilingKeyboardAction` to the public command
+ * set. The default keymap path resolves an action via `matchKeymapAction`, then
+ * runs it through this bridge so it reaches the same `dispatchCommand` router the
+ * binding registry feeds — no duplicated action logic.
+ */
+declare function keyboardActionToCommand(action: TilingKeyboardAction): TilingCommand;
+
+/**
+ * Documented keymap defaults. Matching keys off the PHYSICAL `KeyboardEvent.code`
+ * (not the produced `event.key`), so the bindings hold on macOS / Arc where the
+ * Option(Alt) modifier rewrites `event.key` into dead-key glyphs. These are
+ * deliberately browser-graceful: they never collide with `F11` (`F11`),
+ * `Ctrl/Cmd+W` (`KeyW`), `Ctrl/Cmd+T` (`KeyT`), or `Ctrl+Tab` (`Tab`). Every
+ * binding is Alt-based (or bare `Escape`), and matching requires an EXACT
+ * modifier state, so e.g. `Cmd+1` (`Digit1`+Meta, a browser tab shortcut) never
+ * matches the Alt-only jump family.
+ */
+declare const TILING_KEYMAP_DEFAULTS: ResolvedTilingKeymap;
+/**
+ * Resolve a public keymap to a fully-resolved keymap. `undefined`/`null` → the
+ * documented defaults; a partial keymap merges at the action level (supplying
+ * one binding leaves the others at their defaults).
+ */
+declare function resolveKeymap(keymap?: TilingKeymap | null): ResolvedTilingKeymap;
+/**
+ * Exact-match a keyboard event against a resolved chord. The key identity is
+ * compared on the PHYSICAL `event.code` (so macOS Option-glyph rewrites of
+ * `event.key` are irrelevant); all four modifiers are compared exactly.
+ */
+declare function matchKeyChord(event: TilingKeyboardEventLike, chord: ResolvedTilingKeyChord): boolean;
+/** Capability enable flags consulted while matching a keyboard action. */
+interface TilingKeymapActionGuards {
+    /** Gates the maximize/restore actions (`toggleMaximize` / `restore`). */
+    maximizeEnabled: boolean;
+    /** Gates the pane-switching actions (`previousPane` / `nextPane` / `jumpToPane`). */
+    paneSwitchingEnabled: boolean;
+    /** Gates the directional focus actions (`focusLeft/Right/Up/Down`). */
+    focusEnabled: boolean;
+    /** Gates move-mode entry (`enterMoveMode`); mirrors the drag-rearrange gate. */
+    rearrangeEnabled: boolean;
+}
+/**
+ * Resolve a keyboard event to a logical tiling action, honoring capability
+ * enable flags. Returns `null` when no binding matches or the owning capability
+ * is disabled — the caller then leaves the event alone (no `preventDefault`),
+ * keeping unhandled keys browser-graceful.
+ */
+declare function matchKeymapAction(event: TilingKeyboardEventLike, keymap: ResolvedTilingKeymap, guards: TilingKeymapActionGuards): TilingKeyboardAction | null;
+/**
+ * Resolve the jump-to-N leaf id (1-based), or `null` when out of range (no-op).
+ *
+ * @example
+ * Wire your own "jump to pane N" buttons against the leaf order from
+ * {@link queryTilingLayout}, dispatching the built-in `focus-jump` command:
+ *
+ * ```tsx
+ * import { queryTilingLayout, resolveJumpedPaneId } from "@n-uf/hypr-tiling";
+ *
+ * const { leafIds } = queryTilingLayout(layout);
+ * leafIds.forEach((_, i) => {
+ *   const paneNumber = i + 1;
+ *   const targetLeafId = resolveJumpedPaneId(leafIds, paneNumber); // null → out of range
+ *   // render a button that dispatches { kind: "focus-jump", paneNumber } when targetLeafId != null
+ * });
+ * ```
+ */
+declare function resolveJumpedPaneId(leafIds: ReadonlyArray<string>, paneNumber: number): string | null;
+/**
+ * Resolve the next maximized-leaf state from a toggle on `focusedLeafId`:
+ * - no focused pane → unchanged (returns the current maximized id);
+ * - toggling the already-maximized pane → restore (`null`);
+ * - otherwise → maximize the focused pane.
+ */
+declare function resolveMaximizeToggle(currentMaximizedLeafId: string | null, focusedLeafId: string | null): string | null;
+/** Whether a chord requires at least one held modifier (the switcher needs one to commit on release). */
+declare function chordRequiresModifier(chord: ResolvedTilingKeyChord): boolean;
+/** Whether a modifier set requires at least one held modifier. */
+declare function hasAnyModifier(modifiers: ResolvedTilingKeyChordModifiers): boolean;
+
+/**
+ * Pure multi-selection model for the Alt/Opt+click header → group flow
+ * (`paneSwitching.multiSelectGrouping`).
+ *
+ * The renderer is a `"use client"` DOM component that cannot be exercised under
+ * the node-only jest harness (see `_agent/tiling-architecture.md`, "Test
+ * coverage status"), so the interaction's decision logic lives here as pure
+ * functions the renderer merely wires:
+ *
+ * - `isMultiSelectModifierActive` — discriminate a plain header click from an
+ *   Alt/Opt (multi-select) click.
+ * - `toggleLeafMultiSelection` — add/remove a leaf from the selection set
+ *   (immutable; insertion order is preserved, so the first-selected leaf is the
+ *   `group-leaves` anchor).
+ * - `pruneMultiSelection` — drop ids no longer present in the layout's
+ *   outer-slot leaf set, so a removed pane never lingers selected.
+ * - `canGroupMultiSelection` — whether the current selection can be folded into
+ *   one group RIGHT NOW under the existing `groupLeaves` constraint.
+ * - `resolveMultiSelectGroupCommand` — the `group-leaves` command for the
+ *   current selection (or `null` when there is nothing groupable).
+ *
+ * Cross-ref: `state.ts` (`groupLeaves` — the SOLE grouping operation reused
+ * here, not reimplemented); `commands.ts` (`group-leaves` capability gate).
+ */
+
+/** Minimum selection size that the existing `groupLeaves` op will act on. */
+declare const MULTI_SELECT_GROUP_MIN_MEMBERS: number;
+/**
+ * The modifier-key subset of a pointer/mouse event that discriminates a
+ * multi-select click from a plain click. The multi-select / grouping modifier is
+ * unified on Alt/Opt across every surface (header click + the Alt+G key), chosen
+ * for minimal cross-browser interference: `altKey` = Opt on macOS, Alt on
+ * Windows/Linux.
+ */
+interface MultiSelectModifierState {
+    /** Whether Alt/Opt was held (the multi-select discriminator). */
+    readonly altKey: boolean;
+}
+/**
+ * `true` when the event carries the multi-select modifier — Alt/Opt (`altKey`),
+ * the single chord both the header toggle and the Alt+G group key key off.
+ *
+ * @example
+ * In a custom `renderTile`, add the clicked pane to the multi-selection only when
+ * the platform multi-select modifier is held (a plain click falls through to
+ * focus):
+ *
+ * ```tsx
+ * import { isMultiSelectModifierActive } from "@n-uf/hypr-tiling";
+ *
+ * <header
+ *   onClick={(event) => {
+ *     if (args.isMultiSelectGroupingEnabled && isMultiSelectModifierActive(event)) {
+ *       event.preventDefault();
+ *       args.onToggleMultiSelect();
+ *     }
+ *   }}
+ * />
+ * ```
+ */
+declare function isMultiSelectModifierActive(event: MultiSelectModifierState): boolean;
+/**
+ * Immutably toggle `leafId` in `selection`: present → removed, absent → added.
+ * Returns a NEW `Set` (the input is never mutated). Insertion order is
+ * preserved for added ids, so the first-selected leaf remains the
+ * `group-leaves` anchor.
+ */
+declare function toggleLeafMultiSelection(selection: ReadonlySet<string>, leafId: string): Set<string>;
+/**
+ * Drop any selected id not present in `presentLeafIds` (the layout's current
+ * outer-slot leaf ids). Returns the SAME reference when nothing is pruned, so
+ * the caller can skip a state update; otherwise a new `Set` preserving the
+ * surviving ids in their original order.
+ */
+declare function pruneMultiSelection(selection: ReadonlySet<string>, presentLeafIds: ReadonlyArray<string>): Set<string>;
+/**
+ * Whether the current `selection` (in insertion order) can be folded into one
+ * group right now. Requires at least `MULTI_SELECT_GROUP_MIN_MEMBERS` ids AND
+ * that the existing `groupLeaves` op would actually change `layout` — which
+ * encodes the op's own constraint: the anchor (first id) must be a placeable
+ * slot (not already a group member) and at least two ids must resolve to leaves.
+ * A no-op `groupLeaves` (same reference back) means the selection is not
+ * groupable, so the Group control is suppressed rather than offered inert.
+ */
+declare function canGroupMultiSelection(layout: TilingLayoutNode, selection: ReadonlySet<string>): boolean;
+/**
+ * Resolve the HOST pane (the slot the merged group occupies + its active tab):
+ *
+ * - the explicit `clickedLeafId` (the pane whose Group button was pressed) when
+ *   it is part of the selection — the header-button path;
+ * - else (Alt+G, no click target) the `focusedLeafId` IF it is in the selection,
+ *   else the FIRST-selected pane (insertion order).
+ *
+ * Returns `null` when the selection is empty (nothing to host).
+ */
+declare function resolveMultiSelectGroupHost(selection: ReadonlySet<string>, clickedLeafId: string | null, focusedLeafId: string | null): string | null;
+/**
+ * The `group-leaves` command that folds the current `selection` (insertion
+ * order, expanded over any touched groups) into ONE flat tabbed group at the
+ * `hostLeafId` slot (host = active tab, listed first), or `null` when fewer than
+ * `MULTI_SELECT_GROUP_MIN_MEMBERS` are selected. When `hostLeafId` is omitted the
+ * op defaults the host to the first resolvable id. Dispatching the returned
+ * command is still gated by the `grouping` capability at the renderer's command
+ * router (a safe no-op when grouping is disabled).
+ */
+declare function resolveMultiSelectGroupCommand(selection: ReadonlySet<string>, hostLeafId?: string | null): TilingCommand | null;
+
+/**
+ * All-enabled defaults. An undefined capability config (or any undefined field)
+ * resolves to these via `resolveInteractionCapabilities`.
+ *
+ * The lone opt-IN exception is `paneSwitching.showContentToggle`: it defaults to
+ * `false`. That checkbox (a group tab strip's "show pane body" toggle) is a
+ * development / demo affordance — a consumer app renders its own pane content
+ * and never wants an end-user control that blanks it. Suppressed by default, the
+ * initial pane-content-visible flag pins ON (see `resolveInitialPaneContentVisible`),
+ * so panes paint their content at rest with no wiring. A tooling surface that
+ * genuinely wants the toggle (e.g. the interactive showcase) opts back in with
+ * `paneSwitching: { showContentToggle: true }`.
+ */
+declare const TILING_INTERACTION_CAPABILITY_DEFAULTS: ResolvedTilingInteractionCapabilities;
+/**
+ * Interaction preset for static (config-driven) product dashboards: only height
+ * dividers resize (`resize: "vertical"`), and every interactive surface that
+ * assumes a rearrangeable/maximizable lab layout is off (no drag-rearrange, no
+ * pane focus selection, no maximize, no pane switching / tab strip). Dashboards
+ * pass this instead of hand-repeating the disable set.
+ *
+ * Per-pane title-bar controls (sizing + acquire-space) are OFF here too:
+ * dashboards ship a curated layout with PRE-CONFIGURED static panes and are
+ * resize-only by intent, so letting an end-user re-pin a pane's bbox or have one
+ * pane absorb its siblings' space would fight the authored composition. End-user
+ * per-pane sizing belongs to interactive workspaces (the showcase default), not
+ * config-driven dashboards.
+ */
+declare const TILING_DASHBOARD_PRESET: TilingInteractionCapabilities;
+/**
+ * Single defaulting helper for `TilingInteractionCapabilities`. `undefined` /
+ * `null` → all enabled; a partial override merges field-by-field over the
+ * all-enabled defaults. Uses nullish coalescing so an explicit `false` (e.g.
+ * `rearrange: false`, `maximize.enable: false`) is preserved and never
+ * overridden by the default. Idempotent: re-resolving a resolved object yields
+ * the same result.
+ */
+declare function resolveInteractionCapabilities(capabilities?: TilingInteractionCapabilities | null): ResolvedTilingInteractionCapabilities;
+/**
+ * Pure capability gate for a single split divider. Maps the resize capability
+ * onto a split node's `axis` per the documented axis convention (see
+ * `TilingResizeCapability`): a split with `axis: "horizontal"` is a width
+ * divider (side-by-side panes), a split with `axis: "vertical"` is a height
+ * divider (stacked panes).
+ *
+ * - `"none"` → no divider resizes.
+ * - `"both"` → every divider resizes.
+ * - `"horizontal"` → only width dividers (split `axis === "horizontal"`).
+ * - `"vertical"` → only height dividers (split `axis === "vertical"`).
+ */
+declare function isResizeAxisEnabled(capability: TilingResizeCapability, splitAxis: TilingSplitAxis): boolean;
+
+/**
+ * Consumer-configurable drag easing — the pure resolution + validation half of
+ * the easing public-API surface (HT-ANIM-EASING-CONFIG).
+ *
+ * `DRAG_HOP_EASING` / `DRAG_REFLOW_EASING` used to be fixed module constants in
+ * the renderer (parity-report §5 #9 / §7: the one M10 remainder short of
+ * Hyprland's per-leaf `bezier`/`speed` config). They live here as defaults so
+ * the renderer can thread consumer-supplied CSS `<easing-function>` strings into
+ * the ghost-hop transit and the survivor FLIP reflow timing functions.
+ *
+ * This module is DOM-less and pure (the `node` jest environment runs it),
+ * mirroring how `ghost-transit.ts` / `survivor-reflow.ts` factor the FLIP
+ * GEOMETRY out of the renderer — but an easing STRING is a distinct rendering
+ * concern from FLIP geometry, so the resolver lives in its own module rather
+ * than muddying those geometry modules.
+ *
+ * Cross-ref: `_agent/command-keyboard-api-design.md` §5;
+ * `_agent/comparative-analysis/parity-report.md` §5 #9 / §7 (configurable easing
+ * remainder); `dynamic-tiling-renderer.tsx` (`DragPaneOverlay` hop + survivor
+ * FLIP effect consume the resolved strings).
+ */
+/** The default ghost hop / pickup / hop-out timing function (a snappy decel). */
+declare const DEFAULT_DRAG_HOP_EASING: string;
+/**
+ * The default survivor-reflow settle timing function. Equals the hop curve so
+ * the ghost and the survivors read as one coordinated motion (the renderer's
+ * `dragReflowEasing` prop falls back to the resolved `dragHopEasing` when
+ * undefined, so this default only applies when BOTH are unset).
+ */
+declare const DEFAULT_DRAG_REFLOW_EASING: string;
+/**
+ * Whether `value` is a syntactically-plausible CSS `<easing-function>`: one of
+ * the global keywords, or a `cubic-bezier(...)` / `linear(...)` / `steps(...)`
+ * functional form. This is a SHAPE check (not a full CSS parse) — enough to keep
+ * a malformed / empty string from reaching the compositor as a broken
+ * `transition`, without re-implementing the CSS grammar. Leading / trailing
+ * whitespace is ignored; matching is case-insensitive on the keyword / function
+ * name.
+ */
+declare function isCssEasing(value: string): boolean;
+/**
+ * Resolve a consumer-supplied easing to a usable CSS timing function: returns
+ * `value` when it is a plausible easing (`isCssEasing`), else `fallback`. An
+ * `undefined` / `null` / blank / malformed value collapses to the fallback, so
+ * the renderer always writes a valid `transition` timing function.
+ */
+declare function resolveDragEasing(value: string | undefined | null, fallback: string): string;
+
+export { resolveMultiSelectGroupHost as A, setLeafSizing as B, siblingSubtreeForLeaf as C, swapLeafTiles as D, tileOrderByLeafId as E, toggleLeafMultiSelection as F, type GroupLeavesOptions as G, toggleSplitAxis as H, ungroupNode as I, updateSplitRatio as J, DEFAULT_DRAG_HOP_EASING as K, DEFAULT_DRAG_REFLOW_EASING as L, MULTI_SELECT_GROUP_MIN_MEMBERS as M, type MultiSelectModifierState as N, TILING_DASHBOARD_PRESET as O, TILING_INTERACTION_CAPABILITY_DEFAULTS as P, type TilingCommandGates as Q, type TilingLayoutQuery as R, isCommandEnabled as S, TILING_KEYMAP_DEFAULTS as T, isMultiSelectModifierActive as U, queryTilingLayout as V, resolveInteractionCapabilities as W, resolveJumpedPaneId as X, type TilingKeymapActionGuards as a, chordRequiresModifier as b, canGroupMultiSelection as c, collectGroups as d, collectSplitNodes as e, commandRequiredCapability as f, findLeafByDirection as g, findLeafById as h, groupLeaves as i, hasAnyModifier as j, insertLeafAdjacent as k, isCssEasing as l, isResizeAxisEnabled as m, isStructurallyValidLayout as n, keyboardActionToCommand as o, matchKeyChord as p, matchKeymapAction as q, moveLeafToRoot as r, moveLeafToSplitContainer as s, pruneMultiSelection as t, readLeafNodeIds as u, removeLeafTile as v, resolveDragEasing as w, resolveKeymap as x, resolveMaximizeToggle as y, resolveMultiSelectGroupCommand as z };