sh3-core 0.19.1 → 0.19.5

package/dist/layout/compact/CarouselTabs.svelte.test.js

@@ -202,25 +202,32 @@ describe('CarouselTabs (gestures)', () => {
         flushSync();
         expect(node.activeTab).toBe(0);
     });
-    it('pointerdown inside an overflow-x:scroll element does not initiate a swipe', () => {
+    it('pointerdown inside an overflow-x:scroll element with actual horizontal overflow does not initiate a swipe', () => {
         const node = makeNode(['A', 'B', 'C'], 0);
         mountCarousel({ node, wrap: false });
         const slide = host.querySelector('[data-sh3-slide]');
         const scroller = document.createElement('div');
         scroller.style.overflowX = 'scroll';
+        Object.defineProperty(scroller, 'scrollWidth', { value: 1000, configurable: true });
+        Object.defineProperty(scroller, 'clientWidth', { value: 200, configurable: true });
         slide.appendChild(scroller);
+        // Pointer-down in the center (x=250 < 276 right-gutter boundary).
+        // dx=-170 would commit if the bail were absent, so a passing test
+        // genuinely proves the gesture never started.
         scroller.dispatchEvent(fakePointer('pointerdown', 250, 100));
         document.dispatchEvent(fakePointer('pointermove', 80, 100));
         document.dispatchEvent(fakePointer('pointerup', 80, 100));
         flushSync();
         expect(node.activeTab).toBe(0);
     });
-    it('pointerdown inside an overflow-x:auto element does not initiate a swipe', () => {
+    it('pointerdown inside an overflow-x:auto element with actual horizontal overflow does not initiate a swipe', () => {
         const node = makeNode(['A', 'B', 'C'], 0);
         mountCarousel({ node, wrap: false });
         const slide = host.querySelector('[data-sh3-slide]');
         const scroller = document.createElement('div');
         scroller.style.overflowX = 'auto';
+        Object.defineProperty(scroller, 'scrollWidth', { value: 1000, configurable: true });
+        Object.defineProperty(scroller, 'clientWidth', { value: 200, configurable: true });
         slide.appendChild(scroller);
         scroller.dispatchEvent(fakePointer('pointerdown', 250, 100));
         document.dispatchEvent(fakePointer('pointermove', 80, 100));
@@ -228,6 +235,25 @@ describe('CarouselTabs (gestures)', () => {
         flushSync();
         expect(node.activeTab).toBe(0);
     });
+    it('overflow-x:auto with no actual horizontal overflow does NOT block the swipe', () => {
+        // The common false-positive: a body view sets `overflow: auto` to get
+        // vertical scrolling; the resolved overflow-x is `auto` even though the
+        // content fits horizontally. Previously this killed every carousel swipe
+        // initiated inside the body. With the scrollWidth>clientWidth tightening,
+        // only genuinely scrollable regions block.
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const slide = host.querySelector('[data-sh3-slide]');
+        const wrapper = document.createElement('div');
+        wrapper.style.overflowX = 'auto';
+        // scrollWidth / clientWidth default to 0 in happy-dom — no actual overflow.
+        slide.appendChild(wrapper);
+        wrapper.dispatchEvent(fakePointer('pointerdown', 250, 100));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100));
+        document.dispatchEvent(fakePointer('pointerup', 80, 100));
+        flushSync();
+        expect(node.activeTab).toBe(1);
+    });
     it('pointerdown inside an overflow-x:hidden element still allows swipe', () => {
         const node = makeNode(['A', 'B', 'C'], 0);
         mountCarousel({ node, wrap: false });
@@ -267,6 +293,200 @@ describe('CarouselTabs (gestures)', () => {
         expect(track.classList.contains('sh3-carousel-track--dragging')).toBe(false);
     });
 });
+describe('CarouselTabs — multi-pointer filter', () => {
+    // The carousel attaches its pointermove / pointerup / pointercancel
+    // listeners on `document`, so any pointer's events for those types
+    // reach our handler. Without filtering by pointer id, an unrelated
+    // pointer's release or cancel (palm contact, second finger, stylus
+    // ghost) would tear down a legitimate drag.
+    it('pointercancel for a DIFFERENT pointer id does not abort the active drag', () => {
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        // Drag with pointer id 1.
+        track.dispatchEvent(fakePointer('pointerdown', 250, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 100, 100, 1));
+        // A different pointer (id 2) is cancelled — must NOT end our gesture.
+        document.dispatchEvent(fakePointer('pointercancel', 0, 0, 2));
+        // Our pointer keeps going past the commit threshold and releases.
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 1));
+        document.dispatchEvent(fakePointer('pointerup', 80, 100, 1));
+        flushSync();
+        expect(node.activeTab).toBe(1);
+    });
+    it('pointerup for a DIFFERENT pointer id does not end the active drag', () => {
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        track.dispatchEvent(fakePointer('pointerdown', 250, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 100, 100, 1));
+        // A different pointer (id 2) is released — must NOT end our gesture.
+        document.dispatchEvent(fakePointer('pointerup', 0, 0, 2));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 1));
+        document.dispatchEvent(fakePointer('pointerup', 80, 100, 1));
+        flushSync();
+        expect(node.activeTab).toBe(1);
+    });
+    it('pointercancel for OUR pointer id still aborts', () => {
+        // Sanity check — the existing abort-on-cancel behavior is preserved
+        // when the cancellation is for our active pointer.
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        track.dispatchEvent(fakePointer('pointerdown', 250, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100, 1));
+        document.dispatchEvent(fakePointer('pointermove', 100, 100, 1));
+        document.dispatchEvent(fakePointer('pointercancel', 100, 100, 1));
+        flushSync();
+        expect(node.activeTab).toBe(0);
+    });
+});
+describe('CarouselTabs — edge gutter invariant', () => {
+    // EDGE_PX = 24. Container is 300px wide. Left gutter: x < 24.
+    // Right gutter: x > 276.
+    it('left-edge pointer-down initiates a swipe even on an editable target', () => {
+        // Without the gutter override, an <input> sitting under the finger at
+        // the screen edge would silently swallow the drag (isEditableTarget bail).
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const slide = host.querySelectorAll('[data-sh3-slide]')[1];
+        const input = document.createElement('input');
+        slide.appendChild(input);
+        // x=10 — inside left edge gutter. Swipe right → previous tab.
+        input.dispatchEvent(fakePointer('pointerdown', 10, 100));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100));
+        document.dispatchEvent(fakePointer('pointerup', 200, 100));
+        flushSync();
+        expect(node.activeTab).toBe(0);
+    });
+    it('right-edge pointer-down initiates a swipe even inside an overflow-x:auto region with real overflow', () => {
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const slide = host.querySelectorAll('[data-sh3-slide]')[0];
+        const scroller = document.createElement('div');
+        scroller.style.overflowX = 'auto';
+        Object.defineProperty(scroller, 'scrollWidth', { value: 1000, configurable: true });
+        Object.defineProperty(scroller, 'clientWidth', { value: 200, configurable: true });
+        slide.appendChild(scroller);
+        // x=290 — inside right edge gutter (300 - 24 = 276). Swipe left → next tab.
+        scroller.dispatchEvent(fakePointer('pointerdown', 290, 100));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100));
+        document.dispatchEvent(fakePointer('pointerup', 80, 100));
+        flushSync();
+        expect(node.activeTab).toBe(1);
+    });
+    it('left-edge pointer-down on a contenteditable still initiates a swipe', () => {
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const slide = host.querySelectorAll('[data-sh3-slide]')[1];
+        const editable = document.createElement('div');
+        editable.setAttribute('contenteditable', 'true');
+        slide.appendChild(editable);
+        editable.dispatchEvent(fakePointer('pointerdown', 5, 100));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100));
+        document.dispatchEvent(fakePointer('pointermove', 200, 100));
+        document.dispatchEvent(fakePointer('pointerup', 200, 100));
+        flushSync();
+        expect(node.activeTab).toBe(0);
+    });
+    it('gutter pointer-down: transfers pointer capture to the carousel container on threshold-cross', () => {
+        // Concrete proof that the "invincible gutter" mechanism actually fires:
+        // once horizontal dominance is established on a gutter-initiated drag,
+        // setPointerCapture must be called on the carousel container so the
+        // descendant the touch landed on no longer receives the pointer stream.
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const carousel = host.querySelector('.sh3-carousel');
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        let captured = null;
+        carousel.setPointerCapture = (id) => { captured = id; };
+        carousel.hasPointerCapture = (id) => captured === id;
+        carousel.releasePointerCapture = (id) => { if (captured === id)
+            captured = null; };
+        track.dispatchEvent(fakePointer('pointerdown', 10, 100, 7)); // left gutter
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 7)); // crosses threshold
+        expect(captured).toBe(7);
+    });
+    it('mid-track pointer-down: does NOT transfer pointer capture (contract preserved)', () => {
+        // The "invincible" treatment is scoped to the gutter on purpose. Inside
+        // the slide, the existing rule still holds: descendants can claim and
+        // the carousel aborts.
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const carousel = host.querySelector('.sh3-carousel');
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        let captured = null;
+        carousel.setPointerCapture = (id) => { captured = id; };
+        carousel.hasPointerCapture = (id) => captured === id;
+        carousel.releasePointerCapture = (id) => { if (captured === id)
+            captured = null; };
+        track.dispatchEvent(fakePointer('pointerdown', 150, 100, 7)); // center, not gutter
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 7));
+        expect(captured).toBeNull();
+    });
+    it('gutter swipe: a pointercancel within the transfer window is swallowed, drag continues', () => {
+        // Synthetic Android-style "transfer cancel": setPointerCapture on the
+        // container fires a pointercancel on the original target. Without the
+        // ignoreCancelUntil window, that cancel would abort the very drag the
+        // gutter just guaranteed.
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const carousel = host.querySelector('.sh3-carousel');
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        carousel.setPointerCapture = () => { };
+        carousel.hasPointerCapture = () => false;
+        carousel.releasePointerCapture = () => { };
+        track.dispatchEvent(fakePointer('pointerdown', 10, 100, 9)); // left gutter
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 9)); // crosses threshold → capture armed
+        // Transfer cancel — should be swallowed:
+        document.dispatchEvent(fakePointer('pointercancel', 80, 100, 9));
+        // Drag continues rightward; with starting activeTab=1, rightward swipe
+        // (positive dx) goes to previous tab (activeTab=0).
+        document.dispatchEvent(fakePointer('pointermove', 200, 100, 9));
+        document.dispatchEvent(fakePointer('pointerup', 200, 100, 9));
+        flushSync();
+        expect(node.activeTab).toBe(0);
+    });
+    it('gutter swipe: only the FIRST cancel within the window is swallowed; a second cancel aborts', () => {
+        // Defensive: the swallow is single-shot. After one cancel the window
+        // closes so a subsequent real cancel still aborts the drag.
+        const node = makeNode(['A', 'B', 'C'], 1);
+        mountCarousel({ node, wrap: false });
+        const carousel = host.querySelector('.sh3-carousel');
+        const track = host.querySelector('[data-sh3-carousel-track]');
+        carousel.setPointerCapture = () => { };
+        carousel.hasPointerCapture = () => false;
+        carousel.releasePointerCapture = () => { };
+        track.dispatchEvent(fakePointer('pointerdown', 10, 100, 11));
+        document.dispatchEvent(fakePointer('pointermove', 80, 100, 11)); // claim, arm window
+        document.dispatchEvent(fakePointer('pointercancel', 80, 100, 11)); // swallow
+        document.dispatchEvent(fakePointer('pointercancel', 80, 100, 11)); // abort
+        // Subsequent move/up should now be ignored:
+        document.dispatchEvent(fakePointer('pointermove', 200, 100, 11));
+        document.dispatchEvent(fakePointer('pointerup', 200, 100, 11));
+        flushSync();
+        expect(node.activeTab).toBe(1);
+    });
+    it('center pointer-down on the same editable target still bails (gutter is not the whole carousel)', () => {
+        // Sanity check: the override is scoped to the edge zones only —
+        // mid-track pointer-downs on inputs continue to focus the input.
+        const node = makeNode(['A', 'B', 'C'], 0);
+        mountCarousel({ node, wrap: false });
+        const slide = host.querySelector('[data-sh3-slide]');
+        const input = document.createElement('input');
+        slide.appendChild(input);
+        // x=150 — mid-track, not in either gutter.
+        input.dispatchEvent(fakePointer('pointerdown', 150, 100));
+        document.dispatchEvent(fakePointer('pointermove', 30, 100));
+        document.dispatchEvent(fakePointer('pointerup', 30, 100));
+        flushSync();
+        expect(node.activeTab).toBe(0);
+    });
+});
 describe('CarouselTabs — PointerClaim integration', () => {
     it('does not start gesture when pointer is already claimed by an app', () => {
         const node = makeNode(['A', 'B'], 0);

package/dist/layout/compact/CompactRenderer.svelte

@@ -11,18 +11,24 @@
    * the docked content so the surfaces stack correctly.
    *
    * View-default role lookup is intentionally omitted in v1 — derive()
-   * reads slot.role / tab.role directly. Apps that want non-body slots
+   * reads slot.role / tabs.role directly. Apps that want non-body slots
    * tag them at authoring time. View-default fall-through ships when the
    * registry exposes a pre-mount lookup (deferred from this PR).
    */
-  import { layoutStore } from '../store.svelte';
   import { drawerStore } from './drawerStore.svelte';
   import { derive } from './derive';
+  import { resolveCompactBodyRoot } from './rootStore.svelte';
   import LayoutRenderer from '../LayoutRenderer.svelte';
   import DrawerSurface from '../../overlays/DrawerSurface.svelte';
   import type { DrawerAnchor } from './types';
 
-  const rendering = $derived(derive(layoutStore.root));
+  // Compact body shows whatever compactRootStore currently points at —
+  // the docked tree by default, or one float when the user navigates
+  // there via the FloatsSheet. Drawer derivation runs on the same root,
+  // so a float carrying role-tagged sidebar slots gets the same drawer
+  // chrome the docked tree gets.
+  const bodyRoot = $derived(resolveCompactBodyRoot());
+  const rendering = $derived(derive(bodyRoot));
 
   const anchors: DrawerAnchor[] = ['left', 'right', 'top'];
 </script>

package/dist/layout/compact/CompactRenderer.svelte.test.js

@@ -81,9 +81,10 @@ describe('CompactRenderer — carousels', () => {
             initialLayout: {
                 type: 'tabs',
                 activeTab: 0,
+                role: 'body',
                 tabs: [
-                    { slotId: 's0', viewId: null, label: 'A', role: 'body' },
-                    { slotId: 's1', viewId: null, label: 'B', role: 'body' },
+                    { slotId: 's0', viewId: null, label: 'A' },
+                    { slotId: 's1', viewId: null, label: 'B' },
                 ],
             },
         };
@@ -107,7 +108,8 @@ describe('CompactRenderer — carousels', () => {
                     {
                         type: 'tabs',
                         activeTab: 0,
-                        tabs: [{ slotId: 'l0', viewId: null, label: 'L', role: 'body' }],
+                        role: 'body',
+                        tabs: [{ slotId: 'l0', viewId: null, label: 'L' }],
                     },
                     { type: 'slot', slotId: 'r', viewId: null, role: 'body' },
                 ],

package/dist/layout/compact/derive.js

@@ -11,7 +11,7 @@
  * locks that anchor — inner splits don't retag (a vertical split
  * inside a left-anchored subtree keeps both children on the left).
  *
- * Note: this transform reads slot.role / tab.role only. View-level
+ * Note: this transform reads slot.role / tabs.role only. View-level
  * defaultRole resolution happens at the call site via resolveRole(),
  * which materializes a tree with effective roles before passing to
  * derive(). See layout/compact/CompactRenderer.svelte.
@@ -36,7 +36,7 @@ function collectSlots(node) {
             viewId: t.viewId,
             label: t.label,
             icon: t.icon,
-            role: effectiveRole(t.role),
+            role: effectiveRole(node.role),
         }));
     }
     return node.children.flatMap(collectSlots);
@@ -49,16 +49,7 @@ function stripNonBody(node) {
         return effectiveRole(node.role) === 'body' ? node : null;
     }
     if (node.type === 'tabs') {
-        const bodyTabs = node.tabs.filter((t) => effectiveRole(t.role) === 'body');
-        if (bodyTabs.length === 0)
-            return null;
-        if (bodyTabs.length === node.tabs.length)
-            return node;
-        return {
-            type: 'tabs',
-            activeTab: Math.min(node.activeTab, bodyTabs.length - 1),
-            tabs: bodyTabs,
-        };
+        return effectiveRole(node.role) === 'body' ? node : null;
     }
     // split
     const survivors = [];
@@ -95,11 +86,11 @@ function partitionDrawers(node) {
             return;
         }
         if (n.type === 'tabs') {
+            const role = effectiveRole(n.role);
+            if (role === 'body')
+                return;
+            const anchor = hint !== null && hint !== void 0 ? hint : defaultAnchor(role);
             for (const t of n.tabs) {
-                const role = effectiveRole(t.role);
-                if (role === 'body')
-                    continue;
-                const anchor = hint !== null && hint !== void 0 ? hint : defaultAnchor(role);
                 buckets[anchor].push({
                     slotId: t.slotId, viewId: t.viewId, label: t.label, icon: t.icon, role,
                 });

package/dist/layout/compact/derive.test.js

@@ -128,26 +128,26 @@ describe('derive', () => {
     describe('tabs nodes', () => {
         it('tabs of body slots stay in body root', () => {
             const tree = {
-                type: 'tabs', activeTab: 0,
+                type: 'tabs', activeTab: 0, role: 'body',
                 tabs: [
-                    { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
-                    { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                    { slotId: 't1', viewId: 'v:t1', label: 'Tab 1' },
+                    { slotId: 't2', viewId: 'v:t2', label: 'Tab 2' },
                 ],
             };
             const result = derive(tree);
             expect(result.bodyRoot.type).toBe('tabs');
         });
-        it('tabs with mixed roles split body tabs from sidebar slots', () => {
+        it('body tabs node alongside sidebar slot stays in body root', () => {
             var _a;
             const tree = {
                 type: 'split', direction: 'horizontal', sizes: [0.2, 0.8],
                 children: [
                     { type: 'slot', slotId: 'sb', viewId: 'v:sb', role: 'sidebar' },
                     {
-                        type: 'tabs', activeTab: 0,
+                        type: 'tabs', activeTab: 0, role: 'body',
                         tabs: [
-                            { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
-                            { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                            { slotId: 't1', viewId: 'v:t1', label: 'Tab 1' },
+                            { slotId: 't2', viewId: 'v:t2', label: 'Tab 2' },
                         ],
                     },
                 ],
@@ -156,13 +156,33 @@ describe('derive', () => {
             expect(result.bodyRoot.type).toBe('tabs');
             expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['sb']);
         });
+        it('sidebar-tagged tabs node lifts all tabs into a drawer', () => {
+            var _a;
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+                children: [
+                    {
+                        type: 'tabs', activeTab: 0, role: 'sidebar',
+                        tabs: [
+                            { slotId: 'sb-1', viewId: 'v:sb-1', label: 'Files' },
+                            { slotId: 'sb-2', viewId: 'v:sb-2', label: 'Search' },
+                        ],
+                    },
+                    { type: 'slot', slotId: 'body', viewId: 'v:body', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['sb-1', 'sb-2']);
+            expect(result.bodyRoot.slotId).toBe('body');
+        });
     });
     describe('carousels', () => {
         it('includes a carousels Map in the output', () => {
             var _a;
             const tree = {
                 type: 'tabs',
-                tabs: [{ slotId: 't0', viewId: null, label: 'Only', role: 'body' }],
+                role: 'body',
+                tabs: [{ slotId: 't0', viewId: null, label: 'Only' }],
                 activeTab: 0,
             };
             const out = derive(tree);
@@ -184,7 +204,8 @@ describe('derive', () => {
                     { type: 'slot', slotId: 'sb', viewId: null, role: 'sidebar' },
                     {
                         type: 'tabs',
-                        tabs: [{ slotId: 't0', viewId: null, label: 'Body Tab', role: 'body' }],
+                        role: 'body',
+                        tabs: [{ slotId: 't0', viewId: null, label: 'Body Tab' }],
                         activeTab: 0,
                     },
                 ],

package/dist/layout/compact/rootStore.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { LayoutNode } from '../types';
+export type CompactRoot = {
+    kind: 'docked';
+} | {
+    kind: 'float';
+    floatId: string;
+};
+export declare const compactRootStore: {
+    readonly current: CompactRoot;
+    setRoot(r: CompactRoot): void;
+    reset(): void;
+};
+/**
+ * Resolve the LayoutNode the compact body should render. Returns
+ * `layoutStore.root` when current is docked OR when the referenced float
+ * has been removed (self-heal: also resets `current` to docked).
+ */
+export declare function resolveCompactBodyRoot(): LayoutNode;
+/** Test-only reset. Not exported from src/index.ts. */
+export declare function __resetCompactRootStoreForTest(): void;

package/dist/layout/compact/rootStore.svelte.js

@@ -0,0 +1,59 @@
+/*
+ * compactRootStore — selects which LayoutNode the compact body shows.
+ *
+ * In compact mode the user sees exactly one root at a time: either the
+ * docked tree (the "active layout"), or the content of one float. This
+ * module is the source of truth for that selection. Desktop never reads it.
+ *
+ * Reset triggers (called from existing modules):
+ *   - bindFloatStore (active tree changed)
+ *   - closeFloat(id) when current.floatId === id
+ *   - resolveCompactBodyRoot self-heal when the referenced float is gone
+ *
+ * Set triggers:
+ *   - floatManager.open in compact + non-dismissable
+ *   - focusView / focusTab in compact when the target lives in a float
+ *   - FloatsSheet row tap
+ */
+import { layoutStore } from '../store.svelte';
+let current = $state({ kind: 'docked' });
+export const compactRootStore = {
+    get current() {
+        return current;
+    },
+    setRoot(r) {
+        if (r.kind === 'float') {
+            const exists = layoutStore.tree.floats.some((f) => f.id === r.floatId);
+            if (!exists) {
+                throw new Error(`compactRootStore.setRoot: float id "${r.floatId}" is not in the active tree`);
+            }
+        }
+        current = r;
+    },
+    reset() {
+        current = { kind: 'docked' };
+    },
+};
+/**
+ * Resolve the LayoutNode the compact body should render. Returns
+ * `layoutStore.root` when current is docked OR when the referenced float
+ * has been removed (self-heal: also resets `current` to docked).
+ */
+export function resolveCompactBodyRoot() {
+    // Snapshot locally — narrowing on a module-level $state binding is lost
+    // across function calls because the narrowed-out branch could in theory
+    // reassign before the next read.
+    const cur = current;
+    if (cur.kind === 'docked')
+        return layoutStore.root;
+    const entry = layoutStore.tree.floats.find((f) => f.id === cur.floatId);
+    if (!entry) {
+        current = { kind: 'docked' };
+        return layoutStore.root;
+    }
+    return entry.content;
+}
+/** Test-only reset. Not exported from src/index.ts. */
+export function __resetCompactRootStoreForTest() {
+    current = { kind: 'docked' };
+}

package/dist/layout/compact/rootStore.svelte.test.d.ts

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

package/dist/layout/compact/rootStore.svelte.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { compactRootStore, resolveCompactBodyRoot, __resetCompactRootStoreForTest, } from './rootStore.svelte';
+import { __resetLayoutStoreForTest, layoutStore, } from '../store.svelte';
+function makeFloat(id, viewId = 'v') {
+    return {
+        id,
+        content: { type: 'slot', slotId: `slot-${id}`, viewId },
+        position: { x: 0, y: 0 },
+        size: { w: 200, h: 200 },
+    };
+}
+describe('compactRootStore', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+        __resetCompactRootStoreForTest();
+    });
+    it('starts at { kind: "docked" }', () => {
+        expect(compactRootStore.current).toEqual({ kind: 'docked' });
+    });
+    it('setRoot accepts a float id present in the active tree', () => {
+        const f = makeFloat('f-1');
+        layoutStore.tree.floats.push(f);
+        compactRootStore.setRoot({ kind: 'float', floatId: 'f-1' });
+        expect(compactRootStore.current).toEqual({ kind: 'float', floatId: 'f-1' });
+    });
+    it('setRoot throws when the float id is not in the active tree', () => {
+        expect(() => compactRootStore.setRoot({ kind: 'float', floatId: 'missing' })).toThrow(/missing/);
+    });
+    it('reset returns to docked', () => {
+        layoutStore.tree.floats.push(makeFloat('f-2'));
+        compactRootStore.setRoot({ kind: 'float', floatId: 'f-2' });
+        compactRootStore.reset();
+        expect(compactRootStore.current).toEqual({ kind: 'docked' });
+    });
+    it('resolveCompactBodyRoot returns docked content when current is docked', () => {
+        expect(resolveCompactBodyRoot()).toEqual(layoutStore.tree.docked);
+    });
+    it('resolveCompactBodyRoot returns the float content when current points at it', () => {
+        const f = makeFloat('f-3');
+        layoutStore.tree.floats.push(f);
+        compactRootStore.setRoot({ kind: 'float', floatId: 'f-3' });
+        // Workspace-zone reactivity proxies the pushed object, so identity
+        // (`toBe`) does not hold; the structural content is what we care about.
+        expect(resolveCompactBodyRoot()).toEqual(f.content);
+    });
+    it('resolveCompactBodyRoot self-heals on stale id (returns docked + resets)', () => {
+        const f = makeFloat('f-4');
+        layoutStore.tree.floats.push(f);
+        compactRootStore.setRoot({ kind: 'float', floatId: 'f-4' });
+        layoutStore.tree.floats.length = 0;
+        expect(resolveCompactBodyRoot()).toEqual(layoutStore.tree.docked);
+        expect(compactRootStore.current).toEqual({ kind: 'docked' });
+    });
+});

package/dist/layout/drag.svelte.js

@@ -44,7 +44,7 @@ import { cleanupTree, insertTabIntoTabs, moveTabWithinTabs, removeTabBySlotId, s
 import { layoutStore } from './store.svelte';
 import { isEmptyContent } from './floats';
 import { claim, revoke } from '../gestures/pointerClaim';
-import { ancestorCount } from '../gestures';
+import { ancestorCount, logGesture } from '../gestures';
 export const dragState = $state({
     phase: 'idle',
     source: null,
@@ -116,6 +116,8 @@ function removeGlobalListeners() {
     delete document.body.dataset.dragging;
 }
 function onPointerMove(e) {
+    if (e.pointerId !== activeDragPointerId)
+        return;
     dragState.pointerX = e.clientX;
     dragState.pointerY = e.clientY;
     if (dragState.phase === 'pending') {
@@ -126,7 +128,9 @@ function onPointerMove(e) {
         }
     }
 }
-function onPointerUp(_e) {
+function onPointerUp(e) {
+    if (e.pointerId !== activeDragPointerId)
+        return;
     const wasDragging = dragState.phase === 'dragging';
     if (wasDragging) {
         commit();
@@ -137,7 +141,16 @@ function onPointerUp(_e) {
     }
     teardown();
 }
-function onPointerCancel(_e) {
+function onPointerCancel(e) {
+    // Filter by pointer id. Without this, any pointercancel on the window
+    // (palm contact, ghost touch, stylus cancellation while a finger drag
+    // is active) would tear down a legitimate tab drag — same touch-only
+    // auto-release class as in carousel / floatframe / splitter.
+    if (e.pointerId !== activeDragPointerId) {
+        logGesture('tabdrag:cancel-other-id', e, { activeDragPointerId });
+        return;
+    }
+    logGesture('tabdrag:cancel-our-id', e, { activeDragPointerId });
     teardown();
 }
 function rootNode(ref) {