@apexnative/navigation 1.0.0-alpha.10 → 1.0.0-alpha.11

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.0.0-alpha.11](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.10...v1.0.0-alpha.11) (2026-10-31)
+
+
+### Features
+
+* a pair's primary can take the trailing side or the bottom of a split ([#73](https://github.com/apexnative/navigation/issues/73)) ([90ddcd3](https://github.com/apexnative/navigation/commit/90ddcd3c62fa5878cc98651ca7a2cfcdf4645197))
+
+
+### Bug Fixes
+
+* **ios:** a pair and its insets settle at once when iPhone Duo folds or unfolds ([#71](https://github.com/apexnative/navigation/issues/71)) ([ad87ce1](https://github.com/apexnative/navigation/commit/ad87ce1669b55dfb6ad65bedfb8e119f08abb04e))
+
 ## [1.0.0-alpha.10](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.9...v1.0.0-alpha.10) (2026-10-30)
 
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementDefinition.kt

@@ -11,7 +11,10 @@ data class ArrangementDefinition(
     val axes: Axes,
     /** `split`: the primary's share along the split, 0–1, where a fold doesn't decide. */
     val fraction: Float,
-    /** `overlay`: the edge the primary takes when the pair goes side by side at a fold. */
+    /**
+     * The edge the primary takes. `split`: leading or top puts it first, trailing or bottom second; `overlay`: its edge
+     * when the pair goes side by side at a fold.
+     */
     val primaryEdge: Edge,
     /** What a window too small for a pair shows. */
     val compact: Compact,
@@ -36,8 +39,9 @@ data class ArrangementDefinition(
         @JvmStatic
         fun parse(data: JSONObject): ArrangementDefinition {
             val fraction = data.optDouble("fraction", DEFAULT_FRACTION).takeUnless { it.isNaN() } ?: DEFAULT_FRACTION
+            val style = if (data.optString("style") == "overlay") Style.OVERLAY else Style.SPLIT
             return ArrangementDefinition(
-                style = if (data.optString("style") == "overlay") Style.OVERLAY else Style.SPLIT,
+                style = style,
                 axes = when (data.optString("axes")) {
                     "horizontal" -> Axes.HORIZONTAL
                     "vertical" -> Axes.VERTICAL
@@ -48,7 +52,9 @@ data class ArrangementDefinition(
                     "leading" -> Edge.LEADING
                     "top" -> Edge.TOP
                     "bottom" -> Edge.BOTTOM
-                    else -> Edge.TRAILING
+                    "trailing" -> Edge.TRAILING
+                    // The default of each style: the primary first in a split, at the trailing side of an overlay.
+                    else -> if (style == Style.SPLIT) Edge.LEADING else Edge.TRAILING
                 },
                 compact = if (data.optString("compact") == "pair") Compact.PAIR else Compact.PRIMARY,
             )

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementPlanner.kt

@@ -45,8 +45,9 @@ internal fun WindowFolds.Fold.across(area: Rect): PairFold? {
 /**
  * Decides the frames of a pair. A window too small for a pair (`largeWindow` false: Material's compact width or
  * height) shows the primary alone with `compact: 'primary'`. Otherwise, and with `compact: 'pair'`: `split` lies side
- * by side when wider than tall, else one above the other, the primary at the leading side or on top with its
- * `fraction`; a fold across the pair puts the boundary on it, and the screens on its two sides, off its bounds.
+ * by side when wider than tall, else one above the other, the primary first (at the leading side or on top) or, with
+ * `primaryEdge` trailing or bottom, second, with its `fraction`; a fold across the pair puts the boundary on it, and
+ * the screens on its two sides, off its bounds.
  * `overlay`: both the whole size, the primary over the secondary; side by side at a fold that the device is partly
  * folded at, or that hides what is under it, the primary on `primaryEdge`. Where the axes don't allow the way the pair
  * would lie, only the primary shows (an overlay stays one over the other).
@@ -67,9 +68,9 @@ internal object ArrangementPlanner {
                 val sideBySide = fold?.vertical ?: (width > height)
                 when {
                     !definition.allows(sideBySide) -> ArrangementPlan(Layout.SINGLE, whole, null)
-                    // The primary at the leading side, or on top.
-                    fold != null -> atFold(fold, width, height, primaryFirst = !fold.vertical || !rtl)
-                    else -> byFraction(definition.fraction, width, height, sideBySide, rtl)
+                    fold != null ->
+                        atFold(fold, width, height, primaryFirst(definition.primaryEdge, fold.vertical, rtl))
+                    else -> byFraction(definition, width, height, sideBySide, rtl)
                 }
             }
             Style.OVERLAY ->
@@ -92,27 +93,31 @@ internal object ArrangementPlanner {
     }
 
     private fun byFraction(
-        fraction: Float,
+        definition: ArrangementDefinition,
         width: Int,
         height: Int,
         sideBySide: Boolean,
         rtl: Boolean,
     ): ArrangementPlan {
+        val first = primaryFirst(definition.primaryEdge, sideBySide, rtl)
         if (!sideBySide) {
-            val share = (height * fraction).roundToInt()
-            return ArrangementPlan(Layout.STACKED, Rect(0, 0, width, share), Rect(0, share, width, height))
+            val share = (height * definition.fraction).roundToInt()
+            val boundary = if (first) share else height - share
+            val top = Rect(0, 0, width, boundary)
+            val bottom = Rect(0, boundary, width, height)
+            return ArrangementPlan(Layout.STACKED, if (first) top else bottom, if (first) bottom else top)
         }
-        val share = (width * fraction).roundToInt()
-        // The primary at the leading side: the right one from right to left.
-        val boundary = if (rtl) width - share else share
+        val share = (width * definition.fraction).roundToInt()
+        // The primary's part on the left or on the right: the leading side is the right one from right to left.
+        val boundary = if (first) share else width - share
         val left = Rect(0, 0, boundary, height)
         val right = Rect(boundary, 0, width, height)
-        return ArrangementPlan(Layout.SIDE_BY_SIDE, if (rtl) right else left, if (rtl) left else right)
+        return ArrangementPlan(Layout.SIDE_BY_SIDE, if (first) left else right, if (first) right else left)
     }
 
-    // Whether the primary takes the left part of a vertical fold, or the top part of a horizontal one. An edge of the
-    // other axis counts as the nearest one: leading as top and top as leading, trailing as bottom and bottom as
-    // trailing.
+    // Whether the primary takes the left part of a vertical fold (or of a pair side by side), or the top part of a
+    // horizontal one (or of a pair one above the other). An edge of the other axis counts as the nearest one: leading
+    // as top and top as leading, trailing as bottom and bottom as trailing.
     private fun primaryFirst(edge: Edge, vertical: Boolean, rtl: Boolean): Boolean {
         val first = edge == Edge.LEADING || edge == Edge.TOP
         return if (vertical) first != rtl else first

package/docs-md/containers/arrangement.md

@@ -140,7 +140,7 @@ The type argument is the props of the pair, which the commands check as for any
 
 - **`axes`**: `'horizontal'` side by side only, `'vertical'` one above the other only, `'both'` by default. Where the window allows neither, only the primary shows.
 - **`fraction`**: the primary's share of a split, above 0 and below 1, half by default. At a fold the fold decides.
-- **`primaryEdge`**: where the primary goes when an overlay goes side by side, `'trailing'` by default.
+- **`primaryEdge`**: the side the primary takes. In a split `'leading'`, the default, puts it first, `'trailing'` second; in an overlay that goes side by side, `'trailing'` by default.
 - **`compact`**: what a window that isn't large shows: `'primary'`, the default, or `'pair'`.
 
 A pair has two screens, never more: in a `defineArrangement`, the primary's own `arrangement` doesn't count. Every key: [`defineArrangement`](/api/arrangement/defineArrangement).
@@ -163,6 +163,22 @@ Where only the primary shows, the secondary is still there, out of the window, a
 
 With `compact: 'pair'` of `defineArrangement` the pair shows everywhere: on a phone held upright, one above the other.
 
+### Which screen shows alone, and on which side
+
+The primary leads the pair: its bar is the pair's, and it is the screen that shows alone outside a large window. To have the other screen alone on a phone or on iPhone Duo folded, make that one the primary. `primaryEdge` then puts it on the side the layout asks for:
+
+```ts
+// The list on the leading side, the details on
+// the trailing one; folded, the details alone
+ItemWithList: defineArrangement<{ id: string }>({
+  primary: 'Details',
+  secondary: 'List',
+  primaryEdge: 'trailing',
+}),
+```
+
+The bar stays the details' bar folded and open, so opening iPhone Duo changes nothing in it: the list comes in beside the details, which keep their place in the window. One setting serves both ways a split lies: `'trailing'` and `'bottom'` put the primary second, at the trailing side or at the bottom; `'leading'` and `'top'` put it first.
+
 ## Split and overlay
 
 `style` says how the two share the window:

package/docs-md/index.json

@@ -813,6 +813,10 @@
         "heading": "What each device shows",
         "anchor": "devices"
       },
+      {
+        "heading": "Which screen shows alone, and on which side",
+        "anchor": "primary-and-sides"
+      },
       {
         "heading": "Split and overlay",
         "anchor": "style"

package/ios/Layouts/Arrangement/ANNArrangementViewController.mm

@@ -48,6 +48,14 @@ static NSDirectionalRectEdge ANNOppositeEdge(NSDirectionalRectEdge edge) {
     }
 }
 
+// `primaryEdge` of a split: whether the primary goes second, at the trailing side or at the bottom. A split has no edge
+// of its own: UIKit puts the view of its primary placement first along either axis (measured on iPhone Duo), so the
+// edge decides which screen goes into that placement.
+static BOOL ANNSecondaryFirst(NSDictionary *data) {
+    return ![@"overlay" isEqual:data[@"style"]] &&
+           ([@"trailing" isEqual:data[@"primaryEdge"]] || [@"bottom" isEqual:data[@"primaryEdge"]]);
+}
+
 // Overlay view properties with the edge a view takes when the pair goes side by side.
 static UIOverlayArrangementViewProperties *ANNOverlayProperties(UIOverlayArrangement *overlay,
                                                                NSDirectionalRectEdge edge)
@@ -95,8 +103,11 @@ static UIArrangement *ANNArrangementOfData(NSDictionary *data) API_AVAILABLE(ios
             height.preferred = dimension;
             primary.height = height;
         }
-        [split setViewProperties:primary
-                    forPlacement:UIArrangementViewControllerViewPlacementPrimary];
+        // The share is the primary screen's, in whichever placement it is.
+        UIArrangementViewControllerViewPlacement placement =
+            ANNSecondaryFirst(data) ? UIArrangementViewControllerViewPlacementSecondary
+                                    : UIArrangementViewControllerViewPlacementPrimary;
+        [split setViewProperties:primary forPlacement:placement];
     }
     return split;
 }
@@ -109,6 +120,38 @@ static UIArrangement *ANNPrimaryAloneArrangement(void) API_AVAILABLE(ios(27.1))
     return split;
 }
 
+// A size range from `minimum` to `maximum`, preferring `preferred`.
+static UISplitArrangementDimensionRange *ANNDimensionRange(UISplitArrangementDimension *minimum,
+                                                           UISplitArrangementDimension *preferred,
+                                                           UISplitArrangementDimension *maximum)
+    API_AVAILABLE(ios(27.1)) {
+    UISplitArrangementDimensionRange *range = [UISplitArrangementDimensionRange new];
+    range.minimum = minimum;
+    range.preferred = preferred;
+    range.maximum = maximum;
+    return range;
+}
+
+// The primary alone in the secondary placement, with the primary placement empty. UIKit keeps the empty placement's
+// share of a split (measured on iPhone Duo folded: the primary in the lower half, the upper one blank), so the empty
+// placement gets no room and the primary all of it, along either axis, which no shape of the window leaves out.
+static UIArrangement *ANNSecondPlacementAloneArrangement(void) API_AVAILABLE(ios(27.1)) {
+    UISplitArrangement *split = [UISplitArrangement splitArrangement];
+    split.axes = UIAxisHorizontal | UIAxisVertical;
+    UISplitArrangementDimension *none = [UISplitArrangementDimension absoluteDimension:0];
+    UISplitArrangementDimension *all = [UISplitArrangementDimension fractionalDimension:1];
+    UISplitArrangementViewProperties *empty = [split.defaultViewProperties copy];
+    empty.width = ANNDimensionRange(none, none, none);
+    empty.height = ANNDimensionRange(none, none, none);
+    [split setViewProperties:empty forPlacement:UIArrangementViewControllerViewPlacementPrimary];
+    UISplitArrangementViewProperties *primary = [split.defaultViewProperties copy];
+    primary.width = ANNDimensionRange(all, all, all);
+    primary.height = ANNDimensionRange(all, all, all);
+    [split setViewProperties:primary
+                forPlacement:UIArrangementViewControllerViewPlacementSecondary];
+    return split;
+}
+
 // Room for a pair: both size classes regular (iPad, iPhone Duo unfolded). Nil without a size class yet: the view
 // controller is not in a window.
 static NSNumber *ANNIsLargeWindow(UITraitCollection *traits) {
@@ -183,9 +226,20 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     // (`compact: 'primary'`).
     UIArrangement *_arrangement;
     BOOL _primaryAloneWhenSmall;
+    // `primaryEdge` of a split at the trailing side or the bottom: the secondary is in UIKit's primary placement, the
+    // primary in its secondary one. The primary alone keeps its placement and the secondary leaves its own, so the
+    // primary never changes its container at a fold. The axes the pair may use, for the primary alone then.
+    BOOL _secondaryFirst;
+    UIAxis _axes;
+    // The size a running size transition leads to, zero without one: the shape the pair decides its axes by.
+    CGSize _transitionSize;
     // What UIKit has now, once an arrangement went to it.
     BOOL _arranged;
     BOOL _primaryAlone;
+    // The scene's size classes the pair takes for a size transition, and which transition set them last: only that
+    // one's end takes them away.
+    BOOL _sceneSizeClasses;
+    NSUInteger _sceneSizeClassesTransition;
 }
 
 - (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
@@ -218,14 +272,16 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
             ((ANNComponentViewController *)screen).arrangement = self;
         }
     }
-    [self setViewController:primary
+    _secondaryFirst = ANNSecondaryFirst(data);
+    _axes = ANNArrangementAxes(data[@"axes"]);
+    [self setViewController:_secondaryFirst ? secondary : primary
                forPlacement:UIArrangementViewControllerViewPlacementPrimary];
-    [self setViewController:secondary
+    [self setViewController:_secondaryFirst ? primary : secondary
                forPlacement:UIArrangementViewControllerViewPlacementSecondary];
     _arrangement = ANNArrangementOfData(data);
     _primaryAloneWhenSmall = ![@"pair" isEqual:data[@"compact"]];
     // Before it is in a window: the window's size classes, which it will most likely have.
-    [self arrangeForTraits:ANNUtils.mainWindow.traitCollection animated:NO];
+    [self arrangeForTraits:ANNUtils.mainWindow.traitCollection];
     if (!_arranged) {
         [self updateArrangement:_arrangement animated:NO];
     }
@@ -239,19 +295,33 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
 // `compact: 'primary'`: the pair shows only in a large window; in any other (an iPhone, iPhone Duo folded) the primary
 // shows alone, and the secondary waits out of the window until the window is large (iPhone Duo unfolded). With
 // `compact: 'pair'` UIKit lays the pair out everywhere.
-- (void)arrangeForTraits:(UITraitCollection *)traits animated:(BOOL)animated {
+- (void)arrangeForTraits:(UITraitCollection *)traits {
     NSNumber *large = ANNIsLargeWindow(traits);
     if (!large) {
         return;
     }
-    BOOL alone = _primaryAloneWhenSmall && !large.boolValue;
+    BOOL alone = (_primaryAloneWhenSmall && !large.boolValue) ||
+                 (_secondaryFirst && ![self axesAllowSize:[self pairSize]]);
     if (_arranged && alone == _primaryAlone) {
         return;
     }
     BOOL changed = _arranged;
     _arranged = YES;
     _primaryAlone = alone;
-    [self updateArrangement:alone ? ANNPrimaryAloneArrangement() : _arrangement animated:animated];
+    if (_secondaryFirst) {
+        // The secondary leaves the window with its placement, as a split with no axis takes it out otherwise.
+        UIViewController *first = alone ? nil : _secondary;
+        if ([self viewControllerForPlacement:UIArrangementViewControllerViewPlacementPrimary] !=
+            first) {
+            [self setViewController:first
+                       forPlacement:UIArrangementViewControllerViewPlacementPrimary
+                           animated:NO];
+        }
+        [self updateArrangement:alone ? ANNSecondPlacementAloneArrangement() : _arrangement
+                       animated:NO];
+    } else {
+        [self updateArrangement:alone ? ANNPrimaryAloneArrangement() : _arrangement animated:NO];
+    }
     // A secondary that leaves the window renders no content: the pair waits for it no more.
     if (alone && _secondaryCounted) {
         _secondaryCounted = NO;
@@ -264,8 +334,103 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     }
 }
 
+// Where the axes leave the pair no room, UIKit shows its primary placement alone: with the secondary first that would
+// be the secondary, so the pair takes it out itself, by the shape UIKit goes by (side by side in a wide window, one
+// above the other in a tall one, measured on iPhone Duo).
+- (BOOL)axesAllowSize:(CGSize)size {
+    if ((_axes & UIAxisHorizontal) && (_axes & UIAxisVertical)) {
+        return YES;
+    }
+    BOOL wide = size.width > size.height;
+    return (_axes & (wide ? UIAxisHorizontal : UIAxisVertical)) != 0;
+}
+
+// The pair's size: where a size transition leads, its own once laid out, the window's before.
+- (CGSize)pairSize {
+    if (!CGSizeEqualToSize(_transitionSize, CGSizeZero)) {
+        return _transitionSize;
+    }
+    CGSize size = self.viewIfLoaded.bounds.size;
+    return size.width > 0 && size.height > 0 ? size : ANNUtils.mainWindow.bounds.size;
+}
+
+// New size classes come with a new window size, which leads the pair to its new place. UIKit's own animation of the
+// arrangement would aim at a layout it gives only in between (on iPhone Duo, one above the other while the window
+// still has its old size classes) and play on after the pair took its real one: the screens lagged by half a second.
 - (void)sizeClassesDidChange {
-    [self arrangeForTraits:self.traitCollection animated:self.viewIfLoaded.window != nil];
+    [self arrangeForTraits:self.traitCollection];
+}
+
+// On iPhone Duo the scene has its new size classes as the size transition starts, and the pair gets them only after
+// UIKit laid it out in the new size: the primary first filled the whole open window, then gave half of it to the
+// secondary. For the transition the pair takes the scene's size classes, so it lies as it will from its first layout.
+// Only where the pair has the window's size classes: a sheet or a split view's column has its own.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    // A new shape may leave the axes no room, or give it back: the pair takes it before its first layout in the size.
+    if (_secondaryFirst) {
+        _transitionSize = size;
+        [self arrangeForTraits:self.traitCollection];
+        __weak ANNArrangementViewController *weakPair = self;
+        void (^sized)(id<UIViewControllerTransitionCoordinatorContext>) =
+            ^(id<UIViewControllerTransitionCoordinatorContext> context) {
+              ANNArrangementViewController *pair = weakPair;
+              if (pair && CGSizeEqualToSize(pair->_transitionSize, size)) {
+                  pair->_transitionSize = CGSizeZero;
+              }
+            };
+        [coordinator animateAlongsideTransition:nil completion:sized];
+    }
+    UITraitCollection *scene = self.viewIfLoaded.window.windowScene.traitCollection;
+    NSNumber *large = ANNIsLargeWindow(self.traitCollection);
+    NSNumber *largeScene = scene ? ANNIsLargeWindow(scene) : nil;
+    if (!large || !largeScene || ![self hasWindowSizeClasses]) {
+        return;
+    }
+    // The size classes the pair has now are the scene's of an earlier transition, still running: this one keeps them
+    // until its own end.
+    if ([large isEqual:largeScene] && !_sceneSizeClasses) {
+        return;
+    }
+    _sceneSizeClasses = YES;
+    NSUInteger transition = ++_sceneSizeClassesTransition;
+    self.traitOverrides.horizontalSizeClass = scene.horizontalSizeClass;
+    self.traitOverrides.verticalSizeClass = scene.verticalSizeClass;
+    [self updateTraitsIfNeeded];
+    __weak ANNArrangementViewController *weakSelf = self;
+    void (^ended)(id<UIViewControllerTransitionCoordinatorContext>) =
+        ^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf dropSceneSizeClassesOfTransition:transition];
+        };
+    [coordinator animateAlongsideTransition:nil completion:ended];
+}
+
+- (void)dropSceneSizeClassesOfTransition:(NSUInteger)transition {
+    if (!_sceneSizeClasses || transition != _sceneSizeClassesTransition) {
+        return;
+    }
+    _sceneSizeClasses = NO;
+    [self.traitOverrides removeTrait:UITraitHorizontalSizeClass.class];
+    [self.traitOverrides removeTrait:UITraitVerticalSizeClass.class];
+}
+
+// The pair's size classes are the window's: it stands in the window's root, not in a presented layer, and no split
+// view's column is between them.
+- (BOOL)hasWindowSizeClasses {
+    UIWindow *window = self.viewIfLoaded.window;
+    if (!window) {
+        return NO;
+    }
+    UIViewController *top = self;
+    for (UIViewController *parent = self.parentViewController; parent;
+         parent = parent.parentViewController) {
+        if ([parent isKindOfClass:UISplitViewController.class]) {
+            return NO;
+        }
+        top = parent;
+    }
+    return top == window.rootViewController;
 }
 
 // The first state, before the pair is laid out: as UIKit lays it out in the window's shape (measured on iPhone Duo),
@@ -433,13 +598,17 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
 
 - (void)viewDidLayoutSubviews {
     [super viewDidLayoutSubviews];
+    // A size of its own without a transition (a column of a split view): the axes may allow another shape now.
+    if (_secondaryFirst) {
+        [self arrangeForTraits:self.traitCollection];
+    }
     [self setNeedsStateUpdate];
 }
 
 // In the window now: its own size classes, which the window's stood in for.
 - (void)viewWillAppear:(BOOL)animated {
     [super viewWillAppear:animated];
-    [self arrangeForTraits:self.traitCollection animated:NO];
+    [self arrangeForTraits:self.traitCollection];
 }
 
 - (void)viewDidAppear:(BOOL)animated {
@@ -479,10 +648,12 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
     if (!self.viewIfLoaded.window || _screensDestroyed) {
         return;
     }
+    // By the screens' placements: with `primaryEdge` at the trailing side or the bottom they are the other way round,
+    // and a secondary out of its placement has none.
     UIArrangementViewState *primaryState =
-        [self stateForPlacement:UIArrangementViewControllerViewPlacementPrimary];
+        [self stateForPlacement:[self placementForViewController:_primary]];
     UIArrangementViewState *secondaryState =
-        [self stateForPlacement:UIArrangementViewControllerViewPlacementSecondary];
+        [self stateForPlacement:[self placementForViewController:_secondary]];
     CGRect primaryFrame = ANNShownFrame(_primary.viewIfLoaded, self.view);
     CGRect secondaryFrame = ANNShownFrame(_secondary.viewIfLoaded, self.view);
     BOOL primaryShown = ANNIsShown(_primary, primaryState, primaryFrame);
@@ -498,7 +669,8 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
         CGRect overlap = CGRectIntersection(primaryFrame, secondaryFrame);
         if (!CGRectIsNull(overlap) && overlap.size.width > 1 && overlap.size.height > 1) {
             layout = @"overlay";
-            // UIKit puts the primary over the secondary (zIndex 1 and 0).
+            // UIKit puts the primary over the secondary (zIndex 1 and 0); an overlay keeps the screens in their own
+            // placements.
             primaryFront = primaryState.zIndex >= secondaryState.zIndex;
             secondaryFront = !primaryFront;
         } else {

package/ios/Layouts/Screen/ANNScreenSettling.h

@@ -18,7 +18,9 @@ extern NSNotificationName const ANNScreenSettlingDidEndNotification;
 + (void)beginWithTransition:(id<UIViewControllerTransitionCoordinator>)coordinator;
 
 /// The vertical bar's edge changed: the size transition, when one follows, comes a little later. The hinge's moves
-/// begin the settling too (`ANNHingeDidMoveNotification`): UIKit may give a new safe area before either.
+/// begin the settling too (`ANNHingeDidMoveNotification`): UIKit may give a new safe area before either. Once the size
+/// transition ended the screens are on their new display: the hinge, turning on to its end, holds nothing until it
+/// rests (a new state of the hinge still does), and the settling ends after a shorter quiet time.
 + (void)beginForTraitChange;
 
 /// Whether the screens hold their insets now.

package/ios/Layouts/Screen/ANNScreenSettling.mm

@@ -8,6 +8,9 @@ NSNotificationName const ANNScreenSettlingDidEndNotification = @"ANNScreenSettli
 // How long the values of the screens stand still before the settling ends. On iPhone Duo UIKit's last step of a fold
 // comes some 30 ms after the size transition's end, and the size transition some 50 ms after the bar's new edge.
 static const CFTimeInterval ANNScreenSettlingQuietTime = 0.15;
+// Once the size transition ended, UIKit's last steps come within some 30 ms: the screens are on the new display by
+// then, and every held moment shows them with the old one's insets.
+static const CFTimeInterval ANNScreenSettlingQuietTimeAfterTransition = 0.05;
 // The settling holds the insets no longer than this after its last start, whatever keeps changing.
 static const CFTimeInterval ANNScreenSettlingLongest = 1.0;
 // The degrees the hinge turns before it counts as a move: a device held half open trembles a little.
@@ -16,6 +19,11 @@ static const double ANNScreenSettlingHingeStep = 2;
 static BOOL ANNSettling;
 // The size transitions that began and haven't ended: each screen counts its own call of the same transition.
 static NSInteger ANNSettlingTransitions;
+// A size transition of this settling ended: the hinge, still turning, no longer holds the insets.
+static BOOL ANNSettlingTransitionEnded;
+// Until when the hinge's turns after a size transition count for nothing: the hinge goes on turning to its end once
+// the display switched, and holds nothing until it rests a while.
+static CFTimeInterval ANNSettlingHingeIgnoredUntil;
 static CFTimeInterval ANNSettlingStart;
 static CFTimeInterval ANNSettlingLastChange;
 // Only the check scheduled last runs.
@@ -51,13 +59,22 @@ static NSNumber *ANNSettlingHingeAngle;
         return;
     }
     double turned = fabs(angle.doubleValue - ANNSettlingHingeAngle.doubleValue);
-    BOOL moved = ![state isEqual:ANNSettlingHingeState] || !angle || !ANNSettlingHingeAngle ||
-                 turned >= ANNScreenSettlingHingeStep;
+    BOOL newState = ![state isEqual:ANNSettlingHingeState];
+    BOOL moved =
+        newState || !angle || !ANNSettlingHingeAngle || turned >= ANNScreenSettlingHingeStep;
     if (!moved) {
         return;
     }
     ANNSettlingHingeState = state;
     ANNSettlingHingeAngle = angle;
+    // A new state may bring a new layout; a turn after a size transition only goes on to the hinge's end.
+    CFTimeInterval now = CACurrentMediaTime();
+    BOOL afterTransition = (ANNSettling && ANNSettlingTransitionEnded) ||
+                           now < ANNSettlingHingeIgnoredUntil;
+    if (!newState && afterTransition) {
+        ANNSettlingHingeIgnoredUntil = now + ANNScreenSettlingQuietTime;
+        return;
+    }
     [self beginForTraitChange];
 }
 
@@ -66,6 +83,7 @@ static NSNumber *ANNSettlingHingeAngle;
         return;
     }
     [self begin];
+    ANNSettlingTransitionEnded = NO;
     ANNSettlingTransitions += 1;
     NSUInteger epoch = ANNSettlingEpoch;
     void (^ended)(id<UIViewControllerTransitionCoordinatorContext>) =
@@ -74,8 +92,12 @@ static NSNumber *ANNSettlingHingeAngle;
               return;
           }
           ANNSettlingTransitions = MAX(0, ANNSettlingTransitions - 1);
+          if (ANNSettlingTransitions == 0) {
+              ANNSettlingTransitionEnded = YES;
+              ANNSettlingHingeIgnoredUntil = CACurrentMediaTime() + ANNScreenSettlingQuietTime;
+          }
           [ANNScreenSettling valuesDidChange];
-          [ANNScreenSettling checkAfter:ANNScreenSettlingQuietTime];
+          [ANNScreenSettling checkAfter:[ANNScreenSettling quietTime]];
         };
     [coordinator animateAlongsideTransition:nil completion:ended];
     // The longest still holds should the transition's end never come.
@@ -84,10 +106,21 @@ static NSNumber *ANNSettlingHingeAngle;
 
 // Only iPhone Duo has a vertical bar: no need to ask for the hinge.
 + (void)beginForTraitChange {
+    // After the transition the bar's new edge is one of its last steps: it holds the values a little longer only.
+    if (ANNSettling && ANNSettlingTransitionEnded) {
+        [self valuesDidChange];
+        [self checkAfter:[self quietTime]];
+        return;
+    }
     [self begin];
     [self checkAfter:ANNScreenSettlingQuietTime];
 }
 
++ (CFTimeInterval)quietTime {
+    return ANNSettlingTransitionEnded ? ANNScreenSettlingQuietTimeAfterTransition
+                                      : ANNScreenSettlingQuietTime;
+}
+
 + (void)begin {
     CFTimeInterval now = CACurrentMediaTime();
     ANNSettling = YES;
@@ -121,10 +154,11 @@ static NSNumber *ANNSettlingHingeAngle;
     }
     CFTimeInterval now = CACurrentMediaTime();
     CFTimeInterval longest = ANNSettlingStart + ANNScreenSettlingLongest;
-    CFTimeInterval quiet = ANNSettlingLastChange + ANNScreenSettlingQuietTime;
+    CFTimeInterval quiet = ANNSettlingLastChange + [self quietTime];
     if (now >= longest || (ANNSettlingTransitions == 0 && now >= quiet)) {
         ANNSettling = NO;
         ANNSettlingTransitions = 0;
+        ANNSettlingTransitionEnded = NO;
         ANNSettlingEpoch += 1;
         [NSNotificationCenter.defaultCenter postNotificationName:ANNScreenSettlingDidEndNotification
                                                           object:nil];

package/lib/module/api/screens/arrangement.js

@@ -44,14 +44,17 @@ export function isArrangement(value) {
 export function toEngineArrangement(primary, arrangement) {
   const full = arrangement;
   checkFraction(full.fraction);
+  const style = arrangement.style ?? 'split';
   return {
     primary,
     secondary: arrangement.secondary,
     secondaryProps: arrangement.secondaryProps,
-    style: arrangement.style ?? 'split',
+    style,
     axes: full.axes ?? 'both',
     fraction: full.fraction ?? 0.5,
-    primaryEdge: full.primaryEdge ?? 'trailing',
+    // Where UIKit puts the primary of each style without an edge set: first in a split, at the trailing side of an
+    // overlay that goes side by side.
+    primaryEdge: full.primaryEdge ?? (style === 'split' ? 'leading' : 'trailing'),
     compact: full.compact ?? 'primary'
   };
 }

package/lib/module/api/screens/arrangement.js.map

@@ -1 +1 @@
-{"version":3,"names":["ARRANGEMENT","Symbol","defineArrangement","definition","checkFraction","fraction","isArrangement","value","toEngineArrangement","primary","arrangement","full","secondary","secondaryProps","style","axes","primaryEdge","compact","undefined","Error"],"sourceRoot":"../../../../src","sources":["api/screens/arrangement.ts"],"mappings":";;AAEA,MAAMA,WAAW,GAAGC,MAAM,CAAC,mCAAmC,CAAC;;AAE/D;AACA;AACA;AACA;AACA;;AAkBA;;AAkBA;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,UAAwC,EACpB;EACpBC,aAAa,CAACD,UAAU,CAACE,QAAQ,CAAC;EAClC,OAAO;IAAE,CAACL,WAAW,GAAG,IAAI;IAAEG;EAAW,CAAC;AAC5C;AAEA,OAAO,SAASG,aAAaA,CAACC,KAAc,EAA6B;EACvE,OAAO,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAIP,WAAW,IAAIO,KAAK;AAC5E;;AAEA;AACA,OAAO,SAASC,mBAAmBA,CACjCC,OAAe,EACfC,WAAgE,EAC7C;EACnB,MAAMC,IAAI,GAAGD,WAAyC;EACtDN,aAAa,CAACO,IAAI,CAACN,QAAQ,CAAC;EAC5B,OAAO;IACLI,OAAO;IACPG,SAAS,EAAEF,WAAW,CAACE,SAAS;IAChCC,cAAc,EAAEH,WAAW,CAACG,cAAc;IAC1CC,KAAK,EAAEJ,WAAW,CAACI,KAAK,IAAI,OAAO;IACnCC,IAAI,EAAEJ,IAAI,CAACI,IAAI,IAAI,MAAM;IACzBV,QAAQ,EAAEM,IAAI,CAACN,QAAQ,IAAI,GAAG;IAC9BW,WAAW,EAAEL,IAAI,CAACK,WAAW,IAAI,UAAU;IAC3CC,OAAO,EAAEN,IAAI,CAACM,OAAO,IAAI;EAC3B,CAAC;AACH;AAEA,SAASb,aAAaA,CAACC,QAA4B,EAAE;EACnD,IAAIA,QAAQ,KAAKa,SAAS,IAAI,EAAEb,QAAQ,GAAG,CAAC,IAAIA,QAAQ,GAAG,CAAC,CAAC,EAAE;IAC7D,MAAM,IAAIc,KAAK,CACb,yCAAyCd,QAAQ,+BACnD,CAAC;EACH;AACF","ignoreList":[]}
+{"version":3,"names":["ARRANGEMENT","Symbol","defineArrangement","definition","checkFraction","fraction","isArrangement","value","toEngineArrangement","primary","arrangement","full","style","secondary","secondaryProps","axes","primaryEdge","compact","undefined","Error"],"sourceRoot":"../../../../src","sources":["api/screens/arrangement.ts"],"mappings":";;AAEA,MAAMA,WAAW,GAAGC,MAAM,CAAC,mCAAmC,CAAC;;AAE/D;AACA;AACA;AACA;AACA;;AAkBA;;AA4BA;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,UAAwC,EACpB;EACpBC,aAAa,CAACD,UAAU,CAACE,QAAQ,CAAC;EAClC,OAAO;IAAE,CAACL,WAAW,GAAG,IAAI;IAAEG;EAAW,CAAC;AAC5C;AAEA,OAAO,SAASG,aAAaA,CAACC,KAAc,EAA6B;EACvE,OAAO,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAIP,WAAW,IAAIO,KAAK;AAC5E;;AAEA;AACA,OAAO,SAASC,mBAAmBA,CACjCC,OAAe,EACfC,WAAgE,EAC7C;EACnB,MAAMC,IAAI,GAAGD,WAAyC;EACtDN,aAAa,CAACO,IAAI,CAACN,QAAQ,CAAC;EAC5B,MAAMO,KAAK,GAAGF,WAAW,CAACE,KAAK,IAAI,OAAO;EAC1C,OAAO;IACLH,OAAO;IACPI,SAAS,EAAEH,WAAW,CAACG,SAAS;IAChCC,cAAc,EAAEJ,WAAW,CAACI,cAAc;IAC1CF,KAAK;IACLG,IAAI,EAAEJ,IAAI,CAACI,IAAI,IAAI,MAAM;IACzBV,QAAQ,EAAEM,IAAI,CAACN,QAAQ,IAAI,GAAG;IAC9B;IACA;IACAW,WAAW,EAAEL,IAAI,CAACK,WAAW,KAAKJ,KAAK,KAAK,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;IAC7EK,OAAO,EAAEN,IAAI,CAACM,OAAO,IAAI;EAC3B,CAAC;AACH;AAEA,SAASb,aAAaA,CAACC,QAA4B,EAAE;EACnD,IAAIA,QAAQ,KAAKa,SAAS,IAAI,EAAEb,QAAQ,GAAG,CAAC,IAAIA,QAAQ,GAAG,CAAC,CAAC,EAAE;IAC7D,MAAM,IAAIc,KAAK,CACb,yCAAyCd,QAAQ,+BACnD,CAAC;EACH;AACF","ignoreList":[]}

package/lib/typescript/api/screens/arrangement.d.ts

@@ -23,13 +23,23 @@ export interface ScreenArrangement<Props extends object = {}> {
 }
 /** A pair under a name of its own, with every setting: `defineArrangement`. */
 export interface ArrangementDefinition<Props extends object = {}> extends ScreenArrangement<Props> {
-    /** The screen that owns the bar: its title, buttons, toolbar and status bar are the pair's. A name of `screens`. */
+    /**
+     * The screen that owns the bar: its title, buttons, toolbar and status bar are the pair's. It shows alone outside a
+     * large window (`compact: 'primary'`), and `primaryEdge` puts it on either side. A name of `screens`.
+     */
     primary: string;
     /** The axes the pair may use. Where the window allows none of them, only the primary shows. @default 'both' */
     axes?: 'horizontal' | 'vertical' | 'both';
     /** `split`: the primary's share along the split, above 0 and below 1, where the fold does not decide. @default 0.5 */
     fraction?: number;
-    /** `overlay`: the edge the primary takes when the pair goes side by side. @default 'trailing' */
+    /**
+     * The edge the primary takes. `split`: `leading` or `top` puts the primary first, at the leading side or on top;
+     * `trailing` or `bottom` puts it second, at the trailing side or at the bottom (one setting for both ways the pair
+     * may lie). `overlay`: the primary's edge when the pair goes side by side; an edge of the other axis counts as the
+     * nearest one (`top` as leading, `bottom` as trailing). Whatever the edge, the primary is the screen that shows
+     * alone outside a large window with `compact: 'primary'`: to show the other screen there, make it the primary.
+     * @default 'leading' for split, 'trailing' for overlay
+     */
     primaryEdge?: 'leading' | 'trailing' | 'top' | 'bottom';
     /**
      * Outside a large window: `primary` — the primary alone, as a plain screen; `pair` — the pair as the system lays it

package/lib/typescript/api/screens/arrangement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrangement.d.ts","sourceRoot":"","sources":["../../../../src/api/screens/arrangement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAsB,CAAC;AAE9D,QAAA,MAAM,WAAW,eAA8C,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE;IAC1D;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC;IAC1C;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B;AAED,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE,CAAE,SAAQ,iBAAiB,CAAC,KAAK,CAAC;IAChG,oHAAoH;IACpH,OAAO,EAAE,MAAM,CAAC;IAChB,+GAA+G;IAC/G,IAAI,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG,MAAM,CAAC;IAC1C,sHAAsH;IACtH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC;IACxD;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC9B;AAED,yDAAyD;AACzD,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE;IACpD,QAAQ,CAAC,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,gDAAgD;IAChD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE,EACzD,UAAU,EAAE,qBAAqB,CAAC,KAAK,CAAC,GACvC,WAAW,CAAC,KAAK,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,GAAG,CAAC,CAEvE;AAED,0GAA0G;AAC1G,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,iBAAiB,CAAC,GAAG,CAAC,GAAG,qBAAqB,CAAC,GAAG,CAAC,GAC/D,iBAAiB,CAanB"}
+{"version":3,"file":"arrangement.d.ts","sourceRoot":"","sources":["../../../../src/api/screens/arrangement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAsB,CAAC;AAE9D,QAAA,MAAM,WAAW,eAA8C,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE;IAC1D;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC;IAC1C;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B;AAED,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE,CAAE,SAAQ,iBAAiB,CAAC,KAAK,CAAC;IAChG;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,+GAA+G;IAC/G,IAAI,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG,MAAM,CAAC;IAC1C,sHAAsH;IACtH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC;IACxD;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC9B;AAED,yDAAyD;AACzD,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE;IACpD,QAAQ,CAAC,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,gDAAgD;IAChD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,MAAM,GAAG,EAAE,EACzD,UAAU,EAAE,qBAAqB,CAAC,KAAK,CAAC,GACvC,WAAW,CAAC,KAAK,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,GAAG,CAAC,CAEvE;AAED,0GAA0G;AAC1G,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,iBAAiB,CAAC,GAAG,CAAC,GAAG,qBAAqB,CAAC,GAAG,CAAC,GAC/D,iBAAiB,CAgBnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apexnative/navigation",
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.11",
   "description": "Native navigation for React Native: platform stacks, tabs, modals and side menus on iOS, iPadOS and Android",
   "keywords": [
     "react-native",

package/src/api/screens/arrangement.ts

@@ -26,13 +26,23 @@ export interface ScreenArrangement<Props extends object = {}> {
 
 /** A pair under a name of its own, with every setting: `defineArrangement`. */
 export interface ArrangementDefinition<Props extends object = {}> extends ScreenArrangement<Props> {
-  /** The screen that owns the bar: its title, buttons, toolbar and status bar are the pair's. A name of `screens`. */
+  /**
+   * The screen that owns the bar: its title, buttons, toolbar and status bar are the pair's. It shows alone outside a
+   * large window (`compact: 'primary'`), and `primaryEdge` puts it on either side. A name of `screens`.
+   */
   primary: string;
   /** The axes the pair may use. Where the window allows none of them, only the primary shows. @default 'both' */
   axes?: 'horizontal' | 'vertical' | 'both';
   /** `split`: the primary's share along the split, above 0 and below 1, where the fold does not decide. @default 0.5 */
   fraction?: number;
-  /** `overlay`: the edge the primary takes when the pair goes side by side. @default 'trailing' */
+  /**
+   * The edge the primary takes. `split`: `leading` or `top` puts the primary first, at the leading side or on top;
+   * `trailing` or `bottom` puts it second, at the trailing side or at the bottom (one setting for both ways the pair
+   * may lie). `overlay`: the primary's edge when the pair goes side by side; an edge of the other axis counts as the
+   * nearest one (`top` as leading, `bottom` as trailing). Whatever the edge, the primary is the screen that shows
+   * alone outside a large window with `compact: 'primary'`: to show the other screen there, make it the primary.
+   * @default 'leading' for split, 'trailing' for overlay
+   */
   primaryEdge?: 'leading' | 'trailing' | 'top' | 'bottom';
   /**
    * Outside a large window: `primary` — the primary alone, as a plain screen; `pair` — the pair as the system lays it
@@ -85,14 +95,17 @@ export function toEngineArrangement(
 ): EngineArrangement {
   const full = arrangement as ArrangementDefinition<any>;
   checkFraction(full.fraction);
+  const style = arrangement.style ?? 'split';
   return {
     primary,
     secondary: arrangement.secondary,
     secondaryProps: arrangement.secondaryProps,
-    style: arrangement.style ?? 'split',
+    style,
     axes: full.axes ?? 'both',
     fraction: full.fraction ?? 0.5,
-    primaryEdge: full.primaryEdge ?? 'trailing',
+    // Where UIKit puts the primary of each style without an edge set: first in a split, at the trailing side of an
+    // overlay that goes side by side.
+    primaryEdge: full.primaryEdge ?? (style === 'split' ? 'leading' : 'trailing'),
     compact: full.compact ?? 'primary',
   };
 }