sh3-core 0.6.0 → 0.7.1

package/dist/env/client.d.ts

@@ -18,9 +18,17 @@ export declare function fetchEnvState(shardId: string): Promise<Record<string, u
 export declare function putEnvState(shardId: string, state: Record<string, unknown>): Promise<void>;
 /**
  * Install a package on the server via multipart upload.
- * The client has already fetched and integrity-verified the bundle.
+ * The client has already fetched and integrity-verified the client bundle
+ * (and the server bundle, if present and serverIntegrity was declared).
+ *
+ * @param manifest - Package manifest metadata to persist server-side.
+ * @param clientBundle - Verified client ESM bundle bytes.
+ * @param serverBundle - Optional verified server ESM bundle bytes. When
+ *   provided, the server writes it to `server.js` and hot-mounts the
+ *   shard's routes. If the mount fails, the entire install is rolled
+ *   back server-side.
  */
-export declare function serverInstallPackage(manifest: Record<string, unknown>, clientBundle: ArrayBuffer): Promise<{
+export declare function serverInstallPackage(manifest: Record<string, unknown>, clientBundle: ArrayBuffer, serverBundle?: ArrayBuffer): Promise<{
     ok: boolean;
     id: string;
     error?: string;

package/dist/env/client.js

@@ -50,9 +50,17 @@ export async function putEnvState(shardId, state) {
 }
 /**
  * Install a package on the server via multipart upload.
- * The client has already fetched and integrity-verified the bundle.
+ * The client has already fetched and integrity-verified the client bundle
+ * (and the server bundle, if present and serverIntegrity was declared).
+ *
+ * @param manifest - Package manifest metadata to persist server-side.
+ * @param clientBundle - Verified client ESM bundle bytes.
+ * @param serverBundle - Optional verified server ESM bundle bytes. When
+ *   provided, the server writes it to `server.js` and hot-mounts the
+ *   shard's routes. If the mount fails, the entire install is rolled
+ *   back server-side.
  */
-export async function serverInstallPackage(manifest, clientBundle) {
+export async function serverInstallPackage(manifest, clientBundle, serverBundle) {
     var _a;
     if (!isAdmin())
         throw new Error('Cannot install: not elevated to admin');
@@ -60,6 +68,9 @@ export async function serverInstallPackage(manifest, clientBundle) {
     const form = new FormData();
     form.append('manifest', new Blob([JSON.stringify(manifest)], { type: 'application/json' }), 'manifest.json');
     form.append('client', new Blob([clientBundle], { type: 'application/javascript' }), 'client.js');
+    if (serverBundle !== undefined) {
+        form.append('server', new Blob([serverBundle], { type: 'application/javascript' }), 'server.js');
+    }
     const headers = {};
     if (auth)
         headers['Authorization'] = auth;

package/dist/layout/LayoutRenderer.svelte

@@ -26,7 +26,7 @@
    * path via `[...path, i]`.
    */
 
-  import type { TabsNode, LayoutNode } from './types';
+  import type { TabsNode, LayoutNode, TreeRootRef } from './types';
   import ResizableSplitter from '../primitives/ResizableSplitter.svelte';
   import TabbedPanel, { type TabDragController } from '../primitives/TabbedPanel.svelte';
   import SlotContainer from './SlotContainer.svelte';
@@ -44,7 +44,10 @@
     suppressNextClick,
   } from './drag.svelte';
 
-  let { path = [] }: { path?: number[] } = $props();
+  let {
+    path = [],
+    rootRef = { kind: 'docked' } as TreeRootRef,
+  }: { path?: number[]; rootRef?: TreeRootRef } = $props();
 
   /**
    * Resolve the current node by walking `layoutStore.root` along the
@@ -53,7 +56,16 @@
    * cleanup pass can collapse nodes out from under a recursive
    * renderer), we render null.
    */
-  const node = $derived(nodeAtPath(layoutStore.root, path));
+  const node = $derived.by(() => {
+    let rootNode: LayoutNode | null;
+    if (rootRef.kind === 'docked') {
+      rootNode = layoutStore.root;
+    } else {
+      const entry = layoutStore.tree.floats.find((f) => f.id === rootRef.floatId);
+      rootNode = entry?.content ?? null;
+    }
+    return rootNode ? nodeAtPath(rootNode, path) : null;
+  });
 
   /**
    * Build a TabDragController bound to the current tabs node.
@@ -68,7 +80,7 @@
       onPointerDown(index, event, element) {
         const entry = tabsNode.tabs[index];
         if (!entry) return;
-        beginTabDrag(entry.slotId, entry, event, element);
+        beginTabDrag(entry.slotId, entry, rootRef, event, element);
       },
       onStripHover(stripRect, pointerX, pointerY, tabRects) {
         if (pointerY < stripRect.top || pointerY > stripRect.bottom) {
@@ -92,7 +104,7 @@
           const srcIdx = tabsNode.tabs.findIndex((t) => t.slotId === source.slotId);
           if (srcIdx >= 0 && srcIdx < insertIndex) insertIndex -= 1;
         }
-        setDropTarget({ kind: 'strip', tabsNode, insertIndex });
+        setDropTarget({ kind: 'strip', root: rootRef, tabsNode, insertIndex });
         return insertIndex;
       },
       onStripLeave() {
@@ -141,7 +153,7 @@
    */
   function onEmptyTabsDrop(_e: PointerEvent, tabsNode: import('./types').TabsNode) {
     if (dragState.phase !== 'dragging') return;
-    setDropTarget({ kind: 'strip', tabsNode, insertIndex: 0 });
+    setDropTarget({ kind: 'strip', root: rootRef, tabsNode, insertIndex: 0 });
   }
 
   function onEmptyTabsLeave() {
@@ -166,7 +178,7 @@
       }}
     />
     {#snippet splitPane(i: number)}
-      <Self path={[...path, i]} />
+      <Self {rootRef} path={[...path, i]} />
     {/snippet}
   {:else if node.type === 'tabs'}
     {@const tabs = asTabs(node)}
@@ -189,7 +201,7 @@
         {#if entry}
           <div class="tab-slot-wrapper">
             <SlotContainer node={{ type: 'slot', slotId: entry.slotId, viewId: entry.viewId }} label={entry.label} />
-            <SlotDropZone path={path} />
+            <SlotDropZone {rootRef} path={path} />
           </div>
         {/if}
       {/snippet}
@@ -213,7 +225,7 @@
     {@const slot = asSlot(node)!}
     <div class="leaf-slot-wrapper">
       <SlotContainer node={slot} />
-      <SlotDropZone path={path} />
+      <SlotDropZone {rootRef} path={path} />
     </div>
   {/if}
 {/if}

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

@@ -1,5 +1,7 @@
+import type { TreeRootRef } from './types';
 type $$ComponentProps = {
     path?: number[];
+    rootRef?: TreeRootRef;
 };
 declare const LayoutRenderer: import("svelte").Component<$$ComponentProps, {}, "">;
 type LayoutRenderer = ReturnType<typeof LayoutRenderer>;

package/dist/layout/SlotDropZone.svelte

@@ -21,10 +21,13 @@
 
   import { dragState, setDropTarget, clearDropTarget, type DropTarget } from './drag.svelte';
   import type { LayoutPath, SplitSide } from './ops';
+  import type { TreeRootRef } from './types';
 
   let {
+    rootRef,
     path,
   }: {
+    rootRef: TreeRootRef;
     /** Path of the node this zone covers, used when reporting the drop. */
     path: LayoutPath;
   } = $props();
@@ -72,7 +75,7 @@
     const side = quadrantFor(e.clientX, e.clientY, rect);
     if (side !== hoveredSide) {
       hoveredSide = side;
-      const target: DropTarget = { kind: 'split', path: [...path], side };
+      const target: DropTarget = { kind: 'split', root: rootRef, path: [...path], side };
       setDropTarget(target);
     }
   }

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

@@ -1,5 +1,7 @@
 import type { LayoutPath } from './ops';
+import type { TreeRootRef } from './types';
 type $$ComponentProps = {
+    rootRef: TreeRootRef;
     /** Path of the node this zone covers, used when reporting the drop. */
     path: LayoutPath;
 };

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

@@ -1,18 +1,21 @@
-import type { TabEntry, TabsNode } from './types';
+import type { TabEntry, TabsNode, TreeRootRef } from './types';
 import { type LayoutPath, type SplitSide } from './ops';
 export type DropTarget = {
     kind: 'strip';
+    root: TreeRootRef;
     tabsNode: TabsNode;
     /** Insertion index within tabsNode.tabs (0..length). */
     insertIndex: number;
 } | {
     kind: 'split';
+    root: TreeRootRef;
     path: LayoutPath;
     side: SplitSide;
 };
 interface DragSource {
     slotId: string;
     entry: TabEntry;
+    sourceRoot: TreeRootRef;
     /** The tab's viewport rect at drag start — used to offset the ghost. */
     startRect: DOMRect;
     /** Pointer offset inside the tab at drag start. */
@@ -33,7 +36,7 @@ export declare function suppressNextClick(): boolean;
  * 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;
+export declare function beginTabDrag(slotId: string, entry: TabEntry, sourceRoot: TreeRootRef, 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

package/dist/layout/drag.svelte.js

@@ -42,6 +42,7 @@
  */
 import { cleanupTree, insertTabIntoTabs, moveTabWithinTabs, removeTabBySlotId, splitNodeAtPath, } from './ops';
 import { layoutStore } from './store.svelte';
+import { isEmptyContent } from './floats';
 export const dragState = $state({
     phase: 'idle',
     source: null,
@@ -69,7 +70,7 @@ let pendingStartY = 0;
  * This does not yet enter the dragging phase — movement past the
  * threshold is required.
  */
-export function beginTabDrag(slotId, entry, event, tabElement) {
+export function beginTabDrag(slotId, entry, sourceRoot, event, tabElement) {
     if (dragState.phase !== 'idle')
         return;
     const rect = tabElement.getBoundingClientRect();
@@ -77,6 +78,7 @@ export function beginTabDrag(slotId, entry, event, tabElement) {
     dragState.source = {
         slotId,
         entry,
+        sourceRoot,
         startRect: rect,
         offsetX: event.clientX - rect.left,
         offsetY: event.clientY - rect.top,
@@ -130,11 +132,38 @@ function onPointerUp(_e) {
 function onPointerCancel(_e) {
     teardown();
 }
+function rootNode(ref) {
+    const tree = layoutStore.tree;
+    if (ref.kind === 'docked')
+        return tree.docked;
+    const f = tree.floats.find((e) => e.id === ref.floatId);
+    return f ? f.content : null;
+}
+/**
+ * If `ref` points at a float whose content is now empty (no bound leaf
+ * slots), remove the float from the tree. No-op for docked refs and for
+ * floats that still contain a bound view. Called after a commit that
+ * removed a tab from a float's content.
+ */
+function autoCloseEmptyFloat(ref) {
+    if (ref.kind !== 'float')
+        return;
+    const tree = layoutStore.tree;
+    const idx = tree.floats.findIndex((f) => f.id === ref.floatId);
+    if (idx < 0)
+        return;
+    if (isEmptyContent(tree.floats[idx].content)) {
+        tree.floats.splice(idx, 1);
+    }
+}
 function commit() {
     const { source, target } = dragState;
     if (!source || !target)
         return;
-    const root = layoutStore.root;
+    const sourceRoot = rootNode(source.sourceRoot);
+    const targetRoot = rootNode(target.root);
+    if (!sourceRoot || !targetRoot)
+        return;
     // 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
@@ -152,25 +181,28 @@ function commit() {
         const srcIdx = target.tabsNode.tabs.findIndex((t) => t.slotId === source.slotId);
         if (srcIdx >= 0) {
             moveTabWithinTabs(target.tabsNode, srcIdx, target.insertIndex);
-            cleanupTree(root);
+            cleanupTree(sourceRoot);
+            if (targetRoot !== sourceRoot)
+                cleanupTree(targetRoot);
+            autoCloseEmptyFloat(source.sourceRoot);
             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);
+    // Cross-group strip drop or split drop: remove from SOURCE root, then
+    // insert/split into the target.
+    const removed = removeTabBySlotId(sourceRoot, source.slotId);
     if (!removed)
         return;
     if (target.kind === 'strip') {
         insertTabIntoTabs(target.tabsNode, removed, target.insertIndex);
     }
     else {
-        splitNodeAtPath(root, target.path, removed, target.side);
+        splitNodeAtPath(targetRoot, target.path, removed, target.side);
     }
-    cleanupTree(root);
+    cleanupTree(sourceRoot);
+    if (targetRoot !== sourceRoot)
+        cleanupTree(targetRoot);
+    autoCloseEmptyFloat(source.sourceRoot);
 }
 function teardown() {
     dragState.phase = 'idle';

package/dist/layout/floats.d.ts

@@ -0,0 +1,35 @@
+import type { LayoutNode, FloatEntry } from './types';
+export declare const DEFAULT_SLOT_MIN: {
+    readonly w: 120;
+    readonly h: 80;
+};
+export interface Size {
+    w: number;
+    h: number;
+}
+export declare function computeMinSize(node: LayoutNode): Size;
+/**
+ * Given the list of currently-open floats, return the position a new
+ * float should appear at. Each new float offsets (+32, +32) from the
+ * most recently opened one. If the resulting position would push the
+ * float's header outside `bounds`, wraps back to CASCADE_BASE.
+ */
+export declare function cascadePosition(existing: FloatEntry[], bounds: {
+    w: number;
+    h: number;
+}): {
+    x: number;
+    y: number;
+};
+/** Stable, process-unique float id. Not cryptographic — just unique within a session. */
+export declare function generateFloatId(): string;
+/**
+ * True if a LayoutNode subtree contains no leaf slot with a bound viewId.
+ * Used by the drag-commit auto-close invariant: when the last bound leaf
+ * leaves a float, the float is removed from the tree.
+ *
+ * A tabs node with zero tabs is empty. A split node is empty iff every
+ * child is empty. Only leaf slots with a non-null viewId are considered
+ * "filled".
+ */
+export declare function isEmptyContent(node: LayoutNode): boolean;

package/dist/layout/floats.js

@@ -0,0 +1,73 @@
+/*
+ * Pure helpers for float content: recursive min-size computation over a
+ * LayoutNode subtree, cascade-position generation, and stable id minting.
+ *
+ * Min-size rule (see spec 2026-04-11-layout-topology-design.md):
+ *   - slot:   framework-constant DEFAULT_SLOT_MIN (120×80). Real per-view
+ *             min-size reading is a follow-up; see rescoped DF10.
+ *   - tabs:   element-wise max of all tabs' slot minimums (only one visible).
+ *   - split:  sum along the split axis, max on the cross axis.
+ */
+export const DEFAULT_SLOT_MIN = { w: 120, h: 80 };
+export function computeMinSize(node) {
+    if (node.type === 'slot') {
+        return Object.assign({}, DEFAULT_SLOT_MIN);
+    }
+    if (node.type === 'tabs') {
+        // All tabs fight for the same area; the min is the element-wise max.
+        return Object.assign({}, DEFAULT_SLOT_MIN);
+    }
+    // split
+    const children = node.children.map(computeMinSize);
+    if (node.direction === 'horizontal') {
+        return {
+            w: children.reduce((a, c) => a + c.w, 0),
+            h: children.reduce((a, c) => Math.max(a, c.h), 0),
+        };
+    }
+    return {
+        w: children.reduce((a, c) => Math.max(a, c.w), 0),
+        h: children.reduce((a, c) => a + c.h, 0),
+    };
+}
+const CASCADE_STEP = 32;
+const CASCADE_BASE = { x: 48, y: 48 };
+/**
+ * Given the list of currently-open floats, return the position a new
+ * float should appear at. Each new float offsets (+32, +32) from the
+ * most recently opened one. If the resulting position would push the
+ * float's header outside `bounds`, wraps back to CASCADE_BASE.
+ */
+export function cascadePosition(existing, bounds) {
+    if (existing.length === 0)
+        return Object.assign({}, CASCADE_BASE);
+    const last = existing[existing.length - 1];
+    const next = { x: last.position.x + CASCADE_STEP, y: last.position.y + CASCADE_STEP };
+    // Wraparound if the header would leave the tree-allocated area
+    if (next.x + 120 > bounds.w || next.y + 32 > bounds.h) {
+        return Object.assign({}, CASCADE_BASE);
+    }
+    return next;
+}
+let floatIdCounter = 0;
+/** Stable, process-unique float id. Not cryptographic — just unique within a session. */
+export function generateFloatId() {
+    floatIdCounter += 1;
+    return `float-${Date.now().toString(36)}-${floatIdCounter.toString(36)}`;
+}
+/**
+ * True if a LayoutNode subtree contains no leaf slot with a bound viewId.
+ * Used by the drag-commit auto-close invariant: when the last bound leaf
+ * leaves a float, the float is removed from the tree.
+ *
+ * A tabs node with zero tabs is empty. A split node is empty iff every
+ * child is empty. Only leaf slots with a non-null viewId are considered
+ * "filled".
+ */
+export function isEmptyContent(node) {
+    if (node.type === 'slot')
+        return node.viewId == null;
+    if (node.type === 'tabs')
+        return node.tabs.every((t) => t.viewId == null);
+    return node.children.every(isEmptyContent);
+}

package/dist/layout/floats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/layout/floats.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { computeMinSize, cascadePosition, isEmptyContent } from './floats';
+const slot = (slotId, viewId = 'v') => ({
+    type: 'slot',
+    slotId,
+    viewId,
+});
+const DEFAULT_SLOT_MIN = { w: 120, h: 80 };
+describe('computeMinSize', () => {
+    it('returns slot default for a single slot with no declared minSize', () => {
+        expect(computeMinSize(slot('s1'))).toEqual(DEFAULT_SLOT_MIN);
+    });
+});
+describe('computeMinSize — tabs', () => {
+    it('tabs node matches single slot minimum', () => {
+        const tabs = {
+            type: 'tabs',
+            tabs: [
+                { slotId: 'a', viewId: 'va', label: 'A' },
+                { slotId: 'b', viewId: 'vb', label: 'B' },
+            ],
+            activeTab: 0,
+        };
+        expect(computeMinSize(tabs)).toEqual(DEFAULT_SLOT_MIN);
+    });
+});
+describe('computeMinSize — splits', () => {
+    it('horizontal split sums widths, maxes heights', () => {
+        const split = {
+            type: 'split',
+            direction: 'horizontal',
+            sizes: [1, 1],
+            children: [slot('a'), slot('b')],
+        };
+        expect(computeMinSize(split)).toEqual({ w: 240, h: 80 });
+    });
+    it('vertical split maxes widths, sums heights', () => {
+        const split = {
+            type: 'split',
+            direction: 'vertical',
+            sizes: [1, 1],
+            children: [slot('a'), slot('b')],
+        };
+        expect(computeMinSize(split)).toEqual({ w: 120, h: 160 });
+    });
+});
+describe('cascadePosition', () => {
+    const bounds = { w: 1600, h: 900 };
+    it('returns base when no floats exist', () => {
+        expect(cascadePosition([], bounds)).toEqual({ x: 48, y: 48 });
+    });
+    it('offsets 32px from the most recent float', () => {
+        const existing = [
+            {
+                id: 'f1',
+                content: slot('s'),
+                position: { x: 100, y: 200 },
+                size: { w: 600, h: 400 },
+            },
+        ];
+        expect(cascadePosition(existing, bounds)).toEqual({ x: 132, y: 232 });
+    });
+    it('wraps back to base when the next position would exit bounds', () => {
+        const existing = [
+            {
+                id: 'f1',
+                content: slot('s'),
+                position: { x: 1599, y: 100 },
+                size: { w: 600, h: 400 },
+            },
+        ];
+        expect(cascadePosition(existing, bounds)).toEqual({ x: 48, y: 48 });
+    });
+});
+describe('isEmptyContent', () => {
+    it('true for a slot with null viewId', () => {
+        expect(isEmptyContent({ type: 'slot', slotId: 's', viewId: null })).toBe(true);
+    });
+    it('false for a slot with a bound viewId', () => {
+        expect(isEmptyContent({ type: 'slot', slotId: 's', viewId: 'v' })).toBe(false);
+    });
+    it('true for tabs with all null viewIds', () => {
+        expect(isEmptyContent({
+            type: 'tabs',
+            tabs: [{ slotId: 'a', viewId: null, label: 'A' }],
+            activeTab: 0,
+        })).toBe(true);
+    });
+    it('true for tabs with no tabs at all', () => {
+        expect(isEmptyContent({ type: 'tabs', tabs: [], activeTab: 0 })).toBe(true);
+    });
+    it('false for a split with at least one bound leaf', () => {
+        expect(isEmptyContent({
+            type: 'split',
+            direction: 'horizontal',
+            sizes: [1, 1],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: null },
+                { type: 'slot', slotId: 'b', viewId: 'v' },
+            ],
+        })).toBe(false);
+    });
+    it('true for a split where every child is empty', () => {
+        expect(isEmptyContent({
+            type: 'split',
+            direction: 'vertical',
+            sizes: [1, 1],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: null },
+                { type: 'slot', slotId: 'b', viewId: null },
+            ],
+        })).toBe(true);
+    });
+});

package/dist/layout/inspection.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutNode, TabEntry } from './types';
+import type { TabEntry, LayoutTree } from './types';
 /**
  * Read-only snapshot of the currently-rendered layout tree. The return
  * value is the live object — callers MUST NOT mutate it directly;
@@ -7,7 +7,7 @@ import type { LayoutNode, TabEntry } from './types';
  * updates without manual subscription wiring.
  */
 export declare function inspectActiveLayout(): {
-    root: LayoutNode;
+    root: LayoutTree;
     source: 'home' | 'app';
 };
 /**

package/dist/layout/inspection.js

@@ -32,7 +32,7 @@ export function inspectActiveLayout() {
  * variants arrive later.
  */
 export function spliceIntoActiveLayout(entry) {
-    const root = activeLayout();
+    const root = activeLayout().docked;
     const target = findFirstTabsNode(root);
     if (!target) {
         throw new Error('spliceIntoActiveLayout: no tabs group found in the active layout; ' +
@@ -46,7 +46,7 @@ export function spliceIntoActiveLayout(entry) {
  * layout. Returns `true` if a matching tab was found and activated.
  */
 export function focusTab(slotId) {
-    const root = activeLayout();
+    const root = activeLayout().docked;
     return focusTabWhere(root, (entry) => entry.slotId === slotId);
 }
 /**
@@ -54,7 +54,7 @@ export function focusTab(slotId) {
  * layout. Returns `true` if a matching tab was found and activated.
  */
 export function focusView(viewId) {
-    const root = activeLayout();
+    const root = activeLayout().docked;
     return focusTabWhere(root, (entry) => entry.viewId === viewId);
 }
 /** Walk the tree looking for a tab entry that satisfies `pred`, activate it. */
@@ -90,7 +90,7 @@ export function expandChild(splitPath, childIndex) {
     return setCollapsed(splitPath, childIndex, false);
 }
 function setCollapsed(splitPath, childIndex, value) {
-    const root = activeLayout();
+    const root = activeLayout().docked;
     const node = nodeAtPath(root, splitPath);
     if (!node || node.type !== 'split')
         return false;
@@ -115,7 +115,7 @@ function setCollapsed(splitPath, childIndex, value) {
  * the sole authority on tree mutations.
  */
 export async function closeTab(slotId) {
-    const root = activeLayout();
+    const root = activeLayout().docked;
     const located = findTabBySlotId(root, slotId);
     if (!located)
         return false;
@@ -189,7 +189,7 @@ function findFirstSlotPath(node, path = []) {
  */
 export function dockIntoActiveLayout(entry) {
     var _a;
-    const root = activeLayout();
+    const root = activeLayout().docked;
     // 1. Already present? Focus it.
     if (focusView((_a = entry.viewId) !== null && _a !== void 0 ? _a : ''))
         return true;

package/dist/layout/ops.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutNode, SplitNode, TabsNode, SlotNode, TabEntry } from './types';
+import type { LayoutNode, SplitNode, TabsNode, SlotNode, TabEntry, LayoutTree, TreeRootRef } from './types';
 /** A path down the tree: the list of child indices walked from the root. */
 export type LayoutPath = number[];
 /** A located tab: where it lives and which entry index inside its group. */
@@ -20,6 +20,19 @@ export declare function findSlotBySlotId(root: LayoutNode, slotId: string): {
     parent: SplitNode | null;
     index: number;
 } | null;
+/** A located tab across all roots of a LayoutTree. */
+export interface LocatedTabInTree {
+    root: TreeRootRef;
+    /** The docked-space located tab record from findTabBySlotId. */
+    located: LocatedTab;
+}
+/**
+ * Multi-root version of `findTabBySlotId`: searches the docked tree first,
+ * then each float's content in order. Returns the root reference along with
+ * the `LocatedTab` so drag commit can route its mutation to the right root.
+ * Returns null if the slot id is not present in any root.
+ */
+export declare function findTabInTree(tree: LayoutTree, slotId: string): LocatedTabInTree | null;
 /**
  * Remove a tab from its current location, returning the removed entry
  * (or null if not found). The tabs group it was in may become empty

package/dist/layout/ops.js

@@ -76,6 +76,23 @@ export function findSlotBySlotId(root, slotId) {
     };
     return walk(root, null, 0);
 }
+/**
+ * Multi-root version of `findTabBySlotId`: searches the docked tree first,
+ * then each float's content in order. Returns the root reference along with
+ * the `LocatedTab` so drag commit can route its mutation to the right root.
+ * Returns null if the slot id is not present in any root.
+ */
+export function findTabInTree(tree, slotId) {
+    const inDocked = findTabBySlotId(tree.docked, slotId);
+    if (inDocked)
+        return { root: { kind: 'docked' }, located: inDocked };
+    for (const f of tree.floats) {
+        const hit = findTabBySlotId(f.content, slotId);
+        if (hit)
+            return { root: { kind: 'float', floatId: f.id }, located: hit };
+    }
+    return null;
+}
 // ---------- Tab removal ----------------------------------------------------
 /**
  * Remove a tab from its current location, returning the removed entry

package/dist/layout/ops.test.d.ts

@@ -0,0 +1 @@
+export {};