@spectral_labs/ui 1.7.0 → 1.8.0-next.0

package/dist/internal/drag-drop/__tests__/drag-session.test.svelte.js

@@ -1,803 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { EscapeLayerState, resetEscapeLayerStack } from '../../escape-layer/index.js';
-import { dragSession } from '../drag-session.svelte.js';
-function createSourceConfig(id, overrides = {}) {
-    return {
-        id,
-        getItems: () => [{ 'test-type': id, 'text/plain': `Item ${id}` }],
-        onDragStart: vi.fn(),
-        onDragEnd: vi.fn(),
-        ...overrides,
-    };
-}
-function createTargetConfig(id, overrides = {}) {
-    return {
-        id,
-        onDrop: vi.fn(),
-        ...overrides,
-    };
-}
-function createElement() {
-    const el = document.createElement('div');
-    Object.defineProperty(el, 'getBoundingClientRect', {
-        value: () => ({
-            top: 0,
-            left: 0,
-            bottom: 100,
-            right: 200,
-            width: 200,
-            height: 100,
-            x: 0,
-            y: 0,
-            toJSON() { },
-        }),
-    });
-    document.body.appendChild(el);
-    return el;
-}
-/** Polyfill PointerEvent for jsdom. */
-function ensurePointerEventPolyfill() {
-    if (typeof globalThis.PointerEvent === 'undefined') {
-        ;
-        globalThis.PointerEvent = class PointerEvent extends MouseEvent {
-            pointerId;
-            pointerType;
-            constructor(type, init = {}) {
-                super(type, init);
-                this.pointerId = init.pointerId ?? 0;
-                this.pointerType = init.pointerType ?? '';
-            }
-        };
-    }
-}
-function pointerEvent(type, x, y) {
-    return new PointerEvent(type, {
-        clientX: x,
-        clientY: y,
-        pointerId: 1,
-        pointerType: 'mouse',
-        bubbles: true,
-    });
-}
-function startPointerDrag(id) {
-    const config = createSourceConfig(id);
-    const el = createElement();
-    el.setPointerCapture = vi.fn();
-    el.releasePointerCapture = vi.fn();
-    dragSession.registerSource(config, el);
-    dragSession.beginPointerDrag(id, pointerEvent('pointerdown', 100, 100));
-    el.dispatchEvent(pointerEvent('pointermove', 110, 110)); // crosses the 5px threshold
-    return { config, el };
-}
-function pressEscape() {
-    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
-}
-describe('dragSession', () => {
-    beforeEach(() => {
-        dragSession._resetForTests();
-    });
-    describe('initial state', () => {
-        it('is not dragging initially', () => {
-            expect(dragSession.isDragging).toBe(false);
-        });
-        it('has no source', () => {
-            expect(dragSession.sourceId).toBeNull();
-        });
-        it('has no current target', () => {
-            expect(dragSession.currentTarget).toBeNull();
-        });
-        it('has empty items', () => {
-            expect(dragSession.items).toEqual([]);
-        });
-        it('has empty types', () => {
-            expect(dragSession.types.size).toBe(0);
-        });
-    });
-    describe('source registration', () => {
-        it('registers and unregisters a source', () => {
-            const config = createSourceConfig('source-1');
-            const el = createElement();
-            const unregister = dragSession.registerSource(config, el);
-            expect(dragSession.getSource('source-1')).toBeDefined();
-            expect(dragSession.getSource('source-1').config).toBe(config);
-            unregister();
-            expect(dragSession.getSource('source-1')).toBeUndefined();
-            el.remove();
-        });
-    });
-    describe('target registration', () => {
-        it('registers and unregisters a target', () => {
-            const config = createTargetConfig('target-1');
-            const el = createElement();
-            const unregister = dragSession.registerTarget(config, el);
-            expect(dragSession.getTarget('target-1')).toBeDefined();
-            expect(dragSession.getTarget('target-1').config).toBe(config);
-            unregister();
-            expect(dragSession.getTarget('target-1')).toBeUndefined();
-            el.remove();
-        });
-    });
-    describe('keyboard drag', () => {
-        it('starts a keyboard drag session', () => {
-            const config = createSourceConfig('kb-source');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('kb-source');
-            expect(dragSession.isDragging).toBe(true);
-            expect(dragSession.sourceId).toBe('kb-source');
-            expect(dragSession.modality).toBe('keyboard');
-            expect(dragSession.items).toHaveLength(1);
-            expect(dragSession.types.has('test-type')).toBe(true);
-            expect(config.onDragStart).toHaveBeenCalled();
-            dragSession.cancel();
-            el.remove();
-        });
-        it('does not start if source is disabled', () => {
-            const config = createSourceConfig('disabled-source', { isDisabled: true });
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('disabled-source');
-            expect(dragSession.isDragging).toBe(false);
-            el.remove();
-        });
-        it('does not start if already dragging', () => {
-            const config1 = createSourceConfig('src-1');
-            const config2 = createSourceConfig('src-2');
-            const el1 = createElement();
-            const el2 = createElement();
-            dragSession.registerSource(config1, el1);
-            dragSession.registerSource(config2, el2);
-            dragSession.beginKeyboardDrag('src-1');
-            dragSession.beginKeyboardDrag('src-2');
-            expect(dragSession.sourceId).toBe('src-1'); // first one wins
-            dragSession.cancel();
-            el1.remove();
-            el2.remove();
-        });
-    });
-    describe('cancel', () => {
-        it('resets state and calls onDragEnd with cancel', () => {
-            const config = createSourceConfig('cancel-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('cancel-src');
-            expect(dragSession.isDragging).toBe(true);
-            dragSession.cancel();
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            expect(dragSession.items).toEqual([]);
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            el.remove();
-        });
-    });
-    describe('drop', () => {
-        it('calls onDrop on the target and onDragEnd on the source', async () => {
-            const sourceConfig = createSourceConfig('drop-src');
-            const targetConfig = createTargetConfig('drop-tgt', {
-                getDropOperation: () => 'move',
-                onDrop: vi.fn(),
-            });
-            const srcEl = createElement();
-            const tgtEl = createElement();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(targetConfig, tgtEl);
-            dragSession.beginKeyboardDrag('drop-src');
-            dragSession.focusNextTarget(); // navigate to the target
-            // Verify we're on a target
-            expect(dragSession.currentTargetId).toBe('drop-tgt');
-            await dragSession.drop();
-            expect(targetConfig.onDrop).toHaveBeenCalled();
-            expect(sourceConfig.onDragEnd).toHaveBeenCalledWith('move');
-            expect(dragSession.isDragging).toBe(false);
-            srcEl.remove();
-            tgtEl.remove();
-        });
-        it('cancels if no target is selected', async () => {
-            const config = createSourceConfig('no-tgt-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('no-tgt-src');
-            await dragSession.drop();
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            expect(dragSession.isDragging).toBe(false);
-            el.remove();
-        });
-    });
-    describe('target navigation', () => {
-        it('cycles through targets with focusNextTarget', () => {
-            const sourceConfig = createSourceConfig('nav-src');
-            const tgt1Config = createTargetConfig('nav-tgt-1');
-            const tgt2Config = createTargetConfig('nav-tgt-2');
-            const srcEl = createElement();
-            const tgt1El = createElement();
-            const tgt2El = createElement();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(tgt1Config, tgt1El);
-            dragSession.registerTarget(tgt2Config, tgt2El);
-            dragSession.beginKeyboardDrag('nav-src');
-            dragSession.focusNextTarget();
-            const first = dragSession.currentTargetId;
-            expect(first).toBeTruthy();
-            dragSession.focusNextTarget();
-            const second = dragSession.currentTargetId;
-            expect(second).toBeTruthy();
-            expect(second).not.toBe(first);
-            // Cycle back
-            dragSession.focusNextTarget();
-            expect(dragSession.currentTargetId).toBe(first);
-            dragSession.cancel();
-            srcEl.remove();
-            tgt1El.remove();
-            tgt2El.remove();
-        });
-    });
-    describe('subscriptions', () => {
-        it('notifies subscribers on state change', () => {
-            const callback = vi.fn();
-            const unsub = dragSession.subscribe(callback);
-            const config = createSourceConfig('sub-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('sub-src');
-            expect(callback).toHaveBeenCalled();
-            dragSession.cancel();
-            unsub();
-            el.remove();
-        });
-        it('unsubscribes correctly', () => {
-            const callback = vi.fn();
-            const unsub = dragSession.subscribe(callback);
-            unsub();
-            const config = createSourceConfig('unsub-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('unsub-src');
-            expect(callback).not.toHaveBeenCalled();
-            dragSession.cancel();
-            el.remove();
-        });
-    });
-    describe('collection context', () => {
-        it('sets and checks source collection', () => {
-            const config = createSourceConfig('coll-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('coll-src');
-            dragSession.setSourceCollection('list-A', new Set(['item-1', 'item-2']));
-            expect(dragSession.sourceCollectionId).toBe('list-A');
-            expect(dragSession.draggingKeys.has('item-1')).toBe(true);
-            expect(dragSession.draggingKeys.has('item-2')).toBe(true);
-            expect(dragSession.isInternalDrop('list-A')).toBe(true);
-            expect(dragSession.isInternalDrop('list-B')).toBe(false);
-            // wasDroppedExternally — no drop yet
-            expect(dragSession.wasDroppedExternally('list-A')).toBe(false);
-            dragSession.cancel();
-            el.remove();
-        });
-        it('wasDroppedExternally detects cross-list drops correctly', async () => {
-            const sourceConfig = createSourceConfig('cross-src');
-            const targetConfig = createTargetConfig('cross-tgt', {
-                getDropOperation: () => 'move',
-                onDrop: vi.fn(),
-            });
-            const srcEl = createElement();
-            const tgtEl = createElement();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(targetConfig, tgtEl);
-            dragSession.beginKeyboardDrag('cross-src');
-            dragSession.setSourceCollection('list-A', new Set(['item-1']));
-            dragSession.focusNextTarget();
-            // Before drop, dropCollectionId is null
-            expect(dragSession.wasDroppedExternally('list-A')).toBe(false);
-            await dragSession.drop();
-            // After drop, source's onDragEnd was called — check that the session
-            // correctly tracked that the drop went to a DIFFERENT collection
-            // (cross-tgt is NOT list-A, so wasDroppedExternally should be true)
-            // Note: by this point resetSession was called, so we test indirectly
-            // via the onDragEnd callback behavior
-            expect(sourceConfig.onDragEnd).toHaveBeenCalledWith('move');
-            srcEl.remove();
-            tgtEl.remove();
-        });
-    });
-    describe('touch long-press', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-            ensurePointerEventPolyfill();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-        function createTouchPointerEvent(type, x, y, pointerId = 1) {
-            return new PointerEvent(type, {
-                clientX: x,
-                clientY: y,
-                pointerId,
-                pointerType: 'touch',
-                bubbles: true,
-            });
-        }
-        it('does not start drag immediately on touch pointerdown', () => {
-            const config = createSourceConfig('touch-src');
-            const el = createElement();
-            // Stub setPointerCapture / releasePointerCapture
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            const event = createTouchPointerEvent('pointerdown', 100, 100);
-            dragSession.beginPointerDrag('touch-src', event);
-            // Should NOT be dragging yet — waiting for long-press timer
-            expect(dragSession.isDragging).toBe(false);
-            dragSession.cancel();
-            el.remove();
-        });
-        it('starts drag after 300ms long-press without movement', () => {
-            const config = createSourceConfig('touch-lp');
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            const event = createTouchPointerEvent('pointerdown', 100, 100);
-            dragSession.beginPointerDrag('touch-lp', event);
-            // Advance past the long-press delay
-            vi.advanceTimersByTime(300);
-            expect(dragSession.isDragging).toBe(true);
-            expect(dragSession.sourceId).toBe('touch-lp');
-            expect(config.onDragStart).toHaveBeenCalled();
-            dragSession.cancel();
-            el.remove();
-        });
-        it('cancels if touch moves too far before long-press fires', () => {
-            const config = createSourceConfig('touch-scroll');
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            const downEvent = createTouchPointerEvent('pointerdown', 100, 100);
-            dragSession.beginPointerDrag('touch-scroll', downEvent);
-            // Move more than 10px (LONG_PRESS_TOLERANCE) before timer fires
-            const moveEvent = createTouchPointerEvent('pointermove', 100, 120);
-            el.dispatchEvent(moveEvent);
-            // Even after timer would fire, drag should not start
-            vi.advanceTimersByTime(300);
-            expect(dragSession.isDragging).toBe(false);
-            expect(config.onDragStart).not.toHaveBeenCalled();
-            el.remove();
-        });
-        it('allows small touch jitter within tolerance', () => {
-            const config = createSourceConfig('touch-jitter');
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            const downEvent = createTouchPointerEvent('pointerdown', 100, 100);
-            dragSession.beginPointerDrag('touch-jitter', downEvent);
-            // Small movement within tolerance (< 10px)
-            const moveEvent = createTouchPointerEvent('pointermove', 103, 105);
-            el.dispatchEvent(moveEvent);
-            // Timer fires → drag should start despite small jitter
-            vi.advanceTimersByTime(300);
-            expect(dragSession.isDragging).toBe(true);
-            dragSession.cancel();
-            el.remove();
-        });
-    });
-    describe('exception safety (F-013)', () => {
-        it('resets session even if onDrop throws', async () => {
-            const sourceConfig = createSourceConfig('exc-src');
-            const targetConfig = createTargetConfig('exc-tgt', {
-                getDropOperation: () => 'move',
-                onDrop: vi.fn(() => {
-                    throw new Error('callback error');
-                }),
-            });
-            const srcEl = createElement();
-            const tgtEl = createElement();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(targetConfig, tgtEl);
-            dragSession.beginKeyboardDrag('exc-src');
-            dragSession.focusNextTarget();
-            await expect(dragSession.drop()).rejects.toThrow('callback error');
-            // Session MUST be cleaned up despite the exception
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            expect(dragSession.currentTarget).toBeNull();
-            srcEl.remove();
-            tgtEl.remove();
-        });
-        it('resets session even if onDragEnd throws on cancel', () => {
-            const config = createSourceConfig('exc-cancel', {
-                onDragEnd: vi.fn(() => {
-                    throw new Error('cancel callback error');
-                }),
-            });
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('exc-cancel');
-            expect(() => dragSession.cancel()).toThrow('cancel callback error');
-            // Session MUST be cleaned up
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            el.remove();
-        });
-    });
-    describe('keyboard focus on targets (F-014)', () => {
-        it('focuses target element on Tab navigation', () => {
-            const sourceConfig = createSourceConfig('focus-src');
-            const targetConfig = createTargetConfig('focus-tgt');
-            const srcEl = createElement();
-            const tgtEl = createElement();
-            tgtEl.tabIndex = 0;
-            tgtEl.focus = vi.fn();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(targetConfig, tgtEl);
-            dragSession.beginKeyboardDrag('focus-src');
-            dragSession.focusNextTarget();
-            expect(tgtEl.focus).toHaveBeenCalled();
-            dragSession.cancel();
-            srcEl.remove();
-            tgtEl.remove();
-        });
-    });
-    describe('pagehide cleanup (F-005)', () => {
-        it('resets session on pagehide event during active drag', () => {
-            const config = createSourceConfig('ph-src');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('ph-src');
-            expect(dragSession.isDragging).toBe(true);
-            // Simulate page navigation
-            window.dispatchEvent(new Event('pagehide'));
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            el.remove();
-        });
-        it('does nothing on pagehide when not dragging', () => {
-            // Just verify no error is thrown
-            window.dispatchEvent(new Event('pagehide'));
-            expect(dragSession.isDragging).toBe(false);
-        });
-    });
-    describe('pointer drag re-entrance (#190)', () => {
-        beforeEach(() => {
-            ensurePointerEventPolyfill();
-        });
-        function createMousePointerEvent(type, x, y) {
-            return new PointerEvent(type, {
-                clientX: x,
-                clientY: y,
-                pointerId: 1,
-                pointerType: 'mouse',
-                bubbles: true,
-            });
-        }
-        function registerSource(id) {
-            const config = createSourceConfig(id);
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            return { config, el };
-        }
-        it('a second beginPointerDrag while one is pending does not clobber the first', () => {
-            const inner = registerSource('inner-src');
-            const outer = registerSource('outer-src');
-            // Same pointerdown delivered to both sources (bubbling in a nested DOM)
-            const down = createMousePointerEvent('pointerdown', 100, 100);
-            dragSession.beginPointerDrag('inner-src', down);
-            expect(dragSession.sourceId).toBe('inner-src');
-            dragSession.beginPointerDrag('outer-src', down);
-            expect(dragSession.sourceId).toBe('inner-src'); // first claim wins
-            // Crossing the threshold activates the drag for the FIRST source
-            inner.el.dispatchEvent(createMousePointerEvent('pointermove', 110, 110));
-            expect(dragSession.isDragging).toBe(true);
-            expect(dragSession.sourceId).toBe('inner-src');
-            expect(inner.config.onDragStart).toHaveBeenCalled();
-            expect(outer.config.onDragStart).not.toHaveBeenCalled();
-            // And the session ends cleanly — no stuck ghost
-            inner.el.dispatchEvent(createMousePointerEvent('pointerup', 110, 110));
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            expect(document.querySelector('.sp-drag-ghost')).toBeNull();
-            inner.el.remove();
-            outer.el.remove();
-        });
-        it('releasing before the threshold clears the pending claim for the next drag', () => {
-            const a = registerSource('pending-a');
-            const b = registerSource('pending-b');
-            dragSession.beginPointerDrag('pending-a', createMousePointerEvent('pointerdown', 100, 100));
-            a.el.dispatchEvent(createMousePointerEvent('pointerup', 100, 100));
-            expect(dragSession.sourceId).toBeNull();
-            dragSession.beginPointerDrag('pending-b', createMousePointerEvent('pointerdown', 100, 100));
-            expect(dragSession.sourceId).toBe('pending-b');
-            dragSession.cancel();
-            a.el.remove();
-            b.el.remove();
-        });
-        it('keyboard drag cannot start while a pointer drag is pending', () => {
-            const a = registerSource('kb-block-a');
-            const b = registerSource('kb-block-b');
-            dragSession.beginPointerDrag('kb-block-a', createMousePointerEvent('pointerdown', 100, 100));
-            dragSession.beginKeyboardDrag('kb-block-b');
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBe('kb-block-a');
-            dragSession.cancel();
-            a.el.remove();
-            b.el.remove();
-        });
-        it('pagehide during a pending claim resets it so future drags are not blocked', () => {
-            const src = registerSource('ph-pending');
-            // Pointer down, threshold NOT crossed — claim is pending
-            dragSession.beginPointerDrag('ph-pending', createMousePointerEvent('pointerdown', 100, 100));
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBe('ph-pending');
-            // Page navigates during the pending claim
-            window.dispatchEvent(new Event('pagehide'));
-            expect(dragSession.sourceId).toBeNull();
-            // The re-entrance guard must not block the next drag
-            dragSession.beginPointerDrag('ph-pending', createMousePointerEvent('pointerdown', 100, 100));
-            expect(dragSession.sourceId).toBe('ph-pending');
-            dragSession.cancel();
-            src.el.remove();
-        });
-    });
-    describe('async onDrop (F-001)', () => {
-        it('awaits async onDrop callback before cleanup', async () => {
-            let dropResolved = false;
-            const sourceConfig = createSourceConfig('async-src');
-            const targetConfig = createTargetConfig('async-tgt', {
-                getDropOperation: () => 'move',
-                onDrop: vi.fn(async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                    dropResolved = true;
-                }),
-            });
-            const srcEl = createElement();
-            const tgtEl = createElement();
-            dragSession.registerSource(sourceConfig, srcEl);
-            dragSession.registerTarget(targetConfig, tgtEl);
-            dragSession.beginKeyboardDrag('async-src');
-            dragSession.focusNextTarget();
-            await dragSession.drop();
-            // The async callback should have resolved before we get here
-            expect(dropResolved).toBe(true);
-            expect(targetConfig.onDrop).toHaveBeenCalled();
-            expect(dragSession.isDragging).toBe(false);
-            srcEl.remove();
-            tgtEl.remove();
-        });
-    });
-    describe('escape cancels a POINTER drag (PR #138)', () => {
-        beforeEach(() => {
-            // The session is a module singleton: a test that left one active would
-            // make `beginPointerDrag` refuse re-entry here, and the keystroke would
-            // then be handled by the INHERITED session — a green that proves nothing.
-            dragSession.cancel();
-            ensurePointerEventPolyfill();
-        });
-        it('cancels the session, releases the capture and drops no item', () => {
-            const { config, el } = startPointerDrag('esc-src');
-            const target = createTargetConfig('esc-tgt');
-            const tgtEl = createElement();
-            dragSession.registerTarget(target, tgtEl);
-            expect(dragSession.isDragging).toBe(true);
-            pressEscape();
-            expect(dragSession.isDragging).toBe(false);
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            expect(target.onDrop).not.toHaveBeenCalled();
-            expect(el.releasePointerCapture).toHaveBeenCalled();
-            expect(document.documentElement.classList.contains('sp-drag-active')).toBe(false);
-            expect(document.querySelector('.sp-drag-ghost')).toBeNull();
-            el.remove();
-            tgtEl.remove();
-        });
-        it('does not resurrect the drag on the next pointermove', () => {
-            const { config, el } = startPointerDrag('esc-resurrect');
-            pressEscape();
-            expect(dragSession.isDragging).toBe(false);
-            // The listeners must be gone: _startX/_startY survive, so a surviving
-            // onMove would re-activate the session past the 5px threshold.
-            el.dispatchEvent(pointerEvent('pointermove', 300, 300));
-            expect(dragSession.isDragging).toBe(false);
-            expect(dragSession.sourceId).toBeNull();
-            expect(config.onDragStart).toHaveBeenCalledTimes(1);
-            el.remove();
-        });
-        it('leaves Escape to the application while the claim is still PENDING', () => {
-            const config = createSourceConfig('esc-pending');
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            dragSession.beginPointerDrag('esc-pending', pointerEvent('pointerdown', 100, 100));
-            // no pointermove: under the threshold, the session is not dragging
-            const event = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
-            document.dispatchEvent(event);
-            expect(event.defaultPrevented).toBe(false); // the keystroke belongs to the app
-            expect(config.onDragEnd).not.toHaveBeenCalled();
-            dragSession.cancel();
-            el.remove();
-        });
-    });
-    describe('escape priority over an already-mounted escape layer (see internal/escape-layer)', () => {
-        beforeEach(() => {
-            dragSession.cancel();
-            resetEscapeLayerStack();
-            ensurePointerEventPolyfill();
-        });
-        afterEach(() => {
-            resetEscapeLayerStack();
-        });
-        /**
-         * Mounts a layer BEFORE the drag starts — the order that exposes the bug.
-         * `EscapeLayer` registers its global handler on the first mount; a drag
-         * listener added later on the SAME node in the SAME phase runs after it,
-         * so `preventDefault()` arrives once the dialog has already closed.
-         */
-        function mountLayerFirst() {
-            const onEscapeKeydown = vi.fn();
-            const layer = new EscapeLayerState({ enabled: true, onEscapeKeydown });
-            layer.mount();
-            return { layer, onEscapeKeydown };
-        }
-        it('gives the first escape to the pointer drag and the second to the dialog', () => {
-            const { layer, onEscapeKeydown } = mountLayerFirst();
-            const { config, el } = startPointerDrag('esc-layer-pointer');
-            expect(dragSession.isDragging).toBe(true);
-            pressEscape();
-            expect(dragSession.isDragging).toBe(false);
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            expect(onEscapeKeydown).not.toHaveBeenCalled(); // the dialog must survive
-            pressEscape();
-            expect(onEscapeKeydown).toHaveBeenCalledTimes(1); // now it closes normally
-            layer.unmount();
-            el.remove();
-        });
-        it('gives the first escape to the keyboard drag and the second to the dialog', () => {
-            const { layer, onEscapeKeydown } = mountLayerFirst();
-            const config = createSourceConfig('esc-layer-keyboard');
-            const el = createElement();
-            dragSession.registerSource(config, el);
-            dragSession.beginKeyboardDrag('esc-layer-keyboard');
-            expect(dragSession.isDragging).toBe(true);
-            pressEscape();
-            expect(dragSession.isDragging).toBe(false);
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            expect(onEscapeKeydown).not.toHaveBeenCalled();
-            pressEscape();
-            expect(onEscapeKeydown).toHaveBeenCalledTimes(1);
-            layer.unmount();
-            el.remove();
-        });
-        it('keeps that priority when the layer mounts AFTER the drag has started', () => {
-            // The mirror order. It was already green by accident — the drag listener
-            // happened to be registered first. The point of the pair is that the
-            // outcome no longer depends on which one registered first.
-            const { config, el } = startPointerDrag('esc-layer-after');
-            const { layer, onEscapeKeydown } = mountLayerFirst();
-            expect(dragSession.isDragging).toBe(true);
-            pressEscape();
-            expect(dragSession.isDragging).toBe(false);
-            expect(config.onDragEnd).toHaveBeenCalledWith('cancel');
-            expect(onEscapeKeydown).not.toHaveBeenCalled();
-            pressEscape();
-            expect(onEscapeKeydown).toHaveBeenCalledTimes(1);
-            layer.unmount();
-            el.remove();
-        });
-        it('leaves the dialog closable immediately while the claim is still pending', () => {
-            const { layer, onEscapeKeydown } = mountLayerFirst();
-            const config = createSourceConfig('esc-layer-pending');
-            const el = createElement();
-            el.setPointerCapture = vi.fn();
-            el.releasePointerCapture = vi.fn();
-            dragSession.registerSource(config, el);
-            dragSession.beginPointerDrag('esc-layer-pending', pointerEvent('pointerdown', 100, 100));
-            // no pointermove: under the 5px threshold the session is only PENDING
-            pressEscape();
-            expect(onEscapeKeydown).toHaveBeenCalledTimes(1); // closing stays immediate
-            expect(config.onDragEnd).not.toHaveBeenCalled();
-            dragSession.cancel();
-            layer.unmount();
-            el.remove();
-        });
-    });
-    describe('pointer drop target is computed at release', () => {
-        beforeEach(() => {
-            dragSession.cancel();
-            ensurePointerEventPolyfill();
-        });
-        it('drops on the target under the pointerup when no animation frame has run', async () => {
-            const { config, el } = startPointerDrag('release-src');
-            const target = createTargetConfig('release-tgt');
-            const onPointerUpdate = vi.fn();
-            const tgtEl = createElement(); // rect 0,0 → 200,100
-            dragSession.registerTarget(target, tgtEl, onPointerUpdate);
-            // move then up inside the SAME frame: no requestAnimationFrame callback
-            // has run, so the throttled hit-test never saw either position.
-            el.dispatchEvent(pointerEvent('pointermove', 150, 70));
-            el.dispatchEvent(pointerEvent('pointerup', 150, 70));
-            expect(onPointerUpdate).toHaveBeenCalledWith(150, 70);
-            expect(target.onDrop).toHaveBeenCalledTimes(1);
-            // completeDrop awaits onDrop, so the end-of-drag callback lands one
-            // microtask later even when onDrop is synchronous.
-            await Promise.resolve();
-            expect(config.onDragEnd).toHaveBeenCalledWith('move');
-            el.remove();
-            tgtEl.remove();
-        });
-        it('cancels the pending frame so a stale position cannot land during an async drop', async () => {
-            const { el } = startPointerDrag('release-async-src');
-            let resolveDrop = null;
-            const onDrop = vi.fn(() => new Promise((resolve) => {
-                resolveDrop = resolve;
-            }));
-            const target = createTargetConfig('release-async-tgt', { onDrop });
-            const onPointerUpdate = vi.fn();
-            const tgtEl = createElement();
-            dragSession.registerTarget(target, tgtEl, onPointerUpdate);
-            // 50,70 is INSIDE the target, so a surviving frame would call
-            // onPointerUpdate again with those stale coordinates.
-            el.dispatchEvent(pointerEvent('pointermove', 50, 70));
-            el.dispatchEvent(pointerEvent('pointerup', 150, 70));
-            expect(onPointerUpdate).toHaveBeenCalledTimes(1);
-            expect(onPointerUpdate).toHaveBeenLastCalledWith(150, 70);
-            // completeDrop is still awaiting onDrop — the session is alive, which is
-            // exactly the window a surviving frame would fire in.
-            await new Promise((resolve) => setTimeout(resolve, 48));
-            expect(onPointerUpdate).toHaveBeenCalledTimes(1);
-            expect(onPointerUpdate).toHaveBeenLastCalledWith(150, 70);
-            resolveDrop();
-            el.remove();
-            tgtEl.remove();
-        });
-    });
-    describe('pointer hit-test honours acceptedTypes', () => {
-        beforeEach(() => {
-            dragSession.cancel();
-            ensurePointerEventPolyfill();
-        });
-        it('never makes a target whose accepted types miss the drag the current one', async () => {
-            const { el } = startPointerDrag('types-src'); // carries 'test-type' + 'text/plain'
-            // Registered FIRST and covering the same rect: without the filter the
-            // hit-test stops here, because it breaks at the first rect containing
-            // the point.
-            const foreign = createTargetConfig('types-foreign', { acceptedTypes: ['other-type'] });
-            const foreignEl = createElement();
-            const foreignUpdate = vi.fn();
-            dragSession.registerTarget(foreign, foreignEl, foreignUpdate);
-            const own = createTargetConfig('types-own', { acceptedTypes: ['test-type'] });
-            const ownEl = createElement();
-            const ownUpdate = vi.fn();
-            dragSession.registerTarget(own, ownEl, ownUpdate);
-            el.dispatchEvent(pointerEvent('pointerup', 150, 70));
-            expect(foreignUpdate).not.toHaveBeenCalled();
-            expect(foreign.onDrop).not.toHaveBeenCalled();
-            expect(ownUpdate).toHaveBeenCalledWith(150, 70);
-            expect(own.onDrop).toHaveBeenCalledTimes(1);
-            await Promise.resolve();
-            el.remove();
-            foreignEl.remove();
-            ownEl.remove();
-        });
-        it('still accepts everything when acceptedTypes is absent or empty', async () => {
-            // Non-regression guard for the catch-all: green before and after the
-            // filter, and it must never turn red.
-            const { el } = startPointerDrag('types-catchall-src');
-            const catchAll = createTargetConfig('types-catchall');
-            const catchAllEl = createElement();
-            const catchAllUpdate = vi.fn();
-            dragSession.registerTarget(catchAll, catchAllEl, catchAllUpdate);
-            const empty = createTargetConfig('types-empty', { acceptedTypes: [] });
-            const emptyEl = createElement();
-            dragSession.registerTarget(empty, emptyEl, vi.fn());
-            el.dispatchEvent(pointerEvent('pointerup', 150, 70));
-            expect(catchAllUpdate).toHaveBeenCalledWith(150, 70);
-            expect(catchAll.onDrop).toHaveBeenCalledTimes(1);
-            await Promise.resolve();
-            el.remove();
-            catchAllEl.remove();
-            emptyEl.remove();
-        });
-    });
-});