sh3-core 0.7.3 → 0.7.5

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,6 +159,7 @@ function createHost(slotId, viewId, label) {
             slotId,
             viewId: viewId !== null && viewId !== void 0 ? viewId : '',
             label,
+            meta,
             setDirty(dirty) {
                 dirtyState[slotId] = dirty;
             },
@@ -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

@@ -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.

package/dist/overlays/float.d.ts

@@ -7,6 +7,8 @@ export interface FloatOptions {
         y: number;
     };
     size?: Size;
+    /** Instance data threaded to the view factory via `MountContext.meta`. */
+    meta?: Record<string, unknown>;
 }
 export interface FloatManager {
     open(viewId: string, options?: FloatOptions): string;

package/dist/overlays/float.js

@@ -74,9 +74,12 @@ function openFloat(viewId, options = {}) {
     // float body; the frame header still moves the float as a whole.
     const slotId = mintFloatSlotId(viewId);
     const label = (_a = options.title) !== null && _a !== void 0 ? _a : viewId;
+    const tab = { slotId, viewId, label };
+    if (options.meta)
+        tab.meta = options.meta;
     const content = {
         type: 'tabs',
-        tabs: [{ slotId, viewId, label }],
+        tabs: [tab],
         activeTab: 0,
     };
     const computedMin = computeMinSize(content);

package/dist/overlays/float.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { floatManager, __resetFloatManagerForTest } from './float';
+import { floatManager, __resetFloatManagerForTest, bindFloatStore } from './float';
+import { layoutStore } from '../layout/store.svelte';
 describe('floatManager', () => {
     beforeEach(() => {
         __resetFloatManagerForTest();
@@ -34,4 +35,104 @@ describe('floatManager', () => {
         expect(f.position).toEqual({ x: 100, y: 200 });
         expect(f.size).toEqual({ w: 800, h: 500 });
     });
+    it('open() threads meta into the content TabEntry', () => {
+        const meta = { viewConfigId: 'vc-42' };
+        const id = floatManager.open('test:view', { meta });
+        const f = floatManager.list().find((e) => e.id === id);
+        const tabs = f.content;
+        expect(tabs.type).toBe('tabs');
+        if (tabs.type === 'tabs') {
+            expect(tabs.tabs[0].meta).toEqual({ viewConfigId: 'vc-42' });
+        }
+    });
+    it('open() without meta leaves TabEntry.meta undefined', () => {
+        const id = floatManager.open('test:view');
+        const f = floatManager.list().find((e) => e.id === id);
+        const tabs = f.content;
+        expect(tabs.type).toBe('tabs');
+        if (tabs.type === 'tabs') {
+            expect(tabs.tabs[0].meta).toBeUndefined();
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// DOM tests — floatManager + FloatLayer.svelte in happy-dom
+// ---------------------------------------------------------------------------
+import { renderWithShell } from '../__test__/render';
+import FloatLayer from './FloatLayer.svelte';
+import { tick } from 'svelte';
+import { resetFramework } from '../__test__/reset';
+/**
+ * Wire the floatManager to the same FloatEntry[] that FloatLayer reads
+ * (layoutStore.floats → HOME_TREE.floats). Without this binding, the
+ * manager writes to its internal fallback array, which the component
+ * never observes.
+ */
+function bindManagerToStore() {
+    bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+}
+// ---------------------------------------------------------------------------
+// F.1 — open mounts a frame into the DOM; close removes it
+// ---------------------------------------------------------------------------
+describe('floats — F.1 open/close mounts DOM', () => {
+    beforeEach(() => {
+        resetFramework();
+        bindManagerToStore();
+    });
+    it('mounts a FloatFrame on open() and removes it on close()', async () => {
+        const { container } = renderWithShell(FloatLayer, {});
+        const id = floatManager.open('test:view', { title: 'Test Float' });
+        await tick();
+        // FloatFrame renders a div[role="dialog"] with the title as aria-label.
+        const frame = container.querySelector('[role="dialog"][aria-label="Test Float"]');
+        expect(frame).toBeTruthy();
+        floatManager.close(id);
+        await tick();
+        expect(container.querySelector('[role="dialog"][aria-label="Test Float"]')).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// F.2 — focus stack: last opened is top, previous is restored after close
+// ---------------------------------------------------------------------------
+describe('floats — F.2 focus stack', () => {
+    beforeEach(() => {
+        resetFramework();
+        bindManagerToStore();
+    });
+    it('raises the newer float above the prior and restores previous on close', async () => {
+        var _a, _b;
+        renderWithShell(FloatLayer, {});
+        const id1 = floatManager.open('test:view', { title: 'First' });
+        const id2 = floatManager.open('test:view', { title: 'Second' });
+        await tick();
+        // The most recently focused float sits at the end of list() (top z-order).
+        expect((_a = floatManager.list().at(-1)) === null || _a === void 0 ? void 0 : _a.id).toBe(id2);
+        floatManager.close(id2);
+        await tick();
+        // After closing the top, id1 becomes the sole entry (top of z-order).
+        expect((_b = floatManager.list().at(-1)) === null || _b === void 0 ? void 0 : _b.id).toBe(id1);
+    });
+});
+// ---------------------------------------------------------------------------
+// F.3 — close button in FloatFrame calls floatManager.close()
+// ---------------------------------------------------------------------------
+describe('floats — F.3 close button removes float', () => {
+    beforeEach(() => {
+        resetFramework();
+        bindManagerToStore();
+    });
+    it('clicking the close button removes the float from list()', async () => {
+        const { container } = renderWithShell(FloatLayer, {});
+        const id = floatManager.open('test:view', { title: 'Closeable' });
+        await tick();
+        // FloatFrame renders a button[aria-label="Close float"] inside the frame.
+        const closeBtn = container.querySelector('[role="dialog"] button[aria-label="Close float"]');
+        expect(closeBtn).toBeTruthy();
+        closeBtn.click();
+        await tick();
+        // Float must be gone from the manager's list.
+        expect(floatManager.list().some((f) => f.id === id)).toBe(false);
+        // And its frame must be removed from the DOM.
+        expect(container.querySelector('[role="dialog"][aria-label="Closeable"]')).toBeNull();
+    });
 });

package/dist/primitives/ResizableSplitter.svelte

@@ -221,10 +221,12 @@
         class="splitter-handle"
         class:dragging={drag?.handleIndex === i}
         class:disabled={isCollapsed(i) || isCollapsed(i + 1)}
+        data-testid="splitter-handle-{i}"
         onpointerdown={(e) => beginDrag(e, i)}
         onpointermove={moveDrag}
         onpointerup={endDrag}
         onpointercancel={endDrag}
+        ondblclick={() => onCollapseToggle?.(i, !isCollapsed(i))}
         role="separator"
         aria-orientation={direction === 'horizontal' ? 'vertical' : 'horizontal'}
       ></div>