@rootnative/inertia 0.0.9 → 0.0.10

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

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

package/dist/{chunk-JBK5ZLMH.mjs → chunk-CUHOCONB.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
+import { createMotionComponent } from './chunk-JENYDTXH.mjs';
 import { Pressable } from 'react-native';
 
 var MotionPressable = createMotionComponent(Pressable);

package/dist/{chunk-M4766VUV.mjs → chunk-DRA2K53O.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
+import { createMotionComponent } from './chunk-JENYDTXH.mjs';
 import { ScrollView } from 'react-native';
 
 var MotionScrollView = createMotionComponent(ScrollView);

package/dist/{chunk-L4JFECXU.mjs → chunk-F4HMCXAX.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-6FCATUMY.mjs';
+import { resolveTransition, isTopLevelTransition } from './chunk-HEAWMZEM.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" };

package/dist/{chunk-W7NTRSPD.mjs → chunk-HEAWMZEM.mjs}

@@ -1,7 +1,48 @@
 import { isWorkletFunction } from 'react-native-worklets';
 import { withDelay, withSequence, Easing, withDecay, withTiming, withSpring, withRepeat } from 'react-native-reanimated';
 
-// src/transitions/easing.ts
+// src/transitions/sig.ts
+function stableSig(value) {
+  if (value === void 0) return "";
+  try {
+    return stableStringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") {
+    if (typeof v === "function" || v === void 0) return "null";
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map(stableStringify).join(",") + "]";
+  }
+  const obj = v;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+
+// src/transitions/keys.ts
+var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "tension",
+  "friction",
+  "mass",
+  "velocity",
+  "duration",
+  "easing",
+  "delay",
+  "repeat",
+  "deceleration",
+  "clamp"
+]);
+function isTopLevelTransition(t) {
+  if (t === null || typeof t !== "object") return false;
+  const keys = Object.keys(t);
+  if (keys.length === 0) return false;
+  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
+}
 
 // src/internal/warnOnce.ts
 var warned = /* @__PURE__ */ new Set();
@@ -22,7 +63,7 @@ function warnNonWorkletOnce(key, message) {
 // src/transitions/easing.ts
 function ensureWorkletEasing(easing) {
   if (!easing) return void 0;
-  const fn = isEasingFactory(easing) ? easing.factory() : easing;
+  const fn = unwrapEasingFactory(easing);
   if (isWorkletFunction(fn)) return fn;
   warnNonWorkletOnce(
     "timing-easing",
@@ -34,10 +75,18 @@ function ensureWorkletEasing(easing) {
   };
   return wrapped;
 }
-function isEasingFactory(value) {
-  return typeof value === "object" && value !== null && "factory" in value && typeof value.factory === "function";
+function unwrapEasingFactory(easing) {
+  "worklet";
+  if (typeof easing === "object" && easing !== null && "factory" in easing && typeof easing.factory === "function") {
+    return easing.factory();
+  }
+  return easing;
 }
 
+// src/transitions/constants.ts
+var DEFAULT_TIMING_DURATION = 250;
+var DEFAULT_LAYOUT_DURATION = 300;
+
 // src/transitions/spring.ts
 var DEFAULT_SPRING = {
   tension: 170,
@@ -50,14 +99,11 @@ function springToReanimated(t) {
     stiffness: t.tension ?? DEFAULT_SPRING.tension,
     damping: t.friction ?? DEFAULT_SPRING.friction,
     mass: t.mass ?? DEFAULT_SPRING.mass,
-    velocity: t.velocity,
-    restSpeedThreshold: t.restSpeedThreshold,
-    restDisplacementThreshold: t.restDisplacementThreshold
+    velocity: t.velocity
   };
 }
 
 // src/transitions/resolve.ts
-var DEFAULT_TIMING_DURATION = 250;
 function buildSpring(cfg, toValue, cb) {
   return withSpring(toValue, springToReanimated(cfg), cb);
 }
@@ -90,17 +136,54 @@ function buildOne(cfg, toValue, cb) {
   if (cfg.type === "timing") return buildTiming(cfg, toValue, cb);
   return buildSpring(cfg, toValue, cb);
 }
-function applyRepeat(animation, repeat) {
-  if (repeat === void 0) return animation;
+function normalizeRepeat(repeat) {
+  if (repeat === void 0) return void 0;
   if (repeat === "infinite") {
-    return withRepeat(animation, -1, true);
+    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 !== void 0
+    };
+  }
+  if (!(rawCount >= 1)) {
+    warnOnce(
+      `repeat-count:${String(rawCount)}`,
+      `[inertia] repeat count ${String(rawCount)} is below 1 \u2014 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 void 0;
   }
-  if (typeof repeat === "number") {
-    return withRepeat(animation, repeat, true);
+  return {
+    count: rawCount,
+    alternate: alternate ?? true,
+    explicitAlternate: alternate !== void 0
+  };
+}
+function repeatIterationsOf(repeat) {
+  return normalizeRepeat(repeat)?.count ?? 1;
+}
+function applyRepeat(animation, repeat, options) {
+  const r = normalizeRepeat(repeat);
+  if (r === void 0) 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 \u2014 Reanimated restarts a sequence at its first step on every pass. Append the reverse steps to the sequence to alternate."
+      );
+    }
+    return withRepeat(animation, count, false);
   }
-  const count = repeat.count === "infinite" ? -1 : repeat.count;
-  const alternate = repeat.alternate ?? true;
-  return withRepeat(animation, count, alternate);
+  return withRepeat(animation, count, r.alternate);
 }
 function applyDelay(animation, delay) {
   if (!delay || delay <= 0) return animation;
@@ -139,7 +222,9 @@ function resolveAnimatableValue(value, base, factory) {
       (step2, i) => resolveStep(step2, stepBase, factory?.("step", i))
     );
     const seq = withSequence(...animations);
-    return applyRepeat(seq, base ? repeatOf(base) : void 0);
+    return applyRepeat(seq, base ? repeatOf(base) : void 0, {
+      sequence: true
+    });
   }
   const step = value;
   const cb = factory?.("animation", void 0);
@@ -209,7 +294,6 @@ function bezier(x1, y1, x2, y2, source) {
   }
   return Easing.bezier(x1, y1, x2, y2);
 }
-var DEFAULT_TIMING_DURATION2 = 250;
 function buildReleaseAnimation(transition, toValue, callback) {
   "worklet";
   if (transition.type === "no-animation") {
@@ -226,11 +310,11 @@ function buildReleaseAnimation(transition, toValue, callback) {
   }
   if (transition.type === "timing") {
     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,
       {
-        duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+        duration: transition.duration ?? DEFAULT_TIMING_DURATION,
         easing: easingFn
       },
       callback
@@ -239,49 +323,4 @@ function buildReleaseAnimation(transition, toValue, callback) {
   return withSpring(toValue, springToReanimated(transition), callback);
 }
 
-// src/transitions/keys.ts
-var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "tension",
-  "friction",
-  "mass",
-  "velocity",
-  "restSpeedThreshold",
-  "restDisplacementThreshold",
-  "duration",
-  "easing",
-  "delay",
-  "repeat",
-  "deceleration",
-  "clamp"
-]);
-function isTopLevelTransition(t) {
-  if (t === null || typeof t !== "object") return false;
-  const keys = Object.keys(t);
-  if (keys.length === 0) return false;
-  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
-}
-
-// src/transitions/sig.ts
-function stableSig(value) {
-  if (value === void 0) return "";
-  try {
-    return stableStringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function stableStringify(v) {
-  if (v === null || typeof v !== "object") {
-    if (typeof v === "function" || v === void 0) return "null";
-    return JSON.stringify(v);
-  }
-  if (Array.isArray(v)) {
-    return "[" + v.map(stableStringify).join(",") + "]";
-  }
-  const obj = v;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
-}
-
-export { DEFAULT_SPRING, applyDelay, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };
+export { DEFAULT_LAYOUT_DURATION, DEFAULT_SPRING, applyDelay, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, repeatIterationsOf, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };

package/dist/{chunk-IX6SEOSK.mjs → chunk-JENYDTXH.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-6FCATUMY.mjs';
+import { warnOnce, stableSig, applyDelay, resolveAnimatableValue, isTopLevelTransition, resolveTransition, repeatIterationsOf, DEFAULT_LAYOUT_DURATION, ensureWorkletEasing, springToReanimated, DEFAULT_SPRING } from './chunk-HEAWMZEM.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);
@@ -358,7 +357,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 +555,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 +975,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 +989,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 +1072,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 +1105,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 +1192,10 @@ function createMotionComponent(Component) {
         if (isExiting && pending === 0) {
           safeToRemoveRef.current?.();
         }
-      }, [baseSig, transitionSig]);
+        return () => {
+          done = true;
+        };
+      }, [baseSig, transitionSig, hasAnimationEnd]);
       useGestureLayerProgress(
         pressedProgress,
         pressed,
@@ -1232,7 +1236,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 +1256,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 +1559,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 +1586,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 +1668,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-KFHZMFAX.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var reactNativeReanimated = require('react-native-reanimated');
+
+// src/touch/applyBounds.ts
+function applyBounds(value, min, max, elastic) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return elastic > 0 ? min + (value - min) * elastic : min;
+  }
+  if (max !== void 0 && value > max) {
+    return elastic > 0 ? max + (value - max) * elastic : max;
+  }
+  return value;
+}
+function useTranslateStyle(x, y) {
+  return reactNativeReanimated.useAnimatedStyle(() => ({
+    transform: [{ translateX: x.value }, { translateY: y.value }]
+  }));
+}
+
+exports.applyBounds = applyBounds;
+exports.useTranslateStyle = useTranslateStyle;

package/dist/{chunk-6AN5X3YE.js → chunk-KXU6VH2Y.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkWNVHPMBI_js = require('./chunk-WNVHPMBI.js');
+var chunkN33GSDNQ_js = require('./chunk-N33GSDNQ.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 var jsxRuntime = require('react/jsx-runtime');
@@ -32,7 +32,7 @@ function MotionConfig({
   children
 }) {
   const parent = useMotionConfig();
-  const transitionsSig = chunkWNVHPMBI_js.stableSig(transitions);
+  const transitionsSig = chunkN33GSDNQ_js.stableSig(transitions);
   const value = react.useMemo(
     () => ({
       reducedMotion: reducedMotion ?? parent.reducedMotion,
@@ -49,11 +49,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}': { ... } }}>.`
-    );
-  }
+  chunkN33GSDNQ_js.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) {
@@ -66,7 +65,7 @@ function resolveNamedTransitionProp(transition, registry) {
   if (typeof transition === "string") {
     return lookupNamedTransition(transition, registry);
   }
-  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
+  if (chunkN33GSDNQ_js.isTopLevelTransition(transition)) return transition;
   const map = transition;
   let out = null;
   for (const key in map) {
@@ -86,7 +85,7 @@ function setKeyboard() {
 function setPointer() {
   modality = "pointer";
 }
-function ensureInstalled() {
+function installFocusVisibility() {
   if (installed) return;
   if (reactNative.Platform.OS !== "web") return;
   if (typeof document === "undefined") return;
@@ -96,14 +95,14 @@ function ensureInstalled() {
   document.addEventListener("touchstart", setPointer, true);
   installed = true;
 }
-ensureInstalled();
 function isFocusVisible() {
   if (reactNative.Platform.OS !== "web") return true;
-  ensureInstalled();
+  installFocusVisibility();
   return modality === "keyboard";
 }
 
 exports.MotionConfig = MotionConfig;
+exports.installFocusVisibility = installFocusVisibility;
 exports.isFocusVisible = isFocusVisible;
 exports.lookupNamedTransition = lookupNamedTransition;
 exports.resolveNamedTransition = resolveNamedTransition;