@onekeyfe/react-native-native-overlay 3.0.162-alpha.272 → 6.7.0-8

package/android/src/main/java/com/onekey/nativeoverlay/NativeOverlayHost.kt

@@ -8,6 +8,7 @@ import android.widget.FrameLayout
 import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedCallback
 import java.util.WeakHashMap
+import java.lang.ref.WeakReference
 
 /** Mirrors `OVERLAY_LEVEL_ORDER`. */
 internal enum class NativeOverlayLevel(val order: Int) {
@@ -48,7 +49,7 @@ internal class NativeOverlayHost private constructor(
   )
   private val backCallback = object : OnBackPressedCallback(false) {
     override fun handleOnBackPressed() {
-      topBlockingEntry()?.let { entry ->
+      topBackEntry()?.let { entry ->
         if (entry.dismissOnBackPress) entry.onRequestDismiss?.invoke("back")
       }
     }
@@ -66,7 +67,7 @@ internal class NativeOverlayHost private constructor(
    * predictive back, so the dispatcher alone never runs first.
    */
   fun handleBackKey(event: KeyEvent): Boolean {
-    val entry = topBlockingEntry() ?: return false
+    val entry = topBackEntry() ?: return false
     if (event.action == KeyEvent.ACTION_UP && !event.isCanceled && entry.dismissOnBackPress) {
       entry.onRequestDismiss?.invoke("back")
     }
@@ -108,14 +109,14 @@ internal class NativeOverlayHost private constructor(
   }
 
   fun onEntriesChanged() {
-    val hasBlocking = topBlockingEntry() != null
-    if (hasBlocking && !backCallback.isEnabled) {
+    val hasBackEntry = topBackEntry() != null
+    if (hasBackEntry && !backCallback.isEnabled) {
       // The most recently added callback wins; re-add so ours runs before
       // ReactActivity's and react-native-screens' callbacks.
       backCallback.remove()
       (activity as? ComponentActivity)?.onBackPressedDispatcher?.addCallback(backCallback)
     }
-    backCallback.isEnabled = hasBlocking
+    backCallback.isEnabled = hasBackEntry
     updateAccessibility()
   }
 
@@ -133,11 +134,11 @@ internal class NativeOverlayHost private constructor(
     }
 
   /** Global overlays win; otherwise the topmost visible page overlay. */
-  private fun topBlockingEntry(): NativeOverlayEntryRootView? =
-    orderedEntries().lastOrNull { it.blocking && it.isShownForInput }
+  private fun topBackEntry(): NativeOverlayEntryRootView? =
+    orderedEntries().lastOrNull { (it.blocking || it.dismissOnBackPress) && it.isShownForInput }
       ?: shownPageHosts()
         .flatMap { it.shownEntries() }
-        .lastOrNull { it.blocking }
+        .lastOrNull { it.blocking || it.dismissOnBackPress }
 
   private fun shownPageHosts(): List<NativeOverlayPageHostView> =
     NativeOverlayPageHostView.allHosts().filter {
@@ -160,9 +161,11 @@ internal class NativeOverlayHost private constructor(
   }
 
   companion object {
-    private val hosts = WeakHashMap<Activity, NativeOverlayHost>()
+    private val hosts = WeakHashMap<Activity, WeakReference<NativeOverlayHost>>()
 
     fun of(activity: Activity): NativeOverlayHost =
-      hosts.getOrPut(activity) { NativeOverlayHost(activity) }
+      hosts[activity]?.get() ?: NativeOverlayHost(activity).also {
+        hosts[activity] = WeakReference(it)
+      }
   }
 }

package/android/src/test/java/com/onekey/nativeoverlay/NativeOverlayBackTest.kt

@@ -0,0 +1,157 @@
+package com.onekey.nativeoverlay
+
+import android.view.KeyEvent
+import android.view.View
+import android.widget.FrameLayout
+import androidx.activity.ComponentActivity
+import com.facebook.react.bridge.BridgeReactContext
+import com.facebook.react.uimanager.ThemedReactContext
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotSame
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativeOverlayBackTest {
+  private lateinit var activity: ComponentActivity
+  private lateinit var context: ThemedReactContext
+  private lateinit var host: NativeOverlayHost
+  private val dismissals = mutableListOf<String>()
+
+  @Before
+  fun setUp() {
+    activity = Robolectric.buildActivity(ComponentActivity::class.java).setup().visible().get()
+    val reactContext = BridgeReactContext(activity)
+    reactContext.onHostResume(activity)
+    context = ThemedReactContext(reactContext, activity, "OverlayBackTest", 1)
+    host = NativeOverlayHost.of(activity)
+  }
+
+  private fun entry(name: String, blocking: Boolean, dismissible: Boolean, order: Int = 0) =
+    NativeOverlayEntryRootView(context).apply {
+      this.blocking = blocking
+      dismissOnBackPress = dismissible
+      stackOrder = order
+      isShownForInput = true
+      onRequestDismiss = { dismissals.add("$name:$it") }
+    }
+
+  private fun back(action: Int = KeyEvent.ACTION_UP, flags: Int = 0) =
+    host.handleBackKey(KeyEvent(0L, 0L, action, KeyEvent.KEYCODE_BACK, 0, 0, 0, 0, flags))
+
+  @Test
+  fun dismissibleNonBlockingGlobalEntryWinsOverLowerBlocker() {
+    host.attach(entry("lower", true, true), NativeOverlayLevel.MODAL)
+    host.attach(entry("top", false, true), NativeOverlayLevel.TOAST)
+    assertTrue(back(KeyEvent.ACTION_DOWN))
+    assertEquals(emptyList<String>(), dismissals)
+    assertTrue(back())
+    assertEquals(listOf("top:back"), dismissals)
+  }
+
+  @Test
+  fun dispatcherHandlesNonBlockingEntryAndKeepsPageAccessible() {
+    val page = View(activity).apply { importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_YES }
+    activity.setContentView(page)
+    val top = entry("top", false, true)
+    host.attach(top, NativeOverlayLevel.MODAL)
+    activity.onBackPressedDispatcher.onBackPressed()
+    assertEquals(listOf("top:back"), dismissals)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_YES, page.importantForAccessibility)
+    host.detach(top)
+    assertFalse(back())
+  }
+
+  @Test
+  fun nonDismissibleBlockerConsumesBackWithoutClosingLowerEntry() {
+    host.attach(entry("lower", false, true), NativeOverlayLevel.MODAL)
+    host.attach(entry("lock", true, false), NativeOverlayLevel.LOCK)
+    assertTrue(back())
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun passiveOrNotInputReadyEntriesDoNotTakeBack() {
+    host.attach(entry("passive", false, false), NativeOverlayLevel.TOAST)
+    host.attach(entry("hidden", true, true).apply { isShownForInput = false }, NativeOverlayLevel.LOCK)
+    assertFalse(back())
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun canceledKeyUpDoesNotDismiss() {
+    host.attach(entry("top", false, true), NativeOverlayLevel.MODAL)
+    assertTrue(back(flags = KeyEvent.FLAG_CANCELED))
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun dismissiblePageEntryWinsOverLowerPageBlockerAndSuspensionSkipsIt() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-back-test" }
+    activity.setContentView(pageHost)
+    val lower = entry("lower", true, true).apply { ownerKey = "owner" }
+    val top = entry("top", false, true, 1).apply { ownerKey = "owner" }
+    pageHost.attach(lower)
+    pageHost.attach(top)
+    assertTrue(back())
+    assertEquals(listOf("top:back"), dismissals)
+    pageHost.setSuspendedOwners("owner")
+    assertFalse(back())
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun globalEntryTakesBackBeforePageEntryAndDismissalRestoresPageTarget() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-global-test" }
+    activity.setContentView(FrameLayout(activity).apply { addView(pageHost) })
+    pageHost.attach(entry("page", false, true))
+    val global = entry("global", false, true)
+    host.attach(global, NativeOverlayLevel.MODAL)
+    assertTrue(back())
+    host.detach(global)
+    assertTrue(back())
+    assertEquals(listOf("global:back", "page:back"), dismissals)
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun hostCacheReusesLiveHostAndSeparatesActivities() {
+    assertSame(host, NativeOverlayHost.of(activity))
+    val otherActivity = Robolectric.buildActivity(ComponentActivity::class.java).setup().get()
+    assertNotSame(host, NativeOverlayHost.of(otherActivity))
+  }
+
+  @Test
+  fun hostCacheRebuildsAfterWeakValueIsCleared() {
+    val field = NativeOverlayHost::class.java.getDeclaredField("hosts").apply {
+      isAccessible = true
+    }
+    val cache = field.get(null) as WeakHashMap<*, *>
+    (cache[activity] as WeakReference<*>).clear()
+    val replacement = NativeOverlayHost.of(activity)
+    assertNotSame(host, replacement)
+    assertSame(replacement, NativeOverlayHost.of(activity))
+  }
+
+  @Test
+  fun pageOnlyBackInterceptorRetainsItsHost() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-only" }
+    activity.setContentView(pageHost)
+    pageHost.attach(entry("page", false, true))
+    host.installBackInterceptor()
+    assertTrue(activity.window.callback.dispatchKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK)))
+    assertEquals(listOf("page:back"), dismissals)
+    assertSame(host, NativeOverlayHost.of(activity))
+    pageHost.invalidateHost()
+  }
+}

package/docs/SPEC.md

@@ -28,19 +28,24 @@ TypeScript declarations; React Native generates the Fabric bindings at app
 build time. Publish `common/cpp`, `src`, `lib`, Android/iOS sources, podspec and
 autolinking configuration. Web consumers additionally provide `react-dom`.
 
-`react-native-native-sheet` remains separately published for existing consumers;
-its compatibility shim/deprecation is a subsequent migration step, not a
-silent API change in this release. Sheet behavior derived from that package
-retains its original implementation attribution in source comments.
+`react-native-native-sheet` is retired from this repository after the App
+consumer migration. Its source workspace, example dependency, and dedicated
+tests are removed; sheet presentation is owned by this package and has no
+dependency on the retired package. The old `NativeSheet` API is not retained as
+a compatibility shim. Previously published npm versions remain unchanged, and
+this repository cleanup does not publish or change package versions. Sheet
+behavior derived from that package retains its original implementation
+attribution in source comments.
 
 ### Release boundary
 
-This branch aligns all 42 publishable workspaces to `3.0.162-alpha.272`.
-Publish with the existing `package-publish` workflow dispatch, `npm_dist_tag=next`
-and an empty `only_workspace`, which publishes and registry-verifies all 42.
-Do not merge either repository PR or change the `latest` tag. The app-monorepo
-workspace copy is removed only after this release succeeds and every target
-version and tarball is available. Versions already published on npm are immutable.
+The earlier `3.0.162-alpha.272` release remains immutable. This branch now
+includes the current main SDK baseline, with all publishable workspaces aligned
+before release. Use `package-publish` with `npm_dist_tag=next` and an empty
+`only_workspace` to generate a fresh `6.7.0-alpha.N` preview, publish every
+workspace, and verify every registry version. Preserve `latest` and keep both
+repository PRs open. App consumers pin the verified exact preview version and
+refresh dependency and native locks before installed-version acceptance.
 
 ## 5.1 Purpose, scope, and non-goals
 
@@ -85,6 +90,9 @@ Ownership:
   queues, page visibility, and back/Escape resolution.
 - **Native hosts** own drawing, hit testing, animation, keyboard, and back-key
   capture, and report lifecycle back to the store.
+- Android's static host lookup holds weak Activity keys and weak host values;
+  an active overlay or installed back callback owns its host. The lookup does
+  not itself extend the lifetime of an Activity.
 - **Content** is the caller's React subtree. The overlay view stays where the
   caller rendered it. Native code reparents its content into the host, so React
   context is preserved; there is no root-siblings portal.
@@ -108,6 +116,14 @@ come only from props.
 - `dismiss(id, reason)` moves an entry to `closing`. `finalize(id)` removes it
   after the native exit animation. A closing entry that is never finalized is
   removed after 5 s.
+- `reopen(id)` restores a closing entry to active, cancels its fallback timer,
+  and keeps its ordering, content and removal handler. A declarative
+  false-to-true change before exit completion uses this path; it does not
+  report a completed close. Hosts retarget the in-flight animation, including
+  cancelling the host-requested UIKit sheet dismissal when still running.
+- Removing a queued entry detaches its removal handler before notifying store
+  subscribers or scheduling its callback. Same-tick reuse of that ID owns a
+  separate handler; the old removal cannot invoke or delete the new handler.
 - `dismissAll({ scope, belowLevel, reason })`, `setPageVisible(ownerKey,
 visible)`, `removePage(ownerKey)`.
 - `resolveBack(focusedHostKey?)` returns `dismiss(id)`, `block`, or `pass`.
@@ -136,6 +152,11 @@ visible)`, `removePage(ownerKey)`.
 
 - `usePageOverlayHost()` resolves `hostKey` and `ownerKey` from navigation
   context.
+- A declarative page overlay keeps `scope: 'page'` while either key is
+  unavailable. It does not request or present an entry until both keys are
+  available; becoming ready while visible requests it in the page lane.
+  Hiding or unmounting before readiness creates no entry or close callback.
+  Direct store requests still throw for missing page keys.
 - `useInPageDialog`, `useInModalDialog`, and `useInTabDialog` become aliases of
   page scope. Tab scope is removed.
 
@@ -208,6 +229,30 @@ request ─► queued ─► active ─► (enter anim) presented
 - Threads: store mutations happen on the JS thread. Native animation and layout
   run on the UI thread. Events are delivered as direct events.
 
+### Web presentation updates (OK-50653)
+
+For an open Web overlay that keeps its portal host, changing `presentation`
+between sheet and a non-sheet frame MUST preserve the mounted content subtree.
+Its props and React context continue to update normally. Changing the optional
+sheet handle MUST NOT move the content into a different React child slot.
+Closing without `keepContentMounted` still unmounts content after exit; reopening
+creates a fresh content lifecycle. Business entity changes and draft resets
+remain caller-owned; the overlay does not cache or persist form values.
+
+The stable sheet shell must not change non-sheet animation origins or keyboard
+avoidance geometry. Switching away from a sheet clears any pan offset and its
+backdrop opacity override, and releases an active pointer capture.
+
+Conformance: `src/__tests__/draftRetention.web.test.ts` exercises the real Web
+host, portal and store for presentation changes, live props/context/callbacks,
+close/reopen, animation origins, keyboard geometry and an interrupted pan.
+Chrome extension side-panel and ordinary-tab checks use synthetic content;
+this correction does not claim new iOS/Android runtime verification.
+
+These source changes require a new published package version before the app
+can consume them from npm. This fix leaves package versions and lockfiles at
+their existing values and does not publish a release.
+
 ## 5.5 Data, cache, and identity
 
 - Identity is the entry `id`: caller-provided, otherwise `overlay-<seq>`.
@@ -216,6 +261,22 @@ request ─► queued ─► active ─► (enter anim) presented
 
 ## 5.6 Platform contract
 
+### Web keyboard focus containment
+
+The topmost active, unsuspended blocking Web entry MUST contain sequential
+keyboard focus. Tab from its last tabbable child wraps to the first;
+Shift+Tab from its first wraps to the last. From the entry root, focus enters
+the first/last child respectively. With no tabbable children, focus stays on
+the entry root. Disabled, negative-tabindex, hidden and inert subtrees are
+excluded. Positive tabindex values precede ordinary DOM-order tab stops.
+Non-blocking, lower, closing, suspended and parked entries MUST NOT run a
+focus loop. Existing focus entry/restore and Escape policies are unchanged.
+
+A Web backdrop with `dismissOnPress: true` MUST receive pointer events even
+when its entry is non-blocking. This permits a transparent outside-click
+shield without modal focus or accessibility isolation. A passive backdrop on
+a non-blocking entry remains pointer-transparent.
+
 | Concern                                    | iOS                                                                                                                                                          | Android                                                                                                                                                                                                                                                                                                                                                                                                                 | Web                                                                                                                 |
 | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
 | Global level host                          | One passthrough `UIWindow` per active level per `UIWindowScene`, ordered by `windowLevel`. `lock` sits above RN Alert (2001).                                | One `OverlayHost` FrameLayout in `android.R.id.content` above the ReactRootView, with one child container per level.                                                                                                                                                                                                                                                                                                    | Sibling `div[data-onekey-layer]` roots under `body`, one z-index band per level (`OVERLAY_WEB_Z_INDEX_BASE`).       |
@@ -224,7 +285,7 @@ request ─► queued ─► active ─► (enter anim) presented
 | Page host                                  | Fabric `PageOverlayHost` as the last child of the root-route screen. Custom-drawn sheet, because UIKit sheets cannot be page-scoped.                         | The same host inside the root-route screen. The ReactRootView already dispatches touches, so no nested RootView.                                                                                                                                                                                                                                                                                                        | `position: absolute` host inside the root-route card.                                                               |
 | Header / tab bar coverage (page)           | Covered: the host is above the tab controller and navigation bars.                                                                                           | Covered.                                                                                                                                                                                                                                                                                                                                                                                                                | Covered.                                                                                                            |
 | Touch passthrough (toast, debug, box-none) | `hitTest` returns nil on the window or root view.                                                                                                            | A non-blocking entry hit-tests its React content with `TouchTargetHelper` (honoring `box-none`) and falls through to the FrameLayout sibling on a miss.                                                                                                                                                                                                                                                                 | `pointer-events: none` root, `auto` per entry.                                                                      |
-| Back / Escape                              | Escape via `accessibilityPerformEscape`. The interactive pop gesture is disabled while a blocking page overlay is shown.                                     | A `Window.Callback` wrapper consumes `KEYCODE_BACK` while a blocking overlay is shown. `ReactActivity.onBackPressed` hands back to JS BackHandler (react-navigation) before the `OnBackPressedDispatcher`, and the app opts out of predictive back, so a dispatcher callback alone never runs first. The dispatcher callback is kept for the predictive-back path. The IME still gets back first to close the keyboard. | Capture-phase `keydown` that ignores IME composition.                                                               |
+| Back / Escape                              | Escape via `accessibilityPerformEscape`. The interactive pop gesture is disabled while a blocking page overlay is shown.                                     | A `Window.Callback` wrapper consumes `KEYCODE_BACK` for the topmost input-ready blocking or dismissible overlay. `ReactActivity.onBackPressed` hands back to JS BackHandler (react-navigation) before the `OnBackPressedDispatcher`, and the app opts out of predictive back, so a dispatcher callback alone never runs first. The dispatcher callback is kept for the predictive-back path. The IME still gets back first to close the keyboard. | Capture-phase `keydown` that ignores IME composition.                                                               |
 | Modality / accessibility                   | `accessibilityViewIsModal` on the blocking level window; `.screenChanged` posted on present.                                                                 | `IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS` on the content below.                                                                                                                                                                                                                                                                                                                                                 | `inert` on the app root and lower layers, `role=dialog`, `aria-modal`, focus trap and restore.                      |
 | Keyboard                                   | System sheet avoidance; `keyboardLayoutGuide` for custom presentations. The main window regains key status on dismiss.                                       | `WindowInsetsAnimationCompat` per sheet (the app uses `adjustPan`).                                                                                                                                                                                                                                                                                                                                                     | `visualViewport`.                                                                                                   |
 | Animation engine                           | `UIViewPropertyAnimator` + `UISpringTimingParameters(mass:stiffness:damping:)`, which maps 1:1 and supports damping ratio > 1.                               | `SpringAnimation` with `stiffness = k/m` and `dampingRatio`; `PathInterpolator` for timing curves.                                                                                                                                                                                                                                                                                                                      | WAAPI `element.animate`. Timing presets use `cubic-bezier`; custom springs use `linear()`.                          |
@@ -296,6 +357,17 @@ navigation remains a separate runtime acceptance item.
 
 Automated (P0):
 
+- `src/__tests__/focusTrap.web.test.ts` mounts real Web overlays and checks
+  both Tab boundaries, root/empty fallback, inaccessible children, positive
+  tabindex order, top-entry precedence, page scope, suspension and parking.
+- `src/__tests__/useOverlayController.test.ts` exercises the actual hook and
+  page scope providers: missing/empty keys, delayed readiness, one request,
+  page suspension/removal, hiding/unmounting before readiness and global scope.
+- `NativeOverlayBackTest` exercises the Android host's key interceptor and
+  Back dispatcher with actual entry/page views: dismissible non-blockers,
+  blockers, input readiness, canceled key-up, global/page precedence,
+  suspension and blocking-only accessibility isolation. It also checks live
+  host reuse, Activity isolation and rebuilding after a cleared weak value.
 - `src/__tests__/pageIsolation.web.test.ts` mounts a real React portal in a
   DOM host and verifies late suspension, level ordering and restoration after
   the blocking entry is removed.
@@ -331,7 +403,10 @@ Runtime matrix, required per platform before migrating callers (P1–P3):
    - switch tab and come back: it restores;
    - remove the page: it closes with `page-removed`;
    - the native header and tab bar are covered.
-5. Back/Escape reaches the topmost blocking overlay; the lock swallows it.
+5. Back/Escape reaches the topmost input-ready overlay that is blocking or
+   explicitly dismissible, global before page. A non-dismissible blocker
+   consumes Back without closing; a passive non-blocking entry passes through.
+   Accessibility isolation remains blocking-only. The lock swallows Back.
 6. Keyboard: an input in a global sheet, a page sheet and a secure dialog.
 7. iOS: a system picker opened from an overlay appears above it.
 8. Split view: page overlays stay in their own pane.
@@ -362,8 +437,12 @@ P3 page scope notes:
   their global sheet implementation inside the page host.
 - Android back also resolves page entries: global overlays first, then the
   topmost visible page overlay.
-- A page request without a resolvable host or owner falls back to global
-  scope.
+- A declarative page overlay waits for a resolvable host and owner; it never
+  falls back to global scope. Direct store requests require both keys.
+- On Web, a page overlay also waits for its registered DOM host while closed
+  with `keepContentMounted`. Registration mounts parked content in that host;
+  close/reopen retains the same DOM and state. Unregistration never moves page
+  content into a global layer.
 
 P2 sheet notes:
 
@@ -378,7 +457,11 @@ P2 sheet notes:
   overlay motion; dragging fades the backdrop; a drag to hidden reports
   `pan`.
 - Web renders a bottom surface with pointer drag (40% distance or 0.5 px/ms
-  flick dismisses, never from scrolled content).
+  flick dismisses, never from scrolled content). Reopening kept content after
+  a pan dismissal clears the sheet transform, transition and backdrop opacity;
+  the next dismissal follows the normal exit path and restores focus.
+  Cancelling a tracked pointer resets its drag offset, transition and backdrop
+  without dismissing the sheet or swallowing a later click.
 - A fitted sheet measures its content with `onLayout` before presenting.
   Hidden content stays mounted inside the zero-width host (clipped on iOS,
   INVISIBLE on Android), and the host height stays auto: a fixed 0 height
@@ -475,8 +558,10 @@ P4e lock screen notes:
   interactive (OK-62416).
 - Android back is swallowed on the lock screen (blocking, not dismissible);
   it no longer reaches navigation behind the lock.
-- The web lock tamper check and the lock screen's body-level inert pass are
-  unchanged; the lock layer root is a `document.body` child.
+- The web lock tamper check is retained. The body-level inert pass starts
+  when the lock node actually mounts, covers later body portals, and restores
+  each node's previous inert state on unlock. The lock layer root is a
+  `document.body` child.
 
 P5a native popover notes:
 
@@ -484,14 +569,18 @@ P5a native popover notes:
   (`NativeSheetPresentation`); the Tamagui Popover sheet (`TMPopover.Adapt`),
   its external backdrop, z-index and back handler are gone, and
   the removed `nativeSheet` option throws. iPad / wide windows keep the 400–480 pt centered
-  frame inside the sheet. `usingSheet={false}` still renders no panel on
-  native (web / desktop floating panels).
+  frame inside the sheet. Native keeps this supported sheet presentation
+  even when a cross-platform caller sets `usingSheet={false}` for its web panel.
 - The native popover renders inline in the caller's tree (its contexts
   apply) instead of through the full-window portal. Every popover remains
   mounted until the exit callback (1 s fallback); content then unmounts
   unless `keepChildrenMounted`. Reopening cancels pending teardown.
 - `closePopover()` waits for exit completion; repeated requests share the
   same completion promise, and completion or unmount clears its timer.
+- Percent sheet snap points set the viewport height on native and web; fit
+  mode keeps content measurement. Both keep the header and bottom spacing
+  inside the bounded surface. Native Popover and custom Toast also retain
+  their deferred-guide blocker while open.
 - Sheet options are package-owned. Unsupported legacy `sheetProps` keys
   and floating-panel `zIndex` / `portalProps` throw instead of being ignored.
 
@@ -501,16 +590,22 @@ P5b web popover notes:
   level; the Tamagui Popover and `PopoverContent` are gone.
   - Below `md` with `usingSheet` (the default): an overlay sheet with a
     header and a dismissing backdrop.
-  - Otherwise: `presentation="anchored"`, non-blocking and without a backdrop.
+  - Otherwise: `presentation="anchored"`, non-blocking, with a transparent
+    dismissing backdrop for press-triggered panels. Hover panels have no backdrop.
     Floating UI (`@floating-ui/dom`) places the panel: offset, flip, shift,
     and a max height from the available space. `autoUpdate` follows scroll
     and resize.
-- The enter animation scales an ancestor of the panel, so the panel measures
-  smaller while it runs. The panel is positioned again on `onPresented`.
-- Anchored panels close on an outside press. Presses on the trigger, on the
-  panel, or inside an overlay ranked above it do not close it, so a nested
-  Select or a Dialog opened from the panel keeps it open. They also close on
-  Escape, unless `hoverable`.
+- For a single positioned child, Web anchored scale/fade runs on that content,
+  with a local transform origin. Its full-window positioning ancestors remain
+  untransformed, so Floating UI uses the same coordinate space during and after
+  the animation. Completion positioning must not correct coordinates distorted
+  by the enter scale. Multi-child roots retain their shared full-window motion.
+- Press-triggered anchored panels close on a backdrop press without activating
+  the page underneath. Presses on the panel or inside an overlay ranked above
+  it do not close it, so a nested Select or a Dialog opened from the panel
+  keeps it open. They also close on Escape, unless `hoverable`.
+- Press-triggered anchored panels own a focus scope and forward caller
+  open/close autofocus callbacks. Hover panels never move or trap focus.
 - `hoverable` opens and closes on mouse enter / leave of the trigger and
   panel. The default close delay is 100 ms, so the pointer can cross the gap.
 - `keepChildrenMounted` maps to `keepContentMounted`. On web a closed entry

package/ios/NativeOverlayContainerView.swift

@@ -323,8 +323,17 @@ final class NativeOverlayEntryView: UIView {
     }
     if visible {
       cycleOpen = true
-      // A sheet that is still animating out is re-presented after it finishes.
-      if phase == .hidden || (phase == .exiting && !usesSystemSheet) {
+      if phase == .exiting, usesSystemSheet, let controller = sheetController,
+         controller.cancelHostDismissal(completion: { [weak self, weak controller] in
+           DispatchQueue.main.async {
+             guard let self, self.sheetController === controller, self.phase == .entering else { return }
+             self.phase = .shown
+             self.didPresent()
+             if !self.visible { self.dismissSheet() }
+           }
+         }) {
+        phase = .entering
+      } else if phase == .hidden || (phase == .exiting && !usesSystemSheet) {
         present()
       }
     } else if cycleOpen {
@@ -473,13 +482,13 @@ final class NativeOverlayEntryView: UIView {
     reportContentOffset()
     NativeOverlayWindowManager.shared.entryRemoved(from: hostWindow)
     guard let reason, cycleOpen else { return }
-    cycleOpen = visible
-    onDismissed?(["reason": reason])
-    // Reopened while the exit animation ran; UIKit-initiated dismissals
-    // ("system") are left for JS to settle instead.
+    // A reopen at UIKit's completion boundary keeps the same JS entry.
     if reason == "programmatic", visible, window != nil {
       present()
+      return
     }
+    cycleOpen = visible
+    onDismissed?(["reason": reason])
   }
 
   private func didPresent() {
@@ -568,12 +577,16 @@ final class NativeOverlayEntryView: UIView {
       finishDismiss(reason: "programmatic")
       return
     }
+    if controller.resumeHostDismissal() {
+      phase = .exiting
+      return
+    }
     // Closing mid-presentation is handled by the present completion.
     guard !controller.isBeingPresented, phase != .exiting else { return }
     phase = .exiting
     controller.dismissRequestedByHost = true
     controller.dismiss(animated: true) { [weak self, weak controller] in
-      guard let self, self.sheetController === controller else { return }
+      guard let self, self.sheetController === controller, self.phase == .exiting else { return }
       self.finishDismiss(reason: "programmatic")
     }
   }

package/ios/NativeOverlaySheetController.swift

@@ -31,6 +31,7 @@ private final class NativeOverlaySheetTransitionAnimator: NSObject,
   private let presenting: Bool
   private let motion: NativeOverlayMotion
   private var animator: UIViewPropertyAnimator?
+  private var cancellationCompletion: (() -> Void)?
 
   init(presenting: Bool, motion: NativeOverlayMotion) {
     self.presenting = presenting
@@ -90,15 +91,32 @@ private final class NativeOverlaySheetTransitionAnimator: NSObject,
     animator.addCompletion { position in
       let completed = position == .end && !transitionContext.transitionWasCancelled
       if !completed {
+        sheetView.alpha = self.presenting && reduceMotion ? 0 : 1
         sheetView.transform = self.presenting ? offscreen : .identity
         sheetController.setDimmingAlpha(self.presenting ? 0 : 1)
       }
       transitionContext.completeTransition(completed)
+      if position == .start { self.cancellationCompletion?() }
+      self.cancellationCompletion = nil
     }
     self.animator = animator
     return animator
   }
 
+  func reverseDismissal(completion: @escaping () -> Void) -> Bool {
+    guard !presenting, let animator, animator.isRunning, !animator.isReversed else { return false }
+    cancellationCompletion = completion
+    animator.isReversed = true
+    return true
+  }
+
+  func resumeDismissal() -> Bool {
+    guard !presenting, let animator, animator.isRunning, animator.isReversed else { return false }
+    cancellationCompletion = nil
+    animator.isReversed = false
+    return true
+  }
+
   func animationEnded(_ transitionCompleted: Bool) {
     animator = nil
   }
@@ -119,6 +137,7 @@ final class NativeOverlaySheetController: UIViewController,
   private var dimmingView: UIView?
   private var backdropTap: UITapGestureRecognizer?
   private var heightAnimator: UIViewPropertyAnimator?
+  private var dismissalAnimator: NativeOverlaySheetTransitionAnimator?
   private var shadowSuppressionDisplayLink: CADisplayLink?
   /// Set while the host itself asked UIKit to dismiss.
   var dismissRequestedByHost = false
@@ -230,7 +249,22 @@ final class NativeOverlaySheetController: UIViewController,
   func animationController(
     forDismissed dismissed: UIViewController
   ) -> UIViewControllerAnimatedTransitioning? {
-    NativeOverlaySheetTransitionAnimator(presenting: false, motion: style.exitMotion)
+    let animator = NativeOverlaySheetTransitionAnimator(presenting: false, motion: style.exitMotion)
+    dismissalAnimator = animator
+    return animator
+  }
+
+  func cancelHostDismissal(completion: @escaping () -> Void) -> Bool {
+    guard dismissRequestedByHost,
+          dismissalAnimator?.reverseDismissal(completion: completion) == true else { return false }
+    dismissRequestedByHost = false
+    return true
+  }
+
+  func resumeHostDismissal() -> Bool {
+    guard dismissalAnimator?.resumeDismissal() == true else { return false }
+    dismissRequestedByHost = true
+    return true
   }
 
   override func viewWillAppear(_ animated: Bool) {

package/lib/module/OverlayStore.js

@@ -97,6 +97,16 @@ export class OverlayStore {
     }
   }
 
+  /** Reverses an unfinished close without creating a new presentation cycle. */
+  reopen(id) {
+    const entry = this.shown.get(id);
+    if (!entry || entry.phase !== 'closing') return;
+    this.clearClosingTimer(id);
+    entry.phase = 'active';
+    entry.dismissReason = undefined;
+    this.emit();
+  }
+
   /** Removes a closing (or active) entry once its exit animation finished. */
   finalize(id) {
     const entry = this.shown.get(id);
@@ -207,7 +217,9 @@ export class OverlayStore {
     if (queuedIndex !== -1) {
       this.queued = this.queued.filter(e => e.id !== id);
       // Queued entries never rendered, so they leave without an exit animation.
-      queueMicrotask(() => this.notifyRemoved(id, reason));
+      const handlers = this.handlers.get(id);
+      this.handlers.delete(id);
+      queueMicrotask(() => handlers?.onRemoved?.(reason));
       return true;
     }
     const entry = this.shown.get(id);