sh3-core 0.6.0

package/dist/layout/SlotDropZone.svelte

@@ -0,0 +1,122 @@
+<script lang="ts">
+  /*
+   * SlotDropZone — an overlay covering a slot's body that, during a
+   * drag, reports 4-quadrant split-drop targets to the drag engine
+   * and draws a colored quadrant highlight matching the hovered side.
+   *
+   * Sits in the tab-body pane (for tab leaves) or directly over a
+   * standalone slot container. Does not intercept pointer events when
+   * no drag is active; during a drag, it captures pointermove to
+   * compute the hovered quadrant.
+   *
+   * Quadrant math:
+   *   The body is divided into 4 triangles meeting at the center, so
+   *   each triangle maps the nearest edge to a split side. Top → top
+   *   split (vertical, new tab above). Same for bottom / left / right.
+   *   The inner "center" region is deliberately absent in phase 6 —
+   *   we don't support "merge into same tabs group" via body drop,
+   *   only via strip drop. This keeps the UX unambiguous: body = split,
+   *   strip = merge.
+   */
+
+  import { dragState, setDropTarget, clearDropTarget, type DropTarget } from './drag.svelte';
+  import type { LayoutPath, SplitSide } from './ops';
+
+  let {
+    path,
+  }: {
+    /** Path of the node this zone covers, used when reporting the drop. */
+    path: LayoutPath;
+  } = $props();
+
+  let zoneEl: HTMLDivElement | undefined = $state();
+  let hoveredSide: SplitSide | null = $state(null);
+
+  // Don't capture pointer events unless a drag is in progress — otherwise
+  // the zone would shadow the slot's own interactions.
+  const active = $derived(dragState.phase === 'dragging');
+
+  function quadrantFor(x: number, y: number, rect: DOMRect): SplitSide {
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    const dx = x - cx;
+    const dy = y - cy;
+    // Triangles: compare which signed half-plane the point falls in,
+    // determined by the cell aspect ratio so the diagonals meet at the
+    // center regardless of shape.
+    const nx = dx / rect.width;
+    const ny = dy / rect.height;
+    if (Math.abs(nx) > Math.abs(ny)) {
+      return nx < 0 ? 'left' : 'right';
+    }
+    return ny < 0 ? 'top' : 'bottom';
+  }
+
+  function onMove(e: PointerEvent) {
+    if (!zoneEl) return;
+    const rect = zoneEl.getBoundingClientRect();
+    // If pointer is outside the zone (pointercapture from elsewhere),
+    // clear.
+    if (
+      e.clientX < rect.left ||
+      e.clientX > rect.right ||
+      e.clientY < rect.top ||
+      e.clientY > rect.bottom
+    ) {
+      if (hoveredSide !== null) {
+        hoveredSide = null;
+        clearDropTarget((t) => t.kind === 'split' && t.path.join('/') === path.join('/'));
+      }
+      return;
+    }
+    const side = quadrantFor(e.clientX, e.clientY, rect);
+    if (side !== hoveredSide) {
+      hoveredSide = side;
+      const target: DropTarget = { kind: 'split', path: [...path], side };
+      setDropTarget(target);
+    }
+  }
+
+  function onLeave() {
+    if (hoveredSide !== null) {
+      hoveredSide = null;
+      clearDropTarget((t) => t.kind === 'split' && t.path.join('/') === path.join('/'));
+    }
+  }
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
+  class="slot-drop-zone"
+  class:active
+  bind:this={zoneEl}
+  onpointermove={onMove}
+  onpointerleave={onLeave}
+>
+  {#if hoveredSide}
+    <div class="quad-highlight quad-{hoveredSide}"></div>
+  {/if}
+</div>
+
+<style>
+  .slot-drop-zone {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+  }
+  .slot-drop-zone.active {
+    pointer-events: auto;
+  }
+  .quad-highlight {
+    position: absolute;
+    background: var(--shell-accent);
+    opacity: 0.18;
+    border: 1px dashed var(--shell-accent);
+    pointer-events: none;
+    transition: inset 80ms ease;
+  }
+  .quad-highlight.quad-left   { top: 0; bottom: 0; left: 0; right: 50%; }
+  .quad-highlight.quad-right  { top: 0; bottom: 0; left: 50%; right: 0; }
+  .quad-highlight.quad-top    { left: 0; right: 0; top: 0; bottom: 50%; }
+  .quad-highlight.quad-bottom { left: 0; right: 0; top: 50%; bottom: 0; }
+</style>

package/dist/layout/SlotDropZone.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { LayoutPath } from './ops';
+type $$ComponentProps = {
+    /** Path of the node this zone covers, used when reporting the drop. */
+    path: LayoutPath;
+};
+declare const SlotDropZone: import("svelte").Component<$$ComponentProps, {}, "">;
+type SlotDropZone = ReturnType<typeof SlotDropZone>;
+export default SlotDropZone;

package/dist/layout/drag.svelte.d.ts

@@ -0,0 +1,45 @@
+import type { TabEntry, TabsNode } from './types';
+import { type LayoutPath, type SplitSide } from './ops';
+export type DropTarget = {
+    kind: 'strip';
+    tabsNode: TabsNode;
+    /** Insertion index within tabsNode.tabs (0..length). */
+    insertIndex: number;
+} | {
+    kind: 'split';
+    path: LayoutPath;
+    side: SplitSide;
+};
+interface DragSource {
+    slotId: string;
+    entry: TabEntry;
+    /** The tab's viewport rect at drag start — used to offset the ghost. */
+    startRect: DOMRect;
+    /** Pointer offset inside the tab at drag start. */
+    offsetX: number;
+    offsetY: number;
+}
+interface DragState {
+    phase: 'idle' | 'pending' | 'dragging';
+    source: DragSource | null;
+    pointerX: number;
+    pointerY: number;
+    target: DropTarget | null;
+}
+export declare const dragState: DragState;
+export declare function suppressNextClick(): boolean;
+/**
+ * Begin a potential tab drag. Call from pointerdown on a tab element.
+ * This does not yet enter the dragging phase — movement past the
+ * threshold is required.
+ */
+export declare function beginTabDrag(slotId: string, entry: TabEntry, event: PointerEvent, tabElement: HTMLElement): void;
+/**
+ * Called by drop zone components when the pointer is over them. The
+ * last call wins, so innermost / most-specific zones should call this
+ * on pointermove over their geometry. `clearDropTarget` is called when
+ * the pointer leaves.
+ */
+export declare function setDropTarget(target: DropTarget): void;
+export declare function clearDropTarget(match?: (target: DropTarget) => boolean): void;
+export {};

package/dist/layout/drag.svelte.js

@@ -0,0 +1,200 @@
+/*
+ * Tab drag engine — state machine + global listeners + commit.
+ *
+ * Lifecycle:
+ *   1. TabbedPanel fires `beginTabDrag(slotId, entry, pointerEvent)`
+ *      from pointerdown on a tab. The engine records the starting
+ *      pointer position and the source slotId but does NOT enter the
+ *      "dragging" phase yet.
+ *   2. A global pointermove listener watches for movement exceeding
+ *      DRAG_THRESHOLD_PX. Clicks that never cross the threshold are
+ *      not drags — they fall through to the tab's own click handler.
+ *   3. On threshold cross, the engine transitions to `dragging` and
+ *      starts tracking the pointer; the status (visible ghost, drop
+ *      indicators) is driven by the reactive state.
+ *   4. pointerup commits a drop target (if one is currently hovered)
+ *      and tears down. No commit if the user released over nothing.
+ *
+ * State shape:
+ *   The engine exposes a single `dragState` $state object. Components
+ *   subscribe by reading its fields in a $derived or $effect. The
+ *   fields:
+ *     - phase: 'idle' | 'pending' | 'dragging'
+ *     - source: { slotId, entry } | null
+ *     - pointer: { x, y } current viewport coords while dragging
+ *     - target: DropTarget | null — where the commit would land now
+ *
+ * Drop targets:
+ *   Two kinds:
+ *     { kind: 'strip', tabsNode, insertIndex } — between tabs in a strip
+ *     { kind: 'split', path, side } — quadrant split of a node at path
+ *   The owning components compute these from their bounding rects and
+ *   call `setDropTarget` / `clearDropTarget` when the pointer enters /
+ *   leaves. Multiple overlapping targets: the one most recently set
+ *   wins (innermost component takes priority because it fires last).
+ *
+ * Commit:
+ *   `commit()` is called on pointerup. It looks at dragState.target
+ *   and runs the appropriate ops mutation against the shared root.
+ *   The root is handed to the engine on init (via `initDragEngine`)
+ *   because the engine is a module-level singleton and the root comes
+ *   from the composition layer.
+ */
+import { cleanupTree, insertTabIntoTabs, moveTabWithinTabs, removeTabBySlotId, splitNodeAtPath, } from './ops';
+import { layoutStore } from './store.svelte';
+export const dragState = $state({
+    phase: 'idle',
+    source: null,
+    pointerX: 0,
+    pointerY: 0,
+    target: null,
+});
+/**
+ * True for exactly one macrotask after a drag ends, so the synthetic
+ * `click` the browser fires on the original tab (right after
+ * pointerup) can be ignored. Consumers check `suppressNextClick()` at
+ * the top of their click handler. Without this, the stale click would
+ * call the tab's `select(i)` on an index that no longer maps to the
+ * same tab after the layout mutation.
+ */
+let clickSuppressedUntil = 0;
+export function suppressNextClick() {
+    return performance.now() < clickSuppressedUntil;
+}
+const DRAG_THRESHOLD_PX = 4;
+let pendingStartX = 0;
+let pendingStartY = 0;
+/**
+ * Begin a potential tab drag. Call from pointerdown on a tab element.
+ * This does not yet enter the dragging phase — movement past the
+ * threshold is required.
+ */
+export function beginTabDrag(slotId, entry, event, tabElement) {
+    if (dragState.phase !== 'idle')
+        return;
+    const rect = tabElement.getBoundingClientRect();
+    dragState.phase = 'pending';
+    dragState.source = {
+        slotId,
+        entry,
+        startRect: rect,
+        offsetX: event.clientX - rect.left,
+        offsetY: event.clientY - rect.top,
+    };
+    dragState.pointerX = event.clientX;
+    dragState.pointerY = event.clientY;
+    dragState.target = null;
+    pendingStartX = event.clientX;
+    pendingStartY = event.clientY;
+    installGlobalListeners();
+}
+function installGlobalListeners() {
+    window.addEventListener('pointermove', onPointerMove, true);
+    window.addEventListener('pointerup', onPointerUp, true);
+    window.addEventListener('pointercancel', onPointerCancel, true);
+    // Lock selection / text caret during drag. Restored in teardown.
+    document.body.style.userSelect = 'none';
+    // Signal to non-drag-aware components that a drag is in progress,
+    // so they can suppress misleading hover states via CSS.
+    document.body.dataset.dragging = '';
+}
+function removeGlobalListeners() {
+    window.removeEventListener('pointermove', onPointerMove, true);
+    window.removeEventListener('pointerup', onPointerUp, true);
+    window.removeEventListener('pointercancel', onPointerCancel, true);
+    document.body.style.userSelect = '';
+    delete document.body.dataset.dragging;
+}
+function onPointerMove(e) {
+    dragState.pointerX = e.clientX;
+    dragState.pointerY = e.clientY;
+    if (dragState.phase === 'pending') {
+        const dx = e.clientX - pendingStartX;
+        const dy = e.clientY - pendingStartY;
+        if (dx * dx + dy * dy >= DRAG_THRESHOLD_PX * DRAG_THRESHOLD_PX) {
+            dragState.phase = 'dragging';
+        }
+    }
+}
+function onPointerUp(_e) {
+    const wasDragging = dragState.phase === 'dragging';
+    if (wasDragging) {
+        commit();
+        // Swallow the synthetic click that fires on the source tab
+        // immediately after pointerup. A few ms is plenty — the click
+        // is dispatched synchronously or on the next microtask.
+        clickSuppressedUntil = performance.now() + 50;
+    }
+    teardown();
+}
+function onPointerCancel(_e) {
+    teardown();
+}
+function commit() {
+    const { source, target } = dragState;
+    if (!source || !target)
+        return;
+    const root = layoutStore.root;
+    // Same-group strip drop: atomic move. The two-step remove/insert
+    // flow splices the reactive tabs array twice; splice's internal
+    // `[[Delete]]` trips Svelte's proxy deleteProperty trap, which can
+    // flush reactive consumers while the array is transiently length
+    // `N - 1`. A LayoutRenderer `$derived` evaluated in that window
+    // sees the shrunk array and the index-`N - 1` snippet body reads an
+    // `undefined` entry — which crashes at `.slotId`. `moveTabWithinTabs`
+    // avoids the intermediate state by building the next array off-proxy
+    // and reassigning `tabs` in one shot. See the helper's doc comment.
+    //
+    // LayoutRenderer's `onStripHover` normalizes the insert index for
+    // same-strip drags into post-removal coordinates, so we can pass
+    // `target.insertIndex` straight through.
+    if (target.kind === 'strip') {
+        const srcIdx = target.tabsNode.tabs.findIndex((t) => t.slotId === source.slotId);
+        if (srcIdx >= 0) {
+            moveTabWithinTabs(target.tabsNode, srcIdx, target.insertIndex);
+            cleanupTree(root);
+            return;
+        }
+    }
+    // Cross-group strip drop or split drop: remove from source, then
+    // insert into destination (or split target into a new group). The
+    // destination's tabs array only grows in the strip case, so no
+    // observer sees a shrunk intermediate — the splice-based flow is
+    // fine here.
+    const removed = removeTabBySlotId(root, source.slotId);
+    if (!removed)
+        return;
+    if (target.kind === 'strip') {
+        insertTabIntoTabs(target.tabsNode, removed, target.insertIndex);
+    }
+    else {
+        splitNodeAtPath(root, target.path, removed, target.side);
+    }
+    cleanupTree(root);
+}
+function teardown() {
+    dragState.phase = 'idle';
+    dragState.source = null;
+    dragState.target = null;
+    removeGlobalListeners();
+}
+/**
+ * Called by drop zone components when the pointer is over them. The
+ * last call wins, so innermost / most-specific zones should call this
+ * on pointermove over their geometry. `clearDropTarget` is called when
+ * the pointer leaves.
+ */
+export function setDropTarget(target) {
+    if (dragState.phase !== 'dragging')
+        return;
+    dragState.target = target;
+}
+export function clearDropTarget(match) {
+    if (dragState.phase !== 'dragging')
+        return;
+    if (!dragState.target)
+        return;
+    if (match && !match(dragState.target))
+        return;
+    dragState.target = null;
+}

package/dist/layout/inspection.d.ts

@@ -0,0 +1,72 @@
+import type { LayoutNode, TabEntry } from './types';
+/**
+ * Read-only snapshot of the currently-rendered layout tree. The return
+ * value is the live object — callers MUST NOT mutate it directly;
+ * mutations go through `spliceIntoActiveLayout`. Returning the live
+ * object (not a deep clone) means reactive consumers can re-read on
+ * updates without manual subscription wiring.
+ */
+export declare function inspectActiveLayout(): {
+    root: LayoutNode;
+    source: 'home' | 'app';
+};
+/**
+ * Add a new tab at the end of the first tabs group found in the
+ * currently-rendered layout. If no tabs group exists (e.g. the active
+ * root is the single-slot home layout), throws. Phase 8 scope — richer
+ * variants arrive later.
+ */
+export declare function spliceIntoActiveLayout(entry: TabEntry): void;
+/**
+ * Activate the tab whose slot matches `slotId` in the currently-rendered
+ * layout. Returns `true` if a matching tab was found and activated.
+ */
+export declare function focusTab(slotId: string): boolean;
+/**
+ * Activate the first tab whose `viewId` matches in the currently-rendered
+ * layout. Returns `true` if a matching tab was found and activated.
+ */
+export declare function focusView(viewId: string): boolean;
+/**
+ * Collapse a child of a split node at the given path. Returns true if
+ * the split was found and the child was collapsed.
+ */
+export declare function collapseChild(splitPath: number[], childIndex: number): boolean;
+/**
+ * Expand a previously collapsed child of a split node. Returns true if
+ * the split was found and the child was expanded.
+ */
+export declare function expandChild(splitPath: number[], childIndex: number): boolean;
+/**
+ * Request to close a tab by its slot ID. Respects the view's closable
+ * policy:
+ *   - Non-closable (closable undefined/false): returns false immediately.
+ *   - Pure (closable true): removes the tab, returns true.
+ *   - Guarded (closable { canClose }): awaits canClose(); removes if
+ *     resolved true, returns false if resolved false.
+ *
+ * This is the single entry point for closing tabs — the tab strip's X
+ * button and programmatic callers both use it. The layout engine remains
+ * the sole authority on tree mutations.
+ */
+export declare function closeTab(slotId: string): Promise<boolean>;
+/**
+ * Dock a view into the currently-rendered layout without caring which
+ * root it is. Used by the Ctrl+` shell hotkey and other "just put it
+ * somewhere sensible" callers. Policy:
+ *
+ *   1. If a tab with the same `viewId` already exists, focus it and
+ *      return. Callers don't want a second instance of a singleton view
+ *      every time they hit the shortcut.
+ *   2. Otherwise, append the entry to the first tabs group found
+ *      (`spliceIntoActiveLayout` semantics).
+ *   3. If there's no tabs group (e.g. the home root is a single slot),
+ *      split the first slot leaf horizontally and put the entry on the
+ *      right. This is the "floating window" fallback described in
+ *      roadmap SH9 / DF3 — when floating panels land, callers should
+ *      prefer that path for ephemeral docks.
+ *
+ * Returns true if the view was focused or inserted, false if the layout
+ * was empty or otherwise un-dockable.
+ */
+export declare function dockIntoActiveLayout(entry: TabEntry): boolean;

package/dist/layout/inspection.js

@@ -0,0 +1,209 @@
+/*
+ * Layout inspection / mutation — public API for advanced shards.
+ *
+ * These helpers are how shards like `diagnostic` inject themselves into
+ * the currently-rendered layout. The mutation primitives delegate to
+ * ops.ts for the actual tree work; inspection reads through the layout
+ * manager so diagnostic content stays live as the user rearranges things.
+ *
+ * Scope note: `spliceIntoActiveLayout` targets the CURRENTLY-RENDERED
+ * root only. Mutating a held-but-not-active app tree (e.g. while the
+ * user is on home) is not supported in phase 8. If an advanced shard
+ * wants to reach the held tree, it has to do so while the app is
+ * rendered.
+ */
+import { activeLayout, getActiveRoot } from './store.svelte';
+import { nodeAtPath, findTabBySlotId, removeTabBySlotId, cleanupTree, splitNodeAtPath, } from './ops';
+import { getSlotHandle } from './slotHostPool.svelte';
+/**
+ * Read-only snapshot of the currently-rendered layout tree. The return
+ * value is the live object — callers MUST NOT mutate it directly;
+ * mutations go through `spliceIntoActiveLayout`. Returning the live
+ * object (not a deep clone) means reactive consumers can re-read on
+ * updates without manual subscription wiring.
+ */
+export function inspectActiveLayout() {
+    return { root: activeLayout(), source: getActiveRoot() };
+}
+/**
+ * Add a new tab at the end of the first tabs group found in the
+ * currently-rendered layout. If no tabs group exists (e.g. the active
+ * root is the single-slot home layout), throws. Phase 8 scope — richer
+ * variants arrive later.
+ */
+export function spliceIntoActiveLayout(entry) {
+    const root = activeLayout();
+    const target = findFirstTabsNode(root);
+    if (!target) {
+        throw new Error('spliceIntoActiveLayout: no tabs group found in the active layout; ' +
+            'phase 8 only supports splicing into an existing tab group.');
+    }
+    target.tabs.push(entry);
+    target.activeTab = target.tabs.length - 1;
+}
+/**
+ * Activate the tab whose slot matches `slotId` in the currently-rendered
+ * layout. Returns `true` if a matching tab was found and activated.
+ */
+export function focusTab(slotId) {
+    const root = activeLayout();
+    return focusTabWhere(root, (entry) => entry.slotId === slotId);
+}
+/**
+ * Activate the first tab whose `viewId` matches in the currently-rendered
+ * layout. Returns `true` if a matching tab was found and activated.
+ */
+export function focusView(viewId) {
+    const root = activeLayout();
+    return focusTabWhere(root, (entry) => entry.viewId === viewId);
+}
+/** Walk the tree looking for a tab entry that satisfies `pred`, activate it. */
+function focusTabWhere(node, pred) {
+    if (node.type === 'tabs') {
+        const idx = node.tabs.findIndex(pred);
+        if (idx >= 0) {
+            node.activeTab = idx;
+            return true;
+        }
+        return false;
+    }
+    if (node.type === 'split') {
+        for (const child of node.children) {
+            if (focusTabWhere(child, pred))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Collapse a child of a split node at the given path. Returns true if
+ * the split was found and the child was collapsed.
+ */
+export function collapseChild(splitPath, childIndex) {
+    return setCollapsed(splitPath, childIndex, true);
+}
+/**
+ * Expand a previously collapsed child of a split node. Returns true if
+ * the split was found and the child was expanded.
+ */
+export function expandChild(splitPath, childIndex) {
+    return setCollapsed(splitPath, childIndex, false);
+}
+function setCollapsed(splitPath, childIndex, value) {
+    const root = activeLayout();
+    const node = nodeAtPath(root, splitPath);
+    if (!node || node.type !== 'split')
+        return false;
+    const split = node;
+    if (childIndex < 0 || childIndex >= split.children.length)
+        return false;
+    if (!split.collapsed)
+        split.collapsed = split.children.map(() => false);
+    split.collapsed[childIndex] = value;
+    return true;
+}
+/**
+ * Request to close a tab by its slot ID. Respects the view's closable
+ * policy:
+ *   - Non-closable (closable undefined/false): returns false immediately.
+ *   - Pure (closable true): removes the tab, returns true.
+ *   - Guarded (closable { canClose }): awaits canClose(); removes if
+ *     resolved true, returns false if resolved false.
+ *
+ * This is the single entry point for closing tabs — the tab strip's X
+ * button and programmatic callers both use it. The layout engine remains
+ * the sole authority on tree mutations.
+ */
+export async function closeTab(slotId) {
+    const root = activeLayout();
+    const located = findTabBySlotId(root, slotId);
+    if (!located)
+        return false;
+    const handle = getSlotHandle(slotId);
+    const closable = handle === null || handle === void 0 ? void 0 : handle.closable;
+    // Non-closable: no action.
+    if (!closable)
+        return false;
+    // Guarded: ask the shard.
+    if (typeof closable === 'object') {
+        const allowed = await closable.canClose();
+        if (!allowed)
+            return false;
+        // Re-verify the tab still exists after the async gap — another close
+        // request or a layout mutation may have removed it while we awaited.
+        if (!findTabBySlotId(root, slotId))
+            return false;
+    }
+    // Remove the tab from the tree. This causes Svelte to tear down the
+    // SlotContainer, which calls releaseSlotHost() — the pool's deferred
+    // destroy microtask then fires handle.unmount(). We do NOT call
+    // releaseSlotHost here; the existing component lifecycle handles it.
+    removeTabBySlotId(root, slotId);
+    // Cleanup: prune empty (non-persistent) tab groups, collapse single-child splits.
+    cleanupTree(root);
+    return true;
+}
+function findFirstTabsNode(node) {
+    if (node.type === 'tabs')
+        return node;
+    if (node.type === 'split') {
+        for (const c of node.children) {
+            const hit = findFirstTabsNode(c);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/** Find the path to the first slot leaf with a bound viewId. */
+function findFirstSlotPath(node, path = []) {
+    if (node.type === 'slot')
+        return node.viewId !== null ? path : null;
+    if (node.type === 'split') {
+        for (let i = 0; i < node.children.length; i++) {
+            const hit = findFirstSlotPath(node.children[i], [...path, i]);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/**
+ * Dock a view into the currently-rendered layout without caring which
+ * root it is. Used by the Ctrl+` shell hotkey and other "just put it
+ * somewhere sensible" callers. Policy:
+ *
+ *   1. If a tab with the same `viewId` already exists, focus it and
+ *      return. Callers don't want a second instance of a singleton view
+ *      every time they hit the shortcut.
+ *   2. Otherwise, append the entry to the first tabs group found
+ *      (`spliceIntoActiveLayout` semantics).
+ *   3. If there's no tabs group (e.g. the home root is a single slot),
+ *      split the first slot leaf horizontally and put the entry on the
+ *      right. This is the "floating window" fallback described in
+ *      roadmap SH9 / DF3 — when floating panels land, callers should
+ *      prefer that path for ephemeral docks.
+ *
+ * Returns true if the view was focused or inserted, false if the layout
+ * was empty or otherwise un-dockable.
+ */
+export function dockIntoActiveLayout(entry) {
+    var _a;
+    const root = activeLayout();
+    // 1. Already present? Focus it.
+    if (focusView((_a = entry.viewId) !== null && _a !== void 0 ? _a : ''))
+        return true;
+    // 2. Existing tabs group wins.
+    const tabs = findFirstTabsNode(root);
+    if (tabs) {
+        tabs.tabs.push(entry);
+        tabs.activeTab = tabs.tabs.length - 1;
+        return true;
+    }
+    // 3. Fallback: split the first valid slot leaf.
+    const slotPath = findFirstSlotPath(root);
+    if (!slotPath)
+        return false;
+    splitNodeAtPath(root, slotPath, entry, 'right');
+    return true;
+}