@@ -72,9 +72,12 @@ import org.jetbrains.annotations.ApiStatus
  *
  * Each [lifecycle owner][androidx.lifecycle.LifecycleOwner] may host its own `SentryNavEffect`
  * (e.g., one per Activity). During transitions between owners, `SentryNavEffect` coordinates the
- * overlapping instances so only one records navigation data at a time. `SentryNavEffect`s
- * associated with side-by-side or nested `NavDisplay`s are not supported and can result in
- * duplicated or interleaved data and undefined transaction behavior.
+ * overlapping instances so only one publishes its screen name, back stack, and navigation
+ * transaction at a time, while breadcrumbs from every instance are recorded as navigation happens.
+ * Data is attributed to the incoming screen as soon as it's created, before it becomes visible, as
+ * startup code is the most likely source of crashes and slow spans during a transition.
+ * `SentryNavEffect`s associated with side-by-side or nested `NavDisplay`s are not supported and can
+ * result in duplicated or interleaved data and undefined transaction behavior.
  *
  * @param backStack The navigation backstack to observe.
  * @param backStackEntryMapper Maps each entry of the [backStack] to a name and optional arguments
 
@@ -156,10 +156,24 @@ internal class NavLeaseCoordinator {
     }
   }
 
-  fun bindTransaction(owner: Any, transaction: ITransaction) {
-    val candidate = leaseHolder ?: return
-    if (candidate.owner === owner) {
-      candidate.transaction = transaction
+  fun isRegistered(owner: Any): Boolean = findCandidate(owner) != null
+
+  /** Whether [transaction] is a nav transaction retained for any registered owner. */
+  fun isNavTransaction(transaction: ITransaction): Boolean = candidates.any {
+    it.transaction === transaction
+  }
+
+  /**
+   * Records [transaction] as [owner]'s nav transaction, whether or not [owner] holds the lease.
+   *
+   * A transaction retained without the lease is bound to the scope when [owner] acquires the lease,
+   * if it's still unfinished and the scope is free, and finished when [owner] is
+   * [unregistered][unregisterCandidate].
+   */
+  fun retainTransaction(owner: Any, transaction: ITransaction) {
+    val candidate = findCandidate(owner) ?: return
+    candidate.transaction = transaction
+    if (leaseHolder === candidate) {
       activeTransactionCandidate = candidate
     }
   }
 
@@ -83,15 +83,22 @@ import io.sentry.protocol.Contexts
  * A possible solution would be to implement a parent span delivery system similar to
  * [LocalSentrySpan], but that's a task for another day.
  *
- * **Only leaseholders generate nav transactions and nav state**
+ * **Only leaseholders publish nav state and bind nav transactions**
  *
  * This class works by only allowing `NavScopes` instances holding a lease to publish their
- * navigation state and transactions to the underlying `IScope`.
+ * navigation state and bind their transactions to the underlying `IScope`.
  *
  * `NavScopes` instances without a lease write to a [stagedNavData] holder, which lets them preserve
  * their latest updates without overwriting another instance's published data. When an instance
  * acquires the lease, it publishes its staged data to the underlying `IScope`.
  *
+ * Nav transactions are started whether or not an instance holds the lease, so each one begins when
+ * its destination is reached. Without the lease, a transaction is retained rather than bound, and
+ * bound once the instance acquires the lease, if it's still unfinished and the scope is free. An
+ * unbound transaction collects no child spans, so if its instance stays without the lease longer
+ * than the idle timeout, the transaction finishes empty and is dropped. Propagation context
+ * rotations requested without the lease are likewise deferred until the lease is acquired.
+ *
  * Breadcrumbs are the exception: they only append to the scope, so every instance records them
  * immediately, preserving their real order whether or not it holds the lease.
  *
@@ -285,17 +292,31 @@ internal class NavScopes(
     }
   }
 
+  /** Whether this instance currently holds the nav lease. */
+  fun hasLease(): Boolean = coordinator.hasLease(owner)
+
+  /**
+   * Starts a nav transaction whether or not this instance holds the nav lease, so the transaction
+   * begins when its destination is actually reached.
+   *
+   * Only the leaseholder binds it to the scope (see [NavScope.bindTransaction]). Without the lease,
+   * the [coordinator] retains it and binds it once this instance acquires the lease, provided it's
+   * still unfinished and the scope is free.
+   *
+   * Returns a no-op transaction while this instance isn't [attached][attach] (in particular, after
+   * it's [disposed][dispose]), so it can't start transactions that nothing would finish.
+   */
   override fun startTransaction(
     transactionContext: TransactionContext,
     transactionOptions: TransactionOptions,
   ): ITransaction {
-    if (!coordinator.hasLease(owner)) {
+    if (!coordinator.isRegistered(owner)) {
       return NoOpTransaction.getInstance()
     }
 
     return delegate.startTransaction(transactionContext, transactionOptions).also { transaction ->
       if (!transaction.isNoOp) {
-        coordinator.bindTransaction(owner, transaction)
+        coordinator.retainTransaction(owner, transaction)
       }
     }
   }
@@ -354,8 +375,10 @@ internal class NavScopes(
  * breadcrumbs) only append to the scope, so they can't overwrite another instance's data and are
  * recorded immediately, irrespective of lease ownership.
  *
- * Propagation context isn't staged either: like nav transactions, it's only changed by the
- * leaseholder, and changes made without the lease are discarded.
+ * Propagation context isn't staged either, since an earlier propagation context mustn't overwrite
+ * the scope's current one. Instead, a rotation requested without the lease is
+ * [deferred][deferPropagationContextRotation] and performed once when the lease is acquired, so the
+ * destination reached in the meantime still gets a fresh trace.
  */
 internal class StagedNavData {
 
@@ -364,6 +387,9 @@ internal class StagedNavData {
   private var hasNavigationContextUpdate = false
   private var hasScreenUpdate = false
 
+  /** Whether a propagation context rotation was requested while this instance lacked the lease. */
+  private var hasDeferredPropagationContextRotation = false
+
   // These may differ from the staged values after background updates. We keep the exact published
   // references so cleanup preserves host replacements, including structurally equal replacements.
   private var publishedNavigationContext: Any? = null
@@ -396,6 +422,11 @@ internal class StagedNavData {
     }
   }
 
+  /** Requests a propagation context rotation for when this instance next [publishes][publishTo]. */
+  fun deferPropagationContextRotation() {
+    hasDeferredPropagationContextRotation = true
+  }
+
   fun publishTo(realScope: IScope) {
     // A new leaseholder publishes a complete navigation state. Clearing fields it hasn't staged
     // prevents the previous leaseholder's values from lingering after a handoff.
@@ -404,6 +435,10 @@ internal class StagedNavData {
       if (hasNavigationContextUpdate) contexts[NAVIGATION_CONTEXT_KEY] else null,
       realScope,
     )
+    if (hasDeferredPropagationContextRotation) {
+      realScope.withPropagationContext { realScope.propagationContext = PropagationContext() }
+      hasDeferredPropagationContextRotation = false
+    }
   }
 
   /** Called only for the last publishing session; releasing its lease alone does not clear data. */
@@ -437,9 +472,11 @@ internal class StagedNavData {
  * An [IScope] that writes to [delegate] only when the current [owner] holds the nav lease.
  *
  * Without the lease, nav state (screen and nav context) is redirected to [stagedNavData] and
- * published if [owner] later acquires the lease, while transaction binding and propagation context
- * rotation are discarded. Reads of the scope's app context and transaction, and unbinding [owner]'s
- * own transaction, always go to [delegate].
+ * published if [owner] later acquires the lease. Transaction binding is skipped, as the
+ * [coordinator] binds [owner]'s retained transaction when it acquires the lease, and propagation
+ * context rotation is deferred until then. Reading the scope's app context and unbinding [owner]'s
+ * own transaction always go to [delegate]; reading the scope's transaction does too, except that
+ * another owner's nav transaction is hidden without the lease (see [transaction]).
  */
 internal class NavScope(
   private val delegate: IScope,
@@ -462,8 +499,17 @@ internal class NavScope(
   override val app: App?
     get() = Contexts(delegate.contexts).app
 
+  /**
+   * The transaction bound to the scope. Without the lease, another owner's nav transaction isn't
+   * reported: it doesn't stop [owner] from starting its own, which the [coordinator] binds in its
+   * place when [owner] acquires the lease. Non-nav transactions (e.g., the host's) are always
+   * reported.
+   */
   override val transaction: ITransaction?
-    get() = delegate.transaction
+    get() =
+      delegate.transaction?.takeUnless { current ->
+        !hasLease && coordinator.isNavTransaction(current)
+      }
 
   override fun bindTransaction(transaction: ITransaction) {
     if (!hasLease) {
@@ -498,6 +544,8 @@ internal class NavScope(
   override fun rotatePropagationContext() {
     if (hasLease) {
       delegate.withPropagationContext { delegate.propagationContext = PropagationContext() }
+    } else {
+      stagedNavData.deferPropagationContextRotation()
     }
   }
 }
@@ -537,7 +585,10 @@ internal interface INavScope {
   /** A copy of the scope's app context, if any. */
   val app: App?
 
-  /** The transaction bound to the scope, if any. */
+  /**
+   * The transaction bound to the scope, if any, as far as starting a nav transaction is concerned:
+   * see [NavScope.transaction].
+   */
   val transaction: ITransaction?
 
   /** Binds [transaction] to the scope if no transaction is bound to it. */
 
@@ -26,6 +26,7 @@ import io.sentry.Scope
 import io.sentry.ScopeCallback
 import io.sentry.ScopeType
 import io.sentry.Scopes
+import io.sentry.SentryDate
 import io.sentry.SentryOptions
 import io.sentry.SentryTracer
 import io.sentry.TransactionContext
@@ -626,6 +627,59 @@ class SentryNavEffectTest {
     }
   }
 
+  @Test
+  fun `navigating in response to an Activity result gets its transaction once the effect resumes`() {
+    val fixture = NavTestFixture()
+    val ownerA = NavTestLifecycle(Lifecycle.State.RESUMED)
+    val ownerB = NavTestLifecycle()
+    val backStackA = mutableStateListOf("Home")
+    val showB = mutableStateOf(false)
+    val options = SentryNavOptions()
+    val mapper = BackStackEntryMapper<String> { SentryBackStackEntry(it) }
+    composeRule.setContent {
+      CompositionLocalProvider(LocalLifecycleOwner provides ownerA) {
+        SentryNavEffect(backStackA, mapper, options, fixture.scopes, fixture.coordinator)
+      }
+      if (showB.value) {
+        CompositionLocalProvider(LocalLifecycleOwner provides ownerB) {
+          SentryNavEffect(listOf("Picker"), mapper, options, fixture.scopes, fixture.coordinator)
+        }
+      }
+    }
+
+    // A starts B: A pauses, B is created and takes over, B resumes, then A stops.
+    composeRule.runOnIdle {
+      ownerA.pause()
+      showB.value = true
+    }
+    composeRule.runOnIdle {
+      ownerB.resume()
+      ownerA.stop()
+    }
+    // B finishes with a result: B pauses, then A restarts and navigates before it resumes.
+    composeRule.runOnIdle {
+      ownerB.pause()
+      ownerA.start()
+      backStackA += "Result"
+    }
+    lateinit var beforeResume: SentryDate
+    composeRule.runOnIdle {
+      assertThat(fixture.scope.transaction?.name).isEqualTo("/Picker")
+      assertThat(fixture.scope.breadcrumbs.map { it.data["to"] })
+        .containsExactly("/Home", "/Picker", "/Result")
+        .inOrder()
+      beforeResume = fixture.options.dateProvider.now()
+      ownerA.resume()
+    }
+
+    composeRule.runOnIdle {
+      val transaction = requireNotNull(fixture.scope.transaction)
+      assertThat(transaction.name).isEqualTo("/Result")
+      assertThat(transaction.startDate.nanoTimestamp()).isAtMost(beforeResume.nanoTimestamp())
+      assertThat(fixture.scope.screen).isEqualTo("/Result")
+    }
+  }
+
   @Test
   fun `replacing lifecycle owner disposes the old session and observes the new owner`() {
     val fixture = NavTestFixture()
@@ -697,6 +751,14 @@ private class NavTestLifecycle(state: Lifecycle.State = Lifecycle.State.CREATED)
   fun pause() {
     lifecycle.currentState = Lifecycle.State.STARTED
   }
+
+  fun start() {
+    lifecycle.currentState = Lifecycle.State.STARTED
+  }
+
+  fun stop() {
+    lifecycle.currentState = Lifecycle.State.CREATED
+  }
 }
 
 /** Real SDK state with only the event delivery boundary stubbed. No timers or global SDK state. */
 
@@ -322,18 +322,63 @@ class NavLeaseCoordinatorTest {
   }
 
   @Test
-  fun `a non-leaseholder cannot bind a nav transaction`() {
+  fun `an unregistered owner's nav transaction is not retained`() {
     val fixture = Fixture.create()
     val navLeaseCoordinator = fixture.navLeaseCoordinator
     val other = Any()
     fixture.acquireLease(owner)
 
-    navLeaseCoordinator.bindTransaction(other, transaction)
+    navLeaseCoordinator.retainTransaction(other, transaction)
     navLeaseCoordinator.unregisterCandidate(owner, fixture.scope)
 
     verifyNoInteractions(transaction)
   }
 
+  @Test
+  fun `a nav transaction retained without the lease is bound once its owner acquires the lease`() {
+    val fixture = Fixture.create()
+    val navLeaseCoordinator = fixture.navLeaseCoordinator
+    fixture.acquireLease(owner)
+    fixture.acquireLease(incoming, state = Lifecycle.State.CREATED)
+
+    navLeaseCoordinator.retainTransaction(owner, transaction)
+    assertThat(fixture.scope.transaction).isNull()
+
+    navLeaseCoordinator.unregisterCandidate(incoming, fixture.scope)
+
+    assertThat(navLeaseCoordinator.hasLease(owner)).isTrue()
+    assertThat(fixture.scope.transaction).isSameInstanceAs(transaction)
+  }
+
+  @Test
+  fun `a finished nav transaction retained without the lease is not bound when its owner acquires the lease`() {
+    val fixture = Fixture.create()
+    val navLeaseCoordinator = fixture.navLeaseCoordinator
+    fixture.acquireLease(owner)
+    fixture.acquireLease(incoming, state = Lifecycle.State.CREATED)
+    navLeaseCoordinator.retainTransaction(owner, transaction)
+    whenever(transaction.isFinished).thenReturn(true)
+
+    navLeaseCoordinator.unregisterCandidate(incoming, fixture.scope)
+
+    assertThat(navLeaseCoordinator.hasLease(owner)).isTrue()
+    assertThat(fixture.scope.transaction).isNull()
+  }
+
+  @Test
+  fun `unregistering an owner finishes a nav transaction it retained without the lease`() {
+    val fixture = Fixture.create()
+    val navLeaseCoordinator = fixture.navLeaseCoordinator
+    fixture.acquireLease(owner)
+    fixture.acquireLease(incoming, state = Lifecycle.State.CREATED)
+    navLeaseCoordinator.retainTransaction(owner, transaction)
+
+    navLeaseCoordinator.unregisterCandidate(owner, fixture.scope)
+
+    verify(transaction).finish(SpanStatus.OK)
+    assertThat(navLeaseCoordinator.hasLease(incoming)).isTrue()
+  }
+
   @Test
   fun `an unfinished nav transaction is restored when its owner regains the lease`() {
     val fixture = Fixture.create()
@@ -455,7 +500,7 @@ class NavLeaseCoordinatorTest {
       register(owner, state)
       navLeaseCoordinator.onBackStackUpdate(owner, scope)
       if (transaction != null) {
-        navLeaseCoordinator.bindTransaction(owner, transaction)
+        navLeaseCoordinator.retainTransaction(owner, transaction)
         scope.transaction = transaction
       }
     }