@rootnative/inertia 0.0.8 → 0.0.10

package/src/transitions/easing.ts

@@ -2,7 +2,11 @@
 // dep); Reanimated's own re-export is deprecated.
 import { isWorkletFunction } from 'react-native-worklets'
 import { warnNonWorkletOnce } from '../internal/nonWorkletWarning'
-import { type EasingInput } from '../types'
+import {
+  type EasingFunction,
+  type EasingFunctionFactory,
+  type EasingInput,
+} from '../types'
 
 /**
  * Reanimated 3.9+ validates that easing functions used in nested-transition
@@ -33,7 +37,7 @@ export function ensureWorkletEasing(
   // Reanimated 4 `EasingFunctionFactory` — unwrap via `.factory()` before
   // checking worklet status, so the wrapped fn (not the factory wrapper)
   // ends up in the transition config.
-  const fn = isEasingFactory(easing) ? easing.factory() : easing
+  const fn = unwrapEasingFactory(easing)
   if (isWorkletFunction(fn)) return fn
   warnNonWorkletOnce(
     'timing-easing',
@@ -46,13 +50,21 @@ export function ensureWorkletEasing(
   return wrapped
 }
 
-function isEasingFactory(
-  value: EasingInput,
-): value is { factory: () => (t: number) => number } {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'factory' in value &&
-    typeof (value as { factory: unknown }).factory === 'function'
-  )
+/**
+ * Return the easing function behind an `EasingInput`: a Reanimated 4
+ * `EasingFunctionFactory` is unwrapped through `.factory()`, a plain function
+ * passes through. Worklet, so `buildReleaseAnimation` can call it from a
+ * gesture `onEnd` handler on the UI thread.
+ */
+export function unwrapEasingFactory(easing: EasingInput): EasingFunction {
+  'worklet'
+  if (
+    typeof easing === 'object' &&
+    easing !== null &&
+    'factory' in easing &&
+    typeof (easing as { factory: unknown }).factory === 'function'
+  ) {
+    return (easing as EasingFunctionFactory).factory()
+  }
+  return easing as EasingFunction
 }

package/src/transitions/index.ts

@@ -1,9 +1,14 @@
 export {
   applyDelay,
+  applyRepeat,
+  normalizeRepeat,
+  repeatIterationsOf,
   resolveTransition,
   type AnimationCallback,
   type CallbackFactory,
+  type NormalizedRepeat,
 } from './resolve'
+export { DEFAULT_LAYOUT_DURATION, DEFAULT_TIMING_DURATION } from './constants'
 export { resolveAnimatableValue } from './resolveSequence'
 export { cubicBezier } from './cubicBezier'
 export { ensureWorkletEasing } from './easing'

package/src/transitions/keys.ts

@@ -14,8 +14,6 @@ export const TRANSITION_CONFIG_KEYS = new Set([
   'friction',
   'mass',
   'velocity',
-  'restSpeedThreshold',
-  'restDisplacementThreshold',
   'duration',
   'easing',
   'delay',

package/src/transitions/resolve.ts

@@ -6,8 +6,10 @@ import {
   withSpring,
   withTiming,
 } from 'react-native-reanimated'
+import { DEFAULT_TIMING_DURATION } from './constants'
 import { ensureWorkletEasing } from './easing'
 import { springToReanimated } from './spring'
+import { warnOnce } from '../internal/warnOnce'
 import {
   type DecayTransition,
   type RepeatConfig,
@@ -37,8 +39,6 @@ export type CallbackFactory = (
   step: number | undefined,
 ) => AnimationCallback | undefined
 
-const DEFAULT_TIMING_DURATION = 250
-
 function buildSpring(
   cfg: SpringTransition,
   toValue: number | string,
@@ -94,26 +94,101 @@ function buildOne(
   return buildSpring(cfg as SpringTransition, toValue, cb)
 }
 
+/**
+ * Normalised repeat: `count` is the total number of iterations
+ * (`Number.POSITIVE_INFINITY` for `'infinite'`), `alternate` is the resolved
+ * flag, `explicitAlternate` says whether the caller set `alternate` by hand.
+ */
+export interface NormalizedRepeat {
+  count: number
+  alternate: boolean
+  explicitAlternate: boolean
+}
+
+/**
+ * Reduce the three public `repeat` shapes to one record, or `undefined` when
+ * the animation runs once. A count below `1` is treated as "run once" and
+ * warns in dev: Reanimated's `withRepeat` reads `0` and negative counts as
+ * endless, so forwarding them would turn `repeat: 0` into an infinite loop.
+ */
+export function normalizeRepeat(
+  repeat: RepeatConfig | undefined,
+): NormalizedRepeat | undefined {
+  if (repeat === undefined) return undefined
+  if (repeat === 'infinite') {
+    return {
+      count: Number.POSITIVE_INFINITY,
+      alternate: true,
+      explicitAlternate: false,
+    }
+  }
+  const rawCount = typeof repeat === 'number' ? repeat : repeat.count
+  const alternate = typeof repeat === 'number' ? true : repeat.alternate
+  if (rawCount === 'infinite') {
+    return {
+      count: Number.POSITIVE_INFINITY,
+      alternate: alternate ?? true,
+      explicitAlternate: alternate !== undefined,
+    }
+  }
+  if (!(rawCount >= 1)) {
+    warnOnce(
+      `repeat-count:${String(rawCount)}`,
+      `[inertia] repeat count ${String(rawCount)} is below 1 — the ` +
+        `animation runs once. Use \`repeat: 2\` or more to repeat, or ` +
+        `\`repeat: 'infinite'\`. (Reanimated reads a count of 0 as endless, ` +
+        `so it is not forwarded.)`,
+    )
+    return undefined
+  }
+  return {
+    count: rawCount,
+    alternate: alternate ?? true,
+    explicitAlternate: alternate !== undefined,
+  }
+}
+
+/**
+ * Total number of iterations an animation built from `repeat` runs, including
+ * the first pass. `1` when there is no repeat or the count is below 1;
+ * `Number.POSITIVE_INFINITY` for `'infinite'`.
+ */
+export function repeatIterationsOf(repeat: RepeatConfig | undefined): number {
+  return normalizeRepeat(repeat)?.count ?? 1
+}
+
 /**
  * Wrap an animation in `withRepeat` per the unified `repeat` shape:
  *   - `number`              → finite count, alternating direction
  *   - `'infinite'`          → endless, alternating direction
  *   - `{ count, alternate }`→ explicit; `alternate` defaults to `true`
+ *
+ * Pass `{ sequence: true }` when `animation` is a `withSequence` result.
+ * Reanimated's `reverse` flag only swaps the wrapped animation's `toValue`,
+ * which a sequence ignores — it restarts at step 0 on every pass — so the
+ * flag is not forwarded for sequences. An explicit `alternate: true` on a
+ * sequence warns in dev; write the reverse steps into the sequence instead.
  */
 export function applyRepeat(
   animation: unknown,
   repeat: RepeatConfig | undefined,
+  options?: { sequence?: boolean },
 ) {
-  if (repeat === undefined) return animation
-  if (repeat === 'infinite') {
-    return withRepeat(animation as never, -1, true)
-  }
-  if (typeof repeat === 'number') {
-    return withRepeat(animation as never, repeat, true)
+  const r = normalizeRepeat(repeat)
+  if (r === undefined) return animation
+  const count = Number.isFinite(r.count) ? r.count : -1
+  if (options?.sequence) {
+    if (r.explicitAlternate && r.alternate) {
+      warnOnce(
+        'repeat-sequence-alternate',
+        '[inertia] repeat.alternate has no effect on a sequence — Reanimated ' +
+          'restarts a sequence at its first step on every pass. Append the ' +
+          'reverse steps to the sequence to alternate.',
+      )
+    }
+    return withRepeat(animation as never, count, false)
   }
-  const count = repeat.count === 'infinite' ? -1 : repeat.count
-  const alternate = repeat.alternate ?? true
-  return withRepeat(animation as never, count, alternate)
+  return withRepeat(animation as never, count, r.alternate)
 }
 
 /**

package/src/transitions/resolveSequence.ts

@@ -50,7 +50,9 @@ export function resolveAnimatableValue<V extends number | string>(
       resolveStep(step, stepBase, factory?.('step', i)),
     )
     const seq = withSequence(...(animations as never[]))
-    return applyRepeat(seq, base ? repeatOf(base) : undefined)
+    return applyRepeat(seq, base ? repeatOf(base) : undefined, {
+      sequence: true,
+    })
   }
   const step = value as SequenceStep<V>
   const cb = factory?.('animation', undefined)

package/src/transitions/runtime.ts

@@ -4,12 +4,12 @@ import {
   withSpring,
   withTiming,
 } from 'react-native-reanimated'
+import { DEFAULT_TIMING_DURATION } from './constants'
+import { unwrapEasingFactory } from './easing'
 import { springToReanimated } from './spring'
 import { type AnimationCallback } from './resolve'
 import { type TransitionConfig } from '../types'
 
-const DEFAULT_TIMING_DURATION = 250
-
 /**
  * Worklet-safe single-step animation builder. Mirrors a subset of
  * `resolveTransition` for the UI-thread path where the transition config is
@@ -58,13 +58,10 @@ export function buildReleaseAnimation(
   }
   if (transition.type === 'timing') {
     // Reanimated 4's `Easing.bezier(...)` returns an `EasingFunctionFactory`
-    // rather than the function itself. Unwrap inline so consumers calling
+    // rather than the function itself. Unwrap so consumers calling
     // `buildReleaseAnimation` from a gesture worklet don't have to.
     const e = transition.easing
-    const easingFn =
-      e && typeof e === 'object' && 'factory' in e
-        ? e.factory()
-        : (e ?? Easing.inOut(Easing.ease))
+    const easingFn = e ? unwrapEasingFactory(e) : Easing.inOut(Easing.ease)
     return withTiming(
       toValue,
       {

package/src/transitions/spring.ts

@@ -28,6 +28,13 @@ export const DEFAULT_SPRING: Required<
  * names differ but the underlying physics constants are the same. We don't
  * surface the raw names publicly because the react-spring vocabulary is
  * what designers and prior-art consumers expect.
+ *
+ * Settle control is deliberately absent: Reanimated 4 settles springs on an
+ * internal `energyThreshold` and ignores Reanimated 3's `restSpeedThreshold`
+ * / `restDisplacementThreshold`. Inertia surfaced those two names through
+ * `0.0.9`, where they were silently inert — do not re-add them. If a settle
+ * knob is ever needed, expose Reanimated 4's `overshootClamping` or
+ * `energyThreshold`, which the runtime actually reads.
  */
 export function springToReanimated(t: SpringTransition) {
   'worklet'
@@ -36,7 +43,5 @@ export function springToReanimated(t: SpringTransition) {
     damping: t.friction ?? DEFAULT_SPRING.friction,
     mass: t.mass ?? DEFAULT_SPRING.mass,
     velocity: t.velocity,
-    restSpeedThreshold: t.restSpeedThreshold,
-    restDisplacementThreshold: t.restDisplacementThreshold,
   }
 }

package/src/types.ts

@@ -31,8 +31,6 @@ export interface SpringTransition {
   friction?: number
   mass?: number
   velocity?: number
-  restSpeedThreshold?: number
-  restDisplacementThreshold?: number
   delay?: number
   repeat?: RepeatConfig
 }
@@ -130,6 +128,15 @@ export type TransitionInput = TransitionConfig | TransitionName
 
 /**
  * Repeat config — one shape, not three flags. Default `alternate: true`.
+ *
+ * `count` is the total number of iterations, including the first pass, so
+ * `repeat: 2` plays the animation twice. A count below `1` runs the animation
+ * once and warns in dev.
+ *
+ * `alternate` reverses direction on every other pass for a single-value
+ * animation. It has no effect on a sequence (an array target): Reanimated
+ * restarts a sequence at its first step on every pass. Append the reverse
+ * steps to the sequence to alternate.
  */
 export type RepeatConfig =
   | number

package/src/values/extrapolation.ts

@@ -0,0 +1,21 @@
+import { Extrapolation } from 'react-native-reanimated'
+
+/**
+ * Extrapolation behavior at the edges of the input range. Mirrors
+ * Reanimated's enum so consumers don't need a separate import.
+ *
+ * - `'clamp'` (default) — output stays pinned at the first/last value
+ *   outside the input range. Matches Framer Motion's default.
+ * - `'identity'` — return the input unchanged outside the range.
+ * - `'extend'` — continue the linear slope beyond the range.
+ */
+export type ExtrapolationMode = 'clamp' | 'identity' | 'extend'
+
+/** Map the public mode name to Reanimated's `Extrapolation` enum. */
+export function mapExtrapolation(
+  mode: ExtrapolationMode | undefined,
+): Extrapolation {
+  if (mode === 'identity') return Extrapolation.IDENTITY
+  if (mode === 'extend') return Extrapolation.EXTEND
+  return Extrapolation.CLAMP
+}

package/src/values/index.ts

@@ -18,6 +18,7 @@ export {
 } from './useGesture'
 export {
   useInterpolatedStyle,
+  type InterpolatedStyle,
   type InterpolatedStyleMap,
   type NumericStyleKey,
   type TransformKey,
@@ -37,4 +38,5 @@ export {
   type ShadowConfig,
   type UseShadowOptions,
 } from './useShadow'
+export { useTranslateStyle } from './useTranslateStyle'
 export { useVariants } from './useVariants'

package/src/values/useGesture.ts

@@ -1,11 +1,11 @@
-import { useCallback, useMemo } from 'react'
+import { useCallback, useEffect, useMemo } from 'react'
 import { useSharedValue, type SharedValue } from 'react-native-reanimated'
 import {
   resolveNamedTransitionProp,
   useNamedTransitions,
   useShouldReduceMotion,
 } from '../config'
-import { isFocusVisible } from '../gestures'
+import { installFocusVisibility, isFocusVisible } from '../gestures'
 import { isTopLevelTransition, resolveTransition } from '../transitions'
 import {
   type GestureLayerTransitions,
@@ -110,6 +110,13 @@ export function useGesture(
   // the callbacks below only ever see concrete configs.
   const resolved = resolveNamedTransitionProp(transition, useNamedTransitions())
 
+  // The web modality listeners behind `focusVisible` attach on mount — see
+  // `focusVisibility.ts` for why mount time is early enough and import time
+  // is not an option.
+  useEffect(() => {
+    installFocusVisibility()
+  }, [])
+
   const setLayer = useCallback(
     (sv: SharedValue<number>, layer: LayerName, target: 0 | 1) => {
       const cfg = shouldReduceMotion

package/src/values/useInterpolatedStyle.ts

@@ -1,13 +1,14 @@
 import { useMemo } from 'react'
+import type { ImageStyle, TextStyle, ViewStyle } from 'react-native'
 import {
-  Extrapolation,
   interpolate,
   interpolateColor,
   useAnimatedStyle,
   type SharedValue,
 } from 'react-native-reanimated'
+import { warnOnce } from '../internal/warnOnce'
+import { mapExtrapolation, type ExtrapolationMode } from './extrapolation'
 import type { ColorStyleKey } from './useColorTransition'
-import type { ExtrapolationMode } from './useTransform'
 
 /**
  * Numeric style keys `useInterpolatedStyle` can emit directly (not lifted into
@@ -83,6 +84,29 @@ export type InterpolatedStyleMap = {
   [K in ColorStyleKey]?: readonly string[]
 }
 
+/**
+ * The style shape a map of `K` produces. Transform keys collapse into the
+ * single `transform` array the worklet emits; every other key survives under
+ * its own name, typed from the RN style family it belongs to.
+ *
+ * This is what lets the return narrow to `ViewStyle` at a call site whose map
+ * holds only view keys. Reanimated's own `useAnimatedStyle` resolves to
+ * `DefaultStyle` (`ViewStyle | ImageStyle | TextStyle`), and that union is
+ * rejected inside a `StyleProp<ViewStyle>` array — `TextStyle` fails on
+ * `cursor` — so a consumer had to cast.
+ */
+export type InterpolatedStyle<K extends keyof InterpolatedStyleMap> = {
+  [P in Exclude<K, TransformKey>]: P extends keyof TextStyle
+    ? TextStyle[P]
+    : P extends keyof ImageStyle
+      ? ImageStyle[P]
+      : P extends keyof ViewStyle
+        ? ViewStyle[P]
+        : never
+} & (Extract<K, TransformKey> extends never
+  ? unknown
+  : { transform: NonNullable<ViewStyle['transform']> })
+
 export interface UseInterpolatedStyleOptions {
   /**
    * Input range mapped onto every key's output range. Defaults to `[0, 1]`
@@ -134,12 +158,6 @@ function evenlySpaced(count: number): number[] {
   return out
 }
 
-function mapExtrapolation(mode: ExtrapolationMode | undefined): Extrapolation {
-  if (mode === 'identity') return Extrapolation.IDENTITY
-  if (mode === 'extend') return Extrapolation.EXTEND
-  return Extrapolation.CLAMP
-}
-
 /**
  * Order-preserving structural signature of the map + options. Unlike
  * `stableSig` (which sorts keys), this walks `map` in insertion order because
@@ -178,8 +196,9 @@ function buildEntries(
         ? [0, 1]
         : evenlySpaced(output.length)
 
-    if (__DEV__ && explicitInput && explicitInput.length !== output.length) {
-      console.warn(
+    if (explicitInput && explicitInput.length !== output.length) {
+      warnOnce(
+        `interpolated-style-range:${String(key)}:${explicitInput.length}:${output.length}`,
         `[inertia] useInterpolatedStyle: inputRange has ${explicitInput.length} stops but the "${String(
           key,
         )}" output has ${output.length}. They must match — interpolation results are undefined otherwise.`,
@@ -262,17 +281,17 @@ function buildEntries(
  * hook stays fully declarative and hashable so unchanged maps produce zero
  * new UI-thread closures.
  */
-export function useInterpolatedStyle(
+export function useInterpolatedStyle<K extends keyof InterpolatedStyleMap>(
   progress: SharedValue<number>,
-  map: InterpolatedStyleMap,
+  map: Pick<InterpolatedStyleMap, K>,
   options?: UseInterpolatedStyleOptions,
-): ReturnType<typeof useAnimatedStyle> {
+): InterpolatedStyle<K> {
   const extrapolate = mapExtrapolation(options?.extrapolate)
 
   // Order-preserving signature: the map's key order is load-bearing (transform
   // lifting emits axes in author order), so `stableSig` (which sorts keys) is
   // wrong here — sign the ordered key/output pairs plus the options directly.
-  const sig = buildSignature(map, options)
+  const sig = buildSignature(map as InterpolatedStyleMap, options)
 
   // Resolve every key's plan once on the JS thread so the worklet body only
   // consumes flat arrays — consistent with the JS-thread resolver principle
@@ -280,9 +299,15 @@ export function useInterpolatedStyle(
   // principle 8). Memoized on `sig` so a fresh-but-equal map literal each
   // render yields the same `entries` reference — Reanimated then sees an
   // unchanged closure dependency and does not rebuild the UI-thread worklet.
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const entries = useMemo<Entry[]>(() => buildEntries(map, options), [sig])
+  const entries = useMemo<Entry[]>(
+    () => buildEntries(map as InterpolatedStyleMap, options),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sig],
+  )
 
+  // The worklet builds a `Record<string, unknown>` by design — the emitted keys
+  // are only known from `entries` at run time. `InterpolatedStyle<K>` is the
+  // static statement of that same shape, so the cast is where the two meet.
   return useAnimatedStyle(() => {
     'worklet'
     const out: Record<string, unknown> = {}
@@ -313,7 +338,5 @@ export function useInterpolatedStyle(
     }
     if (transform.length > 0) out.transform = transform
     return out
-  })
+  }) as InterpolatedStyle<K>
 }
-
-declare const __DEV__: boolean

package/src/values/useShadow.ts

@@ -1,3 +1,4 @@
+import { useMemo } from 'react'
 import {
   interpolate,
   interpolateColor,
@@ -9,6 +10,7 @@ import {
   resolveBoxShadowInput,
   type BoxShadowLayer,
 } from '../internal/boxShadow'
+import { stableSig } from '../transitions/sig'
 
 export type { BoxShadowLayer }
 
@@ -113,13 +115,22 @@ export function useShadow({
   // boxShadow layers: parse/pair once on the JS thread into flat records so
   // the worklet only interpolates numbers/colors and concatenates — no
   // frame-time parsing. `[]` when neither side provides the key.
-  const boxShadowPairs =
-    from.boxShadow !== undefined || to.boxShadow !== undefined
-      ? pairBoxShadowLayers(
-          resolveBoxShadowInput(from.boxShadow),
-          resolveBoxShadowInput(to.boxShadow),
-        )
-      : []
+  //
+  // Memoised on the inputs' structure: the pairs array is the one non-scalar
+  // the worklet captures, and `from` / `to` are usually inline literals, so
+  // without the memo a fresh array each render would rebuild the worklet.
+  const boxShadowSig = stableSig([from.boxShadow, to.boxShadow])
+  const boxShadowPairs = useMemo(
+    () =>
+      from.boxShadow !== undefined || to.boxShadow !== undefined
+        ? pairBoxShadowLayers(
+            resolveBoxShadowInput(from.boxShadow),
+            resolveBoxShadowInput(to.boxShadow),
+          )
+        : [],
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [boxShadowSig],
+  )
 
   const opacityFrom = from.shadowOpacity ?? 0
   const opacityTo = to.shadowOpacity ?? 0

package/src/values/useSpring.ts

@@ -6,7 +6,12 @@ import {
   withSpring,
   type SharedValue,
 } from 'react-native-reanimated'
-import { lookupNamedTransition, useNamedTransitions } from '../config'
+import {
+  lookupNamedTransition,
+  useNamedTransitions,
+  useShouldReduceMotion,
+} from '../config'
+import { warnOnce } from '../internal/warnOnce'
 import { springToReanimated } from '../transitions/spring'
 import {
   type NamedTransitions,
@@ -14,8 +19,6 @@ import {
   type TransitionName,
 } from '../types'
 
-declare const __DEV__: boolean
-
 /**
  * Animate a shared value toward `target` with spring physics, using the
  * library's react-spring vocabulary (`tension` / `friction` / `mass`).
@@ -35,12 +38,16 @@ declare const __DEV__: boolean
  * must resolve to a spring config — a name registered as timing / decay /
  * no-animation warns in dev and falls back to the default spring (reach for
  * `useAnimation` when the named transition's type should be honored).
+ *
+ * Reduced motion (via `<MotionConfig reducedMotion>`) is honoured: the output
+ * is assigned the target directly, with no spring, on both paths.
  */
 export function useSpring(
   target: number | SharedValue<number>,
   config?: SpringTransition | TransitionName,
 ): SharedValue<number> {
   const spring = resolveSpringInput(config, useNamedTransitions())
+  const shouldReduceMotion = useShouldReduceMotion()
   // Reanimated config is rebuilt only when the public config object changes
   // shape. The worklet path reads this from JS-thread closure capture, which
   // is fine: it's the resolved config that's invariant across UI-thread
@@ -52,14 +59,7 @@ export function useSpring(
     // depending on `config` itself would rebuild the Reanimated config on
     // every render and defeat the memo.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      spring?.tension,
-      spring?.friction,
-      spring?.mass,
-      spring?.velocity,
-      spring?.restSpeedThreshold,
-      spring?.restDisplacementThreshold,
-    ],
+    [spring?.tension, spring?.friction, spring?.mass, spring?.velocity],
   )
 
   const isSharedTarget = isSharedValue(target)
@@ -72,28 +72,38 @@ export function useSpring(
   // a stale closure.
   useEffect(() => {
     if (isSharedTarget) return
-    output.value = withSpring(target as number, reanimConfig)
+    output.value = shouldReduceMotion
+      ? (target as number)
+      : withSpring(target as number, reanimConfig)
     // `output` is identity-stable per hook instance (Reanimated guarantee).
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isSharedTarget, target, reanimConfig])
+  }, [isSharedTarget, target, reanimConfig, shouldReduceMotion])
 
   // SharedValue path. `useAnimatedReaction` runs the prepare worklet whenever
   // its returned value changes; we read `.value` off the target SV and pipe
   // it through `withSpring` on the UI thread. When the target is a plain
   // number we never declare a source so the reaction is inert (returns
   // `null`, never fires `react`).
+  //
+  // `source` is in the dependency list on purpose. An explicit list replaces
+  // Reanimated's closure-derived one, so a caller that swaps which shared
+  // value drives the spring would otherwise keep the reaction wired to the
+  // old one — the same stale-closure class `useColorCascade` fixed in 0.0.4.
+  // A plain-number target maps to `null`, so a changing number does not
+  // re-register the inert reaction.
+  const source = isSharedTarget ? target : null
   useAnimatedReaction(
     () => {
       'worklet'
-      if (!isSharedTarget) return null
-      return (target as SharedValue<number>).value
+      if (source === null) return null
+      return source.value
     },
     (next, prev) => {
       'worklet'
       if (next === null || next === prev) return
-      output.value = withSpring(next, reanimConfig)
+      output.value = shouldReduceMotion ? next : withSpring(next, reanimConfig)
     },
-    [isSharedTarget, reanimConfig],
+    [source, reanimConfig, shouldReduceMotion],
   )
 
   // Stop the in-flight spring when the owning component unmounts so its
@@ -122,14 +132,13 @@ function resolveSpringInput(
   if (typeof config !== 'string') return config
   const cfg = lookupNamedTransition(config, registry)
   if (cfg.type === undefined || cfg.type === 'spring') return cfg
-  if (__DEV__) {
-    console.warn(
-      `[inertia] Named transition "${config}" resolves to type ` +
-        `'${cfg.type}', but useSpring / useBooleanSpring are spring-only — ` +
-        `falling back to the default spring. Use useAnimation to honor ` +
-        `non-spring named transitions.`,
-    )
-  }
+  warnOnce(
+    `spring-only:${config}`,
+    `[inertia] Named transition "${config}" resolves to type ` +
+      `'${cfg.type}', but useSpring / useBooleanSpring are spring-only — ` +
+      `falling back to the default spring. Use useAnimation to honor ` +
+      `non-spring named transitions.`,
+  )
   return undefined
 }