@rootnative/inertia 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -4,6 +4,84 @@ All notable changes to `@rootnative/inertia` are documented here. The format fol
 
 ## [Unreleased]
 
+## [0.0.10] - 2026-09-06
+
+### Changed
+
+- **`react-native-worklets` is a required peer, not an optional one.** Core imports `isWorkletFunction` from it without a guard in `transitions/easing.ts` and `values/useTransform.ts`, so the package never worked without it. The `optional: true` flag in `peerDependenciesMeta` is removed. A package manager now warns when the peer is missing instead of staying silent. The installation docs already list it as a peer, so no install step changes. Core also declares it as a devDependency, pinned to `~0.5.1` next to Reanimated `~4.1.1`; before, the workspace typecheck passed only because the example app hoisted it. Found by the `1.0.0` readiness audit (2026-09-05).
+
+- **`@testing-library/react-native` is declared as an optional peer (`>=13.0.0`).** The `@rootnative/inertia/testing` entry point imports its `render`, but no field in `package.json` said so. A consumer without the library got a bare module-not-found error from that subpath. It is optional because only that entry point needs it. The docs testing page now names the requirement. Found by the `1.0.0` readiness audit (2026-09-05).
+
+### Removed
+
+- **Breaking: `restSpeedThreshold` and `restDisplacementThreshold` are removed from `SpringTransition`.** Both keys were silently inert on every release since `0.0.1`. They are Reanimated 3 names: Reanimated 4 settles springs on an internal `energyThreshold`, its `SpringConfig` type does not have either key, and its runtime never reads them. Inertia forwarded both into `withSpring`, where they were ignored — a documented public key that did nothing, which is the defect class the `0.0.5` type narrowing exists to prevent. Found by the pre-`1.0.0` review of the transition vocabulary.
+
+  Migration: delete the two keys from any spring config. Their removal cannot change animation behavior, because they never had any. If a settle knob is needed later, Reanimated 4's `overshootClamping` / `energyThreshold` are the candidates, as a non-breaking addition.
+
+### Fixed
+
+- **`repeat: 0` (and any count below 1) runs the animation once instead of forever.** Reanimated's `withRepeat` reads a count of `0` or less as endless, and the resolver forwarded the count as given, so `repeat: 0` — the natural way to write "do not repeat" from a variable — looped without end. Counts below `1` are now treated as "run once", warn once in dev, and are not forwarded. `onAnimationEnd`'s iteration counter and `<Presence>`'s settle gate use the same rule through the new `repeatIterationsOf` helper, so the three cannot disagree. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`repeat.alternate` is no longer forwarded for a sequence, and an explicit `alternate: true` on a sequence warns.** Reanimated's `reverse` flag only swaps the wrapped animation's target, which a `withSequence` ignores — every pass restarts at the first step — so the flag never alternated a sequence. The resolver now passes `reverse: false` for sequences, the `RepeatConfig` docs state the limit, and the sequences page shows the working form: write the reverse steps into the sequence. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`<Presence>` no longer releases an exiting child early when its animation run is replaced mid-exit.** The settle counter that gates `safeToRemove` counted every callback, including the `finished: false` callbacks Reanimated fires for animations that a later effect run replaced. If the value-driving effect re-ran during an exit (a controller change, a reduce-motion flip), the replaced run drained its own counter and unmounted the child while the new run was still animating. Each run is now a token: the effect's cleanup marks the run done, and a superseded run's callbacks are ignored. Pinned by `phase3-audit.test.tsx`, which fails against the previous implementation. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **An `onAnimationEnd` handler added after mount is wired without waiting for the next animation change.** The callback factory skips callback installation when there is no handler and nothing to settle. A handler that went from `undefined` to defined on a later render was read through a ref, but no callback existed to read it, so it stayed silent until `animate` or `transition` changed. The effect is now also keyed on the handler's presence (not its identity — a changing handler still costs nothing). Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`useSpring` and `useBooleanSpring` honour reduced motion.** Under `<MotionConfig reducedMotion>` both hooks assign the target to the output directly, with no spring, on the plain-number path and the shared-value path. They were the only value-layer hooks that ignored the setting. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **Dev warnings fire once per misconfiguration, not once per render.** The unknown-variant warning (`animate="open"` with no matching variant), the unknown named-transition warning, the `<Presence>` keyless-child warning, the `useSpring` spring-only warning, and the `useInterpolatedStyle` range-length warning all went through a bare `console.warn` in render or in a per-render resolver, so a single mistake flooded the console. All now use `warnOnce`, keyed per distinct misconfiguration. `useSwipe`'s decay `releaseTransition` warning in `-gestures` is guarded the same way. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`useTouchDrag` no longer rebuilds its `PanResponder` when an inline callback changes identity.** `onDragStart` / `onDragEnd` / `onRelease` were dependencies of the responder memo, so `onRelease={(e) => ...}` written inline rebuilt the responder on every render. The callbacks are now read through a ref at call time; the responder depends only on the axis, constraint, and elastic scalars, and it always calls the latest callback. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`useShadow`, `useTransform`, and `useGestureLayer` no longer rebuild their worklet for inline literals.** `useShadow` re-parsed the `boxShadow` pairs on every render, `useTransform` captured a fresh `inputRange` / `outputRange` array, and `useGestureLayer` keyed its per-key table on the identity of each `states` layer object. Each render with inline literals — the documented way to call all three — produced a new UI-thread closure. All three now memoise on a structural signature (`stableSig`). Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`sideEffects: false` is now true.** The `focusVisible` input-modality tracker attached its web `document` listeners at import time, which is a side effect the package declared it did not have. The listeners now attach from a mount effect of the first component that tracks `focusVisible` (the `gesture` prop or `useGesture`). Mount time is early enough: the click that focuses an element lands on an element that is already mounted, so the preceding `mousedown` is observed. `installFocusVisibility` is exported from `./gestures` for the same purpose. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **A key added to `animate` after mount now animates on native.** The `useAnimatedStyle` worklet read the active key set through plain `useRef` objects. `react-native-worklets` clones a captured plain object once, when the worklet is first serialised, and in dev it freezes the original, so later writes to `.current` were dropped with a `Tried to modify key 'current'` warning. The worklet only ever saw the mount-time set: a parent that changed `animate={{ opacity: 1 }}` to `animate={{ opacity: 1, translateX: 120 }}` drove the `translateX` shared value, but the element did not move. The set now crosses to the UI thread through a shared value that is rewritten once per growth. The Jest mock runs the worklet on the JS thread and never showed the defect; it was confirmed and fixed against an Android emulator. Found by the `1.0.0` readiness audit (2026-09-05).
+
+- **`useSpring` follows a swapped `SharedValue` target.** The UI-thread reaction listed only the target kind and the spring config as dependencies, and an explicit list replaces Reanimated's closure-derived one. A caller that changed which shared value drives the spring kept the reaction wired to the first one. The current target is now in the list; a plain-number target maps to `null` there, so a changing number does not re-register the inert reaction. Found by the `1.0.0` readiness audit (2026-09-05).
+
+### Added
+
+- **`useTranslateStyle(x, y)` is exported from the root barrel.** The `transform: [{ translateX }, { translateY }]` animated style that `useTouchDrag`, `useDrag`, `usePan`, and `useSwipe` all return; the four hooks now share this one implementation. Use it directly when a custom gesture owns its own translation values. Documented in `docs/docs/api/hooks.md`. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`applyBounds(value, min, max, elastic)` is exported from the root barrel.** The worklet-safe clamp with optional rubber-band overshoot that `useTouchDrag` and `-gestures`' `useDrag` apply their `constraints` and `elastic` options through; the two hooks carried identical private copies. Documented in `docs/docs/api/hooks.md`. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- **`isTopLevelTransition(value)` is exported from the root barrel.** It is the structural discriminator the factory uses to tell a single `TransitionConfig` from a per-property map: every key must be a known config field. Custom animated components that accept both shapes need the same test; `'type' in transition` is wrong because `SpringTransition.type` is optional. The three adapter packages had that bug and now use this export; see `docs/docs/api/transition-utilities.md`.
+
+- **`stableSig(value)` is exported from the root barrel.** It is the order-independent structural signature the factory already keys its `transition` effects on. Custom animated components built on `resolveTransition` need the same thing: an inline `transition` literal is a new object every render, so an effect keyed on its identity restarts the animation each time the parent renders. The three adapter packages now use it for exactly that; see `docs/docs/api/transition-utilities.md`.
+
+- **Three types that already appeared in exported signatures are now exported.** `GestureLayerTransitions` (the per-layer form of a gesture `transition`; from the root and from `@rootnative/inertia/gesture-layer`), `CallbackFactory` (the third parameter of `resolveAnimatableValue`), and `MotionComponentProps` (the props of a `Motion.*` primitive for a given component, for typing a wrapper). Pinned by `__type-tests__/public-types.test-d.tsx`. Found by the `1.0.0` readiness audit (2026-09-05).
+
+- **Dev warning when `controller` and `animate` are set on the same primitive.** The controller drives the animation and `animate` is ignored; that precedence was documented but silent. It now warns once in dev.
+
+### Documentation
+
+- `useVariants` documents that the controller pins the variants map from the first render, and that later renders passing a different map object do not re-key it.
+
+- `RepeatConfig` and the sequences page document the count rule (total iterations, minimum `1`) and the `alternate` limit for sequences. `useSpring` documents that it honours reduced motion.
+
+### Internal
+
+- The adapter peer range on `@rootnative/inertia` now has an upper bound: `>=<version> <next-minor>` instead of `>=<version>`. Pre-`1.0.0`, a minor bump is where a breaking change lands, so an adapter at `0.0.x` must not accept core `0.1.0`. `scripts/check-versions.mjs` check 2 and both release workflows compute the same bound. Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- Duplicated code consolidated: `mapExtrapolation` (was in `useTransform` and `useInterpolatedStyle`) lives in `values/extrapolation.ts`; `DEFAULT_TIMING_DURATION` (250 ms, was declared in both `resolve.ts` and `runtime.ts`) and `DEFAULT_LAYOUT_DURATION` (300 ms, was a literal in two layout files) live in `transitions/constants.ts`; `buildReleaseAnimation` unwraps an `EasingFunctionFactory` through the same worklet helper `ensureWorkletEasing` uses (`unwrapEasingFactory`). Found by the `1.0.0` readiness audit (2026-09-05), Phase 3.
+
+- Tests added for the gaps the audit listed: `useVariants().transitionTo` driving a primitive, the `Motion.Image` runtime path, `useDrag`'s `onDragStart` and decay branch, `usePan`'s `withDecay` config, `MotionLinearGradient`'s locations-presence throw, and `MotionPath`'s `initial.d` mismatch throw.
+
+## [0.0.9] - 2026-08-22
+
+### Changed
+
+- **`useInterpolatedStyle` types its return against the map it was given, so a `style` array no longer needs a cast.** The hook returned `ReturnType<typeof useAnimatedStyle>`, which resolves to Reanimated's `DefaultStyle` — the union `ViewStyle | ImageStyle | TextStyle`. Assigning that union to a single style works, but a **style array** checks every member, and `TextStyle` is not assignable to `ViewStyle` (`cursor` is `string` there and `CursorValue` here). So the documented, dominant call shape — a transform/opacity fragment spread into `style={[base, fragment]}` — was a type error, and consumers cast it away.
+
+  The return is now `InterpolatedStyle<K>`, computed from the map's own keys: view keys satisfy `StyleProp<ViewStyle>`, text-metric keys (`fontSize`, `lineHeight`, `letterSpacing`) satisfy `StyleProp<TextStyle>`, `tintColor` satisfies `StyleProp<ImageStyle>`, and transform keys collapse into the single `transform` array the worklet emits. The narrowing is exact rather than permissive — a text-only fragment is still rejected from a `ViewStyle` slot, pinned in both directions by `__type-tests__/interpolated-style.test-d.tsx`.
+
+  Types only: no runtime change, and no bundle-size change. Removing a now-unnecessary `as ViewStyle` is safe; the cast remains harmless if left in place. `InterpolatedStyle` is exported from the root barrel.
+
+  Surfaced by the `reelist` validation consumer, and it is the independent-application half of the loop reporting its first library defect.
+
 ## [0.0.8] - 2026-08-16
 
 ### Added
@@ -273,7 +351,9 @@ Initial alpha publish. The full initial surface is in place; APIs are still subj
 - SVG path morphing, gradient interpolation, and shared-element transitions across screens are out of scope until `0.2.x` / `1.x` per the roadmap.
 - `react-native-gesture-handler` integration (drag, pan, swipe sub-states) lands in `0.2` via the optional `@rootnative/inertia-gestures` adapter.
 
-[unreleased]: https://github.com/rootnative/inertia/compare/core+gestures+gradients+svg@0.0.8...HEAD
+[unreleased]: https://github.com/rootnative/inertia/compare/core+gestures+gradients+svg@0.0.10...HEAD
+[0.0.10]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.10
+[0.0.9]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.9
 [0.0.8]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.8
 [0.0.7]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.7
 [0.0.6]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.6

package/README.md

@@ -12,7 +12,7 @@
 
 Declarative animation primitives for React Native, built as a thin wrapper around [`react-native-reanimated`](https://docs.swmansion.com/react-native-reanimated/). Inspired by Framer Motion (web) and react-spring (cross-platform).
 
-> **Status:** `0.0.8` — stable. Pre-`1.0.0` minor versions may break — see the root [README](https://github.com/rootnative/inertia#versioning--release).
+> **Status:** `0.0.10` — stable. Pre-`1.0.0` minor versions may break — see the [CHANGELOG](https://github.com/rootnative/inertia/blob/main/packages/core/CHANGELOG.md).
 
 ## Install
 
@@ -76,12 +76,12 @@ Both forms land at ~4.1–4.2 kB brotlied for a single primitive (peers excluded
 
 ## Transitions
 
-| `type`               | Public config keys                                                                           | Maps to                             |
-| -------------------- | -------------------------------------------------------------------------------------------- | ----------------------------------- |
-| `'spring'` (default) | `tension`, `friction`, `mass`, `velocity`, `restSpeedThreshold`, `restDisplacementThreshold` | `withSpring`                        |
-| `'timing'`           | `duration`, `easing`, `delay`                                                                | `withTiming`                        |
-| `'decay'`            | `velocity`, `deceleration`, `clamp`                                                          | `withDecay`                         |
-| `'no-animation'`     | —                                                                                            | direct assignment, no interpolation |
+| `type`               | Public config keys                        | Maps to                             |
+| -------------------- | ----------------------------------------- | ----------------------------------- |
+| `'spring'` (default) | `tension`, `friction`, `mass`, `velocity` | `withSpring`                        |
+| `'timing'`           | `duration`, `easing`, `delay`             | `withTiming`                        |
+| `'decay'`            | `velocity`, `deceleration`, `clamp`       | `withDecay`                         |
+| `'no-animation'`     | —                                         | direct assignment, no interpolation |
 
 Plus, on any transition: `delay`, `repeat`. Per-property transitions take precedence over the top-level transition. Spring config uses **react-spring vocabulary** (`tension`/`friction`); Reanimated's raw `stiffness`/`damping` is never on the public surface.
 

package/dist/applyBounds-BYGiHrYO.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Clamp `value` to `[min, max]`. When `elastic > 0` the overshoot past a
+ * bound is scaled by `elastic` instead of hard-clamped, giving a rubber-band
+ * feel. `min` / `max` may be `undefined` to leave that side unbounded.
+ *
+ * Worklet, so it runs both inside a gesture-handler pan handler on the UI
+ * thread (`useDrag`) and from a JS-thread `PanResponder` callback
+ * (`useTouchDrag`).
+ *
+ * ```ts
+ * applyBounds(120, -100, 100, 0)    // 100
+ * applyBounds(120, -100, 100, 0.5)  // 110
+ * applyBounds(50, undefined, 100, 0) // 50
+ * ```
+ */
+declare function applyBounds(value: number, min: number | undefined, max: number | undefined, elastic: number): number;
+
+export { applyBounds as a };

package/dist/applyBounds-BYGiHrYO.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Clamp `value` to `[min, max]`. When `elastic > 0` the overshoot past a
+ * bound is scaled by `elastic` instead of hard-clamped, giving a rubber-band
+ * feel. `min` / `max` may be `undefined` to leave that side unbounded.
+ *
+ * Worklet, so it runs both inside a gesture-handler pan handler on the UI
+ * thread (`useDrag`) and from a JS-thread `PanResponder` callback
+ * (`useTouchDrag`).
+ *
+ * ```ts
+ * applyBounds(120, -100, 100, 0)    // 100
+ * applyBounds(120, -100, 100, 0.5)  // 110
+ * applyBounds(50, undefined, 100, 0) // 50
+ * ```
+ */
+declare function applyBounds(value: number, min: number | undefined, max: number | undefined, elastic: number): number;
+
+export { applyBounds as a };

package/dist/{chunk-E3ALFSH2.js → chunk-2UGWAB6N.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunk6AN5X3YE_js = require('./chunk-6AN5X3YE.js');
-var chunkWNVHPMBI_js = require('./chunk-WNVHPMBI.js');
+var chunkKXU6VH2Y_js = require('./chunk-KXU6VH2Y.js');
+var chunkN33GSDNQ_js = require('./chunk-N33GSDNQ.js');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var Animated = require('react-native-reanimated');
@@ -45,11 +45,10 @@ function Presence({ children }) {
     react.Children.forEach(children, (child) => {
       if (!react.isValidElement(child)) return;
       if (child.key === null) {
-        if (__DEV__) {
-          console.warn(
-            "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
-          );
-        }
+        chunkN33GSDNQ_js.warnOnce(
+          "presence-keyless-child",
+          "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
+        );
         return;
       }
       out.push(child);
@@ -364,15 +363,17 @@ function resolveLayoutTransition(layout) {
   const cfg = layout === true ? { type: "spring" } : layout;
   if (cfg.type === "no-animation") return void 0;
   if (cfg.type === "timing") {
-    let builder2 = Animated.LinearTransition.duration(cfg.duration ?? 300);
-    const easing = chunkWNVHPMBI_js.ensureWorkletEasing(cfg.easing);
+    let builder2 = Animated.LinearTransition.duration(
+      cfg.duration ?? chunkN33GSDNQ_js.DEFAULT_LAYOUT_DURATION
+    );
+    const easing = chunkN33GSDNQ_js.ensureWorkletEasing(cfg.easing);
     if (easing) builder2 = builder2.easing(easing);
     if (cfg.delay) builder2 = builder2.delay(cfg.delay);
     return builder2;
   }
   const spring = cfg.type === "decay" ? { type: "spring" } : cfg;
-  const { stiffness, damping, mass } = chunkWNVHPMBI_js.springToReanimated({
-    ...chunkWNVHPMBI_js.DEFAULT_SPRING,
+  const { stiffness, damping, mass } = chunkN33GSDNQ_js.springToReanimated({
+    ...chunkN33GSDNQ_js.DEFAULT_SPRING,
     ...spring
   });
   let builder = Animated.LinearTransition.springify().stiffness(stiffness).damping(damping).mass(mass);
@@ -560,14 +561,14 @@ function useSharedLayout(options) {
 }
 function legBuilder(transition) {
   if (transition?.type === "timing") {
-    const duration = transition.duration ?? 300;
+    const duration = transition.duration ?? chunkN33GSDNQ_js.DEFAULT_LAYOUT_DURATION;
     return (from, to) => Animated.withSequence(
       Animated.withTiming(from, { duration: 0 }),
       Animated.withTiming(to, { duration })
     );
   }
-  const springCfg = transition?.type === "spring" ? { ...chunkWNVHPMBI_js.DEFAULT_SPRING, ...transition } : { type: "spring", ...chunkWNVHPMBI_js.DEFAULT_SPRING };
-  const springParams = chunkWNVHPMBI_js.springToReanimated(springCfg);
+  const springCfg = transition?.type === "spring" ? { ...chunkN33GSDNQ_js.DEFAULT_SPRING, ...transition } : { type: "spring", ...chunkN33GSDNQ_js.DEFAULT_SPRING };
+  const springParams = chunkN33GSDNQ_js.springToReanimated(springCfg);
   return (from, to) => Animated.withSequence(
     Animated.withTiming(from, { duration: 0 }),
     Animated.withSpring(to, springParams)
@@ -853,14 +854,14 @@ var DEFAULT_RESTING = {
 function transitionFor(prop, transition) {
   if (!transition) return void 0;
   if (typeof transition === "string") return void 0;
-  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
+  if (chunkN33GSDNQ_js.isTopLevelTransition(transition)) return transition;
   if (GESTURE_LAYER_NAME_SET.has(prop)) return void 0;
   return transition[prop];
 }
 function gestureLayerTransitionFor(layer, transition) {
   if (!transition) return void 0;
   if (typeof transition === "string") return void 0;
-  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
+  if (chunkN33GSDNQ_js.isTopLevelTransition(transition)) return transition;
   return transition[layer];
 }
 function createMotionComponent(Component) {
@@ -910,12 +911,12 @@ function createMotionComponent(Component) {
         onLayout: userOnLayout,
         ...rest
       } = props;
-      const namedTransitions = chunk6AN5X3YE_js.useNamedTransitions();
-      const transition = chunk6AN5X3YE_js.resolveNamedTransitionProp(
+      const namedTransitions = chunkKXU6VH2Y_js.useNamedTransitions();
+      const transition = chunkKXU6VH2Y_js.resolveNamedTransitionProp(
         transitionProp,
         namedTransitions
       );
-      const layout = typeof layoutProp === "string" ? chunk6AN5X3YE_js.lookupNamedTransition(layoutProp, namedTransitions) : layoutProp;
+      const layout = typeof layoutProp === "string" ? chunkKXU6VH2Y_js.lookupNamedTransition(layoutProp, namedTransitions) : layoutProp;
       if (__DEV__ && typeof style === "function") {
         throw new Error(
           "[inertia] `style` must be a style object or array of style objects, not a function. The function-form `style={(state) => ...}` Pressable API is not supported \u2014 use `gesture.pressed` (or `gesture.focused`, etc.) to drive state-dependent styling instead."
@@ -923,7 +924,7 @@ function createMotionComponent(Component) {
       }
       const presence = usePresence();
       const isExiting = presence !== null && presence.isPresent === false;
-      const shouldReduceMotion = chunk6AN5X3YE_js.useShouldReduceMotion();
+      const shouldReduceMotion = chunkKXU6VH2Y_js.useShouldReduceMotion();
       const staggerDelay = useStaggerDelay();
       const onAnimationEndRef = react.useRef(onAnimationEnd);
       onAnimationEndRef.current = onAnimationEnd;
@@ -980,11 +981,8 @@ function createMotionComponent(Component) {
           }
         }
       }
-      const activeKeysRef = react.useRef(null);
-      const hasTransformRef = react.useRef(false);
-      const hasShadowOffsetRef = react.useRef(false);
-      const hasBoxShadowRef = react.useRef(false);
-      const prevActive = activeKeysRef.current;
+      const activeSetRef = react.useRef(null);
+      const prevActive = activeSetRef.current?.keys ?? null;
       let grew = prevActive === null;
       if (!grew && prevActive) {
         for (const k of touched) {
@@ -997,30 +995,32 @@ function createMotionComponent(Component) {
       if (grew) {
         const merged = new Set(prevActive ?? []);
         for (const k of touched) merged.add(k);
-        activeKeysRef.current = ALL_KEYS.filter((k) => merged.has(k));
-        hasTransformRef.current = activeKeysRef.current.some(
-          (k) => TRANSFORM_KEY_SET.has(k)
-        );
-        hasShadowOffsetRef.current = activeKeysRef.current.some(
-          (k) => SHADOW_OFFSET_KEY_SET.has(k)
-        );
-        hasBoxShadowRef.current = activeKeysRef.current.includes("boxShadow");
-        if (__DEV__ && hasBoxShadowRef.current && activeKeysRef.current.some(
-          (k) => k !== "boxShadow" && k.startsWith("shadow")
-        )) {
-          chunkWNVHPMBI_js.warnOnce(
+        const keys = ALL_KEYS.filter((k) => merged.has(k));
+        activeSetRef.current = {
+          keys,
+          hasTransform: keys.some((k) => TRANSFORM_KEY_SET.has(k)),
+          hasShadowOffset: keys.some((k) => SHADOW_OFFSET_KEY_SET.has(k)),
+          hasBoxShadow: keys.includes("boxShadow")
+        };
+        if (__DEV__ && activeSetRef.current.hasBoxShadow && keys.some((k) => k !== "boxShadow" && k.startsWith("shadow"))) {
+          chunkN33GSDNQ_js.warnOnce(
             "boxShadow-with-native-shadow",
             "[inertia] `boxShadow` is animated alongside the native `shadow*` keys on the same element, which applies two shadow systems at once. Pick one: `boxShadow` for the cross-platform CSS form, or the native `shadow*` keys."
           );
         }
       }
+      const activeKeys = activeSetRef.current.keys;
+      const activeSetSV = Animated.useSharedValue(activeSetRef.current);
+      const activeSet = activeSetRef.current;
+      react.useEffect(() => {
+        if (activeSetSV.value !== activeSet) activeSetSV.value = activeSet;
+      }, [activeSetSV, activeSet]);
       const drivenNow = /* @__PURE__ */ new Set();
       collectTouchedKeys(drivenNow, animateRecord);
       if (initialRecord) collectTouchedKeys(drivenNow, initialRecord);
       if (isExiting && exitRecord) collectTouchedKeys(drivenNow, exitRecord);
       const everDrivenRef = react.useRef(/* @__PURE__ */ new Set());
       for (const k of drivenNow) everDrivenRef.current.add(k);
-      const activeKeys = activeKeysRef.current;
       const everDriven = everDrivenRef.current;
       const styleResting = {};
       let styleRestingShadow = null;
@@ -1076,9 +1076,9 @@ function createMotionComponent(Component) {
       const boxShadowInsets = Animated.useSharedValue(
         boxShadowSeedRef.current.insets
       );
-      const styleRestingSig = chunkWNVHPMBI_js.stableSig(styleResting);
+      const styleRestingSig = chunkN33GSDNQ_js.stableSig(styleResting);
       react.useEffect(() => {
-        for (const key of activeKeysRef.current) {
+        for (const key of activeKeys) {
           if (everDrivenRef.current.has(key)) continue;
           sharedValues[key].value = styleResting[key] ?? DEFAULT_RESTING[key];
           if (key === "boxShadow") {
@@ -1104,13 +1104,14 @@ function createMotionComponent(Component) {
       const gestureSV = Animated.useSharedValue(
         resolveGestureLayers(gesture)
       );
-      const gestureTargetsSig = chunkWNVHPMBI_js.stableSig(gesture);
+      const gestureTargetsSig = chunkN33GSDNQ_js.stableSig(gesture);
       react.useEffect(() => {
         gestureSV.value = resolveGestureLayers(gesture);
       }, [gestureTargetsSig]);
       const baseRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : animateRecord;
-      const baseSig = chunkWNVHPMBI_js.stableSig(baseRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
-      const transitionSig = chunkWNVHPMBI_js.stableSig(transition);
+      const baseSig = chunkN33GSDNQ_js.stableSig(baseRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
+      const transitionSig = chunkN33GSDNQ_js.stableSig(transition);
+      const hasAnimationEnd = onAnimationEnd !== void 0;
       const safeToRemoveRef = react.useRef(void 0);
       safeToRemoveRef.current = presence?.safeToRemove;
       react.useEffect(() => {
@@ -1185,8 +1186,8 @@ function createMotionComponent(Component) {
             isExiting ? onSettle : void 0,
             TRANSFORM_KEY_SET.has(key) ? transformGroup : void 0
           );
-          sharedValues[key].value = chunkWNVHPMBI_js.applyDelay(
-            chunkWNVHPMBI_js.resolveAnimatableValue(
+          sharedValues[key].value = chunkN33GSDNQ_js.applyDelay(
+            chunkN33GSDNQ_js.resolveAnimatableValue(
               COLOR_KEY_SET.has(key) ? normalizeAnimatableColorTarget(target) : target,
               cfg,
               factory
@@ -1197,7 +1198,10 @@ function createMotionComponent(Component) {
         if (isExiting && pending === 0) {
           safeToRemoveRef.current?.();
         }
-      }, [baseSig, transitionSig]);
+        return () => {
+          done = true;
+        };
+      }, [baseSig, transitionSig, hasAnimationEnd]);
       useGestureLayerProgress(
         pressedProgress,
         pressed,
@@ -1238,7 +1242,7 @@ function createMotionComponent(Component) {
         if (!hasLayoutId) return void 0;
         const out = {};
         let any = false;
-        for (const key of activeKeysRef.current) {
+        for (const key of activeKeys) {
           if (!SHARED_STYLE_KEY_SET.has(key)) continue;
           const v = sharedValues[key].value;
           if (typeof v !== "number" && typeof v !== "string") continue;
@@ -1250,7 +1254,7 @@ function createMotionComponent(Component) {
       const sharedLayout = useSharedLayout({
         layoutId,
         userRef: ref,
-        transition: chunkWNVHPMBI_js.isTopLevelTransition(transition) ? transition : void 0,
+        transition: chunkN33GSDNQ_js.isTopLevelTransition(transition) ? transition : void 0,
         shouldReduceMotion,
         userOnLayout,
         readStyles: readSharedStyles
@@ -1258,10 +1262,11 @@ function createMotionComponent(Component) {
       const flip = sharedLayout.flip;
       const carry = sharedLayout.carry;
       const animatedStyle = Animated.useAnimatedStyle(() => {
-        const activeKeys2 = activeKeysRef.current;
-        const hasTransform = hasTransformRef.current;
-        const hasShadowOffset = hasShadowOffsetRef.current;
-        const hasBoxShadow = hasBoxShadowRef.current;
+        const activeSet2 = activeSetSV.value;
+        const activeKeys2 = activeSet2.keys;
+        const hasTransform = activeSet2.hasTransform;
+        const hasShadowOffset = activeSet2.hasShadowOffset;
+        const hasBoxShadow = activeSet2.hasBoxShadow;
         const out = {};
         const transform = [];
         let shadowOffsetW = 0;
@@ -1352,7 +1357,7 @@ function createMotionComponent(Component) {
         setFocusVisible,
         setHovered
       );
-      const layoutSig = chunkWNVHPMBI_js.stableSig(layout);
+      const layoutSig = chunkN33GSDNQ_js.stableSig(layout);
       const layoutTransition = react.useMemo(
         () => shouldReduceMotion ? void 0 : resolveLayoutTransition(layout),
         // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -1501,8 +1506,8 @@ function driveBoxShadow(slot, insetSlot, target, cfg, staggerDelay, factory) {
   );
   insetSlot.value = insets;
   if (from.length !== currentLayers.length) slot.value = layersToPayload(from);
-  slot.value = chunkWNVHPMBI_js.applyDelay(
-    chunkWNVHPMBI_js.resolveTransition(
+  slot.value = chunkN33GSDNQ_js.applyDelay(
+    chunkN33GSDNQ_js.resolveTransition(
       cfg,
       layersToPayload(to),
       factory?.("animation", void 0)
@@ -1560,12 +1565,7 @@ function stepCountOf(v) {
 }
 function totalIterationsOf(cfg) {
   if (!cfg || cfg.type === "no-animation" || cfg.type === "decay") return 1;
-  const r = cfg.repeat;
-  if (r === void 0) return 1;
-  if (r === "infinite") return Number.POSITIVE_INFINITY;
-  if (typeof r === "number") return r;
-  if (r.count === "infinite") return Number.POSITIVE_INFINITY;
-  return r.count;
+  return chunkN33GSDNQ_js.repeatIterationsOf(cfg.repeat);
 }
 function reachesTerminalPhase(cfg) {
   return Number.isFinite(totalIterationsOf(cfg));
@@ -1592,16 +1592,21 @@ function useControllerKey(controller) {
   return controller?.current;
 }
 function resolveAnimateInput(animate, variants, controllerKey) {
+  if (controllerKey !== void 0 && animate !== void 0) {
+    chunkN33GSDNQ_js.warnOnce(
+      "controller-and-animate",
+      "[inertia] Both `controller` and `animate` are set on the same primitive. The controller drives the animation and `animate` is ignored \u2014 remove one of the two."
+    );
+  }
   if (controllerKey !== void 0 && variants && controllerKey in variants) {
     return variants[controllerKey];
   }
   if (typeof animate === "string") {
     if (variants && animate in variants) return variants[animate];
-    if (__DEV__) {
-      console.warn(
-        `[inertia] animate="${animate}" but no matching variant. Did you forget to pass \`variants\`?`
-      );
-    }
+    chunkN33GSDNQ_js.warnOnce(
+      `missing-variant:${animate}`,
+      `[inertia] animate="${animate}" but no matching variant. Did you forget to pass \`variants\`?`
+    );
     return void 0;
   }
   return animate;
@@ -1628,7 +1633,7 @@ function resolveGestureLayers(gesture) {
     for (const key of ALL_KEYS) {
       if (STRUCTURED_KEY_SET.has(key)) {
         if (__DEV__ && subState[key] !== void 0) {
-          chunkWNVHPMBI_js.warnOnce(
+          chunkN33GSDNQ_js.warnOnce(
             `gesture-structured-${layer}-${key}`,
             `[inertia] \`${key}\` is not supported inside \`gesture.${layer}\` and will be ignored. Drive it from \`animate\` (optionally via a variant keyed off the same state), or interpolate it yourself with \`useShadow\`.`
           );
@@ -1652,7 +1657,7 @@ function resolveGestureLayers(gesture) {
   return out;
 }
 function useGestureLayerProgress(progress, active, declared, layer, transition, isExiting, shouldReduceMotion) {
-  const layerCfgSig = chunkWNVHPMBI_js.stableSig(gestureLayerTransitionFor(layer, transition));
+  const layerCfgSig = chunkN33GSDNQ_js.stableSig(gestureLayerTransitionFor(layer, transition));
   react.useEffect(() => {
     if (!declared) return;
     if (isExiting) {
@@ -1661,7 +1666,7 @@ function useGestureLayerProgress(progress, active, declared, layer, transition,
     }
     const target = active ? 1 : 0;
     const cfg = shouldReduceMotion ? { type: "no-animation" } : gestureLayerTransitionFor(layer, transition) ?? { type: "spring" };
-    progress.value = chunkWNVHPMBI_js.resolveTransition(cfg, target);
+    progress.value = chunkN33GSDNQ_js.resolveTransition(cfg, target);
   }, [active, declared, isExiting, shouldReduceMotion, layerCfgSig]);
 }
 function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisible, setHovered) {
@@ -1669,6 +1674,9 @@ function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisib
   const hasFocused = gesture?.focused ? 1 : 0;
   const hasFocusVisible = gesture?.focusVisible ? 1 : 0;
   const hasHovered = gesture?.hovered ? 1 : 0;
+  react.useEffect(() => {
+    if (hasFocusVisible) chunkKXU6VH2Y_js.installFocusVisibility();
+  }, [hasFocusVisible]);
   return react.useMemo(() => {
     if (!gesture) return {};
     const handlers = {};
@@ -1694,7 +1702,7 @@ function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisib
     if (gesture.focused || gesture.focusVisible) {
       handlers.onFocus = compose(rest.onFocus, () => {
         if (gesture.focused) setFocused(true);
-        if (gesture.focusVisible && chunk6AN5X3YE_js.isFocusVisible()) setFocusVisible(true);
+        if (gesture.focusVisible && chunkKXU6VH2Y_js.isFocusVisible()) setFocusVisible(true);
       });
       handlers.onBlur = compose(rest.onBlur, () => {
         if (gesture.focused) setFocused(false);

package/dist/{chunk-ZBHQPVWE.js → chunk-3ZNHPT5Z.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
+var chunk2UGWAB6N_js = require('./chunk-2UGWAB6N.js');
 var reactNative = require('react-native');
 
-var MotionScrollView = chunkE3ALFSH2_js.createMotionComponent(reactNative.ScrollView);
+var MotionScrollView = chunk2UGWAB6N_js.createMotionComponent(reactNative.ScrollView);
 
 exports.MotionScrollView = MotionScrollView;

package/dist/{chunk-IHVMNOS4.js → chunk-46766TBM.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
+var chunk2UGWAB6N_js = require('./chunk-2UGWAB6N.js');
 var Animated = require('react-native-reanimated');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Animated__default = /*#__PURE__*/_interopDefault(Animated);
 
-var MotionFlatList = chunkE3ALFSH2_js.createMotionComponent(
+var MotionFlatList = chunk2UGWAB6N_js.createMotionComponent(
   Animated__default.default.FlatList
   // `createMotionComponent<C>` returns a non-generic `MotionComponent<C>`, so
   // `data` / `renderItem` would collapse to `any` and lose `ItemT` inference.

package/dist/{chunk-MUT6BTZS.js → chunk-4EZ5DBL3.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunk6AN5X3YE_js = require('./chunk-6AN5X3YE.js');
-var chunkWNVHPMBI_js = require('./chunk-WNVHPMBI.js');
+var chunkKXU6VH2Y_js = require('./chunk-KXU6VH2Y.js');
+var chunkN33GSDNQ_js = require('./chunk-N33GSDNQ.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 
@@ -10,12 +10,15 @@ function useGesture(transition) {
   const focused = reactNativeReanimated.useSharedValue(0);
   const focusVisible = reactNativeReanimated.useSharedValue(0);
   const hovered = reactNativeReanimated.useSharedValue(0);
-  const shouldReduceMotion = chunk6AN5X3YE_js.useShouldReduceMotion();
-  const resolved = chunk6AN5X3YE_js.resolveNamedTransitionProp(transition, chunk6AN5X3YE_js.useNamedTransitions());
+  const shouldReduceMotion = chunkKXU6VH2Y_js.useShouldReduceMotion();
+  const resolved = chunkKXU6VH2Y_js.resolveNamedTransitionProp(transition, chunkKXU6VH2Y_js.useNamedTransitions());
+  react.useEffect(() => {
+    chunkKXU6VH2Y_js.installFocusVisibility();
+  }, []);
   const setLayer = react.useCallback(
     (sv, layer, target) => {
       const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
-      sv.value = chunkWNVHPMBI_js.resolveTransition(cfg, target);
+      sv.value = chunkN33GSDNQ_js.resolveTransition(cfg, target);
     },
     // The transition is intentionally read on every call rather than cooked
     // into the dep array — a fresh literal each render would otherwise
@@ -34,7 +37,7 @@ function useGesture(transition) {
       onHoverOut: () => setLayer(hovered, "hovered", 0),
       onFocus: () => {
         setLayer(focused, "focused", 1);
-        if (chunk6AN5X3YE_js.isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
+        if (chunkKXU6VH2Y_js.isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
       },
       onBlur: () => {
         setLayer(focused, "focused", 0);
@@ -47,7 +50,7 @@ function useGesture(transition) {
 }
 function layerTransition(layer, transition) {
   if (!transition) return void 0;
-  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
+  if (chunkN33GSDNQ_js.isTopLevelTransition(transition)) return transition;
   return transition[layer];
 }