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

package/dist/gesture-handler-compat/recognizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizer.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/recognizer.ts"],"names":[],"mappings":"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","sourcesContent":["// The recognizer: a state machine over RN's touch and responder props, which\n// is what a `GestureDetector` actually is once both spellings of the builder\n// are stripped away.\n//\n// THE SEAM THAT MAKES IT WORK, and it reads like a footnote: **View touch\n// props fire independently of responder status**. So the machine runs off\n// `onTouchStart`/`onTouchMove`, keeps its own\n// UNDETERMINED -> BEGAN -> ACTIVE/FAILED progression, holds no lock while it\n// is deciding, and returns `true` from `onMoveShouldSetResponder` at exactly\n// the instant it activates. `onStartShouldSetResponder` returns false always\n// — a pan that grabbed the interaction on press is a pan with no\n// `activeOffset` at all, and deciding late is what every offset knob is for.\n//\n// `responder/system.ts` dispatches the touch props BEFORE it negotiates, in\n// both `touchStart` and `touchMove`, so the machine's state is always current\n// by the time the negotiation asks it anything. That ordering is load-bearing\n// and predates this module.\n//\n// TWO LOCKS, AT TWO LEVELS, and this file is where they meet. The responder\n// lock keeps its one job — one interaction, one holder, one irrevocable GTK\n// `CLAIMED` on the source. Gesture arbitration is a second, JS-only registry\n// (./orchestrator) that never talks to GTK, and `decide()` below is the one\n// place a recognizer asks it for a turn. A gesture that is first to activate\n// takes the responder as it always did; a gesture activating alongside one\n// that already holds it does not ask, becomes ACTIVE in the registry, and is\n// driven from the touch props.\n//\n// There are therefore two reasons a gesture can be ACTIVE without the lock —\n// a kind that never takes it (`Native`, `claimsResponder: false`) and one that\n// simply lost the race to a simultaneous partner — and exactly one test for\n// both: `runtime.hasResponder`. A static per-kind flag cannot answer it,\n// because whether a `Pan` holds the lock is a fact about this interaction.\nimport type { GestureResponderEvent } from \"../responder/types\"\nimport type { Orchestrator, Participant } from \"./orchestrator\"\nimport {\n  GESTURE_STATE,\n  POINTER_TYPE,\n  TOUCH_EVENT_TYPE,\n  type GestureEventPayload,\n  type GestureHitSlop,\n  type GestureKind,\n  type GestureStateManagerApi,\n  type GestureStateValue,\n  type GestureTouchEvent,\n  type RecognizerConfig,\n  type TouchEventTypeValue,\n} from \"./types\"\n\nexport type Rect = { x: number; y: number; width: number; height: number }\n\n/**\n * What the recognizer needs from the world it is mounted in: where its view\n * is, and how to take the interaction when no touch event is in flight.\n */\nexport type RecognizerEnvironment = {\n  /**\n   * The gesture's own view in WINDOW coordinates, or null before it is laid\n   * out. Window coordinates because that is the space RN's `pageX`/`pageY`\n   * are in, so no conversion sits between a touch and a bounds test.\n   */\n  boundsInWindow: () => Rect | null\n  /**\n   * Ask for the responder outside a touch event. Returns whether it was\n   * granted. See `ResponderSystem.requestResponder`.\n   */\n  requestResponder: () => boolean\n  /**\n   * The JS-only arbitration registry this gesture takes part in. Injected\n   * rather than imported so a test can drive one loop in isolation, exactly\n   * as the responder system is injected rather than imported.\n   */\n  orchestrator: Orchestrator\n}\n\n/** The read-only view of the runtime the predicates are allowed to see. */\nexport type RecognizerView = {\n  /** Measured from the point of ACTIVATION once there is one; see `Runtime`. */\n  translationX: number\n  translationY: number\n  /**\n   * Straight-line travel from the PRESS, which outlives activation.\n   *\n   * `LongPress` needs this and translation will not do: it activates on a\n   * timer, translation is re-based to the activation point, and upstream's\n   * `maxDist` is measured from the press for the whole gesture — so a hold\n   * that drifted 8px before the timer and 8px after it has travelled 16, not\n   * twice-nearly-nothing.\n   */\n  distanceFromPress: number\n  velocityX: number\n  velocityY: number\n  /** Whether this press's own timer has already fired. */\n  timerElapsed: boolean\n  /** Pointers down now, and the most this interaction has ever had at once. */\n  pointerCount: number\n  maxPointerCount: number\n  /** Completed press-release cycles, including the one being decided. */\n  taps: number\n  /**\n   * `Pinch`: the scale since GTK recognized the gesture, 1 at the start.\n   * `Rotation`: radians since it did, 0 at the start and positive clockwise.\n   *\n   * Both are 1 and 0 for every pointer-driven kind, so a predicate that reads\n   * them on the wrong kind gets the identity rather than a lie.\n   */\n  scale: number\n  rotation: number\n  /**\n   * `ForceTouch`: the pressure, normalised to `[0, 1]`.\n   *\n   * 0 for every other kind — an input with no pressure axis reports no\n   * pressure, and a predicate reading this on the wrong kind gets the number\n   * that is true rather than one that looks plausible.\n   */\n  force: number\n}\n\n/**\n * The timer a recognizer arms on every press, and what its firing means.\n *\n * All three kinds want one and they disagree only about the outcome: `Pan`'s\n * `activateAfterLongPress` and `LongPress`'s `minDuration` mature the gesture,\n * `Tap`'s `maxDuration` is a deadline that kills it.\n */\nexport type RecognizerTimer = {\n  delay: number\n  elapsed: \"activate\" | \"fail\"\n}\n\n/** What lifting the pointer means to a gesture that is still BEGAN. */\nexport type ReleaseOutcome =\n  | { kind: \"activate\" }\n  | { kind: \"fail\" }\n  /** Not over — wait this long for another press, then fail. */\n  | { kind: \"await\"; delay: number }\n  /**\n   * Nothing at all: stay BEGAN, with no timer and no decision.\n   *\n   * `Manual` alone, and it is upstream's documented rule for it — \"it will not\n   * fail when all the pointers are lifted from the screen\". A gesture the app\n   * drives has no business being failed by a lift the app did not ask about.\n   */\n  | { kind: \"hold\" }\n\n/**\n * What a recognizer kind contributes: predicates over the current state of\n * one press. Everything else — the state progression, the callbacks, the\n * responder plumbing, the bounds tests, the timer — is shared, which is what\n * makes `Tap` and `LongPress` an afternoon rather than a second machine.\n *\n * Only `shouldFail` and `shouldActivate` are required, and `Pan` implements\n * exactly those two: the rest exist because `Tap` activates on a RELEASE and\n * `LongPress` can be cancelled after it is already ACTIVE, and neither shape\n * was reachable from a pair of movement predicates.\n */\nexport type RecognizerDecider = {\n  /**\n   * Which kind this is.\n   *\n   * Carried by the decider because the decider IS what tells the kinds apart,\n   * and because the arbitration loop needs exactly one fact about a gesture\n   * beyond its relations: whether it is `Gesture.Native()`, the one kind that\n   * can cancel an already-active gesture.\n   */\n  kind: GestureKind\n  shouldFail: (view: RecognizerView, config: RecognizerConfig) => boolean\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig) => boolean\n  /** Absent means \"no timer\", which is `Pan` without `activateAfterLongPress`. */\n  timer?: (config: RecognizerConfig) => RecognizerTimer | null\n  /** Absent means an ACTIVE gesture is only ever ended by the pointer. */\n  shouldCancelWhileActive?: (\n    view: RecognizerView,\n    config: RecognizerConfig,\n  ) => boolean\n  /** Absent means a lift while BEGAN is the end of it, which is `Pan`'s rule. */\n  onRelease?: (view: RecognizerView, config: RecognizerConfig) => ReleaseOutcome\n  /**\n   * Whether activating means taking the responder. Absent means yes, which is\n   * every recognizer that decides the interaction is React Native's.\n   *\n   * `Native` is the one that says no, and it is not an optimisation: taking\n   * the responder is what makes the platform declare `CLAIMED` and suspend\n   * every enclosing `GtkScrolledWindow`'s kinetics\n   * (`responder/use-responder.ts`). A gesture whose entire meaning is \"the\n   * native widget is handling this\" cannot be the thing that stops the native\n   * widget from handling it.\n   *\n   * A recognizer that does not claim runs off the touch props alone — they\n   * fire regardless of responder status, which is the same seam the BEGAN\n   * phase already uses. It never receives `onResponderMove`, so its updates\n   * come from `onTouchMove` and its ending from `onTouchEnd`/`onTouchCancel`.\n   */\n  claimsResponder?: boolean\n  /**\n   * Activating IS the whole gesture: end it, successfully, in the same breath.\n   *\n   * `Fling` alone, and it is upstream's own shape rather than a shortcut —\n   * `FlingGestureHandler.activate()` is overridden to call `this.end()`\n   * immediately after `super.activate()`. A fling is a verdict about a motion\n   * that has already happened, so there is nothing left to report once it is\n   * reached: BEGAN -> ACTIVE -> END, synchronously, with `onStart` and `onEnd`\n   * one after the other and no `onUpdate` between them.\n   */\n  endsOnActivate?: boolean\n  /**\n   * Which entry surface drives this kind. Absent means `\"pointer\"`.\n   *\n   * The one structural concession this module makes, and it is about where\n   * events COME FROM rather than about what happens to them. Three kinds of\n   * input are simply not in the pointer stream:\n   *\n   *   - `\"touchpad\"` — `Pinch`/`Rotation`, fed by\n   *     `GtkGestureZoom`/`GtkGestureRotate`, because a touchpad pinch presses\n   *     no button and so opens no GTK sequence and no responder session;\n   *   - `\"hover\"` — `Hover`, fed by `GtkEventControllerMotion`, because a\n   *     pointer that is merely OVER a view has pressed nothing either, and\n   *     RN's touch props fire only from a press;\n   *   - `\"stylus\"` — `ForceTouch`, fed by `GtkGestureStylus`, because pressure\n   *     is a tablet axis and `wl_pointer` has none.\n   *\n   * Everything downstream of the entry point is this same machine: the same\n   * states, the same callbacks, the same payload, the same `tryActivate` and\n   * the same relation maps. There is no second arbitration path.\n   *\n   * Exactly one surface is live per recognizer. A non-pointer kind's\n   * touch/responder props are empty, so a mouse press cannot begin a pinch or\n   * a hover; a `\"pointer\"` kind's controller channel is inert, so a pinch\n   * cannot begin a pan.\n   */\n  source?: \"pointer\" | \"touchpad\" | \"hover\" | \"stylus\"\n}\n\ntype Timer = ReturnType<typeof setTimeout> | null\n\ntype Runtime = {\n  state: GestureStateValue\n  oldState: GestureStateValue\n  /**\n   * WALL CLOCK at the press, which is what `duration` is measured against.\n   * Not the event's own `timestamp`: that is GTK's event time, with no fixed\n   * epoch, and a timer firing has no event to read one off anyway. Upstream\n   * computes it the same way.\n   */\n  pressTime: number\n  /** Where translation is measured FROM; reset to the activation point. */\n  originX: number\n  originY: number\n  /** Where the press landed, which activation does NOT move. */\n  pressX: number\n  pressY: number\n  lastX: number\n  lastY: number\n  lastTime: number\n  velocityX: number\n  velocityY: number\n  /** The previous update's translation, for the change delta. */\n  changeFromX: number\n  changeFromY: number\n  /** Whether any update has been emitted yet, for the first change delta. */\n  hasEmittedUpdate: boolean\n  /** Whether the gesture ever reached ACTIVE, which outlives the state itself. */\n  hasActivated: boolean\n  activationTimer: Timer\n  timerElapsed: boolean\n  pointerCount: number\n  maxPointerCount: number\n  /**\n   * Completed press-release cycles, and the timer waiting for the next one.\n   *\n   * These two are the only state that survives a press, and the timer IS the\n   * sequence: while it is armed the gesture is a multi-tap in progress, and\n   * the next `onTouchStart` continues it instead of starting over.\n   */\n  taps: number\n  delayTimer: Timer\n  /**\n   * The orchestrator cleared this gesture to become ACTIVE and it is waiting\n   * for the responder lock to catch up.\n   *\n   * This is the ONLY thing `onMoveShouldSetResponder` answers from. It used to\n   * mean \"a timer or a callback asked to activate\", which was the same thing\n   * while there was nothing to arbitrate; now the difference is load-bearing,\n   * because a gesture parked behind `requireExternalGestureToFail` wants to\n   * activate and must not be allowed to take the lock.\n   */\n  authorized: boolean\n  /**\n   * Whether THIS gesture holds the responder, in THIS interaction.\n   *\n   * Which of two update pumps drives it: the holder reads `onResponderMove`,\n   * anything else ACTIVE reads `onTouchMove`. Two different gestures end up on\n   * the second pump and only this flag covers both — a kind that never takes\n   * the lock (`claimsResponder: false`), and a kind that does but lost the\n   * race to a simultaneous partner. Exactly one pump fires per gesture.\n   */\n  hasResponder: boolean\n  forcedFailure: boolean\n  /**\n   * The touchpad gesture's own accumulators, and the values the previous\n   * update reported — which is what `scaleChange`/`rotationChange` and\n   * `velocity` are computed from.\n   *\n   * Held here rather than read back off the GTK controller so that a\n   * recognizer measures what it was TOLD. `gtk_gesture_zoom_get_scale_delta`\n   * returns 1 the moment the gesture is no longer active, so an `end` handler\n   * that asked GTK would report the gesture undoing itself.\n   */\n  scale: number\n  rotation: number\n  scaleVelocity: number\n  rotationVelocity: number\n  changeFromScale: number\n  changeFromRotation: number\n  /** `ForceTouch`'s pressure, and the value the previous update reported. */\n  force: number\n  changeFromForce: number\n  /** Wall clock of the last controller sample, for the per-second velocities. */\n  lastSampleTime: number\n}\n\nconst newRuntime = (): Runtime => ({\n  state: GESTURE_STATE.UNDETERMINED,\n  oldState: GESTURE_STATE.UNDETERMINED,\n  pressTime: 0,\n  originX: 0,\n  originY: 0,\n  pressX: 0,\n  pressY: 0,\n  lastX: 0,\n  lastY: 0,\n  lastTime: 0,\n  velocityX: 0,\n  velocityY: 0,\n  changeFromX: 0,\n  changeFromY: 0,\n  hasEmittedUpdate: false,\n  hasActivated: false,\n  activationTimer: null,\n  timerElapsed: false,\n  pointerCount: 0,\n  maxPointerCount: 0,\n  taps: 0,\n  delayTimer: null,\n  authorized: false,\n  hasResponder: false,\n  forcedFailure: false,\n  scale: 1,\n  rotation: 0,\n  scaleVelocity: 0,\n  rotationVelocity: 0,\n  changeFromScale: 1,\n  changeFromRotation: 0,\n  force: 0,\n  changeFromForce: 0,\n  lastSampleTime: 0,\n})\n\n/**\n * RNGH's `checkHitSlop`, restated: build the acceptable box in the view's own\n * coordinates, then test the pointer's offset into the view against it.\n *\n * Every side is \"outward is positive\", so a NEGATIVE value shrinks the box —\n * the capability RN's own View `hitSlop` does not have. Explicit sides\n * override `horizontal`/`vertical`, and `width`/`height` then anchor the\n * opposite edge to whichever side was named.\n *\n * The plain-number spelling is normalised into the four sides up front.\n * Upstream's web path does not do this and silently ignores a number, which\n * is a bug rather than a semantic worth reproducing — its own native paths\n * normalise exactly this way.\n */\nexport const hitSlopRect = (\n  bounds: Rect,\n  hitSlop: GestureHitSlop | undefined,\n): Rect => {\n  if (hitSlop === undefined || hitSlop === null) {\n    return bounds\n  }\n  const slop =\n    typeof hitSlop === \"number\"\n      ? { left: hitSlop, right: hitSlop, top: hitSlop, bottom: hitSlop }\n      : hitSlop\n\n  let left = 0\n  let top = 0\n  let right = bounds.width\n  let bottom = bounds.height\n\n  if (slop.horizontal !== undefined) {\n    left -= slop.horizontal\n    right += slop.horizontal\n  }\n  if (slop.vertical !== undefined) {\n    top -= slop.vertical\n    bottom += slop.vertical\n  }\n  if (slop.left !== undefined) {\n    left = -slop.left\n  }\n  if (slop.right !== undefined) {\n    right = bounds.width + slop.right\n  }\n  if (slop.top !== undefined) {\n    top = -slop.top\n  }\n  if (slop.bottom !== undefined) {\n    bottom = bounds.height + slop.bottom\n  }\n  if (slop.width !== undefined) {\n    if (slop.left !== undefined) {\n      right = left + slop.width\n    } else if (slop.right !== undefined) {\n      left = right - slop.width\n    }\n  }\n  if (slop.height !== undefined) {\n    if (slop.top !== undefined) {\n      bottom = top + slop.height\n    } else if (slop.bottom !== undefined) {\n      top = bottom - slop.height\n    }\n  }\n\n  return {\n    x: bounds.x + left,\n    y: bounds.y + top,\n    width: right - left,\n    height: bottom - top,\n  }\n}\n\nconst contains = (rect: Rect, x: number, y: number): boolean =>\n  x >= rect.x &&\n  x <= rect.x + rect.width &&\n  y >= rect.y &&\n  y <= rect.y + rect.height\n\n/**\n * One frame from whichever GTK controller feeds a non-pointer kind, in the\n * terms the recognizer reads.\n *\n * ONE sample type for three sources rather than three, because what the\n * machine needs from all of them is the same short list and only two fields\n * differ per kind. `scale` and `rotation` are CUMULATIVE since GTK recognized\n * the gesture, which is what `gtk_gesture_zoom_get_scale_delta` (\"the zooming\n * difference since the gesture was recognized, hence the starting point is\n * considered 1:1\") and `gtk_gesture_rotate_get_angle_delta` already are — the\n * same shape as upstream's own accumulators, so nothing is re-derived on the\n * way in.\n */\nexport type ControllerSample = {\n  /**\n   * Where the gesture is, in the gesture VIEW's own coordinates.\n   *\n   * A pinch's bounding-box centre, a hover's pointer, a stylus tip: three\n   * names for the position the payload's `x`/`y`, `focalX`/`focalY` and\n   * `anchorX`/`anchorY` are all filled from, which is why they are one pair\n   * of fields and not three.\n   */\n  x: number\n  y: number\n  /** `Pinch`: 1 at the start of the gesture, above 1 for a spread. */\n  scale?: number\n  /** `Rotation`: 0 at the start; radians, positive clockwise. */\n  rotation?: number\n  /** `ForceTouch`: pressure normalised to `[0, 1]`. */\n  force?: number\n  /** Pointers GTK reported. A touchpad pinch is always two; a hover is one. */\n  pointers: number\n}\n\n/**\n * The non-pointer entry surface, for the kinds GTK feeds rather than the\n * pointer stream. Null on every pointer kind — see `RecognizerDecider.source`.\n */\nexport type ControllerChannel = {\n  begin: (sample: ControllerSample) => void\n  update: (sample: ControllerSample) => void\n  end: () => void\n  cancel: () => void\n}\n\nexport type Recognizer = {\n  /** The responder props to put on the gesture's view. Empty for a controller kind. */\n  handlers: Record<string, (event: GestureResponderEvent) => boolean | void>\n  /**\n   * Where `GtkGestureZoom`/`GtkGestureRotate`/`GtkEventControllerMotion`/\n   * `GtkGestureStylus` deliver, or null for a pointer kind.\n   */\n  controller: ControllerChannel | null\n  /** This gesture's seat in the arbitration loop. */\n  participant: Participant\n  /** Cancels any pending timer and leaves the loop; called on unmount. */\n  dispose: () => void\n}\n\n/**\n * Builds the machine. `readConfig` is called on every event rather than\n * captured, so a re-render that hands the detector a fresh gesture object —\n * which is what both spellings produce, every render — takes effect without\n * swapping the handler set mid-drag.\n */\nexport const createRecognizer = (\n  handlerTag: number,\n  decider: RecognizerDecider,\n  readConfig: () => RecognizerConfig,\n  env: RecognizerEnvironment,\n): Recognizer => {\n  let runtime = newRuntime()\n\n  const isEnabled = (): boolean => readConfig().enabled !== false\n\n  /**\n   * What kind of device this gesture's events come from.\n   *\n   * `MOUSE` for everything except `ForceTouch`, and that is not a default with\n   * a hole in it: this platform has one pointer and no touch injection, so\n   * every other kind really is a mouse. A pressure reading can only have come\n   * from a tablet tool, so the one kind that reads pressure reports `STYLUS`.\n   */\n  const pointerType =\n    decider.source === \"stylus\" ? POINTER_TYPE.STYLUS : POINTER_TYPE.MOUSE\n\n  const setState = (next: GestureStateValue): void => {\n    runtime.oldState = runtime.state\n    runtime.state = next\n  }\n\n  const viewOf = (): RecognizerView => ({\n    translationX: runtime.lastX - runtime.originX,\n    translationY: runtime.lastY - runtime.originY,\n    distanceFromPress: Math.hypot(\n      runtime.lastX - runtime.pressX,\n      runtime.lastY - runtime.pressY,\n    ),\n    velocityX: runtime.velocityX,\n    velocityY: runtime.velocityY,\n    timerElapsed: runtime.timerElapsed,\n    pointerCount: runtime.pointerCount,\n    maxPointerCount: runtime.maxPointerCount,\n    taps: runtime.taps,\n    scale: runtime.scale,\n    rotation: runtime.rotation,\n    force: runtime.force,\n  })\n\n  /**\n   * One payload, from a point rather than from an event.\n   *\n   * A timer has no event to build one from and every one of the three kinds\n   * has a timer that can end the gesture — `Tap`'s `maxDuration` and\n   * `maxDelay` both finalize with no pointer in flight. Fabricating a\n   * `GestureResponderEvent` to feed an event-shaped builder would have put an\n   * invented event into the responder system's own vocabulary; taking the\n   * three numbers the payload actually needs does not.\n   */\n  const payloadAt = (\n    pageX: number,\n    pageY: number,\n    pointerCount: number,\n    fallback?: { locationX: number; locationY: number },\n  ): GestureEventPayload => {\n    const bounds = env.boundsInWindow()\n    const translationX = pageX - runtime.originX\n    const translationY = pageY - runtime.originY\n    return {\n      handlerTag,\n      numberOfPointers: pointerCount,\n      pointerType,\n      state: runtime.state,\n      oldState: runtime.oldState,\n      // RNGH's `x`/`y` are relative to the GESTURE's view. The responder\n      // event's own `locationX` is relative to whichever widget carried the\n      // event, which is the deepest one with a controller and not always this\n      // one — so it is recomputed rather than passed through.\n      x: bounds ? pageX - bounds.x : (fallback?.locationX ?? pageX),\n      y: bounds ? pageY - bounds.y : (fallback?.locationY ?? pageY),\n      absoluteX: pageX,\n      absoluteY: pageY,\n      translationX,\n      translationY,\n      velocityX: runtime.velocityX,\n      velocityY: runtime.velocityY,\n      // On the first update the change IS the translation, which is\n      // upstream's rule rather than an approximation of it.\n      changeX: runtime.hasEmittedUpdate\n        ? translationX - runtime.changeFromX\n        : translationX,\n      changeY: runtime.hasEmittedUpdate\n        ? translationY - runtime.changeFromY\n        : translationY,\n      duration: Date.now() - runtime.pressTime,\n      scale: runtime.scale,\n      // A RATIO, not a difference — scale composes by multiplication, and\n      // upstream's `changeEventCalculator` for `Pinch` divides where the one\n      // for `Rotation` subtracts. On the first update it is the scale itself,\n      // which is upstream's rule for both and the same rule `changeX` follows.\n      scaleChange: runtime.hasEmittedUpdate\n        ? runtime.scale / runtime.changeFromScale\n        : runtime.scale,\n      // The focal point IS the position for these two kinds: the touchpad\n      // channel writes the gesture's bounding-box centre into the same\n      // last-position fields the pointer kinds write a touch into, so `x`/`y`\n      // and `focalX`/`focalY` are the same number arrived at the same way.\n      focalX: bounds ? pageX - bounds.x : (fallback?.locationX ?? pageX),\n      focalY: bounds ? pageY - bounds.y : (fallback?.locationY ?? pageY),\n      rotation: runtime.rotation,\n      rotationChange: runtime.hasEmittedUpdate\n        ? runtime.rotation - runtime.changeFromRotation\n        : runtime.rotation,\n      anchorX: bounds ? pageX - bounds.x : (fallback?.locationX ?? pageX),\n      anchorY: bounds ? pageY - bounds.y : (fallback?.locationY ?? pageY),\n      force: runtime.force,\n      // A DIFFERENCE, like `rotationChange` and unlike `scaleChange`, because\n      // upstream's `changeEventCalculator` for `ForceTouch` subtracts. On the\n      // first update it is the force itself, which is upstream's rule there\n      // and the same rule `changeX` follows.\n      forceChange: runtime.hasEmittedUpdate\n        ? runtime.force - runtime.changeFromForce\n        : runtime.force,\n      velocity:\n        decider.kind === \"rotation\"\n          ? runtime.rotationVelocity\n          : runtime.scaleVelocity,\n    }\n  }\n\n  const payloadOf = (event: GestureResponderEvent): GestureEventPayload => {\n    const { pageX, pageY, locationX, locationY } = event.nativeEvent\n    return payloadAt(pageX, pageY, event.nativeEvent.touches.length, {\n      locationX,\n      locationY,\n    })\n  }\n\n  /** The payload for a decision a timer made, from the last known position. */\n  const payloadNow = (): GestureEventPayload =>\n    payloadAt(runtime.lastX, runtime.lastY, runtime.pointerCount)\n\n  const touchEventOf = (\n    event: GestureResponderEvent,\n    eventType: TouchEventTypeValue,\n  ): GestureTouchEvent => {\n    const bounds = env.boundsInWindow()\n    const toData = (touch: {\n      identifier: number\n      pageX: number\n      pageY: number\n    }) => ({\n      id: touch.identifier,\n      x: bounds ? touch.pageX - bounds.x : touch.pageX,\n      y: bounds ? touch.pageY - bounds.y : touch.pageY,\n      absoluteX: touch.pageX,\n      absoluteY: touch.pageY,\n    })\n    return {\n      handlerTag,\n      numberOfTouches: event.nativeEvent.touches.length,\n      eventType,\n      allTouches: event.nativeEvent.touches.map(toData),\n      changedTouches: event.nativeEvent.changedTouches.map(toData),\n      state: runtime.state,\n      pointerType,\n    }\n  }\n\n  const clearActivationTimer = (): void => {\n    if (runtime.activationTimer !== null) {\n      clearTimeout(runtime.activationTimer)\n      runtime.activationTimer = null\n    }\n  }\n\n  const clearDelayTimer = (): void => {\n    if (runtime.delayTimer !== null) {\n      clearTimeout(runtime.delayTimer)\n      runtime.delayTimer = null\n    }\n  }\n\n  const track = (event: GestureResponderEvent): void => {\n    const { pageX, pageY, timestamp } = event.nativeEvent\n    const elapsed = timestamp - runtime.lastTime\n    if (elapsed > 0) {\n      runtime.velocityX = ((pageX - runtime.lastX) / elapsed) * 1000\n      runtime.velocityY = ((pageY - runtime.lastY) / elapsed) * 1000\n    }\n    runtime.lastX = pageX\n    runtime.lastY = pageY\n    runtime.lastTime = timestamp\n    countPointers(event)\n  }\n\n  const countPointers = (event: GestureResponderEvent): void => {\n    runtime.pointerCount = event.nativeEvent.touches.length\n    runtime.maxPointerCount = Math.max(\n      runtime.maxPointerCount,\n      runtime.pointerCount,\n    )\n  }\n\n  /**\n   * Every exit from a live gesture goes through here exactly once, and this is\n   * where the tap sequence dies: `newRuntime()` drops `taps` along with\n   * everything else, so a finalized multi-tap starts counting from zero.\n   */\n  const finalize = (\n    payloadFor: () => GestureEventPayload,\n    success: boolean,\n  ): void => {\n    if (runtime.state === GESTURE_STATE.UNDETERMINED) {\n      // Already over. The responder system dispatches `onResponderRelease` to\n      // whoever holds the lock at the end of the interaction, and a gesture\n      // can have cancelled itself while still holding it — a `LongPress` that\n      // wandered past `maxDistance`, or one the orchestrator cancelled. One\n      // exit per gesture, and this is where the second one stops.\n      return\n    }\n    const config = readConfig()\n    clearActivationTimer()\n    clearDelayTimer()\n    // Read the flag, not the state: a cancellation sets the state to\n    // CANCELLED on its way in, and an ACTIVE gesture that gets cancelled must\n    // still be told it deactivated.\n    const wasActive = runtime.hasActivated\n    if (success) {\n      setState(GESTURE_STATE.END)\n    }\n    // Built AFTER the transition, so `event.state` is the state the gesture\n    // ended in — which is what a consumer comparing it against `State` reads.\n    const payload = payloadFor()\n    // The deactivation callback is the ACTIVE gesture's ending. A gesture\n    // that never activated gets `onFinalize` and nothing else, which is what\n    // lets a consumer distinguish a drag that finished from one that never\n    // happened — `react-native-reanimated-dnd` relies on exactly that.\n    if (wasActive) {\n      config.onDeactivate?.(payload, success)\n    }\n    config.onFinalize?.(payload, success)\n    // Told AFTER the callbacks and BEFORE the reset. After, so a gesture this\n    // failure releases from `awaiting` starts where the previous one left off\n    // rather than in the middle of it; before, so the loop is handed the state\n    // the gesture actually ended in — END releases nobody and cancels the\n    // waiters, FAILED and CANCELLED release them.\n    env.orchestrator.finished(participant, runtime.state)\n    runtime = newRuntime()\n  }\n\n  const finalizeAt = (event: GestureResponderEvent, success: boolean): void => {\n    finalize(() => payloadOf(event), success)\n  }\n\n  const fail = (event: GestureResponderEvent): void => {\n    clearActivationTimer()\n    setState(GESTURE_STATE.FAILED)\n    finalize(() => payloadOf(event), false)\n  }\n\n  /** A timer decided this, so there is no event and the position is the last one. */\n  const failNow = (): void => {\n    clearActivationTimer()\n    setState(GESTURE_STATE.FAILED)\n    finalize(payloadNow, false)\n  }\n\n  /** Whether this kind takes the interaction when it activates. */\n  const claimsResponder = decider.claimsResponder !== false\n\n  /**\n   * Everything becoming ACTIVE means, from a position rather than an event.\n   *\n   * Three ways in now, and the third is the whole of slice 3: `onResponderGrant`\n   * for a recognizer that took the lock, `authorize()` for one that never will\n   * (`claimsResponder: false`), and `authorize()` again for one that WOULD have\n   * but was told the interaction is already held by a gesture it is\n   * simultaneous with. Everything after the transition is identical, because\n   * being ACTIVE is a fact about the gesture and not about the lock.\n   */\n  const enterActive = (pageX: number, pageY: number): void => {\n    setState(GESTURE_STATE.ACTIVE)\n    runtime.authorized = false\n    clearActivationTimer()\n    clearDelayTimer()\n    // Translation is measured from where the gesture BECAME ACTIVE, not\n    // from the press: a pan with `activeOffsetY([-10, 10])` that reported\n    // 10px of travel the moment it started would jump the content by the\n    // threshold on every drag. With `activateAfterLongPress` the pointer\n    // has not moved when the timer grants, so the two origins coincide —\n    // which is only true because the grant no longer waits for a move.\n    runtime.originX = pageX\n    runtime.originY = pageY\n    runtime.lastX = pageX\n    runtime.lastY = pageY\n    runtime.changeFromX = 0\n    runtime.changeFromY = 0\n    runtime.hasEmittedUpdate = false\n    runtime.hasActivated = true\n  }\n\n  /**\n   * `Fling`'s ending, which is the same instant as its activation.\n   *\n   * Called at the tail of every path into ACTIVE, so the one-shot kind behaves\n   * identically however it got there — a grant, an authorization without one,\n   * or a controller channel. Upstream reaches this by overriding `activate()`\n   * to call `end()`; a flag on the decider is the same statement without a\n   * subclass to put it on.\n   */\n  const endIfOneShot = (): void => {\n    if (decider.endsOnActivate === true) {\n      finalize(payloadNow, true)\n    }\n  }\n\n  /** Becoming ACTIVE without a grant to carry the position or the payload. */\n  const activateHere = (): void => {\n    enterActive(runtime.lastX, runtime.lastY)\n    const payload = payloadNow()\n    // Mutual exclusion is enforced here rather than at the moment permission\n    // was given, because permission is not always the same instant: a gesture\n    // that has to take the responder becomes ACTIVE only if the negotiation\n    // grants it, and an ancestor can still win.\n    env.orchestrator.activated(participant)\n    readConfig().onActivate?.(payload)\n    endIfOneShot()\n  }\n\n  /**\n   * The orchestrator's answer, and the only place the two locks touch.\n   *\n   * `needsResponder` false means another gesture already holds the interaction\n   * and this one was cleared to run alongside it. It does NOT ask for the\n   * responder: the lock is single-holder by design, GTK has already been told\n   * everything it can be told, and winning the lock would take the interaction\n   * away from the gesture this one was written to accompany.\n   *\n   * A recognizer that never claims takes the same path for its own reason —\n   * it is not asking for the interaction, it is reporting that the widget\n   * underneath it has taken one.\n   */\n  const authorize = (needsResponder: boolean): void => {\n    if (runtime.state !== GESTURE_STATE.BEGAN) {\n      return\n    }\n    runtime.authorized = true\n    if (!claimsResponder || !needsResponder) {\n      activateHere()\n      return\n    }\n    // The out-of-event channel, asked from inside a touch event as well as\n    // from a timer, and that uniformity is not laziness. Slice 1 could leave\n    // an in-event activation to the negotiation the responder system runs\n    // after the touch props, because there was only ever one gesture asking.\n    // With two, both would defer into the same negotiation, exactly one would\n    // win it, and the loser would sit authorized and never activate — so\n    // `Simultaneous` would silently be a race. Asking here settles the lock\n    // before the second gesture is even consulted, which is what lets it be\n    // told the interaction is already taken.\n    //\n    // It is the same negotiation either way: `requestResponder` reuses\n    // `negotiateAndTransfer` unchanged, so capture still beats bubble and an\n    // ancestor can still win.\n    env.requestResponder()\n  }\n\n  /**\n   * The one place a recognizer asks to become active, and therefore the seam\n   * the orchestrator sits in.\n   *\n   * Every path that used to take the responder now goes through here first:\n   * the gesture's own criteria being met is a request, not a decision. What\n   * comes back is `authorize()` (with or without the lock), a parking in\n   * `awaiting` that leaves the gesture BEGAN holding nothing, or a\n   * cancellation. `Native` goes through it too — a gesture that never takes\n   * the lock still takes part in arbitration, and it is the one kind that can\n   * cancel an already-active gesture.\n   */\n  const decide = (): void => {\n    if (runtime.authorized || runtime.state !== GESTURE_STATE.BEGAN) {\n      return\n    }\n    env.orchestrator.tryActivate(participant)\n  }\n\n  /** Cancelled by the loop: another gesture won, or the one it waited for ended. */\n  const cancelFromOrchestrator = (): void => {\n    if (\n      runtime.state !== GESTURE_STATE.BEGAN &&\n      runtime.state !== GESTURE_STATE.ACTIVE\n    ) {\n      return\n    }\n    setState(GESTURE_STATE.CANCELLED)\n    finalize(payloadNow, false)\n  }\n\n  const participant: Participant = {\n    tag: handlerTag,\n    kind: decider.kind,\n    authorize,\n    holdsResponder: () => runtime.hasResponder,\n    cancel: cancelFromOrchestrator,\n  }\n\n  /**\n   * The state, read through a call.\n   *\n   * Not decoration: `decide()` can change the state before it returns — the\n   * orchestrator may activate the gesture, or cancel it, synchronously — and a\n   * narrowed `runtime.state` read straight afterwards is a fact the compiler\n   * believes and the runtime does not.\n   */\n  const stateNow = (): GestureStateValue => runtime.state\n\n  /**\n   * The four transitions an app may drive by hand — upstream's\n   * `GestureStateManager`, and the whole of what `Gesture.Manual()` is.\n   *\n   * These used to be two real transitions and two deferrals: `fail()` and\n   * `end()` both set a flag that the next `onTouchMove` noticed, which was\n   * enough while the only caller was a `Pan` narrowing its own criteria, and\n   * is not enough for a gesture that has NO criteria. `Manual` is driven\n   * entirely from here, so each of the four has to mean what upstream's means,\n   * at the moment it is called:\n   *\n   *   begin     UNDETERMINED -> BEGAN\n   *   activate  BEGAN -> ACTIVE, through the orchestrator like every other\n   *             activation — a manual gesture takes part in arbitration\n   *             rather than bypassing it, which is the point of having it\n   *   end       BEGAN or ACTIVE -> END, successfully\n   *   fail      BEGAN or ACTIVE -> FAILED\n   *\n   * `activate()` is FORCED past `manualActivation`, exactly as upstream's web\n   * state manager calls `handler.activate(true)`: that flag exists to stop the\n   * gesture's own predicates activating it, and this is not them.\n   */\n  const stateManager: GestureStateManagerApi = {\n    begin: () => {\n      if (runtime.state === GESTURE_STATE.UNDETERMINED) {\n        setState(GESTURE_STATE.BEGAN)\n        readConfig().onBegin?.(payloadNow())\n      }\n    },\n    activate: () => {\n      // Upstream forces the BEGAN step first when asked to activate a gesture\n      // that never began, \"to preserve the correct state transition flow\" —\n      // and here it also matters that the orchestrator has been told about the\n      // gesture, which `record()` on the press is what does.\n      if (runtime.state === GESTURE_STATE.UNDETERMINED) {\n        setState(GESTURE_STATE.BEGAN)\n        env.orchestrator.record(participant)\n        readConfig().onBegin?.(payloadNow())\n      }\n      if (runtime.state === GESTURE_STATE.BEGAN) {\n        decide()\n      }\n    },\n    fail: () => {\n      if (\n        runtime.state === GESTURE_STATE.BEGAN ||\n        runtime.state === GESTURE_STATE.ACTIVE\n      ) {\n        // Kept as well as acted on: a gesture failed from inside\n        // `onTouchesDown` has not reached the move that would have consulted\n        // its predicates, and the flag is what stops a later move reviving it.\n        runtime.forcedFailure = true\n        failNow()\n      }\n    },\n    end: () => {\n      if (\n        runtime.state === GESTURE_STATE.BEGAN ||\n        runtime.state === GESTURE_STATE.ACTIVE\n      ) {\n        runtime.forcedFailure = true\n        finalize(payloadNow, true)\n      }\n    },\n  }\n\n  const outsideBounds = (event: GestureResponderEvent): boolean => {\n    const bounds = env.boundsInWindow()\n    if (bounds === null) {\n      // Before the first layout there is no truth to test against, and\n      // refusing every press would be worse than accepting them.\n      return false\n    }\n    const { pageX, pageY } = event.nativeEvent\n    return !contains(hitSlopRect(bounds, readConfig().hitSlop), pageX, pageY)\n  }\n\n  const pointerCountAllowed = (event: GestureResponderEvent): boolean => {\n    const config = readConfig()\n    const count = event.nativeEvent.touches.length\n    return (\n      count >= (config.minPointers ?? 1) && count <= (config.maxPointers ?? 10)\n    )\n  }\n\n  /**\n   * One ACTIVE gesture's reaction to the pointer moving, from whichever\n   * channel reached it: `onResponderMove` for the lock's holder,\n   * `onTouchMove` for a recognizer that never takes it.\n   *\n   * Returns nothing; the gesture may have finalized itself on the way out.\n   */\n  const advance = (event: GestureResponderEvent): void => {\n    track(event)\n    const config = readConfig()\n    if (\n      (config.shouldCancelWhenOutside === true && outsideBounds(event)) ||\n      // `LongPress` is the one kind that can be cancelled by movement it has\n      // already accepted: `maxDistance` keeps applying once the press has\n      // matured, and travelling past it while ACTIVE is a cancellation\n      // rather than a failure.\n      decider.shouldCancelWhileActive?.(viewOf(), config) === true\n    ) {\n      setState(GESTURE_STATE.CANCELLED)\n      finalizeAt(event, false)\n      return\n    }\n    const payload = payloadOf(event)\n    // The event that GRANTED the responder reaches here too — the system\n    // dispatches the move to whoever holds the lock after the handoff, in\n    // the same event. Emitting it would be an update of zero travel that\n    // `onActivate` has just reported the position of, and it would make\n    // upstream's rule that the FIRST change equals the translation vacuous:\n    // that first delta would always be zero. So the activation event is not\n    // an update, and the first real move is.\n    if (\n      !runtime.hasEmittedUpdate &&\n      payload.translationX === 0 &&\n      payload.translationY === 0\n    ) {\n      return\n    }\n    config.onUpdate?.(payload)\n    config.onChange?.(payload)\n    runtime.changeFromX = payload.translationX\n    runtime.changeFromY = payload.translationY\n    runtime.hasEmittedUpdate = true\n  }\n\n  const handlers = {\n    // Always false. A pan that takes the interaction on press cannot honour\n    // an `activeOffset`, and letting a sibling or an ancestor win instead is\n    // the behaviour every offset knob exists to produce.\n    onStartShouldSetResponder: () => false,\n\n    onTouchStart: (event: GestureResponderEvent) => {\n      const config = readConfig()\n      if (!isEnabled() || outsideBounds(event)) {\n        return\n      }\n      // A tap sequence in progress carries its count across the press. The\n      // delay timer's existence IS the sequence — while it is armed the\n      // gesture is between taps, still BEGAN, and this press is the next one\n      // rather than a fresh gesture.\n      const continuing =\n        runtime.delayTimer !== null && runtime.state === GESTURE_STATE.BEGAN\n      const carriedTaps = continuing ? runtime.taps : 0\n      clearDelayTimer()\n      runtime = newRuntime()\n      runtime.taps = carriedTaps\n\n      const { pageX, pageY, timestamp } = event.nativeEvent\n      runtime.pressTime = Date.now()\n      runtime.originX = pageX\n      runtime.originY = pageY\n      runtime.pressX = pageX\n      runtime.pressY = pageY\n      runtime.lastX = pageX\n      runtime.lastY = pageY\n      runtime.lastTime = timestamp\n      countPointers(event)\n      setState(GESTURE_STATE.BEGAN)\n      // Recorded on the press, not on mount. That is the whole islands answer\n      // in one line: a gesture takes part in an interaction only when the\n      // interaction's pointer reaches it, so a relation naming a gesture in\n      // another `Root` — or one the pointer never went near — never has an\n      // occasion to apply and can never park anything for ever. Recording on\n      // mount would have made `requireExternalGestureToFail` across two\n      // islands a permanent deadlock. See docs/api.md.\n      env.orchestrator.record(participant)\n      // Upstream begins once per SEQUENCE, not once per tap: its `begin()` is\n      // reached only from the UNDETERMINED branch, so the second press of a\n      // double tap gets no second `onBegin`.\n      if (!continuing) {\n        config.onBegin?.(payloadOf(event))\n      }\n      config.onTouchesDown?.(\n        touchEventOf(event, TOUCH_EVENT_TYPE.TOUCHES_DOWN),\n        stateManager,\n      )\n\n      const timer = decider.timer?.(config) ?? null\n      if (timer !== null) {\n        runtime.activationTimer = setTimeout(() => {\n          runtime.activationTimer = null\n          if (runtime.state !== GESTURE_STATE.BEGAN) {\n            return\n          }\n          runtime.timerElapsed = true\n          if (timer.elapsed === \"fail\") {\n            // `Tap`'s `maxDuration`: the pointer is still down and the tap is\n            // already too slow. There is no event to fail with.\n            failNow()\n            return\n          }\n          if (readConfig().manualActivation === true) {\n            return\n          }\n          // Asked rather than assumed: the timer maturing is one criterion\n          // among the kind's own, and `LongPress` also wants the right number\n          // of pointers down before it will take the gesture.\n          if (!decider.shouldActivate(viewOf(), readConfig())) {\n            return\n          }\n          // THE OUT-OF-EVENT GRANT. Without it the gesture could not take the\n          // interaction until the pointer next moved — one frame late for a\n          // drag, and never for a press-and-hold that stays still. This is\n          // the single extension slice 1 makes to the responder model;\n          // docs/research/gestures.md records it with its reason.\n          decide()\n        }, timer.delay)\n      }\n\n      // A recognizer that never claims may activate on the press itself, and\n      // `Gesture.Native().shouldActivateOnStart(true)` is the shape that\n      // wants to: a native BUTTON takes the press at once rather than waiting\n      // to see whether the pointer travels.\n      //\n      // Deliberately not asked for the claiming kinds, and that is the same\n      // rule `onStartShouldSetResponder` states by always answering false — a\n      // gesture that grabbed the interaction on press cannot honour an\n      // `activeOffset`, and deciding late is what every offset knob is for.\n      // Nothing is being decided late here, because nothing is being taken.\n      if (\n        !claimsResponder &&\n        config.manualActivation !== true &&\n        decider.shouldActivate(viewOf(), config)\n      ) {\n        decide()\n      }\n    },\n\n    onTouchMove: (event: GestureResponderEvent) => {\n      if (runtime.state === GESTURE_STATE.ACTIVE) {\n        // A gesture that does not hold the lock has no `onResponderMove`\n        // coming, so this is where its updates live. One that does is driven\n        // from there instead, and emitting here as well would double every\n        // update it reports.\n        //\n        // Two kinds of gesture end up here and the flag covers both: one that\n        // never takes the lock (`claimsResponder: false`), and one that would\n        // have but is ACTIVE alongside a gesture it is `Simultaneous` with.\n        // Without the second, `Simultaneous` would be a state with no events\n        // attached to it.\n        if (!runtime.hasResponder) {\n          advance(event)\n        }\n        return\n      }\n      if (runtime.state !== GESTURE_STATE.BEGAN) {\n        // A finished gesture is not tracked at all.\n        return\n      }\n      track(event)\n      const config = readConfig()\n      config.onTouchesMove?.(\n        touchEventOf(event, TOUCH_EVENT_TYPE.TOUCHES_MOVE),\n        stateManager,\n      )\n      const view = viewOf()\n      // Failure is tested before activation, and the comparisons differ —\n      // failure is strict, activation is not — so a translation sitting\n      // exactly on a bound activates rather than fails. That asymmetry is\n      // upstream's and is reproduced rather than tidied.\n      if (\n        runtime.forcedFailure ||\n        !pointerCountAllowed(event) ||\n        // Upstream fails a BEGAN handler that leaves the view, not just an\n        // ACTIVE one — `onPointerLeave` splits exactly that way. It is the\n        // default for `Tap` and `LongPress`, which is why it surfaces here;\n        // `Pan` leaves the flag off unless an app sets it.\n        (config.shouldCancelWhenOutside === true && outsideBounds(event)) ||\n        decider.shouldFail(view, config)\n      ) {\n        fail(event)\n        return\n      }\n      if (config.manualActivation === true) {\n        return\n      }\n      if (decider.shouldActivate(view, config)) {\n        decide()\n      }\n    },\n\n    // The instant of decision. Everything above ran holding nothing.\n    onMoveShouldSetResponder: () => {\n      // `Native` never answers yes: winning here is what makes the platform\n      // claim the GTK sequence and suspend the scroller it is reporting on.\n      if (!claimsResponder) {\n        return false\n      }\n      if (runtime.state !== GESTURE_STATE.BEGAN || !isEnabled()) {\n        return false\n      }\n      // The orchestrator's answer and nothing else. Slice 1 asked the decider\n      // a second time from here, on the reasoning that a move arriving while\n      // another view held the responder had not reached the decision above —\n      // which was never true (system.ts dispatches the touch props BEFORE it\n      // negotiates, in both entry points) and is now actively wrong: a gesture\n      // parked behind `requireExternalGestureToFail` still meets its own\n      // criteria, and answering them here would let it take the lock it was\n      // told to wait for.\n      return runtime.authorized\n    },\n\n    onResponderGrant: (event: GestureResponderEvent) => {\n      // The host holds the responder whoever asked for it — the recognizer's\n      // props are merged into the child's, so a child with responder props of\n      // its own can be the reason this fired.\n      runtime.hasResponder = true\n      if (!runtime.authorized) {\n        // Not this gesture's grant. Becoming ACTIVE is the orchestrator's to\n        // authorize, and it has not.\n        return\n      }\n      enterActive(event.nativeEvent.pageX, event.nativeEvent.pageY)\n      const payload = payloadOf(event)\n      env.orchestrator.activated(participant)\n      readConfig().onActivate?.(payload)\n      endIfOneShot()\n    },\n\n    onResponderMove: (event: GestureResponderEvent) => {\n      if (runtime.state !== GESTURE_STATE.ACTIVE) {\n        return\n      }\n      advance(event)\n    },\n\n    onResponderRelease: (event: GestureResponderEvent) => {\n      runtime.hasResponder = false\n      finalizeAt(event, true)\n    },\n\n    onResponderTerminate: (event: GestureResponderEvent) => {\n      runtime.hasResponder = false\n      // The interaction went somewhere this registry cannot follow — an\n      // ancestor took the responder, the window lost focus, a scroller moved\n      // under it. Anything running alongside this gesture was riding on a lock\n      // that is gone, and there is no callback of its own coming to tell it.\n      env.orchestrator.interactionLost(participant)\n      if (runtime.state === GESTURE_STATE.UNDETERMINED) {\n        // Already over: this gesture cancelled itself while still holding the\n        // lock, and the system is telling the HOST the interaction ended.\n        return\n      }\n      setState(GESTURE_STATE.CANCELLED)\n      finalizeAt(event, false)\n    },\n\n    onTouchEnd: (event: GestureResponderEvent) => {\n      readConfig().onTouchesUp?.(\n        touchEventOf(event, TOUCH_EVENT_TYPE.TOUCHES_UP),\n        stateManager,\n      )\n      // The responder holder is finalized by `onResponderRelease`, which the\n      // system dispatches AFTER the touch props. A gesture that is ACTIVE\n      // without holding the lock — a `Native`, or a `Simultaneous` partner\n      // that lost the race for it — has no responder callback coming, and\n      // this is where its successful ending is.\n      if (runtime.state === GESTURE_STATE.ACTIVE) {\n        if (!runtime.hasResponder) {\n          finalizeAt(event, true)\n        }\n        return\n      }\n      if (runtime.state !== GESTURE_STATE.BEGAN) {\n        return\n      }\n      const config = readConfig()\n      runtime.taps += 1\n      const outcome = decider.onRelease?.(viewOf(), config) ?? { kind: \"fail\" }\n\n      if (outcome.kind === \"hold\") {\n        // `Manual`: the pointer lifting decides nothing, because nothing about\n        // this gesture is decided by the pointer. It stays BEGAN, holding no\n        // lock and running no timer, until the app says otherwise — and the\n        // `onTouchesUp` above has just given it the state manager to say it\n        // with. The next press resets it, as it resets any BEGAN gesture.\n        return\n      }\n\n      if (outcome.kind === \"await\") {\n        // Not over. The gesture stays BEGAN with its count intact, holding no\n        // lock, and the next press continues it — or this timer fails it.\n        clearActivationTimer()\n        runtime.delayTimer = setTimeout(() => {\n          runtime.delayTimer = null\n          if (runtime.state === GESTURE_STATE.BEGAN) {\n            failNow()\n          }\n        }, outcome.delay)\n        return\n      }\n\n      if (outcome.kind === \"fail\") {\n        // `fail()` rather than a bare `finalizeAt(..., false)`, because the\n        // payload has to carry the state the gesture ENDED in and this path\n        // was reporting BEGAN. Upstream's `fail()` moves to FAILED first, and\n        // a consumer comparing `event.state` against `State.FAILED` — which is\n        // exactly what two of the four target libraries do with `State` — was\n        // being told the gesture was still deciding. `Fling` made it visible\n        // because failing on the lift is its ordinary ending rather than an\n        // edge case, but `Tap` and `Pan` were reporting it too.\n        fail(event)\n        return\n      }\n\n      // `Tap` activating: this is the one kind whose activation criterion is\n      // the pointer coming back UP, so the grant is asked for here rather than\n      // from a move. The responder system dispatches the touch props before it\n      // clears the session, so the out-of-event channel still has an\n      // interaction to negotiate over — and the `onResponderRelease` that\n      // follows in the same event is what ends the gesture with success.\n      clearActivationTimer()\n      decide()\n      if (stateNow() === GESTURE_STATE.ACTIVE) {\n        if (!runtime.hasResponder) {\n          // It activated alongside a gesture that holds the lock, so no\n          // `onResponderRelease` is coming for it either.\n          finalizeAt(event, true)\n        }\n        return\n      }\n      // Nobody granted it — an ancestor holds the interaction, the gesture is\n      // not on its path, or the orchestrator parked it behind another. There\n      // is no release callback coming, and a discrete gesture whose pointer\n      // has lifted cannot be woken later: the interaction it would have taken\n      // is over.\n      finalizeAt(event, false)\n    },\n\n    onTouchCancel: (event: GestureResponderEvent) => {\n      readConfig().onTouchesCancel?.(\n        touchEventOf(event, TOUCH_EVENT_TYPE.TOUCHES_CANCEL),\n        stateManager,\n      )\n      // THIS is where a stolen sequence lands, and why the responder system\n      // learned to tell `->DENIED` from an ordinary `drag-end`\n      // (`responder/use-responder.ts`). A native ancestor claiming mid-drag\n      // used to arrive here as `onTouchEnd`, which for an ACTIVE `Native`\n      // gesture would have reported a clean, successful ending of a drag that\n      // was actually taken away.\n      //\n      // An ACTIVE gesture that DID hold the lock is cancelled by\n      // `onResponderTerminate`, which the system dispatches after these touch\n      // props — finalizing here too would end it twice.\n      if (\n        runtime.state === GESTURE_STATE.BEGAN ||\n        (!runtime.hasResponder && runtime.state === GESTURE_STATE.ACTIVE)\n      ) {\n        setState(GESTURE_STATE.CANCELLED)\n        finalizeAt(event, false)\n      }\n    },\n  }\n\n  /**\n   * The second entry surface: a GTK controller, for the kinds the pointer\n   * stream cannot carry.\n   *\n   * THREE sources arrive here and the machine cannot tell them apart, which is\n   * the point — `GtkGestureZoom`/`GtkGestureRotate` for `Pinch`/`Rotation`,\n   * `GtkEventControllerMotion` for `Hover`, `GtkGestureStylus` for\n   * `ForceTouch`. What they have in common is everything that matters: no\n   * button goes down, so there is no GTK sequence, no responder session and\n   * nothing to claim; and the numbers they carry are already in the shape the\n   * payload wants.\n   *\n   * Everything below the entry point is the machine above, unchanged. `begin`\n   * does what `onTouchStart` does (record with the orchestrator, BEGAN,\n   * `onBegin`), `update` does what `onTouchMove` and `advance` do between them\n   * (test the kind's predicate, `decide()`, emit), and `end` does what\n   * `onTouchEnd` does. `decide()` is the same call into the same\n   * `tryActivate`, and `finalize` is the same one exit.\n   *\n   * ONE DIFFERENCE FROM `Pan`, and it is upstream's: `scale`, `rotation` and\n   * `force` are NOT re-based when the gesture activates. Translation is,\n   * because a pan that reported its `activeOffset` as travel would jump the\n   * content by the threshold on every drag. Upstream's `scale` is not —\n   * `resetProgress()` resets it only while the handler is not yet ACTIVE, so\n   * the value that crossed the activation threshold is the value the first\n   * `onUpdate` reports. GTK measures from its own recognition point for the\n   * same reason, so the two origins already agree and nothing is re-derived.\n   */\n  const controller: ControllerChannel = {\n    begin: (sample: ControllerSample): void => {\n      if (!isEnabled() || runtime.state !== GESTURE_STATE.UNDETERMINED) {\n        return\n      }\n      const bounds = env.boundsInWindow()\n      const pageX = (bounds?.x ?? 0) + sample.x\n      const pageY = (bounds?.y ?? 0) + sample.y\n      if (\n        bounds !== null &&\n        !contains(hitSlopRect(bounds, readConfig().hitSlop), pageX, pageY)\n      ) {\n        return\n      }\n      runtime = newRuntime()\n      runtime.pressTime = Date.now()\n      runtime.lastSampleTime = runtime.pressTime\n      runtime.originX = pageX\n      runtime.originY = pageY\n      runtime.pressX = pageX\n      runtime.pressY = pageY\n      runtime.lastX = pageX\n      runtime.lastY = pageY\n      runtime.scale = sample.scale ?? 1\n      runtime.rotation = sample.rotation ?? 0\n      runtime.force = sample.force ?? 0\n      runtime.pointerCount = sample.pointers\n      runtime.maxPointerCount = sample.pointers\n      setState(GESTURE_STATE.BEGAN)\n      // On the gesture, not on mount — the same rule and the same line as\n      // `onTouchStart`, and the same islands answer follows from it.\n      env.orchestrator.record(participant)\n      readConfig().onBegin?.(payloadNow())\n      // `Hover` activates on the crossing itself: upstream's\n      // `onPointerMoveOver` calls `begin()` and `activate()` one after the\n      // other, because a pointer that is over the view IS the gesture and\n      // there is nothing further to wait for. Asked through the decider rather\n      // than flagged, so it is the same question `onTouchStart` asks of a\n      // `Native` that activates on the press.\n      if (\n        readConfig().manualActivation !== true &&\n        decider.shouldActivate(viewOf(), readConfig())\n      ) {\n        decide()\n      }\n    },\n\n    update: (sample: ControllerSample): void => {\n      if (\n        runtime.state !== GESTURE_STATE.BEGAN &&\n        runtime.state !== GESTURE_STATE.ACTIVE\n      ) {\n        return\n      }\n      const scale = sample.scale ?? 1\n      const rotation = sample.rotation ?? 0\n      const now = Date.now()\n      const elapsed = now - runtime.lastSampleTime\n      if (elapsed > 0) {\n        // Per SECOND, which upstream documents and neither of its web paths\n        // computes. See `GestureEventPayload.velocity`.\n        runtime.scaleVelocity = ((scale - runtime.scale) / elapsed) * 1000\n        runtime.rotationVelocity =\n          ((rotation - runtime.rotation) / elapsed) * 1000\n        runtime.lastSampleTime = now\n      }\n      runtime.scale = scale\n      runtime.rotation = rotation\n      runtime.force = sample.force ?? 0\n      runtime.pointerCount = sample.pointers\n      runtime.maxPointerCount = Math.max(\n        runtime.maxPointerCount,\n        sample.pointers,\n      )\n      const bounds = env.boundsInWindow()\n      runtime.lastX = (bounds?.x ?? 0) + sample.x\n      runtime.lastY = (bounds?.y ?? 0) + sample.y\n\n      const config = readConfig()\n      // A kind that can be cancelled by its own numbers while ACTIVE gets the\n      // same treatment `advance` gives `LongPress` — `ForceTouch` is the one\n      // that wants it, because `maxForce` keeps applying after activation.\n      if (\n        runtime.state === GESTURE_STATE.ACTIVE &&\n        decider.shouldCancelWhileActive?.(viewOf(), config) === true\n      ) {\n        setState(GESTURE_STATE.CANCELLED)\n        finalize(payloadNow, false)\n        return\n      }\n      if (runtime.state === GESTURE_STATE.BEGAN) {\n        if (decider.shouldFail(viewOf(), config)) {\n          failNow()\n          return\n        }\n        if (config.manualActivation === true) {\n          return\n        }\n        if (!decider.shouldActivate(viewOf(), config)) {\n          return\n        }\n        // The same request into the same loop every other kind makes. It can\n        // come back as an activation, as a parking behind\n        // `requireExternalGestureToFail`, or as a cancellation.\n        decide()\n        if (stateNow() !== GESTURE_STATE.ACTIVE) {\n          return\n        }\n        // `onActivate` has just reported this sample; emitting it again as an\n        // update would double it, exactly as `advance` refuses the event that\n        // granted the responder.\n        runtime.changeFromScale = runtime.scale\n        runtime.changeFromRotation = runtime.rotation\n        runtime.changeFromForce = runtime.force\n        return\n      }\n      const payload = payloadNow()\n      config.onUpdate?.(payload)\n      config.onChange?.(payload)\n      runtime.changeFromX = payload.translationX\n      runtime.changeFromY = payload.translationY\n      runtime.changeFromScale = runtime.scale\n      runtime.changeFromRotation = runtime.rotation\n      runtime.changeFromForce = runtime.force\n      runtime.hasEmittedUpdate = true\n    },\n\n    /** GTK's `end`: a success if it activated, a failure if it never did. */\n    end: (): void => {\n      if (runtime.state === GESTURE_STATE.ACTIVE) {\n        finalize(payloadNow, true)\n        return\n      }\n      if (runtime.state === GESTURE_STATE.BEGAN) {\n        setState(GESTURE_STATE.FAILED)\n        finalize(payloadNow, false)\n      }\n    },\n\n    /** GTK's `cancel`: the sequence was taken away. */\n    cancel: (): void => {\n      if (\n        runtime.state === GESTURE_STATE.BEGAN ||\n        runtime.state === GESTURE_STATE.ACTIVE\n      ) {\n        setState(GESTURE_STATE.CANCELLED)\n        finalize(payloadNow, false)\n      }\n    },\n  }\n\n  const drivenByController =\n    decider.source !== undefined && decider.source !== \"pointer\"\n\n  return {\n    // Exactly one surface is live. A controller kind that also answered the\n    // touch props would begin on a mouse press — `onBegin` on every click, on\n    // a gesture that cannot happen — and a pointer kind with a live controller\n    // channel would pan on a pinch.\n    handlers: drivenByController ? {} : handlers,\n    controller: drivenByController ? controller : null,\n    participant,\n    dispose: () => {\n      clearActivationTimer()\n      clearDelayTimer()\n      env.orchestrator.forget(participant)\n    },\n  }\n}\n"]}

package/dist/gesture-handler-compat/relations.d.ts

@@ -0,0 +1,43 @@
+import { type GestureRef, type GestureRelations } from "./types";
+/** Called by a mounted detector for each gesture it drives, on every render. */
+export declare const bindGestureTag: (spec: object, tag: number) => void;
+/** Called when a detector unmounts. Hygiene: a stale tag is never recorded. */
+export declare const unbindGestureTag: (spec: object) => void;
+/**
+ * Every handler tag one relation reference stands for.
+ *
+ * Three spellings, all upstream's: the gesture itself, a ref built with
+ * `withRef()` holding it, or a raw handler tag. A COMPOSED gesture stands for
+ * every gesture in it, which is what makes
+ * `requireExternalGestureToFail(Gesture.Simultaneous(a, b))` mean what it
+ * reads like.
+ */
+export declare const resolveGestureTags: (reference: GestureRef) => number[];
+export type RelationRegistry = {
+    /**
+     * Replaces every relation recorded for one gesture. Replaces rather than
+     * merges, because the config is rebuilt from scratch on every render and a
+     * merge would accumulate references to gestures nobody holds any more —
+     * upstream shipped exactly that leak (#3763).
+     */
+    configure: (tag: number, relations: Partial<GestureRelations>) => void;
+    drop: (tag: number) => void;
+    /** `tag` must wait for `otherTag` to fail before it may activate. */
+    shouldWaitForFailure: (tag: number, otherTag: number) => boolean;
+    /** `tag` and `otherTag` may both be ACTIVE at once. */
+    shouldRecognizeSimultaneously: (tag: number, otherTag: number) => boolean;
+    /** `otherTag` must wait for `tag` — the same relation, declared from the other end. */
+    blocks: (tag: number, otherTag: number) => boolean;
+    reset: () => void;
+};
+/**
+ * References are stored raw and resolved on every question, rather than
+ * resolved to tags once at configure time.
+ *
+ * That is deliberate and it is what makes cross-component relations work at
+ * all: React mounts children before parents and siblings in tree order, so a
+ * gesture routinely names one whose detector has not minted its tag yet.
+ * Resolving lazily means the answer is correct as soon as both ends are
+ * mounted, in whatever order that happened, with no second pass.
+ */
+export declare const createRelationRegistry: () => RelationRegistry;

package/dist/gesture-handler-compat/relations.js

@@ -0,0 +1,128 @@
+// The three relation maps, and the identity that makes them mean something.
+//
+// This is upstream's `InteractionManager` under a different name. The rename
+// is not cosmetic: RN's OWN `InteractionManager` ships on this platform too
+// (src/apis), and two unrelated things called the same thing inside one
+// package is a trap somebody eventually falls into. What upstream calls
+// `InteractionManager` is a relation registry and nothing else, so that is
+// what it is called here.
+//
+// IT NEVER TALKS TO GTK, and that is the whole point of the slice. The
+// responder lock is a single global interaction lock with one irrevocable
+// `CLAIMED` on the source; it cannot express `Simultaneous` and must not try,
+// because making it multi-holder would break `PanResponder` and every
+// RN-portable app on this platform. So there are two locks at two levels: the
+// responder lock decides that an interaction belongs to React Native, and
+// this registry — plus the loop in ./orchestrator — decides which gestures
+// are active inside it. Every relation resolves in JS before anything is
+// claimed. See docs/research/gesture-detector.md, "Can the responder lock
+// express this? No — and it should not try".
+//
+// There are exactly three relations and composition is sugar over them:
+//
+//   waitFor             this gesture must wait for those to fail
+//   simultaneousHandlers  these two may both be active
+//   blocksHandlers      those must wait for THIS one
+//
+// Nothing is vendored, adapted or transcribed from `src/web/`; what is
+// reproduced is the behaviour, which docs/research/gesture-detector.md
+// restated as a specification.
+import { isComposedGestureSpec, } from "./types";
+/**
+ * Which MOUNTED gesture a spec object stands for.
+ *
+ * A relation names another gesture by handing over its spec object — that is
+ * upstream's `GestureRef` and it is the only identity an app ever holds. The
+ * spec is rebuilt on every render by both spellings, so the object cannot BE
+ * the identity; what it can do is point at one. A mounted detector binds each
+ * of its specs to the handler tag it minted, and the binding is never
+ * removed on re-render, so a memoized gesture holding a reference to last
+ * render's spec object still resolves to the right live gesture.
+ *
+ * Weak on purpose: a spec object from a render nobody remembers must not keep
+ * anything alive.
+ */
+const tagOfSpec = new WeakMap();
+/** Called by a mounted detector for each gesture it drives, on every render. */
+export const bindGestureTag = (spec, tag) => {
+    tagOfSpec.set(spec, tag);
+};
+/** Called when a detector unmounts. Hygiene: a stale tag is never recorded. */
+export const unbindGestureTag = (spec) => {
+    tagOfSpec.delete(spec);
+};
+/**
+ * Every handler tag one relation reference stands for.
+ *
+ * Three spellings, all upstream's: the gesture itself, a ref built with
+ * `withRef()` holding it, or a raw handler tag. A COMPOSED gesture stands for
+ * every gesture in it, which is what makes
+ * `requireExternalGestureToFail(Gesture.Simultaneous(a, b))` mean what it
+ * reads like.
+ */
+export const resolveGestureTags = (reference) => {
+    if (typeof reference === "number") {
+        return [reference];
+    }
+    if (reference === null || typeof reference !== "object") {
+        return [];
+    }
+    if (isComposedGestureSpec(reference)) {
+        return reference.toGestureArray().flatMap(resolveGestureTags);
+    }
+    const direct = tagOfSpec.get(reference);
+    if (direct !== undefined) {
+        return [direct];
+    }
+    // `withRef(ref)` puts the gesture into an ordinary React ref, and upstream's
+    // relation methods accept that ref in place of the gesture.
+    const current = reference.current;
+    return current !== null && typeof current === "object"
+        ? resolveGestureTags(current)
+        : [];
+};
+const containsTag = (references, tag) => references !== undefined &&
+    references.some((reference) => resolveGestureTags(reference).includes(tag));
+/**
+ * References are stored raw and resolved on every question, rather than
+ * resolved to tags once at configure time.
+ *
+ * That is deliberate and it is what makes cross-component relations work at
+ * all: React mounts children before parents and siblings in tree order, so a
+ * gesture routinely names one whose detector has not minted its tag yet.
+ * Resolving lazily means the answer is correct as soon as both ends are
+ * mounted, in whatever order that happened, with no second pass.
+ */
+export const createRelationRegistry = () => {
+    const waitForRelations = new Map();
+    const simultaneousRelations = new Map();
+    const blocksHandlersRelations = new Map();
+    const set = (map, tag, references) => {
+        if (references === undefined || references.length === 0) {
+            map.delete(tag);
+            return;
+        }
+        map.set(tag, references);
+    };
+    return {
+        configure: (tag, relations) => {
+            set(waitForRelations, tag, relations.waitFor);
+            set(simultaneousRelations, tag, relations.simultaneousHandlers);
+            set(blocksHandlersRelations, tag, relations.blocksHandlers);
+        },
+        drop: (tag) => {
+            waitForRelations.delete(tag);
+            simultaneousRelations.delete(tag);
+            blocksHandlersRelations.delete(tag);
+        },
+        shouldWaitForFailure: (tag, otherTag) => containsTag(waitForRelations.get(tag), otherTag),
+        shouldRecognizeSimultaneously: (tag, otherTag) => containsTag(simultaneousRelations.get(tag), otherTag),
+        blocks: (tag, otherTag) => containsTag(blocksHandlersRelations.get(tag), otherTag),
+        reset: () => {
+            waitForRelations.clear();
+            simultaneousRelations.clear();
+            blocksHandlersRelations.clear();
+        },
+    };
+};
+//# sourceMappingURL=relations.js.map

package/dist/gesture-handler-compat/relations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/relations.ts"],"names":[],"mappings":"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","sourcesContent":["// The three relation maps, and the identity that makes them mean something.\n//\n// This is upstream's `InteractionManager` under a different name. The rename\n// is not cosmetic: RN's OWN `InteractionManager` ships on this platform too\n// (src/apis), and two unrelated things called the same thing inside one\n// package is a trap somebody eventually falls into. What upstream calls\n// `InteractionManager` is a relation registry and nothing else, so that is\n// what it is called here.\n//\n// IT NEVER TALKS TO GTK, and that is the whole point of the slice. The\n// responder lock is a single global interaction lock with one irrevocable\n// `CLAIMED` on the source; it cannot express `Simultaneous` and must not try,\n// because making it multi-holder would break `PanResponder` and every\n// RN-portable app on this platform. So there are two locks at two levels: the\n// responder lock decides that an interaction belongs to React Native, and\n// this registry — plus the loop in ./orchestrator — decides which gestures\n// are active inside it. Every relation resolves in JS before anything is\n// claimed. See docs/research/gesture-detector.md, \"Can the responder lock\n// express this? No — and it should not try\".\n//\n// There are exactly three relations and composition is sugar over them:\n//\n//   waitFor             this gesture must wait for those to fail\n//   simultaneousHandlers  these two may both be active\n//   blocksHandlers      those must wait for THIS one\n//\n// Nothing is vendored, adapted or transcribed from `src/web/`; what is\n// reproduced is the behaviour, which docs/research/gesture-detector.md\n// restated as a specification.\nimport {\n  isComposedGestureSpec,\n  type GestureRef,\n  type GestureRelations,\n} from \"./types\"\n\n/**\n * Which MOUNTED gesture a spec object stands for.\n *\n * A relation names another gesture by handing over its spec object — that is\n * upstream's `GestureRef` and it is the only identity an app ever holds. The\n * spec is rebuilt on every render by both spellings, so the object cannot BE\n * the identity; what it can do is point at one. A mounted detector binds each\n * of its specs to the handler tag it minted, and the binding is never\n * removed on re-render, so a memoized gesture holding a reference to last\n * render's spec object still resolves to the right live gesture.\n *\n * Weak on purpose: a spec object from a render nobody remembers must not keep\n * anything alive.\n */\nconst tagOfSpec = new WeakMap<object, number>()\n\n/** Called by a mounted detector for each gesture it drives, on every render. */\nexport const bindGestureTag = (spec: object, tag: number): void => {\n  tagOfSpec.set(spec, tag)\n}\n\n/** Called when a detector unmounts. Hygiene: a stale tag is never recorded. */\nexport const unbindGestureTag = (spec: object): void => {\n  tagOfSpec.delete(spec)\n}\n\n/**\n * Every handler tag one relation reference stands for.\n *\n * Three spellings, all upstream's: the gesture itself, a ref built with\n * `withRef()` holding it, or a raw handler tag. A COMPOSED gesture stands for\n * every gesture in it, which is what makes\n * `requireExternalGestureToFail(Gesture.Simultaneous(a, b))` mean what it\n * reads like.\n */\nexport const resolveGestureTags = (reference: GestureRef): number[] => {\n  if (typeof reference === \"number\") {\n    return [reference]\n  }\n  if (reference === null || typeof reference !== \"object\") {\n    return []\n  }\n  if (isComposedGestureSpec(reference)) {\n    return reference.toGestureArray().flatMap(resolveGestureTags)\n  }\n  const direct = tagOfSpec.get(reference)\n  if (direct !== undefined) {\n    return [direct]\n  }\n  // `withRef(ref)` puts the gesture into an ordinary React ref, and upstream's\n  // relation methods accept that ref in place of the gesture.\n  const current = (reference as { current?: unknown }).current\n  return current !== null && typeof current === \"object\"\n    ? resolveGestureTags(current as GestureRef)\n    : []\n}\n\nconst containsTag = (\n  references: readonly GestureRef[] | undefined,\n  tag: number,\n): boolean =>\n  references !== undefined &&\n  references.some((reference) => resolveGestureTags(reference).includes(tag))\n\nexport type RelationRegistry = {\n  /**\n   * Replaces every relation recorded for one gesture. Replaces rather than\n   * merges, because the config is rebuilt from scratch on every render and a\n   * merge would accumulate references to gestures nobody holds any more —\n   * upstream shipped exactly that leak (#3763).\n   */\n  configure: (tag: number, relations: Partial<GestureRelations>) => void\n  drop: (tag: number) => void\n  /** `tag` must wait for `otherTag` to fail before it may activate. */\n  shouldWaitForFailure: (tag: number, otherTag: number) => boolean\n  /** `tag` and `otherTag` may both be ACTIVE at once. */\n  shouldRecognizeSimultaneously: (tag: number, otherTag: number) => boolean\n  /** `otherTag` must wait for `tag` — the same relation, declared from the other end. */\n  blocks: (tag: number, otherTag: number) => boolean\n  reset: () => void\n}\n\n/**\n * References are stored raw and resolved on every question, rather than\n * resolved to tags once at configure time.\n *\n * That is deliberate and it is what makes cross-component relations work at\n * all: React mounts children before parents and siblings in tree order, so a\n * gesture routinely names one whose detector has not minted its tag yet.\n * Resolving lazily means the answer is correct as soon as both ends are\n * mounted, in whatever order that happened, with no second pass.\n */\nexport const createRelationRegistry = (): RelationRegistry => {\n  const waitForRelations = new Map<number, readonly GestureRef[]>()\n  const simultaneousRelations = new Map<number, readonly GestureRef[]>()\n  const blocksHandlersRelations = new Map<number, readonly GestureRef[]>()\n\n  const set = (\n    map: Map<number, readonly GestureRef[]>,\n    tag: number,\n    references: readonly GestureRef[] | undefined,\n  ): void => {\n    if (references === undefined || references.length === 0) {\n      map.delete(tag)\n      return\n    }\n    map.set(tag, references)\n  }\n\n  return {\n    configure: (tag, relations) => {\n      set(waitForRelations, tag, relations.waitFor)\n      set(simultaneousRelations, tag, relations.simultaneousHandlers)\n      set(blocksHandlersRelations, tag, relations.blocksHandlers)\n    },\n\n    drop: (tag) => {\n      waitForRelations.delete(tag)\n      simultaneousRelations.delete(tag)\n      blocksHandlersRelations.delete(tag)\n    },\n\n    shouldWaitForFailure: (tag, otherTag) =>\n      containsTag(waitForRelations.get(tag), otherTag),\n\n    shouldRecognizeSimultaneously: (tag, otherTag) =>\n      containsTag(simultaneousRelations.get(tag), otherTag),\n\n    blocks: (tag, otherTag) =>\n      containsTag(blocksHandlersRelations.get(tag), otherTag),\n\n    reset: () => {\n      waitForRelations.clear()\n      simultaneousRelations.clear()\n      blocksHandlersRelations.clear()\n    },\n  }\n}\n"]}

package/dist/gesture-handler-compat/tap.d.ts

@@ -0,0 +1,6 @@
+import type { RecognizerDecider } from "./recognizer";
+/** Upstream's `DEFAULT_MAX_DURATION_MS`. */
+export declare const DEFAULT_MAX_DURATION = 500;
+/** Upstream's `DEFAULT_MAX_DELAY_MS`. */
+export declare const DEFAULT_MAX_DELAY = 500;
+export declare const tapDecider: RecognizerDecider;

package/dist/gesture-handler-compat/tap.js

@@ -0,0 +1,29 @@
+/** Upstream's `DEFAULT_MAX_DURATION_MS`. */
+export const DEFAULT_MAX_DURATION = 500;
+/** Upstream's `DEFAULT_MAX_DELAY_MS`. */
+export const DEFAULT_MAX_DELAY = 500;
+const exceeds = (value, limit) => limit !== undefined && Math.abs(value) > limit;
+export const tapDecider = {
+    kind: "tap",
+    /** The deadline, re-armed on every press of the sequence. */
+    timer: (config) => ({
+        delay: config.maxDuration ?? DEFAULT_MAX_DURATION,
+        elapsed: "fail",
+    }),
+    shouldFail: (view, config) => exceeds(view.translationX, config.maxDeltaX) ||
+        exceeds(view.translationY, config.maxDeltaY) ||
+        exceeds(view.distanceFromPress, config.maxDistance),
+    // Never from movement: a tap that activated while the pointer was still
+    // down would be a press, and would take the interaction away from whatever
+    // pan is watching the same view.
+    shouldActivate: () => false,
+    onRelease: (view, config) => {
+        const wanted = config.numberOfTaps ?? 1;
+        if (view.taps >= wanted &&
+            view.maxPointerCount >= (config.minPointers ?? 1)) {
+            return { kind: "activate" };
+        }
+        return { kind: "await", delay: config.maxDelay ?? DEFAULT_MAX_DELAY };
+    },
+};
+//# sourceMappingURL=tap.js.map

package/dist/gesture-handler-compat/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/tap.ts"],"names":[],"mappings":"AAmCA,4CAA4C;AAC5C,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAA;AACvC,yCAAyC;AACzC,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;AAEpC,MAAM,OAAO,GAAG,CAAC,KAAa,EAAE,KAAyB,EAAW,EAAE,CACpE,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,CAAA;AAEhD,MAAM,CAAC,MAAM,UAAU,GAAsB;IAC3C,IAAI,EAAE,KAAK;IAEX,6DAA6D;IAC7D,KAAK,EAAE,CAAC,MAAwB,EAAmB,EAAE,CAAC,CAAC;QACrD,KAAK,EAAE,MAAM,CAAC,WAAW,IAAI,oBAAoB;QACjD,OAAO,EAAE,MAAM;KAChB,CAAC;IAEF,UAAU,EAAE,CAAC,IAAoB,EAAE,MAAwB,EAAW,EAAE,CACtE,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,SAAS,CAAC;QAC5C,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,SAAS,CAAC;QAC5C,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,WAAW,CAAC;IAErD,wEAAwE;IACxE,2EAA2E;IAC3E,iCAAiC;IACjC,cAAc,EAAE,GAAY,EAAE,CAAC,KAAK;IAEpC,SAAS,EAAE,CACT,IAAoB,EACpB,MAAwB,EACR,EAAE;QAClB,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,IAAI,CAAC,CAAA;QACvC,IACE,IAAI,CAAC,IAAI,IAAI,MAAM;YACnB,IAAI,CAAC,eAAe,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC,EACjD,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;QAC7B,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,QAAQ,IAAI,iBAAiB,EAAE,CAAA;IACvE,CAAC;CACF,CAAA","sourcesContent":["// Tap's predicates, over the same machine `Pan` runs on.\n//\n// A tap is the one kind whose activation criterion is the pointer coming back\n// UP, and the whole of it is three numbers and a counter:\n//\n//   - `maxDuration` is a deadline armed on every press. It fires while the\n//     pointer is still down, and firing kills the tap — a press held too long\n//     is not a tap, it is a press.\n//   - `maxDelay` is the gap between taps. On a release that has not completed\n//     the sequence the gesture stays BEGAN, holding nothing, and this timer is\n//     what eventually gives up.\n//   - `maxDistance` / `maxDeltaX` / `maxDeltaY` fail a press that travelled.\n//     This is the tap-vs-drag disambiguation and it is the reason a tap and a\n//     pan can share a view at all.\n//\n// Restated from `src/web/handlers/TapGestureHandler.ts` at 3.1.0, not\n// transcribed. Two of its details are worth naming because they look like\n// bugs and are not:\n//\n//   - there is **no default `maxDistance`**. Upstream initialises all three\n//     distance limits to `Number.MIN_SAFE_INTEGER` and treats that as \"unset\",\n//     so an unconfigured tap accepts any travel that stays inside the view and\n//     lifts in time. `shouldCancelWhenOutside` (which `Gesture.Tap()` turns on\n//     in its constructor) is what actually bounds it. Inventing a default here\n//     would refuse taps upstream accepts;\n//   - `minPointers` is checked against the MOST pointers the interaction ever\n//     had at once, not the count at release, which by then is zero.\nimport type {\n  RecognizerDecider,\n  RecognizerTimer,\n  RecognizerView,\n  ReleaseOutcome,\n} from \"./recognizer\"\nimport type { RecognizerConfig } from \"./types\"\n\n/** Upstream's `DEFAULT_MAX_DURATION_MS`. */\nexport const DEFAULT_MAX_DURATION = 500\n/** Upstream's `DEFAULT_MAX_DELAY_MS`. */\nexport const DEFAULT_MAX_DELAY = 500\n\nconst exceeds = (value: number, limit: number | undefined): boolean =>\n  limit !== undefined && Math.abs(value) > limit\n\nexport const tapDecider: RecognizerDecider = {\n  kind: \"tap\",\n\n  /** The deadline, re-armed on every press of the sequence. */\n  timer: (config: RecognizerConfig): RecognizerTimer => ({\n    delay: config.maxDuration ?? DEFAULT_MAX_DURATION,\n    elapsed: \"fail\",\n  }),\n\n  shouldFail: (view: RecognizerView, config: RecognizerConfig): boolean =>\n    exceeds(view.translationX, config.maxDeltaX) ||\n    exceeds(view.translationY, config.maxDeltaY) ||\n    exceeds(view.distanceFromPress, config.maxDistance),\n\n  // Never from movement: a tap that activated while the pointer was still\n  // down would be a press, and would take the interaction away from whatever\n  // pan is watching the same view.\n  shouldActivate: (): boolean => false,\n\n  onRelease: (\n    view: RecognizerView,\n    config: RecognizerConfig,\n  ): ReleaseOutcome => {\n    const wanted = config.numberOfTaps ?? 1\n    if (\n      view.taps >= wanted &&\n      view.maxPointerCount >= (config.minPointers ?? 1)\n    ) {\n      return { kind: \"activate\" }\n    }\n    return { kind: \"await\", delay: config.maxDelay ?? DEFAULT_MAX_DELAY }\n  },\n}\n"]}

package/dist/gesture-handler-compat/touchpad.d.ts

@@ -0,0 +1,41 @@
+import type { RecognizerDecider } from "./recognizer";
+import type { RecognizerConfig } from "./types";
+/**
+ * Upstream's `ROTATION_RECOGNITION_THRESHOLD`
+ * (`src/web/handlers/RotationGestureHandler.ts` at 3.1.0), reproduced exactly:
+ * five degrees of accumulated rotation activates the gesture.
+ */
+export declare const ROTATION_RECOGNITION_THRESHOLD: number;
+/**
+ * Five percent of scale change activates a pinch — and this number is OURS,
+ * which is the one place these two recognizers do not restate upstream.
+ *
+ * Upstream's gate is two stages of pixels: `ScaleGestureDetector` reports
+ * nothing until the span between the two touches has changed by more than
+ * `spanSlop` (`DEFAULT_TOUCH_SLOP * 2`, 30px), and `PinchGestureHandler` then
+ * activates after a further `DEFAULT_TOUCH_SLOP` (15px) from wherever that
+ * opened. Both are arithmetic over two touch POSITIONS, and a touchpad pinch
+ * has none: libinput hands the compositor a ratio and GDK hands GTK a ratio,
+ * so there is no span in pixels anywhere in this chain to measure 45 of.
+ *
+ * What makes a small threshold the right restatement rather than a weaker one
+ * is where upstream's slop sits in the pipeline. Upstream's is the FIRST
+ * decision that a pinch is happening at all — nothing below it filters. Here
+ * libinput has already made that decision: it will not emit
+ * `GESTURE_PINCH_BEGIN` until it has classified the two fingers' motion as a
+ * pinch rather than a two-finger scroll, which is a threshold of its own and a
+ * stricter one. Measured with the virtual touchpad, the first `scale-changed`
+ * after `begin` already reports about 1.09. So this gate is a second, smaller
+ * one, and setting it at upstream's effective magnitude would refuse pinches
+ * the platform has already accepted.
+ */
+export declare const PINCH_RECOGNITION_THRESHOLD = 0.05;
+export declare const pinchDecider: RecognizerDecider;
+export declare const rotationDecider: RecognizerDecider;
+/**
+ * Upstream sets `shouldCancelWhenOutside = false` from both handlers' `init`,
+ * against a base class that defaults it on for several other kinds. Applied
+ * from the builders' constructors here, which is where this module puts every
+ * other constructor-set default.
+ */
+export declare const TOUCHPAD_DEFAULTS: Partial<RecognizerConfig>;

package/dist/gesture-handler-compat/touchpad.js

@@ -0,0 +1,64 @@
+/**
+ * Upstream's `ROTATION_RECOGNITION_THRESHOLD`
+ * (`src/web/handlers/RotationGestureHandler.ts` at 3.1.0), reproduced exactly:
+ * five degrees of accumulated rotation activates the gesture.
+ */
+export const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
+/**
+ * Five percent of scale change activates a pinch — and this number is OURS,
+ * which is the one place these two recognizers do not restate upstream.
+ *
+ * Upstream's gate is two stages of pixels: `ScaleGestureDetector` reports
+ * nothing until the span between the two touches has changed by more than
+ * `spanSlop` (`DEFAULT_TOUCH_SLOP * 2`, 30px), and `PinchGestureHandler` then
+ * activates after a further `DEFAULT_TOUCH_SLOP` (15px) from wherever that
+ * opened. Both are arithmetic over two touch POSITIONS, and a touchpad pinch
+ * has none: libinput hands the compositor a ratio and GDK hands GTK a ratio,
+ * so there is no span in pixels anywhere in this chain to measure 45 of.
+ *
+ * What makes a small threshold the right restatement rather than a weaker one
+ * is where upstream's slop sits in the pipeline. Upstream's is the FIRST
+ * decision that a pinch is happening at all — nothing below it filters. Here
+ * libinput has already made that decision: it will not emit
+ * `GESTURE_PINCH_BEGIN` until it has classified the two fingers' motion as a
+ * pinch rather than a two-finger scroll, which is a threshold of its own and a
+ * stricter one. Measured with the virtual touchpad, the first `scale-changed`
+ * after `begin` already reports about 1.09. So this gate is a second, smaller
+ * one, and setting it at upstream's effective magnitude would refuse pinches
+ * the platform has already accepted.
+ */
+export const PINCH_RECOGNITION_THRESHOLD = 0.05;
+const magnitude = (view) => Math.abs(view.scale - 1);
+export const pinchDecider = {
+    kind: "pinch",
+    // See the file header: there is no press, so there is no interaction lock
+    // to take. Every update arrives through `Recognizer.touchpad` instead.
+    claimsResponder: false,
+    source: "touchpad",
+    /**
+     * Never from the gesture itself. Upstream's pinch has no failure predicate
+     * over movement at all, and it goes further: `PinchGestureHandler.init` sets
+     * `shouldCancelWhenOutside = false` explicitly, so a pinch whose focal point
+     * wanders off the view keeps running. It fails when GTK ends the gesture
+     * before it ever activated, which is the shared machine's own rule.
+     */
+    shouldFail: () => false,
+    shouldActivate: (view) => magnitude(view) >= PINCH_RECOGNITION_THRESHOLD,
+};
+export const rotationDecider = {
+    kind: "rotation",
+    claimsResponder: false,
+    source: "touchpad",
+    shouldFail: () => false,
+    shouldActivate: (view) => Math.abs(view.rotation) >= ROTATION_RECOGNITION_THRESHOLD,
+};
+/**
+ * Upstream sets `shouldCancelWhenOutside = false` from both handlers' `init`,
+ * against a base class that defaults it on for several other kinds. Applied
+ * from the builders' constructors here, which is where this module puts every
+ * other constructor-set default.
+ */
+export const TOUCHPAD_DEFAULTS = {
+    shouldCancelWhenOutside: false,
+};
+//# sourceMappingURL=touchpad.js.map

package/dist/gesture-handler-compat/touchpad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchpad.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/touchpad.ts"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAA;AAE/C,MAAM,SAAS,GAAG,CAAC,IAAoB,EAAU,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;AAE5E,MAAM,CAAC,MAAM,YAAY,GAAsB;IAC7C,IAAI,EAAE,OAAO;IACb,0EAA0E;IAC1E,uEAAuE;IACvE,eAAe,EAAE,KAAK;IACtB,MAAM,EAAE,UAAU;IAElB;;;;;;OAMG;IACH,UAAU,EAAE,GAAY,EAAE,CAAC,KAAK;IAEhC,cAAc,EAAE,CAAC,IAAoB,EAAW,EAAE,CAChD,SAAS,CAAC,IAAI,CAAC,IAAI,2BAA2B;CACjD,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAsB;IAChD,IAAI,EAAE,UAAU;IAChB,eAAe,EAAE,KAAK;IACtB,MAAM,EAAE,UAAU;IAElB,UAAU,EAAE,GAAY,EAAE,CAAC,KAAK;IAEhC,cAAc,EAAE,CAAC,IAAoB,EAAW,EAAE,CAChD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,8BAA8B;CAC5D,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA8B;IAC1D,uBAAuB,EAAE,KAAK;CAC/B,CAAA","sourcesContent":["// `Gesture.Pinch()` and `Gesture.Rotation()` — the two recognizers whose raw\n// numbers come from GTK rather than from the pointer stream.\n//\n// WHY THEY ARE DIFFERENT AT ALL, and it is one sentence: this platform has one\n// pointer. Upstream's `PinchGestureHandler` runs a `ScaleGestureDetector` over\n// two tracked pointers and needs two real touches; there are none here and no\n// protocol to synthesize one. What there IS instead is better —\n// `gtk_gesture_zoom_filter_event` lets `GDK_TOUCHPAD_PINCH` through when\n// `gdk_touchpad_event_get_n_fingers() == 2` and `_gtk_gesture_zoom_get_distance`\n// reads `gdk_touchpad_event_get_pinch_scale()` straight off the event rather\n// than computing it from two points. So a TOUCHPAD pinch drives\n// `GtkGestureZoom` with no touchscreen involved, which is a path RNGH's own\n// single-runtime implementation does not have.\n//\n// WHAT IS SHARED, which is everything that matters: the state machine, the\n// callbacks, the payload, `tryActivate`, the relation maps, `makeActive`'s\n// broadcast cancel and `finished`. ./recognizer runs one machine with two\n// entry surfaces — the touch/responder props for the pointer kinds, and\n// `Recognizer.controller` for the kinds a GTK controller feeds — and only the\n// entry surface differs. There is no second arbitration path and no second\n// registry. `Hover` and `ForceTouch` arrive on that same channel from\n// `GtkEventControllerMotion` and `GtkGestureStylus`, which is why it is named\n// for the controller rather than for the touchpad.\n//\n// THEY NEVER TAKE THE RESPONDER (`claimsResponder: false`), for a reason that\n// is structural rather than a policy: the responder lock is a lock over an\n// INTERACTION, and an interaction here starts with a press. A touchpad pinch\n// has no button down, so there is no session to take, nothing to transfer and\n// no GTK sequence to claim. `Native` reaches the same flag from the opposite\n// direction — it has a sequence and must not claim it — and both end up on the\n// touch-prop update pump, which is why one flag covers both.\nimport type { RecognizerDecider, RecognizerView } from \"./recognizer\"\nimport type { RecognizerConfig } from \"./types\"\n\n/**\n * Upstream's `ROTATION_RECOGNITION_THRESHOLD`\n * (`src/web/handlers/RotationGestureHandler.ts` at 3.1.0), reproduced exactly:\n * five degrees of accumulated rotation activates the gesture.\n */\nexport const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36\n\n/**\n * Five percent of scale change activates a pinch — and this number is OURS,\n * which is the one place these two recognizers do not restate upstream.\n *\n * Upstream's gate is two stages of pixels: `ScaleGestureDetector` reports\n * nothing until the span between the two touches has changed by more than\n * `spanSlop` (`DEFAULT_TOUCH_SLOP * 2`, 30px), and `PinchGestureHandler` then\n * activates after a further `DEFAULT_TOUCH_SLOP` (15px) from wherever that\n * opened. Both are arithmetic over two touch POSITIONS, and a touchpad pinch\n * has none: libinput hands the compositor a ratio and GDK hands GTK a ratio,\n * so there is no span in pixels anywhere in this chain to measure 45 of.\n *\n * What makes a small threshold the right restatement rather than a weaker one\n * is where upstream's slop sits in the pipeline. Upstream's is the FIRST\n * decision that a pinch is happening at all — nothing below it filters. Here\n * libinput has already made that decision: it will not emit\n * `GESTURE_PINCH_BEGIN` until it has classified the two fingers' motion as a\n * pinch rather than a two-finger scroll, which is a threshold of its own and a\n * stricter one. Measured with the virtual touchpad, the first `scale-changed`\n * after `begin` already reports about 1.09. So this gate is a second, smaller\n * one, and setting it at upstream's effective magnitude would refuse pinches\n * the platform has already accepted.\n */\nexport const PINCH_RECOGNITION_THRESHOLD = 0.05\n\nconst magnitude = (view: RecognizerView): number => Math.abs(view.scale - 1)\n\nexport const pinchDecider: RecognizerDecider = {\n  kind: \"pinch\",\n  // See the file header: there is no press, so there is no interaction lock\n  // to take. Every update arrives through `Recognizer.touchpad` instead.\n  claimsResponder: false,\n  source: \"touchpad\",\n\n  /**\n   * Never from the gesture itself. Upstream's pinch has no failure predicate\n   * over movement at all, and it goes further: `PinchGestureHandler.init` sets\n   * `shouldCancelWhenOutside = false` explicitly, so a pinch whose focal point\n   * wanders off the view keeps running. It fails when GTK ends the gesture\n   * before it ever activated, which is the shared machine's own rule.\n   */\n  shouldFail: (): boolean => false,\n\n  shouldActivate: (view: RecognizerView): boolean =>\n    magnitude(view) >= PINCH_RECOGNITION_THRESHOLD,\n}\n\nexport const rotationDecider: RecognizerDecider = {\n  kind: \"rotation\",\n  claimsResponder: false,\n  source: \"touchpad\",\n\n  shouldFail: (): boolean => false,\n\n  shouldActivate: (view: RecognizerView): boolean =>\n    Math.abs(view.rotation) >= ROTATION_RECOGNITION_THRESHOLD,\n}\n\n/**\n * Upstream sets `shouldCancelWhenOutside = false` from both handlers' `init`,\n * against a base class that defaults it on for several other kinds. Applied\n * from the builders' constructors here, which is where this module puts every\n * other constructor-set default.\n */\nexport const TOUCHPAD_DEFAULTS: Partial<RecognizerConfig> = {\n  shouldCancelWhenOutside: false,\n}\n"]}