@nativescript/core 9.1.0-alpha.9 → 9.1.0-dev.0

package/ui/transition/shared-transition-helper.ios.js

@@ -3,115 +3,6 @@ import { isNumber } from '../../utils/types';
 import { Screen } from '../../platform';
 import { CORE_ANIMATION_DEFAULTS } from '../../utils/animation-helpers';
 import { ios as iOSUtils } from '../../utils/native-helper';
-import { Color } from '../../color';
-/**
- * Apply a drop shadow behind the destination view during an interactive
- * dismiss so it looks elevated above the source (Apple Music–style).
- *
- * Shadow + rounded corners can't coexist on the same CALayer on iOS — both
- * `masksToBounds = true` and `layer.mask` clip the shadow as part of the
- * compositing pipeline. So the shadow lives on a SIBLING CALayer inserted
- * below the modal's layer in its superlayer (the same pattern NS uses for
- * box-shadow via `outerShadowContainerLayer`). The modal keeps its own
- * `cornerRadius` + `masksToBounds` so subviews still clip to the rounded
- * shape.
- *
- * Because the shadow layer is a sibling (not a child), it doesn't inherit
- * the modal's transform automatically — `syncInteractiveDismissShadow`
- * mirrors transform/position/bounds during the drag.
- *
- * Falsy `shadowConfig` is a no-op.
- */
-export function applyInteractiveDismissShadow(presentedView, shadowConfig) {
-    if (!presentedView?.layer || !shadowConfig)
-        return;
-    const layer = presentedView.layer;
-    const superlayer = layer.superlayer;
-    if (!superlayer)
-        return;
-    const bounds = layer.bounds;
-    if (bounds.size.width <= 0 || bounds.size.height <= 0)
-        return;
-    // Idempotent.
-    if (presentedView.__sharedTransitionShadowLayer)
-        return;
-    const cfg = shadowConfig === true ? {} : shadowConfig;
-    const colorInput = cfg.color ?? '#000';
-    let cgColor;
-    try {
-        const nsColor = typeof colorInput === 'string' ? new Color(colorInput) : colorInput;
-        cgColor = nsColor.ios?.CGColor || nsColor.CGColor || UIColor.blackColor.CGColor;
-    }
-    catch (_) {
-        cgColor = UIColor.blackColor.CGColor;
-    }
-    const opacity = isNumber(cfg.opacity) ? cfg.opacity : 0.3;
-    const radius = isNumber(cfg.radius) ? cfg.radius : 30;
-    const offsetX = isNumber(cfg.offset?.x) ? cfg.offset.x : 0;
-    const offsetY = isNumber(cfg.offset?.y) ? cfg.offset.y : 8;
-    const cornerRadius = layer.cornerRadius || 0;
-    const roundedRectPath = UIBezierPath.bezierPathWithRoundedRectCornerRadius(CGRectMake(0, 0, bounds.size.width, bounds.size.height), cornerRadius).CGPath;
-    const shadowLayer = CALayer.layer();
-    // Match the modal's geometry so shadow tracks 1:1.
-    shadowLayer.anchorPoint = layer.anchorPoint;
-    shadowLayer.bounds = bounds;
-    shadowLayer.position = layer.position;
-    shadowLayer.transform = layer.transform;
-    shadowLayer.shadowColor = cgColor;
-    shadowLayer.shadowOpacity = opacity;
-    shadowLayer.shadowRadius = radius;
-    shadowLayer.shadowOffset = CGSizeMake(offsetX, offsetY);
-    // Explicit shadowPath = shadow renders from this shape outward;
-    // the layer itself stays fully transparent.
-    shadowLayer.shadowPath = roundedRectPath;
-    CATransaction.begin();
-    CATransaction.setDisableActions(true);
-    superlayer.insertSublayerBelow(shadowLayer, layer);
-    CATransaction.commit();
-    presentedView.__sharedTransitionShadowLayer = shadowLayer;
-}
-/**
- * Mirror the modal layer's geometry onto the sibling shadow layer so the
- * shadow tracks the interactive drag. Called from the gesture handlers
- * after the modal's state has been updated (either via direct transform
- * in morph mode, or via `interactiveController.updateInteractiveTransition`
- * for the non-morph modal/page case driven by UIViewPropertyAnimator).
- *
- * Reads the layer's **presentation** values when an animation is in flight
- * — model values would point at the animation's end state and snap the
- * shadow there. Falls back to model values when no animation is running.
- */
-export function syncInteractiveDismissShadow(presentedView) {
-    const shadowLayer = presentedView?.__sharedTransitionShadowLayer;
-    if (!shadowLayer || !presentedView?.layer)
-        return;
-    const layer = presentedView.layer;
-    const pres = typeof layer.presentationLayer === 'function' ? layer.presentationLayer() : null;
-    const src = pres || layer;
-    const b = src.bounds;
-    CATransaction.begin();
-    CATransaction.setDisableActions(true);
-    shadowLayer.bounds = b;
-    shadowLayer.position = src.position;
-    shadowLayer.anchorPoint = src.anchorPoint;
-    shadowLayer.transform = src.transform;
-    shadowLayer.shadowPath = UIBezierPath.bezierPathWithRoundedRectCornerRadius(CGRectMake(0, 0, b.size.width, b.size.height), src.cornerRadius || 0).CGPath;
-    CATransaction.commit();
-}
-/**
- * Remove the sibling shadow layer. Safe to call repeatedly / when no
- * shadow was applied.
- */
-export function removeInteractiveDismissShadow(presentedView) {
-    const shadowLayer = presentedView?.__sharedTransitionShadowLayer;
-    if (!shadowLayer)
-        return;
-    CATransaction.begin();
-    CATransaction.setDisableActions(true);
-    shadowLayer.removeFromSuperlayer();
-    CATransaction.commit();
-    presentedView.__sharedTransitionShadowLayer = null;
-}
 export class SharedTransitionHelper {
     static animate(state, transitionContext, type) {
         const transition = state.instance;
@@ -143,10 +34,6 @@ export class SharedTransitionHelper {
                             independent: [],
                         };
                     }
-                    // Track every matched source view so cleanup can restore alpha,
-                    // including duplicates (same album surfacing in multiple lists)
-                    // that we hide but don't create a snapshot for.
-                    transition.sharedElements._allPresentingViews = sharedElements.slice();
                     if (SharedTransition.DEBUG) {
                         console.log(`  ${type}: Present`);
                         console.log(`1. Found sharedTransitionTags to animate:`, sharedElementTags);
@@ -159,22 +46,12 @@ export class SharedTransitionHelper {
                     const pageEndTags = pageEnd?.sharedTransitionTags || {};
                     // console.log('pageEndIndependentTags:', pageEndIndependentTags);
                     const positionSharedTags = async () => {
-                        const processedTags = new Set();
                         for (const presentingView of sharedElements) {
                             const presentingSharedElement = presentingView.ios;
-                            const tag = presentingView.sharedTransitionTag;
-                            if (processedTags.has(tag)) {
-                                // The same item can appear in multiple lists on the source page
-                                // (e.g., a featured album also surfacing in "Recently Played").
-                                // Each instance has the same sharedTransitionTag. Only the first
-                                // one becomes the snapshot origin; the rest must still be hidden
-                                // so they don't show through behind the animating snapshot.
-                                if (presentingSharedElement) {
-                                    presentingSharedElement.alpha = 0;
-                                }
-                                continue;
-                            }
-                            processedTags.add(tag);
+                            // console.log('fromTarget instanceof UIImageView:', fromTarget instanceof UIImageView)
+                            // TODO: discuss whether we should check if UIImage/UIImageView type to always snapshot images or if other view types could be duped/added vs. snapshotted
+                            // Note: snapshot may be most efficient/simple
+                            // console.log('---> ', presentingView.sharedTransitionTag, ': ', presentingSharedElement)
                             const presentedView = presented.find((v) => v.sharedTransitionTag === presentingView.sharedTransitionTag);
                             const presentedSharedElement = presentedView.ios;
                             const pageEndProps = pageEndTags[presentingView.sharedTransitionTag];
@@ -183,25 +60,15 @@ export class SharedTransitionHelper {
                                 await pageEndProps?.callback(presentedView, 'present');
                             }
                             // treat images differently...
-                            let imageSourceChangeListener;
                             if (presentedSharedElement instanceof UIImageView) {
-                                // In case the image is loaded async, keep the snapshot's image in sync with
-                                // the destination view's image. We hold a ref so we can detach the listener
-                                // on cleanup (the View would otherwise hold a strong ref via the observers
-                                // map and the snapshot closure would leak).
-                                imageSourceChangeListener = () => {
+                                // in case the image is loaded async, we need to update the snapshot when it changes
+                                // todo: remove listener on transition end
+                                presentedView.on('imageSourceChange', () => {
                                     snapshot.image = iOSUtils.snapshotView(presentedSharedElement, Screen.mainScreen.scale);
                                     snapshot.tintColor = presentedSharedElement.tintColor;
-                                };
-                                presentedView.on('imageSourceChange', imageSourceChangeListener);
+                                });
                                 snapshot.tintColor = presentedSharedElement.tintColor;
                                 snapshot.contentMode = presentedSharedElement.contentMode;
-                                // Seed the snapshot with the source's already-loaded image so the very
-                                // first frame of the animation isn't blank if the destination image is
-                                // still loading.
-                                if (presentingSharedElement instanceof UIImageView) {
-                                    snapshot.image = presentingSharedElement.image;
-                                }
                             }
                             iOSUtils.copyLayerProperties(snapshot, presentingSharedElement, pageEndProps?.propertiesToMatch);
                             snapshot.clipsToBounds = true;
@@ -229,115 +96,86 @@ export class SharedTransitionHelper {
                                 startOpacity: presentedView.opacity,
                                 endOpacity: presentingView.opacity,
                                 propertiesToMatch: pageEndProps?.propertiesToMatch,
-                                imageSourceChangeListener,
                             });
                             // set initial opacity to match the source view opacity
                             snapshot.alpha = presentingView.opacity;
-                            // Hide both while animating in the transition context.
-                            //
-                            // We mutate native alpha directly rather than NS `opacity` so the NS-side
-                            // style remains the user's intended value (typically 1). If we instead set
-                            // `view.opacity = 0` and then a transition was interrupted before cleanup
-                            // (or the page was reused), `startOpacity` here could capture 0 from a prior
-                            // run and the cleanup below would leave the destination invisible.
-                            presentingSharedElement.alpha = 0;
-                            presentedSharedElement.alpha = 0;
+                            // hide both while animating within the transition context
+                            presentingView.opacity = 0;
+                            presentedView.opacity = 0;
                         }
                     };
                     const positionIndependentTags = async () => {
-                        // "Independent" tags appear on only one of the two pages (or were
-                        // explicitly enumerated in pageEnd.sharedTransitionTags). We auto-discover
-                        // them so authors don't have to enumerate every tag manually:
-                        //   - source-only (orphan on presenting): fade *out* on present, fade
-                        //     back in on dismiss. e.g., a "FEATURED ALBUM" label on a hero card
-                        //     that has no counterpart on the destination page.
-                        //   - destination-only (orphan on presented): fade *in* on present, fade
-                        //     back out on dismiss. e.g., metadata that only exists on the detail
-                        //     page.
-                        // Authors can override per-tag via pageStart / pageEnd `sharedTransitionTags`
-                        // (e.g. add `y: -20` to slide while fading), or opt a view out entirely
-                        // with `sharedTransitionIgnore`.
-                        const orphanTags = [];
-                        const seenOrphan = new Set();
-                        const addOrphan = (tag) => {
-                            if (!tag || seenOrphan.has(tag) || sharedElementTags.includes(tag))
-                                return;
-                            seenOrphan.add(tag);
-                            orphanTags.push(tag);
-                        };
-                        for (const v of presenting)
-                            addOrphan(v.sharedTransitionTag);
-                        for (const v of presented)
-                            addOrphan(v.sharedTransitionTag);
-                        // Tags the user listed in pageEnd.sharedTransitionTags but that don't
-                        // match a real view are silently skipped further down — keep them in
-                        // the iteration so per-tag config still applies to existing orphans.
-                        for (const tag in pageEndTags)
-                            addOrphan(tag);
-                        for (const tag of orphanTags) {
-                            const pageStartIndependentProps = pageStart?.sharedTransitionTags ? pageStart?.sharedTransitionTags[tag] : null;
-                            const pageEndProps = pageEndTags[tag];
-                            let independentView = presenting.find((v) => v.sharedTransitionTag === tag);
-                            let isPresented = false;
-                            if (!independentView) {
-                                independentView = presented.find((v) => v.sharedTransitionTag === tag);
+                        // independent tags
+                        for (const tag in pageEndTags) {
+                            // only handle if independent (otherwise it's shared between both pages and handled above)
+                            if (!sharedElementTags.includes(tag)) {
+                                // only consider start when there's a matching end
+                                const pageStartIndependentProps = pageStart?.sharedTransitionTags ? pageStart?.sharedTransitionTags[tag] : null;
+                                // console.log('start:', tag, pageStartIndependentProps);
+                                const pageEndProps = pageEndTags[tag];
+                                let independentView = presenting.find((v) => v.sharedTransitionTag === tag);
+                                let isPresented = false;
                                 if (!independentView) {
-                                    // Tag declared in config but no matching view; skip (don't
-                                    // break — later tags might still resolve).
-                                    continue;
+                                    independentView = presented.find((v) => v.sharedTransitionTag === tag);
+                                    if (!independentView) {
+                                        break;
+                                    }
+                                    isPresented = true;
                                 }
-                                isPresented = true;
-                            }
-                            const independentSharedElement = independentView.ios;
-                            if (pageEndProps?.callback) {
-                                await pageEndProps?.callback(independentView, 'present');
-                            }
-                            const snapshot = UIImageView.alloc().initWithImage(iOSUtils.snapshotView(independentSharedElement, Screen.mainScreen.scale));
-                            if (independentSharedElement instanceof UIImageView) {
-                                snapshot.tintColor = independentSharedElement.tintColor;
-                                snapshot.contentMode = independentSharedElement.contentMode;
-                            }
-                            snapshot.clipsToBounds = true;
-                            // Copy layer properties (cornerRadius, borderWidth/Color)
-                            // from the source view so the snapshot renders with the
-                            // same rounded corners. Without this, source-side
-                            // thumbnails/buttons appear with sharp square corners
-                            // during a non-morph interactive dismiss — the snapshot
-                            // is what the user sees through the dismissing modal,
-                            // and its layer is freshly created with cornerRadius 0.
-                            iOSUtils.copyLayerProperties(snapshot, independentSharedElement, pageEndProps?.propertiesToMatch);
-                            const startFrame = independentSharedElement.convertRectToView(independentSharedElement.bounds, transitionContext.containerView);
-                            snapshot.frame = startFrame;
-                            if (SharedTransition.DEBUG) {
-                                console.log('---> ', independentView.sharedTransitionTag, ' frame:', iOSUtils.printCGRect(snapshot.frame));
+                                const independentSharedElement = independentView.ios;
+                                if (pageEndProps?.callback) {
+                                    await pageEndProps?.callback(independentView, 'present');
+                                }
+                                // let snapshot: UIImageView;
+                                // if (isPresented) {
+                                // 	snapshot = UIImageView.alloc().init();
+                                // } else {
+                                const snapshot = UIImageView.alloc().initWithImage(iOSUtils.snapshotView(independentSharedElement, Screen.mainScreen.scale));
+                                // }
+                                if (independentSharedElement instanceof UIImageView) {
+                                    // in case the image is loaded async, we need to update the snapshot when it changes
+                                    // todo: remove listener on transition end
+                                    // if (isPresented) {
+                                    // 	independentView.on('imageSourceChange', () => {
+                                    // 		snapshot.image = iOSNativeHelper.snapshotView(independentSharedElement, Screen.mainScreen.scale);
+                                    // 		snapshot.tintColor = independentSharedElement.tintColor;
+                                    // 	});
+                                    // }
+                                    snapshot.tintColor = independentSharedElement.tintColor;
+                                    snapshot.contentMode = independentSharedElement.contentMode;
+                                }
+                                snapshot.clipsToBounds = true;
+                                const startFrame = independentSharedElement.convertRectToView(independentSharedElement.bounds, transitionContext.containerView);
+                                const startFrameRect = getRectFromProps(pageStartIndependentProps);
+                                // adjust for any specified start positions
+                                const startFrameAdjusted = CGRectMake(startFrame.origin.x + startFrameRect.x, startFrame.origin.y + startFrameRect.y, startFrame.size.width, startFrame.size.height);
+                                // console.log('startFrameAdjusted:', tag, iOSNativeHelper.printCGRect(startFrameAdjusted));
+                                // if (pageStartIndependentProps?.scale) {
+                                // 	snapshot.transform = CGAffineTransformConcat(CGAffineTransformMakeTranslation(startFrameAdjusted.origin.x, startFrameAdjusted.origin.y), CGAffineTransformMakeScale(pageStartIndependentProps.scale.x, pageStartIndependentProps.scale.y))
+                                // } else {
+                                snapshot.frame = startFrame; //startFrameAdjusted;
+                                // }
+                                if (SharedTransition.DEBUG) {
+                                    console.log('---> ', independentView.sharedTransitionTag, ' frame:', iOSUtils.printCGRect(snapshot.frame));
+                                }
+                                const endFrameRect = getRectFromProps(pageEndProps);
+                                const endFrame = CGRectMake(startFrame.origin.x + endFrameRect.x, startFrame.origin.y + endFrameRect.y, startFrame.size.width, startFrame.size.height);
+                                // console.log('endFrame:', tag, iOSNativeHelper.printCGRect(endFrame));
+                                transition.sharedElements.independent.push({
+                                    view: independentView,
+                                    isPresented,
+                                    startFrame,
+                                    snapshot,
+                                    endFrame,
+                                    startTransform: independentSharedElement.transform,
+                                    scale: pageEndProps.scale,
+                                    startOpacity: independentView.opacity,
+                                    endOpacity: isNumber(pageEndProps.opacity) ? pageEndProps.opacity : 0,
+                                    propertiesToMatch: pageEndProps?.propertiesToMatch,
+                                    zIndex: isNumber(pageEndProps?.zIndex) ? pageEndProps.zIndex : 0,
+                                });
+                                independentView.opacity = 0;
                             }
-                            const endFrameRect = getRectFromProps(pageEndProps);
-                            const endFrame = CGRectMake(startFrame.origin.x + (endFrameRect.x || 0), startFrame.origin.y + (endFrameRect.y || 0), startFrame.size.width, startFrame.size.height);
-                            // Opacity defaults are side-aware: source-only orphans fade out (1 → 0),
-                            // destination-only orphans fade in (0 → 1). The values are read back
-                            // during dismiss as `endOpacity → startOpacity` so the return phase is
-                            // automatically symmetric. Author-supplied opacity always wins.
-                            const startOpacity = isNumber(pageStartIndependentProps?.opacity) ? pageStartIndependentProps.opacity : isPresented ? 0 : independentView.opacity;
-                            const endOpacity = isNumber(pageEndProps?.opacity) ? pageEndProps.opacity : isPresented ? independentView.opacity : 0;
-                            // Snapshot's initial visible alpha. Default UIImageView alpha is 1;
-                            // destination-only orphans need to start at 0 so the fade-in is
-                            // visible, hence we always set it explicitly.
-                            snapshot.alpha = startOpacity;
-                            transition.sharedElements.independent.push({
-                                view: independentView,
-                                isPresented,
-                                startFrame,
-                                snapshot,
-                                endFrame,
-                                startTransform: independentSharedElement.transform,
-                                scale: pageEndProps?.scale,
-                                startOpacity,
-                                endOpacity,
-                                propertiesToMatch: pageEndProps?.propertiesToMatch,
-                                zIndex: isNumber(pageEndProps?.zIndex) ? pageEndProps.zIndex : 0,
-                            });
-                            // Native alpha; see comment in positionSharedTags.
-                            independentSharedElement.alpha = 0;
                         }
                     };
                     // position all sharedTransitionTag elements
@@ -345,7 +183,7 @@ export class SharedTransitionHelper {
                     await positionIndependentTags();
                     // combine to order by zIndex and add to transition context
                     const snapshotData = transition.sharedElements.presenting.concat(transition.sharedElements.independent);
-                    snapshotData.sort((a, b) => (a.zIndex || 0) - (b.zIndex || 0));
+                    snapshotData.sort((a, b) => (a.zIndex > b.zIndex ? 1 : -1));
                     if (SharedTransition.DEBUG) {
                         console.log(`zIndex settings:`, snapshotData.map((s) => {
                             return {
@@ -361,41 +199,9 @@ export class SharedTransitionHelper {
                     // Important: always set after above shared element positions have had their start positions set
                     transition.presented.view.alpha = isNumber(pageStart?.opacity) ? pageStart?.opacity : 0;
                     transition.presented.view.frame = CGRectMake(startFrame.x, startFrame.y, startFrame.width, startFrame.height);
-                    // Optional top-corner rounding for sheet-style transitions (e.g.
-                    // a modal that's rounded at the bottom of the screen and flattens
-                    // as it slides up). Setting maskedCorners and masksToBounds here
-                    // (before the animation) so they're stable during the animated
-                    // cornerRadius change.
-                    if (isNumber(pageStart?.cornerRadius) || isNumber(pageEnd?.cornerRadius)) {
-                        const layer = transition.presented.view.layer;
-                        // top-left | top-right | bottom-left | bottom-right (CACornerMask bits)
-                        layer.maskedCorners = 15;
-                        layer.masksToBounds = true;
-                        if (isNumber(pageStart?.cornerRadius)) {
-                            layer.cornerRadius = pageStart.cornerRadius;
-                        }
-                    }
                     const cleanupPresent = () => {
                         for (const presented of transition.sharedElements.presented) {
-                            // Detach the per-transition imageSourceChange listener registered
-                            // during positionSharedTags so it doesn't leak (the snapshot is gone).
-                            if (presented.imageSourceChangeListener) {
-                                presented.view.off('imageSourceChange', presented.imageSourceChangeListener);
-                                presented.imageSourceChangeListener = null;
-                            }
-                            // Restore the destination native alpha from the NS opacity (the source
-                            // of truth). NS opacity wasn't modified during the transition, so this
-                            // reflects the user's intended visibility (typically 1).
-                            presented.view.ios.alpha = presented.view.opacity;
-                        }
-                        // Restore native alpha on every source view we touched — including
-                        // duplicates that share a sharedTransitionTag and were hidden without
-                        // a snapshot. Even though the source page is being removed, the View
-                        // instances may be reused on subsequent navigations.
-                        for (const sourceView of transition.sharedElements._allPresentingViews || []) {
-                            if (sourceView?.ios) {
-                                sourceView.ios.alpha = sourceView.opacity;
-                            }
+                            presented.view.opacity = presented.startOpacity;
                         }
                         for (const presenting of transition.sharedElements.presenting) {
                             presenting.snapshot.removeFromSuperview();
@@ -403,7 +209,7 @@ export class SharedTransitionHelper {
                         for (const independent of transition.sharedElements.independent) {
                             independent.snapshot.removeFromSuperview();
                             if (independent.isPresented) {
-                                independent.view.ios.alpha = independent.view.opacity;
+                                independent.view.opacity = independent.startOpacity;
                             }
                         }
                         SharedTransition.updateState(transition.id, {
@@ -426,12 +232,6 @@ export class SharedTransitionHelper {
                         transition.presented.view.alpha = isNumber(pageEnd?.opacity) ? pageEnd?.opacity : 1;
                         const endFrame = getRectFromProps(pageEnd);
                         transition.presented.view.frame = CGRectMake(endFrame.x, endFrame.y, endFrame.width, endFrame.height);
-                        // Animate cornerRadius alongside the page frame. Implicit animation
-                        // of cornerRadius is supported on iOS 11+, both inside
-                        // UIView.animateWith… and UIViewPropertyAnimator's animations block.
-                        if (isNumber(pageEnd?.cornerRadius)) {
-                            transition.presented.view.layer.cornerRadius = pageEnd.cornerRadius;
-                        }
                         if (pageOut) {
                             if (isNumber(pageOut.opacity)) {
                                 transition.presenting.view.alpha = pageOut?.opacity;
@@ -510,23 +310,6 @@ export class SharedTransitionHelper {
                     });
                     if (type === 'page') {
                         transitionContext.containerView.insertSubviewBelowSubview(transition.presenting.view, transition.presented.view);
-                        // UIKit's standard pop places the incoming source view off to the
-                        // left so it can slide into position; for custom shared transitions
-                        // (where the destination either slides down or morphs to source) we
-                        // don't want that lateral slide. Pin the source to its fullscreen
-                        // frame so it stays put underneath the animating destination.
-                        // Users can still opt into a custom source animation via `pageOut`.
-                        const sourceDefaults = getRectFromProps(null);
-                        transition.presenting.view.frame = CGRectMake(0, 0, sourceDefaults.width, sourceDefaults.height);
-                    }
-                    // Morph + interactive dismiss: the gesture handler drives the
-                    // animation via transforms and finalizes by calling cancel/finish
-                    // on the transitionContext. Running the standard snapshot + spring
-                    // rig here would race that and frequently call completeTransition(true)
-                    // *before* the user's gesture ended — causing the dismiss to commit
-                    // even on a cancel. Skip the rest of the dismiss setup entirely.
-                    if (state.interactive?.dismiss?.morph && state.interactiveBegan) {
-                        return;
                     }
                     // console.log('transitionContext.containerView.subviews.count:', transitionContext.containerView.subviews.count);
                     if (SharedTransition.DEBUG) {
@@ -539,21 +322,11 @@ export class SharedTransitionHelper {
                     const pageEndTags = pageEnd?.sharedTransitionTags || {};
                     const pageReturn = state.pageReturn;
                     for (const p of transition.sharedElements.presented) {
-                        // Use native alpha (not NS opacity) so we don't pollute the NS-side
-                        // value if the dismiss is interrupted; cleanup restores from NS opacity.
-                        p.view.ios.alpha = 0;
-                    }
-                    // Ensure top-corner masking + clipping is in place before we animate
-                    // cornerRadius back toward the start value. If the present pass already
-                    // set these, this is a harmless no-op.
-                    if (isNumber(pageReturn?.cornerRadius)) {
-                        const layer = transition.presented.view.layer;
-                        layer.maskedCorners = 15; // top-left | top-right | bottom-left | bottom-right
-                        layer.masksToBounds = true;
+                        p.view.opacity = 0;
                     }
                     // combine to order by zIndex and add to transition context
                     const snapshotData = transition.sharedElements.presenting.concat(transition.sharedElements.independent);
-                    snapshotData.sort((a, b) => (a.zIndex || 0) - (b.zIndex || 0));
+                    snapshotData.sort((a, b) => (a.zIndex > b.zIndex ? 1 : -1));
                     if (SharedTransition.DEBUG) {
                         console.log(`zIndex settings:`, snapshotData.map((s) => {
                             return {
@@ -592,43 +365,13 @@ export class SharedTransitionHelper {
                         // add snapshot to animate
                         transitionContext.containerView.addSubview(data.snapshot);
                     }
-                    // Hide every source-side shared element now that snapshots have been
-                    // captured. The animating snapshot covers them; without this, the user
-                    // sees a "double image" — the real source element AND the snapshot
-                    // animating over it back to its position. Use the full list (not just
-                    // the deduped `presenting`) so duplicates from sister lists are hidden
-                    // too. Restored in cleanupDismiss below.
-                    for (const sourceView of transition.sharedElements._allPresentingViews || []) {
-                        if (sourceView?.ios) {
-                            sourceView.ios.alpha = 0;
-                        }
-                    }
                     const cleanupDismiss = () => {
-                        // Restore alpha on every source view we hid — including duplicate
-                        // sources with the same sharedTransitionTag — using NS opacity as
-                        // the source of truth.
-                        for (const sourceView of transition.sharedElements._allPresentingViews || []) {
-                            if (sourceView?.ios) {
-                                sourceView.ios.alpha = sourceView.opacity;
-                            }
-                        }
                         for (const presenting of transition.sharedElements.presenting) {
+                            presenting.view.opacity = presenting.startOpacity;
                             presenting.snapshot.removeFromSuperview();
                         }
-                        for (const presented of transition.sharedElements.presented) {
-                            // Detach the imageSourceChange listener and restore alpha. Even though
-                            // the destination page is being torn down, NS Views can outlive their
-                            // nativeView and we shouldn't leak observers.
-                            if (presented.imageSourceChangeListener) {
-                                presented.view.off('imageSourceChange', presented.imageSourceChangeListener);
-                                presented.imageSourceChangeListener = null;
-                            }
-                            if (presented.view.ios) {
-                                presented.view.ios.alpha = presented.view.opacity;
-                            }
-                        }
                         for (const independent of transition.sharedElements.independent) {
-                            independent.view.ios.alpha = independent.view.opacity;
+                            independent.view.opacity = independent.startOpacity;
                             independent.snapshot.removeFromSuperview();
                         }
                         SharedTransition.finishState(transition.id);
@@ -647,11 +390,6 @@ export class SharedTransitionHelper {
                         transition.presented.view.alpha = isNumber(pageReturn?.opacity) ? pageReturn?.opacity : 0;
                         const endFrame = getRectFromProps(pageReturn, getPageStartDefaultsForType(type));
                         transition.presented.view.frame = CGRectMake(endFrame.x, endFrame.y, endFrame.width, endFrame.height);
-                        // Animate cornerRadius back toward the start value (e.g. a sheet
-                        // re-rounds as it slides offscreen).
-                        if (isNumber(pageReturn?.cornerRadius)) {
-                            transition.presented.view.layer.cornerRadius = pageReturn.cornerRadius;
-                        }
                         if (pageOut) {
                             // always return to defaults if pageOut had been used
                             transition.presenting.view.alpha = 1;
@@ -712,78 +450,20 @@ export class SharedTransitionHelper {
         switch (type) {
             case 'page':
                 interactiveState.transitionContext.containerView.insertSubviewBelowSubview(state.instance.presenting.view, state.instance.presented.view);
-                // Pin the source view to its fullscreen frame so it doesn't slide
-                // in from off-left as the user drags. The default UIKit pop expects
-                // to animate the source from off-left; for shared-element / morph
-                // transitions we want the source to stay put underneath the
-                // animating destination so the visuals feel connected.
-                {
-                    const sourceDefaults = getRectFromProps(null);
-                    state.instance.presenting.view.frame = CGRectMake(0, 0, sourceDefaults.width, sourceDefaults.height);
-                }
                 break;
         }
-        // Apply the dismiss shadow here, not from the gesture handler. UIKit
-        // reparents the presented view into the transition containerView as
-        // part of starting the interactive transition; applying earlier would
-        // attach the shadow to the now-orphaned old superlayer.
-        if (state.interactive?.dismiss?.shadow && state.instance?.presented?.view) {
-            applyInteractiveDismissShadow(state.instance.presented.view, state.interactive.dismiss.shadow);
-        }
     }
     static interactiveUpdate(state, interactiveState, type, percent) {
         if (interactiveState) {
-            if (state.interactive?.dismiss?.morph) {
-                // Morph mode: the gesture handler drives the destination view's
-                // transform directly. We only forward the event so observers can
-                // react to the gesture's percentage.
-                SharedTransition.notifyEvent(SharedTransition.interactiveUpdateEvent, {
-                    id: state?.instance?.id,
-                    type,
-                    percent,
-                });
-                return;
-            }
             if (!interactiveState.added) {
-                // Defer setup until the gesture has clearly committed to a horizontal
-                // dismiss motion. A vertical scroll on a descendant scroll view also
-                // triggers the page-level pan gesture (NS pan recognizers don't yield
-                // to scroll-view pans by default), producing near-zero percent values.
-                // Without this guard we'd mount the dismiss snapshots and hide the
-                // destination during a scroll, making the image look "stuck" until the
-                // cancel animation runs.
-                if (Math.abs(percent) < 0.05) {
-                    return;
-                }
                 interactiveState.added = true;
                 for (const p of state.instance.sharedElements.presented) {
-                    // Native alpha (not NS opacity) for the same reason as the dismiss path:
-                    // if the user lets go without crossing the threshold, cancel uses NS
-                    // opacity as source of truth to restore.
-                    p.view.ios.alpha = 0;
+                    p.view.opacity = 0;
                 }
                 for (const p of state.instance.sharedElements.presenting) {
                     p.snapshot.alpha = p.endOpacity;
                     interactiveState.transitionContext.containerView.addSubview(p.snapshot);
                 }
-                // Re-mount independent (orphan) snapshots so they're available to
-                // animate alongside the gesture. They were removed in present cleanup
-                // but the records (including their snapshots) live on transition.sharedElements.
-                // Source-only orphans were left at alpha 0 since present; their snapshots
-                // pick up where the present animation left off (endOpacity).
-                for (const ind of state.instance.sharedElements.independent) {
-                    ind.snapshot.alpha = ind.endOpacity;
-                    interactiveState.transitionContext.containerView.addSubview(ind.snapshot);
-                }
-                // Hide every source-side shared element (including duplicates that share
-                // a sharedTransitionTag in sister lists) so the user only sees the
-                // animating snapshot — not the snapshot AND the real source element
-                // simultaneously ("double image" during interactive dismissal).
-                for (const sourceView of state.instance.sharedElements._allPresentingViews || []) {
-                    if (sourceView?.ios) {
-                        sourceView.ios.alpha = 0;
-                    }
-                }
                 const pageStart = state.pageStart;
                 const startFrame = getRectFromProps(pageStart, getPageStartDefaultsForType(type));
                 interactiveState.propertyAnimator = UIViewPropertyAnimator.alloc().initWithDurationDampingRatioAnimations(1, 1, () => {
@@ -792,25 +472,8 @@ export class SharedTransitionHelper {
                         iOSUtils.copyLayerProperties(p.snapshot, p.view.ios, p.propertiesToMatch);
                         p.snapshot.alpha = 1;
                     }
-                    // Animate orphan snapshots back toward their start state alongside
-                    // the rest of the dismiss. For source-only orphans this is the
-                    // fade-back-in that mirrors the fade-out of present.
-                    for (const ind of state.instance.sharedElements.independent) {
-                        ind.snapshot.alpha = ind.startOpacity;
-                        if (ind.scale) {
-                            ind.snapshot.transform = ind.startTransform;
-                        }
-                        else {
-                            ind.snapshot.frame = ind.startFrame;
-                        }
-                    }
                     state.instance.presented.view.alpha = isNumber(state.pageReturn?.opacity) ? state.pageReturn?.opacity : 0;
                     state.instance.presented.view.frame = CGRectMake(startFrame.x, startFrame.y, state.instance.presented.view.bounds.size.width, state.instance.presented.view.bounds.size.height);
-                    // Drive cornerRadius via the same percent the user controls — round
-                    // the page back up as they pan it offscreen.
-                    if (isNumber(state.pageReturn?.cornerRadius)) {
-                        state.instance.presented.view.layer.cornerRadius = state.pageReturn.cornerRadius;
-                    }
                 });
             }
             interactiveState.propertyAnimator.fractionComplete = percent;
@@ -822,108 +485,17 @@ export class SharedTransitionHelper {
         }
     }
     static interactiveCancel(state, interactiveState, type) {
-        if (state?.instance && interactiveState && state.interactive?.dismiss?.morph) {
-            // Morph mode cancel — spring the destination view back to identity.
-            const view = state.instance.presented?.view;
-            let didFinalize = false;
-            const finalize = () => {
-                if (didFinalize)
-                    return;
-                didFinalize = true;
-                if (view)
-                    view.transform = CGAffineTransformIdentity;
-                // Restore the source-side element alphas that the gesture hid on
-                // engagement so the source page is correct when shown again.
-                for (const v of state.instance.sharedElements?._allPresentingViews || []) {
-                    if (v?.ios)
-                        v.ios.alpha = v.opacity;
-                }
-                if (interactiveState.transitionContext) {
-                    interactiveState.transitionContext.cancelInteractiveTransition();
-                    interactiveState.transitionContext.completeTransition(false);
-                }
-                SharedTransition.updateState(state?.instance?.id, {
-                    interactiveBegan: false,
-                    interactiveCancelled: true,
-                });
-                SharedTransition.notifyEvent(SharedTransition.interactiveCancelledEvent, {
-                    id: state?.instance?.id,
-                    type,
-                });
-            };
-            if (view) {
-                iOSUtils.animateWithSpring({
-                    animations: () => {
-                        view.transform = CGAffineTransformIdentity;
-                        // Cross-fade sources back IN PARALLEL with the spring so
-                        // they're visible from frame one of the snap-back. This
-                        // also makes the source restoration robust to a new
-                        // gesture interrupting our completion callback.
-                        for (const v of state.instance.sharedElements?._allPresentingViews || []) {
-                            if (v?.ios)
-                                v.ios.alpha = v.opacity;
-                        }
-                    },
-                    completion: () => finalize(),
-                });
-                // Safety: ensure finalize runs even if the animation completion
-                // is dropped (e.g. interrupted by another gesture).
-                setTimeout(finalize, 800);
-            }
-            else {
-                finalize();
-            }
-            return;
-        }
-        if (state?.instance && interactiveState && !interactiveState.added) {
-            // The gesture engaged the interactive transition but never crossed the
-            // motion threshold in interactiveUpdate (e.g., the user was scrolling
-            // vertically). Nothing was visually set up — just tell UIKit we're
-            // cancelling and clear the flags.
-            if (interactiveState.transitionContext) {
-                interactiveState.transitionContext.cancelInteractiveTransition();
-                interactiveState.transitionContext.completeTransition(false);
-            }
-            SharedTransition.updateState(state?.instance?.id, {
-                interactiveBegan: false,
-                interactiveCancelled: true,
-            });
-            SharedTransition.notifyEvent(SharedTransition.interactiveCancelledEvent, {
-                id: state?.instance?.id,
-                type,
-            });
-            return;
-        }
         if (state?.instance && interactiveState?.added && interactiveState?.propertyAnimator) {
             interactiveState.propertyAnimator.reversed = true;
             const duration = isNumber(state.pageEnd?.duration) ? state.pageEnd?.duration / 1000 : CORE_ANIMATION_DEFAULTS.duration;
             interactiveState.propertyAnimator.continueAnimationWithTimingParametersDurationFactor(null, duration);
             setTimeout(() => {
                 for (const p of state.instance.sharedElements.presented) {
-                    // Restore native alpha from NS opacity (the user-intended value).
-                    p.view.ios.alpha = p.view.opacity;
-                }
-                // Restore alpha on every source view we hid during interactiveUpdate
-                // (including duplicates from sister lists).
-                for (const sourceView of state.instance.sharedElements._allPresentingViews || []) {
-                    if (sourceView?.ios) {
-                        sourceView.ios.alpha = sourceView.opacity;
-                    }
+                    p.view.opacity = 1;
                 }
                 for (const p of state.instance.sharedElements.presenting) {
                     p.snapshot.removeFromSuperview();
                 }
-                // Tear down orphan snapshots that interactiveUpdate re-mounted. The
-                // source-only orphans' view.alpha stays at 0 — we're returning to the
-                // presented (modal-on-top) state, so they should remain hidden until
-                // a real dismiss completes. Cancel/finish for the next dismiss owns
-                // the eventual restore.
-                for (const ind of state.instance.sharedElements.independent) {
-                    ind.snapshot.removeFromSuperview();
-                    // Reset snapshot alpha to its post-present end state so a subsequent
-                    // interactiveUpdate picks up from the right place.
-                    ind.snapshot.alpha = ind.endOpacity;
-                }
                 state.instance.presented.view.alpha = 1;
                 interactiveState.propertyAnimator = null;
                 interactiveState.added = false;
@@ -941,263 +513,15 @@ export class SharedTransitionHelper {
         }
     }
     static interactiveFinish(state, interactiveState, type) {
-        if (state?.instance && interactiveState && state.interactive?.dismiss?.morph) {
-            // Morph mode finish — animate the destination view to the matching
-            // source element's frame and fade it out, then complete.
-            const view = state.instance.presented?.view;
-            const destPresented = state.instance.sharedElements?.presented?.[0];
-            const destTag = destPresented?.view?.sharedTransitionTag;
-            const matchingSource = state.instance.sharedElements?.presenting?.find?.((p) => p.view.sharedTransitionTag === destTag);
-            const srcIos = matchingSource?.view?.ios;
-            const destSharedIos = destPresented?.view?.ios;
-            const containerView = interactiveState.transitionContext?.containerView;
-            let targetTransform = null;
-            if (view && srcIos && containerView) {
-                const sourceFrame = srcIos.convertRectToView(srcIos.bounds, containerView);
-                const bounds = view.bounds;
-                if (bounds.size.width > 0 && bounds.size.height > 0 && sourceFrame.size.width > 0 && sourceFrame.size.height > 0) {
-                    // Anchor the modal's transform on the *internal* matched
-                    // element (e.g. the album art inside the modal) so that the
-                    // modal and the matched element converge along the same
-                    // trajectory to the source thumbnail. Without this, the modal
-                    // scales around its own center while the matched-element
-                    // snapshot flies separately to source — making the two visibly
-                    // drift apart mid-spring.
-                    //
-                    // Pick a uniform scale that takes the modal's matched element
-                    // to the source's size. For square album art (both sides) this
-                    // is exact; for slightly off-square sources (e.g. 360×380) we
-                    // match width and let the small remainder be hidden by the
-                    // fade-out.
-                    const destSharedFrameInModal = destSharedIos ? destSharedIos.convertRectToView(destSharedIos.bounds, view) : null;
-                    const sx = sourceFrame.size.width / bounds.size.width;
-                    const sy = sourceFrame.size.height / bounds.size.height;
-                    const targetCx = sourceFrame.origin.x + sourceFrame.size.width / 2;
-                    const targetCy = sourceFrame.origin.y + sourceFrame.size.height / 2;
-                    const modalCx = bounds.size.width / 2;
-                    const modalCy = bounds.size.height / 2;
-                    let tx;
-                    let ty;
-                    if (destSharedFrameInModal && destSharedFrameInModal.size.width > 0 && destSharedFrameInModal.size.height > 0) {
-                        // Place the internal album art's center on the source's
-                        // center. After scaling around modal center, internal art's
-                        // visual center = modalCenter + (internalArtCenter - modalCenter) * scale + translation.
-                        const internalCx = destSharedFrameInModal.origin.x + destSharedFrameInModal.size.width / 2;
-                        const internalCy = destSharedFrameInModal.origin.y + destSharedFrameInModal.size.height / 2;
-                        tx = targetCx - modalCx - (internalCx - modalCx) * sx;
-                        ty = targetCy - modalCy - (internalCy - modalCy) * sy;
-                    }
-                    else {
-                        // Fallback: align modal center on source center.
-                        tx = targetCx - modalCx;
-                        ty = targetCy - modalCy;
-                    }
-                    targetTransform = CGAffineTransformConcat(CGAffineTransformMakeTranslation(tx, ty), CGAffineTransformMakeScale(sx, sy));
-                }
-            }
-            // Build a snapshot fly-back for each shared element so the album
-            // art (etc.) does a real shared-element transition to its source
-            // frame in parallel with the destination view's shrink+fade.
-            // Without this, the image rides along with the morphing view and
-            // lands at a visually offset position rather than precisely back
-            // at the source thumbnail.
-            const sharedSnapshots = [];
-            if (containerView) {
-                for (const presented of state.instance.sharedElements?.presented || []) {
-                    const destSharedView = presented.view?.ios;
-                    const tag = presented.view?.sharedTransitionTag;
-                    if (!destSharedView || !tag)
-                        continue;
-                    const sourceShared = state.instance.sharedElements?.presenting?.find?.((p) => p.view.sharedTransitionTag === tag);
-                    const srcSharedView = sourceShared?.view?.ios;
-                    if (!srcSharedView)
-                        continue;
-                    const startFrame = destSharedView.convertRectToView(destSharedView.bounds, containerView);
-                    const endFrame = srcSharedView.convertRectToView(srcSharedView.bounds, containerView);
-                    if (startFrame.size.width <= 0 || endFrame.size.width <= 0)
-                        continue;
-                    const snap = UIImageView.alloc().init();
-                    if (destSharedView instanceof UIImageView && destSharedView.image) {
-                        snap.image = destSharedView.image;
-                        snap.contentMode = destSharedView.contentMode;
-                        snap.tintColor = destSharedView.tintColor;
-                    }
-                    else {
-                        try {
-                            snap.image = iOSUtils.snapshotView(presented.view.ios, Screen.mainScreen.scale);
-                        }
-                        catch (e) {
-                            continue;
-                        }
-                    }
-                    snap.clipsToBounds = true;
-                    snap.layer.cornerRadius = destSharedView.layer?.cornerRadius || 0;
-                    snap.frame = startFrame;
-                    containerView.addSubview(snap);
-                    // Hide the destination shared element so we don't see it
-                    // shrinking inside the morphing view at the same time the
-                    // snapshot is flying back to source — that would double up.
-                    destSharedView.alpha = 0;
-                    sharedSnapshots.push({
-                        snap,
-                        endFrame,
-                        endCornerRadius: srcSharedView.layer?.cornerRadius || 0,
-                        srcSharedView,
-                    });
-                }
-            }
-            // Identify which source NS views have a matching fly-back snapshot.
-            // Those sources stay at alpha 0 through the spring and are restored
-            // inside finalize(), so the snapshot doesn't overlay an already-
-            // visible source mid-flight (which looks like two images for a beat).
-            const snapshottedSources = new Set();
-            for (const entry of sharedSnapshots) {
-                if (entry.srcSharedView)
-                    snapshottedSources.add(entry.srcSharedView);
-            }
-            // Source-only orphan views (album thumbnails, badges, etc.) were
-            // already restored to their opacity by the gesture handler at morph
-            // engagement, so we don't need fade-in snapshots here — they're
-            // already visible behind the morphing modal.
-            let didFinalize = false;
-            const finalize = () => {
-                if (didFinalize)
-                    return;
-                didFinalize = true;
-                // Detach the imageSourceChange listeners that were attached during
-                // PRESENT — the destination View is about to be torn down.
-                for (const presented of state.instance.sharedElements?.presented || []) {
-                    if (presented.imageSourceChangeListener) {
-                        presented.view.off('imageSourceChange', presented.imageSourceChangeListener);
-                        presented.imageSourceChangeListener = null;
-                    }
-                }
-                // Restore the snapshotted sources (held at alpha 0 through the
-                // spring) immediately before removing the snapshot, so the
-                // snapshot's last frame and the source's first visible frame
-                // coincide exactly — no double-image, no gap.
-                for (const entry of sharedSnapshots) {
-                    const srcSharedView = entry.srcSharedView;
-                    if (srcSharedView) {
-                        const nsView = state.instance.sharedElements?.presenting?.find?.((p) => p.view?.ios === srcSharedView)?.view;
-                        srcSharedView.alpha = nsView ? nsView.opacity : 1;
-                    }
-                }
-                for (const { snap } of sharedSnapshots) {
-                    snap.removeFromSuperview();
-                }
-                // Independent (orphan) views were restored at gesture engagement,
-                // so they're already visible. Just tear down any leftover present-
-                // phase snapshots that weren't removed in present cleanup, and
-                // ensure alpha is set from NS opacity for safety in case the
-                // engagement code path was bypassed.
-                for (const independent of state.instance?.sharedElements?.independent || []) {
-                    if (independent.view?.ios) {
-                        independent.view.ios.alpha = independent.view.opacity;
-                    }
-                    independent.snapshot?.removeFromSuperview();
-                }
-                if (view) {
-                    view.transform = CGAffineTransformIdentity;
-                    view.alpha = 1;
-                }
-                // Remove the sibling shadow view if interactive engagement added one.
-                removeInteractiveDismissShadow(view);
-                SharedTransition.finishState(state.instance.id);
-                if (interactiveState.transitionContext) {
-                    interactiveState.transitionContext.finishInteractiveTransition();
-                    interactiveState.transitionContext.completeTransition(true);
-                }
-                SharedTransition.notifyEvent(SharedTransition.finishedEvent, {
-                    id: state?.instance?.id,
-                    type,
-                    action: 'interactiveFinish',
-                });
-            };
-            if (view && targetTransform) {
-                const shadowViewToAnimate = view.__sharedTransitionShadowView;
-                iOSUtils.animateWithSpring({
-                    animations: () => {
-                        view.transform = targetTransform;
-                        view.alpha = 0;
-                        // Drive the sibling shadow view through the same spring so it
-                        // shrinks + translates with the modal as it morphs to the
-                        // source. Also fade it out so it doesn't linger behind the
-                        // finalizing snapshot.
-                        if (shadowViewToAnimate) {
-                            shadowViewToAnimate.transform = targetTransform;
-                            shadowViewToAnimate.alpha = 0;
-                        }
-                        // Restore source-side element alphas IN PARALLEL with the
-                        // destination's morph + fade — but skip sources that have
-                        // a flying snapshot. Those are held at alpha 0 and
-                        // revealed by finalize() right before the snapshot is
-                        // removed, so the user never sees both the snapshot AND
-                        // the source visible at the same time.
-                        for (const v of state.instance.sharedElements?._allPresentingViews || []) {
-                            if (v?.ios && !snapshottedSources.has(v.ios)) {
-                                v.ios.alpha = v.opacity;
-                            }
-                        }
-                        // Source-only orphan views were already restored at
-                        // engagement; nothing more to do for them here.
-                        // Fly each shared-element snapshot to its source frame.
-                        // Rides the same spring so the image lands precisely back
-                        // at the source position as the destination view fades.
-                        for (const { snap, endFrame, endCornerRadius } of sharedSnapshots) {
-                            snap.frame = endFrame;
-                            snap.layer.cornerRadius = endCornerRadius;
-                        }
-                    },
-                    completion: () => finalize(),
-                });
-                // Safety: ensure finalize runs even if the animation completion
-                // is dropped (e.g. interrupted by another gesture).
-                setTimeout(finalize, 800);
-            }
-            else {
-                // No target transform; ensure sources are still restored.
-                for (const v of state.instance.sharedElements?._allPresentingViews || []) {
-                    if (v?.ios)
-                        v.ios.alpha = v.opacity;
-                }
-                finalize();
-            }
-            return;
-        }
         if (state?.instance && interactiveState?.added && interactiveState?.propertyAnimator) {
             interactiveState.propertyAnimator.reversed = false;
             const duration = isNumber(state.pageReturn?.duration) ? state.pageReturn?.duration / 1000 : CORE_ANIMATION_DEFAULTS.duration;
             interactiveState.propertyAnimator.continueAnimationWithTimingParametersDurationFactor(null, duration);
             setTimeout(() => {
-                // Restore alpha on every source view we hid (including duplicates) so
-                // the source page is visible if shown again.
-                for (const sourceView of state.instance.sharedElements._allPresentingViews || []) {
-                    if (sourceView?.ios) {
-                        sourceView.ios.alpha = sourceView.opacity;
-                    }
-                }
                 for (const presenting of state.instance.sharedElements.presenting) {
+                    presenting.view.opacity = presenting.startOpacity;
                     presenting.snapshot.removeFromSuperview();
                 }
-                for (const presented of state.instance.sharedElements.presented) {
-                    if (presented.imageSourceChangeListener) {
-                        presented.view.off('imageSourceChange', presented.imageSourceChangeListener);
-                        presented.imageSourceChangeListener = null;
-                    }
-                }
-                // Restore alpha on independent (orphan) source views and tear down
-                // their snapshots. Without this, source-only orphans (any non-matched
-                // sharedTransitionTag on the source page) stay at alpha 0 forever,
-                // leaving the page visibly blank where they used to be. The non-morph
-                // interactive path drives a propertyAnimator instead of running the
-                // dismiss snapshot/animation rig, so the standard cleanup doesn't run.
-                for (const ind of state.instance.sharedElements.independent) {
-                    if (ind.view?.ios) {
-                        ind.view.ios.alpha = ind.view.opacity;
-                    }
-                    ind.snapshot?.removeFromSuperview();
-                }
                 SharedTransition.finishState(state.instance.id);
                 interactiveState.propertyAnimator = null;
                 interactiveState.added = false;