@rootnative/inertia 0.0.2 → 0.0.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to `@rootnative/inertia` are documented here. The format fol
 
 ## [Unreleased]
 
+## [0.0.3] - 2026-07-25
+
+### Fixed
+
+- **Properties mentioned only by `gesture` / `exit` / a non-current variant no longer stomp the static `style`.** A key touched by any of those joins the animated key set — the worklet has to know about it so the layer or branch can drive it later — but until something actually drove it, it rested at a generic default and the animated style, which merges _after_ `style`, silently overrode the element's own stylesheet. `<Motion.View style={styles.field} gesture={{ focused: { borderColor: '#4f46e5' } }} />` rendered `borderColor: 'transparent'` on the very first frame, before any interaction; `exit={{ width: 0 }}` collapsed the element to zero width while it was still on screen; a `width` present in one variant branch collapsed the element whenever a different branch was active. Affected every property whose default isn't an identity — `width`, `height`, `borderRadius`, `shadowOpacity`, `shadowRadius`, `elevation`, `shadowOffset`, and all five color keys. Transforms and `opacity` were unaffected, which is why this survived so long: their defaults (`0` / `1`) happen to be no-ops. Undriven properties now rest at the value the static `style` sets — read through `StyleSheet.flatten`, so style arrays and registered stylesheet IDs resolve, transform entries are read out of the `transform` array, `shadowOffset` decomposes into both axes, and unit-suffixed rotations (`'45deg'`, `'0.5rad'`) convert to the plain degrees the shared value holds — falling back to the type default only when the style is silent too. Gesture layers now blend from that style-derived base and return to it on release. The base also tracks a `style` that changes after mount (a theme swap no longer gets pinned to the value captured at mount). Non-numeric style values such as `width: '100%'` are deliberately not seeded into numeric slots, since a later `withTiming` can't interpolate them. Values a record has already driven are untouched: switching to a variant branch that omits a key still leaves it where the previous branch put it. Guarded by `style-resting.test.tsx` (18 cases).
+
+- **`<Presence>` children now animate out in place instead of jumping to the end of their siblings.** The render list was built as "every present entry, then every exiting entry". React reconciles that array by key, so appending physically moved the node: removing the middle of a three-row list rendered `a, c, b` and the departing row visibly jumped to the bottom before it had finished fading. Absolutely-positioned overlays — popovers, sheets, toasts, the cases `<Presence>` gets used for most and the ones the existing tests covered — never showed it; every list and column did. Exiting entries are now spliced back in at the position they held, anchored immediately after their nearest surviving predecessor (or at the front if there isn't one), so adjacent departures keep their relative order and siblings added or reordered mid-exit are placed around them. `<Presence>` remembers the full previous render order, including entries that were already exiting, since an exiting child is by definition absent from `children`. Note for anyone touching this code: the ordering pass has to read the exiting map that the _current_ render computed, not the `useState` value — on the render that first detects a departure the state update hasn't applied yet, and using the stale map drops the child from the remembered order entirely on the following render, losing the exit animation rather than merely misplacing it. Guarded by `Presence.order.test.tsx` (12 cases; 7 fail against the previous implementation).
+
+- **An endless (`repeat: 'infinite'`) animation no longer blocks completion counters.** A callback is only promoted to the terminal `'animation'` phase once `iteration >= totalIterations - 1`, which is unreachable against `Infinity`. Two counters were gated behind that check and both broke in the presence of an endless animation. **(1) The transform group** — a multi-axis transform coalesces its terminal callbacks into one `onAnimationEnd({ key: 'transform' })`, counting the participating axes and firing when the last settles. An endless axis pinned that count above zero forever, so `animate={{ translateX: 100, translateY: 50 }}` with `transition={{ translateX: { repeat: 'infinite' }, translateY: {} }}` settled `translateY`, decremented the counter, and fired **nothing** — the completion was silently swallowed. Endless axes are now excluded from the group, so the finite axes still report; when every transform axis is endless no terminal callback fires at all, which is correct since nothing finishes. **(2) `<Presence>`'s settle counter** — the same unreachable check gated `safeToRemove`, so an endless exit animation left the child **mounted forever**. A top-level `transition={{ repeat: 'infinite' }}` is inherited by `exit`, so a pulsing element inside `<Presence>` would never unmount — a permanent leak, not just a missed callback. Exit keys that can never settle are no longer counted: finite keys still gate the unmount, and if every exiting property is endless the child is released immediately. Scope the repeat to one property (`transition={{ opacity: { repeat: 'infinite' } }}`) when you want a loop _and_ a normal exit. Guarded by `endless-repeat.test.tsx` (8 cases; 4 fail against the previous implementation).
+
+- **`useColorCascade` now notices when a layer's `progress` shared value is swapped.** The layer chain is memoized on a structural signature — key, base colour, layer count, layer colours — which can't contain the shared values themselves because they're objects, and they were excluded from change detection entirely. Swapping _which_ value drives a layer while its colour stayed the same therefore did nothing: the worklet went on reading the old shared value, and driving the one no longer referenced by any layer still moved the colour. A conditionally-sourced progress (`{ progress: isError ? errorSpring : hoverSpring, color }`) silently animated off the wrong input. Shared-value references are now compared directly and the array is rebuilt only when one actually differs, so the swap rewires the worklet while a fresh-but-equal `layers` literal still produces no new UI-thread closure.
+
+- **`useAnimator()` is now identity-stable by construction, as documented.** Its JSDoc, the hooks reference, and the `0.0.2` changelog all promised an identity-stable setter safe to drop into memoized handlers, and all three explained it as reading the registry "live inside the body" — but the implementation listed `[registry, shouldReduceMotion]` as `useCallback` dependencies, so a provider republishing its `transitions` map or a reduced-motion change handed back a new function and churned every handler built on it. It stayed stable only by accident of `<MotionConfig>` memoizing. Both values now genuinely live in refs read at call time, which also makes writes resolve against the registry current _when the event fires_ rather than the one captured at render.
+
+- **The `layoutId` measure registry now evicts expired entries.** Rects only ever left the module-level map through `consumeLayout` / `peekSharedLayout`, so a `layoutId` that unmounted and was never remounted kept its entry for the lifetime of the process. Harmless for a handful of hero images; a slow leak for per-item ids in a long-lived list (`layoutId={`photo-${item.id}`}`), where the release is never consumed. Writes now run an expiry sweep, amortized to at most one full scan per TTL window so a burst of layout events doesn't become a burst of scans. Sweeping a still-mounted element's entry is safe — it re-registers on its next `onLayout`, and unmount re-publishes the rect with a fresh TTL either way.
+
 ## [0.0.2] - 2026-07-24
 
 ### Added
@@ -89,7 +105,13 @@ Initial alpha publish. The full v0.1 surface is in place; APIs are still subject
 - 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.0-alpha.2...HEAD
+[unreleased]: https://github.com/rootnative/inertia/compare/core+gestures+gradients+svg@0.0.3...HEAD
+[0.0.3]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.3
+[0.0.2]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.2
+[0.0.1]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.1
+[0.0.0-alpha.5]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.5
+[0.0.0-alpha.4]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.4
+[0.0.0-alpha.3]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.3
 [0.0.0-alpha.2]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.2
 [0.0.0-alpha.1]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.1
-[0.0.0-alpha.0]: https://github.com/rootnative/inertia/releases/tag/v0.0.0-alpha.0
+[0.0.0-alpha.0]: https://github.com/rootnative/inertia/releases/tag/core+gestures+gradients+svg@0.0.0-alpha.0

package/dist/{chunk-NKA6XR77.js → chunk-3XTVY34H.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkIWLU3VDE_js = require('./chunk-IWLU3VDE.js');
+var chunkBP3Y2SHQ_js = require('./chunk-BP3Y2SHQ.js');
 var reactNative = require('react-native');
 
-var MotionPressable = chunkIWLU3VDE_js.createMotionComponent(reactNative.Pressable);
+var MotionPressable = chunkBP3Y2SHQ_js.createMotionComponent(reactNative.Pressable);
 
 exports.MotionPressable = MotionPressable;

package/dist/{chunk-V6BTXHZK.mjs → chunk-46P57VMY.mjs}

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

package/dist/{chunk-IWLU3VDE.js → chunk-BP3Y2SHQ.js}

@@ -5,6 +5,7 @@ var chunkPTRF47DA_js = require('./chunk-PTRF47DA.js');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var Animated = require('react-native-reanimated');
+var reactNative = require('react-native');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -35,6 +36,8 @@ function Presence({ children }) {
     () => /* @__PURE__ */ new Map()
   );
   const prevIncomingRef = react.useRef(incoming);
+  const orderRef = react.useRef([]);
+  let pendingExiting = null;
   if (prevIncomingRef.current !== incoming) {
     const prev = prevIncomingRef.current;
     prevIncomingRef.current = incoming;
@@ -56,8 +59,12 @@ function Presence({ children }) {
         ensureMutable().delete(key);
       }
     }
-    if (next) setExiting(next);
+    if (next) {
+      pendingExiting = next;
+      setExiting(next);
+    }
   }
+  const activeExiting = pendingExiting ?? exiting;
   const handleRemove = react.useCallback((key) => {
     setExiting((prev) => {
       if (!prev.has(key)) return prev;
@@ -66,19 +73,42 @@ function Presence({ children }) {
       return next;
     });
   }, []);
-  const renderList = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const presentKeys = /* @__PURE__ */ new Set();
+  const order = [];
   for (const el of incoming) {
-    renderList.push({
-      key: el.key,
-      element: el,
-      isPresent: true
-    });
+    const key = el.key;
+    byKey.set(key, el);
+    presentKeys.add(key);
+    order.push(key);
   }
-  for (const [key, el] of exiting) {
-    if (!renderList.some((entry) => entry.key === key)) {
-      renderList.push({ key, element: el, isPresent: false });
+  const prevOrder = orderRef.current;
+  for (let i = 0; i < prevOrder.length; i++) {
+    const key = prevOrder[i];
+    const departing = activeExiting.get(key);
+    if (!departing || byKey.has(key)) continue;
+    let insertAt = 0;
+    for (let j = i - 1; j >= 0; j--) {
+      const anchor = order.indexOf(prevOrder[j]);
+      if (anchor !== -1) {
+        insertAt = anchor + 1;
+        break;
+      }
     }
+    byKey.set(key, departing);
+    order.splice(insertAt, 0, key);
   }
+  for (const [key, el] of activeExiting) {
+    if (byKey.has(key)) continue;
+    byKey.set(key, el);
+    order.push(key);
+  }
+  orderRef.current = order;
+  const renderList = order.map((key) => ({
+    key,
+    element: byKey.get(key),
+    isPresent: presentKeys.has(key)
+  }));
   return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderList.map(({ key, element, isPresent }) => /* @__PURE__ */ jsxRuntime.jsx(
     PresenceItem,
     {
@@ -130,11 +160,23 @@ function resolveLayoutTransition(layout) {
 var REGISTRY = /* @__PURE__ */ new Map();
 var SHARED_LAYOUT_TTL_MS = 1e3;
 var now = () => Date.now();
+var lastSweep = 0;
+function sweepExpired(at) {
+  if (at - lastSweep < SHARED_LAYOUT_TTL_MS) return;
+  lastSweep = at;
+  for (const [id, entry] of REGISTRY) {
+    if (entry.expiresAt < at) REGISTRY.delete(id);
+  }
+}
 function registerLayout(id, rect) {
-  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+  const at = now();
+  sweepExpired(at);
+  REGISTRY.set(id, { rect, expiresAt: at + SHARED_LAYOUT_TTL_MS });
 }
 function releaseLayout(id, rect) {
-  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+  const at = now();
+  sweepExpired(at);
+  REGISTRY.set(id, { rect, expiresAt: at + SHARED_LAYOUT_TTL_MS });
 }
 function consumeLayout(id) {
   const entry = REGISTRY.get(id);
@@ -510,23 +552,49 @@ function createMotionComponent(Component) {
           (k) => SHADOW_OFFSET_KEY_SET.has(k)
         );
       }
+      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 = {};
+      if (activeKeys.some((k) => !everDriven.has(k))) {
+        const flat = reactNative.StyleSheet.flatten(style);
+        if (flat) {
+          for (const key of activeKeys) {
+            if (everDriven.has(key)) continue;
+            const v = styleValueFor(flat, key);
+            if (v !== void 0) styleResting[key] = v;
+          }
+        }
+      }
       const sharedValues = useAnimatableSharedValues((key) => {
         if (SHADOW_OFFSET_KEY_SET.has(key)) {
           const axis = shadowOffsetAxisFor(key);
           if (initial === false) {
-            return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+            return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? styleResting[key] ?? DEFAULT_RESTING[key];
           }
           return shadowOffsetAxisValue(
             initialRecord?.shadowOffset,
             axis
-          ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+          ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? styleResting[key] ?? DEFAULT_RESTING[key];
         }
         if (initial === false) {
           const a = animateRecord[key];
-          return restValue(a) ?? DEFAULT_RESTING[key];
+          return restValue(a) ?? styleResting[key] ?? DEFAULT_RESTING[key];
         }
-        return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
+        return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? styleResting[key] ?? DEFAULT_RESTING[key];
       });
+      const styleRestingSig = chunkPTRF47DA_js.stableSig(styleResting);
+      react.useEffect(() => {
+        for (const key of activeKeysRef.current) {
+          if (everDrivenRef.current.has(key)) continue;
+          sharedValues[key].value = styleResting[key] ?? DEFAULT_RESTING[key];
+        }
+      }, [styleRestingSig]);
       const pressedProgress = Animated.useSharedValue(0);
       const focusedProgress = Animated.useSharedValue(0);
       const focusVisibleProgress = Animated.useSharedValue(0);
@@ -569,11 +637,15 @@ function createMotionComponent(Component) {
             if (isExiting) safeToRemoveRef.current?.();
           }
         };
+        const configFor = (key) => shouldReduceMotion ? { type: "no-animation" } : transitionFor(
+          SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
+          transition
+        );
         let transformPending = 0;
         for (const k of ALL_KEYS) {
-          if (TRANSFORM_KEY_SET.has(k) && baseRecord[k] !== void 0) {
-            transformPending++;
-          }
+          if (!TRANSFORM_KEY_SET.has(k) || baseRecord[k] === void 0) continue;
+          if (!reachesTerminalPhase(configFor(k))) continue;
+          transformPending++;
         }
         const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
         for (const key of ALL_KEYS) {
@@ -582,11 +654,8 @@ function createMotionComponent(Component) {
             shadowOffsetAxisFor(key)
           ) : baseRecord[key];
           if (target === void 0) continue;
-          const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(
-            SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
-            transition
-          );
-          if (isExiting) pending++;
+          const cfg = configFor(key);
+          if (isExiting && reachesTerminalPhase(cfg)) pending++;
           const factory = makeKeyCallbackFactory(
             key,
             sharedValues[key],
@@ -655,7 +724,7 @@ function createMotionComponent(Component) {
       const flip = sharedLayout.flip;
       const hasLayoutId = layoutId !== void 0;
       const animatedStyle = Animated.useAnimatedStyle(() => {
-        const activeKeys = activeKeysRef.current;
+        const activeKeys2 = activeKeysRef.current;
         const hasTransform = hasTransformRef.current;
         const hasShadowOffset = hasShadowOffsetRef.current;
         const out = {};
@@ -671,7 +740,7 @@ function createMotionComponent(Component) {
         const focusedLayer = layers ? layers.focused : null;
         const focusVisibleLayer = layers ? layers.focusVisible : null;
         const pressedLayer = layers ? layers.pressed : null;
-        for (const key of activeKeys) {
+        for (const key of activeKeys2) {
           let v = sharedValues[key].value;
           const isColor = COLOR_KEY_SET.has(key);
           if (hoveredLayer && ph > 0 && hoveredLayer[key] !== void 0) {
@@ -911,6 +980,40 @@ function shadowOffsetAxisFor(key) {
 function shadowOffsetAxisValue(source, axis) {
   return source?.[axis];
 }
+function styleValueFor(flat, key) {
+  if (SHADOW_OFFSET_KEY_SET.has(key)) {
+    return shadowOffsetAxisValue(
+      flat.shadowOffset,
+      shadowOffsetAxisFor(key)
+    );
+  }
+  if (TRANSFORM_KEY_SET.has(key)) {
+    const list = flat.transform;
+    if (!Array.isArray(list)) return void 0;
+    for (const entry of list) {
+      if (!entry || typeof entry !== "object") continue;
+      const v2 = entry[key];
+      if (v2 === void 0) continue;
+      if (ROTATION_KEYS.has(key)) return parseAngleDegrees(v2);
+      return typeof v2 === "number" ? v2 : void 0;
+    }
+    return void 0;
+  }
+  const v = flat[key];
+  if (COLOR_KEY_SET.has(key)) {
+    return typeof v === "string" || typeof v === "number" ? v : void 0;
+  }
+  return typeof v === "number" ? v : void 0;
+}
+function parseAngleDegrees(v) {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return void 0;
+  const deg = /^(-?\d*\.?\d+)deg$/.exec(v);
+  if (deg) return Number(deg[1]);
+  const rad = /^(-?\d*\.?\d+)rad$/.exec(v);
+  if (rad) return Number(rad[1]) * 180 / Math.PI;
+  return void 0;
+}
 function collectTouchedKeys(touched, record) {
   for (const k of ALL_KEYS) {
     if (k in record) touched.add(k);
@@ -934,6 +1037,9 @@ function totalIterationsOf(cfg) {
   if (r.count === "infinite") return Number.POSITIVE_INFINITY;
   return r.count;
 }
+function reachesTerminalPhase(cfg) {
+  return Number.isFinite(totalIterationsOf(cfg));
+}
 function targetEndValue(v) {
   if (v === void 0) return void 0;
   if (typeof v === "number" || typeof v === "string") return v;

package/dist/{chunk-TUMNV4P7.mjs → chunk-BQQTHG2V.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-LYMLQ6WQ.mjs';
+import { createMotionComponent } from './chunk-CSODMRJ7.mjs';
 import { View } from 'react-native';
 
 var MotionView = createMotionComponent(View);

package/dist/{chunk-LYMLQ6WQ.mjs → chunk-CSODMRJ7.mjs}

@@ -3,6 +3,7 @@ import { stableSig, resolveAnimatableValue, isTopLevelTransition, resolveTransit
 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';
+import { StyleSheet } from 'react-native';
 
 var PresenceContext = createContext(null);
 function usePresence() {
@@ -29,6 +30,8 @@ function Presence({ children }) {
     () => /* @__PURE__ */ new Map()
   );
   const prevIncomingRef = useRef(incoming);
+  const orderRef = useRef([]);
+  let pendingExiting = null;
   if (prevIncomingRef.current !== incoming) {
     const prev = prevIncomingRef.current;
     prevIncomingRef.current = incoming;
@@ -50,8 +53,12 @@ function Presence({ children }) {
         ensureMutable().delete(key);
       }
     }
-    if (next) setExiting(next);
+    if (next) {
+      pendingExiting = next;
+      setExiting(next);
+    }
   }
+  const activeExiting = pendingExiting ?? exiting;
   const handleRemove = useCallback((key) => {
     setExiting((prev) => {
       if (!prev.has(key)) return prev;
@@ -60,19 +67,42 @@ function Presence({ children }) {
       return next;
     });
   }, []);
-  const renderList = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const presentKeys = /* @__PURE__ */ new Set();
+  const order = [];
   for (const el of incoming) {
-    renderList.push({
-      key: el.key,
-      element: el,
-      isPresent: true
-    });
+    const key = el.key;
+    byKey.set(key, el);
+    presentKeys.add(key);
+    order.push(key);
   }
-  for (const [key, el] of exiting) {
-    if (!renderList.some((entry) => entry.key === key)) {
-      renderList.push({ key, element: el, isPresent: false });
+  const prevOrder = orderRef.current;
+  for (let i = 0; i < prevOrder.length; i++) {
+    const key = prevOrder[i];
+    const departing = activeExiting.get(key);
+    if (!departing || byKey.has(key)) continue;
+    let insertAt = 0;
+    for (let j = i - 1; j >= 0; j--) {
+      const anchor = order.indexOf(prevOrder[j]);
+      if (anchor !== -1) {
+        insertAt = anchor + 1;
+        break;
+      }
     }
+    byKey.set(key, departing);
+    order.splice(insertAt, 0, key);
   }
+  for (const [key, el] of activeExiting) {
+    if (byKey.has(key)) continue;
+    byKey.set(key, el);
+    order.push(key);
+  }
+  orderRef.current = order;
+  const renderList = order.map((key) => ({
+    key,
+    element: byKey.get(key),
+    isPresent: presentKeys.has(key)
+  }));
   return /* @__PURE__ */ jsx(Fragment, { children: renderList.map(({ key, element, isPresent }) => /* @__PURE__ */ jsx(
     PresenceItem,
     {
@@ -124,11 +154,23 @@ function resolveLayoutTransition(layout) {
 var REGISTRY = /* @__PURE__ */ new Map();
 var SHARED_LAYOUT_TTL_MS = 1e3;
 var now = () => Date.now();
+var lastSweep = 0;
+function sweepExpired(at) {
+  if (at - lastSweep < SHARED_LAYOUT_TTL_MS) return;
+  lastSweep = at;
+  for (const [id, entry] of REGISTRY) {
+    if (entry.expiresAt < at) REGISTRY.delete(id);
+  }
+}
 function registerLayout(id, rect) {
-  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+  const at = now();
+  sweepExpired(at);
+  REGISTRY.set(id, { rect, expiresAt: at + SHARED_LAYOUT_TTL_MS });
 }
 function releaseLayout(id, rect) {
-  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+  const at = now();
+  sweepExpired(at);
+  REGISTRY.set(id, { rect, expiresAt: at + SHARED_LAYOUT_TTL_MS });
 }
 function consumeLayout(id) {
   const entry = REGISTRY.get(id);
@@ -504,23 +546,49 @@ function createMotionComponent(Component) {
           (k) => SHADOW_OFFSET_KEY_SET.has(k)
         );
       }
+      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 = {};
+      if (activeKeys.some((k) => !everDriven.has(k))) {
+        const flat = StyleSheet.flatten(style);
+        if (flat) {
+          for (const key of activeKeys) {
+            if (everDriven.has(key)) continue;
+            const v = styleValueFor(flat, key);
+            if (v !== void 0) styleResting[key] = v;
+          }
+        }
+      }
       const sharedValues = useAnimatableSharedValues((key) => {
         if (SHADOW_OFFSET_KEY_SET.has(key)) {
           const axis = shadowOffsetAxisFor(key);
           if (initial === false) {
-            return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+            return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? styleResting[key] ?? DEFAULT_RESTING[key];
           }
           return shadowOffsetAxisValue(
             initialRecord?.shadowOffset,
             axis
-          ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+          ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? styleResting[key] ?? DEFAULT_RESTING[key];
         }
         if (initial === false) {
           const a = animateRecord[key];
-          return restValue(a) ?? DEFAULT_RESTING[key];
+          return restValue(a) ?? styleResting[key] ?? DEFAULT_RESTING[key];
         }
-        return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
+        return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? styleResting[key] ?? DEFAULT_RESTING[key];
       });
+      const styleRestingSig = stableSig(styleResting);
+      useEffect(() => {
+        for (const key of activeKeysRef.current) {
+          if (everDrivenRef.current.has(key)) continue;
+          sharedValues[key].value = styleResting[key] ?? DEFAULT_RESTING[key];
+        }
+      }, [styleRestingSig]);
       const pressedProgress = useSharedValue(0);
       const focusedProgress = useSharedValue(0);
       const focusVisibleProgress = useSharedValue(0);
@@ -563,11 +631,15 @@ function createMotionComponent(Component) {
             if (isExiting) safeToRemoveRef.current?.();
           }
         };
+        const configFor = (key) => shouldReduceMotion ? { type: "no-animation" } : transitionFor(
+          SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
+          transition
+        );
         let transformPending = 0;
         for (const k of ALL_KEYS) {
-          if (TRANSFORM_KEY_SET.has(k) && baseRecord[k] !== void 0) {
-            transformPending++;
-          }
+          if (!TRANSFORM_KEY_SET.has(k) || baseRecord[k] === void 0) continue;
+          if (!reachesTerminalPhase(configFor(k))) continue;
+          transformPending++;
         }
         const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
         for (const key of ALL_KEYS) {
@@ -576,11 +648,8 @@ function createMotionComponent(Component) {
             shadowOffsetAxisFor(key)
           ) : baseRecord[key];
           if (target === void 0) continue;
-          const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(
-            SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
-            transition
-          );
-          if (isExiting) pending++;
+          const cfg = configFor(key);
+          if (isExiting && reachesTerminalPhase(cfg)) pending++;
           const factory = makeKeyCallbackFactory(
             key,
             sharedValues[key],
@@ -649,7 +718,7 @@ function createMotionComponent(Component) {
       const flip = sharedLayout.flip;
       const hasLayoutId = layoutId !== void 0;
       const animatedStyle = useAnimatedStyle(() => {
-        const activeKeys = activeKeysRef.current;
+        const activeKeys2 = activeKeysRef.current;
         const hasTransform = hasTransformRef.current;
         const hasShadowOffset = hasShadowOffsetRef.current;
         const out = {};
@@ -665,7 +734,7 @@ function createMotionComponent(Component) {
         const focusedLayer = layers ? layers.focused : null;
         const focusVisibleLayer = layers ? layers.focusVisible : null;
         const pressedLayer = layers ? layers.pressed : null;
-        for (const key of activeKeys) {
+        for (const key of activeKeys2) {
           let v = sharedValues[key].value;
           const isColor = COLOR_KEY_SET.has(key);
           if (hoveredLayer && ph > 0 && hoveredLayer[key] !== void 0) {
@@ -905,6 +974,40 @@ function shadowOffsetAxisFor(key) {
 function shadowOffsetAxisValue(source, axis) {
   return source?.[axis];
 }
+function styleValueFor(flat, key) {
+  if (SHADOW_OFFSET_KEY_SET.has(key)) {
+    return shadowOffsetAxisValue(
+      flat.shadowOffset,
+      shadowOffsetAxisFor(key)
+    );
+  }
+  if (TRANSFORM_KEY_SET.has(key)) {
+    const list = flat.transform;
+    if (!Array.isArray(list)) return void 0;
+    for (const entry of list) {
+      if (!entry || typeof entry !== "object") continue;
+      const v2 = entry[key];
+      if (v2 === void 0) continue;
+      if (ROTATION_KEYS.has(key)) return parseAngleDegrees(v2);
+      return typeof v2 === "number" ? v2 : void 0;
+    }
+    return void 0;
+  }
+  const v = flat[key];
+  if (COLOR_KEY_SET.has(key)) {
+    return typeof v === "string" || typeof v === "number" ? v : void 0;
+  }
+  return typeof v === "number" ? v : void 0;
+}
+function parseAngleDegrees(v) {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return void 0;
+  const deg = /^(-?\d*\.?\d+)deg$/.exec(v);
+  if (deg) return Number(deg[1]);
+  const rad = /^(-?\d*\.?\d+)rad$/.exec(v);
+  if (rad) return Number(rad[1]) * 180 / Math.PI;
+  return void 0;
+}
 function collectTouchedKeys(touched, record) {
   for (const k of ALL_KEYS) {
     if (k in record) touched.add(k);
@@ -928,6 +1031,9 @@ function totalIterationsOf(cfg) {
   if (r.count === "infinite") return Number.POSITIVE_INFINITY;
   return r.count;
 }
+function reachesTerminalPhase(cfg) {
+  return Number.isFinite(totalIterationsOf(cfg));
+}
 function targetEndValue(v) {
   if (v === void 0) return void 0;
   if (typeof v === "number" || typeof v === "string") return v;

package/dist/chunk-FNVFV4EY.js

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

package/dist/chunk-FWQOXA43.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunkBP3Y2SHQ_js = require('./chunk-BP3Y2SHQ.js');
+var reactNative = require('react-native');
+
+var MotionText = chunkBP3Y2SHQ_js.createMotionComponent(reactNative.Text);
+
+exports.MotionText = MotionText;

package/dist/chunk-KBP4LR75.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunkBP3Y2SHQ_js = require('./chunk-BP3Y2SHQ.js');
+var reactNative = require('react-native');
+
+var MotionImage = chunkBP3Y2SHQ_js.createMotionComponent(reactNative.Image);
+
+exports.MotionImage = MotionImage;

package/dist/{chunk-2DHKV2XY.mjs → chunk-O22NXXCZ.mjs}

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

package/dist/{chunk-HFDZAHWP.mjs → chunk-OQV66TBQ.mjs}

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

package/dist/{chunk-ZN3PNGHQ.mjs → chunk-SGUHE5CX.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-LYMLQ6WQ.mjs';
+import { createMotionComponent } from './chunk-CSODMRJ7.mjs';
 import { Text } from 'react-native';
 
 var MotionText = createMotionComponent(Text);

package/dist/{chunk-TUYHTHVV.js → chunk-W5MC3P4N.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkIWLU3VDE_js = require('./chunk-IWLU3VDE.js');
+var chunkBP3Y2SHQ_js = require('./chunk-BP3Y2SHQ.js');
 var reactNative = require('react-native');
 
-var MotionScrollView = chunkIWLU3VDE_js.createMotionComponent(reactNative.ScrollView);
+var MotionScrollView = chunkBP3Y2SHQ_js.createMotionComponent(reactNative.ScrollView);
 
 exports.MotionScrollView = MotionScrollView;