sh3-core 0.6.0 → 0.7.0

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 {};

package/dist/layout/ops.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { findTabInTree } from './ops';
+describe('findTabInTree', () => {
+    const tree = {
+        docked: {
+            type: 'tabs',
+            tabs: [{ slotId: 'docked-a', viewId: 'v', label: 'A' }],
+            activeTab: 0,
+        },
+        floats: [
+            {
+                id: 'float-1',
+                content: {
+                    type: 'tabs',
+                    tabs: [{ slotId: 'float-a', viewId: 'v', label: 'A' }],
+                    activeTab: 0,
+                },
+                position: { x: 0, y: 0 },
+                size: { w: 600, h: 400 },
+            },
+        ],
+    };
+    it('finds a tab in the docked tree', () => {
+        const hit = findTabInTree(tree, 'docked-a');
+        expect(hit).not.toBeNull();
+        expect(hit.root).toEqual({ kind: 'docked' });
+    });
+    it('finds a tab inside a float and reports the float id', () => {
+        const hit = findTabInTree(tree, 'float-a');
+        expect(hit).not.toBeNull();
+        expect(hit.root).toEqual({ kind: 'float', floatId: 'float-1' });
+    });
+    it('returns null when the slot is not found', () => {
+        expect(findTabInTree(tree, 'nonexistent')).toBeNull();
+    });
+});

package/dist/layout/presets.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutNode, LayoutTree, LayoutPreset, CanonicalPreset } from './types';
+export declare function normalizeInitialLayout(input: LayoutNode | LayoutTree | LayoutPreset[]): CanonicalPreset[];

package/dist/layout/presets.js

@@ -0,0 +1,49 @@
+/*
+ * Initial layout normalization — converts the three accepted input
+ * shapes (bare LayoutNode, LayoutTree, LayoutPreset[]) into a canonical
+ * CanonicalPreset[] the framework operates on. The ergonomic `tree`
+ * field on LayoutPreset is discarded after normalization in favor of
+ * `variants.default`. Non-default variant keys are preserved untouched
+ * for the rescoped DF10 selection policy.
+ */
+function isLayoutNode(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const t = x.type;
+    return t === 'split' || t === 'tabs' || t === 'slot';
+}
+function isLayoutTree(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const o = x;
+    return isLayoutNode(o.docked) && Array.isArray(o.floats);
+}
+function wrapNodeAsTree(node) {
+    return { docked: node, floats: [] };
+}
+function canonicalizePreset(p) {
+    const variants = {};
+    if (p.tree)
+        variants.default = p.tree;
+    if (p.variants) {
+        for (const key of Object.keys(p.variants)) {
+            variants[key] = p.variants[key];
+        }
+    }
+    if (!variants.default) {
+        throw new Error(`LayoutPreset "${p.name}" must provide either 'tree' or 'variants.default'`);
+    }
+    return { name: p.name, variants };
+}
+export function normalizeInitialLayout(input) {
+    if (Array.isArray(input)) {
+        return input.map(canonicalizePreset);
+    }
+    if (isLayoutTree(input)) {
+        return [{ name: 'default', variants: { default: input } }];
+    }
+    if (isLayoutNode(input)) {
+        return [{ name: 'default', variants: { default: wrapNodeAsTree(input) } }];
+    }
+    throw new Error('normalizeInitialLayout: input is not a LayoutNode, LayoutTree, or LayoutPreset[]');
+}

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

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

package/dist/layout/presets.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeInitialLayout } from './presets';
+const leafNode = { type: 'slot', slotId: 's1', viewId: 'v1' };
+describe('normalizeInitialLayout', () => {
+    it('wraps a bare LayoutNode as a single default preset with empty floats', () => {
+        const result = normalizeInitialLayout(leafNode);
+        expect(result).toEqual([
+            {
+                name: 'default',
+                variants: {
+                    default: { docked: leafNode, floats: [] },
+                },
+            },
+        ]);
+    });
+    it('passes a LayoutTree through as a single default preset', () => {
+        const tree = { docked: leafNode, floats: [] };
+        const result = normalizeInitialLayout(tree);
+        expect(result).toEqual([
+            {
+                name: 'default',
+                variants: { default: tree },
+            },
+        ]);
+    });
+    it('canonicalizes a preset list, using tree as default and preserving variants', () => {
+        const authorTree = { docked: leafNode, floats: [] };
+        const companionTree = {
+            docked: { type: 'slot', slotId: 's2', viewId: 'v2' },
+            floats: [],
+        };
+        const presets = [
+            {
+                name: 'author',
+                tree: authorTree,
+                variants: { companion: companionTree },
+            },
+        ];
+        const result = normalizeInitialLayout(presets);
+        expect(result).toEqual([
+            {
+                name: 'author',
+                variants: {
+                    default: authorTree,
+                    companion: companionTree,
+                },
+            },
+        ]);
+    });
+    it('accepts a preset with only variants (no tree shortcut)', () => {
+        const tree = { docked: leafNode, floats: [] };
+        const presets = [{ name: 'x', variants: { default: tree } }];
+        const result = normalizeInitialLayout(presets);
+        expect(result).toEqual([{ name: 'x', variants: { default: tree } }]);
+    });
+    it('throws if a preset has neither tree nor variants.default', () => {
+        const bad = [{ name: 'broken', variants: { companion: { docked: leafNode, floats: [] } } }];
+        expect(() => normalizeInitialLayout(bad)).toThrow(/must provide either 'tree' or 'variants.default'/);
+    });
+    it('when a preset has both tree and variants.default, variants.default wins', () => {
+        const fromTree = { docked: leafNode, floats: [] };
+        const fromVariant = {
+            docked: { type: 'slot', slotId: 's3', viewId: 'v3' },
+            floats: [],
+        };
+        const result = normalizeInitialLayout([
+            { name: 'x', tree: fromTree, variants: { default: fromVariant } },
+        ]);
+        expect(result[0].variants.default).toBe(fromVariant);
+    });
+});

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

@@ -1,4 +1,4 @@
-import type { LayoutNode } from './types';
+import type { LayoutNode, LayoutTree, FloatEntry } from './types';
 import type { App } from '../apps/types';
 /**
  * Attach an app: create or hydrate its workspace-zone layout proxy,
@@ -16,24 +16,28 @@ export declare function detachApp(): void;
 export declare function switchToHome(): void;
 export declare function switchToApp(): void;
 /**
- * The currently-rendered root. LayoutRenderer reads this through the
- * `layoutStore` export below. Home uses the framework constant;
- * app uses the workspace-zone proxy's `root` (which is reactive, so
+ * The currently-rendered LayoutTree. LayoutRenderer reads this via
+ * layoutStore.tree. Home uses a framework constant; app reads the
+ * currently-active preset from the workspace-zone proxy (reactive, so
  * mutations from splitter/drag/ops reach the renderer unchanged).
  */
-export declare function activeLayout(): LayoutNode;
+export declare function activeLayout(): LayoutTree;
 export declare function getActiveRoot(): 'home' | 'app';
 export declare function getAttachedAppId(): string | null;
 /**
- * Preserved for callers that still read `layoutStore.root`. The getter
- * delegates to `activeLayout()` so every read walks through the
- * manager. Writes to `layoutStore.root` are disallowed (mutation is
- * expected to happen on the returned tree's nodes in place, as in
- * phase 7 — splitter drags mutate `sizes[i]`, tab clicks mutate
- * `activeTab`, drag-commit calls `ops.ts` functions that mutate
- * children arrays). Nothing in the codebase currently reassigns
- * `layoutStore.root`, so this getter-only shape is sufficient.
+ * Preserved for callers that still read `layoutStore.root`. The `root`
+ * getter is an alias for `tree.docked` so existing callers still compile
+ * without changes. The `tree` getter exposes the full LayoutTree for
+ * new consumers that also need floats. The `floats` getter is a
+ * convenience alias for `tree.floats`.
+ *
+ * Writes to any of these properties are disallowed (mutation happens on
+ * the returned tree's nodes in place — splitter drags mutate `sizes[i]`,
+ * tab clicks mutate `activeTab`, drag-commit calls ops.ts functions that
+ * mutate children arrays).
  */
 export declare const layoutStore: {
     readonly root: LayoutNode;
+    readonly tree: LayoutTree;
+    readonly floats: FloatEntry[];
 };