@apexnative/navigation 1.0.0-alpha.5 → 1.0.0-alpha.6

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -1,9 +1,7 @@
 #import "ANNComponentViewController.h"
 #import "ANNAppearanceDispatcher.h"
-#import "ANNArrangementState.h"
 #import "ANNBottomTabsController.h"
 #import "ANNComponentPresenter.h"
-#import "ANNEventContract.h"
 #import "ANNHinge.h"
 #import "ANNKeyCommands.h"
 #import "ANNNodeRegistry.h"
@@ -11,7 +9,7 @@
 #import "ANNPendingLayers.h"
 #import "ANNPreviewPush.h"
 #import "ANNScreenBars.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
 #import "ANNScreenRegions.h"
 #import "ANNScreenSafeArea.h"
@@ -432,7 +430,7 @@
     return UIRectEdgeNone;
 }
 
-// The insets and the padding of a React screen or a slot screen go to the module, which keeps them, gives JavaScript
+// The insets and the padding of a React screen or a slot screen go to the store, which keeps them, gives JavaScript
 // what still covers the content and tells only of changes; the regions in the same pass. Only in a window and with an
 // id; never after the destroy, which removed them (a late layout would bring them back), nor for the JavaScript that
 // went (an old screen held after a reload: the new JavaScript may give its id to a new screen).
@@ -453,22 +451,18 @@
     UINavigationController *stack = [self shownNavigation];
     ANNScreenPaddingContext context = {
         .inStack = stack != nil,
-        // The stack's toolbar, by the rule the stack shows it with: one that `topBar.hideOnScroll`
-        // hid with the bar still counts.
-        .stackShowsToolbar = stack != nil && options.toolbar.shouldShow,
-        .windowBottomSafeArea = window.safeAreaInsets.bottom,
         .verticalBarSide = [self verticalBarSide],
     };
     UIEdgeInsets padding = ANNScreenPadding(insets, options, context);
-    [ANNScreenInsets setInsets:insets
-                       padding:padding
-                   forScreenId:componentId
-                  eventEmitter:eventEmitter];
+    [ANNScreenEnvironment setInsets:insets
+                            padding:padding
+                        forScreenId:componentId
+                       eventEmitter:eventEmitter];
     [self updateRegions];
 }
 
 // The regions in the same pass, and on the next turn after a change of the hinge's state (`hingeDidChange:`). Nil
-// before iOS 27.1: nothing to keep. An empty first result is not sent.
+// before iOS 27.1: nothing to keep. The store neither keeps nor sends an empty first result.
 - (void)updateRegions {
     UIView<ANNComponentProtocol> *content = _reactView;
     NSString *componentId = self.layoutInfo.componentId;
@@ -483,12 +477,7 @@
     if (!regions) {
         return;
     }
-    const auto &keys = ANNEventContract.ScreenRegionsChanged;
-    BOOL empty = [regions[keys.division] count] == 0 && [regions[keys.occlusion] count] == 0;
-    if (empty && ![ANNScreenRegions regionsForScreenId:componentId]) {
-        return;
-    }
-    [ANNScreenRegions setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
+    [ANNScreenEnvironment setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
 }
 
 - (void)hingeDidChange:(NSNotification *)notification {
@@ -690,9 +679,7 @@
     // its destroy, as at a reload) keeps it.
     NSString *componentId = self.layoutInfo.componentId;
     if (componentId && ![ANNNodeRegistry nodeForComponentId:componentId]) {
-        [ANNScreenInsets removeScreenId:componentId];
-        [ANNScreenRegions removeScreenId:componentId];
-        [ANNArrangementState removeScreenId:componentId];
+        [ANNScreenEnvironment removeScreenId:componentId];
         [ANNScreenReadiness removeScreenId:componentId];
     }
 }

package/ios/Layouts/Screen/ANNPreviewInteraction.h

@@ -9,15 +9,18 @@
 
 /**
  * Previews `preview` from `view`, the component view with the tag `reactTag`, and replaces an earlier
- * preview of the view. `commit` runs on a tap on the preview and returns whether it showed the
- * screen; the preview goes then, as the push it stands for is done. `dismissed` runs once when the
- * preview goes without being shown as a screen: replaced by another preview of the view, after
- * Fabric gave the view to another component, or when `source`, the screen of the view, goes.
+ * preview of the view. `prepare` runs as each press starts, before the menu shows the preview: it
+ * renders the screen if it hasn't yet, and returns NO when the preview went instead (no menu shows
+ * then). `commit` runs on a tap on the preview and returns whether it showed the screen; the
+ * preview goes then, as the push it stands for is done. `dismissed` runs once when the preview
+ * goes without being shown as a screen: replaced by another preview of the view, after Fabric gave
+ * the view to another component, or when `source`, the screen of the view, goes.
  */
 + (void)attachPreview:(UIViewController *)preview
                toView:(UIView *)view
              reactTag:(NSInteger)reactTag
                source:(UIViewController *)source
+              prepare:(BOOL (^)(void))prepare
                commit:(BOOL (^)(void))commit
             dismissed:(void (^)(void))dismissed;
 

package/ios/Layouts/Screen/ANNPreviewInteraction.mm

@@ -24,15 +24,23 @@ static NSMutableSet *ANNPreviews(void) {
 @implementation ANNPreviewInteraction {
     UIViewController *_preview;
     NSInteger _reactTag;
+    __weak UIViewController *_source;
+    BOOL (^_prepare)(void);
     BOOL (^_commit)(void);
     void (^_dismissed)(void);
     UIContextMenuInteraction *_interaction;
+    // The snapshots of the view that the menu of this press lifts and puts back, over the view until
+    // the menu is gone. Each press has its own list: a new press may start while the last menu goes.
+    NSMutableArray<UIView *> *_snapshots;
+    // The list of the menu that goes now: its end removes them.
+    __weak NSMutableArray<UIView *> *_endingSnapshots;
 }
 
 + (void)attachPreview:(UIViewController *)preview
                toView:(UIView *)view
              reactTag:(NSInteger)reactTag
                source:(UIViewController *)source
+              prepare:(BOOL (^)(void))prepare
                commit:(BOOL (^)(void))commit
             dismissed:(void (^)(void))dismissed {
     if (!view || !preview) {
@@ -45,6 +53,8 @@ static NSMutableSet *ANNPreviews(void) {
     ANNPreviewInteraction *previewInteraction = [ANNPreviewInteraction new];
     previewInteraction->_preview = preview;
     previewInteraction->_reactTag = reactTag;
+    previewInteraction->_source = source;
+    previewInteraction->_prepare = [prepare copy];
     previewInteraction->_commit = [commit copy];
     previewInteraction->_dismissed = [dismissed copy];
     previewInteraction->_interaction =
@@ -91,7 +101,9 @@ static NSMutableSet *ANNPreviews(void) {
     [view removeInteraction:_interaction];
     // A tap's commit animation may still run: a preview that went, its screen destroyed and its push failed, is not
     // pushed when the animation ends.
+    _prepare = nil;
     _commit = nil;
+    [ANNPreviewInteraction removeSnapshots:_snapshots];
     void (^dismissed)(void) = _dismissed;
     _dismissed = nil;
     if (dismissed) {
@@ -116,6 +128,18 @@ static NSMutableSet *ANNPreviews(void) {
         [self detach];
         return nil;
     }
+    // UIKit ends a lift that never became a menu too (the touch ended before the long press); should
+    // it not, the snapshot of that press goes now.
+    if (_snapshots != _endingSnapshots) {
+        [ANNPreviewInteraction removeSnapshots:_snapshots];
+    }
+    _snapshots = [NSMutableArray new];
+    // UIKit asks for the configuration as the press starts, about half a second before it shows the preview: the
+    // screen renders now, so that its content is there by then.
+    if (_prepare && !_prepare()) {
+        [self detach];
+        return nil;
+    }
     UIViewController *preview = _preview;
     NSArray *actions = preview.resolveOptions.preview.actions;
     return [UIContextMenuConfiguration
@@ -129,6 +153,23 @@ static NSMutableSet *ANNPreviews(void) {
                      }];
 }
 
+// The menu goes: the snapshots of its press go once it is gone. UIKit asks for the one
+// it goes back to after this call, so the list is read at the end, not now.
+- (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+       willEndForConfiguration:(UIContextMenuConfiguration *)configuration
+                      animator:(id<UIContextMenuInteractionAnimating>)animator {
+    NSMutableArray<UIView *> *snapshots = _snapshots;
+    _endingSnapshots = snapshots;
+    void (^remove)(void) = ^{
+      [ANNPreviewInteraction removeSnapshots:snapshots];
+    };
+    if (animator) {
+        [animator addCompletion:remove];
+    } else {
+        dispatch_async(dispatch_get_main_queue(), remove);
+    }
+}
+
 - (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
     willPerformPreviewActionForMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
                                             animator:(id<UIContextMenuInteractionCommitAnimating>)
@@ -148,24 +189,45 @@ static NSMutableSet *ANNPreviews(void) {
 
 #pragma mark - Targeted previews
 
-// The view the menu lifts from and goes back to: a snapshot of the source view in its window. With
-// the source view itself UIKit adds its views next to it, among the React views of its parent, and
-// Fabric then mounts and unmounts at the wrong places.
+// The view the menu lifts from and goes back to: a snapshot of the source view, laid over it in the
+// view of its screen, the core's own (in its window when the view is elsewhere), so that it goes with
+// the screen (a pop right after the menu). With the source view itself UIKit adds its views next to
+// it, among the React views of its parent, and Fabric then mounts and unmounts at the wrong places.
+// A snapshot out of the window, with only a target there, iOS 27 doesn't lift: it dims it in place.
 - (UITargetedPreview *)snapshotPreviewOf:(UIView *)view {
-    UIWindow *window = view.window;
+    UIView *container = _source.viewIfLoaded;
+    if (!container || ![view isDescendantOfView:container]) {
+        container = view.window;
+    }
+    // A screen out of its window (a command took it away while the menu showed) has no place for it:
+    // UIKit needs the view in a window.
+    if (!container.window) {
+        return nil;
+    }
     UIView *snapshot = [view snapshotViewAfterScreenUpdates:NO];
-    if (!window || !snapshot) {
+    if (!snapshot) {
         return nil;
     }
+    snapshot.frame = [view convertRect:view.bounds toView:container];
+    snapshot.userInteractionEnabled = NO;
+    snapshot.accessibilityElementsHidden = YES;
+    [container addSubview:snapshot];
+    if (!_snapshots) {
+        _snapshots = [NSMutableArray new];
+    }
+    [_snapshots addObject:snapshot];
     UIPreviewParameters *parameters = [UIPreviewParameters new];
     parameters.backgroundColor = UIColor.clearColor;
     parameters.visiblePath = [UIBezierPath bezierPathWithRoundedRect:view.bounds
                                                         cornerRadius:view.layer.cornerRadius];
-    CGPoint center = [view convertPoint:CGPointMake(CGRectGetMidX(view.bounds),
-                                                    CGRectGetMidY(view.bounds))
-                                 toView:window];
-    UIPreviewTarget *target = [[UIPreviewTarget alloc] initWithContainer:window center:center];
-    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters target:target];
+    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters];
+}
+
++ (void)removeSnapshots:(NSMutableArray<UIView *> *)snapshots {
+    for (UIView *snapshot in snapshots) {
+        [snapshot removeFromSuperview];
+    }
+    [snapshots removeAllObjects];
 }
 
 - (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction

package/ios/Layouts/Screen/ANNScreenEnvironment.h

@@ -0,0 +1,63 @@
+#import "ANNEventEmitter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A view that keeps a screen's content out of its padding (the screen's safe area view).
+@protocol ANNScreenPaddingListener <NSObject>
+/// The padding of its screen changed. Main queue.
+- (void)screenPaddingDidChange;
+@end
+
+/// What JavaScript knows of each screen's place, by the screen's id, in one record: its safe area (the insets
+/// JavaScript gets, `useSafeAreaInsets`, and the padding of its safe area view), its reserved regions
+/// (`useReservedRegions`) and, in a pair, its arrangement (`useArrangement`). The core measures them
+/// (`ANNScreenSafeArea`, `ANNScreenRegions`, the pair's layout) on the main queue and keeps them here; JavaScript reads
+/// them from its own thread for a screen's first render, under one lock, and gets every change as an event. When the
+/// screen goes, `removeScreenId:` clears all of it. As on Android (`ScreenEnvironment`).
+@interface ANNScreenEnvironment : NSObject
+
+/// Keeps the screen's insets and the padding of its safe area view. The padding is the part of the insets the safe
+/// area view keeps the content out of (the edges the screen's options give); JavaScript gets the rest, what still
+/// covers the content (0 on a padded edge). Tells the padding's listeners of that screen when the padding changed, then
+/// JavaScript (`ANN.ScreenInsetsChanged`) when its insets did. Main queue.
++ (void)setInsets:(UIEdgeInsets)insets
+          padding:(UIEdgeInsets)padding
+      forScreenId:(NSString *)screenId
+     eventEmitter:(ANNEventEmitter *)eventEmitter;
+/// The padding of the screen's safe area view; none before the screen was laid out. Any thread.
++ (UIEdgeInsets)paddingForScreenId:(NSString *)screenId;
+/// `{ top, right, bottom, left }`, or nil before the screen was laid out. Any thread.
++ (nullable NSDictionary<NSString *, NSNumber *> *)insetsForScreenId:(NSString *)screenId;
+
+/// Keeps the screen's regions (`{ division, occlusion }`) and tells JavaScript (`ANN.ScreenRegionsChanged`) when they
+/// changed. None at first is what JavaScript reads before the first layout: it is neither kept nor told. Main queue.
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter;
+/// `{ division, occlusion }`, or nil before the screen's regions were first kept. Any thread.
++ (nullable NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId;
+
+/// Keeps the screen's arrangement (`{ placement, layout, front, hidden }`) and tells JavaScript
+/// (`ANN.ArrangementChanged`) when it changed; nothing goes without an emitter. Main queue.
++ (void)setArrangement:(NSDictionary<NSString *, id> *)arrangement
+           forScreenId:(NSString *)screenId
+          eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
+/// The screen's arrangement, or nil for a screen outside a pair. Any thread.
++ (nullable NSDictionary<NSString *, id> *)arrangementForScreenId:(NSString *)screenId;
+
+/// Tells `listener` of each change of the screen's padding, until it is removed or goes (held weakly). Several
+/// listeners may listen to one screen. Main queue.
++ (void)addPaddingListener:(id<ANNScreenPaddingListener>)listener forScreenId:(NSString *)screenId;
++ (void)removePaddingListener:(id<ANNScreenPaddingListener>)listener
+                  forScreenId:(NSString *)screenId;
+
+/// Forgets everything kept for the screen. Its padding listeners stay: a live safe area view keeps listening while it
+/// keeps the id, and stops itself. Main queue.
++ (void)removeScreenId:(NSString *)screenId;
+/// Forgets every screen: after a reload the new JavaScript counts its ids anew. Main queue.
++ (void)removeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenEnvironment.mm

@@ -0,0 +1,181 @@
+#import "ANNScreenEnvironment.h"
+#import "ANNEventContract.h"
+
+// One screen's record; nil for a fact not known yet (not laid out, no regions, outside a pair). Changed and read only
+// under the lock of `ANNEnvironmentById`; the values are immutable, so a reader keeps what it took.
+@interface ANNScreenEnvironmentRecord : NSObject
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSNumber *> *insets;
+@property(nonatomic, strong, nullable) NSValue *padding;
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSArray *> *regions;
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, id> *arrangement;
+@end
+
+@implementation ANNScreenEnvironmentRecord
+@end
+
+// Written on the main queue, read from any thread: every access holds its lock.
+static NSMutableDictionary<NSString *, ANNScreenEnvironmentRecord *> *ANNEnvironmentById;
+// The safe area views of each screen, by its id (the id's value: the view's id and the core's are other strings), held
+// weakly. Main queue only.
+static NSMutableDictionary<NSString *, NSHashTable<id<ANNScreenPaddingListener>> *>
+    *ANNPaddingListenersById;
+
+@implementation ANNScreenEnvironment
+
++ (void)initialize {
+    if (self == ANNScreenEnvironment.class) {
+        ANNEnvironmentById = [NSMutableDictionary new];
+        ANNPaddingListenersById = [NSMutableDictionary new];
+    }
+}
+
+// The screen's record, a new one for a screen not kept yet. Under the lock.
++ (ANNScreenEnvironmentRecord *)recordOf:(NSString *)screenId {
+    ANNScreenEnvironmentRecord *record = ANNEnvironmentById[screenId];
+    if (!record) {
+        record = [ANNScreenEnvironmentRecord new];
+        ANNEnvironmentById[screenId] = record;
+    }
+    return record;
+}
+
+#pragma mark - Insets and padding
+
++ (void)setInsets:(UIEdgeInsets)insets
+          padding:(UIEdgeInsets)padding
+      forScreenId:(NSString *)screenId
+     eventEmitter:(ANNEventEmitter *)eventEmitter {
+    NSValue *paddingValue = [NSValue valueWithUIEdgeInsets:padding];
+    // JavaScript gets what still covers the content: the edges the safe area view keeps it off are 0.
+    const auto &keys = ANNEventContract.ScreenInsetsChanged;
+    NSDictionary<NSString *, NSNumber *> *value = @{
+        keys.top : @(MAX(insets.top - padding.top, 0)),
+        keys.right : @(MAX(insets.right - padding.right, 0)),
+        keys.bottom : @(MAX(insets.bottom - padding.bottom, 0)),
+        keys.left : @(MAX(insets.left - padding.left, 0)),
+    };
+    BOOL paddingChanged;
+    BOOL insetsChanged;
+    @synchronized(ANNEnvironmentById) {
+        ANNScreenEnvironmentRecord *record = [self recordOf:screenId];
+        paddingChanged = ![record.padding isEqualToValue:paddingValue];
+        insetsChanged = ![record.insets isEqualToDictionary:value];
+        record.padding = paddingValue;
+        record.insets = value;
+    }
+    // The listeners read the padding back, so it is kept before they are told. A copy: a listener may stop or start
+    // listening while it is told.
+    if (paddingChanged) {
+        NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+        for (id<ANNScreenPaddingListener> listener in listeners.allObjects) {
+            [listener screenPaddingDidChange];
+        }
+    }
+    if (insetsChanged) {
+        [eventEmitter sendScreenInsetsChanged:screenId insets:value];
+    }
+}
+
++ (UIEdgeInsets)paddingForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].padding.UIEdgeInsetsValue;
+    }
+}
+
++ (NSDictionary<NSString *, NSNumber *> *)insetsForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].insets;
+    }
+}
+
+#pragma mark - Regions
+
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter {
+    const auto &keys = ANNEventContract.ScreenRegionsChanged;
+    BOOL empty = [regions[keys.division] count] == 0 && [regions[keys.occlusion] count] == 0;
+    @synchronized(ANNEnvironmentById) {
+        NSDictionary<NSString *, NSArray *> *before = ANNEnvironmentById[screenId].regions;
+        if ((!before && empty) || [before isEqualToDictionary:regions]) {
+            return;
+        }
+        [self recordOf:screenId].regions = regions;
+    }
+    [eventEmitter sendScreenRegionsChanged:screenId regions:regions];
+}
+
++ (NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].regions;
+    }
+}
+
+#pragma mark - Arrangement
+
++ (void)setArrangement:(NSDictionary<NSString *, id> *)arrangement
+           forScreenId:(NSString *)screenId
+          eventEmitter:(ANNEventEmitter *)eventEmitter {
+    @synchronized(ANNEnvironmentById) {
+        ANNScreenEnvironmentRecord *record = [self recordOf:screenId];
+        if ([record.arrangement isEqualToDictionary:arrangement]) {
+            return;
+        }
+        record.arrangement = arrangement;
+    }
+    [eventEmitter sendArrangementChanged:screenId state:arrangement];
+}
+
++ (NSDictionary<NSString *, id> *)arrangementForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].arrangement;
+    }
+}
+
+#pragma mark - Padding listeners
+
++ (void)addPaddingListener:(id<ANNScreenPaddingListener>)listener
+               forScreenId:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    if (!listeners) {
+        listeners = [NSHashTable weakObjectsHashTable];
+        ANNPaddingListenersById[screenId] = listeners;
+    }
+    [listeners addObject:listener];
+}
+
++ (void)removePaddingListener:(id<ANNScreenPaddingListener>)listener
+                  forScreenId:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    [listeners removeObject:listener];
+    [self forgetListenersOfScreenIdIfNone:screenId];
+}
+
+// A view that went (it doesn't remove itself in its `dealloc`) leaves no entry in the weak table: `allObjects` counts
+// only the live ones. The table of a screen nobody listens to goes with the last one, or with the screen's record.
++ (void)forgetListenersOfScreenIdIfNone:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    if (listeners && listeners.allObjects.count == 0) {
+        [ANNPaddingListenersById removeObjectForKey:screenId];
+    }
+}
+
+#pragma mark - Removal
+
++ (void)removeScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        [ANNEnvironmentById removeObjectForKey:screenId];
+    }
+    [self forgetListenersOfScreenIdIfNone:screenId];
+}
+
++ (void)removeAll {
+    @synchronized(ANNEnvironmentById) {
+        [ANNEnvironmentById removeAllObjects];
+    }
+    for (NSString *screenId in ANNPaddingListenersById.allKeys) {
+        [self forgetListenersOfScreenIdIfNone:screenId];
+    }
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenRegions.h

@@ -1,12 +1,10 @@
-#import "ANNEventEmitter.h"
 #import <UIKit/UIKit.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// The reserved regions of each screen (`useReservedRegions`), iOS 27.1: `division`, where the screen divides (the fold
-/// of a partly folded device), and `occlusion`, where hardware covers it (a camera); each a list of
-/// `{ x, y, width, height }`. The native side keeps them on the main queue; JavaScript reads them from its own thread
-/// for a screen's first render, and gets every change as `ANN.ScreenRegionsChanged`.
+/// The reserved regions of a screen (`useReservedRegions`), iOS 27.1: `division`, where the screen divides (the fold of
+/// a partly folded device), and `occlusion`, where hardware covers it (a camera); each a list of
+/// `{ x, y, width, height }`. Measured here; kept for JavaScript by `ANNScreenEnvironment`.
 @interface ANNScreenRegions : NSObject
 
 /// The active regions UIKit reserves in `view`, without the margins it adds around them for interactive content, in
@@ -15,19 +13,6 @@ NS_ASSUME_NONNULL_BEGIN
 + (nullable NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
                                                 inCoordinatesOf:(UIView *)coordinateView;
 
-/// Keeps the screen's regions and tells when they changed. Main queue.
-+ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
-       forScreenId:(NSString *)screenId
-      eventEmitter:(ANNEventEmitter *)eventEmitter;
-
-/// `{ division, occlusion }`, or nil before the screen was laid out. Any thread.
-+ (nullable NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId;
-
-+ (void)removeScreenId:(NSString *)screenId;
-
-/// Forgets every screen: after a reload the new JavaScript counts its ids anew. Main queue.
-+ (void)removeAll;
-
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenRegions.mm

@@ -1,8 +1,6 @@
 #import "ANNScreenRegions.h"
 #import "ANNEventContract.h"
 
-static NSMutableDictionary<NSString *, NSDictionary<NSString *, NSArray *> *> *ANNScreenRegionsById;
-
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
 // The part of a region inside the screen, CGRectNull for a region outside it (the fold beside a screen of a pair, the
 // camera above a screen under the bar). A fold is 0 wide or 0 high: it is inside where its line crosses the screen,
@@ -51,12 +49,6 @@ ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *c
 
 @implementation ANNScreenRegions
 
-+ (void)initialize {
-    if (self == ANNScreenRegions.class) {
-        ANNScreenRegionsById = [NSMutableDictionary new];
-    }
-}
-
 + (NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
                                        inCoordinatesOf:(UIView *)coordinateView {
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
@@ -75,34 +67,4 @@ ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *c
     return nil;
 }
 
-+ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
-       forScreenId:(NSString *)screenId
-      eventEmitter:(ANNEventEmitter *)eventEmitter {
-    @synchronized(ANNScreenRegionsById) {
-        if ([ANNScreenRegionsById[screenId] isEqualToDictionary:regions]) {
-            return;
-        }
-        ANNScreenRegionsById[screenId] = regions;
-    }
-    [eventEmitter sendScreenRegionsChanged:screenId regions:regions];
-}
-
-+ (NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId {
-    @synchronized(ANNScreenRegionsById) {
-        return ANNScreenRegionsById[screenId];
-    }
-}
-
-+ (void)removeScreenId:(NSString *)screenId {
-    @synchronized(ANNScreenRegionsById) {
-        [ANNScreenRegionsById removeObjectForKey:screenId];
-    }
-}
-
-+ (void)removeAll {
-    @synchronized(ANNScreenRegionsById) {
-        [ANNScreenRegionsById removeAllObjects];
-    }
-}
-
 @end

package/ios/Layouts/Screen/ANNScreenSafeArea.h

@@ -7,10 +7,6 @@ NS_ASSUME_NONNULL_BEGIN
 typedef struct {
     /// The screen is in a stack.
     BOOL inStack;
-    /// The screen's stack shows its toolbar.
-    BOOL stackShowsToolbar;
-    /// The bottom of the window's safe area: the home indicator.
-    CGFloat windowBottomSafeArea;
     /// The physical side of the iPhone Duo vertical bar (iOS 27.1): `UIRectEdgeLeft`, `UIRectEdgeRight`, or
     /// `UIRectEdgeNone` without one.
     UIRectEdge verticalBarSide;
@@ -27,11 +23,10 @@ FOUNDATION_EXPORT UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize
                                                       UIEdgeInsets safeArea);
 
 /// The padding the screen's safe area view keeps (`layout.safeAreaEdges`): the insets on the padded edges, 0 on the
-/// others. With `layout.safeAreaEdges` exactly those edges (an explicit `'top'` keeps the top under a large title too);
-/// without it every edge but: the top under a shown top bar (in a stack, under the top bar, `topBar.visible` not
-/// `false`) or with a large title that can show; the bottom when the bottom inset covers more than the window's home
-/// indicator (by over 0.5 pt), or in a stack with a toolbar and `topBar.hideOnScroll`; the side of the vertical bar
-/// unless `layout.drawBehindVerticalBar` or `layout.verticalBars` is `false`.
+/// others. With `layout.safeAreaEdges` exactly those edges, but the top under a large title that can show (in a stack,
+/// `topBar.visible` not `false`); without it every edge but: the top under a shown top bar (in a stack, under the top
+/// bar, `topBar.visible` not `false`) or with a large title that can show; the bottom, always; the side of the
+/// vertical bar unless `layout.drawBehindVerticalBar` or `layout.verticalBars` is `false`.
 FOUNDATION_EXPORT UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
                                                 ANNScreenPaddingContext context);