react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/responder/system.js

@@ -63,13 +63,68 @@ export const createResponderSystem = (options) => {
             propsOf(path[i])?.[bubbleName]?.(event);
         }
     };
-    const grant = (host, event, fromStart) => {
+    const grant = (host, event) => {
         responder = host;
         notify(host, "onResponderGrant", event);
-        if (fromStart) {
-            notify(host, "onResponderStart", event);
+        // The GTK claim is per INTERACTION, not per grant: a transfer moves a JS
+        // lock, and there is nothing left to tell GTK once the sequence is
+        // already ours. Claiming again on the new holder's own gesture would
+        // deny the sequence on the source below it and silently end the drag.
+        if (session && !session.claimed) {
+            session.claimed = true;
+            options.onClaim?.(session.host);
         }
-        options.onGrant?.(host);
+    };
+    /**
+     * The negotiation path when someone already holds the responder: RN prunes
+     * it to the lowest common ancestor of the holder and the event target, and
+     * then skips the holder itself so it is never asked whether it wants what
+     * it already has. Pruning is what makes the lock transferable only
+     * UPWARDS — a descendant of the holder is not on the pruned path and
+     * cannot take it, which is RN's documented rule.
+     *
+     * Returns null when the two paths are disjoint (RNW's `lowestCommonAncestor
+     * == null`): nothing may take the responder in that case.
+     */
+    const pruneToAncestors = (path, holder) => {
+        const holderPath = pathOf(holder);
+        let common = -1;
+        const shared = Math.min(path.length, holderPath.length);
+        for (let i = 0; i < shared && path[i] === holderPath[i]; i += 1) {
+            common = i;
+        }
+        if (common === -1) {
+            return null;
+        }
+        return path.slice(0, path[common] === holder ? common : common + 1);
+    };
+    /**
+     * RN's handoff, in react-native-web's order: ask the holder, then
+     * terminate it, then grant. (Upstream's ResponderEventPlugin dispatches
+     * the grant BEFORE asking, so a rejected candidate still sees
+     * `onResponderGrant` — a quirk of the pooled-event implementation rather
+     * than of the model. RN's own documentation diagram, which RNW reproduces
+     * verbatim, shows TerminationRequest -> GRANT, and that is what we do.)
+     *
+     * A holder with no `onResponderTerminationRequest` always yields: absent
+     * means "sure", in RN and in RNW alike.
+     */
+    const attemptTransfer = (winner, event) => {
+        const holder = responder;
+        if (holder === null) {
+            grant(winner, event);
+            return;
+        }
+        if (holder === winner) {
+            return;
+        }
+        if (propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {
+            notify(winner, "onResponderReject", event);
+            return;
+        }
+        notify(holder, "onResponderTerminate", event);
+        responder = null;
+        grant(winner, event);
     };
     /**
      * Capture root-to-target, then bubble target-to-root — RN's two-phase
@@ -90,6 +145,23 @@ export const createResponderSystem = (options) => {
         }
         return firstToClaim([...path].reverse(), bubble, event);
     };
+    /**
+     * The whole negotiation for one event: prune the path if the lock is held,
+     * ask who wants it, hand it over. Returns nothing — the caller reads
+     * `responder` afterwards, because RN dispatches `onResponderStart`/`Move`
+     * to whoever holds the lock AFTER the handoff, not before it.
+     */
+    const negotiateAndTransfer = (path, event, phase) => {
+        const holder = responder;
+        const candidates = holder === null ? path : pruneToAncestors(path, holder);
+        if (candidates === null || candidates.length === 0) {
+            return;
+        }
+        const winner = negotiate(candidates, event, phase);
+        if (winner) {
+            attemptTransfer(winner, event);
+        }
+    };
     const finish = (touch, terminated, touchProps) => {
         const current = session;
         if (!current) {
@@ -105,7 +177,6 @@ export const createResponderSystem = (options) => {
         if (holder) {
             notify(holder, "onResponderEnd", event);
             notify(holder, terminated ? "onResponderTerminate" : "onResponderRelease", event);
-            options.onRelease?.(holder);
         }
     };
     return {
@@ -129,42 +200,45 @@ export const createResponderSystem = (options) => {
             if (session !== null) {
                 return;
             }
-            session = { host, identifier: touch.identifier };
+            session = {
+                host,
+                identifier: touch.identifier,
+                lastTouch: touch,
+                claimed: false,
+            };
             recordTouchStart(history, touch);
             refreshActiveTouches(history);
             const path = pathOf(host);
             const event = createEvent(touch, true);
             dispatchTouch(path, "onTouchStartCapture", "onTouchStart", event);
+            negotiateAndTransfer(path, event, "start");
+            // RN dispatches this to whoever holds the lock once the handoff is
+            // over, which is why it is not folded into grant(): a view granted on
+            // a MOVE must not be told the interaction just started.
             if (responder !== null) {
-                return;
-            }
-            const winner = negotiate(path, event, "start");
-            if (winner) {
-                grant(winner, event, true);
+                notify(responder, "onResponderStart", event);
             }
         },
         touchMove(host, touch) {
             if (session === null || session.host !== host) {
                 return;
             }
+            session.lastTouch = touch;
             recordTouchMove(history, touch);
             refreshActiveTouches(history);
             const path = pathOf(host);
             const event = createEvent(touch, true);
             dispatchTouch(path, "onTouchMoveCapture", "onTouchMove", event);
-            if (responder === null) {
-                // The common PanResponder shape: nothing claims on press, and the
-                // pan starts once onMoveShouldSetPanResponder sees enough movement.
-                const winner = negotiate(path, event, "move");
-                if (winner) {
-                    grant(winner, event, false);
-                }
-                return;
+            // Two shapes go through here. Nobody holds the lock yet: the common
+            // PanResponder one, where the pan starts once
+            // onMoveShouldSetPanResponder sees enough movement. Somebody does: an
+            // ancestor may still take it over, and the move is then delivered to
+            // whoever ends up holding it — including in the same event as the
+            // handoff, exactly as RN's own state diagram shows.
+            negotiateAndTransfer(path, event, "move");
+            if (responder !== null) {
+                notify(responder, "onResponderMove", event);
             }
-            // v1 deliberately does not renegotiate while a responder holds: GTK
-            // cannot revoke a claim, so a transfer we cannot enforce natively would
-            // be a lie at the boundary with native widgets. Tracked as task 002b.
-            notify(responder, "onResponderMove", event);
         },
         touchEnd(host, touch) {
             if (session === null || session.host !== host) {
@@ -178,7 +252,53 @@ export const createResponderSystem = (options) => {
             }
             finish(touch, true, ["onTouchCancelCapture", "onTouchCancel"]);
         },
+        terminate(reason) {
+            const current = session;
+            const holder = responder;
+            if (current === null || holder === null) {
+                // Nothing holds the lock: an ancestor scrolling or a menu opening is
+                // then simply an ancestor scrolling or a menu opening. RN terminates
+                // a RESPONDER; it has nothing to say when there is not one.
+                return false;
+            }
+            const event = createEvent(current.lastTouch, false);
+            if (reason === "scroll" &&
+                propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {
+                return false;
+            }
+            // No onResponderEnd here, and that is RN's shape rather than an
+            // oversight: End pairs with a touch actually ending. A termination
+            // that is not a pointer event goes straight to Terminate.
+            recordTouchEnd(history, current.lastTouch);
+            refreshActiveTouches(history);
+            session = null;
+            responder = null;
+            notify(holder, "onResponderTerminate", event);
+            return true;
+        },
+        requestResponder(host) {
+            const current = session;
+            if (current === null) {
+                // No interaction to take. A timer that fires after the pointer is up
+                // is a timer that lost, and there is nothing to negotiate over.
+                return false;
+            }
+            if (responder === host) {
+                return true;
+            }
+            const path = pathOf(current.host);
+            // A node off the interaction's path is not a candidate — the same rule
+            // the touch paths enforce by construction, stated here because this
+            // entry point is reached from a timer rather than from an event that
+            // already travelled the tree.
+            if (!path.includes(host)) {
+                return false;
+            }
+            negotiateAndTransfer(path, createEvent(current.lastTouch, true), "move");
+            return responder === host;
+        },
         getResponder: () => responder,
+        getSource: () => session?.host ?? null,
     };
 };
 //# sourceMappingURL=system.js.map

package/dist/responder/system.js.map

@@ -1 +1 @@
-{"version":3,"file":"system.js","sourceRoot":"","sources":["../../src/responder/system.ts"],"names":[],"mappings":"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","sourcesContent":["// RN's Gesture Responder System: the negotiation, in pure JS.\n//\n// Zero @gtkx imports on purpose. Everything platform-specific enters through\n// two seams — `parentOf`, which turns a host handle into its parent, and the\n// grant/release notifications the platform uses to make its one-way GTK\n// claim. That keeps the algorithm unit-testable off Linux, which matters\n// because this is the part that is subtle and the part every platform\n// historically gets wrong.\n//\n// Why reimplemented rather than reused: every other RN platform feeds\n// `topTouchStart/Move/End/Cancel` to the stock renderer's\n// ResponderEventPlugin, which lives in `facebook/react` inside\n// `react-native-renderer`. We render through `@gtkx/react` on\n// `react-reconciler`, so there is no plugin seam to feed —\n// react-native-web is in the same position and reimplemented for the same\n// reason (docs/research/gestures.md).\nimport type { NativeTouch } from \"../components/press-event\"\nimport {\n  createTouchHistory,\n  recordTouchEnd,\n  recordTouchMove,\n  recordTouchStart,\n  refreshActiveTouches,\n} from \"./touch-history\"\nimport type { GestureResponderEvent, ResponderProps } from \"./types\"\n\n/** An opaque platform handle. A Gtk.Widget in practice; never treated as one. */\nexport type ResponderHost = object\n\nexport type ResponderSystemOptions = {\n  /** The platform's parent link. Returning null ends the path. */\n  parentOf: (host: ResponderHost) => ResponderHost | null\n  /**\n   * Fired after a node is granted the responder — where the platform makes\n   * its GTK `CLAIMED` declaration. One-way by construction: GTK has no way\n   * to hand a claimed sequence back, so this is only ever called once JS has\n   * already decided (docs/research/gestures.md, \"no voluntary release\").\n   */\n  onGrant?: (host: ResponderHost) => void\n  /** Fired when the responder is released or terminated. */\n  onRelease?: (host: ResponderHost) => void\n}\n\ntype Registration = { getProps: () => ResponderProps }\n\n// One interaction, from press to release. v1 is single-pointer: a mouse is\n// one fabricated touch, so at most one session exists at a time. It also\n// does the deduplicating — GTK delivers a press to every ancestor's gesture\n// in the bubble chain, so the second and later reports for the same press\n// find a session already open and return.\ntype Session = { host: ResponderHost; identifier: number }\n\nexport type ResponderSystem = {\n  register(host: ResponderHost, getProps: () => ResponderProps): () => void\n  touchStart(host: ResponderHost, touch: NativeTouch): void\n  touchMove(host: ResponderHost, touch: NativeTouch): void\n  touchEnd(host: ResponderHost, touch: NativeTouch): void\n  touchCancel(host: ResponderHost, touch: NativeTouch): void\n  /** The node currently holding the responder, or null. */\n  getResponder(): ResponderHost | null\n}\n\ntype ShouldSetName =\n  | \"onStartShouldSetResponder\"\n  | \"onStartShouldSetResponderCapture\"\n  | \"onMoveShouldSetResponder\"\n  | \"onMoveShouldSetResponderCapture\"\n\ntype NotifyName =\n  | \"onResponderGrant\"\n  | \"onResponderStart\"\n  | \"onResponderMove\"\n  | \"onResponderEnd\"\n  | \"onResponderRelease\"\n  | \"onResponderTerminate\"\n  | \"onResponderReject\"\n\ntype TouchName =\n  | \"onTouchStart\"\n  | \"onTouchStartCapture\"\n  | \"onTouchMove\"\n  | \"onTouchMoveCapture\"\n  | \"onTouchEnd\"\n  | \"onTouchEndCapture\"\n  | \"onTouchCancel\"\n  | \"onTouchCancelCapture\"\n\nexport const createResponderSystem = (\n  options: ResponderSystemOptions,\n): ResponderSystem => {\n  const registry = new Map<ResponderHost, Registration>()\n  const history = createTouchHistory()\n  let responder: ResponderHost | null = null\n  let session: Session | null = null\n\n  /**\n   * The registered nodes from the toplevel down to `host`, root first — RN's\n   * capture order, reversed for bubble.\n   *\n   * The walk stops wherever `parentOf` stops, which on this platform is the\n   * layout Root: an RN tree here is an island inside a native GTK widget\n   * tree (NestedRoot/IntrinsicRoot mount engines into arbitrary GTK slots),\n   * so there is no single app-wide view hierarchy to traverse. Native\n   * widgets on the way up are simply not registered and take no part.\n   */\n  const pathOf = (host: ResponderHost): ResponderHost[] => {\n    const path: ResponderHost[] = []\n    let current: ResponderHost | null = host\n    while (current) {\n      if (registry.has(current)) {\n        path.unshift(current)\n      }\n      current = options.parentOf(current)\n    }\n    return path\n  }\n\n  const propsOf = (host: ResponderHost): ResponderProps | null =>\n    registry.get(host)?.getProps() ?? null\n\n  const createEvent = (\n    touch: NativeTouch,\n    stillDown: boolean,\n  ): GestureResponderEvent => ({\n    nativeEvent: {\n      ...touch,\n      // Single-pointer: `touches` is the still-active set (empty once the\n      // pointer is up), `changedTouches` is always this one.\n      touches: stillDown ? [touch] : [],\n      changedTouches: [touch],\n    },\n    touchHistory: history,\n  })\n\n  /**\n   * Runs a should-set handler over `path` in order, stopping at the first\n   * that returns true — RN's executeDispatchesInOrderStopAtTrue. Handlers\n   * before the winner all run, which PanResponder depends on: its capture\n   * handlers are where gestureState is initialised and where dx/dy are\n   * accumulated on move.\n   */\n  const firstToClaim = (\n    path: readonly ResponderHost[],\n    name: ShouldSetName,\n    event: GestureResponderEvent,\n  ): ResponderHost | null => {\n    for (const host of path) {\n      const handler = propsOf(host)?.[name]\n      if (handler?.(event) === true) {\n        return host\n      }\n    }\n    return null\n  }\n\n  const notify = (\n    host: ResponderHost,\n    name: NotifyName,\n    event: GestureResponderEvent,\n  ): void => {\n    propsOf(host)?.[name]?.(event)\n  }\n\n  const dispatchTouch = (\n    path: readonly ResponderHost[],\n    captureName: TouchName,\n    bubbleName: TouchName,\n    event: GestureResponderEvent,\n  ): void => {\n    for (const host of path) {\n      propsOf(host)?.[captureName]?.(event)\n    }\n    for (let i = path.length - 1; i >= 0; i -= 1) {\n      propsOf(path[i]!)?.[bubbleName]?.(event)\n    }\n  }\n\n  const grant = (\n    host: ResponderHost,\n    event: GestureResponderEvent,\n    fromStart: boolean,\n  ): void => {\n    responder = host\n    notify(host, \"onResponderGrant\", event)\n    if (fromStart) {\n      notify(host, \"onResponderStart\", event)\n    }\n    options.onGrant?.(host)\n  }\n\n  /**\n   * Capture root-to-target, then bubble target-to-root — RN's two-phase\n   * negotiation, and the one place GTK's model and RN's agree, since GTK's\n   * CAPTURE/TARGET/BUBBLE phases run in exactly this order. We still do the\n   * walk ourselves so a single GTK event source can drive the whole path.\n   */\n  const negotiate = (\n    path: readonly ResponderHost[],\n    event: GestureResponderEvent,\n    phase: \"start\" | \"move\",\n  ): ResponderHost | null => {\n    const capture =\n      phase === \"start\"\n        ? \"onStartShouldSetResponderCapture\"\n        : \"onMoveShouldSetResponderCapture\"\n    const bubble =\n      phase === \"start\"\n        ? \"onStartShouldSetResponder\"\n        : \"onMoveShouldSetResponder\"\n    const captured = firstToClaim(path, capture, event)\n    if (captured) {\n      return captured\n    }\n    return firstToClaim([...path].reverse(), bubble, event)\n  }\n\n  const finish = (\n    touch: NativeTouch,\n    terminated: boolean,\n    touchProps: [TouchName, TouchName],\n  ): void => {\n    const current = session\n    if (!current) {\n      return\n    }\n    recordTouchEnd(history, touch)\n    refreshActiveTouches(history)\n    const event = createEvent(touch, false)\n    dispatchTouch(pathOf(current.host), touchProps[0], touchProps[1], event)\n\n    const holder = responder\n    session = null\n    responder = null\n    if (holder) {\n      notify(holder, \"onResponderEnd\", event)\n      notify(\n        holder,\n        terminated ? \"onResponderTerminate\" : \"onResponderRelease\",\n        event,\n      )\n      options.onRelease?.(holder)\n    }\n  }\n\n  return {\n    register(host, getProps) {\n      registry.set(host, { getProps })\n      return () => {\n        registry.delete(host)\n        // A responder that unmounts mid-gesture cannot be asked anything\n        // ever again; drop the lock rather than stranding it.\n        if (responder === host) {\n          responder = null\n        }\n        if (session?.host === host) {\n          session = null\n        }\n      }\n    },\n\n    touchStart(host, touch) {\n      // Already tracking this press: this is an ancestor's gesture seeing the\n      // same event through GTK's bubble chain.\n      if (session !== null) {\n        return\n      }\n      session = { host, identifier: touch.identifier }\n      recordTouchStart(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchStartCapture\", \"onTouchStart\", event)\n\n      if (responder !== null) {\n        return\n      }\n      const winner = negotiate(path, event, \"start\")\n      if (winner) {\n        grant(winner, event, true)\n      }\n    },\n\n    touchMove(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      recordTouchMove(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchMoveCapture\", \"onTouchMove\", event)\n\n      if (responder === null) {\n        // The common PanResponder shape: nothing claims on press, and the\n        // pan starts once onMoveShouldSetPanResponder sees enough movement.\n        const winner = negotiate(path, event, \"move\")\n        if (winner) {\n          grant(winner, event, false)\n        }\n        return\n      }\n      // v1 deliberately does not renegotiate while a responder holds: GTK\n      // cannot revoke a claim, so a transfer we cannot enforce natively would\n      // be a lie at the boundary with native widgets. Tracked as task 002b.\n      notify(responder, \"onResponderMove\", event)\n    },\n\n    touchEnd(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, false, [\"onTouchEndCapture\", \"onTouchEnd\"])\n    },\n\n    touchCancel(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, true, [\"onTouchCancelCapture\", \"onTouchCancel\"])\n    },\n\n    getResponder: () => responder,\n  }\n}\n"]}
+{"version":3,"file":"system.js","sourceRoot":"","sources":["../../src/responder/system.ts"],"names":[],"mappings":"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","sourcesContent":["// RN's Gesture Responder System: the negotiation, in pure JS.\n//\n// Zero @gtkx imports on purpose. Everything platform-specific enters through\n// two seams — `parentOf`, which turns a host handle into its parent, and\n// `onClaim`, the one-way GTK declaration the platform makes once per\n// interaction. That keeps the algorithm unit-testable off Linux, which\n// matters because this is the part that is subtle and the part every\n// platform historically gets wrong.\n//\n// Why reimplemented rather than reused: every other RN platform feeds\n// `topTouchStart/Move/End/Cancel` to the stock renderer's\n// ResponderEventPlugin, which lives in `facebook/react` inside\n// `react-native-renderer`. We render through `@gtkx/react` on\n// `react-reconciler`, so there is no plugin seam to feed —\n// react-native-web is in the same position and reimplemented for the same\n// reason (docs/research/gestures.md).\nimport type { NativeTouch } from \"../components/press-event\"\nimport {\n  createTouchHistory,\n  recordTouchEnd,\n  recordTouchMove,\n  recordTouchStart,\n  refreshActiveTouches,\n} from \"./touch-history\"\nimport type { GestureResponderEvent, ResponderProps } from \"./types\"\n\n/** An opaque platform handle. A Gtk.Widget in practice; never treated as one. */\nexport type ResponderHost = object\n\n/**\n * Why the responder was taken away by something that is not a pointer event.\n *\n * react-native-web's list is longer — cancel-ish events, context menu,\n * window blur, ancestor scroll, selection change — and measuring GTK\n * collapsed most of it. GTK cancels a single-button gesture the instant a\n * second button goes down, and a widget that steals a sequence (a\n * selectable label, a `GtkDragSource` attached through `Controllers`)\n * cancels it too, so \"context menu\" and \"selection change\" both arrive as\n * an ordinary `::cancel` on the event source and need no trigger of their\n * own. What is left needs asking for:\n *\n * - `\"blur\"`: the toplevel stopped being the active window. Not a question,\n *   in RN or here — the window is gone either way.\n * - `\"scroll\"`: an ancestor scroller moved under the gesture. The one\n *   termination a holder may refuse, and therefore the only place\n *   `onResponderTerminationRequest` is consulted outside a transfer (PRD\n *   crux 2: GTK's `CLAIMED` is irrevocable, so anything GTK has already\n *   taken cannot be given back no matter what the holder answers).\n */\nexport type TerminationReason = \"blur\" | \"scroll\"\n\nexport type ResponderSystemOptions = {\n  /** The platform's parent link. Returning null ends the path. */\n  parentOf: (host: ResponderHost) => ResponderHost | null\n  /**\n   * Fired at most ONCE per interaction, the first time any node is granted\n   * the responder — where the platform makes its GTK `CLAIMED` declaration.\n   *\n   * Its argument is the node whose event source is carrying the interaction,\n   * NOT the node that won the responder. Those differ whenever an ancestor\n   * claims (the common `onMoveShouldSetPanResponder` shape), and claiming on\n   * the ancestor is actively wrong: GTK denies the sequence on every gesture\n   * below the one that claims, which kills the very source the interaction\n   * is arriving through. What GTK is being told is \"this interaction belongs\n   * to React Native, native widgets keep off\" — a statement about the\n   * island, not about which view inside it currently holds the lock, which\n   * is a JS matter GTK has no way to represent.\n   *\n   * One-way by construction: GTK has no way to hand a claimed sequence back,\n   * so this only ever runs once JS has already decided (see\n   * docs/research/gestures.md, \"no voluntary release\").\n   */\n  onClaim?: (source: ResponderHost) => void\n}\n\ntype Registration = { getProps: () => ResponderProps }\n\n// One interaction, from press to release. v1 is single-pointer: a mouse is\n// one fabricated touch, so at most one session exists at a time. It also\n// does the deduplicating — GTK delivers a press to every ancestor's gesture\n// in the bubble chain, so the second and later reports for the same press\n// find a session already open and return.\n//\n// `lastTouch` exists for termination: a window losing focus is not a pointer\n// event, and `onResponderTerminate` still has to be handed an RN-shaped\n// event. The last known position is what RN reports there too.\ntype Session = {\n  host: ResponderHost\n  identifier: number\n  lastTouch: NativeTouch\n  claimed: boolean\n}\n\nexport type ResponderSystem = {\n  register(host: ResponderHost, getProps: () => ResponderProps): () => void\n  touchStart(host: ResponderHost, touch: NativeTouch): void\n  touchMove(host: ResponderHost, touch: NativeTouch): void\n  touchEnd(host: ResponderHost, touch: NativeTouch): void\n  touchCancel(host: ResponderHost, touch: NativeTouch): void\n  /**\n   * Something that is not a pointer event took the interaction. Returns\n   * whether the responder was actually given up — `false` means either\n   * nothing held it or the holder refused a reason that allows refusal.\n   */\n  terminate(reason: TerminationReason): boolean\n  /**\n   * THE OUT-OF-EVENT GRANT CHANNEL. A registered node asks for the responder\n   * between touch events, and the ordinary negotiation runs against a\n   * synthesized event at the last known pointer position.\n   *\n   * RN negotiates inside touch events only, so a recognizer that changes its\n   * mind on a TIMER has no way to take the interaction until the pointer next\n   * moves. `activateAfterLongPress` is exactly that recognizer: the press\n   * matures while the pointer is still, and waiting for the next move puts\n   * the \"lifted\" visual one frame late — or, for a press-and-hold that never\n   * moves again, never.\n   *\n   * The precedent is react-native-web, which added\n   * `onScrollShouldSetResponder` and `onSelectionChangeShouldSetResponder`\n   * for its own platform's realities; extending the model where the platform\n   * demands it is recorded as acceptable in docs/research/gestures.md, and\n   * this channel is documented there with its reason.\n   *\n   * Deliberately NOT a new prop and not a new grant path: it reuses\n   * `negotiateAndTransfer` unchanged, so capture still beats bubble, the LCA\n   * pruning still applies, and an ancestor that wants the interaction still\n   * wins it. The only thing that is new is WHEN the question gets asked. The\n   * synthesized event is the same one `terminate()` already builds from\n   * `session.lastTouch`, for the same reason.\n   *\n   * No `onResponderMove` is dispatched afterwards: the pointer did not move,\n   * and inventing a move to announce a grant would put a fabricated\n   * coordinate into every consumer's translation arithmetic.\n   *\n   * Returns whether `host` holds the responder once the negotiation is over\n   * — `false` when there is no interaction, when `host` is not on the path\n   * the interaction is travelling, or when somebody else won.\n   */\n  requestResponder(host: ResponderHost): boolean\n  /** The node currently holding the responder, or null. */\n  getResponder(): ResponderHost | null\n  /** The node whose event source is carrying the interaction, or null. */\n  getSource(): ResponderHost | null\n}\n\ntype ShouldSetName =\n  | \"onStartShouldSetResponder\"\n  | \"onStartShouldSetResponderCapture\"\n  | \"onMoveShouldSetResponder\"\n  | \"onMoveShouldSetResponderCapture\"\n\ntype NotifyName =\n  | \"onResponderGrant\"\n  | \"onResponderStart\"\n  | \"onResponderMove\"\n  | \"onResponderEnd\"\n  | \"onResponderRelease\"\n  | \"onResponderTerminate\"\n  | \"onResponderReject\"\n\ntype TouchName =\n  | \"onTouchStart\"\n  | \"onTouchStartCapture\"\n  | \"onTouchMove\"\n  | \"onTouchMoveCapture\"\n  | \"onTouchEnd\"\n  | \"onTouchEndCapture\"\n  | \"onTouchCancel\"\n  | \"onTouchCancelCapture\"\n\nexport const createResponderSystem = (\n  options: ResponderSystemOptions,\n): ResponderSystem => {\n  const registry = new Map<ResponderHost, Registration>()\n  const history = createTouchHistory()\n  let responder: ResponderHost | null = null\n  let session: Session | null = null\n\n  /**\n   * The registered nodes from the toplevel down to `host`, root first — RN's\n   * capture order, reversed for bubble.\n   *\n   * The walk stops wherever `parentOf` stops, which on this platform is the\n   * layout Root: an RN tree here is an island inside a native GTK widget\n   * tree (NestedRoot/IntrinsicRoot mount engines into arbitrary GTK slots),\n   * so there is no single app-wide view hierarchy to traverse. Native\n   * widgets on the way up are simply not registered and take no part.\n   */\n  const pathOf = (host: ResponderHost): ResponderHost[] => {\n    const path: ResponderHost[] = []\n    let current: ResponderHost | null = host\n    while (current) {\n      if (registry.has(current)) {\n        path.unshift(current)\n      }\n      current = options.parentOf(current)\n    }\n    return path\n  }\n\n  const propsOf = (host: ResponderHost): ResponderProps | null =>\n    registry.get(host)?.getProps() ?? null\n\n  const createEvent = (\n    touch: NativeTouch,\n    stillDown: boolean,\n  ): GestureResponderEvent => ({\n    nativeEvent: {\n      ...touch,\n      // Single-pointer: `touches` is the still-active set (empty once the\n      // pointer is up), `changedTouches` is always this one.\n      touches: stillDown ? [touch] : [],\n      changedTouches: [touch],\n    },\n    touchHistory: history,\n  })\n\n  /**\n   * Runs a should-set handler over `path` in order, stopping at the first\n   * that returns true — RN's executeDispatchesInOrderStopAtTrue. Handlers\n   * before the winner all run, which PanResponder depends on: its capture\n   * handlers are where gestureState is initialised and where dx/dy are\n   * accumulated on move.\n   */\n  const firstToClaim = (\n    path: readonly ResponderHost[],\n    name: ShouldSetName,\n    event: GestureResponderEvent,\n  ): ResponderHost | null => {\n    for (const host of path) {\n      const handler = propsOf(host)?.[name]\n      if (handler?.(event) === true) {\n        return host\n      }\n    }\n    return null\n  }\n\n  const notify = (\n    host: ResponderHost,\n    name: NotifyName,\n    event: GestureResponderEvent,\n  ): void => {\n    propsOf(host)?.[name]?.(event)\n  }\n\n  const dispatchTouch = (\n    path: readonly ResponderHost[],\n    captureName: TouchName,\n    bubbleName: TouchName,\n    event: GestureResponderEvent,\n  ): void => {\n    for (const host of path) {\n      propsOf(host)?.[captureName]?.(event)\n    }\n    for (let i = path.length - 1; i >= 0; i -= 1) {\n      propsOf(path[i]!)?.[bubbleName]?.(event)\n    }\n  }\n\n  const grant = (host: ResponderHost, event: GestureResponderEvent): void => {\n    responder = host\n    notify(host, \"onResponderGrant\", event)\n    // The GTK claim is per INTERACTION, not per grant: a transfer moves a JS\n    // lock, and there is nothing left to tell GTK once the sequence is\n    // already ours. Claiming again on the new holder's own gesture would\n    // deny the sequence on the source below it and silently end the drag.\n    if (session && !session.claimed) {\n      session.claimed = true\n      options.onClaim?.(session.host)\n    }\n  }\n\n  /**\n   * The negotiation path when someone already holds the responder: RN prunes\n   * it to the lowest common ancestor of the holder and the event target, and\n   * then skips the holder itself so it is never asked whether it wants what\n   * it already has. Pruning is what makes the lock transferable only\n   * UPWARDS — a descendant of the holder is not on the pruned path and\n   * cannot take it, which is RN's documented rule.\n   *\n   * Returns null when the two paths are disjoint (RNW's `lowestCommonAncestor\n   * == null`): nothing may take the responder in that case.\n   */\n  const pruneToAncestors = (\n    path: readonly ResponderHost[],\n    holder: ResponderHost,\n  ): ResponderHost[] | null => {\n    const holderPath = pathOf(holder)\n    let common = -1\n    const shared = Math.min(path.length, holderPath.length)\n    for (let i = 0; i < shared && path[i] === holderPath[i]; i += 1) {\n      common = i\n    }\n    if (common === -1) {\n      return null\n    }\n    return path.slice(0, path[common] === holder ? common : common + 1)\n  }\n\n  /**\n   * RN's handoff, in react-native-web's order: ask the holder, then\n   * terminate it, then grant. (Upstream's ResponderEventPlugin dispatches\n   * the grant BEFORE asking, so a rejected candidate still sees\n   * `onResponderGrant` — a quirk of the pooled-event implementation rather\n   * than of the model. RN's own documentation diagram, which RNW reproduces\n   * verbatim, shows TerminationRequest -> GRANT, and that is what we do.)\n   *\n   * A holder with no `onResponderTerminationRequest` always yields: absent\n   * means \"sure\", in RN and in RNW alike.\n   */\n  const attemptTransfer = (\n    winner: ResponderHost,\n    event: GestureResponderEvent,\n  ): void => {\n    const holder = responder\n    if (holder === null) {\n      grant(winner, event)\n      return\n    }\n    if (holder === winner) {\n      return\n    }\n    if (propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {\n      notify(winner, \"onResponderReject\", event)\n      return\n    }\n    notify(holder, \"onResponderTerminate\", event)\n    responder = null\n    grant(winner, event)\n  }\n\n  /**\n   * Capture root-to-target, then bubble target-to-root — RN's two-phase\n   * negotiation, and the one place GTK's model and RN's agree, since GTK's\n   * CAPTURE/TARGET/BUBBLE phases run in exactly this order. We still do the\n   * walk ourselves so a single GTK event source can drive the whole path.\n   */\n  const negotiate = (\n    path: readonly ResponderHost[],\n    event: GestureResponderEvent,\n    phase: \"start\" | \"move\",\n  ): ResponderHost | null => {\n    const capture =\n      phase === \"start\"\n        ? \"onStartShouldSetResponderCapture\"\n        : \"onMoveShouldSetResponderCapture\"\n    const bubble =\n      phase === \"start\"\n        ? \"onStartShouldSetResponder\"\n        : \"onMoveShouldSetResponder\"\n    const captured = firstToClaim(path, capture, event)\n    if (captured) {\n      return captured\n    }\n    return firstToClaim([...path].reverse(), bubble, event)\n  }\n\n  /**\n   * The whole negotiation for one event: prune the path if the lock is held,\n   * ask who wants it, hand it over. Returns nothing — the caller reads\n   * `responder` afterwards, because RN dispatches `onResponderStart`/`Move`\n   * to whoever holds the lock AFTER the handoff, not before it.\n   */\n  const negotiateAndTransfer = (\n    path: readonly ResponderHost[],\n    event: GestureResponderEvent,\n    phase: \"start\" | \"move\",\n  ): void => {\n    const holder = responder\n    const candidates = holder === null ? path : pruneToAncestors(path, holder)\n    if (candidates === null || candidates.length === 0) {\n      return\n    }\n    const winner = negotiate(candidates, event, phase)\n    if (winner) {\n      attemptTransfer(winner, event)\n    }\n  }\n\n  const finish = (\n    touch: NativeTouch,\n    terminated: boolean,\n    touchProps: [TouchName, TouchName],\n  ): void => {\n    const current = session\n    if (!current) {\n      return\n    }\n    recordTouchEnd(history, touch)\n    refreshActiveTouches(history)\n    const event = createEvent(touch, false)\n    dispatchTouch(pathOf(current.host), touchProps[0], touchProps[1], event)\n\n    const holder = responder\n    session = null\n    responder = null\n    if (holder) {\n      notify(holder, \"onResponderEnd\", event)\n      notify(\n        holder,\n        terminated ? \"onResponderTerminate\" : \"onResponderRelease\",\n        event,\n      )\n    }\n  }\n\n  return {\n    register(host, getProps) {\n      registry.set(host, { getProps })\n      return () => {\n        registry.delete(host)\n        // A responder that unmounts mid-gesture cannot be asked anything\n        // ever again; drop the lock rather than stranding it.\n        if (responder === host) {\n          responder = null\n        }\n        if (session?.host === host) {\n          session = null\n        }\n      }\n    },\n\n    touchStart(host, touch) {\n      // Already tracking this press: this is an ancestor's gesture seeing the\n      // same event through GTK's bubble chain.\n      if (session !== null) {\n        return\n      }\n      session = {\n        host,\n        identifier: touch.identifier,\n        lastTouch: touch,\n        claimed: false,\n      }\n      recordTouchStart(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchStartCapture\", \"onTouchStart\", event)\n\n      negotiateAndTransfer(path, event, \"start\")\n      // RN dispatches this to whoever holds the lock once the handoff is\n      // over, which is why it is not folded into grant(): a view granted on\n      // a MOVE must not be told the interaction just started.\n      if (responder !== null) {\n        notify(responder, \"onResponderStart\", event)\n      }\n    },\n\n    touchMove(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      session.lastTouch = touch\n      recordTouchMove(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchMoveCapture\", \"onTouchMove\", event)\n\n      // Two shapes go through here. Nobody holds the lock yet: the common\n      // PanResponder one, where the pan starts once\n      // onMoveShouldSetPanResponder sees enough movement. Somebody does: an\n      // ancestor may still take it over, and the move is then delivered to\n      // whoever ends up holding it — including in the same event as the\n      // handoff, exactly as RN's own state diagram shows.\n      negotiateAndTransfer(path, event, \"move\")\n      if (responder !== null) {\n        notify(responder, \"onResponderMove\", event)\n      }\n    },\n\n    touchEnd(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, false, [\"onTouchEndCapture\", \"onTouchEnd\"])\n    },\n\n    touchCancel(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, true, [\"onTouchCancelCapture\", \"onTouchCancel\"])\n    },\n\n    terminate(reason) {\n      const current = session\n      const holder = responder\n      if (current === null || holder === null) {\n        // Nothing holds the lock: an ancestor scrolling or a menu opening is\n        // then simply an ancestor scrolling or a menu opening. RN terminates\n        // a RESPONDER; it has nothing to say when there is not one.\n        return false\n      }\n      const event = createEvent(current.lastTouch, false)\n      if (\n        reason === \"scroll\" &&\n        propsOf(holder)?.onResponderTerminationRequest?.(event) === false\n      ) {\n        return false\n      }\n\n      // No onResponderEnd here, and that is RN's shape rather than an\n      // oversight: End pairs with a touch actually ending. A termination\n      // that is not a pointer event goes straight to Terminate.\n      recordTouchEnd(history, current.lastTouch)\n      refreshActiveTouches(history)\n      session = null\n      responder = null\n      notify(holder, \"onResponderTerminate\", event)\n      return true\n    },\n\n    requestResponder(host) {\n      const current = session\n      if (current === null) {\n        // No interaction to take. A timer that fires after the pointer is up\n        // is a timer that lost, and there is nothing to negotiate over.\n        return false\n      }\n      if (responder === host) {\n        return true\n      }\n      const path = pathOf(current.host)\n      // A node off the interaction's path is not a candidate — the same rule\n      // the touch paths enforce by construction, stated here because this\n      // entry point is reached from a timer rather than from an event that\n      // already travelled the tree.\n      if (!path.includes(host)) {\n        return false\n      }\n      negotiateAndTransfer(path, createEvent(current.lastTouch, true), \"move\")\n      return responder === host\n    },\n\n    getResponder: () => responder,\n    getSource: () => session?.host ?? null,\n  }\n}\n"]}

package/dist/responder/use-responder.d.ts

@@ -4,6 +4,17 @@ import { type ResponderHost } from "./system";
 import { type ResponderProps } from "./types";
 /** Exposed for tests and for future ScrollView arbitration. */
 export declare const getCurrentResponder: () => ResponderHost | null;
+/**
+ * The out-of-event grant channel, for a recognizer whose mind was changed by
+ * a timer rather than by a pointer (`activateAfterLongPress`). See
+ * `ResponderSystem.requestResponder` for what it does and
+ * docs/research/gestures.md for why the model is extended at all.
+ *
+ * @internal Not part of the RN surface: an app writes responder props, and
+ * nothing in RN asks for the responder from outside an event. This exists for
+ * `GestureDetector`, whose recognizers do.
+ */
+export declare const requestResponder: (widget: Gtk.Widget) => boolean;
 /**
  * Attaches the responder event source to a component's widget, but only when
  * it actually declares responder props — RN never asks a view without

package/dist/responder/use-responder.js

@@ -15,6 +15,9 @@
 // drag-begin on press with no threshold of its own, which is exactly what
 // RN wants — the responder system has no threshold either, and PanResponder
 // users apply their own inside onMoveShouldSetPanResponder.
+//
+// The terminations that are not pointer events (watchTerminations, below)
+// were expected to need that raw tap after all. Measurement said otherwise.
 import { useLayoutEffect, useRef } from "react";
 import { createTouch } from "../components/press-event";
 import { Gtk } from "../gtkx/bridge/index";
@@ -23,6 +26,79 @@ import { hasResponderProps } from "./types";
 // The gesture that reported each registered widget, so a grant can make the
 // GTK claim on the right one.
 const gestures = new WeakMap();
+/** Whether `widget` is `ancestor` or sits underneath it. */
+const contains = (ancestor, widget) => {
+    for (let current = widget; current !== null; current = current.getParent()) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Every `GtkScrolledWindow` above `source`, innermost first. Nested
+ * scrollers are rare but real, and stopping only the innermost would let an
+ * outer one take the drag instead.
+ */
+const enclosingScrollers = (source) => {
+    const found = [];
+    for (let widget = source.getParent(); widget !== null; widget = widget.getParent()) {
+        if (widget instanceof Gtk.ScrolledWindow) {
+            found.push(widget);
+        }
+    }
+    return found;
+};
+/**
+ * `setIsJSResponder`, which is what every RN platform calls the message
+ * "JavaScript has taken this interaction, native scroller stop stealing the
+ * drag". iOS cancels the `UIScrollView` pan when the responder is a
+ * descendant; Android has a `JSResponderHandler`; react-native-windows
+ * punted on it in 2017, shipped a `manipulationModes` prop instead, and its
+ * tracking issues are still open.
+ *
+ * On GTK the message is `kinetic-scrolling`. Measured on GTK 4 rather than
+ * inferred (tests/gtk/components/scroll-arbitration.gtk.test.tsx):
+ * `GtkScrolledWindow` installs exactly four gestures of its own —
+ * `GestureLongPress`, `GestureSwipe`, `GesturePan`, `GestureDrag`, all
+ * touch-only, all in the CAPTURE phase — and turning kinetic scrolling off
+ * puts those four, and only those four, into `GTK_PHASE_NONE`. Setting a
+ * controller's phase to NONE resets it, so a scroll that had already begun
+ * stops there; the wheel and the motion controllers are untouched, so
+ * scrolling with a mouse keeps working while a child pans.
+ *
+ * Why this is needed at all when the `CLAIMED` declaration above already
+ * denies ancestor gestures: it is a race, and only sometimes ours.
+ * `GtkScrolledWindow` does not claim on press — it claims in `drag-update`,
+ * once movement passes `gtk-dnd-drag-threshold` (8 px). A view that claims
+ * on press beats it. A view that claims on a MOVE — which is what
+ * `onMoveShouldSetPanResponder` does, and it is the commonest shape there
+ * is — usually does not, and `CLAIMED` cannot be taken back once the
+ * scroller has it. So the claim is not enough on its own, and this is the
+ * part that makes a child pan reachable inside a scrolling list.
+ *
+ * Restores the previous value rather than assuming `true`: an app that
+ * turned kinetic scrolling off itself must not have it turned back on.
+ */
+const suspendEnclosingScrollers = (source) => {
+    const suspended = enclosingScrollers(source).filter((scroller) => scroller.getKineticScrolling());
+    for (const scroller of suspended) {
+        scroller.setKineticScrolling(false);
+    }
+    return () => {
+        for (const scroller of suspended) {
+            scroller.setKineticScrolling(true);
+        }
+    };
+};
+/**
+ * The scroller suspension for the interaction currently under way. Module
+ * scope because it is set when the responder is granted and undone when the
+ * interaction ends, which are two different events on two different
+ * objects; there is only ever one interaction, which is the same assumption
+ * the responder system itself is built on (one pointer, one session).
+ */
+let restoreScrollers = null;
 /**
  * One lock for the process, as in RN. What is island-scoped is the
  * negotiation PATH, not the lock: `parentOf` walks the GTK widget tree and
@@ -31,15 +107,100 @@ const gestures = new WeakMap();
  */
 const responderSystem = createResponderSystem({
     parentOf: (host) => host.getParent(),
-    onGrant: (host) => {
+    onClaim: (source) => {
         // GTK's only arbitration primitive, used the only way it can honestly be
         // used: a final one-way declaration AFTER JS has decided. There is no
         // un-claim, so nothing may depend on taking it back.
-        gestures.get(host)?.setState(Gtk.EventSequenceState.CLAIMED);
+        //
+        // On the SOURCE's gesture — the one the interaction is arriving through
+        // — never on the granted view's. Claiming denies the sequence on every
+        // gesture above the claimer and cancels it on everything below, so
+        // claiming on an ancestor kills the source and the drag goes silent
+        // after the grant. Slice 2 did exactly that, and the common
+        // onMoveShouldSetPanResponder shape never received a single move.
+        gestures.get(source)?.setState(Gtk.EventSequenceState.CLAIMED);
+        // A ResponderHost is deliberately opaque to the pure module; on this
+        // platform it is always the Gtk.Widget that registered it.
+        restoreScrollers = suspendEnclosingScrollers(source);
     },
 });
+/**
+ * Everything that ends a gesture without being a pointer event, connected
+ * for the length of one interaction and torn down with it.
+ *
+ * The plan for this task called for a single `GtkEventControllerLegacy` on
+ * the toplevel in the capture phase — react-native-web's shape, on the
+ * reasoning that a raw event tap is the only way to see terminations that
+ * are not pointer events. Measured against GTK, it buys nothing here. Each
+ * of the two triggers that survive has a first-class signal that says
+ * exactly what we need to know and nothing else, and the rest of RNW's list
+ * turned out to arrive as an ordinary gesture `::cancel` (see
+ * `TerminationReason`). A legacy controller would have re-derived all of it
+ * from a stream of raw events, and its one advantage — hearing events on a
+ * sequence GTK has already denied us — matters only for triggers that no
+ * longer exist.
+ */
+const watchTerminations = (source) => {
+    const disposers = [];
+    // Window blur. GTK's `is-active` on the toplevel is the same thing the DOM
+    // reports as a window `blur` — the window stopped being the active one,
+    // which on a desktop usually means the user alt-tabbed mid-drag.
+    const root = source.getRoot();
+    if (root instanceof Gtk.Window) {
+        const onActive = () => {
+            if (!root.isActive()) {
+                responderSystem.terminate("blur");
+            }
+        };
+        root.on("notify::is-active", onActive);
+        disposers.push(() => {
+            root.off("notify::is-active", onActive);
+        });
+    }
+    // An ancestor scrolling. RNW's rule exactly: the scroller has to CONTAIN
+    // the responder and not BE it — a ScrollView that holds the responder
+    // itself keeps it, and a sibling list scrolling is none of our business.
+    // Watching the adjustments rather than a scroll controller is what makes
+    // that precise: it fires for a wheel, for a keyboard scroll and for
+    // kinetic deceleration alike, and only for this scroller.
+    for (const scroller of enclosingScrollers(source)) {
+        const onScrolled = () => {
+            const holder = responderSystem.getResponder();
+            if (holder !== null &&
+                holder !== scroller &&
+                contains(scroller, holder)) {
+                responderSystem.terminate("scroll");
+            }
+        };
+        for (const adjustment of [
+            scroller.getHadjustment(),
+            scroller.getVadjustment(),
+        ]) {
+            adjustment.on("value-changed", onScrolled);
+            disposers.push(() => {
+                adjustment.off("value-changed", onScrolled);
+            });
+        }
+    }
+    return () => {
+        for (const dispose of disposers) {
+            dispose();
+        }
+    };
+};
 /** Exposed for tests and for future ScrollView arbitration. */
 export const getCurrentResponder = () => responderSystem.getResponder();
+/**
+ * The out-of-event grant channel, for a recognizer whose mind was changed by
+ * a timer rather than by a pointer (`activateAfterLongPress`). See
+ * `ResponderSystem.requestResponder` for what it does and
+ * docs/research/gestures.md for why the model is extended at all.
+ *
+ * @internal Not part of the RN surface: an app writes responder props, and
+ * nothing in RN asks for the responder from outside an event. This exists for
+ * `GestureDetector`, whose recognizers do.
+ */
+export const requestResponder = (widget) => responderSystem.requestResponder(widget);
 /**
  * Attaches the responder event source to a component's widget, but only when
  * it actually declares responder props — RN never asks a view without
@@ -69,25 +230,83 @@ export const useResponder = (widgetRef, props) => {
         // coordinates — the start has to be carried.
         let startX = 0;
         let startY = 0;
+        let stopWatching = null;
+        // Whether this sequence was taken from us by something above. See the
+        // `sequence-state-changed` handler below.
+        let denied = false;
+        const endInteraction = () => {
+            stopWatching?.();
+            stopWatching = null;
+            restoreScrollers?.();
+            restoreScrollers = null;
+        };
+        // THE ONE SIGNAL THAT TELLS A THEFT FROM AN ENDING.
+        //
+        // GTK's claim propagation is asymmetric, and measuring it on 4.22.4
+        // corrected `docs/research/gestures.md`, which had it backwards. A claim
+        // by a DESCENDANT cancels the ancestor's gesture — `::cancel` then
+        // `::end`, and no state transition at all, which the `cancel` handler
+        // below already turns into a termination. A claim by an ANCESTOR is the
+        // dangerous direction: it DENIES the descendant's sequence and then ends
+        // it with an ordinary `drag-end`, exactly the signal a finger lifting
+        // produces. Without this handler a native ancestor stealing the drag
+        // mid-gesture reaches JS as `onResponderRelease` — a CLEAN RELEASE,
+        // indistinguishable from the user letting go, so a drag would commit
+        // itself at whatever position the theft happened at.
+        //
+        // `->DENIED` is the only thing that separates the two, which is why the
+        // sequence state has to be watched rather than just the drag signals.
+        // Nothing else here can produce it: this module never sets DENIED, and
+        // our own CLAIMED is always made on the source, which cancels ancestors
+        // rather than denying them.
+        drag.on("sequence-state-changed", (_sequence, state) => {
+            if (state === Gtk.EventSequenceState.DENIED) {
+                denied = true;
+            }
+        });
         drag.on("drag-begin", (x, y) => {
             startX = x;
             startY = y;
+            // A `GtkGestureSingle` denies its own sequence when a press arrives on
+            // the wrong button and nothing is down yet, so the flag can survive from
+            // before this press. Every interaction starts clean.
+            denied = false;
             responderSystem.touchStart(widget, createTouch(widget, x, y));
+            // Every ancestor's gesture reports the same press; only the one that
+            // opened the interaction owns it, and asking the system afterwards is
+            // the cheapest way to find out which that was.
+            if (responderSystem.getSource() === widget) {
+                stopWatching = watchTerminations(widget);
+            }
         });
         drag.on("drag-update", (offsetX, offsetY) => {
             responderSystem.touchMove(widget, createTouch(widget, startX + offsetX, startY + offsetY));
         });
         drag.on("drag-end", (offsetX, offsetY) => {
-            responderSystem.touchEnd(widget, createTouch(widget, startX + offsetX, startY + offsetY));
+            const touch = createTouch(widget, startX + offsetX, startY + offsetY);
+            // A denied sequence ends with this same signal, and it is not an
+            // ending: the interaction was taken away. RN's word for that is a
+            // termination, so it goes down the cancel path.
+            if (denied) {
+                responderSystem.touchCancel(widget, touch);
+            }
+            else {
+                responderSystem.touchEnd(widget, touch);
+            }
+            endInteraction();
         });
-        // GTK cancels a sequence when something upstream claims it — a native
-        // ancestor scrolling, say. RN calls that a termination, and it is the
-        // one termination trigger we get for free.
+        // GTK cancels a sequence when something takes it away from us: a native
+        // ancestor claiming it, a `GtkDragSource` attached through `Controllers`
+        // reaching its threshold, a second mouse button going down for a context
+        // menu. RN calls all of that a termination, and unlike RNW we never get
+        // to ask first — by the time GTK tells us, the sequence is gone.
         drag.on("cancel", () => {
             responderSystem.touchCancel(widget, createTouch(widget, startX, startY));
+            endInteraction();
         });
         widget.addController(drag);
         return () => {
+            endInteraction();
             widget.removeController(drag);
             gestures.delete(widget);
             unregister();