@rootnative/inertia 0.0.9 → 0.0.11

package/CHANGELOG.md

@@ -4,6 +4,98 @@ All notable changes to `@rootnative/inertia` are documented here. The format fol
 
 ## [Unreleased]
 
+## [0.0.11] - 2026-09-09
+
+### Changed
+
+- **Breaking: the peer ranges are narrowed to the Expo SDK 57 band.** `react` is now `>=19.2.3 <20.0.0`, `react-native` is `>=0.83.0 <0.87.0`, `react-native-reanimated` is `>=4.5.0 <4.6.0`, and `react-native-worklets` is `>=0.10.0 <0.11.0`. The old ranges advertised a floor that npm rejects. `0.0.10` declares `react-native >=0.81.0` and `react-native-reanimated >=4.0.0`, and the newest Reanimated that range admits requires `react-native 0.83 - 0.87`, so a fresh install can fail with `ERESOLVE`. Nothing in this repository changed when that became true — Reanimated narrowed its own range after the release, which is why a range needs a gate that re-checks it and not only a review at the time it is written.
+
+  The band cannot be wider. Each peer range resolves on its own, so any set that admits both SDK 54 (`react-native 0.81` with Reanimated `4.1`) and SDK 57 (`react-native 0.86` with Reanimated `4.5`) also admits `react-native 0.81` with Reanimated `4.6`, which cannot install. A range promises every combination it permits, not only the combinations that were tested.
+
+  A new `compat.yml` workflow now packs the release candidate and installs it into every Expo SDK fixture in `rootnative/sdk-compat` before the publish, with `enforce-range: true`. The test suite in this repository says nothing about what a consumer can install, and that gap is what let the `0.0.10` range ship.
+
+  Migration: move the app to Expo SDK 57 (React `19.2.3`, React Native `0.86.3`, Reanimated `4.5.1`, Worklets `0.10.1`). A project on SDK 54 stays on `0.0.10`. The dev pins and the example app moved to the same band, so the package now develops against the runtime it declares. `sdk-compat` records SDK 54 as a documented boundary, not as a failure.
+
+- **`@rootnative/inertia/jest-preset` needs `@react-native/jest-preset` in the consuming project.** React Native `0.86` moved its Jest preset into that package and left `react-native/jest-preset` as a shim that re-exports it. The shim declares the new package as an **optional** peer, and no package manager installs an optional peer, so the shim throws a migration error for every consumer who did not add the package by hand. The preset now resolves `@react-native/jest-preset` directly and throws a named error that says what to install, so the failure states this package's requirement instead of surfacing as a React Native migration message. Add it as a devDependency at the version that matches your `react-native`. The docs testing page carries the install step and the new `preset` spelling.
+
+  The package is deliberately **not** a peer dependency here. React Native pins it to an exact version — `0.86.3` requires exactly `@react-native/jest-preset@0.86.3` — so any range declared in this package would advertise versions that cannot install, and the `sdk-compat` range audit fails on it. An exact pin would break on every React Native patch. The version relationship belongs to `react-native`, which already declares it.
+
+### Added
+
+- **Three style types are exported: `ColorStyle`, `TranslateStyle` and `ShadowStyle`.** They are what `useColorTransition`, `useColorCascade`, `useTranslateStyle` and `useShadow` return. Each hook was public while the type of the style object it hands back was not, so a consumer could not name the value in a typed variable, a prop, or a wrapper hook's signature without rebuilding the type by hand.
+
+### Fixed
+
+- **A keyframe array no longer crashes the whole render under reduced motion.** `withSequence` writes a `finished` flag onto every argument it is handed. Reduced motion collapses each step to `no-animation`, and `no-animation` resolves to the bare target rather than an animation object, so `animate={{ translateY: [0, -8, 0] }}` reached `withSequence(0, -8, 0)` and threw `TypeError: Cannot create property 'finished' on number` from inside render. React unmounted the tree, so any consumer using the documented keyframe form — the shape in this package's own `llms.txt` — served a blank page to every visitor with reduce-motion switched on at the OS level. The resolver now settles the property on the last keyframe instead of building a sequence, which is where the sequence would have ended; `repeat` and `delay` were already dropped for `no-animation`, so nothing is left pending. A per-step `{ type: 'no-animation' }` inside a sequence that otherwise animates hit the same throw and now becomes a zero-length timing, keeping its slot in the order.
+
+  Found from a consumer, not from CI, and the reason is worth keeping: **the Jest mock cannot observe this class of bug.** Its `withSequence` is `(...args) => args[args.length - 1]` and its `withTiming` / `withSpring` return their target, so every step looks like a bare value whether the gate is on or off — the existing reduced-motion sequence tests passed against the crashing code. The regression tests therefore assert the one thing that stays observable under the mock: a sequence under the gate never reaches `withSequence` at all. For the same reason the gate is now detected from the resolved config (`no-animation` base), never by inspecting the shape of a resolved step.
+
+## [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
@@ -285,7 +377,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.9...HEAD
+[unreleased]: https://github.com/rootnative/inertia/compare/core+gestures+gradients+svg@0.0.11...HEAD
+[0.0.11]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.11
+[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

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.9` — stable. Pre-`1.0.0` minor versions may break — see the root [README](https://github.com/rootnative/inertia#versioning--release).
+> **Status:** `0.0.11` — stable. Pre-`1.0.0` minor versions may break — see the [CHANGELOG](https://github.com/rootnative/inertia/blob/main/packages/core/CHANGELOG.md).
 
 ## Install
 
@@ -22,7 +22,7 @@ pnpm add @rootnative/inertia react-native-reanimated
 
 Then enable the [Reanimated Babel plugin](https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation).
 
-**Peer dependencies:** `react >=19.0.0`, `react-native >=0.81.0`, `react-native-reanimated >=4.0.0`.
+**Peer dependencies:** `react >=19.2.3`, `react-native >=0.83.0 <0.87.0`, `react-native-reanimated >=4.5.0 <4.6.0`, `react-native-worklets >=0.10.0 <0.11.0`.
 
 ## Quick start
 
@@ -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/{chunk-MFAFB4K7.mjs → chunk-2Q6JMDYZ.mjs}

@@ -1,4 +1,4 @@
-import { stableSig, isTopLevelTransition } from './chunk-W7NTRSPD.mjs';
+import { stableSig, warnOnce, isTopLevelTransition } from './chunk-QIRKPDXA.mjs';
 import { createContext, useContext, useMemo } from 'react';
 import { useReducedMotion } from 'react-native-reanimated';
 import { jsx } from 'react/jsx-runtime';
@@ -47,11 +47,10 @@ var UNKNOWN_NAME_FALLBACK = { type: "spring" };
 function lookupNamedTransition(name, registry) {
   const cfg = registry[name];
   if (cfg) return cfg;
-  if (__DEV__) {
-    console.warn(
-      `[inertia] Unknown transition name "${name}" \u2014 falling back to the default spring. Register it on a provider: <MotionConfig transitions={{ '${name}': { ... } }}>.`
-    );
-  }
+  warnOnce(
+    `unknown-transition:${name}`,
+    `[inertia] Unknown transition name "${name}" \u2014 falling back to the default spring. Register it on a provider: <MotionConfig transitions={{ '${name}': { ... } }}>.`
+  );
   return UNKNOWN_NAME_FALLBACK;
 }
 function resolveNamedTransition(input, registry) {
@@ -84,7 +83,7 @@ function setKeyboard() {
 function setPointer() {
   modality = "pointer";
 }
-function ensureInstalled() {
+function installFocusVisibility() {
   if (installed) return;
   if (Platform.OS !== "web") return;
   if (typeof document === "undefined") return;
@@ -94,11 +93,10 @@ function ensureInstalled() {
   document.addEventListener("touchstart", setPointer, true);
   installed = true;
 }
-ensureInstalled();
 function isFocusVisible() {
   if (Platform.OS !== "web") return true;
-  ensureInstalled();
+  installFocusVisibility();
   return modality === "keyboard";
 }
 
-export { MotionConfig, isFocusVisible, lookupNamedTransition, resolveNamedTransition, resolveNamedTransitionProp, useMotionConfig, useNamedTransitions, useShouldReduceMotion };
+export { MotionConfig, installFocusVisibility, isFocusVisible, lookupNamedTransition, resolveNamedTransition, resolveNamedTransitionProp, useMotionConfig, useNamedTransitions, useShouldReduceMotion };

package/dist/chunk-2UREDR4Z.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunkHBURWGCZ_js = require('./chunk-HBURWGCZ.js');
+var reactNative = require('react-native');
+
+var MotionView = chunkHBURWGCZ_js.createMotionComponent(reactNative.View);
+
+exports.MotionView = MotionView;

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

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

package/dist/{chunk-IX6SEOSK.mjs → chunk-5EYIZG72.mjs}

@@ -1,5 +1,5 @@
-import { useNamedTransitions, resolveNamedTransitionProp, lookupNamedTransition, useShouldReduceMotion, isFocusVisible } from './chunk-MFAFB4K7.mjs';
-import { warnOnce, stableSig, applyDelay, resolveAnimatableValue, isTopLevelTransition, resolveTransition, ensureWorkletEasing, springToReanimated, DEFAULT_SPRING } from './chunk-W7NTRSPD.mjs';
+import { useNamedTransitions, resolveNamedTransitionProp, lookupNamedTransition, useShouldReduceMotion, installFocusVisibility, isFocusVisible } from './chunk-2Q6JMDYZ.mjs';
+import { warnOnce, stableSig, applyDelay, resolveAnimatableValue, isTopLevelTransition, resolveTransition, repeatIterationsOf, DEFAULT_LAYOUT_DURATION, ensureWorkletEasing, springToReanimated, DEFAULT_SPRING } from './chunk-QIRKPDXA.mjs';
 import { createContext, useContext, useMemo, Children, isValidElement, useState, useRef, useCallback, forwardRef, useEffect } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import Animated, { useSharedValue, cancelAnimation, useAnimatedStyle, interpolateColor, reanimatedVersion, runOnJS, LinearTransition, withSequence, withTiming, withSpring } from 'react-native-reanimated';
@@ -39,11 +39,10 @@ function Presence({ children }) {
     Children.forEach(children, (child) => {
       if (!isValidElement(child)) return;
       if (child.key === null) {
-        if (__DEV__) {
-          console.warn(
-            "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
-          );
-        }
+        warnOnce(
+          "presence-keyless-child",
+          "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
+        );
         return;
       }
       out.push(child);
@@ -261,7 +260,7 @@ function resolveBoxShadowInput(input) {
     offsetY: coerceLength(layer.offsetY, "offsetY"),
     blurRadius: coerceLength(layer.blurRadius, "blurRadius"),
     spreadDistance: coerceLength(layer.spreadDistance, "spreadDistance"),
-    color: layer.color ?? "black",
+    color: coerceColor(layer.color),
     inset: layer.inset ?? false
   }));
 }
@@ -292,6 +291,13 @@ function invisibleLayer(inset) {
     inset
   };
 }
+function coerceColor(value) {
+  if (value === void 0) return "black";
+  if (typeof value === "string") return value;
+  throw new Error(
+    `[inertia] boxShadow: color must be a colour string, got ${typeof value}. PlatformColor and DynamicColorIOS values cannot be interpolated \u2014 pass a string colour on an animated shadow.`
+  );
+}
 function coerceLength(value, field) {
   if (value === void 0) return 0;
   if (typeof value === "number") return value;
@@ -358,7 +364,9 @@ function resolveLayoutTransition(layout) {
   const cfg = layout === true ? { type: "spring" } : layout;
   if (cfg.type === "no-animation") return void 0;
   if (cfg.type === "timing") {
-    let builder2 = LinearTransition.duration(cfg.duration ?? 300);
+    let builder2 = LinearTransition.duration(
+      cfg.duration ?? DEFAULT_LAYOUT_DURATION
+    );
     const easing = ensureWorkletEasing(cfg.easing);
     if (easing) builder2 = builder2.easing(easing);
     if (cfg.delay) builder2 = builder2.delay(cfg.delay);
@@ -554,7 +562,7 @@ function useSharedLayout(options) {
 }
 function legBuilder(transition) {
   if (transition?.type === "timing") {
-    const duration = transition.duration ?? 300;
+    const duration = transition.duration ?? DEFAULT_LAYOUT_DURATION;
     return (from, to) => withSequence(
       withTiming(from, { duration: 0 }),
       withTiming(to, { duration })
@@ -974,11 +982,8 @@ function createMotionComponent(Component) {
           }
         }
       }
-      const activeKeysRef = useRef(null);
-      const hasTransformRef = useRef(false);
-      const hasShadowOffsetRef = useRef(false);
-      const hasBoxShadowRef = useRef(false);
-      const prevActive = activeKeysRef.current;
+      const activeSetRef = useRef(null);
+      const prevActive = activeSetRef.current?.keys ?? null;
       let grew = prevActive === null;
       if (!grew && prevActive) {
         for (const k of touched) {
@@ -991,30 +996,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")
-        )) {
+        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"))) {
           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 = useSharedValue(activeSetRef.current);
+      const activeSet = activeSetRef.current;
+      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 = 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;
@@ -1072,7 +1079,7 @@ function createMotionComponent(Component) {
       );
       const styleRestingSig = stableSig(styleResting);
       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") {
@@ -1105,6 +1112,7 @@ function createMotionComponent(Component) {
       const baseRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : animateRecord;
       const baseSig = stableSig(baseRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
       const transitionSig = stableSig(transition);
+      const hasAnimationEnd = onAnimationEnd !== void 0;
       const safeToRemoveRef = useRef(void 0);
       safeToRemoveRef.current = presence?.safeToRemove;
       useEffect(() => {
@@ -1191,7 +1199,10 @@ function createMotionComponent(Component) {
         if (isExiting && pending === 0) {
           safeToRemoveRef.current?.();
         }
-      }, [baseSig, transitionSig]);
+        return () => {
+          done = true;
+        };
+      }, [baseSig, transitionSig, hasAnimationEnd]);
       useGestureLayerProgress(
         pressedProgress,
         pressed,
@@ -1232,7 +1243,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;
@@ -1252,10 +1263,11 @@ function createMotionComponent(Component) {
       const flip = sharedLayout.flip;
       const carry = sharedLayout.carry;
       const animatedStyle = 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;
@@ -1554,12 +1566,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 repeatIterationsOf(cfg.repeat);
 }
 function reachesTerminalPhase(cfg) {
   return Number.isFinite(totalIterationsOf(cfg));
@@ -1586,16 +1593,21 @@ function useControllerKey(controller) {
   return controller?.current;
 }
 function resolveAnimateInput(animate, variants, controllerKey) {
+  if (controllerKey !== void 0 && animate !== void 0) {
+    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\`?`
-      );
-    }
+    warnOnce(
+      `missing-variant:${animate}`,
+      `[inertia] animate="${animate}" but no matching variant. Did you forget to pass \`variants\`?`
+    );
     return void 0;
   }
   return animate;
@@ -1663,6 +1675,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;
+  useEffect(() => {
+    if (hasFocusVisible) installFocusVisibility();
+  }, [hasFocusVisible]);
   return useMemo(() => {
     if (!gesture) return {};
     const handlers = {};

package/dist/{chunk-EN4PN7X3.mjs → chunk-7RMSLKQQ.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
+import { createMotionComponent } from './chunk-5EYIZG72.mjs';
 import Animated from 'react-native-reanimated';
 
 var MotionFlatList = createMotionComponent(

package/dist/{chunk-6YIUETBF.mjs → chunk-DT2KVAAO.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
+import { createMotionComponent } from './chunk-5EYIZG72.mjs';
 import { Image } from 'react-native';
 
 var MotionImage = createMotionComponent(Image);

package/dist/{chunk-L4JFECXU.mjs → chunk-FKJLPYGY.mjs}

@@ -1,6 +1,6 @@
-import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions, isFocusVisible } from './chunk-MFAFB4K7.mjs';
-import { resolveTransition, isTopLevelTransition } from './chunk-W7NTRSPD.mjs';
-import { useCallback, useMemo } from 'react';
+import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions, installFocusVisibility, isFocusVisible } from './chunk-2Q6JMDYZ.mjs';
+import { resolveTransition, isTopLevelTransition } from './chunk-QIRKPDXA.mjs';
+import { useEffect, useCallback, useMemo } from 'react';
 import { useSharedValue } from 'react-native-reanimated';
 
 function useGesture(transition) {
@@ -10,6 +10,9 @@ function useGesture(transition) {
   const hovered = useSharedValue(0);
   const shouldReduceMotion = useShouldReduceMotion();
   const resolved = resolveNamedTransitionProp(transition, useNamedTransitions());
+  useEffect(() => {
+    installFocusVisibility();
+  }, []);
   const setLayer = useCallback(
     (sv, layer, target) => {
       const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };