@flighthq/interaction 0.2.0 → 0.2.1-next.410.a23f189

package/src/hitTests.test.ts

@@ -1,32 +1,186 @@
 import { createDisplayObject, createDisplayObjectGeneric, getDisplayObjectRuntime } from '@flighthq/displayobject';
-import { setRectangle } from '@flighthq/geometry';
+import { createRectangle, setRectangle } from '@flighthq/geometry';
 import { addNodeChild, getNodeLocalBoundsRectangle, invalidateNodeLocalTransform } from '@flighthq/node';
-import type { DisplayObject, DisplayObjectRuntime } from '@flighthq/types';
+import { appendPathRectangle, createPath } from '@flighthq/path';
+import type { DisplayObject, DisplayObjectRuntime, HitTestResult, NodeAny } from '@flighthq/types';
 import { DisplayObjectKind } from '@flighthq/types';
 
 import {
+  describeGraphHit,
   findGraphHitTarget,
+  findGraphHitTargetPrecise,
+  findGraphHitTargets,
+  findGraphHitTargetsPrecise,
   hitTestDisplayObjects,
   hitTestGraphLocalBounds,
   hitTestGraphPoint,
-  registerHitTestPoint,
+  hitTestGraphPointPrecise,
+  hitTestNodeRegion,
+  registerHitTest,
+  registerHitTestPrecise,
 } from './hitTests';
+import { setNodeHitArea, setNodeHitTestEnabled } from './nodeInteractionState';
+
+// A precise provider over local bounds: 0 (hit) inside, -1 outside — the boolean-precise shape.
+function boundsPrecise(source: NodeAny, x: number, y: number): number {
+  return hitTestGraphLocalBounds(source, x, y) ? 0 : -1;
+}
+
+function boundsObject(w: number, h: number): DisplayObject {
+  const obj = createDisplayObject();
+  setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, w, h);
+  setNodeHitTestEnabled(obj, true);
+  return obj;
+}
+
+function emptyResult(node: DisplayObject): HitTestResult {
+  return { localX: 0, localY: 0, node, subIndex: -2 };
+}
+
+beforeAll(() => {
+  registerHitTest(DisplayObjectKind, hitTestGraphLocalBounds);
+});
+
+describe('describeGraphHit', () => {
+  it('fills node, local coordinates, and the sub-index from the kind exact provider', () => {
+    const kind = 'DescribeKind';
+    const node = createDisplayObjectGeneric(kind);
+    node.x = 40;
+    node.y = 40;
+    invalidateNodeLocalTransform(node);
+    setRectangle(getNodeLocalBoundsRectangle(node), 0, 0, 100, 100);
+    registerHitTestPrecise(kind, () => 7);
+    const out = emptyResult(node);
+    describeGraphHit(node, 50, 50, out);
+    expect(out.node).toBe(node);
+    expect(out.localX).toBe(10);
+    expect(out.localY).toBe(10);
+    expect(out.subIndex).toBe(7);
+  });
+
+  it('reports subIndex -1 when the kind has no exact provider', () => {
+    const obj = boundsObject(100, 100);
+    const out = emptyResult(obj);
+    describeGraphHit(obj, 50, 50, out);
+    expect(out.subIndex).toBe(-1);
+  });
+});
 
 describe('findGraphHitTarget', () => {
   it('returns null when node is disabled', () => {
-    const obj = createDisplayObject();
+    const obj = boundsObject(100, 100);
     obj.enabled = false;
     expect(findGraphHitTarget(obj, 50, 50)).toBeNull();
   });
 
-  it('returns a child node registered with a hit handler', () => {
+  it('is not a candidate until it opts in, then is', () => {
+    const obj = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+    expect(findGraphHitTarget(obj, 50, 50)).toBeNull();
+    setNodeHitTestEnabled(obj, true);
+    expect(findGraphHitTarget(obj, 50, 50)).toBe(obj);
+    setNodeHitTestEnabled(obj, false);
+    expect(findGraphHitTarget(obj, 50, 50)).toBeNull();
+  });
+
+  it('descends into an un-opted-in parent to reach an opted-in child', () => {
     const parent = createDisplayObject();
-    const child = createDisplayObjectGeneric(DisplayObjectKind);
-    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    const child = boundsObject(100, 100);
+    addNodeChild(parent, child);
+    expect(findGraphHitTarget(parent, 50, 50)).toBe(child);
+  });
+
+  it('treats a hitArea node as an atomic unit that consumes and hides its children', () => {
+    const parent = boundsObject(200, 200);
+    const child = boundsObject(50, 50);
     addNodeChild(parent, child);
-    registerHitTestPoint(DisplayObjectKind, hitTestGraphLocalBounds);
-    const hit = findGraphHitTarget(parent, 50, 50);
-    expect(hit).toBe(child);
+    setNodeHitArea(parent, 'bounds');
+    expect(findGraphHitTarget(parent, 25, 25)).toBe(parent);
+  });
+
+  it('resolves a rectangle hitArea in the node local space, through the world transform', () => {
+    const obj = createDisplayObject();
+    obj.x = 40;
+    obj.y = 40;
+    invalidateNodeLocalTransform(obj);
+    setNodeHitTestEnabled(obj, true);
+    setNodeHitArea(obj, createRectangle(0, 0, 100, 100));
+    expect(findGraphHitTarget(obj, 50, 50)).toBe(obj);
+    expect(findGraphHitTarget(obj, 20, 20)).toBeNull();
+  });
+
+  it('resolves a path hitArea by winding, and a node proxy in the proxy world space', () => {
+    const pathObj = createDisplayObject();
+    setNodeHitTestEnabled(pathObj, true);
+    const path = createPath();
+    appendPathRectangle(path, 0, 0, 30, 30);
+    setNodeHitArea(pathObj, path);
+    expect(findGraphHitTarget(pathObj, 10, 10)).toBe(pathObj);
+    expect(findGraphHitTarget(pathObj, 40, 40)).toBeNull();
+
+    const proxyOwner = createDisplayObject();
+    const proxy = createDisplayObjectGeneric(DisplayObjectKind);
+    setRectangle(getNodeLocalBoundsRectangle(proxy), 0, 0, 20, 20);
+    setNodeHitTestEnabled(proxyOwner, true);
+    setNodeHitArea(proxyOwner, proxy);
+    expect(findGraphHitTarget(proxyOwner, 5, 5)).toBe(proxyOwner);
+    expect(findGraphHitTarget(proxyOwner, 50, 50)).toBeNull();
+  });
+});
+
+describe('findGraphHitTargetPrecise', () => {
+  it('uses the kind exact provider, so a bbox hit off the real geometry misses', () => {
+    const kind = 'PreciseFirstKind';
+    const node = createDisplayObjectGeneric(kind);
+    setRectangle(getNodeLocalBoundsRectangle(node), 0, 0, 100, 100);
+    setNodeHitTestEnabled(node, true);
+    // Exact provider only accepts the left half.
+    registerHitTestPrecise(kind, (s, x, y) => (hitTestGraphLocalBounds(s, x, y) && x < 50 ? 0 : -1));
+    registerHitTest(kind, hitTestGraphLocalBounds);
+    expect(findGraphHitTargetPrecise(node, 25, 50)).toBe(node);
+    expect(findGraphHitTargetPrecise(node, 75, 50)).toBeNull();
+    // Coarse still hits the whole box.
+    expect(findGraphHitTarget(node, 75, 50)).toBe(node);
+  });
+
+  it('falls back to the coarse bounds handler when no exact provider is registered', () => {
+    const obj = boundsObject(100, 100);
+    expect(findGraphHitTargetPrecise(obj, 50, 50)).toBe(obj);
+  });
+});
+
+describe('findGraphHitTargets', () => {
+  it('collects every hit under the point, front-to-back', () => {
+    const root = createDisplayObject();
+    const under = boundsObject(100, 100);
+    const over = boundsObject(100, 100);
+    addNodeChild(root, under);
+    addNodeChild(root, over);
+    const stack = findGraphHitTargets(root, 50, 50);
+    expect(stack).toEqual([over, under]);
+  });
+
+  it('clears the out array and returns it', () => {
+    const obj = boundsObject(100, 100);
+    const out: DisplayObject[] = [createDisplayObject()];
+    const result = findGraphHitTargets(obj, 50, 50, out);
+    expect(result).toBe(out);
+    expect(out).toEqual([obj]);
+  });
+});
+
+describe('findGraphHitTargetsPrecise', () => {
+  it('collects hits using exact geometry per kind', () => {
+    const kind = 'PreciseStackKind';
+    registerHitTest(kind, hitTestGraphLocalBounds);
+    registerHitTestPrecise(kind, boundsPrecise);
+    const root = createDisplayObject();
+    const a = createDisplayObjectGeneric(kind);
+    setRectangle(getNodeLocalBoundsRectangle(a), 0, 0, 100, 100);
+    setNodeHitTestEnabled(a, true);
+    addNodeChild(root, a);
+    expect(findGraphHitTargetsPrecise(root, 50, 50)).toEqual([a]);
+    expect(findGraphHitTargetsPrecise(root, 500, 500)).toEqual([]);
   });
 });
 
@@ -37,53 +191,32 @@ describe('hitTestDisplayObjects', () => {
   beforeEach(() => {
     a = createDisplayObject();
     b = createDisplayObject();
-
     addNodeChild(createDisplayObject(), a);
     addNodeChild(createDisplayObject(), b);
-
     setRectangle(getNodeLocalBoundsRectangle(a), 0, 0, 10, 10);
     setRectangle(getNodeLocalBoundsRectangle(b), 0, 0, 10, 10);
-
     a.x = 0;
     a.y = 0;
     b.x = 5;
     b.y = 5;
-
     a.scaleX = a.scaleY = 1;
     b.scaleX = b.scaleY = 1;
   });
 
   it('returns true when bounds intersect', () => {
-    const result = hitTestDisplayObjects(a, b);
-    expect(result).toBe(true);
+    expect(hitTestDisplayObjects(a, b)).toBe(true);
   });
 
   it('returns false when bounds do not intersect', () => {
     b.x = 20;
     b.y = 20;
     invalidateNodeLocalTransform(b);
-
-    const result = hitTestDisplayObjects(a, b);
-    expect(result).toBe(false);
+    expect(hitTestDisplayObjects(a, b)).toBe(false);
   });
 
   it('returns false if either object has no parent', () => {
     (getDisplayObjectRuntime(b) as DisplayObjectRuntime).parent = null;
-
-    const result = hitTestDisplayObjects(a, b);
-    expect(result).toBe(false);
-  });
-
-  it('compares bounds in world space', () => {
-    a.scaleX = 1;
-    a.scaleY = 1;
-
-    b.x = 5;
-    b.y = 5;
-    invalidateNodeLocalTransform(b);
-
-    const result = hitTestDisplayObjects(a, b);
-    expect(result).toBe(true);
+    expect(hitTestDisplayObjects(a, b)).toBe(false);
   });
 
   it('includes child bounds when a child extends beyond the object local bounds', () => {
@@ -93,25 +226,18 @@ describe('hitTestDisplayObjects', () => {
     invalidateNodeLocalTransform(child);
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 20, 20);
     addNodeChild(a, child);
-
     b.x = 100;
     b.y = 100;
     invalidateNodeLocalTransform(b);
-
     expect(hitTestDisplayObjects(a, b)).toBe(true);
   });
 });
 
 describe('hitTestGraphLocalBounds', () => {
-  it('returns true when world-space point is inside local bounds', () => {
+  it('returns whether a world-space point is inside local bounds', () => {
     const obj = createDisplayObject();
     setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
     expect(hitTestGraphLocalBounds(obj, 50, 50)).toBe(true);
-  });
-
-  it('returns false when world-space point is outside local bounds', () => {
-    const obj = createDisplayObject();
-    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
     expect(hitTestGraphLocalBounds(obj, 200, 200)).toBe(false);
   });
 });
@@ -119,88 +245,99 @@ describe('hitTestGraphLocalBounds', () => {
 describe('hitTestGraphPoint', () => {
   let obj: DisplayObject;
 
-  beforeAll(() => {
-    registerHitTestPoint(DisplayObjectKind, hitTestGraphLocalBounds);
-  });
-
   beforeEach(() => {
-    obj = createDisplayObject();
-    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+    obj = boundsObject(100, 100);
   });
 
-  it('returns true for point inside bounds', () => {
-    const result = hitTestGraphPoint(obj, 50, 50);
-    expect(result).toBe(true);
+  it('returns true for point inside bounds, false outside', () => {
+    expect(hitTestGraphPoint(obj, 50, 50)).toBe(true);
+    expect(hitTestGraphPoint(obj, 200, 200)).toBe(false);
   });
 
-  it('returns false for point outside bounds', () => {
-    const result = hitTestGraphPoint(obj, 200, 200);
-    expect(result).toBe(false);
+  it('returns false for a node that has not opted in', () => {
+    const other = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(other), 0, 0, 100, 100);
+    expect(hitTestGraphPoint(other, 50, 50)).toBe(false);
   });
 
   it('returns false if object is not enabled', () => {
     obj.enabled = false;
-    const result = hitTestGraphPoint(obj, 50, 50);
-    expect(result).toBe(false);
+    expect(hitTestGraphPoint(obj, 50, 50)).toBe(false);
   });
 
-  it('returns false when point is outside bounds', () => {
-    const result = hitTestGraphPoint(obj, 200, 200);
-    expect(result).toBe(false);
+  it('returns true when an opted-in child is hit even if the parent is inert', () => {
+    const parent = createDisplayObject();
+    const child = boundsObject(100, 100);
+    addNodeChild(parent, child);
+    expect(hitTestGraphPoint(parent, 50, 50)).toBe(true);
   });
 
-  it('respects world transform', () => {
-    obj.x = 100;
-    obj.y = 100;
-    invalidateNodeLocalTransform(obj);
-    const inside = hitTestGraphPoint(obj, 150, 150);
-    const outside = hitTestGraphPoint(obj, 50, 50);
-
-    expect(inside).toBe(true);
-    expect(outside).toBe(false);
+  it('does not test children of a disabled parent', () => {
+    const parent = createDisplayObject();
+    parent.enabled = false;
+    const child = boundsObject(100, 100);
+    addNodeChild(parent, child);
+    expect(hitTestGraphPoint(parent, 50, 50)).toBe(false);
   });
+});
 
-  it('works with the default shapeFlag param', () => {
-    const result = hitTestGraphPoint(obj, 50, 50);
-    expect(result).toBe(true);
-
-    const resultExplicit = hitTestGraphPoint(obj, 50, 50, true);
-    expect(resultExplicit).toBe(true);
+describe('hitTestGraphPointPrecise', () => {
+  it('uses exact geometry, so a bbox hit off the real geometry misses', () => {
+    const kind = 'PreciseAnyKind';
+    const node = createDisplayObjectGeneric(kind);
+    setRectangle(getNodeLocalBoundsRectangle(node), 0, 0, 100, 100);
+    setNodeHitTestEnabled(node, true);
+    registerHitTestPrecise(kind, (s, x, y) => (hitTestGraphLocalBounds(s, x, y) && x < 50 ? 0 : -1));
+    expect(hitTestGraphPointPrecise(node, 25, 50)).toBe(true);
+    expect(hitTestGraphPointPrecise(node, 75, 50)).toBe(false);
   });
+});
 
-  it('returns true when a child is hit even if the parent has no local bounds', () => {
-    const child = createDisplayObject();
-    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
-    addNodeChild(obj, child);
-
-    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 0, 0);
-    expect(hitTestGraphPoint(obj, 50, 50)).toBe(true);
+describe('hitTestNodeRegion', () => {
+  it('tests a node kind geometry, ignoring eligibility and children', () => {
+    const obj = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+    expect(hitTestNodeRegion(obj, 50, 50)).toBe(true);
+    expect(hitTestNodeRegion(obj, 200, 200)).toBe(false);
   });
 
-  it('does not test children of a disabled parent', () => {
-    obj.enabled = false;
-
-    const child = createDisplayObject();
-    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
-    addNodeChild(obj, child);
-
-    expect(hitTestGraphPoint(obj, 50, 50)).toBe(false);
+  it('uses the hitArea when one is set', () => {
+    const obj = createDisplayObject();
+    setNodeHitArea(obj, createRectangle(0, 0, 30, 30));
+    expect(hitTestNodeRegion(obj, 10, 10)).toBe(true);
+    expect(hitTestNodeRegion(obj, 40, 40)).toBe(false);
   });
 
-  it('uses a registered handler for a custom kind', () => {
-    const CustomKind = 'CustomKind';
-    registerHitTestPoint(CustomKind, () => true);
-    const custom = createDisplayObjectGeneric(CustomKind);
-
-    expect(hitTestGraphPoint(custom, 50, 50)).toBe(true);
+  it('uses the exact provider when precise', () => {
+    const kind = 'RegionPreciseKind';
+    const node = createDisplayObjectGeneric(kind);
+    setRectangle(getNodeLocalBoundsRectangle(node), 0, 0, 100, 100);
+    registerHitTestPrecise(kind, (s, x, y) => (hitTestGraphLocalBounds(s, x, y) && x < 50 ? 0 : -1));
+    expect(hitTestNodeRegion(node, 25, 50, true)).toBe(true);
+    expect(hitTestNodeRegion(node, 75, 50, true)).toBe(false);
   });
 });
 
-describe('registerHitTestPoint', () => {
-  it('registers a handler that hitTestGraphPoint will use', () => {
+describe('registerHitTest', () => {
+  it('registers a coarse handler that hitTestGraphPoint will use', () => {
     const kind = 'RegisterTest';
-    registerHitTestPoint(kind, () => true);
+    registerHitTest(kind, () => true);
     const node = createDisplayObjectGeneric(kind);
+    setNodeHitTestEnabled(node, true);
     expect(hitTestGraphPoint(node, 0, 0)).toBe(true);
   });
 });
+
+describe('registerHitTestPrecise', () => {
+  it('registers an exact provider used by the precise queries and describeGraphHit', () => {
+    const kind = 'RegisterPreciseTest';
+    registerHitTest(kind, () => true);
+    registerHitTestPrecise(kind, () => 3);
+    const node = createDisplayObjectGeneric(kind);
+    setNodeHitTestEnabled(node, true);
+    expect(findGraphHitTargetPrecise(node, 0, 0)).toBe(node);
+    const out = emptyResult(node);
+    describeGraphHit(node, 0, 0, out);
+    expect(out.subIndex).toBe(3);
+  });
+});

package/src/interactionManager.test.ts

@@ -2,11 +2,11 @@ import { createDisplayObject } from '@flighthq/displayobject';
 import { setRectangle } from '@flighthq/geometry';
 import { addNodeChild, createNode, getNodeLocalBoundsRectangle, invalidateNodeLocalTransform } from '@flighthq/node';
 import { connectSignal, createSignal, emitSignal } from '@flighthq/signals';
-import type { InputKeyboardData, InputPointerData, InputSignals } from '@flighthq/types';
+import type { Cursor, InputKeyboardData, InputPointerData, InputSignals } from '@flighthq/types';
 import { DisplayObjectKind } from '@flighthq/types';
 
 import { hitTestGraphLocalBounds } from './hitTests';
-import { registerHitTestPoint } from './hitTests';
+import { registerHitTest } from './hitTests';
 import {
   captureInteractionPointer,
   connectInputToInteraction,
@@ -25,10 +25,12 @@ import {
   enableInteractionSignals,
   getInteractionSignals,
   releaseInteractionPointer,
+  setInteractionConnectGuard,
 } from './interactionManager';
+import { setNodeCursor, setNodeHitTestEnabled } from './nodeInteractionState';
 
 beforeAll(() => {
-  registerHitTestPoint(DisplayObjectKind, hitTestGraphLocalBounds);
+  registerHitTest(DisplayObjectKind, hitTestGraphLocalBounds);
 });
 
 describe('captureInteractionPointer', () => {
@@ -76,10 +78,11 @@ describe('connectInteractionSignal', () => {
   it('can use tracked subscribers without scanning for direct signal connections', () => {
     const kind = 'TrackedSubscriberHitTest';
     const root = createNode(kind);
+    setNodeHitTestEnabled(root, true);
     const manager = createInteractionManager(root, { trackedSubscribersOnly: true });
     let fired = 0;
     let hitTests = 0;
-    registerHitTestPoint(kind, () => {
+    registerHitTest(kind, () => {
       hitTests++;
       return true;
     });
@@ -98,10 +101,11 @@ describe('connectInteractionSignal', () => {
   it('clears tracked once subscribers after dispatch', () => {
     const kind = 'TrackedOnceHitTest';
     const root = createNode(kind);
+    setNodeHitTestEnabled(root, true);
     const manager = createInteractionManager(root, { trackedSubscribersOnly: true });
     let fired = 0;
     let hitTests = 0;
-    registerHitTestPoint(kind, () => {
+    registerHitTest(kind, () => {
       hitTests++;
       return true;
     });
@@ -137,6 +141,13 @@ describe('createInteractionManager', () => {
     expect(manager.enabled).toBe(true);
     expect(manager.trackedSubscribersOnly).toBe(true);
   });
+
+  it('defaults cursorBackend to null and accepts one via options', () => {
+    const root = createDisplayObject();
+    expect(createInteractionManager(root).cursorBackend).toBeNull();
+    const backend = { setCursor: () => {} };
+    expect(createInteractionManager(root, { cursorBackend: backend }).cursorBackend).toBe(backend);
+  });
 });
 
 describe('createInteractionSignals', () => {
@@ -168,11 +179,12 @@ describe('disconnectInteractionSignal', () => {
   it('disconnects a tracked subscriber and removes the dispatch cost', () => {
     const kind = 'DisconnectTrackedHitTest';
     const root = createNode(kind);
+    setNodeHitTestEnabled(root, true);
     const manager = createInteractionManager(root, { trackedSubscribersOnly: true });
     let fired = 0;
     let hitTests = 0;
     const slot = () => fired++;
-    registerHitTestPoint(kind, () => {
+    registerHitTest(kind, () => {
       hitTests++;
       return true;
     });
@@ -254,7 +266,7 @@ describe('dispatchInteractionPointerDown', () => {
     const root = createNode(kind);
     const manager = createInteractionManager(root);
     let hitTests = 0;
-    registerHitTestPoint(kind, () => {
+    registerHitTest(kind, () => {
       hitTests++;
       return true;
     });
@@ -268,7 +280,7 @@ describe('dispatchInteractionPointerDown', () => {
     const root = createNode(kind);
     const manager = createInteractionManager(root);
     let hitTests = 0;
-    registerHitTestPoint(kind, () => {
+    registerHitTest(kind, () => {
       hitTests++;
       return true;
     });
@@ -288,6 +300,7 @@ describe('dispatchInteractionPointerDown', () => {
     const root = createDisplayObject();
     const child = createDisplayObject();
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
     addNodeChild(root, child);
 
     const signals = enableInteractionSignals(child);
@@ -303,6 +316,7 @@ describe('dispatchInteractionPointerDown', () => {
     const root = createDisplayObject();
     const child = createDisplayObject();
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
     addNodeChild(root, child);
 
     const signals = enableInteractionSignals(child);
@@ -318,6 +332,7 @@ describe('dispatchInteractionPointerDown', () => {
     const root = createDisplayObject();
     const child = createDisplayObject();
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
     addNodeChild(root, child);
 
     const signals = enableInteractionSignals(child);
@@ -341,6 +356,7 @@ describe('dispatchInteractionPointerDown', () => {
     child.y = 20;
     invalidateNodeLocalTransform(child);
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
     addNodeChild(root, child);
 
     const manager = createInteractionManager(root);
@@ -379,6 +395,7 @@ describe('dispatchInteractionPointerDown', () => {
     child.y = 7;
     invalidateNodeLocalTransform(child);
     setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
     addNodeChild(root, parent);
     addNodeChild(parent, child);
 
@@ -422,6 +439,23 @@ describe('dispatchInteractionPointerMove', () => {
     expect(fired).toBe(1);
   });
 
+  it('applies the rollover target cursor and clears it on exit — even with no move subscribers', () => {
+    const root = createDisplayObject();
+    const child = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    setNodeHitTestEnabled(child, true);
+    addNodeChild(root, child);
+    const applied: (Cursor | null)[] = [];
+    const manager = createInteractionManager(root, { cursorBackend: { setCursor: (c) => applied.push(c) } });
+    setNodeCursor(child, 'pointer');
+
+    dispatchInteractionPointerMove(manager, 50, 50);
+    expect(applied.at(-1)).toBe('pointer');
+
+    dispatchInteractionPointerMove(manager, 500, 500);
+    expect(applied.at(-1)).toBeNull();
+  });
+
   it('fires over and roll over when entering a target', () => {
     const { child, manager } = createHitScene();
     const order: string[] = [];
@@ -562,10 +596,27 @@ describe('releaseInteractionPointer', () => {
   });
 });
 
+describe('setInteractionConnectGuard', () => {
+  it('invokes the installed guard when a signal is connected, and stops after null', () => {
+    const root = createDisplayObject();
+    const manager = createInteractionManager(root);
+    const seen: string[] = [];
+    setInteractionConnectGuard((target, name) => {
+      void target;
+      seen.push(name);
+    });
+    connectInteractionSignal(manager, root, 'onPointerDown', () => {});
+    setInteractionConnectGuard(null);
+    connectInteractionSignal(manager, root, 'onPointerUp', () => {});
+    expect(seen).toEqual(['onPointerDown']);
+  });
+});
+
 function createHitScene() {
   const root = createDisplayObject();
   const child = createDisplayObject();
   setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+  setNodeHitTestEnabled(child, true);
   addNodeChild(root, child);
   return { child, manager: createInteractionManager(root), root };
 }