@rootnative/impulse 0.0.0-alpha.0 → 0.0.0-alpha.1

package/CHANGELOG.md

@@ -4,14 +4,50 @@ All notable changes to `@rootnative/impulse` are documented here. The format fol
 
 ## [Unreleased]
 
-Nothing is published. This section holds the scaffold as it is built; the first release note is written when Milestone 1's graduation gate is met and `0.0.1` is cut.
+`0.0.0-alpha.1` is on npm, cut from the `core@0.0.0-alpha.1` tag. This section holds every change since it.
+
+## [0.0.0-alpha.1] - 2026-09-27
+
+The second alpha. It carries every change since `0.0.0-alpha.0`: the eight intent hooks, the `IntentEndInfo` argument on every end callback, and the worklet warning. Milestone 1's gate is closed on mechanics only, and feel is untested.
 
 ### Added
 
+- **A phase callback that is not a worklet now warns in development.** `onBegin`, `onUpdate`, and `onFinalize` run on the UI thread. A plain function there throws `Tried to synchronously call a Remote Function. Called "anonymous"` on the first touch that reaches the phase, and that error names neither the hook nor the option. The warning names both and gives the fix: add the `'worklet'` directive. It runs from `useGestureMemo`, so all eight intents get it and a new intent cannot skip it. It is `warnOnce`-keyed by hook and option. The shipped Jest setup now mocks `isWorkletFunction` and reports every function as a worklet, because the mock has no UI thread and a Jest run without the Worklets Babel plugin marks nothing.
+
+- **Every intent result now hides `gesture` and `ref` from enumeration, which fixes a render crash in every intent.** Reading a shared value off a hook result inside a worklet — `useAnimatedStyle(() => ({ transform: [{ translateX: drag.x.value }] }))`, the pattern every docs page shows — made the worklet capture `drag` itself, because a worklet captures the root identifier it reads through. Worklets then tried to copy the whole result to the UI thread, could not copy the RNGH gesture inside it, and the component threw `[Worklets] Cannot copy value of type 'PanGesture'` at render. **Every example screen died of this**, and it was invisible to the test suite because the Jest Reanimated mock serializes nothing. Worklets copies an object through `Object.entries`, so making the two fields non-enumerable removes them from the copy and leaves the shared values, which is all a worklet ever wanted. **No public API changed and no consumer code needs editing** — property access still works, so `<GestureDetector gesture={drag.gesture}>` and every coexistence option are unaffected. The only observable difference is that `gesture` and `ref` no longer appear in `Object.keys`, a spread, `JSON.stringify`, or a logged object.
+
+- **`useRotate`** — a two-finger rotation that owns the angle it produces. It accumulates across gestures the way `usePinch` accumulates a scale, so `min` and `max` are the travel of the control rather than of one gesture, and `elastic` lets the fingers turn past an end with `settled` reporting where the angle belongs. `anchor` is the point the turn happens about, which is `focal`'s counterpart. `onRotateStart` / `onRotateEnd` on the JS thread, `onBegin` / `onUpdate` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/rotate`.
+- **`useRotate` reports degrees, and RNGH reports radians.** This is the only place in the library where a unit is changed rather than passed through. `min: -45` is a range a person wrote; `-Math.PI / 4` is one they derived, and deriving it per project is the work Impulse exists to remove. A React Native style takes either unit, so the call site pays nothing. The conversion is applied at all four boundaries — `angle`, `gestureAngle`, `velocity`, and the `min` / `max` comparison — and `useRotate.test.tsx` pins each one, because a boundary added later and forgotten is a silent factor of 57.
+- **`useRotate` does not wrap at a full turn.** A second revolution reports `720`. A dial counting turns needs exactly that, and a photo editor wants `10` rather than `370` — Impulse does not guess which, because wrapping by default makes the counting case unrecoverable while not wrapping makes the editor case one `%` at the call site.
+- **Public types `RotateEvent`, `UseRotateOptions`, and `UseRotateResult`.**
+- **`example/screens/RotateScreen.tsx`**, wired into the gallery. A levelling control carries the anchor transform and the elastic ends; a second panel composes `useRotate` with `usePinch` under `mode: 'simultaneous'`, which is the photo-editor pair and the case neither hook can express alone — neither has a threshold, so nothing else would separate them.
+- **`usePinch`** — a two-finger pinch that owns the scale it produces. It accumulates across gestures the way `useDrag` accumulates a position, so `min` and `max` are the zoom range of the viewer rather than of one gesture, and `elastic` lets the fingers pull past an end with `settled` reporting where the scale belongs. `onPinchStart` / `onPinchEnd` on the JS thread, `onBegin` / `onUpdate` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/pinch`.
+- **`usePinch` recovers the gesture's start by division, not by assignment.** RNGH activates a pinch on movement, so its `scale` at `onStart` is not reliably `1`; assigning the current scale there multiplies that head start into the value and the content jumps before it grows. Dividing it out means the first update reproduces the scale the view already had — the same defect `useDrag` avoids by subtracting the threshold once at the start.
+- **`focal` is reported because scaling about the view's centre is wrong.** It is the midpoint between the fingers, relative to the view, and without it the content slides out from under them as it grows. It is read at `onStart` as well as at every update, so `onPinchStart` does not hand over the previous gesture's point, and it keeps its last value after the fingers lift so a release animation scales about the same place the pinch did.
+- **`usePinch` has no activation criteria, and that is RNGH's limit rather than a choice.** `Gesture.Pinch()` takes the touch as soon as a second finger moves and exposes no threshold. It is therefore the one continuous intent that cannot separate itself from a neighbour with a number: a pinch and a pan share a view through `useGestures([pinch, pan], { mode: 'simultaneous' })` or through `alongside`, and through nothing else. Faking a threshold would need `manualActivation`, which the design contract discourages.
+- **Public types `PinchEvent`, `UsePinchOptions`, and `UsePinchResult`.**
+- **`example/screens/PinchScreen.tsx`**, wired into the gallery. It carries the two questions Jest cannot answer: whether the content stays under the fingers, which is what the focal transform is for, and whether an `elastic` of `0.35` reads as resistance or as a fault. That number is a guess — `useDrag` defaults `elastic` to `0` and has none to borrow — and the resistance is computed on the scale rather than on its logarithm, so the two ends do not resist symmetrically. Only a device settles either.
+- **`usePan`** — a pan that reports movement rather than owning a position, and the line between it and `useDrag`. `useDrag` holds `x` and `y` as the place a thing sits: they accumulate across gestures and `bounds` clamps them. `usePan` holds nothing — it zeroes both at the start of every gesture, has no `bounds` and no `elastic`, and hands over a per-frame `change` the consumer adds up. That is the camera, the scrubber, and the canvas, where `bounds` is the wrong owner. `onPanStart` / `onPanEnd` on the JS thread, `onBegin` / `onUpdate` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/pan`.
+- **`usePan` computes `change` itself rather than passing RNGH's through.** RNGH reports the whole translation as the first `changeX`, threshold included, so a consumer accumulating it jumps ten points before anything moves — the same defect `useDrag` avoids by subtracting the offset once at the start. `translation` is measured from the activation point for the same reason.
+- **`useSwipe`** — a pan judged at release. The finger moves and `x` and `y` report it so a view can follow; on release the dominant axis alone is tested, against `commitDistance` (80 points) or `commitSpeed` (800 points per second), either of which is enough on its own. Neither number has been measured on hardware. `onSwipe` and `onSwipeEnd` on the JS thread, `onBegin` / `onUpdate` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/swipe`.
+- **`useSwipe`'s `directions` is the activation criterion, not only a filter.** An all-horizontal list produces `activeOffsetX`, so a swipeable row lives inside a vertical list with no relation declared; an all-vertical list does the same on `y`; a mixed list has no axis to lock, falls back to `minDistance`, and has to declare `deferTo` or `blocks`. Narrowing `directions` is the cheapest coexistence fix in the library.
+- **`onSwipe` and `onSwipeEnd` do different jobs, and the payload says so.** `onSwipe` fires only for a release that committed, and takes a `CommittedSwipeEvent` whose `direction` is never `null` — no null check for a case it cannot be in. `onSwipeEnd` fires for every release of a swipe that activated, which is how a view that followed the finger learns to go back, and its `direction` is `null` for a release that stopped short. A cancelled gesture never commits: the finger did not lift, so its velocity describes the last movement rather than a release.
+- **Public types `PanAxis`, `PanEvent`, `UsePanOptions`, `UsePanResult`, `SwipeDirection`, `SwipeEvent`, `CommittedSwipeEvent`, `UseSwipeOptions`, and `UseSwipeResult`.**
+- **`example/screens/PanScreen.tsx` and `example/screens/SwipeScreen.tsx`**, wired into the gallery. The pan screen pushes a canvas whose offset the *screen* owns, advanced by `change` on every frame, so drift between the finger and the grid is visible rather than asserted; the swipe screen puts horizontal cards inside a vertical list to re-test the coexistence claim through a second hook, and pairs them with an all-directions panel that has to declare `deferTo`.
+
+- **A relation to a component that owns no gesture now warns in development.** This is the silent failure the package exists to remove. RNGH resolves every `alongside` / `blocks` / `deferTo` reference through `ref.current?.handlerTag ?? -1` and then keeps only tags above zero, so a ref to React Native's own `ScrollView` is dropped — no warning, no error, and no way to tell the result apart from a relation nobody wrote. The gesture still works, and it still fights the scroll view for the touch. The warning names the hook, the option, and the fix: import `ScrollView` or `FlatList` from `@rootnative/impulse/gesture-handler`. It fires from an effect rather than during render, because a ref is empty while the component that owns it renders, and it is `warnOnce`-keyed by hook and option, so a hook that re-renders at frame rate does not print at frame rate.
+- **The same check stays quiet for a target that mounts in a later commit**, which is the one case it cannot see. Its ref is empty when the check runs and nothing re-checks it. Silence is correct rather than cautious there: RNGH re-resolves relations through `MountRegistry` when a handler mounts late, so the relation is installed and a warning would report a defect that is not there. `relationReferences.test.tsx` pins the three outcomes through a real render, and `relations.test.ts` pins the unit rules — the tag-above-zero threshold, one report per option rather than per reference, and each option reported separately.
+- **`useDoubleTap`** — two taps in quick succession. It shares `useTap`'s payload and its `maxDistance`, because the two hooks recognize the same touch and differ only in how many times it happens; a double tap that is fussier about travel than a single tap on the same view is a difference nobody asked for. `onDoubleTap` on the JS thread, `onBegin` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/double-tap`.
+- **Pairing a single tap with a double tap is `exclusive`, not `race`, and the docs said `race`.** A single tap recognizes on the first release, so under `Gesture.Race` it wins every time and the double tap never fires. `useTap`'s hook comment, the root README, and the package README all carried the wrong composition; all three now say `useGestures([double, tap], { mode: 'exclusive' })`, and `useDoubleTap.test.tsx` asserts the RNGH relation after `prepare()` rather than trusting the prose. The cost of the right answer is stated too: the single tap cannot report for `maxDelay` milliseconds, which is why lowering `maxDelay` is the first thing to reach for.
+- **`useLongPress`** — a press held past a duration, and the first intent whose JS-thread callback fires **while the finger is still down**. That is the difference between a long press and a slow tap: a context menu opens under a finger that has not lifted. `onLongPress` at recognition and `onLongPressEnd` at release, both on the JS thread; `onBegin` / `onFinalize` as worklets. Reachable as `@rootnative/impulse/long-press`.
+- **`useLongPress`'s `isActive` is the held state, not a pressed state.** It turns true at recognition rather than at touch-down, which is the opposite of `useTap` and deliberate: every ordinary tap on the view reaches `onBegin`, and almost none of them are this gesture, so a flag that is true for all of them tells a consumer nothing. Drive a pressed state from a composed `useTap` instead.
+- **`LongPressEvent` carries `duration`** — roughly `minDuration` at `onLongPress`, and the whole hold at `onLongPressEnd`, which is what a hold-to-record affordance stops on. Deriving it from two timestamps the consumer records themselves is the work the payload exists to remove.
+- **Public types `UseDoubleTapOptions`, `UseDoubleTapResult`, `LongPressEvent`, `UseLongPressOptions`, and `UseLongPressResult`.** `TapEvent` is now shared by both tap hooks and moved to `src/intents/tapEvent.ts` with its normalizer, so the two cannot disagree about which RNGH field means what. It is still exported under the same name from the root entry and from `@rootnative/impulse/tap`.
+- **`example/screens/DoubleTapScreen.tsx` and `example/screens/LongPressScreen.tsx`**, wired into the gallery. Each carries the question its hook cannot answer in Jest: the double-tap screen switches `maxDelay` between 500ms and 250ms so the single-tap latency of the pairing can be felt against the double-tap tolerance it buys, and the long-press screen switches `minDuration` and turns its card green at recognition, so a callback firing at the wrong phase is visible rather than asserted.
+- **`scripts/check-artifact.mjs` derives its required-file list from `exports`** instead of holding a copy of it. The literal list was written when there were three subpaths and would not have covered the fourth and fifth, which is the commit where a guard against publishing an `exports` entry with no file behind it becomes a guard against publishing the entries somebody remembered. It also now checks each subpath's `.d.ts`, which the literal never did.
 - **`useDrag`** — the second intent hook, and the first continuous one. Shared values `x` and `y` that follow the finger on the UI thread and accumulate across gestures, `bounds` with an `elastic` coefficient, `onDragStart` / `onDragEnd` on the JS thread, and `onBegin` / `onUpdate` / `onFinalize` as worklets. Returns values and no style, and starts no animation: `onDragEnd` carries `velocity` and `settled` — the nearest in-bounds point — and the consumer springs it home. Reachable as `@rootnative/impulse/drag`.
 - **`useDrag`'s threshold is directional on a single axis and radial on both.** `axis: 'x'` maps to `activeOffsetX`, so a horizontal drag inside a vertical scroll view leaves the scroll alone until the finger commits sideways; `axis: 'both'` maps to `minDistance`. The default of 10 points is Impulse's — a bare `Gesture.Pan()` activates almost immediately, which is what makes a drag steal a scroll. `failOffset` is available for the stricter case and unset by default. The number has not been measured on hardware.
 - **`useDrag` does not jump by the threshold when it activates.** The finger has already travelled that distance when RNGH reports the start, and it stays in `translationX` for the rest of the gesture, so the offset is subtracted once at the start. Without that, the view leaps the threshold the moment the drag wins.
-- **`onDragEnd` is guarded on `success`.** RNGH calls `onEnd` for a cancelled gesture too. A cancelled drag never released and carries no velocity worth seeding a spring with, so it reaches `onFinalize` and not `onDragEnd`.
 - **Public types `DragAxis`, `DragBounds`, and `DragEvent`.**
 - **`example/screens/DragScreen.tsx`**, wired into the gallery. It carries Milestone 1's gate — a horizontal drag inside a vertical scroller — plus a two-axis drag that declares `blocks` against that scroller, and it springs both home from `settled` to show where Impulse stops and the consumer starts.
 - **`useTap`** — the first intent hook, and the pattern the rest follow. An intent-shaped payload (`{ x, y, absolute, pointers }`) instead of RNGH's flat event, `onTap` on the JS thread with Impulse owning the `runOnJS` boundary, `onBegin` / `onFinalize` as worklets, and an `isActive` shared value for a pressed state that needs no re-render. Reachable as `@rootnative/impulse/tap`.
@@ -36,13 +72,23 @@ Nothing is published. This section holds the scaffold as it is built; the first
 - **`scripts/check-versions.mjs`** — the release-consistency guard. It verifies that exactly one public package exists, that the CHANGELOG has a section for the current version, that the link footer resolves, that the status lines in both READMEs are current, and that no `v`-prefixed version string reaches a published surface.
 - **`example/`** — Expo SDK 57 app for manual validation. It carries the navigator shell and no intent screens yet; a screen is added with each intent, and a device pass is a release requirement.
 
+### Changed
+
+- **The docs now record the device sweep of 2026-09-19 and 2026-09-20.** It ran on an Android emulator with injected touches and on an iOS simulator with XCUITest. Both checks of Milestone 1's gate passed on both platforms, and every intent was driven on at least one platform. Six docs pages, the doc comments, and `llms.txt` said "No hardware pass has happened". Each one now says what the sweep proved and what it did not. The sweep measured no feel, no physical device ran it, and `useSwipe`'s `commitSpeed` is still untested.
+- **Every end callback now reports how the gesture ended.** `onTap`, `onDoubleTap`, `onLongPressEnd`, and `onDragEnd` take a second argument, `IntentEndInfo`, and fire on **both** endings: `{ cancelled: false }` when the user completed the gesture, `{ cancelled: true }` when the system took it away. **This is a breaking change to four public signatures**, and alpha is when to make it — a consumer who ignores the new argument now runs their handler on the cancelled path. Before this, a cancel was reported only by `onFinalize`, which is a worklet, so a consumer holding phase in React state had to write `'worklet'` plus `scheduleOnRN` by hand — the exact ceremony the library exists to remove. Found by the web survey: hold a `useLongPress` past `minDuration`, then move the pointer past `maxDistance` without releasing, and `isActive` clears while React state does not. It is an object rather than a bare boolean so a later reason field does not break the signature a second time.
+- **The cancel never announces the end of a gesture that never started.** RNGH calls `onEnd` only when the old state was `ACTIVE`, so a touch that never activated — a tap that moved too far, a press released before `minDuration`, a drag that never passed `threshold` — reaches `onFinalize` and no end callback on either path. That is also why removing the `success` guard was the whole change: `onEnd(event, false)` already meant "activated, then cancelled", one-to-one. No activation tracking was added.
+- **`onDragEnd`'s velocity is not a throw on the cancelled path.** The finger never lifted, so it describes the last movement. Springing on it flings a view the user never released; return to `settled` instead. The docs page and `example/screens/DragScreen.tsx` both say so.
+- **`onFinalize` is unchanged, on purpose.** Its `success: false` still covers both a gesture that never activated and one that was cancelled, and the hook still clears `isActive` before calling it. Nothing has to decode that any more, so it stays the UI-thread cleanup hook that runs for every attempt. Rejected: a third `{ activated }` argument, and reordering the two lines so `isActive` survives into the callback — the first adds public surface nothing needs, the second is an implicit signal that works only for the two hooks that set `isActive` at recognition.
+- **`example/screens/LongPressScreen.tsx` no longer crosses the thread boundary by hand.** It carried the workaround on purpose, with a comment saying so: a `useRef` for "was it recognized", a worklet `onFinalize`, and a `scheduleOnRN` back to the JS thread. All three are gone, which is the clearest measure of what the argument bought. All four screens now branch on `cancelled`.
+
 ### Notes
 
 - **The package ships ESM only.** CJS with code splitting defeats the Reanimated Babel plugin and ships worklets that crash on native — that defect cost `@rootnative/components` two releases. See the comment in `tsup.config.ts` before changing the format.
-- **`useTap` and `useDrag` are the intents implemented.** `useSwipe`, `usePinch`, and the rest are designed but not written. Milestone 1's code is now complete; its graduation gate is a device pass that has not happened, so every activation-criteria default in this release is a design intention rather than a measurement.
-- **A pan that fails before it activates cannot be tested in Jest.** RNGH's mock fills every gesture's state sequence from `[BEGAN, ACTIVE, END]`, so it injects an ACTIVE event before any FAILED it is given and the drag always starts. The threshold's real effect is checked on the example screen.
+- **`useTap`, `useDoubleTap`, `useLongPress`, `useDrag`, `usePan`, `useSwipe`, `usePinch`, and `useRotate` are the intents implemented.** `useHover` and `useEdgeSwipe` are designed but not written. Milestone 1's code is complete and Milestone 2 is under way. The device sweep of 2026-09-19 and 2026-09-20 measured the mechanical half of Milestone 1's gate on both platforms; feel is untested, so the activation-criteria defaults a scripted touch could not reach are still design intentions.
+- **A gesture that fails before it activates cannot be tested in Jest, and it is not only pan.** RNGH's mock fills every gesture's state sequence from `[BEGAN, ACTIVE, END]`, so it injects an ACTIVE event before any FAILED it is given and `onStart` always runs. For `useDrag` that means the threshold never rejects; for `useLongPress` it means a press released early still reaches `onLongPress`. Both are checked against the gesture's config and on the example screen instead.
 - **A relation cannot name a component ref without a cast.** RNGH types a relation target as `RefObject<ComponentType | undefined | null>` — a ref to a component *type*, which is not what `ref={}` produces — so a real `ScrollView` ref does not typecheck. Impulse's `GestureReference` mirrors RNGH's type exactly, so the mismatch is visible rather than absorbed.
 - **`useGestures` does not take coexistence options**, and that is a limitation rather than a choice. RNGH's three external-gesture relations are methods on a single gesture, and a composed gesture does not have them. Set `alongside` / `blocks` / `deferTo` on the member hooks instead.
 - **Impulse does not yet warn when a hook mounts with no `<GestureHandlerRootView>` above it.** RNGH's root-view context is not exported from its package entry, and reaching it would mean a deep import into `lib/commonjs/`, which pins one module format and breaks under the others.
 
-[unreleased]: https://github.com/rootnative/impulse/commits/main
+[unreleased]: https://github.com/rootnative/impulse/compare/core@0.0.0-alpha.1...HEAD
+[0.0.0-alpha.1]: https://github.com/rootnative/impulse/releases/tag/core@0.0.0-alpha.1

package/README.md

@@ -12,7 +12,7 @@
 
 Declarative gesture primitives for React Native, built as a thin wrapper around [`react-native-gesture-handler`](https://docs.swmansion.com/react-native-gesture-handler/). A gesture is written as an intent, not assembled from a builder chain.
 
-> **Status:** `0.0.0-alpha.0` — pre-release, not published. What ships today is the composition and coexistence core — `useGestures`, `useRawGesture`, and the `alongside` / `blocks` / `deferTo` options — plus `useTap`, the first intent hook, and the `@rootnative/impulse/gesture-handler` interop subpath. Every other intent hook is **not implemented**. See the [CHANGELOG](https://github.com/rootnative/impulse/blob/main/packages/core/CHANGELOG.md).
+> **Status:** `0.0.0-alpha.1` — published as an alpha on the `alpha` dist-tag. Install it with `@rootnative/impulse@alpha`. What ships today is the composition and coexistence core — `useGestures`, `useRawGesture`, and the `alongside` / `blocks` / `deferTo` options — plus eight intent hooks, **`useTap`, `useDoubleTap`, `useLongPress`, `useDrag`, `usePan`, `useSwipe`, `usePinch`, and `useRotate`**, and the `@rootnative/impulse/gesture-handler` interop subpath. `useHover` and `useEdgeSwipe` are **not implemented**. A device sweep on 2026-09-19 measured the activation criteria a scripted touch can reach; how a gesture feels is still untested. See the [CHANGELOG](https://github.com/rootnative/impulse/blob/main/packages/core/CHANGELOG.md).
 
 ## Install
 
@@ -42,9 +42,13 @@ Neither is a replacement for the other, and `-gestures` is not deprecated.
 
 ## What ships today
 
-### `useTap` — the first intent
+### The intent hooks
 
-One hook, one intent. The callback name states its thread: `onTap` runs on the JS thread and may set React state directly, because Impulse owns the `runOnJS` boundary. `onBegin` and `onFinalize` are worklets.
+Six so far. Every one returns `{ gesture, ref, isActive }` plus whatever values its own intent produces, and every one takes the same `alongside` / `blocks` / `deferTo` options.
+
+**The callback name states its thread.** A callback named for what happened — `onTap`, `onDoubleTap`, `onLongPress`, `onDragEnd`, `onSwipe` — runs on the JS thread and may set React state directly, because Impulse owns the `scheduleOnRN` boundary. A callback named for a phase — `onBegin`, `onUpdate`, `onFinalize` — is a worklet and runs on the UI thread. There is no flag to set and no `scheduleOnRN` to write.
+
+#### `useTap`
 
 ```tsx
 import { GestureDetector, useTap } from '@rootnative/impulse'
@@ -76,12 +80,194 @@ The payload is shaped by intent rather than passed through: `{ x, y, absolute: {
 | `maxDistance` | `10` points | **Not** RNGH's behaviour. RNGH defers the slop to the platform, so the same tap is accepted on one operating system and rejected on the other. |
 | `pointers` | `1` | Raise it for a two-finger tap. |
 
-Neither default has been measured on hardware yet.
+The device sweep of 2026-09-19 did not test either default.
 
 **Accessibility.** A tap gesture is invisible to a screen reader and unreachable from a keyboard, and this hook does not fix that. Whatever the tap does must also be reachable another way — the same action on a `<Pressable>`, or `accessibilityActions` on the view. A tap-only affordance is a bug, not a trade-off.
 
 **Web.** A single-finger tap behaves as it does on native. `pointers` above 1 is unreliable, because a mouse reports one pointer and touch emulation varies by browser.
 
+#### `useDoubleTap`
+
+Two taps in quick succession, sharing `useTap`'s payload and its `maxDistance` — a double tap that is fussier about travel than a single tap on the same view is a difference nobody asked for.
+
+```tsx
+import { GestureDetector, useDoubleTap, useGestures, useTap } from '@rootnative/impulse'
+
+const double = useDoubleTap({ maxDelay: 250, onDoubleTap: zoomIn })
+const tap = useTap({ onTap: select })
+
+// The double tap first, and the mode is `exclusive`.
+const { gesture } = useGestures([double, tap], { mode: 'exclusive' })
+```
+
+**Pairing it with a single tap is the whole difficulty, and `race` is the wrong mode.** A single tap recognizes on the first release, so under `race` it wins every time and the double tap never fires. `exclusive` makes the single tap wait to learn whether a second tap is coming — and that wait is `maxDelay` long, on every ordinary tap. Lowering `maxDelay` is what buys the latency back.
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `maxDelay` | `500` ms | RNGH's own default, and the latency a composed single tap pays. 250–300 is closer to what the platforms use. |
+| `maxDuration` | `500` ms | Per tap, not for the pair. |
+| `maxDistance` | `10` points | Impulse's number, the same as `useTap`'s. |
+
+A view that needs only a double tap needs no composition — use the hook alone. Three taps and up are not modelled: build one with `useRawGesture` and `Gesture.Tap().numberOfTaps(3)`.
+
+**Accessibility.** Worse than a tap: VoiceOver and TalkBack both consume a double tap as their own activation gesture, so a screen-reader user cannot reach this at all. The action must be offered explicitly somewhere else.
+
+#### `useLongPress`
+
+A press held past a duration. **`onLongPress` fires while the finger is still down** — that is the difference between a long press and a slow tap, and it is where a context menu opens and a haptic fires.
+
+```tsx
+import { GestureDetector, useLongPress } from '@rootnative/impulse'
+
+const hold = useLongPress({
+  minDuration: 400,
+  onLongPress: openMenu,                       // finger still down
+  onLongPressEnd: (event, { cancelled }) => {  // and how it ended
+    if (cancelled) return closeMenu()          // the system took it away
+    stopRecording(event.duration)              // the finger lifted
+  },
+})
+```
+
+`isActive` is the **held** state, not a pressed state: it turns true at recognition, not at touch-down, so an ordinary tap on the view never changes it. The payload carries `duration` — roughly `minDuration` at `onLongPress`, and the whole hold at `onLongPressEnd`, which is what a hold-to-record affordance stops on.
+
+**Every end callback takes a second argument.** `onTap`, `onDoubleTap`, `onLongPressEnd`, and `onDragEnd` each fire on both endings, and `cancelled` says which — `true` when the system took the gesture away rather than the user completing it. Check it before you navigate, submit, or count. Without it a cancel is reportable only from `onFinalize`, which is a worklet, so a consumer holding phase in React state has to cross the thread boundary by hand.
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `minDuration` | `500` ms | RNGH's own default, restated. Below ~200ms it stops being distinguishable from a held tap. |
+| `maxDistance` | `10` points | RNGH's own default. It bounds the **wait**, not the hold — the finger may travel freely once the press is recognized. |
+
+**Hold, then drag.** RNGH has no "activate after this one activates" relation, so it is two gestures and a gate: run them `alongside` each other and let the drag's worklets read `hold.isActive`. Raise the drag's `threshold` too, or the drag activates before the press ever does.
+
+**Accessibility.** The best fallback of any gesture here, so use it: `<Pressable>` takes `onLongPress` directly and is reachable by every assistive technology.
+
+#### `useDrag`
+
+Shared values that follow the finger on the UI thread and accumulate across gestures. **No style and no animation** — that is what separates it from `@rootnative/inertia-gestures`' hook of the same name.
+
+```tsx
+import { GestureDetector, useDrag } from '@rootnative/impulse'
+
+const drag = useDrag({ axis: 'x', bounds: { left: -120, right: 0 }, elastic: 0.3 })
+const style = useAnimatedStyle(() => ({
+  transform: [{ translateX: drag.x.value }],
+}))
+```
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `threshold` | `10` points | Impulse's number. Directional on a single axis (`activeOffsetX` / `activeOffsetY`), radial on `'both'` (`minDistance`). A bare `Gesture.Pan()` activates almost immediately, which is what makes a drag steal a scroll. |
+| `axis` | `'both'` | The locked axis's shared value never changes. |
+| `elastic` | `0` | `0` clamps hard at a bound; `0.3` gives the rubber-band pull an over-scroll has. |
+| `failOffset` | unset | Cross-axis movement that makes the drag give up. |
+
+`onDragEnd` carries `velocity` and `settled` — the nearest in-bounds point — so an elastic overshoot can be sprung home without re-deriving the clamp. Impulse does not move it back itself; that is an animation. On the cancelled path the finger never lifted, so `velocity` describes the last movement rather than a throw: return to `settled` instead of springing on it.
+
+**Coexistence.** A threshold decides who moves first, not who wins a contested touch. Say that too: `deferTo: scrollRef` for a drag that is the fallback, `blocks: listRef` for one that is the foreground affordance.
+
+#### `usePan`
+
+The same recognizer as `useDrag`, and the opposite contract. **`usePan` reports movement; `useDrag` owns a position.** `usePan` holds no value at all: it zeroes at the start of every gesture, it has no `bounds` and no `elastic`, and it reports a per-frame `change` the consumer adds up.
+
+```tsx
+import { GestureDetector, usePan } from '@rootnative/impulse'
+
+const pan = usePan({
+  onUpdate: (event) => {
+    'worklet'
+    camera.x.value += event.change.x
+    camera.y.value += event.change.y
+  },
+})
+```
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `threshold` | `10` points | Same form as `useDrag`: directional on a single axis, radial on `'both'`. |
+| `axis` | `'both'` | The locked axis reports zero. |
+| `failOffset` | unset | Cross-axis movement that makes the pan give up. |
+| `pointers` | unset | Setting it fixes the count exactly. |
+
+RNGH's own `changeX` reports the whole translation on the first update, threshold included, so a consumer accumulating it jumps ten points before anything moves. `usePan` computes the delta itself, so `change` and `translation` are both measured from the activation point.
+
+Reach for `useDrag` to move a view. Reach for `usePan` to pan a camera, scrub a value, or feed a number Impulse has no business clamping.
+
+#### `useSwipe`
+
+A pan judged at release. The finger moves and `x` and `y` report it so a view can follow; on release the travel and the speed along the dominant axis decide whether it counted.
+
+```tsx
+import { GestureDetector, useSwipe } from '@rootnative/impulse'
+
+const swipe = useSwipe({
+  directions: ['left', 'right'],
+  onSwipe: (event) => remove(item.id, event.direction),
+  onSwipeEnd: (event) => {
+    swipe.x.value = withSpring(event.direction === null ? 0 : EXIT)
+  },
+})
+```
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `directions` | all four | Which directions may commit — **and the activation criterion**. |
+| `threshold` | `10` points | When the swipe takes the touch and starts reporting. Not the commit test. |
+| `commitDistance` | `80` points | How far a release must have travelled to count. |
+| `commitSpeed` | `800` pt/s | How fast a release must be moving to count. The flick. Either test is enough on its own. |
+
+**`directions` is the coexistence setting, not only a filter.** An all-horizontal list gives the gesture a directional threshold on x, so a swipeable row lives inside a vertical list with no relation declared. An all-vertical list does the same on y. A mixed list has no axis to lock, so the threshold is radial and the swipe competes for every touch — declare `deferTo` or `blocks` there.
+
+`onSwipe` fires only for a release that counted, and its payload's `direction` is never `null`. `onSwipeEnd` fires for every release of a swipe that activated, which is how a view that followed the finger learns to go back. A cancelled gesture never commits.
+
+#### `usePinch`
+
+A two-finger pinch that **owns the scale it produces**. RNGH's own factor restarts at `1` on every gesture; `usePinch` multiplies it into the scale it already holds, so `min` and `max` are the zoom range of the viewer rather than of one gesture.
+
+```tsx
+import { GestureDetector, usePinch } from '@rootnative/impulse'
+
+const pinch = usePinch({ min: 1, max: 4 })
+const style = useAnimatedStyle(() => ({
+  transform: [{ scale: pinch.scale.value }],
+}))
+```
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `initial` | `1` | The scale before any pinch. Read once, at mount. |
+| `min` / `max` | unset | The zoom range of the viewer. Unset is unbounded. |
+| `elastic` | `0` | How much of the pull past an end reaches `scale`. `0` stops dead; `1` ignores the end. |
+
+`focal` is the midpoint between the fingers, relative to the view, and a zoom viewer cannot skip it: scaling about the view's centre slides the content out from under the fingers. Translate the focal point to the origin, scale, then translate back. `gestureScale` in the payload is RNGH's own factor, for the cases that want the raw gesture.
+
+**`usePinch` has no activation criteria, and that is RNGH's limit rather than a choice.** `Gesture.Pinch()` takes the touch as soon as a second finger moves and exposes no threshold, so a pinch and a pan are separated by a relation alone — `useGestures([pinch, pan], { mode: 'simultaneous' })`.
+
+#### `useRotate`
+
+A two-finger rotation that owns the angle it produces, the way `usePinch` owns a scale.
+
+```tsx
+import { GestureDetector, useRotate } from '@rootnative/impulse'
+
+const rotate = useRotate({ min: -45, max: 45 })
+const style = useAnimatedStyle(() => ({
+  transform: [{ rotate: `${rotate.angle.value}deg` }],
+}))
+```
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `initial` | `0` | The angle before any rotation, in degrees. Read once, at mount. |
+| `min` / `max` | unset | The travel of the control, in degrees. Unset is unbounded. |
+| `elastic` | `0` | How much of the turn past an end reaches `angle`. `0` stops dead; `1` ignores the end. |
+
+**`useRotate` reports degrees, and RNGH reports radians.** This is the one place in the library where a unit is changed rather than passed through: write `min: -45`, not `-Math.PI / 4`. The conversion applies to `angle`, `gestureAngle`, `velocity`, and the `min` / `max` comparison.
+
+The angle **does not wrap** at a full turn — a second revolution reports `720`. A dial counting turns needs that, and a photo editor takes the remainder itself.
+
+`anchor` is the point the turn happens about, and it is the counterpart of pinch's `focal`. `useRotate` has no activation criteria either, so rotate and pinch are composed `simultaneous`.
+
 ### `useGestures` — composition
 
 Composition is **data, not nesting**. One flat list plus the relation that holds over it, and the result is itself a member, so precedence reads left to right instead of inside out.
@@ -89,9 +275,10 @@ Composition is **data, not nesting**. One flat list plus the relation that holds
 ```tsx
 import { GestureDetector, useGestures } from '@rootnative/impulse'
 
-// tap and double-tap race; the winner runs alongside the drag
+// the single tap waits for the double tap to fail; the winner runs
+// alongside the drag
 const { gesture } = useGestures(
-  [useGestures([tap, double], { mode: 'race' }), drag],
+  [useGestures([double, tap], { mode: 'exclusive' }), drag],
   { mode: 'simultaneous' },
 )
 
@@ -116,6 +303,8 @@ useRawGesture(build, deps, { deferTo: scrollRef })  // the other one wins
 
 All three may be set at once — they are independent relations, not a choice of one. Naming the same gesture in two of them warns in development.
 
+**The ref has to belong to a gesture.** RNGH resolves a relation through `ref.current?.handlerTag` and drops a ref that has none, without a word — so `deferTo` on React Native's own `ScrollView` installs nothing and the drag and the scroll keep fighting for the touch. Import `ScrollView` or `FlatList` from `@rootnative/impulse/gesture-handler` instead; another Impulse hook's `ref` always carries a tag. Impulse warns once in development when it catches this, which is when the ref is filled by the time the gesture mounts. A target that mounts in a later commit stays silent.
+
 ### `useRawGesture` — the escape hatch
 
 For a recognizer the intent hooks will not model. You own the dependency list, the thread, and the payload; Impulse still owns gesture identity, relation resolution, and a `ref` other hooks can name.
@@ -135,8 +324,8 @@ const fling = useRawGesture(
 
 - **`GestureDetector`**, re-exported from the root entry. Every hook's result is handed to it, so reaching for it is not a reason to add a second gesture import to an app.
 - **`@rootnative/impulse/gesture-handler`** — RNGH's own primitives, re-exported under their original names by reference. It keeps `@rootnative/impulse` the only gesture import in an app.
-- **Subpaths** — `@rootnative/impulse/tap`, `@rootnative/impulse/compose`, and `@rootnative/impulse/raw`, so an app that uses one hook does not ship the set.
-- **Types** — `AttachableGesture`, `CoexistenceOptions`, `ComposeMode`, `GestureReference`, `GestureReferences`, `HitSlop`, `IntentResult`, `Point`, and per-intent `TapEvent` / `UseTapOptions` / `UseTapResult`.
+- **Subpaths** — `@rootnative/impulse/tap`, `/double-tap`, `/long-press`, `/drag`, `/pan`, `/swipe`, `/pinch`, `/rotate`, `/compose`, and `/raw`, so an app that uses one hook does not ship the set.
+- **Types** — `AttachableGesture`, `CoexistenceOptions`, `ComposeMode`, `GestureReference`, `GestureReferences`, `HitSlop`, `IntentResult`, `Point`, and per-intent `TapEvent`, `LongPressEvent`, `DragAxis` / `DragBounds` / `DragEvent`, `PanAxis` / `PanEvent`, `SwipeDirection` / `SwipeEvent` / `CommittedSwipeEvent`, `PinchEvent`, `RotateEvent`, plus the `Use*Options` and `Use*Result` pair for each hook. `useTap` and `useDoubleTap` share one `TapEvent`.
 - **`@rootnative/impulse/jest-preset`** — one-line Jest wiring, layered on `@react-native/jest-preset`.
 
 ## Gesture identity is stable by construction
@@ -147,9 +336,11 @@ Worklet callbacks are the deliberate exception: a worklet is captured as written
 
 ## What does not ship yet
 
-Every intent hook except `useTap` — `useDoubleTap`, `useLongPress`, `useDrag`, `usePan`, `useSwipe`, `usePinch`, `useRotate`, `useHover`, `useEdgeSwipe`. They are designed and the design is locked; none of them is written.
+Two intent hooks — `useHover` and `useEdgeSwipe`. They are designed and the design is locked; neither is written.
+
+Three further limits today:
 
-Two further limits today:
+- **Most activation-criteria defaults are still design intentions.** A device sweep on 2026-09-19 drove every intent on Android or iOS and measured what a scripted touch can: `useDrag`'s `bounds` and `elastic`, `usePinch`'s and `useRotate`'s `min` and `max`, `useLongPress`'s `minDuration`, and `useSwipe`'s `commitDistance` are all honoured exactly. That the library obeys a number is not evidence that the number is right — only a hand reports that. A deliberate double tap still registers at `maxDelay: 250` on both platforms, so the 500ms default is the one most likely to move. Three numbers stay unmeasured, because no instrument here could produce them: `useTap`'s and `useDoubleTap`'s `maxDistance`, the shared 10-point `threshold`, and `useSwipe`'s `commitSpeed`.
 
 - **`useGestures` does not take coexistence options.** RNGH's three relations are methods on a single gesture, and a composed gesture does not have them. Set them on the member hooks instead.
 - **No warning when `<GestureHandlerRootView>` is missing.** Its absence is silent — the gesture simply never fires — and RNGH does not export the context that would let Impulse detect it.
@@ -167,7 +358,11 @@ The preset also needs `@react-native/jest-preset` as a devDependency at the vers
 
 ## Documentation
 
-The docs site is not built yet. Until it is, the [repository README](https://github.com/rootnative/impulse) carries the design principles, the boundary with `@rootnative/inertia`, and the roadmap.
+**[rootnative.github.io/impulse](https://rootnative.github.io/impulse/)** — installation, a page per intent hook, composition, coexistence, threads and callbacks, and the [web behaviour](https://rootnative.github.io/impulse/web) of each intent. The example app runs in a browser at [/impulse/example/](https://rootnative.github.io/impulse/example/).
+
+The [repository README](https://github.com/rootnative/impulse) carries the design principles, the boundary with `@rootnative/inertia`, and the roadmap.
+
+An agent reads `node_modules/@rootnative/impulse/llms.txt` for the exact API of the installed version, or [`llms-full.txt`](https://rootnative.github.io/impulse/llms-full.txt) for the full reference.
 
 ## Licence
 

package/dist/{chunk-5BMRKYVY.js → chunk-2UZTAWUQ.js}

@@ -1,6 +1,24 @@
 import { useRef, useInsertionEffect, useCallback } from 'react';
 
-// src/internal/useLatestCallback.ts
+// src/internal/intentResult.ts
+function buildIntentResult(built, values) {
+  const result = { ...values };
+  Object.defineProperty(result, "gesture", {
+    value: built.gesture,
+    enumerable: false,
+    // Configurable so the object stays describable and a future field can
+    // replace it. Not writable: the result is read-only by type, and a
+    // consumer swapping the gesture would defeat the memoisation that keeps
+    // gesture identity stable.
+    configurable: true
+  });
+  Object.defineProperty(result, "ref", {
+    value: built.ref,
+    enumerable: false,
+    configurable: true
+  });
+  return result;
+}
 function useLatestCallback(callback) {
   const latest = useRef(callback);
   useInsertionEffect(() => {
@@ -36,4 +54,4 @@ function useStableRecord(value) {
   return held.current;
 }
 
-export { useLatestCallback, useStableRecord };
+export { buildIntentResult, useLatestCallback, useStableRecord };

package/dist/chunk-BNSFDNLA.js

@@ -0,0 +1,75 @@
+import { toTapEvent } from './chunk-VEPUHGPN.js';
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEFAULT_MAX_DURATION = 500;
+var DEFAULT_MAX_DELAY = 500;
+var DEFAULT_MAX_DISTANCE = 10;
+function useDoubleTap(options = {}) {
+  const {
+    pointers = 1,
+    maxDuration = DEFAULT_MAX_DURATION,
+    maxDelay = DEFAULT_MAX_DELAY,
+    maxDistance = DEFAULT_MAX_DISTANCE,
+    enabled,
+    onDoubleTap,
+    onBegin,
+    onFinalize
+  } = options;
+  const isActive = useSharedValue(false);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const handleDoubleTap = useLatestCallback(onDoubleTap);
+  const hasDoubleTapHandler = onDoubleTap !== void 0;
+  const built = useGestureMemo(
+    "useDoubleTap",
+    () => {
+      const tap = Gesture.Tap().numberOfTaps(2).minPointers(pointers).maxDuration(maxDuration).maxDelay(maxDelay).maxDistance(maxDistance).onBegin((event) => {
+        "worklet";
+        isActive.value = true;
+        onBegin?.(toTapEvent(event));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (hasDoubleTapHandler) {
+          scheduleOnRN(handleDoubleTap, toTapEvent(event), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toTapEvent(event), success);
+      });
+      if (hitSlop !== void 0) {
+        tap.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        tap.enabled(enabled);
+      }
+      return tap;
+    },
+    [
+      pointers,
+      maxDuration,
+      maxDelay,
+      maxDistance,
+      hitSlop,
+      enabled,
+      hasDoubleTapHandler,
+      handleDoubleTap,
+      isActive,
+      onBegin,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { isActive }),
+    [built, isActive]
+  );
+}
+
+export { useDoubleTap };

package/dist/chunk-DXXGWG4Q.js

@@ -0,0 +1,136 @@
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEFAULT_INITIAL_SCALE = 1;
+function resist(value, min, max, elastic) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return min + (value - min) * elastic;
+  }
+  if (max !== void 0 && value > max) {
+    return max + (value - max) * elastic;
+  }
+  return value;
+}
+function clamp(value, min, max) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return min;
+  }
+  if (max !== void 0 && value > max) {
+    return max;
+  }
+  return value;
+}
+function usePinch(options = {}) {
+  const {
+    initial = DEFAULT_INITIAL_SCALE,
+    min,
+    max,
+    elastic = 0,
+    enabled,
+    onPinchStart,
+    onPinchEnd,
+    onBegin,
+    onUpdate,
+    onFinalize
+  } = options;
+  const scale = useSharedValue(initial);
+  const focal = useSharedValue({ x: 0, y: 0 });
+  const isActive = useSharedValue(false);
+  const startScale = useSharedValue(initial);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const handlePinchStart = useLatestCallback(onPinchStart);
+  const handlePinchEnd = useLatestCallback(onPinchEnd);
+  const hasPinchStart = onPinchStart !== void 0;
+  const hasPinchEnd = onPinchEnd !== void 0;
+  const built = useGestureMemo(
+    "usePinch",
+    () => {
+      const toPinchEvent = (event) => {
+        "worklet";
+        return {
+          scale: scale.value,
+          gestureScale: event.scale,
+          focal: focal.value,
+          velocity: event.velocity,
+          settled: clamp(scale.value, min, max),
+          pointers: event.numberOfPointers
+        };
+      };
+      const trackFocal = (event) => {
+        "worklet";
+        focal.value = { x: event.focalX, y: event.focalY };
+      };
+      const pinch = Gesture.Pinch().onBegin((event) => {
+        "worklet";
+        onBegin?.(toPinchEvent(event));
+      }).onStart((event) => {
+        "worklet";
+        startScale.value = event.scale === 0 ? scale.value : scale.value / event.scale;
+        trackFocal(event);
+        isActive.value = true;
+        if (hasPinchStart) {
+          scheduleOnRN(handlePinchStart, toPinchEvent(event));
+        }
+      }).onUpdate((event) => {
+        "worklet";
+        trackFocal(event);
+        scale.value = resist(
+          startScale.value * event.scale,
+          min,
+          max,
+          elastic
+        );
+        onUpdate?.(toPinchEvent(event));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (hasPinchEnd) {
+          scheduleOnRN(handlePinchEnd, toPinchEvent(event), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toPinchEvent(event), success);
+      });
+      if (hitSlop !== void 0) {
+        pinch.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        pinch.enabled(enabled);
+      }
+      return pinch;
+    },
+    [
+      min,
+      max,
+      elastic,
+      hitSlop,
+      enabled,
+      hasPinchStart,
+      hasPinchEnd,
+      handlePinchStart,
+      handlePinchEnd,
+      scale,
+      focal,
+      startScale,
+      isActive,
+      onBegin,
+      onUpdate,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { scale, focal, isActive }),
+    [built, scale, focal, isActive]
+  );
+}
+
+export { usePinch };