sh3-core 0.17.0 → 0.19.0

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

@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest';
+import { derive } from './derive';
+describe('derive', () => {
+    describe('body partition', () => {
+        it('all-body tree → bodyRoot identical, all drawers null', () => {
+            const tree = {
+                type: 'split',
+                direction: 'horizontal',
+                sizes: [1, 1],
+                children: [
+                    { type: 'slot', slotId: 'a', viewId: 'view:a', role: 'body' },
+                    { type: 'slot', slotId: 'b', viewId: 'view:b', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect(result.bodyRoot).toEqual(tree);
+            expect(result.drawers.left).toBeNull();
+            expect(result.drawers.right).toBeNull();
+            expect(result.drawers.top).toBeNull();
+        });
+        it('zero-body tree → bodyRoot is empty placeholder', () => {
+            var _a, _b;
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [1, 1],
+                children: [
+                    { type: 'slot', slotId: 'a', viewId: 'view:a', role: 'sidebar' },
+                    { type: 'slot', slotId: 'b', viewId: 'view:b', role: 'inspector' },
+                ],
+            };
+            const result = derive(tree);
+            expect(result.bodyRoot.type).toBe('slot');
+            expect(result.bodyRoot.slotId).toBe('__sh3core__:compact:empty');
+            expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['a']);
+            expect((_b = result.drawers.right) === null || _b === void 0 ? void 0 : _b.slots.map((s) => s.slotId)).toEqual(['b']);
+        });
+        it('single body wrapped in split collapses to bare body slot', () => {
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [0.2, 0.8],
+                children: [
+                    { type: 'slot', slotId: 'side', viewId: 'view:side', role: 'sidebar' },
+                    { type: 'slot', slotId: 'body', viewId: 'view:body', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect(result.bodyRoot.type).toBe('slot');
+            expect(result.bodyRoot.slotId).toBe('body');
+        });
+    });
+    describe('anchor inference', () => {
+        it('first horizontal child → left, last → right', () => {
+            var _a, _b;
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [0.2, 0.6, 0.2],
+                children: [
+                    { type: 'slot', slotId: 'sb', viewId: 'v:sb', role: 'sidebar' },
+                    { type: 'slot', slotId: 'body', viewId: 'v:body', role: 'body' },
+                    { type: 'slot', slotId: 'ins', viewId: 'v:ins', role: 'inspector' },
+                ],
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['sb']);
+            expect((_b = result.drawers.right) === null || _b === void 0 ? void 0 : _b.slots.map((s) => s.slotId)).toEqual(['ins']);
+            expect(result.drawers.top).toBeNull();
+        });
+        it('top of vertical split → top anchor', () => {
+            var _a;
+            const tree = {
+                type: 'split', direction: 'vertical', sizes: [0.3, 0.7],
+                children: [
+                    { type: 'slot', slotId: 'tools', viewId: 'v:tools', role: 'sidebar' },
+                    { type: 'slot', slotId: 'body', viewId: 'v:body', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.top) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['tools']);
+            expect(result.drawers.left).toBeNull();
+            expect(result.drawers.right).toBeNull();
+        });
+        it('inspector with no horizontal anchor defaults to right', () => {
+            var _a;
+            const tree = {
+                type: 'slot', slotId: 'lone', viewId: 'v:lone', role: 'inspector',
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.right) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['lone']);
+            expect(result.drawers.left).toBeNull();
+        });
+        it('sidebar with no horizontal anchor defaults to left', () => {
+            var _a;
+            const tree = {
+                type: 'slot', slotId: 'lone', viewId: 'v:lone', role: 'sidebar',
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['lone']);
+            expect(result.drawers.right).toBeNull();
+        });
+    });
+    describe('multi-slot drawers', () => {
+        it('two sidebars on the left render as one drawer with two slots', () => {
+            var _a;
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+                children: [
+                    {
+                        type: 'split', direction: 'vertical', sizes: [0.5, 0.5],
+                        children: [
+                            { type: 'slot', slotId: 'sb-top', viewId: 'v:sb-top', role: 'sidebar' },
+                            { type: 'slot', slotId: 'sb-bot', viewId: 'v:sb-bot', role: 'sidebar' },
+                        ],
+                    },
+                    { 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-top', 'sb-bot']);
+        });
+    });
+    describe('default role', () => {
+        it('untagged slot defaults to body', () => {
+            const tree = { type: 'slot', slotId: 'x', viewId: 'v:x' };
+            const result = derive(tree);
+            expect(result.bodyRoot).toEqual(tree);
+            expect(result.drawers.left).toBeNull();
+            expect(result.drawers.right).toBeNull();
+            expect(result.drawers.top).toBeNull();
+        });
+    });
+    describe('tabs nodes', () => {
+        it('tabs of body slots stay in body root', () => {
+            const tree = {
+                type: 'tabs', activeTab: 0,
+                tabs: [
+                    { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
+                    { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect(result.bodyRoot.type).toBe('tabs');
+        });
+        it('tabs with mixed roles split body tabs from sidebar slots', () => {
+            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,
+                        tabs: [
+                            { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
+                            { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                        ],
+                    },
+                ],
+            };
+            const result = derive(tree);
+            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']);
+        });
+    });
+    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' }],
+                activeTab: 0,
+            };
+            const out = derive(tree);
+            expect(out.carousels).toBeInstanceOf(Map);
+            expect(out.carousels.size).toBe(1);
+            expect((_a = out.carousels.get('')) === null || _a === void 0 ? void 0 : _a.activeLabel).toBe('Only');
+        });
+        it('carousels Map is empty when bodyRoot has no qualifying tabs', () => {
+            const tree = { type: 'slot', slotId: 's', viewId: null, role: 'body' };
+            const out = derive(tree);
+            expect(out.carousels.size).toBe(0);
+        });
+        it('detection runs against bodyRoot (post-stripNonBody), not the source tree', () => {
+            const tree = {
+                type: 'split',
+                direction: 'horizontal',
+                sizes: [0.3, 0.7],
+                children: [
+                    { type: 'slot', slotId: 'sb', viewId: null, role: 'sidebar' },
+                    {
+                        type: 'tabs',
+                        tabs: [{ slotId: 't0', viewId: null, label: 'Body Tab', role: 'body' }],
+                        activeTab: 0,
+                    },
+                ],
+            };
+            const out = derive(tree);
+            expect(out.carousels.size).toBe(1);
+            expect(out.carousels.get('')).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+import type { DrawerAnchor, DrawerStateMap } from './types';
+export declare const drawerStore: {
+    readonly state: DrawerStateMap;
+    open(anchor: DrawerAnchor): void;
+    close(anchor: DrawerAnchor): void;
+    toggle(anchor: DrawerAnchor): void;
+    activate(anchor: DrawerAnchor, slotId: string): void;
+    /**
+     * Bind a write-through callback. layoutStore calls this when the active
+     * preset/viewport changes; the callback persists state into the
+     * AppLayoutBlob.drawers field. Pass null to unbind.
+     */
+    __setWriteThrough(cb: ((next: DrawerStateMap) => void) | null): void;
+    /**
+     * Replace the current state from a persisted snapshot. Used by
+     * layoutStore on preset/viewport-class change.
+     */
+    __hydrate(snapshot: DrawerStateMap): void;
+    /** Test-only reset. */
+    __reset(): void;
+};

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

@@ -0,0 +1,75 @@
+/*
+ * drawerStore — backing store for Sh3.drawers.
+ *
+ * In-memory state mirror; persistence integration (read/write
+ * AppLayoutBlob.drawers) lives in layout/store.svelte.ts and is wired
+ * via __setWriteThrough(...). When no blob is bound (home layout, satellite
+ * mode, tests), mutations stay in-memory only.
+ *
+ * The state object is keyed by anchor only; the per-(preset, viewport)
+ * dimension lives in the blob, not here. The bind helper in layoutStore
+ * rehydrates this store when the active preset or viewport class changes.
+ *
+ * File is .svelte.ts so the Svelte compiler processes the runes.
+ */
+function initial() {
+    return {
+        left: { open: false, activeSlotId: null },
+        right: { open: false, activeSlotId: null },
+        top: { open: false, activeSlotId: null },
+    };
+}
+const state = $state(initial());
+let writeThrough = null;
+function flush() {
+    if (writeThrough)
+        writeThrough(state);
+}
+export const drawerStore = {
+    get state() {
+        return state;
+    },
+    open(anchor) {
+        state[anchor].open = true;
+        flush();
+    },
+    close(anchor) {
+        state[anchor].open = false;
+        flush();
+    },
+    toggle(anchor) {
+        state[anchor].open = !state[anchor].open;
+        flush();
+    },
+    activate(anchor, slotId) {
+        state[anchor].activeSlotId = slotId;
+        flush();
+    },
+    /**
+     * Bind a write-through callback. layoutStore calls this when the active
+     * preset/viewport changes; the callback persists state into the
+     * AppLayoutBlob.drawers field. Pass null to unbind.
+     */
+    __setWriteThrough(cb) {
+        writeThrough = cb;
+    },
+    /**
+     * Replace the current state from a persisted snapshot. Used by
+     * layoutStore on preset/viewport-class change.
+     */
+    __hydrate(snapshot) {
+        for (const anchor of ['left', 'right', 'top']) {
+            state[anchor].open = snapshot[anchor].open;
+            state[anchor].activeSlotId = snapshot[anchor].activeSlotId;
+        }
+    },
+    /** Test-only reset. */
+    __reset() {
+        writeThrough = null;
+        const fresh = initial();
+        for (const anchor of ['left', 'right', 'top']) {
+            state[anchor].open = fresh[anchor].open;
+            state[anchor].activeSlotId = fresh[anchor].activeSlotId;
+        }
+    },
+};

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

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

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

@@ -0,0 +1,43 @@
+/*
+ * Drawer store unit tests. These exercise the in-memory state machine
+ * only; persistence integration is covered in Task 11's blob
+ * round-trip test.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { drawerStore } from './drawerStore.svelte';
+describe('drawerStore', () => {
+    beforeEach(() => {
+        drawerStore.__reset();
+    });
+    it('starts with all drawers closed', () => {
+        expect(drawerStore.state.left).toEqual({ open: false, activeSlotId: null });
+        expect(drawerStore.state.right).toEqual({ open: false, activeSlotId: null });
+        expect(drawerStore.state.top).toEqual({ open: false, activeSlotId: null });
+    });
+    it('open(anchor) sets open true', () => {
+        drawerStore.open('left');
+        expect(drawerStore.state.left.open).toBe(true);
+    });
+    it('close(anchor) sets open false', () => {
+        drawerStore.open('left');
+        drawerStore.close('left');
+        expect(drawerStore.state.left.open).toBe(false);
+    });
+    it('toggle(anchor) flips open state', () => {
+        drawerStore.toggle('right');
+        expect(drawerStore.state.right.open).toBe(true);
+        drawerStore.toggle('right');
+        expect(drawerStore.state.right.open).toBe(false);
+    });
+    it('activate(anchor, slotId) sets activeSlotId', () => {
+        drawerStore.activate('left', 'sidebar-1');
+        expect(drawerStore.state.left.activeSlotId).toBe('sidebar-1');
+    });
+    it('reset returns to initial state', () => {
+        drawerStore.open('left');
+        drawerStore.activate('right', 'x');
+        drawerStore.__reset();
+        expect(drawerStore.state.left.open).toBe(false);
+        expect(drawerStore.state.right.activeSlotId).toBeNull();
+    });
+});

package/dist/layout/compact/enrichCarousels.d.ts

@@ -0,0 +1,8 @@
+import type { LayoutNode } from '../types';
+export type NodePath = string;
+export interface CarouselInfo {
+    wrap: boolean;
+    activeLabel: string;
+}
+export declare function pathKey(path: number[]): NodePath;
+export declare function enrichCarousels(root: LayoutNode): Map<NodePath, CarouselInfo>;

package/dist/layout/compact/enrichCarousels.js

@@ -0,0 +1,44 @@
+/*
+ * enrichCarousels — pure post-derive transform.
+ *
+ * Walks the compact bodyRoot (the body-only sub-tree returned by
+ * stripNonBody) and identifies every TabsNode whose horizontal extent
+ * equals the body container's full width. A TabsNode qualifies iff
+ * every ancestor split is vertical — any horizontal split anywhere
+ * above it disqualifies the node and everything beneath it.
+ *
+ * The output is a Map keyed by NodePath (dot-joined child indices)
+ * carrying { wrap, activeLabel } for the renderer + chrome breadcrumb.
+ *
+ * The walk does NOT descend into a TabsNode itself once it has been
+ * identified — tab children are slot/leaf content, not nested layout
+ * nodes that could themselves carouselize.
+ */
+export function pathKey(path) {
+    return path.join('.');
+}
+export function enrichCarousels(root) {
+    const out = new Map();
+    function walk(node, ancestorAllVertical, path) {
+        var _a, _b;
+        if (node.type === 'tabs') {
+            if (ancestorAllVertical) {
+                const active = node.tabs[node.activeTab];
+                out.set(pathKey(path), {
+                    wrap: (_a = node.wrap) !== null && _a !== void 0 ? _a : false,
+                    activeLabel: (_b = active === null || active === void 0 ? void 0 : active.label) !== null && _b !== void 0 ? _b : '',
+                });
+            }
+            return;
+        }
+        if (node.type === 'split') {
+            const next = ancestorAllVertical && node.direction === 'vertical';
+            for (let i = 0; i < node.children.length; i++) {
+                walk(node.children[i], next, [...path, i]);
+            }
+            return;
+        }
+    }
+    walk(root, true, []);
+    return out;
+}

package/dist/layout/compact/enrichCarousels.test.d.ts

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

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

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { enrichCarousels, pathKey } from './enrichCarousels';
+function slot(id) {
+    return { type: 'slot', slotId: id, viewId: null };
+}
+function tabs(labels, wrap) {
+    return Object.assign({ type: 'tabs', tabs: labels.map((l, i) => ({ slotId: `t${i}`, viewId: null, label: l })), activeTab: 0 }, (wrap !== undefined ? { wrap } : {}));
+}
+function vsplit(...children) {
+    return {
+        type: 'split',
+        direction: 'vertical',
+        sizes: children.map(() => 1),
+        children,
+    };
+}
+function hsplit(...children) {
+    return {
+        type: 'split',
+        direction: 'horizontal',
+        sizes: children.map(() => 1),
+        children,
+    };
+}
+describe('pathKey', () => {
+    it('joins indices with dots; empty path → empty string', () => {
+        expect(pathKey([])).toBe('');
+        expect(pathKey([0])).toBe('0');
+        expect(pathKey([1, 0, 2])).toBe('1.0.2');
+    });
+});
+describe('enrichCarousels', () => {
+    it('bodyRoot IS a tabs node → 1 carousel at root', () => {
+        const root = tabs(['A', 'B']);
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(1);
+        expect(out.get('')).toEqual({ wrap: false, activeLabel: 'A' });
+    });
+    it('vertical-split[slot, tabs] → 1 carousel at "1"', () => {
+        const root = vsplit(slot('s'), tabs(['X', 'Y']));
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(1);
+        expect(out.get('1')).toEqual({ wrap: false, activeLabel: 'X' });
+    });
+    it('vertical-split[tabs, vertical-split[tabs, slot]] → 2 carousels (stacked)', () => {
+        const inner = vsplit(tabs(['I0', 'I1']), slot('s'));
+        const root = vsplit(tabs(['T0']), inner);
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(2);
+        expect(out.get('0')).toEqual({ wrap: false, activeLabel: 'T0' });
+        expect(out.get('1.0')).toEqual({ wrap: false, activeLabel: 'I0' });
+    });
+    it('horizontal-split[tabs, slot] → 0 carousels (tabs is narrowed)', () => {
+        const root = hsplit(tabs(['A']), slot('s'));
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(0);
+    });
+    it('horizontal-split[tabs] (single child) → 0 carousels (any horizontal ancestor narrows)', () => {
+        const root = hsplit(tabs(['A']));
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(0);
+    });
+    it('vertical-split[slot, horizontal-split[tabs, slot]] → 0 (inner tabs has horizontal ancestor)', () => {
+        const root = vsplit(slot('s'), hsplit(tabs(['A']), slot('s2')));
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(0);
+    });
+    it('flows wrap=true through into the map', () => {
+        const root = vsplit(slot('s'), tabs(['X'], true));
+        const out = enrichCarousels(root);
+        expect(out.get('1')).toEqual({ wrap: true, activeLabel: 'X' });
+    });
+    it('reads activeLabel from the currently-active tab, not always the first', () => {
+        const t = tabs(['First', 'Second', 'Third']);
+        t.activeTab = 2;
+        const out = enrichCarousels(t);
+        expect(out.get('')).toEqual({ wrap: false, activeLabel: 'Third' });
+    });
+    it('does not recurse into the carousel\'s own children (a tabs node\'s tabs are not walked)', () => {
+        const root = tabs(['A']);
+        const out = enrichCarousels(root);
+        expect(out.size).toBe(1);
+    });
+    it('bare slot → 0 carousels', () => {
+        const out = enrichCarousels(slot('s'));
+        expect(out.size).toBe(0);
+    });
+});

package/dist/layout/compact/resolveRole.d.ts

@@ -0,0 +1,6 @@
+import type { SlotRole } from '../types';
+interface SlotLike {
+    role?: SlotRole;
+}
+export declare function resolveRole(slot: SlotLike, viewDefault: SlotRole | undefined): SlotRole;
+export {};

package/dist/layout/compact/resolveRole.js

@@ -0,0 +1,13 @@
+/*
+ * Role resolution: slot-level wins, view-level fills in, default 'body'.
+ *
+ * Why this matters: authoring a layout shouldn't require knowing every
+ * view's natural role. The view's author knows best ('graphlive:hierarchy'
+ * is a sidebar by nature), so they declare `defaultRole: 'sidebar'` on
+ * the ViewHandle. The app retains override authority by writing `role`
+ * on the slot itself.
+ */
+export function resolveRole(slot, viewDefault) {
+    var _a, _b;
+    return (_b = (_a = slot.role) !== null && _a !== void 0 ? _a : viewDefault) !== null && _b !== void 0 ? _b : 'body';
+}

package/dist/layout/compact/resolveRole.test.d.ts

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

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

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { resolveRole } from './resolveRole';
+describe('resolveRole', () => {
+    it('slot-level role wins over view default', () => {
+        expect(resolveRole({ role: 'body' }, 'sidebar')).toBe('body');
+        expect(resolveRole({ role: 'inspector' }, 'sidebar')).toBe('inspector');
+    });
+    it('view default fills in when slot role is unset', () => {
+        expect(resolveRole({}, 'sidebar')).toBe('sidebar');
+        expect(resolveRole({}, 'inspector')).toBe('inspector');
+    });
+    it('defaults to body when both unset', () => {
+        expect(resolveRole({}, undefined)).toBe('body');
+    });
+    it('treats undefined slot role same as missing field', () => {
+        expect(resolveRole({ role: undefined }, 'sidebar')).toBe('sidebar');
+    });
+});

package/dist/layout/compact/types.d.ts

@@ -0,0 +1,30 @@
+import type { LayoutNode, SlotNode, SlotRole } from '../types';
+import type { NodePath, CarouselInfo } from './enrichCarousels';
+export type { NodePath, CarouselInfo };
+export type DrawerAnchor = 'left' | 'right' | 'top';
+export interface DrawerSpec {
+    slots: Array<{
+        slotId: string;
+        viewId: string | null;
+        label: string;
+        icon?: string;
+        role: SlotRole;
+    }>;
+}
+export interface CompactRendering {
+    bodyRoot: LayoutNode;
+    drawers: {
+        left: DrawerSpec | null;
+        right: DrawerSpec | null;
+        top: DrawerSpec | null;
+    };
+    carousels: Map<NodePath, CarouselInfo>;
+}
+export interface DrawerState {
+    open: boolean;
+    activeSlotId: string | null;
+}
+export type DrawerStateMap = {
+    [anchor in DrawerAnchor]: DrawerState;
+};
+export declare const EMPTY_BODY: SlotNode;

package/dist/layout/compact/types.js

@@ -0,0 +1,15 @@
+/*
+ * Compact-rendering types. The derivation (./derive.ts) walks the
+ * canonical LayoutNode tree and emits a CompactRendering: a body root
+ * (the body-only sub-tree) plus per-anchor drawer specs.
+ *
+ * EMPTY_BODY is the placeholder used when an input tree has zero body
+ * slots — likely an authoring bug, but we render the chrome correctly
+ * rather than crashing.
+ */
+export const EMPTY_BODY = {
+    type: 'slot',
+    slotId: '__sh3core__:compact:empty',
+    viewId: null,
+    role: 'body',
+};

package/dist/layout/drag.svelte.js

@@ -43,6 +43,8 @@
 import { cleanupTree, insertTabIntoTabs, moveTabWithinTabs, removeTabBySlotId, splitNodeAtPath, } from './ops';
 import { layoutStore } from './store.svelte';
 import { isEmptyContent } from './floats';
+import { claim, revoke } from '../gestures/pointerClaim';
+import { ancestorCount } from '../gestures';
 export const dragState = $state({
     phase: 'idle',
     source: null,
@@ -65,6 +67,7 @@ export function suppressNextClick() {
 const DRAG_THRESHOLD_PX = 4;
 let pendingStartX = 0;
 let pendingStartY = 0;
+let activeDragPointerId = null;
 /**
  * Begin a potential tab drag. Call from pointerdown on a tab element.
  * This does not yet enter the dragging phase — movement past the
@@ -73,6 +76,11 @@ let pendingStartY = 0;
 export function beginTabDrag(slotId, entry, sourceRoot, event, tabElement) {
     if (dragState.phase !== 'idle')
         return;
+    const depth = ancestorCount(tabElement);
+    const claimGranted = claim(event.pointerId, { ownerId: 'sh3:tabdrag', axis: 'xy', priority: 'normal', depth });
+    if (!claimGranted)
+        return;
+    activeDragPointerId = event.pointerId;
     const rect = tabElement.getBoundingClientRect();
     dragState.phase = 'pending';
     dragState.source = {
@@ -205,6 +213,10 @@ function commit() {
     autoCloseEmptyFloat(source.sourceRoot);
 }
 function teardown() {
+    if (activeDragPointerId !== null) {
+        revoke(activeDragPointerId, 'sh3:tabdrag');
+        activeDragPointerId = null;
+    }
     dragState.phase = 'idle';
     dragState.source = null;
     dragState.target = null;
@@ -244,4 +256,5 @@ export function __resetDragStateForTest() {
     clickSuppressedUntil = 0;
     pendingStartX = 0;
     pendingStartY = 0;
+    activeDragPointerId = null;
 }

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

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

package/dist/layout/presets.compactVariant.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { resolveActiveTree } from './presets';
+describe('compact variant selection', () => {
+    const preset = {
+        name: 'main',
+        variants: {
+            default: { docked: { type: 'slot', slotId: 'a', viewId: 'v:a' }, floats: [] },
+            compact: { docked: { type: 'slot', slotId: 'b', viewId: 'v:b' }, floats: [] },
+        },
+    };
+    it('returns default variant when class is desktop', () => {
+        const tree = resolveActiveTree(preset, 'desktop');
+        expect(tree.docked.slotId).toBe('a');
+    });
+    it('returns compact variant when class is compact and present', () => {
+        const tree = resolveActiveTree(preset, 'compact');
+        expect(tree.docked.slotId).toBe('b');
+    });
+    it('falls back to default when compact variant is absent', () => {
+        const onlyDefault = {
+            name: 'main',
+            variants: { default: preset.variants.default },
+        };
+        const tree = resolveActiveTree(onlyDefault, 'compact');
+        expect(tree.docked.slotId).toBe('a');
+    });
+});