@symbiote-native/engine 1.3.0 → 1.4.0

package/build/events/index.js

@@ -1,374 +1,217 @@
-// Event normalization. Fabric delivers raw touch primitives to a single global
-// handler, with the instanceHandle (our SymbioteNode) as the target. There is no
-// raw `press` event; a tap is synthesized from a touch sequence: the start and
-// end targets are correlated so a press fires only when the touch ends on the
-// node it started on (or a descendant). Bubbling events walk target -> root,
-// invoking each ancestor's listener until one calls stopPropagation. Layout is a
-// direct event in RN and is delivered only to its own target.
+// Event normalization. Fabric delivers raw touch primitives to a single global handler with the
+// `instanceHandle` (our `ISymbioteNode`) as the target, and there is no raw `press`: a tap is
+// synthesized here from a touch sequence
+// The pieces live in siblings, kept apart т.к. they answer different questions: `./names` what an
+// event is called, `./delivery` who receives it, `./press` what a tap is made of, `./responder`
+// who owns the gesture
 import { dlog, isDebug } from '../debug.js';
 import { runWrapped } from '../dispatch.js';
 import { getSlot } from '../fabric.js';
-import { isAnchor, isSymbioteNode, } from '../node.js';
+import { isSymbioteNode } from '../node.js';
 import { registeredNativeEvent } from '../registry.js';
-import { ancestorsOf, parentOf } from '../host-access.js';
-import { setIsJSResponder } from '../imperative.js';
 import { attachTouchHistory, recordTouchTrack, resetTouchHistory, touchHistory, } from '../touch-history.js';
-import { isRecord } from '../type-guards.js';
-// Raw Fabric event -> listener name, split by dispatch phase. Press is synthesized
-// from a touch sequence and layout is direct, so neither lives in this table.
-// Bubbling events walk target -> root; direct events fire only on the target.
-const BUBBLING_EVENTS = {
-    topFocus: 'focus',
-    topBlur: 'blur',
-    topChange: 'change',
-    topEndEditing: 'endEditing',
-    topSubmitEditing: 'submitEditing',
-    topKeyPress: 'keyPress',
-};
-const DIRECT_EVENTS = {
-    topLayout: 'layout',
-    topScroll: 'scroll',
-    topScrollBeginDrag: 'scrollBeginDrag',
-    topScrollEndDrag: 'scrollEndDrag',
-    topMomentumScrollBegin: 'momentumScrollBegin',
-    topMomentumScrollEnd: 'momentumScrollEnd',
-    topSelectionChange: 'selectionChange',
-    topContentSizeChange: 'contentSizeChange',
-    topLoadStart: 'loadStart',
-    topLoad: 'load',
-    topLoadEnd: 'loadEnd',
-    topError: 'error',
-    topProgress: 'progress',
-    topPartialLoad: 'partialLoad',
-    topRefresh: 'refresh',
-    topShow: 'show',
-    topRequestClose: 'requestClose',
-    topDismiss: 'dismiss',
-    topOrientationChange: 'orientationChange',
-    // Text glyph layout (onTextLayout) and the iOS status-bar-tap scroll-to-top.
-    topTextLayout: 'textLayout',
-    topScrollToTop: 'scrollToTop',
-    // Accessibility events from RN's base ViewConfig; any view can emit them.
-    // accessibilityAction fires on iOS + Android; the iOS-only three (accessibilityTap,
-    // magicTap, accessibilityEscape) have no Android producer, so they are inert there.
-    topAccessibilityAction: 'accessibilityAction',
-    topAccessibilityTap: 'accessibilityTap',
-    topMagicTap: 'magicTap',
-    topAccessibilityEscape: 'accessibilityEscape',
-};
-const TOUCH_START = 'topTouchStart';
-const TOUCH_MOVE = 'topTouchMove';
-const TOUCH_END = 'topTouchEnd';
-const TOUCH_CANCEL = 'topTouchCancel';
-const PRESS = 'press';
-// Responder protocol (PanResponder / Touchable). RN's two-phase negotiation:
-// every should-set is asked CAPTURE (root -> target) then BUBBLE (target -> root),
-// and the first node returning true wins, on a touch START *and* on every MOVE,
-// so a node can claim the responder mid-gesture. If someone already holds it, the
-// incumbent is asked onResponderTerminationRequest; a true answer (or no listener)
-// hands it over (terminate + grant), a false answer rejects the taker. Lifecycle
-// events are direct (grant/start/move/end/release/terminate/reject). Listener names
-// are post-`on` (onResponderMove -> 'responderMove').
-const START_SHOULD_SET = 'startShouldSetResponder';
-const START_SHOULD_SET_CAPTURE = 'startShouldSetResponderCapture';
-const MOVE_SHOULD_SET = 'moveShouldSetResponder';
-const MOVE_SHOULD_SET_CAPTURE = 'moveShouldSetResponderCapture';
-const RESPONDER_GRANT = 'responderGrant';
-const RESPONDER_REJECT = 'responderReject';
-const RESPONDER_START = 'responderStart';
-const RESPONDER_MOVE = 'responderMove';
-const RESPONDER_END = 'responderEnd';
-const RESPONDER_RELEASE = 'responderRelease';
-const RESPONDER_TERMINATE = 'responderTerminate';
-const RESPONDER_TERMINATION_REQUEST = 'responderTerminationRequest';
-// Synthesized alongside press so Pressable can show pressed-state feedback: both
-// fire on the node the touch STARTED on (the responder), pressOut on end/cancel.
-const PRESS_IN = 'pressIn';
-const PRESS_OUT = 'pressOut';
-// Synthesized from a sustained hold so bare Text/View onLongPress fires without a
-// native event (Pressable runs the same timer in JS). Default delay matches RN's
-// Touchable (500ms); a fired long press suppresses the tap on release.
-const LONG_PRESS = 'longPress';
-const DEFAULT_LONG_PRESS_MS = 500;
-// Pressability cancels the pending long press when the touch drifts past this many
-// points from where it started (Pressability.DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE).
-const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
+import { bubble, callOwnListener, deliverDirect, endsWithin, hasListenerInPath, } from './delivery.js';
+import { BUBBLING_EVENTS, DEFAULT_LONG_PRESS_MS, DIRECT_EVENTS, LONG_PRESS, LONG_PRESS_DEACTIVATION_DISTANCE, PRESS, PRESS_IN, PRESS_OUT, RESPONDER_END, RESPONDER_MOVE, RESPONDER_RELEASE, RESPONDER_START, RESPONDER_TERMINATE, TOUCH_CANCEL, TOUCH_END, TOUCH_MOVE, TOUCH_START, } from './names.js';
+import { activePresses, clearLongPress, findActivePress, hasRemainingTouchWithin, readTouchPoint, takeAllPresses, takeEndedPresses, } from './press.js';
+import { clearResponder, heldResponder, negotiateResponder, releaseResponderToNative, } from './responder.js';
+// Fabric calls one handler for every surface, so the registration happens once per runtime
 let installed = false;
-// Each unrelated target owns an independent press. Additional fingers under the same owner join
-// that press, so one target still receives exactly one pressIn/press/pressOut lifecycle.
-const activePresses = new Set();
-// The node that claimed the responder for the in-flight touch (PanResponder), or
-// undefined when nobody claimed it. Receives move and release/terminate.
-let currentResponder;
-function clearLongPress(press) {
-    if (press.longPressTimer !== undefined) {
-        clearTimeout(press.longPressTimer);
+function armLongPress(press, nativeEvent) {
+    press.longPressTimer = setTimeout(() => {
+        if (!activePresses.has(press))
+            return;
         press.longPressTimer = undefined;
-    }
-}
-function takeAllPresses() {
-    const presses = [...activePresses];
-    activePresses.clear();
-    for (const press of presses)
-        clearLongPress(press);
-    return presses;
+        press.longPressFired = true;
+        dlog('synthesized longPress -> dispatch');
+        runWrapped(() => bubble(press.owner, LONG_PRESS, nativeEvent));
+    }, DEFAULT_LONG_PRESS_MS);
 }
-function findActivePress(target) {
-    for (const press of activePresses) {
-        if (endsWithin(target, press.owner))
-            return press;
-    }
-    return undefined;
-}
-// Read the changed finger's page coordinate from a raw native touch event, falling back to the
-// active-touch list and then undefined. Callers skip coordinate-dependent logic rather than guess.
-function readTouchPoint(nativeEvent) {
-    const fromPair = (source) => {
-        if (!source)
-            return undefined;
-        const { pageX, pageY } = source;
-        if (typeof pageX === 'number' && typeof pageY === 'number')
-            return { x: pageX, y: pageY };
-        return undefined;
-    };
-    const direct = fromPair(nativeEvent);
-    if (direct)
-        return direct;
-    // `changedTouches` identifies the finger for this frame. Read it before the full active-touch
-    // list, whose first entry may belong to another simultaneously pressed target.
-    for (const key of ['changedTouches', 'touches']) {
-        const touches = nativeEvent[key];
-        if (!Array.isArray(touches))
-            continue;
-        for (const touch of touches) {
-            if (!isRecord(touch))
-                continue;
-            const point = fromPair(touch);
-            if (point)
-                return point;
-        }
-    }
-    return undefined;
-}
-// Whether any touch still down started inside an owner (its target IS the owner or a descendant).
-// RN's noResponderTouches walks nativeEvent.touches and returns false the moment one is found; a
-// responder release and our synthesized press completion both wait until none remain. The headless
-// smokes fire with an empty `{}` event -> no remaining touch -> preserve single-touch behavior.
-function hasRemainingTouchWithin(owner, nativeEvent) {
-    const touches = nativeEvent.touches;
-    if (!Array.isArray(touches))
-        return false;
-    for (const touch of touches) {
-        if (!isRecord(touch))
-            continue;
-        const target = touch.target;
-        if (isSymbioteNode(target) && endsWithin(target, owner))
-            return true;
-    }
-    return false;
-}
-// Whether any node from `target` up to the root listens for `listenerName`, used to
-// arm the long-press timer only when a handler would actually receive it.
-function hasListenerInPath(target, listenerName) {
-    for (let node = target; node; node = parentOf(node)) {
-        if (node.listeners?.has(listenerName) === true)
-            return true;
-    }
-    return false;
-}
-// Invoke one node's own listener (no bubbling) and hand back its return value, so
-// the responder negotiation can read the boolean from onStartShouldSetResponder.
-function callOwnListener(node, listenerName, nativeEvent) {
-    const listener = node.listeners?.get(listenerName);
-    if (!listener)
-        return undefined;
-    return listener({
-        type: listenerName,
-        target: node,
-        currentTarget: node,
-        nativeEvent,
-        stopPropagation: () => { },
+function onTouchStart(target, nativeEvent) {
+    if (isDebug()) {
+        dlog(`event ${TOUCH_START} on ${target.component}`);
+        // A responder surviving into a one-touch start lost its end or cancel. If it is an ancestor of
+        // the target, this whole tap goes to it and the release finally clears it
+        if (heldResponder() !== undefined)
+            dlog(`touchStart while ${heldResponder()?.component} still holds it`);
+    }
+    // Update the touch bank, then attach it so responder handlers read each touch's own
+    // previous-to-current delta. RN records before dispatch too
+    recordTouchTrack('start', nativeEvent);
+    attachTouchHistory(nativeEvent);
+    const canJoinExistingPress = Array.isArray(nativeEvent.touches) && nativeEvent.touches.length > 1;
+    const joinedPress = canJoinExistingPress
+        ? findActivePress(target)
+        : undefined;
+    // A one-touch or identifier-less frame starts a new physical gesture, so any surviving press is
+    // stale (its end or cancel was lost) and gets released instead of suppressing this start
+    const stalePresses = canJoinExistingPress ? [] : takeAllPresses();
+    let startedPress;
+    if (joinedPress === undefined) {
+        startedPress = {
+            owner: target,
+            longPressTimer: undefined,
+            longPressFired: false,
+            longPressStart: readTouchPoint(nativeEvent),
+        };
+        activePresses.add(startedPress);
+        if (hasListenerInPath(target, LONG_PRESS))
+            armLongPress(startedPress, nativeEvent);
+    }
+    runWrapped(() => {
+        for (const stale of stalePresses)
+            bubble(stale.owner, PRESS_OUT, nativeEvent);
+        if (startedPress)
+            bubble(startedPress.owner, PRESS_IN, nativeEvent);
+        else
+            dlog('pressIn retained (another touch joined the active press)');
+        // A View can be both a Pressable and a PanResponder target, so the negotiation runs alongside
+        // press synthesis rather than instead of it
+        negotiateResponder(target, 'start', nativeEvent);
+        const responder = heldResponder();
+        if (responder)
+            callOwnListener(responder, RESPONDER_START, nativeEvent);
     });
 }
-// The node chain from `from` up to the root, deepest first. The single allocation
-// the two-phase walk indexes both ways (capture reads it reversed).
-//
-// ONE CROSSING, not one per level. This used to climb `parentOf`, which crosses the host boundary
-// each step — 18 questions per event on a depth-8 chain, and again on every frame of every drag for
-// the responder's scope. The host holds the tree, so the chain is one answer it can give: the same
-// argument `parentsOf` / `subtreesOf` won for the teardown sweep (F-2) and `nextSiblingOf` for Vue's
-// quadratic (F-19).
-function pathToRoot(from) {
-    return [...ancestorsOf(from)];
-}
-// Depth of a node below the root (root = 0). Aligns two nodes before the lockstep
-// climb to their lowest common ancestor.
-function depthOf(node) {
-    let depth = 0;
-    for (let n = parentOf(node); n; n = parentOf(n))
-        depth++;
-    return depth;
-}
-// RN's getLowestCommonAncestor over our parent pointers: lift the deeper node to the
-// shallower one's depth, then climb both in lockstep until they meet (ResponderEvent-
-// Plugin.getLowestCommonAncestor). Used to scope the move re-negotiation.
-function lowestCommonAncestor(a, b) {
-    let da = depthOf(a);
-    let db = depthOf(b);
-    let na = a;
-    let nb = b;
-    while (na && da > db) {
-        na = parentOf(na);
-        da--;
-    }
-    while (nb && db > da) {
-        nb = parentOf(nb);
-        db--;
-    }
-    while (na && nb) {
-        if (na === nb)
-            return na;
-        na = parentOf(na);
-        nb = parentOf(nb);
-    }
-    return undefined;
+// Only the press owning this move may lose its long-press timer: movement on an unrelated
+// simultaneously held Pressable must not disturb another target's clock
+function cancelLongPressOnDrift(target, nativeEvent) {
+    const movedPress = findActivePress(target);
+    if (movedPress?.longPressTimer === undefined || !movedPress.longPressStart)
+        return;
+    const here = readTouchPoint(nativeEvent);
+    if (!here)
+        return;
+    const dx = here.x - movedPress.longPressStart.x;
+    const dy = here.y - movedPress.longPressStart.y;
+    if (Math.hypot(dx, dy) > LONG_PRESS_DEACTIVATION_DISTANCE) {
+        dlog('longPress cancelled (moved past deactivation distance)');
+        clearLongPress(movedPress);
+    }
+}
+function onTouchMove(target, nativeEvent) {
+    recordTouchTrack('move', nativeEvent);
+    attachTouchHistory(nativeEvent);
+    cancelLongPressOnDrift(target, nativeEvent);
+    runWrapped(() => {
+        // Re-negotiate first: a node can claim the responder mid-gesture through
+        // `onMoveShouldSetResponder`, and the responder itself is skipped
+        negotiateResponder(target, 'move', nativeEvent);
+        // The only consumer of a move is the responder; without one RN drops it too
+        const responder = heldResponder();
+        if (responder)
+            callOwnListener(responder, RESPONDER_MOVE, nativeEvent);
+    });
 }
-// RN's two-phase should-set walk: CAPTURE root -> deepest, then BUBBLE deepest -> root;
-// the first node returning true wins. `skip` is excluded from both passes; RN skips
-// the deepest node when it IS the current responder (you don't ask the holder to
-// re-claim), so its should-set callback never consumes the gesture frame out from under
-// its own onResponderMove (PanResponder folds geometry in the should-set-capture
-// handler, so asking the responder again would zero its move).
-function findWantsResponder(path, captureName, bubbleName, nativeEvent, skip) {
-    for (let i = path.length - 1; i >= 0; i--) {
-        if (path[i] !== skip &&
-            callOwnListener(path[i], captureName, nativeEvent) === true) {
-            return path[i];
+// Each target completes independently. An honest tap ends inside that target, while `pressOut`
+// always releases the pressed state, a drag-away end included
+function completePress(press, target, nativeEvent) {
+    if (endsWithin(target, press.owner)) {
+        if (press.longPressFired)
+            dlog('press suppressed (longPress already fired)');
+        else {
+            dlog('event press -> dispatch');
+            bubble(press.owner, PRESS, nativeEvent);
         }
     }
-    for (const node of path) {
-        if (node !== skip &&
-            callOwnListener(node, bubbleName, nativeEvent) === true)
-            return node;
-    }
-    return undefined;
+    bubble(press.owner, PRESS_OUT, nativeEvent);
 }
-// Tell native which node owns the gesture, RN's `injectGlobalResponderHandler`
-// (ReactFabric-dev.js:18862) — the OLD owner first, then the new one, both in one call so no
-// site can do half of it.
-//
-// WITHOUT THIS A JS RESPONDER LOSES TO ANY SCROLL VIEW ABOVE IT, and it is invisible from JS:
-// `onStartShouldSetResponder` returns true, the native UIScrollView never learns the gesture was
-// claimed, and every subsequent move arrives as `topScroll` instead of `topTouchMove` — so the
-// negotiation never even gets a move to grant on. Device-diagnosed 2026-09-08 on a PanResponder
-// drag box inside the canary's ScrollView: `startShouldSet -> true` followed by
-// `topScrollBeginDrag` and twenty `topScroll`, with no grant and no move.
-//
-// `blockNativeResponder` is the taker's own `onResponderGrant` return, exactly as RN reads it.
-function handOverNativeResponder(from, to, blockNativeResponder) {
-    if (isDebug()) {
-        dlog(`setIsJSResponder from=${from === undefined ? 'none' : 'yes'} ` +
-            `to=${to === undefined ? 'none' : 'yes'} block=${blockNativeResponder}`);
-    }
-    if (from !== undefined)
-        setIsJSResponder(from, false, blockNativeResponder);
-    if (to !== undefined)
-        setIsJSResponder(to, true, blockNativeResponder);
-}
-// Whether the taker asked native to stand down. RN reads this off the grant dispatch's return;
-// an absent listener means no claim, which is RN's `blockNativeResponder || false`.
-function blocksNative(result) {
-    return result === true;
-}
-// Negotiate (or re-negotiate) the responder for a touch start/move. If nobody holds
-// it, the winner is granted. If someone does, the incumbent is asked to relinquish
-// via onResponderTerminationRequest (absent listener = implicit yes); on yes it is
-// terminated and the taker granted, on no the taker is rejected.
-function negotiateResponder(target, phase, nativeEvent) {
-    // With no responder, ask the full path from the touch target. With one, RN scopes
-    // the walk to the lowest common ancestor of responder+target upward (never below
-    // the responder) and skips the deepest node when it IS the responder (Responder-
-    // EventPlugin.setResponderAndExtractTransfer). At touch start currentResponder is
-    // cleared, so this collapses to the plain target->root start walk.
-    //
-    // ONE WALK, and the common case never needs a second. `pathToRoot` crosses the host boundary per
-    // level, and the previous shape paid `lowestCommonAncestor` — `depthOf(a)` plus `depthOf(b)` plus
-    // a lockstep climb — BEFORE walking again from the answer. Measured on a depth-8 chain: 19
-    // crossings per move, of which 18 were the ancestor search, on a path that runs 60 times a second
-    // for the whole of a drag (`__tests__/touch-crossing-cost.test.ts`).
-    //
-    // The scope RN computes is the lowest common ancestor of responder and target, and while a finger
-    // stays inside the view that claimed it — which is what a drag IS — the responder is an ANCESTOR
-    // of the target, so the LCA is the responder itself and it is already in the target's own path.
-    // An index lookup answers it with nothing crossed, and the scoped path is that path's suffix.
-    // The genuine cross-subtree case (the finger left the responder's subtree) still falls back to
-    // the full search, and it is a rare frame rather than every frame.
-    const targetPath = pathToRoot(target);
-    const heldAt = currentResponder === undefined ? -1 : targetPath.indexOf(currentResponder);
-    const from = currentResponder === undefined
-        ? target
-        : heldAt >= 0
-            ? currentResponder
-            : lowestCommonAncestor(currentResponder, target);
-    if (!from)
+// `responderEnd` fires on every finger leaving; the FINAL name (release on an end, terminate on a
+// cancel) only once no touch remains inside the responder
+function finishResponder(responder, finalName, isFinal, nativeEvent) {
+    callOwnListener(responder, RESPONDER_END, nativeEvent);
+    if (!isFinal)
         return;
-    const path = from === target
-        ? targetPath
-        : heldAt >= 0
-            ? targetPath.slice(heldAt)
-            : pathToRoot(from);
-    const skip = from === currentResponder ? from : undefined;
-    const wants = phase === 'start'
-        ? findWantsResponder(path, START_SHOULD_SET_CAPTURE, START_SHOULD_SET, nativeEvent, skip)
-        : findWantsResponder(path, MOVE_SHOULD_SET_CAPTURE, MOVE_SHOULD_SET, nativeEvent, skip);
-    // Every exit is logged: a negotiation that declines is indistinguishable from one that never
-    // ran, and the two have opposite causes.
-    if (!wants) {
-        if (isDebug()) {
-            dlog(`responder ${phase}: nobody wants it (path=${path.length}${skip === undefined ? '' : ', one skipped'})`);
+    callOwnListener(responder, finalName, nativeEvent);
+    releaseResponderToNative(responder);
+}
+function onTouchEnd(target, nativeEvent) {
+    recordTouchTrack('end', nativeEvent);
+    attachTouchHistory(nativeEvent);
+    const hadActivePress = activePresses.size > 0;
+    const completedPresses = takeEndedPresses(nativeEvent);
+    const responder = heldResponder();
+    // RN releases the responder only when no remaining touch still down started inside it, so
+    // lifting ONE finger of a multi-touch gesture must not release. `onResponderEnd` still fires
+    const releases = responder !== undefined && !hasRemainingTouchWithin(responder, nativeEvent);
+    if (releases)
+        clearResponder();
+    runWrapped(() => {
+        for (const press of completedPresses)
+            completePress(press, target, nativeEvent);
+        if (!hadActivePress) {
+            if (isDebug())
+                dlog(`event ${TOUCH_END} ignored (no matching start)`);
         }
-        return;
-    }
-    if (wants === currentResponder) {
-        if (isDebug())
-            dlog(`responder ${phase}: ${wants.component} already holds it`);
-        return;
-    }
-    if (currentResponder === undefined) {
-        currentResponder = wants;
+        else if (completedPresses.length === 0)
+            dlog('press retained (another touch remains inside its owner)');
+        if (!responder)
+            return;
+        finishResponder(responder, RESPONDER_RELEASE, releases, nativeEvent);
+        if (!releases)
+            dlog('responderEnd without release (touches remain inside responder)');
+    });
+    // Once no touch is down, clear the bank so the next gesture starts clean
+    if (touchHistory.numberActiveTouches === 0)
+        resetTouchHistory();
+}
+// Android: a ScrollView whose scroller has not finished (fling tail, spring-back) intercepts the
+// next down natively, and the tap reaches JS as start plus cancel with no press
+function onTouchCancel(target, nativeEvent) {
+    if (isDebug())
+        dlog(`event ${TOUCH_CANCEL} on ${target.component}`);
+    recordTouchTrack('end', nativeEvent);
+    attachTouchHistory(nativeEvent);
+    // A cancel is scoped to the fingers removed from `touches`, just like an end, so an unrelated
+    // Pressable, or another finger under the same owner, keeps its press and long-press state
+    const cancelledPresses = takeEndedPresses(nativeEvent);
+    const responder = heldResponder();
+    const terminates = responder !== undefined && !hasRemainingTouchWithin(responder, nativeEvent);
+    if (terminates)
+        clearResponder();
+    runWrapped(() => {
+        for (const press of cancelledPresses)
+            bubble(press.owner, PRESS_OUT, nativeEvent);
+        if (!responder)
+            return;
+        finishResponder(responder, RESPONDER_TERMINATE, terminates, nativeEvent);
+    });
+    if (touchHistory.numberActiveTouches === 0)
+        resetTouchHistory();
+}
+const TOUCH_HANDLERS = {
+    [TOUCH_START]: onTouchStart,
+    [TOUCH_MOVE]: onTouchMove,
+    [TOUCH_END]: onTouchEnd,
+    [TOUCH_CANCEL]: onTouchCancel,
+};
+// A third-party Fabric view declares its own events, which the built-in tables do not know, so the
+// registry answers keyed by the node's own component
+function deliverNonTouch(target, topLevelType, nativeEvent) {
+    const direct = DIRECT_EVENTS[topLevelType];
+    if (direct !== undefined) {
         if (isDebug())
-            dlog(`responder granted to ${wants.component}`);
-        const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
-        handOverNativeResponder(undefined, wants, blocksNative(granted));
-        return;
+            dlog(`event ${topLevelType} -> ${direct} (direct)`);
+        runWrapped(() => deliverDirect(target, direct, nativeEvent));
+        return true;
     }
-    const incumbent = currentResponder;
-    // A missing termination-request listener means implicit consent (RN default true);
-    // only an explicit non-true answer keeps the incumbent and rejects the taker.
-    const guarded = incumbent.listeners?.has(RESPONDER_TERMINATION_REQUEST) === true;
-    const allowed = !guarded ||
-        callOwnListener(incumbent, RESPONDER_TERMINATION_REQUEST, nativeEvent) ===
-            true;
-    if (allowed) {
-        // RN's transfer order (setResponderAndExtractTransfer): grant the TAKER first, then
-        // terminate the incumbent. RN dispatches grant ahead of the terminationRequest too,
-        // purely to read the taker's block-native return; we have no native surface to
-        // block, so on the REJECT path firing a grant the taker never keeps would be a
-        // visible no-op event with no behavioral counterpart. We therefore fire grant
-        // before terminate on the consent path (matching RN's grant<terminate ordering) and
-        // omit it on reject; the consent OUTCOME is unchanged either way.
+    const bubbling = BUBBLING_EVENTS[topLevelType];
+    if (bubbling !== undefined) {
         if (isDebug())
-            dlog(`responder transferred ${incumbent.component} -> ${wants.component}`);
-        const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
-        callOwnListener(incumbent, RESPONDER_TERMINATE, nativeEvent);
-        currentResponder = wants;
-        handOverNativeResponder(incumbent, wants, blocksNative(granted));
+            dlog(`event ${topLevelType} -> ${bubbling} (bubble)`);
+        runWrapped(() => bubble(target, bubbling, nativeEvent));
+        return true;
     }
-    else {
-        if (isDebug())
-            dlog(`responder takeover of ${incumbent.component} rejected`);
-        callOwnListener(wants, RESPONDER_REJECT, nativeEvent);
+    const registered = registeredNativeEvent(target.component, topLevelType);
+    if (registered === undefined)
+        return false;
+    if (isDebug()) {
+        const phase = registered.direct ? 'direct' : 'bubble';
+        dlog(`event ${topLevelType} -> ${registered.listener} (${phase}, registered)`);
     }
+    runWrapped(() => registered.direct
+        ? deliverDirect(target, registered.listener, nativeEvent)
+        : bubble(target, registered.listener, nativeEvent));
+    return true;
 }
 export function installEventHandler() {
     if (installed)
@@ -377,321 +220,17 @@ export function installEventHandler() {
     getSlot().registerEventHandler((instanceHandle, topLevelType, nativeEvent) => {
         if (!isSymbioteNode(instanceHandle))
             return;
-        if (topLevelType === TOUCH_START) {
-            // The ternary is gone with the gate: `isSymbioteNode(instanceHandle)` was re-asked here
-            // three lines after the early return above already proved it.
-            if (isDebug()) {
-                dlog(`event ${TOUCH_START} on ${instanceHandle.component}`);
-                // A responder surviving into a one-touch start lost its end/cancel. If it is an ancestor
-                // of the target, this whole tap goes to it and the release finally clears it.
-                if (currentResponder !== undefined)
-                    dlog(`touchStart while ${currentResponder.component} still holds the responder`);
-            }
-            // Update the touch bank, then attach it so responder handlers (PanResponder)
-            // read each touch's own previous->current delta; RN records before dispatch.
-            recordTouchTrack('start', nativeEvent);
-            attachTouchHistory(nativeEvent);
-            const canJoinExistingPress = Array.isArray(nativeEvent.touches) && nativeEvent.touches.length > 1;
-            const joinedPress = canJoinExistingPress
-                ? findActivePress(instanceHandle)
-                : undefined;
-            // A one-touch or identifier-less frame starts a new physical gesture. Any surviving press
-            // is stale (its end/cancel was lost), so release it instead of letting it suppress this start.
-            const stalePresses = canJoinExistingPress ? [] : takeAllPresses();
-            let startedPress;
-            if (joinedPress === undefined) {
-                startedPress = {
-                    owner: instanceHandle,
-                    longPressTimer: undefined,
-                    longPressFired: false,
-                    longPressStart: readTouchPoint(nativeEvent),
-                };
-                activePresses.add(startedPress);
-                if (hasListenerInPath(instanceHandle, LONG_PRESS)) {
-                    const press = startedPress;
-                    press.longPressTimer = setTimeout(() => {
-                        if (!activePresses.has(press))
-                            return;
-                        press.longPressTimer = undefined;
-                        press.longPressFired = true;
-                        dlog('synthesized longPress -> dispatch');
-                        runWrapped(() => bubble(press.owner, LONG_PRESS, nativeEvent));
-                    }, DEFAULT_LONG_PRESS_MS);
-                }
-            }
-            runWrapped(() => {
-                for (const stale of stalePresses)
-                    bubble(stale.owner, PRESS_OUT, nativeEvent);
-                if (startedPress)
-                    bubble(startedPress.owner, PRESS_IN, nativeEvent);
-                else
-                    dlog('pressIn retained (another touch joined the active press)');
-                // Responder negotiation runs alongside press synthesis: a View can be both
-                // a Pressable (press) and a PanResponder target (responder).
-                negotiateResponder(instanceHandle, 'start', nativeEvent);
-                // onResponderStart is a direct event to whoever now holds the responder.
-                if (currentResponder)
-                    callOwnListener(currentResponder, RESPONDER_START, nativeEvent);
-            });
-            return;
-        }
-        if (topLevelType === TOUCH_MOVE) {
-            recordTouchTrack('move', nativeEvent);
-            attachTouchHistory(nativeEvent);
-            // Only the press owning this move can lose its long-press timer; movement on an unrelated
-            // simultaneously held Pressable must not disturb another target's clock.
-            const movedPress = findActivePress(instanceHandle);
-            if (movedPress?.longPressTimer !== undefined &&
-                movedPress.longPressStart) {
-                const here = readTouchPoint(nativeEvent);
-                if (here) {
-                    const dx = here.x - movedPress.longPressStart.x;
-                    const dy = here.y - movedPress.longPressStart.y;
-                    if (Math.hypot(dx, dy) > LONG_PRESS_DEACTIVATION_DISTANCE) {
-                        dlog('longPress cancelled (moved past deactivation distance)');
-                        clearLongPress(movedPress);
-                    }
-                }
-            }
-            runWrapped(() => {
-                // Re-negotiate first: a node can claim the responder mid-gesture via
-                // onMoveShouldSetResponder (the responder itself is skipped, see negotiate).
-                negotiateResponder(instanceHandle, 'move', nativeEvent);
-                // The only consumer of a move is the responder; without one, RN drops it too.
-                if (currentResponder)
-                    callOwnListener(currentResponder, RESPONDER_MOVE, nativeEvent);
-            });
-            return;
-        }
-        if (topLevelType === TOUCH_END) {
-            recordTouchTrack('end', nativeEvent);
-            attachTouchHistory(nativeEvent);
-            const hadActivePress = activePresses.size > 0;
-            const completedPresses = [];
-            for (const press of activePresses) {
-                if (hasRemainingTouchWithin(press.owner, nativeEvent))
-                    continue;
-                activePresses.delete(press);
-                clearLongPress(press);
-                completedPresses.push(press);
-            }
-            const responder = currentResponder;
-            // RN releases (and clears) the responder only when no remaining touch still down
-            // started inside it; lifting ONE finger in a multi-touch gesture must NOT release.
-            // onResponderEnd still fires on every finger-up. (ResponderEventPlugin: responderEnd
-            // is unconditional, responderRelease is gated on noResponderTouches.)
-            const releases = responder !== undefined &&
-                !hasRemainingTouchWithin(responder, nativeEvent);
-            if (releases)
-                currentResponder = undefined;
-            runWrapped(() => {
-                for (const press of completedPresses) {
-                    // Each target completes independently. An honest tap ends inside that target; pressOut
-                    // always releases its pressed state, including a drag-away end.
-                    if (endsWithin(instanceHandle, press.owner)) {
-                        if (press.longPressFired) {
-                            dlog('press suppressed (longPress already fired)');
-                        }
-                        else {
-                            dlog('event press -> dispatch');
-                            bubble(press.owner, PRESS, nativeEvent);
-                        }
-                    }
-                    bubble(press.owner, PRESS_OUT, nativeEvent);
-                }
-                if (!hadActivePress) {
-                    if (isDebug())
-                        dlog(`event ${TOUCH_END} ignored (no matching start)`);
-                }
-                else if (completedPresses.length === 0) {
-                    dlog('press retained (another touch remains inside its owner)');
-                }
-                // onResponderEnd fires on every finger-up; onResponderRelease (the final
-                // release) only when the last responder touch lifted.
-                if (responder) {
-                    callOwnListener(responder, RESPONDER_END, nativeEvent);
-                    if (releases) {
-                        callOwnListener(responder, RESPONDER_RELEASE, nativeEvent);
-                        handOverNativeResponder(responder, undefined, false);
-                    }
-                    else
-                        dlog('responderEnd without release (touches remain inside responder)');
-                }
-            });
-            // Once no touch is down, clear the bank so the next gesture starts clean.
-            if (touchHistory.numberActiveTouches === 0)
-                resetTouchHistory();
-            return;
-        }
-        if (topLevelType === TOUCH_CANCEL) {
-            // Android: a ScrollView whose scroller has not finished (fling tail, spring-back) intercepts
-            // the next down natively, and the tap reaches JS as start + cancel with no press.
-            if (isDebug())
-                dlog(`event ${TOUCH_CANCEL} on ${instanceHandle.component}`);
-            recordTouchTrack('end', nativeEvent);
-            attachTouchHistory(nativeEvent);
-            // A cancel is scoped to the finger(s) removed from `touches`, just like an end. An unrelated
-            // Pressable—or another finger under the same owner—must keep its press and long-press state.
-            const cancelledPresses = [];
-            for (const press of activePresses) {
-                if (hasRemainingTouchWithin(press.owner, nativeEvent))
-                    continue;
-                activePresses.delete(press);
-                clearLongPress(press);
-                cancelledPresses.push(press);
-            }
-            const responder = currentResponder;
-            const terminatesResponder = responder !== undefined &&
-                !hasRemainingTouchWithin(responder, nativeEvent);
-            if (terminatesResponder)
-                currentResponder = undefined;
-            runWrapped(() => {
-                for (const press of cancelledPresses)
-                    bubble(press.owner, PRESS_OUT, nativeEvent);
-                if (responder) {
-                    // Like touch-end, every finger leaving emits responderEnd. Termination is final only
-                    // when no touch remains inside the responder.
-                    callOwnListener(responder, RESPONDER_END, nativeEvent);
-                    if (terminatesResponder) {
-                        callOwnListener(responder, RESPONDER_TERMINATE, nativeEvent);
-                        handOverNativeResponder(responder, undefined, false);
-                    }
-                }
-            });
-            if (touchHistory.numberActiveTouches === 0)
-                resetTouchHistory();
-            return;
-        }
-        const direct = DIRECT_EVENTS[topLevelType];
-        if (direct !== undefined) {
-            if (isDebug()) {
-                dlog(`event ${topLevelType} -> ${direct} (direct)`);
-            }
-            runWrapped(() => deliverDirect(instanceHandle, direct, nativeEvent));
-            return;
-        }
-        const bubbling = BUBBLING_EVENTS[topLevelType];
-        if (bubbling !== undefined) {
-            if (isDebug()) {
-                dlog(`event ${topLevelType} -> ${bubbling} (bubble)`);
-            }
-            runWrapped(() => bubble(instanceHandle, bubbling, nativeEvent));
+        const touch = TOUCH_HANDLERS[topLevelType];
+        if (touch !== undefined) {
+            touch(instanceHandle, nativeEvent);
             return;
         }
-        // Third-party Fabric views (registerComponent) declare their own events; the
-        // built-in tables above don't know them, so fall back to the registry, keyed by
-        // the node's own component. `direct` events fire only on their target, the rest
-        // bubble: same split as the built-ins.
-        const registered = registeredNativeEvent(instanceHandle.component, topLevelType);
-        if (registered !== undefined) {
-            if (isDebug()) {
-                const phase = registered.direct ? 'direct' : 'bubble';
-                dlog(`event ${topLevelType} -> ${registered.listener} (${phase}, registered)`);
-            }
-            runWrapped(() => registered.direct
-                ? deliverDirect(instanceHandle, registered.listener, nativeEvent)
-                : bubble(instanceHandle, registered.listener, nativeEvent));
+        if (deliverNonTouch(instanceHandle, topLevelType, nativeEvent))
             return;
-        }
-        // Nothing claimed this event: neither a built-in table nor the view's derived
-        // config. A permanent diagnostic seam: if a native view fires something we drop
-        // on the floor (an event the ViewConfig didn't surface, or a name mismatch),
-        // this is where it shows up. Keeps "the handler silently did nothing" debuggable.
+        // Nothing claimed this event, neither a built-in table nor the view's derived config. A
+        // permanent seam: a native view firing something we drop on the floor shows up here
         if (isDebug()) {
             dlog(`event ${topLevelType} UNMATCHED on ${instanceHandle.component} (dropped)`);
         }
     });
 }
-// A press is honest only if the touch ends on the node it started on, or a
-// descendant of it: walk parent pointers up from the end target looking for the
-// start target. The start node may have been unmounted mid-touch (parent pointer
-// cleared); the walk simply runs out and returns false, no throw.
-function endsWithin(endTarget, start) {
-    let node = endTarget;
-    while (node) {
-        if (node === start)
-            return true;
-        node = parentOf(node);
-    }
-    return false;
-}
-// Two-phase delivery, mirroring RN's accumulateTwoPhaseDispatches (legacy-events/
-// EventPropagators): CAPTURE root -> target first, invoking each node's
-// `<EventName>Capture` listener, then BUBBLE target -> root invoking the plain
-// listener. The same event object semantics apply to both passes; a stopPropagation
-// in capture halts before bubble ever runs. `target` stays the original node;
-// `currentTarget` tracks whose listener runs.
-function bubble(target, listenerName, nativeEvent) {
-    let stopped = false;
-    const stopPropagation = () => {
-        stopped = true;
-    };
-    // Capture phase: root -> target. RN gathers captured listeners first (the
-    // `<EventName>Capture` registration), so on*Capture handlers fire ahead of the
-    // bubble pass. The path is built target -> root, then walked in reverse to get
-    // root -> target without a second allocation.
-    const captureName = `${listenerName}Capture`;
-    const path = pathToRoot(target);
-    for (let i = path.length - 1; i >= 0; i--) {
-        const node = path[i];
-        // Anchors (Angular's #anchor component hosts) never paint and have no native view. A
-        // listener registered on one only exists because a framework's own output-binding
-        // machinery (already delivered directly, e.g. Angular's EventEmitter.subscribe) also
-        // registered it through Renderer2.listen. Bubbling into it would refire that same
-        // callback a second time, so anchors are transparent to listener lookup, not just paint.
-        const listener = isAnchor(node)
-            ? undefined
-            : node.listeners?.get(captureName);
-        if (listener) {
-            if (isDebug())
-                dlog(`event ${listenerName} capture on ${node.component}`);
-            listener({
-                type: listenerName,
-                target,
-                currentTarget: node,
-                nativeEvent,
-                stopPropagation,
-            });
-            if (stopped)
-                return;
-        }
-    }
-    // Bubble phase: target -> root, invoking each ancestor's plain listener. Anchors are
-    // transparent here too, same reason (see the capture-phase comment above).
-    //
-    // THE SAME ARRAY, read forward. This used to re-walk `parentOf` from the target, which is a
-    // CROSSING of the host boundary per level — so one event asked the host for its ancestors twice,
-    // measured at 18 questions on a depth-8 chain where 9 is the floor. The comment above already
-    // says the path is built once "without a second allocation"; the second WALK is the expensive
-    // half, and it was the one left in. Every touch and every frame of every drag pays it.
-    for (const node of path) {
-        const listener = isAnchor(node)
-            ? undefined
-            : node.listeners?.get(listenerName);
-        if (listener) {
-            const event = {
-                type: listenerName,
-                target,
-                currentTarget: node,
-                nativeEvent,
-                stopPropagation,
-            };
-            listener(event);
-            if (stopped)
-                return;
-        }
-    }
-}
-// Direct (non-bubbling) delivery: only the target's own listener fires.
-function deliverDirect(target, listenerName, nativeEvent) {
-    const listener = target.listeners?.get(listenerName);
-    if (!listener)
-        return;
-    listener({
-        type: listenerName,
-        target,
-        currentTarget: target,
-        nativeEvent,
-        stopPropagation: () => { },
-    });
-}