sh3-core 0.7.1 → 0.7.5

package/dist/layout/ops.js

@@ -195,6 +195,24 @@ export function makeSplitWithNewTab(existing, entry, side) {
         children,
     };
 }
+/**
+ * Shallow-clone a layout node. Used by splitNodeAtPath's root case to
+ * break the circular reference that would occur if the root object
+ * (mutated in-place) were embedded as its own child.
+ */
+function snapshotNode(node) {
+    if (node.type === 'tabs')
+        return Object.assign(Object.assign({}, node), { tabs: [...node.tabs] });
+    if (node.type === 'split') {
+        const clone = Object.assign(Object.assign({}, node), { children: [...node.children], sizes: [...node.sizes] });
+        if (node.pinned)
+            clone.pinned = [...node.pinned];
+        if (node.collapsed)
+            clone.collapsed = [...node.collapsed];
+        return clone;
+    }
+    return Object.assign({}, node); // slot — plain shallow copy
+}
 /**
  * Apply a slot-split as a tree mutation: find the target node at the
  * given path and replace it with a new split. Handles the root case
@@ -205,14 +223,13 @@ export function splitNodeAtPath(root, path, entry, side) {
     const target = nodeAtPath(root, path);
     if (!target)
         return;
-    const replacement = makeSplitWithNewTab(target, entry, side);
     if (path.length === 0) {
-        // Replace root contents in place. The root is a discriminated
-        // union; to rewrite it we cast once through `unknown` and then to
-        // a loose record shape, overwrite fields, and clear stale keys
-        // from the previous node kind so the union stays well-formed.
+        // Root case: target IS root. Snapshot it so makeSplitWithNewTab
+        // embeds the clone, not root itself — avoids a circular reference
+        // when we Object.assign the replacement back onto root.
+        const snapshot = snapshotNode(target);
+        const replacement = makeSplitWithNewTab(snapshot, entry, side);
         const rootAsRecord = root;
-        // Clear stale keys first so Object.assign doesn't leave a hybrid.
         delete rootAsRecord.tabs;
         delete rootAsRecord.activeTab;
         delete rootAsRecord.slotId;
@@ -220,10 +237,12 @@ export function splitNodeAtPath(root, path, entry, side) {
         delete rootAsRecord.direction;
         delete rootAsRecord.sizes;
         delete rootAsRecord.pinned;
+        delete rootAsRecord.collapsed;
         delete rootAsRecord.children;
         Object.assign(rootAsRecord, replacement);
         return;
     }
+    const replacement = makeSplitWithNewTab(target, entry, side);
     const parentPath = path.slice(0, -1);
     const indexInParent = path[path.length - 1];
     const parent = nodeAtPath(root, parentPath);

package/dist/layout/ops.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { findTabInTree } from './ops';
+import { findTabInTree, splitNodeAtPath, cleanupTree, findTabBySlotId } from './ops';
 describe('findTabInTree', () => {
     const tree = {
         docked: {
@@ -34,3 +34,53 @@ describe('findTabInTree', () => {
         expect(findTabInTree(tree, 'nonexistent')).toBeNull();
     });
 });
+describe('splitNodeAtPath — root case (path = [])', () => {
+    it('does not create a circular reference when splitting the root', () => {
+        // splitNodeAtPath mutates root in-place (tabs → split). Cast to
+        // LayoutNode so TS doesn't narrow from the initializer.
+        const root = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: 'v1', label: 'One' }],
+            activeTab: 0,
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'right');
+        // After split, root should be a split node with two children.
+        // Neither child should be root itself (no circular ref).
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            for (const child of root.children) {
+                expect(child).not.toBe(root);
+            }
+        }
+    });
+    it('cleanupTree does not infinite-loop after splitting the root', () => {
+        const root = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: 'v1', label: 'One' }],
+            activeTab: 0,
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'right');
+        // This must terminate. Before the fix it infinite-loops.
+        cleanupTree(root);
+        // Both tabs should still be findable.
+        expect(findTabBySlotId(root, 's1')).not.toBeNull();
+        expect(findTabBySlotId(root, 's2')).not.toBeNull();
+    });
+    it('works when root is a slot leaf', () => {
+        const root = {
+            type: 'slot',
+            slotId: 'leaf',
+            viewId: 'v',
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'bottom');
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            for (const child of root.children) {
+                expect(child).not.toBe(root);
+            }
+        }
+    });
+});

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

@@ -5,7 +5,7 @@ import type { ViewHandle } from '../shards/types';
  * the pool does not know which wrapper owns the host at any given time,
  * and that is intentional. The same host may be passed around.
  */
-export declare function acquireSlotHost(slotId: string, viewId: string | null, label: string): HTMLDivElement;
+export declare function acquireSlotHost(slotId: string, viewId: string | null, label: string, meta?: Record<string, unknown>): HTMLDivElement;
 /**
  * Release the pooled host. If this was the last reference, a
  * destruction is queued to run in a microtask; a later acquire before
@@ -34,3 +34,18 @@ export declare function isSlotDirty(slotId: string): boolean;
  * re-render when the deferred mount sets the flag.
  */
 export declare function isSlotClosable(slotId: string): boolean;
+/**
+ * Test-only: set the closable policy for a slot without going through a
+ * ViewFactory. Call BEFORE launchApp so the tab strip reads the right
+ * closable state when it renders.
+ *
+ * `true`  — tab shows a close button and is removed on click.
+ * `false` — tab shows no close button (non-closable).
+ */
+export declare function setSlotClosableForTest(slotId: string, closable: boolean): void;
+/**
+ * Test-only: attach a canClose guard to a slot. The slot must have been
+ * marked closable via `setSlotClosableForTest` first (or the guard will
+ * be installed alongside a `true` closable flag).
+ */
+export declare function setSlotCanCloseForTest(slotId: string, canClose: () => Promise<boolean>): void;

package/dist/layout/slotHostPool.svelte.js

@@ -32,9 +32,59 @@
  *   edge-case escape hatch reserved by the design. Not wired yet —
  *   phase 6 has no view that needs it.
  */
-import { getView } from '../shards/registry';
+import { getView, __addViewRegistrationListener } from '../shards/registry';
 const pool = new Map();
 const pendingDestroy = new Set();
+/**
+ * Called by the registry whenever a new ViewFactory is registered.
+ * Scans the pool for entries that have the matching viewId but were not
+ * mounted (because the factory wasn't available at acquire-time). Mounts
+ * them now.
+ *
+ * This handles the "late factory registration" case: a shard activates
+ * after the layout has already acquired a slot for its view. Rather than
+ * requiring the layout to re-acquire, the pool retries the mount here.
+ */
+function onViewRegistered(viewId, factory) {
+    for (const [slotId, entry] of pool.entries()) {
+        if (entry.viewId !== viewId || entry.handle !== undefined)
+            continue;
+        // Entry is in the pool, matches the view, and has no handle yet —
+        // the factory wasn't available when the microtask ran. Mount now.
+        const ctx = {
+            slotId,
+            viewId,
+            label: entry.label,
+            meta: entry.meta,
+            setDirty(dirty) {
+                dirtyState[slotId] = dirty;
+            },
+        };
+        queueMicrotask(() => {
+            var _a, _b;
+            // Re-check: entry may have been released before this microtask fires.
+            if (!pool.has(slotId))
+                return;
+            if (entry.handle !== undefined)
+                return; // already mounted by a race
+            entry.handle = factory.mount(entry.host, ctx);
+            if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:')) {
+                closableState[slotId] = true;
+            }
+            if ((_b = entry.handle) === null || _b === void 0 ? void 0 : _b.onResize) {
+                const onResize = entry.handle.onResize.bind(entry.handle);
+                entry.resizeObserver = new ResizeObserver((entries) => {
+                    for (const e of entries) {
+                        const box = e.contentRect;
+                        onResize(Math.round(box.width), Math.round(box.height));
+                    }
+                });
+                entry.resizeObserver.observe(entry.host);
+            }
+        });
+    }
+}
+__addViewRegistrationListener(onViewRegistered);
 /**
  * Reactive dirty-state map. Keyed by slotId, values are $state so
  * Svelte tracks reads in `isSlotDirty()` and re-renders the tab strip
@@ -75,7 +125,7 @@ const closableState = $state({});
  * is destroyed before its deferred mount ever runs (e.g. rapid
  * add-then-remove of a slot during a drag).
  */
-function createHost(slotId, viewId, label) {
+function createHost(slotId, viewId, label, meta) {
     const host = document.createElement('div');
     host.className = 'slot-host';
     host.dataset.slotId = slotId;
@@ -93,6 +143,7 @@ function createHost(slotId, viewId, label) {
         handle: undefined,
         viewId,
         label,
+        meta,
         refcount: 0,
         resizeObserver: undefined,
         cancelPendingMount: () => {
@@ -108,12 +159,13 @@ function createHost(slotId, viewId, label) {
             slotId,
             viewId: viewId !== null && viewId !== void 0 ? viewId : '',
             label,
+            meta,
             setDirty(dirty) {
                 dirtyState[slotId] = dirty;
             },
         };
         entry.handle = factory === null || factory === void 0 ? void 0 : factory.mount(host, ctx);
-        if ((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) {
+        if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:')) {
             closableState[slotId] = true;
         }
         // The pool owns the ResizeObserver so its lifetime matches the
@@ -140,13 +192,13 @@ function createHost(slotId, viewId, label) {
  * the pool does not know which wrapper owns the host at any given time,
  * and that is intentional. The same host may be passed around.
  */
-export function acquireSlotHost(slotId, viewId, label) {
+export function acquireSlotHost(slotId, viewId, label, meta) {
     // If the slot was about to be destroyed, cancel — this acquire is the
     // "other half" of a re-parent (teardown was the previous container).
     pendingDestroy.delete(slotId);
     let entry = pool.get(slotId);
     if (!entry) {
-        entry = createHost(slotId, viewId, label);
+        entry = createHost(slotId, viewId, label, meta);
         pool.set(slotId, entry);
     }
     entry.refcount++;
@@ -162,8 +214,16 @@ export function releaseSlotHost(slotId) {
     if (!entry)
         return;
     entry.refcount--;
-    if (entry.refcount > 0)
+    if (entry.refcount > 0) {
+        // Refcount is still > 0 (e.g. acquireAppSlotHolds holds a ref), but
+        // the renderer releasing this slot is done with it. Detach the host
+        // from its current DOM parent so it doesn't remain visible in the old
+        // SlotContainer. The pool entry (and view) stays alive for re-acquisition
+        // — for example, a preset switch back to this slot's preset will re-append
+        // the host to a new SlotContainer without destroying the view.
+        entry.host.remove();
         return;
+    }
     pendingDestroy.add(slotId);
     queueMicrotask(() => {
         var _a, _b;
@@ -200,6 +260,7 @@ export function resetSlotHostPool() {
         delete dirtyState[key];
     for (const key of Object.keys(closableState))
         delete closableState[key];
+    handleOverrides.clear();
 }
 /**
  * Read the current ViewHandle for a slot. Returns undefined if the slot
@@ -208,6 +269,9 @@ export function resetSlotHostPool() {
  */
 export function getSlotHandle(slotId) {
     var _a;
+    const override = handleOverrides.get(slotId);
+    if (override)
+        return override;
     return (_a = pool.get(slotId)) === null || _a === void 0 ? void 0 : _a.handle;
 }
 /**
@@ -225,5 +289,59 @@ export function isSlotDirty(slotId) {
  */
 export function isSlotClosable(slotId) {
     var _a;
+    if (handleOverrides.has(slotId)) {
+        const h = handleOverrides.get(slotId);
+        return !!h.closable;
+    }
     return (_a = closableState[slotId]) !== null && _a !== void 0 ? _a : false;
 }
+// ---------------------------------------------------------------------------
+// Test-only handle override map — lets tests inject closable/canClose policy
+// without needing a real ViewFactory. Not exported from src/index.ts.
+// ---------------------------------------------------------------------------
+/**
+ * Map of slotId → synthetic ViewHandle injected by tests. These take
+ * priority over the pool's real handles in `getSlotHandle` and
+ * `isSlotClosable`. Cleared by `resetSlotHostPool`.
+ */
+const handleOverrides = new Map();
+/**
+ * Test-only: set the closable policy for a slot without going through a
+ * ViewFactory. Call BEFORE launchApp so the tab strip reads the right
+ * closable state when it renders.
+ *
+ * `true`  — tab shows a close button and is removed on click.
+ * `false` — tab shows no close button (non-closable).
+ */
+export function setSlotClosableForTest(slotId, closable) {
+    const existing = handleOverrides.get(slotId);
+    if (existing) {
+        existing.closable = closable;
+    }
+    else {
+        handleOverrides.set(slotId, { unmount() { }, closable });
+    }
+    // Keep reactive closableState in sync so the tab strip re-renders.
+    if (closable) {
+        closableState[slotId] = true;
+    }
+    else {
+        delete closableState[slotId];
+    }
+}
+/**
+ * Test-only: attach a canClose guard to a slot. The slot must have been
+ * marked closable via `setSlotClosableForTest` first (or the guard will
+ * be installed alongside a `true` closable flag).
+ */
+export function setSlotCanCloseForTest(slotId, canClose) {
+    const existing = handleOverrides.get(slotId);
+    if (existing) {
+        existing.closable = { canClose };
+    }
+    else {
+        handleOverrides.set(slotId, { unmount() { }, closable: { canClose } });
+    }
+    // Guarded slots are still considered "closable" for tab strip rendering.
+    closableState[slotId] = true;
+}

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

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

package/dist/layout/slotHostPool.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { tick } from 'svelte';
+import { resetFramework } from '../__test__/reset';
+import { acquireSlotHost, releaseSlotHost } from './slotHostPool.svelte';
+import { registerView } from '../shards/registry';
+import SlotContainer from './SlotContainer.svelte';
+import { renderWithShell } from '../__test__/render';
+import { switchToHome, switchToApp } from './store.svelte';
+import { makeApp, makeAppManifest, makeSlotNode, makeTree } from '../__test__/fixtures';
+import { registerApp } from '../apps/registry.svelte';
+import { launchApp } from '../apps/lifecycle';
+// ─── D.1 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.1 refcount destroys once', () => {
+    beforeEach(resetFramework);
+    it('runs the factory teardown exactly once after the final release, in a microtask', async () => {
+        const teardown = vi.fn();
+        // ViewFactory is an object: { mount(el, ctx): ViewHandle }
+        // ViewHandle has unmount(), NOT dispose()
+        registerView('v', {
+            mount: () => ({
+                unmount: teardown,
+            }),
+        });
+        acquireSlotHost('s1', 'v', 's1');
+        acquireSlotHost('s1', 'v', 's1');
+        releaseSlotHost('s1');
+        await Promise.resolve();
+        expect(teardown).not.toHaveBeenCalled();
+        releaseSlotHost('s1');
+        await Promise.resolve();
+        expect(teardown).toHaveBeenCalledTimes(1);
+    });
+});
+// ─── D.2 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.2 re-acquire cancels destroy', () => {
+    beforeEach(resetFramework);
+    it('does not destroy the host when released and re-acquired in the same microtask', async () => {
+        const teardown = vi.fn();
+        registerView('v', {
+            mount: () => ({
+                unmount: teardown,
+            }),
+        });
+        acquireSlotHost('s2', 'v', 's2');
+        releaseSlotHost('s2');
+        acquireSlotHost('s2', 'v', 's2');
+        await Promise.resolve();
+        expect(teardown).not.toHaveBeenCalled();
+    });
+});
+// ─── D.3 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.3 late factory registration', () => {
+    beforeEach(resetFramework);
+    it('mounts the view when a factory registers after acquireSlotHost', async () => {
+        const mount = vi.fn((el) => {
+            const span = document.createElement('span');
+            span.dataset.mountedFor = 'late';
+            el.appendChild(span);
+            return {
+                unmount: () => span.remove(),
+            };
+        });
+        acquireSlotHost('late-slot', 'late:view', 'late-slot');
+        await Promise.resolve();
+        registerView('late:view', { mount });
+        await Promise.resolve();
+        expect(mount).toHaveBeenCalledTimes(1);
+    });
+});
+// ─── D.4 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.4 shared host across containers', () => {
+    beforeEach(resetFramework);
+    it('mounts the factory once across two SlotContainers for the same slotId', async () => {
+        const mount = vi.fn((_el) => ({ unmount: () => { } }));
+        registerView('shared:view', { mount });
+        // SlotNode for both containers — same slotId, same viewId
+        const node = { type: 'slot', slotId: 'shared', viewId: 'shared:view' };
+        renderWithShell(SlotContainer, { node, label: 'A' });
+        renderWithShell(SlotContainer, { node, label: 'B' });
+        await tick();
+        expect(mount).toHaveBeenCalledTimes(1);
+    });
+});
+// ─── D.5 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.5 root swap preserves app slots', () => {
+    beforeEach(resetFramework);
+    it('does not destroy app-held pooled hosts when swapping app to home and back', async () => {
+        const teardown = vi.fn();
+        registerView('persist:view', { mount: () => ({ unmount: teardown }) });
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'd5' }),
+            initialLayout: [
+                { name: 'default', tree: makeTree(makeSlotNode('d5-slot', 'persist:view')) },
+            ],
+        }));
+        await launchApp('d5');
+        await Promise.resolve();
+        switchToHome();
+        await Promise.resolve();
+        switchToApp();
+        await Promise.resolve();
+        expect(teardown).not.toHaveBeenCalled();
+    });
+});

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

@@ -7,6 +7,22 @@ import type { App } from '../apps/types';
  * Does NOT switch the active root. Call switchToApp() separately.
  */
 export declare function attachApp(app: App): void;
+/**
+ * Second-phase attach: take refcount holds on every slot in the active
+ * preset's tree. Must run AFTER required shards have activated (and
+ * therefore registered their view factories), so the pool's microtask
+ * factory lookup sees them. See the refcount-hold discipline comment at
+ * the top of this module and the createHost microtask in slotHostPool.
+ *
+ * TODO(preset-switch leak): holds are taken for the INITIAL preset only
+ * and released only in detachApp. On presetManager.switch(), the old
+ * preset's slot hosts stay pool-resident with refcount >= 1 (view handle
+ * and ResizeObserver not torn down) for the lifetime of the app attach.
+ * Acceptable for small preset sets; revisit if presets become churnier.
+ * Proper fix: re-scope holds on preset switch, or make this first-frame
+ * only and let renderers own all refcounts.
+ */
+export declare function acquireAppSlotHolds(): void;
 /**
  * Detach the currently-attached app. Releases its refcount holds; the
  * pool's microtask cleanup drops the pooled hosts if they also have no
@@ -41,3 +57,9 @@ export declare const layoutStore: {
     readonly tree: LayoutTree;
     readonly floats: FloatEntry[];
 };
+/**
+ * Test-only reset. Restores the layout store to its boot state: no app
+ * attached, active root = 'home'. Not exported from `src/index.ts` —
+ * tests import this submodule path directly.
+ */
+export declare function __resetLayoutStoreForTest(): void;

package/dist/layout/store.svelte.js

@@ -50,10 +50,10 @@ const HOME_LAYOUT = {
     slotId: 'sh3core.home',
     viewId: 'sh3core:home',
 };
-const HOME_TREE = {
+const HOME_TREE = $state({
     docked: HOME_LAYOUT,
     floats: [],
-};
+});
 let appEntry = $state(null);
 let activeRoot = $state('home');
 // ---------- read-side adapter helpers -------------------------------------
@@ -133,17 +133,40 @@ export function attachApp(app) {
         workspace: defaultBlob,
     });
     const proxy = state.workspace;
-    // Take refcount holds on every slot in the active preset's tree
-    // (including floats). See the refcount-hold discipline comment at top.
-    const tree = currentTree(proxy);
+    // Create the entry with no slot holds yet; `acquireAppSlotHolds` does
+    // that as a second phase, after shards have had a chance to register
+    // their view factories. Binding the preset manager proxy happens here
+    // so shards can read/switch presets from their activate() hook.
+    appEntry = { appId: app.manifest.id, proxy, heldSlotIds: [] };
+    bindPresetBlob(proxy);
+}
+/**
+ * Second-phase attach: take refcount holds on every slot in the active
+ * preset's tree. Must run AFTER required shards have activated (and
+ * therefore registered their view factories), so the pool's microtask
+ * factory lookup sees them. See the refcount-hold discipline comment at
+ * the top of this module and the createHost microtask in slotHostPool.
+ *
+ * TODO(preset-switch leak): holds are taken for the INITIAL preset only
+ * and released only in detachApp. On presetManager.switch(), the old
+ * preset's slot hosts stay pool-resident with refcount >= 1 (view handle
+ * and ResizeObserver not torn down) for the lifetime of the app attach.
+ * Acceptable for small preset sets; revisit if presets become churnier.
+ * Proper fix: re-scope holds on preset switch, or make this first-frame
+ * only and let renderers own all refcounts.
+ */
+export function acquireAppSlotHolds() {
+    if (!appEntry) {
+        throw new Error('acquireAppSlotHolds: no app attached');
+    }
+    if (appEntry.heldSlotIds.length > 0)
+        return; // idempotent
+    const tree = currentTree(appEntry.proxy);
     const refs = collectTreeSlotRefs(tree);
-    const heldSlotIds = [];
-    for (const { slotId, viewId, label } of refs) {
-        acquireSlotHost(slotId, viewId, label);
-        heldSlotIds.push(slotId);
+    for (const { slotId, viewId, label, meta } of refs) {
+        acquireSlotHost(slotId, viewId, label, meta);
+        appEntry.heldSlotIds.push(slotId);
     }
-    appEntry = { appId: app.manifest.id, proxy, heldSlotIds };
-    bindPresetBlob(proxy);
 }
 /**
  * Detach the currently-attached app. Releases its refcount holds; the
@@ -171,6 +194,33 @@ export function switchToApp() {
     }
     activeRoot = 'app';
 }
+// ---------- `layoutStore` back-compat shim -------------------------------
+/**
+ * Reactive-derived active LayoutTree. Using `$derived.by` gives us a
+ * stable, memoized reactive node that downstream accessors
+ * (`layoutStore.root`, `.tree`, `.floats`) all subscribe to once —
+ * instead of re-running the proxy-read chain on every access.
+ *
+ * Reading `blob.activePreset` by name inside this derived is load-bearing:
+ * it registers the preset-name signal as a dependency, so
+ * `presetManager.switch()` invalidates the derived and triggers re-render.
+ * Do not collapse this into a plain function that only reads the preset
+ * object — the derived would still recompute, but consumers that cached
+ * the result via a different path could miss the invalidation.
+ */
+const activeTree = $derived.by(() => {
+    if (activeRoot === 'app' && appEntry) {
+        // Read activePreset by name explicitly so Svelte tracks this signal.
+        const blob = appEntry.proxy;
+        const presetName = blob.activePreset;
+        const preset = blob.presets[presetName];
+        if (!preset) {
+            throw new Error(`AppLayoutBlob active preset "${presetName}" not found in presets map`);
+        }
+        return preset.default;
+    }
+    return HOME_TREE;
+});
 /**
  * The currently-rendered LayoutTree. LayoutRenderer reads this via
  * layoutStore.tree. Home uses a framework constant; app reads the
@@ -178,9 +228,11 @@ export function switchToApp() {
  * mutations from splitter/drag/ops reach the renderer unchanged).
  */
 export function activeLayout() {
-    if (activeRoot === 'app' && appEntry)
-        return currentTree(appEntry.proxy);
-    return HOME_TREE;
+    // Delegates to the $derived.by so callers outside component contexts
+    // (e.g. inspection.ts, ops.ts) still read the correct tree. The $derived
+    // is recalculated whenever activeRoot, appEntry, or blob.activePreset
+    // changes, so these callers always see a fresh snapshot.
+    return activeTree;
 }
 export function getActiveRoot() {
     return activeRoot;
@@ -189,7 +241,6 @@ export function getAttachedAppId() {
     var _a;
     return (_a = appEntry === null || appEntry === void 0 ? void 0 : appEntry.appId) !== null && _a !== void 0 ? _a : null;
 }
-// ---------- `layoutStore` back-compat shim -------------------------------
 /**
  * Preserved for callers that still read `layoutStore.root`. The `root`
  * getter is an alias for `tree.docked` so existing callers still compile
@@ -204,12 +255,23 @@ export function getAttachedAppId() {
  */
 export const layoutStore = {
     get root() {
-        return activeLayout().docked;
+        return activeTree.docked;
     },
     get tree() {
-        return activeLayout();
+        return activeTree;
     },
     get floats() {
-        return activeLayout().floats;
+        return activeTree.floats;
     },
 };
+/**
+ * Test-only reset. Restores the layout store to its boot state: no app
+ * attached, active root = 'home'. Not exported from `src/index.ts` —
+ * tests import this submodule path directly.
+ */
+export function __resetLayoutStoreForTest() {
+    appEntry = null;
+    activeRoot = 'home';
+    HOME_TREE.floats.length = 0;
+    HOME_TREE.docked = HOME_LAYOUT;
+}

package/dist/layout/tree-walk.d.ts

@@ -12,6 +12,7 @@ export declare function collectSlotRefs(tree: LayoutNode): {
     slotId: string;
     viewId: string | null;
     label: string;
+    meta?: Record<string, unknown>;
 }[];
 /**
  * Multi-root version of `collectSlotRefs`: walks the docked tree first
@@ -23,4 +24,5 @@ export declare function collectTreeSlotRefs(tree: LayoutTree): {
     slotId: string;
     viewId: string | null;
     label: string;
+    meta?: Record<string, unknown>;
 }[];

package/dist/layout/tree-walk.js

@@ -20,7 +20,7 @@ export function collectSlotRefs(tree) {
         }
         if (node.type === 'tabs') {
             for (const t of node.tabs) {
-                out.push({ slotId: t.slotId, viewId: t.viewId, label: t.label });
+                out.push({ slotId: t.slotId, viewId: t.viewId, label: t.label, meta: t.meta });
             }
             return;
         }

package/dist/layout/types.d.ts

@@ -38,6 +38,11 @@ export interface TabEntry {
     label: string;
     /** Optional icon hint (not yet rendered in phase 8). */
     icon?: string;
+    /**
+     * Caller-supplied instance data, threaded to `MountContext.meta`.
+     * Ephemeral — not serialized with the layout tree.
+     */
+    meta?: Record<string, unknown>;
 }
 /**
  * A layout node that groups one or more slots as tabs, showing one at a time.