sh3-core 0.11.6 → 0.11.7

package/dist/layout/LayoutRenderer.browser.test.js

@@ -350,3 +350,199 @@ describe('LayoutRenderer browser — E.6 fixed slots', () => {
         expect(document.querySelector('[data-testid="collapse-toggle-2"]')).toBeNull();
     });
 });
+// ---------------------------------------------------------------------------
+// E.7 — fixed positions reject quadrant drops, allow strip drops
+// ---------------------------------------------------------------------------
+describe('LayoutRenderer browser — E.7 fixed-slot drop protection', () => {
+    beforeEach(() => { cleanupDOM(); resetFramework(); });
+    function mk(x, y, type, buttons = 1) {
+        return new PointerEvent(type, {
+            bubbles: true, cancelable: true, pointerId: 1, pointerType: 'mouse',
+            clientX: x, clientY: y, screenX: x, screenY: y, buttons, button: 0,
+        });
+    }
+    it('rejects a quadrant drop onto a fixed slot body', async () => {
+        stubView();
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'e7a' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeSplitNode([
+                        makeTabsNode([makeTabEntry({ slotId: 'src' })]),
+                        makeSlotNode('fixedSlot'),
+                    ], { fixed: [false, true] })),
+                },
+            ],
+        }));
+        await launchApp('e7a');
+        renderWithShell(LayoutRenderer, { path: [] });
+        await settle(30);
+        const beforeRoot = JSON.stringify(layoutStore.root);
+        const srcTab = document.querySelector('[role="tab"]');
+        if (!srcTab)
+            throw new Error('no source tab');
+        const fixedHost = document.querySelector('[data-slot-id="fixedSlot"]');
+        if (!fixedHost)
+            throw new Error('no fixed slot host');
+        const fixedRect = fixedHost.getBoundingClientRect();
+        const fx = fixedRect.left + fixedRect.width / 2;
+        const fy = fixedRect.top + fixedRect.height / 2;
+        const sr = srcTab.getBoundingClientRect();
+        const sx = sr.left + sr.width / 2;
+        const sy = sr.top + sr.height / 2;
+        srcTab.dispatchEvent(mk(sx, sy, 'pointerdown'));
+        window.dispatchEvent(mk(sx + 6, sy, 'pointermove'));
+        window.dispatchEvent(mk(fx, fy, 'pointermove'));
+        window.dispatchEvent(mk(fx, fy, 'pointerup', 0));
+        await settle();
+        expect(JSON.stringify(layoutStore.root)).toBe(beforeRoot);
+    });
+    it('still accepts a strip drop into a fixed tabs node', async () => {
+        stubView();
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'e7b' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeSplitNode([
+                        makeTabsNode([makeTabEntry({ slotId: 'src' })]),
+                        makeTabsNode([makeTabEntry({ slotId: 'dst' })]),
+                    ], { fixed: [false, true] })),
+                },
+            ],
+        }));
+        await launchApp('e7b');
+        renderWithShell(LayoutRenderer, { path: [] });
+        await settle(30);
+        const tabs = document.querySelectorAll('[role="tab"]');
+        const strips = document.querySelectorAll('[role="tablist"]');
+        if (tabs.length < 2 || strips.length < 2)
+            throw new Error('layout did not render');
+        const src = tabs[0];
+        const dstStrip = strips[1];
+        const sr = src.getBoundingClientRect();
+        const sx = sr.left + sr.width / 2;
+        const sy = sr.top + sr.height / 2;
+        const tr = dstStrip.getBoundingClientRect();
+        const tx = tr.left + tr.width / 2;
+        const ty = tr.top + tr.height / 2;
+        src.dispatchEvent(mk(sx, sy, 'pointerdown'));
+        window.dispatchEvent(mk(sx + 6, sy, 'pointermove'));
+        dstStrip.dispatchEvent(mk(tx, ty, 'pointermove'));
+        window.dispatchEvent(mk(tx, ty, 'pointerup', 0));
+        await settle();
+        // After the strip drop, the source (left) tabs node empties and is
+        // pruned (it's non-fixed). The split collapses to its sole surviving
+        // child — the previously-fixed tabs node — which is now root.
+        const root = layoutStore.root;
+        expect(root === null || root === void 0 ? void 0 : root.type).toBe('tabs');
+        if ((root === null || root === void 0 ? void 0 : root.type) === 'tabs') {
+            const slotIds = root.tabs.map((t) => t.slotId).sort();
+            expect(slotIds).toEqual(['dst', 'src']);
+        }
+    });
+    it('preserves a fixed tabs node when its last tab is dragged out', async () => {
+        stubView();
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'e7c' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeSplitNode([
+                        makeTabsNode([makeTabEntry({ slotId: 'sink' })]),
+                        makeTabsNode([makeTabEntry({ slotId: 'lonely' })]),
+                    ], { fixed: [false, true] })),
+                },
+            ],
+        }));
+        await launchApp('e7c');
+        renderWithShell(LayoutRenderer, { path: [] });
+        await settle(30);
+        const tabs = document.querySelectorAll('[role="tab"]');
+        const strips = document.querySelectorAll('[role="tablist"]');
+        if (tabs.length < 2)
+            throw new Error('layout did not render');
+        const lonely = Array.from(tabs).find((t) => { var _a; return (_a = t.textContent) === null || _a === void 0 ? void 0 : _a.includes('lonely'); });
+        if (!lonely)
+            throw new Error('lonely tab not found');
+        const sinkStrip = strips[0];
+        const sr = lonely.getBoundingClientRect();
+        const sx = sr.left + sr.width / 2;
+        const sy = sr.top + sr.height / 2;
+        const tr = sinkStrip.getBoundingClientRect();
+        const tx = tr.left + tr.width / 2;
+        const ty = tr.top + tr.height / 2;
+        lonely.dispatchEvent(mk(sx, sy, 'pointerdown'));
+        window.dispatchEvent(mk(sx + 6, sy, 'pointermove'));
+        sinkStrip.dispatchEvent(mk(tx, ty, 'pointermove'));
+        window.dispatchEvent(mk(tx, ty, 'pointerup', 0));
+        await settle();
+        const root = layoutStore.root;
+        expect(root === null || root === void 0 ? void 0 : root.type).toBe('split');
+        if ((root === null || root === void 0 ? void 0 : root.type) === 'split') {
+            expect(root.children).toHaveLength(2);
+            const fixed = root.children[1];
+            expect(fixed.type).toBe('tabs');
+            if (fixed.type === 'tabs')
+                expect(fixed.tabs).toHaveLength(0);
+            expect(root.fixed).toEqual([false, true]);
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// E.8 — same-strip tab reorder preserves mounted views
+// ---------------------------------------------------------------------------
+describe('LayoutRenderer browser — E.8 same-strip reorder', () => {
+    beforeEach(() => { cleanupDOM(); resetFramework(); });
+    it('keeps the active pane populated after moving the second tab to first', async () => {
+        var _a, _b, _c, _d;
+        // A view that tags its host with a unique marker so we can verify which
+        // slot's host ends up where. The marker survives re-parent because the
+        // pool moves the host element rather than recreating it.
+        registerView('marker:view', {
+            mount: (el) => {
+                var _a;
+                const tag = document.createElement('span');
+                tag.className = 'view-marker';
+                tag.textContent = 'M:' + ((_a = el.dataset.slotId) !== null && _a !== void 0 ? _a : '?');
+                el.appendChild(tag);
+                return { unmount: () => tag.remove() };
+            },
+        });
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'e8' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 'A', label: 'A', viewId: 'marker:view' }),
+                        makeTabEntry({ slotId: 'B', label: 'B', viewId: 'marker:view' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('e8');
+        renderWithShell(LayoutRenderer, { path: [] });
+        await settle(50);
+        // Sanity: both panes have their respective markers.
+        const beforePanes = document.querySelectorAll('.tab-body-pane');
+        expect(beforePanes.length).toBe(2);
+        expect((_a = beforePanes[0].querySelector('.view-marker')) === null || _a === void 0 ? void 0 : _a.textContent).toBe('M:A');
+        expect((_b = beforePanes[1].querySelector('.view-marker')) === null || _b === void 0 ? void 0 : _b.textContent).toBe('M:B');
+        // Programmatic same-strip reorder: move tab at index 1 to position 0.
+        // This is the exact mutation the drag commit applies on a same-strip drop.
+        const ops = await import('./ops');
+        const root = layoutStore.root;
+        if ((root === null || root === void 0 ? void 0 : root.type) !== 'tabs')
+            throw new Error('expected tabs root');
+        ops.moveTabWithinTabs(root, 1, 0);
+        await settle(50);
+        // After the reorder: tabs are [B, A], activeTab=0. Pane 0 is the visible
+        // one. Both panes must still hold a mounted slot-host with the right view.
+        const afterPanes = document.querySelectorAll('.tab-body-pane');
+        expect(afterPanes.length).toBe(2);
+        expect((_c = afterPanes[0].querySelector('.view-marker')) === null || _c === void 0 ? void 0 : _c.textContent).toBe('M:B');
+        expect((_d = afterPanes[1].querySelector('.view-marker')) === null || _d === void 0 ? void 0 : _d.textContent).toBe('M:A');
+    });
+});

package/dist/layout/SlotContainer.svelte

@@ -51,14 +51,19 @@
   $effect(() => {
     if (!wrapper) return;
 
-    // Capture slotId at effect-run time so the cleanup closure releases the
-    // correct slot even when node.slotId has already changed to a new value
-    // by the time Svelte calls the cleanup (which happens after reactive
-    // state has been updated). Without this capture, cleanup would call
-    // releaseSlotHost with the NEW slotId instead of the old one.
+    // Capture slotId AND wrapper at effect-run time so the cleanup closure
+    // releases the correct slot from the correct wrapper. Both can change
+    // before cleanup fires:
+    //   - node.slotId reads the new value (Svelte updates state before
+    //     running the effect's cleanup), so we'd release the wrong slot.
+    //   - the wrapper binding can be re-pointed by Svelte if the component
+    //     is reused. Capturing locks the release to the wrapper this
+    //     effect actually appended into — important for the pool's "only
+    //     detach if still in our wrapper" guard.
     const currentSlotId = node.slotId;
+    const wrapperEl = wrapper;
     const host = acquireSlotHost(currentSlotId, node.viewId, label || node.viewId || currentSlotId);
-    wrapper.appendChild(host);
+    wrapperEl.appendChild(host);
 
     // Local observer exists only to drive the placeholder's dims text;
     // the view's own onResize is delivered by the pool.
@@ -69,11 +74,11 @@
         height = Math.round(box.height);
       }
     });
-    ro.observe(wrapper);
+    ro.observe(wrapperEl);
 
     return () => {
       ro.disconnect();
-      releaseSlotHost(currentSlotId);
+      releaseSlotHost(currentSlotId, wrapperEl);
     };
   });
 </script>

package/dist/layout/SlotDropZone.svelte

@@ -17,11 +17,20 @@
    *   we don't support "merge into same tabs group" via body drop,
    *   only via strip drop. This keeps the UX unambiguous: body = split,
    *   strip = merge.
+   *
+   * Fixed positions:
+   *   When the SplitNode parent of this zone's path has fixed=true at the
+   *   relevant index, the zone reports no targets and renders no highlight or
+   *   hit boxes. The strip drop is computed elsewhere (LayoutRenderer
+   *   .onStripHover) and is not affected by this guard. See
+   *   docs/superpowers/specs/2026-04-28-fixed-slot-drop-protection-design.md.
    */
 
   import { dragState, setDropTarget, clearDropTarget, type DropTarget } from './drag.svelte';
   import type { LayoutPath, SplitSide } from './ops';
-  import type { TreeRootRef } from './types';
+  import { isPathFixedByParent } from './ops';
+  import type { LayoutNode, TreeRootRef } from './types';
+  import { layoutStore } from './store.svelte';
 
   let {
     rootRef,
@@ -39,6 +48,22 @@
   // the zone would shadow the slot's own interactions.
   const active = $derived(dragState.phase === 'dragging');
 
+  /**
+   * True when the parent split of this zone's path has fixed=true at the
+   * relevant index. While true, the zone does not report split targets and
+   * does not render the quadrant highlight or hit boxes.
+   */
+  const parentFixed = $derived.by(() => {
+    let root: LayoutNode | null;
+    if (rootRef.kind === 'docked') {
+      root = layoutStore.root;
+    } else {
+      const entry = layoutStore.tree.floats.find((f) => f.id === rootRef.floatId);
+      root = entry?.content ?? null;
+    }
+    return root ? isPathFixedByParent(root, path) : false;
+  });
+
   function quadrantFor(x: number, y: number, rect: DOMRect): SplitSide {
     const cx = rect.left + rect.width / 2;
     const cy = rect.top + rect.height / 2;
@@ -57,6 +82,13 @@
 
   function onMove(e: PointerEvent) {
     if (!zoneEl) return;
+    if (parentFixed) {
+      if (hoveredSide !== null) {
+        hoveredSide = null;
+        clearDropTarget((t) => t.kind === 'split' && t.path.join('/') === path.join('/'));
+      }
+      return;
+    }
     const rect = zoneEl.getBoundingClientRect();
     // If pointer is outside the zone (pointercapture from elsewhere),
     // clear.
@@ -92,18 +124,21 @@
 <div
   class="slot-drop-zone"
   class:active
+  class:locked={parentFixed}
   bind:this={zoneEl}
   onpointermove={onMove}
   onpointerleave={onLeave}
 >
-  {#if hoveredSide}
-    <div class="quad-highlight quad-{hoveredSide}"></div>
-  {/if}
-  {#if active}
-    <div class="quad-target quad-left"   data-testid="drop-zone-left"></div>
-    <div class="quad-target quad-right"  data-testid="drop-zone-right"></div>
-    <div class="quad-target quad-top"    data-testid="drop-zone-top"></div>
-    <div class="quad-target quad-bottom" data-testid="drop-zone-bottom"></div>
+  {#if !parentFixed}
+    {#if hoveredSide}
+      <div class="quad-highlight quad-{hoveredSide}"></div>
+    {/if}
+    {#if active}
+      <div class="quad-target quad-left"   data-testid="drop-zone-left"></div>
+      <div class="quad-target quad-right"  data-testid="drop-zone-right"></div>
+      <div class="quad-target quad-top"    data-testid="drop-zone-top"></div>
+      <div class="quad-target quad-bottom" data-testid="drop-zone-bottom"></div>
+    {/if}
   {/if}
 </div>
 

package/dist/layout/ops.d.ts

@@ -108,6 +108,16 @@ export declare function makeSplitWithNewTab(existing: LayoutNode, entry: TabEntr
 export declare function splitNodeAtPath(root: LayoutNode, path: LayoutPath, entry: TabEntry, side: SplitSide): void;
 /** Walk a LayoutPath and return the node at its tip, or null. */
 export declare function nodeAtPath(root: LayoutNode, path: LayoutPath): LayoutNode | null;
+/**
+ * True when the parent split of `path` exists and has `fixed[lastIndex] === true`.
+ *
+ * The drag layer and the ops layer both consult this to decide whether a
+ * quadrant-split drop may land at `path`. A `path.length === 0` always returns
+ * false: the root has no parent split. If the path leads through a non-split
+ * (tabs/slot) ancestor, no parent split exists at the relevant slice and the
+ * function returns false.
+ */
+export declare function isPathFixedByParent(root: LayoutNode, path: LayoutPath): boolean;
 /**
  * Post-mutation cleanup pass. Removes empty tabs groups from their
  * parents and collapses single-child splits. Runs until the tree

package/dist/layout/ops.js

@@ -250,6 +250,8 @@ export function splitNodeAtPath(root, path, entry, side) {
     const target = nodeAtPath(root, path);
     if (!target)
         return;
+    if (isPathFixedByParent(root, path))
+        return;
     if (path.length === 0) {
         // Root case: target IS root. Snapshot it so makeSplitWithNewTab
         // embeds the clone, not root itself — avoids a circular reference
@@ -289,6 +291,24 @@ export function nodeAtPath(root, path) {
     }
     return cur;
 }
+/**
+ * True when the parent split of `path` exists and has `fixed[lastIndex] === true`.
+ *
+ * The drag layer and the ops layer both consult this to decide whether a
+ * quadrant-split drop may land at `path`. A `path.length === 0` always returns
+ * false: the root has no parent split. If the path leads through a non-split
+ * (tabs/slot) ancestor, no parent split exists at the relevant slice and the
+ * function returns false.
+ */
+export function isPathFixedByParent(root, path) {
+    var _a;
+    if (path.length === 0)
+        return false;
+    const parent = nodeAtPath(root, path.slice(0, -1));
+    if (!parent || parent.type !== 'split')
+        return false;
+    return ((_a = parent.fixed) === null || _a === void 0 ? void 0 : _a[path[path.length - 1]]) === true;
+}
 // ---------- Cleanup --------------------------------------------------------
 /**
  * Post-mutation cleanup pass. Removes empty tabs groups from their
@@ -307,6 +327,7 @@ export function cleanupTree(root) {
     }
 }
 function cleanupPass(node, parent, indexInParent) {
+    var _a;
     if (node.type === 'split') {
         // Recurse first so we collapse bottom-up.
         let recursed = false;
@@ -314,16 +335,23 @@ function cleanupPass(node, parent, indexInParent) {
             if (cleanupPass(node.children[i], node, i))
                 recursed = true;
         }
-        // Drop empty tabs children — unless the tabs node is persistent.
+        // Drop empty tabs children — unless the tabs node is persistent OR is
+        // fixed in its parent. A fixed child must keep its position in the
+        // parent split's children array; pruning would mutate that array.
         for (let i = node.children.length - 1; i >= 0; i--) {
             const child = node.children[i];
-            if (child.type === 'tabs' && child.tabs.length === 0 && !child.persistent) {
+            if (child.type === 'tabs'
+                && child.tabs.length === 0
+                && !child.persistent
+                && !((_a = node.fixed) === null || _a === void 0 ? void 0 : _a[i])) {
                 node.children.splice(i, 1);
                 node.sizes.splice(i, 1);
                 if (node.pinned)
                     node.pinned.splice(i, 1);
                 if (node.collapsed)
                     node.collapsed.splice(i, 1);
+                if (node.fixed)
+                    node.fixed.splice(i, 1);
                 recursed = true;
             }
         }

package/dist/layout/ops.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { findTabInTree, splitNodeAtPath, cleanupTree, findTabBySlotId } from './ops';
+import { findTabInTree, splitNodeAtPath, cleanupTree, findTabBySlotId, isPathFixedByParent, } from './ops';
+import { makeSlotNode, makeSplitNode, makeTabsNode, makeTabEntry, } from '../__test__/fixtures';
 describe('findTabInTree', () => {
     const tree = {
         docked: {
@@ -84,3 +85,112 @@ describe('splitNodeAtPath — root case (path = [])', () => {
         }
     });
 });
+describe('isPathFixedByParent', () => {
+    it('returns false for root path', () => {
+        const root = makeSplitNode([makeSlotNode('a'), makeSlotNode('b')], { fixed: [true, true] });
+        expect(isPathFixedByParent(root, [])).toBe(false);
+    });
+    it('returns false when parent has no fixed array', () => {
+        const root = makeSplitNode([makeSlotNode('a'), makeSlotNode('b')]);
+        expect(isPathFixedByParent(root, [0])).toBe(false);
+    });
+    it('returns false when fixed[index] is false or undefined', () => {
+        const root = makeSplitNode([makeSlotNode('a'), makeSlotNode('b')], { fixed: [false, false] });
+        expect(isPathFixedByParent(root, [0])).toBe(false);
+        expect(isPathFixedByParent(root, [1])).toBe(false);
+        const sparse = makeSplitNode([makeSlotNode('a'), makeSlotNode('b')], { fixed: [true] });
+        expect(isPathFixedByParent(sparse, [1])).toBe(false);
+    });
+    it('returns true when fixed[index] is true', () => {
+        const root = makeSplitNode([makeSlotNode('a'), makeSlotNode('b')], { fixed: [true, false] });
+        expect(isPathFixedByParent(root, [0])).toBe(true);
+        expect(isPathFixedByParent(root, [1])).toBe(false);
+    });
+    it('returns true for a fixed grandchild reached through a non-fixed parent', () => {
+        const inner = makeSplitNode([makeSlotNode('x'), makeSlotNode('y')], { fixed: [true, false] });
+        const root = makeSplitNode([inner, makeSlotNode('b')]);
+        expect(isPathFixedByParent(root, [0, 0])).toBe(true);
+        expect(isPathFixedByParent(root, [0, 1])).toBe(false);
+    });
+    it('returns false when the path lands inside a tabs node (parent is not a split)', () => {
+        const tabs = makeTabsNode([makeTabEntry({ slotId: 't1' })]);
+        const root = makeSplitNode([tabs, makeSlotNode('b')], { fixed: [true, false] });
+        expect(isPathFixedByParent(root, [0])).toBe(true);
+        // A path beyond a tabs node walks no further (nodeAtPath returns null).
+        expect(isPathFixedByParent(root, [0, 0])).toBe(false);
+    });
+});
+describe('splitNodeAtPath — fixed-parent guard', () => {
+    const newEntry = () => ({ slotId: 'new', viewId: 'v', label: 'New' });
+    it('is a no-op when the parent has fixed=true at the target index', () => {
+        const tabsA = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        const tabsB = makeTabsNode([makeTabEntry({ slotId: 'b' })]);
+        const root = makeSplitNode([tabsA, tabsB], { fixed: [true, false] });
+        const before = JSON.stringify(root);
+        splitNodeAtPath(root, [0], newEntry(), 'right');
+        splitNodeAtPath(root, [0], newEntry(), 'top');
+        expect(JSON.stringify(root)).toBe(before);
+    });
+    it('still splits at a non-fixed sibling index', () => {
+        const tabsA = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        const tabsB = makeTabsNode([makeTabEntry({ slotId: 'b' })]);
+        const root = makeSplitNode([tabsA, tabsB], { fixed: [true, false] });
+        splitNodeAtPath(root, [1], newEntry(), 'right');
+        expect(root.children[1].type).toBe('split');
+    });
+    it('still splits a descendant of a fixed sub-split that is not itself fixed', () => {
+        const inner = makeSplitNode([makeTabsNode([makeTabEntry({ slotId: 'x' })]), makeTabsNode([makeTabEntry({ slotId: 'y' })])], { fixed: [false, false] });
+        const root = makeSplitNode([inner, makeSlotNode('b')], { fixed: [true, false] });
+        splitNodeAtPath(root, [0, 0], newEntry(), 'right');
+        const after = root.children[0].children[0];
+        expect(after.type).toBe('split');
+    });
+    it('still allows splitting the root (path = []) regardless of any fixed flags', () => {
+        const root = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        splitNodeAtPath(root, [], newEntry(), 'right');
+        expect(root.type).toBe('split');
+    });
+});
+describe('cleanupTree — fixed empty tabs preservation', () => {
+    it('keeps an empty tabs child whose parent has fixed=true at that index', () => {
+        const empty = makeTabsNode([]);
+        const sibling = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        const root = makeSplitNode([empty, sibling], { fixed: [true, false] });
+        cleanupTree(root);
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            expect(root.children).toHaveLength(2);
+            const first = root.children[0];
+            expect(first.type).toBe('tabs');
+            if (first.type === 'tabs')
+                expect(first.tabs).toHaveLength(0);
+        }
+    });
+    it('still prunes an empty tabs child whose parent fixed flag is false', () => {
+        const empty = makeTabsNode([]);
+        const sibling = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        const root = makeSplitNode([empty, sibling], { fixed: [false, false] });
+        cleanupTree(root);
+        expect(root.type).toBe('tabs');
+    });
+    it('still prunes an empty tabs child when the parent has no fixed array at all', () => {
+        const empty = makeTabsNode([]);
+        const sibling = makeTabsNode([makeTabEntry({ slotId: 'a' })]);
+        const root = makeSplitNode([empty, sibling]);
+        cleanupTree(root);
+        expect(root.type).toBe('tabs');
+    });
+    it('preserves the parent fixed array length when a non-fixed empty tabs child IS pruned', () => {
+        const empty = makeTabsNode([]);
+        const fixedKept = makeTabsNode([makeTabEntry({ slotId: 'k' })]);
+        const other = makeTabsNode([makeTabEntry({ slotId: 'o' })]);
+        const root = makeSplitNode([empty, fixedKept, other], { fixed: [false, true, false] });
+        cleanupTree(root);
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            expect(root.children).toHaveLength(2);
+            expect(root.fixed).toEqual([true, false]);
+            expect(root.sizes).toHaveLength(2);
+        }
+    });
+});

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

@@ -10,8 +10,14 @@ export declare function acquireSlotHost(slotId: string, viewId: string | null, l
  * Release the pooled host. If this was the last reference, a
  * destruction is queued to run in a microtask; a later acquire before
  * that microtask cancels the destroy (the re-parent case).
+ *
+ * When `fromWrapper` is provided, the host is detached from the DOM only
+ * if its current parent is still that wrapper. This guards the same-strip
+ * tab reorder scenario (see below) where another caller has already moved
+ * the host to a different wrapper before this release fires; an
+ * unconditional detach would yank the host out of its new home.
  */
-export declare function releaseSlotHost(slotId: string): void;
+export declare function releaseSlotHost(slotId: string, fromWrapper?: HTMLElement): void;
 /**
  * Test / teardown helper — destroys every pooled host immediately. Used
  * by HMR boundaries and tests; not part of normal runtime flow.

package/dist/layout/slotHostPool.svelte.js

@@ -232,20 +232,39 @@ export function acquireSlotHost(slotId, viewId, label, meta) {
  * Release the pooled host. If this was the last reference, a
  * destruction is queued to run in a microtask; a later acquire before
  * that microtask cancels the destroy (the re-parent case).
+ *
+ * When `fromWrapper` is provided, the host is detached from the DOM only
+ * if its current parent is still that wrapper. This guards the same-strip
+ * tab reorder scenario (see below) where another caller has already moved
+ * the host to a different wrapper before this release fires; an
+ * unconditional detach would yank the host out of its new home.
  */
-export function releaseSlotHost(slotId) {
+export function releaseSlotHost(slotId, fromWrapper) {
     const entry = pool.get(slotId);
     if (!entry)
         return;
     entry.refcount--;
     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();
+        // Refcount remains positive (e.g. acquireAppSlotHolds keeps a hold for
+        // every slot in the active layout). Detach the host from its current
+        // DOM parent ONLY when that parent is the wrapper the caller is
+        // releasing from — i.e. nobody else has moved it elsewhere yet.
+        //
+        // Same-strip tab reorder is the exact case this guard exists for:
+        // Svelte runs the two SlotContainer effects as
+        // [cleanup0, body0, cleanup1, body1]. By the time cleanup1 fires,
+        // body0 has already `appendChild`'d the host into the OTHER pane's
+        // wrapper (move semantics auto-detach from the original). An
+        // unconditional `.remove()` would empty the pane that just claimed
+        // the host and leave the active tab visibly blank.
+        //
+        // Same-instance prop change (preset switch on a single SlotContainer)
+        // still works correctly: the host's parent is still our wrapper at
+        // cleanup time, so the detach runs and the wrapper is empty when the
+        // new acquire appends a different host.
+        if (fromWrapper && entry.host.parentNode === fromWrapper) {
+            entry.host.remove();
+        }
         return;
     }
     pendingDestroy.add(slotId);

package/dist/sh3core-shard/sh3coreShard.svelte.js

@@ -96,9 +96,22 @@ export const sh3coreShard = {
         };
         ctx.registerView('sh3core:home', factory);
         ctx.registerView('shell:keys-and-peers', keysFactory);
-        // Dynamic launcher actions: one "Launch <App>" per registered app, kept
-        // in sync as packages install/uninstall via the registry. Re-launching
-        // the active app is harmless (lifecycle treats it as a resume).
+        // Launcher parent — submenu drill host. No `run` needed: the
+        // dispatcher's default behavior opens a sub-palette filtered to
+        // `submenuOf === 'sh3.app.launch'`. The single parent replaces the
+        // per-app palette entries that used to flood the idle palette.
+        ctx.actions.register({
+            id: 'sh3.app.launch',
+            label: 'Launch app',
+            scope: ['home', 'app'],
+            submenu: true,
+            paletteItem: true,
+        });
+        // Dynamic launcher children: one per registered app, kept in sync
+        // as packages install/uninstall via the registry. Children inherit
+        // the parent's surface placement, so they don't set paletteItem
+        // themselves. Direct text match (e.g. typing the app name) still
+        // surfaces them at the root palette via the scorer.
         const launcherUnregisters = new Map();
         $effect.root(() => {
             $effect(() => {
@@ -109,8 +122,9 @@ export const sh3coreShard = {
                         continue;
                     const off = ctx.actions.register({
                         id: `sh3.app.launch:${id}`,
-                        label: `Launch ${app.manifest.label}`,
+                        label: app.manifest.label,
                         scope: ['home', 'app'],
+                        submenuOf: 'sh3.app.launch',
                         run() {
                             void launchApp(id);
                         },

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.11.6";
+export declare const VERSION = "0.11.7";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.11.6';
+export const VERSION = '0.11.7';