@craft-native/ios 0.0.247 → 0.0.249

package/templates/CraftNativeScreen.swift

@@ -59,6 +59,19 @@ private func craftNativeGridColumnCount(_ value: Any?) -> Int {
     return max(1, tracks.count)
 }
 
+private func craftNativeGridRowCount(_ value: Any?) -> Int? {
+    if let number = craftNativeNumber(value) { return max(1, number.intValue) }
+    guard let text = value as? String else { return nil }
+    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !trimmed.isEmpty else { return nil }
+    if trimmed.hasPrefix("repeat(") {
+        let digits = trimmed.dropFirst("repeat(".count).prefix { $0.isNumber }
+        if let count = Int(digits) { return max(1, count) }
+    }
+    let tracks = trimmed.split(whereSeparator: { $0 == " " || $0 == "\t" || $0 == "\n" })
+    return tracks.isEmpty ? nil : max(1, tracks.count)
+}
+
 /// Optional bridge to the shared Zig flex rule. Native hosts retain their
 /// local implementation when no Craft runtime is linked (the normal SDK
 /// fallback), while runtime-backed apps get one cross-platform calculation.
@@ -240,12 +253,56 @@ private enum CraftNativeTreeLayoutBridge {
         var gridAutoRows: Float = .nan
     }
 
+    private struct StyleInputV5 {
+        var direction: UInt32 = 0
+        var width: Float = .nan
+        var height: Float = .nan
+        var intrinsicWidth: Float = .nan
+        var intrinsicHeight: Float = .nan
+        var baseline: Float = .nan
+        var aspectRatio: Float = .nan
+        var flexBasis: Float = .nan
+        var flexGrow: Float = 0
+        var flexShrink: Float = 0
+        var minWidth: Float = .nan
+        var maxWidth: Float = .nan
+        var minHeight: Float = .nan
+        var maxHeight: Float = .nan
+        var gap: Float = 0
+        var justifyContent: UInt32 = 0
+        var alignItems: UInt32 = 3
+        var alignSelf: UInt32 = 0
+        var flexWrap: UInt32 = 0
+        var alignContent: UInt32 = 5
+        var marginTop: Float = 0
+        var marginRight: Float = 0
+        var marginBottom: Float = 0
+        var marginLeft: Float = 0
+        var paddingTop: Float = 0
+        var paddingRight: Float = 0
+        var paddingBottom: Float = 0
+        var paddingLeft: Float = 0
+        var grid: UInt32 = 0
+        var gridColumns: UInt32 = 1
+        var rowGap: Float = 0
+        var columnGap: Float = 0
+        var reverse: UInt32 = 0
+        var gridAutoRows: Float = .nan
+        var gridRows: UInt32 = 0
+    }
+
     private struct NodeInputV4 {
         var style: StyleInputV4
         var firstChild: UInt32
         var childCount: UInt32
     }
 
+    private struct NodeInputV5 {
+        var style: StyleInputV5
+        var firstChild: UInt32
+        var childCount: UInt32
+    }
+
     fileprivate struct Frame {
         var x: Float
         var y: Float
@@ -269,6 +326,7 @@ private enum CraftNativeTreeLayoutBridge {
         let padding: UIEdgeInsets
         let grid: Bool
         let gridColumns: Int
+        let gridRows: Int?
         let gridAutoRows: CraftNativeLength?
         let reverse: Bool
         let wrapReverse: Bool
@@ -309,6 +367,11 @@ private enum CraftNativeTreeLayoutBridge {
         return unsafeBitCast(symbol, to: FunctionV2.self)
     }()
 
+    private static let functionV5: FunctionV2? = {
+        guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_layout_tree_v5") else { return nil }
+        return unsafeBitCast(symbol, to: FunctionV2.self)
+    }()
+
     private static func finite(_ value: CGFloat?) -> Float {
         guard let value, value.isFinite else { return .nan }
         return Float(value)
@@ -421,6 +484,9 @@ private enum CraftNativeTreeLayoutBridge {
 
     fileprivate static func treeFrames(root: TreeNode, width: CGFloat, height: CGFloat) -> TreeResult? {
         guard let function, width.isFinite, height.isFinite, width >= 0, height >= 0, !root.children.isEmpty else { return nil }
+        if containsGridRows(root) {
+            return treeFramesV5(root: root, width: width, height: height, function: functionV5)
+        }
         if containsGridAutoRows(root) {
             return treeFramesV4(root: root, width: width, height: height, function: functionV4)
         }
@@ -529,6 +595,10 @@ private enum CraftNativeTreeLayoutBridge {
         node.gridAutoRows != nil || node.children.contains(where: containsGridAutoRows)
     }
 
+    private static func containsGridRows(_ node: TreeNode) -> Bool {
+        node.gridRows != nil || node.children.contains(where: containsGridRows)
+    }
+
     private static func treeFramesV2(root: TreeNode, width: CGFloat, height: CGFloat, function: FunctionV2?) -> TreeResult? {
         guard let function, width.isFinite, height.isFinite, width >= 0, height >= 0, !root.children.isEmpty else { return nil }
         var nodes: [TreeNode] = []
@@ -712,6 +782,100 @@ private enum CraftNativeTreeLayoutBridge {
         }) else { return nil }
         return TreeResult(nodes: nodes, parents: parents, frames: output)
     }
+
+    /// v5 appends the explicit grid-template-rows count to v4's payload.
+    /// Older runtimes continue through v4 when no explicit rows are present.
+    private static func treeFramesV5(root: TreeNode, width: CGFloat, height: CGFloat, function: FunctionV2?) -> TreeResult? {
+        guard let function, width.isFinite, height.isFinite, width >= 0, height >= 0, !root.children.isEmpty else { return nil }
+        var nodes: [TreeNode] = []
+        var parents: [Int] = []
+        func append(_ node: TreeNode, parent: Int) {
+            let index = nodes.count
+            nodes.append(node)
+            parents.append(parent)
+            node.children.forEach { append($0, parent: index) }
+        }
+        append(root, parent: -1)
+
+        func put(_ input: inout StyleInputV5, _ node: TreeNode, parentWidth: CGFloat, parentHeight: CGFloat, rootNode: Bool, parentDirection: NSLayoutConstraint.Axis) {
+            let contentWidth = max(0, (rootNode ? width : node.intrinsic.width) - node.padding.left - node.padding.right)
+            let contentHeight = max(0, (rootNode ? height : node.intrinsic.height) - node.padding.top - node.padding.bottom)
+            let mainSize = node.direction == .horizontal ? contentWidth : contentHeight
+            input.direction = node.direction == .horizontal ? 0 : 1
+            input.width = rootNode ? Float(width) : length(node.style.width, base: parentWidth)
+            input.height = rootNode ? Float(height) : length(node.style.height, base: parentHeight)
+            input.intrinsicWidth = rootNode ? .nan : Float(max(0, node.intrinsic.width))
+            input.intrinsicHeight = rootNode ? .nan : Float(max(0, node.intrinsic.height))
+            input.baseline = rootNode ? .nan : Float(max(0, node.baseline))
+            input.aspectRatio = finite(node.style.aspectRatio)
+            input.flexBasis = length(node.style.flexBasis, base: mainSize)
+            input.flexGrow = rootNode ? 0 : Float(max(0, node.style.flexGrow))
+            let defaultShrink: CGFloat = node.view is UIScrollView || (node.view is UILabel && parentDirection == .horizontal) ? 1 : 0
+            input.flexShrink = rootNode ? 0 : Float(max(0, node.style.flexShrink ?? defaultShrink))
+            input.minWidth = length(node.style.minWidth, base: contentWidth)
+            input.maxWidth = length(node.style.maxWidth, base: contentWidth)
+            input.minHeight = length(node.style.minHeight, base: contentHeight)
+            input.maxHeight = length(node.style.maxHeight, base: contentHeight)
+            input.gap = Float(max(0, node.gap))
+            input.justifyContent = justify(node.justifyContent)
+            input.alignItems = alignment(node.alignItems)
+            input.alignSelf = rootNode ? 0 : alignSelf(node.style.alignSelf)
+            input.flexWrap = node.wrap ? 1 : 0
+            input.alignContent = craftNativeAlignContentCode(node.alignContent)
+            input.marginTop = Float(max(0, node.style.marginTop))
+            input.marginRight = Float(max(0, node.style.marginRight))
+            input.marginBottom = Float(max(0, node.style.marginBottom))
+            input.marginLeft = Float(max(0, node.style.marginLeft))
+            input.paddingTop = Float(max(0, node.padding.top))
+            input.paddingRight = Float(max(0, node.padding.right))
+            input.paddingBottom = Float(max(0, node.padding.bottom))
+            input.paddingLeft = Float(max(0, node.padding.left))
+            input.grid = node.grid ? 1 : 0
+            input.gridColumns = UInt32(max(1, node.gridColumns))
+            input.rowGap = Float(max(0, node.rowGap))
+            input.columnGap = Float(max(0, node.columnGap))
+            input.reverse = (node.reverse ? 1 : 0) | (node.wrapReverse ? 2 : 0)
+            input.gridAutoRows = node.gridAutoRows.map { length($0, base: contentHeight) } ?? .nan
+            input.gridRows = UInt32(max(0, node.gridRows ?? 0))
+        }
+
+        var styles = [StyleInputV5](repeating: StyleInputV5(), count: nodes.count)
+        var metadata = [Float](repeating: 0, count: nodes.count * 2)
+        var cursor = 0
+        func write(_ node: TreeNode, parentWidth: CGFloat, parentHeight: CGFloat, rootNode: Bool, parentDirection: NSLayoutConstraint.Axis) {
+            let index = cursor
+            cursor += 1
+            put(&styles[index], node, parentWidth: parentWidth, parentHeight: parentHeight, rootNode: rootNode, parentDirection: parentDirection)
+            let contentWidth = max(0, (rootNode ? width : node.intrinsic.width) - node.padding.left - node.padding.right)
+            let contentHeight = max(0, (rootNode ? height : node.intrinsic.height) - node.padding.top - node.padding.bottom)
+            let firstChild = cursor
+            node.children.forEach { write($0, parentWidth: contentWidth, parentHeight: contentHeight, rootNode: false, parentDirection: node.direction) }
+            metadata[index * 2] = Float(firstChild)
+            metadata[index * 2 + 1] = Float(cursor - firstChild)
+        }
+        write(root, parentWidth: width, parentHeight: height, rootNode: true, parentDirection: root.direction)
+        let inputs = zip(styles, stride(from: 0, to: metadata.count, by: 2)).map { style, offset in
+            NodeInputV5(style: style, firstChild: UInt32(metadata[offset]), childCount: UInt32(metadata[offset + 1]))
+        }
+
+        var output = [Frame](repeating: Frame(x: 0, y: 0, width: 0, height: 0), count: nodes.count)
+        let frameCount = output.count
+        let status = inputs.withUnsafeBufferPointer { inputBuffer in
+            metadata.withUnsafeBufferPointer { metadataBuffer in
+                output.withUnsafeMutableBufferPointer { outputBuffer in
+                    function(
+                        Float(width), Float(height), UnsafeRawPointer(inputBuffer.baseAddress!), inputs.count,
+                        UnsafeMutableRawPointer(outputBuffer.baseAddress!), frameCount
+                    )
+                }
+            }
+        }
+        guard status == 0, output.allSatisfy({ frame in
+            frame.x.isFinite && frame.y.isFinite && frame.width.isFinite && frame.height.isFinite &&
+                frame.width >= 0 && frame.height >= 0
+        }) else { return nil }
+        return TreeResult(nodes: nodes, parents: parents, frames: output)
+    }
 }
 
 private enum CraftNativeFlexLineBridge {
@@ -1140,10 +1304,13 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
     func stop() {
         detachPlayer()
         playerController.player = nil
+        playerController.delegate = nil
         sourceURI = ""
         playIntent = nil
         userPaused = false
         ended = false
+        handlers.removeAll()
+        emit = nil
         if playerController.parent != nil {
             playerController.willMove(toParent: nil)
             playerController.view.removeFromSuperview()
@@ -1160,6 +1327,11 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var overlayCoordinatesByID: [String: [CLLocationCoordinate2D]] = [:]
     private var overlayColors: [ObjectIdentifier: UIColor] = [:]
     private var overlayWidths: [ObjectIdentifier: CGFloat] = [:]
+    private var polygonsByID: [String: MKPolygon] = [:]
+    private var polygonCoordinatesByID: [String: [CLLocationCoordinate2D]] = [:]
+    private var polygonFills: [ObjectIdentifier: UIColor] = [:]
+    private var polygonStrokes: [ObjectIdentifier: UIColor] = [:]
+    private var polygonWidths: [ObjectIdentifier: CGFloat] = [:]
     private var initialCameraKey: String?
     private var pendingFitKey: String?
     private var pendingRegion: MKCoordinateRegion?
@@ -1193,6 +1365,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     override init(frame: CGRect) {
         super.init(frame: frame)
         delegate = self
+        refreshThemeDefaults()
         showsCompass = false
         showsScale = false
         isRotateEnabled = false
@@ -1204,9 +1377,29 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     required init?(coder: NSCoder) {
         super.init(coder: coder)
         delegate = self
+        refreshThemeDefaults()
+    }
+
+    func refreshThemeDefaults() {
+        tileAttribution.textColor = .secondaryLabel
+        tileAttribution.backgroundColor = UIColor.secondarySystemBackground.withAlphaComponent(0.85)
+        // Marker images are rasterized from the resolved trait color. Refresh
+        // mounted annotations as well as the utility chrome so a retained map
+        // does not keep light-trait artwork after a dark-mode switch.
+        Self.markerImages.removeAllObjects()
+        for (id, annotation) in annotationsByID {
+            if let view = view(for: annotation) { configureMarkerView(view, id: id) }
+        }
+    }
+
+    override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
+        super.traitCollectionDidChange(previousTraitCollection)
+        guard previousTraitCollection?.userInterfaceStyle != traitCollection.userInterfaceStyle else { return }
+        refreshThemeDefaults()
     }
 
     func configure(props: [String: Any], children: [Any], markerHandler: @escaping (String) -> Void) {
+        delegate = self
         onMarkerTap = markerHandler
         isScrollEnabled = props["scrollEnabled"] as? Bool ?? true
         isZoomEnabled = props["zoomEnabled"] as? Bool ?? true
@@ -1235,6 +1428,31 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         var nextHandlers: [String: String] = [:]
         var nextPolylines: [String: (coordinates: [CLLocationCoordinate2D], color: UIColor, width: CGFloat)] = [:]
         var nextPolylineIDs: [String] = []
+        var nextPolygons: [String: (coordinates: [CLLocationCoordinate2D], fill: UIColor, stroke: UIColor, width: CGFloat)] = [:]
+        if let polylines = props["polylines"] as? [[String: Any]] {
+            for overlay in polylines {
+                let points = Self.coordinates(overlay["geometry"])
+                guard let id = (overlay["id"] as? CustomStringConvertible)?.description,
+                      points.count > 1 else { continue }
+                let authoredWidth = Self.numeric(overlay["strokeWidth"]) ?? 3
+                let width = CGFloat(authoredWidth)
+                guard authoredWidth.isFinite, width.isFinite, width > 0 else { continue }
+                nextPolylineIDs.append(id)
+                nextPolylines[id] = (points, Self.color(overlay["strokeColor"] as? String), width)
+            }
+        }
+        if let markers = props["markers"] as? [[String: Any]] {
+            for overlay in markers {
+                let points = Self.coordinates(overlay["geometry"])
+                guard let id = (overlay["id"] as? CustomStringConvertible)?.description,
+                      let point = points.first else { continue }
+                nextMarkers[id] = (point, overlay["title"] as? String)
+                if let color = overlay["pinColor"] as? String { nextPinColors[id] = Self.color(color) }
+                if let bearing = Self.numeric(overlay["bearing"]), bearing.isFinite {
+                    nextBearings[id] = bearing.truncatingRemainder(dividingBy: 360)
+                }
+            }
+        }
         for (index, child) in children.enumerated() {
             guard let node = child as? [String: Any], let rawType = node["type"] as? String else { continue }
             let type = rawType.lowercased()
@@ -1262,6 +1480,14 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
                 guard authoredWidth.isFinite, width.isFinite, width > 0 else { continue }
                 if nextPolylines[id] == nil { nextPolylineIDs.append(id) }
                 nextPolylines[id] = (points, Self.color(childProps["strokeColor"] as? String), width)
+            } else if type == "mappolygon" || type == "polygon" {
+                guard points.count > 2 else { continue }
+                let authoredWidth = Self.numeric(childProps["strokeWidth"]) ?? 2
+                let width = CGFloat(authoredWidth)
+                guard authoredWidth.isFinite, width.isFinite, width > 0 else { continue }
+                let fill = Self.color(childProps["fillColor"] as? String).withAlphaComponent(0.28)
+                let stroke = Self.color(childProps["strokeColor"] as? String)
+                nextPolygons[id] = (points, fill, stroke, width)
             }
         }
 
@@ -1314,6 +1540,39 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             overlayWidths[ObjectIdentifier(overlay)] = value.width
             addOverlay(overlay)
         }
+        let stalePolygons = polygonsByID.keys.filter { nextPolygons[$0] == nil }
+        for id in stalePolygons {
+            if let polygon = polygonsByID.removeValue(forKey: id) {
+                removeOverlay(polygon)
+                polygonFills.removeValue(forKey: ObjectIdentifier(polygon))
+                polygonStrokes.removeValue(forKey: ObjectIdentifier(polygon))
+                polygonWidths.removeValue(forKey: ObjectIdentifier(polygon))
+            }
+            polygonCoordinatesByID.removeValue(forKey: id)
+        }
+        for (id, value) in nextPolygons {
+            if let polygon = polygonsByID[id],
+               let coordinates = polygonCoordinatesByID[id],
+               Self.coordinatesEqual(coordinates, value.coordinates),
+               polygonFills[ObjectIdentifier(polygon)]?.isEqual(value.fill) == true,
+               polygonStrokes[ObjectIdentifier(polygon)]?.isEqual(value.stroke) == true,
+               polygonWidths[ObjectIdentifier(polygon)] == value.width {
+                continue
+            }
+            if let previous = polygonsByID.removeValue(forKey: id) {
+                removeOverlay(previous)
+                polygonFills.removeValue(forKey: ObjectIdentifier(previous))
+                polygonStrokes.removeValue(forKey: ObjectIdentifier(previous))
+                polygonWidths.removeValue(forKey: ObjectIdentifier(previous))
+            }
+            let polygon = MKPolygon(coordinates: value.coordinates, count: value.coordinates.count)
+            polygonsByID[id] = polygon
+            polygonCoordinatesByID[id] = value.coordinates
+            polygonFills[ObjectIdentifier(polygon)] = value.fill
+            polygonStrokes[ObjectIdentifier(polygon)] = value.stroke
+            polygonWidths[ObjectIdentifier(polygon)] = value.width
+            addOverlay(polygon)
+        }
         // Keep authored casing/foreground order when an earlier line changes
         // or retained children move. Exchanging native overlays preserves the
         // unchanged objects, tile levels and current camera.
@@ -1349,7 +1608,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
                 initialCameraKey = key
             }
         } else if props["fitToBounds"] as? Bool == true {
-            let key = "fit:\(Self.overlayKey(markers: nextMarkers.mapValues { $0.coordinate }, polylines: nextPolylines.mapValues { $0.coordinates })):\(edgePadding)"
+            let key = "fit:\(Self.overlayKey(markers: nextMarkers.mapValues { $0.coordinate }, polylines: nextPolylines.mapValues { $0.coordinates }, polygons: nextPolygons.mapValues { $0.coordinates })):\(edgePadding)"
             if initialCameraKey != key {
                 // A native screen can reconcile before UIKit assigns the map
                 // its final safe-area-constrained bounds. Keep the fit
@@ -1368,6 +1627,39 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         applyCameraOrientation()
     }
 
+    /// Release callbacks and native overlays before a map leaves a screen or
+    /// is recycled for another row. `configure` restores the delegate when
+    /// the view is adopted again.
+    func destroy() {
+        delegate = nil
+        onMarkerTap = nil
+        onMapPress = nil
+        onRegionChangeComplete = nil
+        markerHandlers.removeAll()
+        markerBearings.removeAll()
+        markerPinColors.removeAll()
+        removeAnnotations(Array(annotationsByID.values))
+        annotationsByID.removeAll()
+        removeOverlays(Array(overlaysByID.values))
+        overlaysByID.removeAll()
+        overlayCoordinatesByID.removeAll()
+        overlayColors.removeAll()
+        overlayWidths.removeAll()
+        removeOverlays(Array(polygonsByID.values))
+        polygonsByID.removeAll()
+        polygonCoordinatesByID.removeAll()
+        polygonFills.removeAll()
+        polygonStrokes.removeAll()
+        polygonWidths.removeAll()
+        if let tileOverlay {
+            removeOverlay(tileOverlay)
+            self.tileOverlay = nil
+        }
+        tileTemplate = nil
+        tileAttribution.text = nil
+        tileAttribution.isHidden = true
+    }
+
     private func configureTiles(_ options: [String: Any]?) {
         let template = options?["urlTemplate"] as? String
         let credit = options?["attribution"] as? String ?? ""
@@ -1503,6 +1795,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         guard bounds.width > 0, bounds.height > 0 else { return false }
         var rect = MKMapRect.null
         for overlay in overlaysByID.values { rect = rect.union(overlay.boundingMapRect) }
+        for polygon in polygonsByID.values { rect = rect.union(polygon.boundingMapRect) }
         for annotation in annotationsByID.values {
             let point = MKMapPoint(annotation.coordinate)
             rect = rect.union(MKMapRect(x: point.x, y: point.y, width: 0, height: 0))
@@ -1543,6 +1836,13 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
     func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
         if let tiles = overlay as? MKTileOverlay { return MKTileOverlayRenderer(tileOverlay: tiles) }
+        if let polygon = overlay as? MKPolygon {
+            let renderer = MKPolygonRenderer(polygon: polygon)
+            renderer.fillColor = polygonFills[ObjectIdentifier(polygon)] ?? UIColor.systemBlue.withAlphaComponent(0.28)
+            renderer.strokeColor = polygonStrokes[ObjectIdentifier(polygon)] ?? .systemBlue
+            renderer.lineWidth = polygonWidths[ObjectIdentifier(polygon)] ?? 2
+            return renderer
+        }
         let renderer = MKPolylineRenderer(overlay: overlay)
         renderer.strokeColor = overlayColors[ObjectIdentifier(overlay)] ?? .systemBlue
         renderer.lineWidth = overlayWidths[ObjectIdentifier(overlay)] ?? 3
@@ -1575,7 +1875,8 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
     private static func overlayKey(
         markers: [String: CLLocationCoordinate2D],
-        polylines: [String: [CLLocationCoordinate2D]]
+        polylines: [String: [CLLocationCoordinate2D]],
+        polygons: [String: [CLLocationCoordinate2D]]
     ) -> String {
         let markerKey = markers.keys.sorted().compactMap { id in
             guard let point = markers[id] else { return nil }
@@ -1585,7 +1886,11 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             guard let points = polylines[id] else { return nil }
             return "\(id):" + points.map { "\($0.latitude),\($0.longitude)" }.joined(separator: ";")
         }.joined(separator: "|")
-        return "m[\(markerKey)]p[\(polylineKey)]"
+        let polygonKey = polygons.keys.sorted().compactMap { id in
+            guard let points = polygons[id] else { return nil }
+            return "\(id):" + points.map { "\($0.latitude),\($0.longitude)" }.joined(separator: ";")
+        }.joined(separator: "|")
+        return "m[\(markerKey)]p[\(polylineKey)]g[\(polygonKey)]"
     }
 
     private static func region(_ value: Any?) -> MKCoordinateRegion? {
@@ -1615,6 +1920,8 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
     private static func color(_ value: String?) -> UIColor {
         switch value?.lowercased() {
+        case "label": return .label
+        case "secondarylabel", "secondary-label": return .secondaryLabel
         case "red": return .systemRed
         case "green": return .systemGreen
         case "orange": return .systemOrange
@@ -1726,6 +2033,7 @@ private struct CraftNativeLayoutStyle {
     let marginLeft: CGFloat
     let display: String
     let gridColumns: Int
+    let gridRows: Int?
     let gridAutoRows: CraftNativeLength?
 
     static let empty = CraftNativeLayoutStyle([:])
@@ -1767,6 +2075,7 @@ private struct CraftNativeLayoutStyle {
         marginLeft = number(raw["marginLeft"]) ?? horizontalMargin
         display = raw["display"] as? String ?? "flex"
         gridColumns = craftNativeGridColumnCount(raw["gridTemplateColumns"] ?? raw["gridColumns"])
+        gridRows = craftNativeGridRowCount(raw["gridTemplateRows"])
         gridAutoRows = CraftNativeLength(raw["gridAutoRows"])
     }
 }
@@ -2276,6 +2585,7 @@ private class CraftNativeFlowView: UIStackView {
     var columnGap: CGFloat? { didSet { if columnGap != oldValue { invalidateMeasurements() } } }
     var grid = false { didSet { if grid != oldValue { invalidateMeasurements() } } }
     var gridColumns = 1 { didSet { if gridColumns != oldValue { invalidateMeasurements() } } }
+    var gridRows: Int? { didSet { if gridRows != oldValue { invalidateMeasurements() } } }
     var gridAutoRows: CraftNativeLength? { didSet { if gridAutoRows != oldValue { invalidateMeasurements() } } }
     var reverse = false { didSet { if reverse != oldValue { invalidateMeasurements() } } }
     var wrapReverse = false { didSet { if wrapReverse != oldValue { invalidateMeasurements() } } }
@@ -2450,6 +2760,11 @@ private class CraftNativeFlowView: UIStackView {
 
     func removeLayoutStyle(for view: UIView) {
         view.craftLayoutStyle = .empty
+        // Detaching a retained child must invalidate the parent's cached
+        // intrinsic measurements too. The normal arranged-subview path does
+        // this after removal, but callers that clear a style before deciding
+        // whether to detach must not leave the old dimensions memoized.
+        invalidateMeasurements()
     }
 
     /// Forgets measured sizes and lays out again on the next pass.
@@ -2622,6 +2937,7 @@ private class CraftNativeFlowView: UIStackView {
                 padding: nested?.effectivePadding ?? .zero,
                 grid: nested?.grid ?? false,
                 gridColumns: nested?.gridColumns ?? 1,
+                gridRows: nested?.gridRows,
                 gridAutoRows: nested?.gridAutoRows,
                 reverse: nested?.reverse ?? false,
                 wrapReverse: nested?.wrapReverse ?? false,
@@ -2645,6 +2961,7 @@ private class CraftNativeFlowView: UIStackView {
             padding: effectivePadding,
             grid: grid,
             gridColumns: gridColumns,
+            gridRows: gridRows,
             gridAutoRows: gridAutoRows,
             reverse: reverse,
             wrapReverse: wrapReverse,
@@ -2677,6 +2994,7 @@ private class CraftNativeFlowView: UIStackView {
                 padding: nested?.effectivePadding ?? .zero,
                 grid: nested?.grid ?? false,
                 gridColumns: nested?.gridColumns ?? 1,
+                gridRows: nested?.gridRows,
                 gridAutoRows: nested?.gridAutoRows,
                 reverse: nested?.reverse ?? false,
                 wrapReverse: nested?.wrapReverse ?? false,
@@ -2700,6 +3018,7 @@ private class CraftNativeFlowView: UIStackView {
             padding: effectivePadding,
             grid: grid,
             gridColumns: gridColumns,
+            gridRows: gridRows,
             gridAutoRows: gridAutoRows,
             reverse: reverse,
             wrapReverse: wrapReverse,
@@ -3249,10 +3568,17 @@ private class CraftNativeFlowView: UIStackView {
             rowHeights[row] = max(rowHeights[row], size.height + style.marginTop + style.marginBottom)
         }
         let width = innerWidth ?? (CGFloat(columns) * cellWidth + gaps)
+        if let explicitRows = gridRows, let innerHeight {
+            let count = max(explicitRows, rowHeights.count)
+            while rowHeights.count < count { rowHeights.append(0) }
+            let available = max(0, innerHeight - CGFloat(max(0, count - 1)) * verticalGap)
+            let equal = available / CGFloat(max(1, count))
+            rowHeights = rowHeights.map { max($0, equal) }
+        }
         let height = rowHeights.reduce(0, +) + CGFloat(max(0, rowHeights.count - 1)) * verticalGap
         // Older runtimes return nil for the optional symbol; the local layout
         // below remains the compatibility path in that case.
-        let sharedFrames = CraftNativeGridBridge.frames(
+        let sharedFrames = gridRows == nil ? CraftNativeGridBridge.frames(
             availableWidth: innerWidth ?? width,
             availableHeight: innerHeight ?? height,
             columns: columns,
@@ -3280,7 +3606,7 @@ private class CraftNativeFlowView: UIStackView {
             },
             autoRowHeight: gridAutoRows.map { $0.resolve(innerHeight) ?? 0 },
             alignContent: craftNativeAlignContentCode(alignContent)
-        )
+        ) : nil
         if place {
             if let sharedFrames {
                 for (index, child) in children.enumerated() {
@@ -3457,13 +3783,14 @@ private final class CraftNativeImageBackgroundView: UIImageView {
     }
 }
 
-private final class CraftNativeModalView: UIView {
+private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
     let contentStack = CraftNativeFlowView()
     private let blocker = UIView()
+    private let backdropTap = UITapGestureRecognizer()
     private var renderedVisible = false
     private var dismissSuppressedByRequest = false
     private var animationGeneration = 0
-    var onRequestClose: (() -> Void)?
+    var onRequestClose: ((String) -> Void)?
 
     var transparent = false {
         didSet { blocker.backgroundColor = transparent ? .clear : UIColor.black.withAlphaComponent(0.32) }
@@ -3474,7 +3801,10 @@ private final class CraftNativeModalView: UIView {
         isUserInteractionEnabled = true
         blocker.isUserInteractionEnabled = true
         blocker.backgroundColor = UIColor.black.withAlphaComponent(0.32)
-        blocker.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(blockerTapped)))
+        backdropTap.addTarget(self, action: #selector(backdropTapped))
+        backdropTap.cancelsTouchesInView = false
+        backdropTap.delegate = self
+        addGestureRecognizer(backdropTap)
         addSubview(blocker)
         contentStack.backgroundColor = .clear
         addSubview(contentStack)
@@ -3551,11 +3881,11 @@ private final class CraftNativeModalView: UIView {
         onRequestClose = nil
     }
 
-    func requestClose() {
+    func requestClose(reason: String = "backdrop") {
         guard let onRequestClose else { return }
         dismissSuppressedByRequest = true
         isUserInteractionEnabled = false
-        onRequestClose()
+        onRequestClose(reason)
     }
 
     func consumeDismissSuppression() -> Bool {
@@ -3566,7 +3896,35 @@ private final class CraftNativeModalView: UIView {
 
     func clearDismissSuppression() { dismissSuppressedByRequest = false }
 
-    @objc private func blockerTapped() { requestClose() }
+    @objc private func backdropTapped() { requestClose(reason: "backdrop") }
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        guard gestureRecognizer === backdropTap else { return true }
+        var candidate = touch.view
+        while let view = candidate, view !== self {
+            if view === blocker { return true }
+            if view is UIControl || !(view.gestureRecognizers?.isEmpty ?? true) { return false }
+            candidate = view.superview
+        }
+        return true
+    }
+
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        guard !isHidden, alpha > 0.01, isUserInteractionEnabled else { return nil }
+        let contentPoint = contentStack.convert(point, from: self)
+        if contentStack.bounds.contains(contentPoint), let hit = contentStack.hitTest(contentPoint, with: event), hit !== contentStack {
+            // Flow/layout views occupy the modal's entire content rect, but a
+            // blank part of one must still be a scrim tap. Preserve touches
+            // only when the hit view (or one of its ancestors) actually owns
+            // a control or gesture recognizer.
+            var candidate: UIView? = hit
+            while let view = candidate, view !== contentStack {
+                if view is UIControl || !(view.gestureRecognizers?.isEmpty ?? true) { return hit }
+                candidate = view.superview
+            }
+        }
+        return blocker.hitTest(blocker.convert(point, from: self), with: event)
+    }
 
     override func layoutSubviews() {
         super.layoutSubviews()
@@ -3618,6 +3976,11 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
 
     override init(frame: CGRect) {
         super.init(frame: frame)
+        // Let native controls finish tracking taps before the scroll view decides
+        // whether the gesture is a drag. This matches UIKit's table-view
+        // behavior and prevents switches, sliders, and date pickers from
+        // losing most taps when they live inside a ScrollView.
+        delaysContentTouches = false
         keyboardTapGesture.cancelsTouchesInView = false
         keyboardTapGesture.delegate = self
         keyboardTapGesture.addTarget(self, action: #selector(keyboardTap))
@@ -3629,6 +3992,14 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
 
     required init?(coder: NSCoder) { nil }
 
+    override func touchesShouldCancel(in view: UIView) -> Bool {
+        // A drag beginning on a button scrolls; lifting without dragging
+        // remains a tap. Sliders, switches and text fields keep tracking.
+        if view is UIButton { return true }
+        if view is UIControl { return false }
+        return super.touchesShouldCancel(in: view)
+    }
+
     var isVertical: Bool { contentStack.axis == .vertical }
 
     /// Lays the content out again on the next pass. Scrolling alone does not:
@@ -4266,6 +4637,35 @@ private final class CraftNativeLabel: UILabel {
     }
 }
 
+/// A non-editable text view used when a native Text explicitly opts into
+/// selection. UILabel has no selection model; UITextView supplies UIKit's
+/// standard loupe, menu and copy behavior while remaining a plain text leaf.
+private final class CraftNativeSelectableTextView: UITextView {
+    convenience init() {
+        self.init(frame: .zero, textContainer: nil)
+    }
+
+    override init(frame: CGRect, textContainer: NSTextContainer?) {
+        super.init(frame: frame, textContainer: textContainer)
+        isEditable = false
+        isSelectable = true
+        isScrollEnabled = false
+        backgroundColor = .clear
+        textContainerInset = .zero
+        self.textContainer.lineFragmentPadding = 0
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        isEditable = false
+        isSelectable = true
+        isScrollEnabled = false
+        backgroundColor = .clear
+        textContainerInset = .zero
+        self.textContainer.lineFragmentPadding = 0
+    }
+}
+
 /// A one-line TextInput. Its style's padding is where the text and the
 /// placeholder start, as in a web input; UITextField has no padding of its own.
 final class CraftNativeTextField: UITextField {
@@ -4302,6 +4702,22 @@ private final class CraftNativeFlexSpacer: UIView {}
 private final class CraftNativeIconView: UIImageView {
     var defaultBox: CGFloat? { didSet { if defaultBox != oldValue { invalidateIntrinsicContentSize() } } }
 
+    /// An icon says only what the screen labels it. iOS gives a symbol image
+    /// a description of its own ("Circle", "Chevron"), which VoiceOver read
+    /// as an extra stop and a row read as part of its text; an unlabelled
+    /// icon is decoration, as UIKit's own glyph accessories are.
+    private var authoredLabel: String?
+
+    override var accessibilityLabel: String? {
+        get { authoredLabel }
+        set { authoredLabel = newValue }
+    }
+
+    override var isAccessibilityElement: Bool {
+        get { authoredLabel != nil && super.isAccessibilityElement }
+        set { super.isAccessibilityElement = newValue }
+    }
+
     override var intrinsicContentSize: CGSize {
         if let defaultBox { return CGSize(width: defaultBox, height: defaultBox) }
         return super.intrinsicContentSize
@@ -4511,9 +4927,17 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    // A reparented popup must keep the live native view that owns its draft,
+    // focus and selection. The mutation protocol identifies nodes globally;
+    // retain the previous render by that ID when the new parent has no local
+    // identity entry for it.
+    private var previousNodesByProtocolID: [String: RenderedNode] = [:]
+    private var adoptedPreviousProtocolIDs = Set<String>()
+
     private let config: CraftConfig
     private let routeName: String?
     private(set) var routeParams: [String: Any]
+    private(set) var routeProps: [String: Any]
     private let jsContext = JSContext(virtualMachine: CraftNativeBundle.virtualMachine)!
     private let rootStack = CraftNativeFlowView()
     private var handlers: [ObjectIdentifier: String] = [:]
@@ -4538,6 +4962,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var sliderSteps: [ObjectIdentifier: Float] = [:]
     private var pickerOptions: [ObjectIdentifier: [(value: String, label: String)]] = [:]
     private var modalVisibility: [ObjectIdentifier: Bool] = [:]
+    private var modalFocusRestore: [ObjectIdentifier: UIView] = [:]
     private var layoutHandlers: [ObjectIdentifier: String] = [:]
     private var lastLayoutFrames: [ObjectIdentifier: CGRect] = [:]
     private var tapRecognizers: [ObjectIdentifier: UITapGestureRecognizer] = [:]
@@ -4595,10 +5020,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// A request a screen-owned module answers, by request token, and how to
     /// call it off when it times out or is cancelled.
     private var screenRequestCancellers: [String: () -> Void] = [:]
-    /// Shown at least once: a later appearance is the screen coming back.
-    private var hasAppeared = false
-    /// Whether the script was last told the screen is on screen.
-    private var reportedVisible = false
+    /// Whether the script was last told the screen is on screen; nil until the
+    /// first report. A screen first reported hidden - an adjacent tab the
+    /// shell prepares ahead of a swipe - must hear that, or its script takes
+    /// itself to be in front and acts on it: a sign-in guard on a prepared
+    /// Record tab pushed Login over the Feed at launch.
+    private var reportedVisible: Bool?
     private let capabilityScope = UUID().uuidString
     private var pendingCapabilityRequests = Set<String>()
     private var pendingCapabilityDeadlines: [String: DispatchWorkItem] = [:]
@@ -4624,10 +5051,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// `DEEP_LINK`; it can open paths but not push, pop or style a bar.
     let isAppScript: Bool
 
-    init(config: CraftConfig, routeName: String? = nil, routeParams: [String: Any] = [:], isAppScript: Bool = false) {
+    init(config: CraftConfig, routeName: String? = nil, routeParams: [String: Any] = [:], routeProps: [String: Any] = [:], isAppScript: Bool = false) {
         self.config = config
         self.routeName = routeName
         self.routeParams = routeParams
+        self.routeProps = routeProps
         self.isAppScript = isAppScript
         super.init(nibName: nil, bundle: nil)
     }
@@ -4718,6 +5146,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// sees, not a tab prepared behind it.
     private var isShownOnScreen: Bool {
         guard let window = view.window else { return false }
+        if let shell = navigationController?.parent as? CraftHybridController,
+           !shell.isFocusedScreen(self) { return false }
         var candidate: UIView? = view
         while let current = candidate, current !== window {
             if current.isHidden { return false }
@@ -4783,8 +5213,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// The screen came on screen or went off it: a screen pushed over it was
     /// popped, or the hybrid shell switched to or away from its tab (which
     /// hides a stack rather than moving it, so UIKit says nothing). The first
-    /// appearance is the screen's mount, not news; every later one is
-    /// `SCREEN_FOCUS { focused: true }`, and going away is `focused: false`.
+    /// appearance of a screen shown as it mounts is the mount, not news; every
+    /// later one is `SCREEN_FOCUS { focused: true }`, and going away is
+    /// `focused: false`. A screen that mounts hidden is told `focused: false`
+    /// first, so its first showing is news too.
     func screenVisibilityChanged(_ visible: Bool) {
         guard !runtimeDisposed else { return }
         if !visible, isViewLoaded { stopCelebrations(in: view) }
@@ -4793,31 +5225,32 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // chrome even when no new SCREEN_FOCUS event is needed.
         if visible { restoreShellChrome() }
         guard visible != reportedVisible else { return }
+        let first = reportedVisible == nil
         reportedVisible = visible
         if visible { DeepLinkManager.shared.replayNativeLinks() }
-        if visible, !hasAppeared {
-            hasAppeared = true
-            return
-        }
+        if first, visible { return }
         send(type: "SCREEN_FOCUS", payload: ["focused": visible])
     }
 
-    /// New params for the screen already showing a path: opened again with
-    /// another query (`/m/messages?person=8`), or a tab's root opened with
-    /// one (`/m/store?coach=5`). The script's `craft.route.params` changes
-    /// and it hears `ROUTE_PARAMS`; before the script has run, it simply
-    /// starts with them.
-    func receiveRouteParams(_ params: [String: Any]) {
+    /// New params or props for the screen already showing a path: opened
+    /// again with another query or a structured handoff. The two namespaces
+    /// stay separate so props cannot collide with path/query params.
+    func receiveRouteParams(_ params: [String: Any], props: [String: Any] = [:]) {
         routeParams = params
+        routeProps = props
         guard isViewLoaded, !runtimeDisposed else { return }
         let context = jsContext
-        CraftNativeScriptThread.run { context.setObject(params as NSDictionary, forKeyedSubscript: "__stxNativeParams" as NSString) }
-        send(type: "ROUTE_PARAMS", payload: ["params": params])
+        CraftNativeScriptThread.run {
+            context.setObject(params as NSDictionary, forKeyedSubscript: "__stxNativeParams" as NSString)
+            context.setObject(props as NSDictionary, forKeyedSubscript: "__stxNativeProps" as NSString)
+        }
+        send(type: "ROUTE_PARAMS", payload: ["params": params, "props": props])
     }
 
     private func disposeRuntime() {
         guard !runtimeDisposed else { return }
         runtimeDisposed = true
+        disposeRenderedTree()
         let context = jsContext
         CraftNativeScriptThread.run { context.objectForKeyedSubscript("__stxNativeUnmount")?.call(withArguments: []) }
         audio.close()
@@ -4827,6 +5260,21 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         screenRequestCancellers.removeAll()
     }
 
+    /// Runtime disposal happens before UIKit necessarily deallocates the
+    /// controller. Release the rendered tree now so recycled rows, native
+    /// delegates, media, and map callbacks cannot outlive their screen.
+    private func disposeRenderedTree() {
+        guard let root = renderedRoot else { return }
+        forgetHandlers(root)
+        rootStack.removeArrangedSubview(root.view)
+        root.view.removeFromSuperview()
+        renderedRoot = nil
+        flatListRows.removeAll()
+        flatListRecycled.removeAll()
+        flatListOwners.removeAll()
+        svgOwners.removeAll()
+    }
+
     private var appliedTraitDefaults: String?
 
     private func refreshTraitDefaults() {
@@ -4847,6 +5295,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     private func refreshTraitDefaults(in node: RenderedNode?) {
         guard let node else { return }
+        (node.view as? CraftNativeMapView)?.refreshThemeDefaults()
         (node.view as? CraftNativeFlatList)?.refreshThemeDefaults()
         node.children.forEach { refreshTraitDefaults(in: $0) }
     }
@@ -4882,13 +5331,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     /// What a screen's script starts with that only the main thread may read:
-    /// the app's state, the appearance, what the device can do.
+    /// the app's state, the appearance, initial visibility, what the device can do.
     private struct ScriptInputs {
         let capabilityJSON: String
         let appState: String
         let colorScheme: String
         let appearanceJSON: String
         let sessionTokenKey: String
+        let focused: Bool?
     }
 
     private func scriptInputs() -> ScriptInputs {
@@ -4899,7 +5349,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             appState: CraftNativeActions.currentAppState(),
             colorScheme: colorScheme,
             appearanceJSON: appearanceJSON(),
-            sessionTokenKey: Self.jsonString(CraftSession.tokenKey(config))
+            sessionTokenKey: Self.jsonString(CraftSession.tokenKey(config)),
+            focused: reportedVisible
         )
     }
 
@@ -4908,6 +5359,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             jsContext.setObject(routeName, forKeyedSubscript: "__stxNativeRoute" as NSString)
         }
         jsContext.setObject(routeParams as NSDictionary, forKeyedSubscript: "__stxNativeParams" as NSString)
+        jsContext.setObject(routeProps as NSDictionary, forKeyedSubscript: "__stxNativeProps" as NSString)
+        // Hidden before its script ran: the SCREEN_FOCUS saying so reached no
+        // callback, so the script reads it as it starts instead.
+        if inputs.focused == false {
+            jsContext.setObject(false, forKeyedSubscript: "__stxNativeFocused" as NSString)
+        }
         jsContext.exceptionHandler = { [weak self] context, exception in
             // Never stringify an arbitrary JS object here. JavaScriptCore can
             // re-enter this handler while coercing an exception whose
@@ -4998,6 +5455,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 onMessage: function(callback) { globalThis.__stxNativeCallback = callback; }
             };
         """)
+        jsContext.evaluateScript(Self.nativeWebAPICompatibilityPrelude)
         installHostAPIs()
         jsContext.evaluateScript("""
             if (typeof globalThis.setTimeout !== 'function') {
@@ -5054,6 +5512,25 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         """)
     }
 
+    /// JavaScriptCore has the language core but not browser URL/encoding
+    /// globals. Keep their absence actionable for shared modules instead of
+    /// surfacing an opaque ReferenceError from an unrelated load path. Full
+    /// implementations belong to the shared STX runtime.
+    private static let nativeWebAPICompatibilityPrelude = """
+        (function() {
+          function unavailable(name, hint) {
+            var failure = function() {
+              throw new ReferenceError(name + ' is not available on a native screen — ' + hint);
+            };
+            failure.prototype.constructor = failure;
+            return failure;
+          }
+          if (typeof globalThis.URL === 'undefined') globalThis.URL = unavailable('URL', 'use an absolute URL or build the path with encodeURIComponent');
+          if (typeof globalThis.URLSearchParams === 'undefined') globalThis.URLSearchParams = unavailable('URLSearchParams', 'build query strings with encodeURIComponent');
+          if (typeof globalThis.TextEncoder === 'undefined') globalThis.TextEncoder = unavailable('TextEncoder', 'use a native-supported encoding helper');
+        })();
+    """
+
     /// `value` as a JavaScript string literal (JSON), quotes and all.
     static func jsonString(_ value: String) -> String {
         guard let data = try? JSONSerialization.data(withJSONObject: [value]),
@@ -5222,14 +5699,22 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                         }));
                     });
                 }
-                var craft = globalThis.craft = globalThis.craft || {};
-                if (Array.isArray(bridge.capabilities) && bridge.capabilities.indexOf('dialog') >= 0 && !craft.dialog) {
-                    craft.dialog = {
-                        alert: function(options) { return request('alert', [options || {}]).then(function() {}); },
-                        confirm: function(options) { return request('confirm', [options || {}]).then(Boolean); },
-                        actionSheet: function(options) { return request('actionSheet', [options || {}]).then(function(id) { return typeof id === 'string' ? id : null; }); }
-                    };
+                // Native capability ownership wins over any browser-shaped
+                // dialog object the bundle installed before the bridge ran.
+                // Leaving the old guard here sends actionSheet through the
+                // DOM fallback even though this screen can present UIKit.
+                function installNativeDialog() {
+                    var craft = globalThis.craft = globalThis.craft || {};
+                    if (Array.isArray(bridge.capabilities) && bridge.capabilities.indexOf('dialog') >= 0) {
+                        craft.dialog = {
+                            alert: function(options) { return request('alert', [options || {}]).then(function() {}); },
+                            confirm: function(options) { return request('confirm', [options || {}]).then(Boolean); },
+                            actionSheet: function(options) { return request('actionSheet', [options || {}]).then(function(id) { return typeof id === 'string' ? id : null; }); }
+                        };
+                    }
                 }
+                globalThis.__craftInstallNativeDialog = installNativeDialog;
+                installNativeDialog();
             })();
         """)
         // `AudioContext` and the rest of Web Audio, rendered natively.
@@ -5443,6 +5928,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             jsContext.evaluateScript(runtime.source, withSourceURL: runtime.url)
         }
         jsContext.evaluateScript(bundle.source, withSourceURL: bundle.url)
+        // The STX runtime may install its browser-shaped craft.dialog after
+        // the host prelude. Re-assert the native capability once the bundle
+        // has finished so native screens cannot fall through to a DOM sheet.
+        jsContext.evaluateScript("if (typeof globalThis.__craftInstallNativeDialog === 'function') globalThis.__craftInstallNativeDialog();")
         // A bundle that names no route leaves `__stxNativeRoute` undefined;
         // its title is the app's, not the word "undefined". A title the
         // script set with `navigation.setOptions` wins over both.
@@ -5943,7 +6432,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         guard !isAppScript else { return }
         deepLinkListener = DeepLinkManager.shared.addNativeListener(canReceive: { [weak self] in
             guard let self = self else { return false }
-            return self.reportedVisible && !self.runtimeDisposed && self.navigationController?.topViewController === self
+            return self.reportedVisible == true && !self.runtimeDisposed && self.navigationController?.topViewController === self
         }) { [weak self] url, initial in
             guard let self = self else { return }
             var payload = CraftNativeActions.deepLinkData(url)
@@ -6155,7 +6644,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             // A path rather than a screen: the hybrid shell opens it, natively
             // or in the web view.
             guard let path = payload["path"] as? String, !path.isEmpty else { return }
-            hybridEvents?.nativeScreen(self, open: path)
+            hybridEvents?.nativeScreen(self, open: path, props: payload["props"] as? [String: Any] ?? [:])
         case "NAVIGATE_BACK":
             if !isAppScript, navigationController?.topViewController === self {
                 navigationController?.popViewController(animated: true)
@@ -6255,6 +6744,124 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         let id = args.first as? String ?? ""
         switch (module, method) {
+        case ("View", "focus"):
+            let options = args.first as? [String: Any]
+            let nodeId = options?["nodeId"] as? String ?? (args.first as? String) ?? ""
+            let mode = options?["mode"] as? String ?? (args.count > 1 ? args[1] as? String : nil) ?? "keyboard"
+            guard !nodeId.isEmpty else {
+                reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.focus needs a nodeId")))
+                return true
+            }
+            guard let node = renderedNode(nodeId) else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_FOUND", message: "View.focus could not find mounted node \(nodeId)")))
+                return true
+            }
+            guard node.view.window != nil else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_MOUNTED", message: "View.focus requires a mounted node")))
+                return true
+            }
+            switch mode {
+            case "keyboard":
+                guard node.view is UITextField || node.view is UITextView else {
+                    reply(.failure(CraftNativeActionError(code: "UNSUPPORTED_TARGET", message: "Keyboard focus is supported only for text inputs")))
+                    return true
+                }
+                guard node.view.becomeFirstResponder() else {
+                    reply(.failure(CraftNativeActionError(code: "FOCUS_FAILED", message: "The mounted view refused keyboard focus")))
+                    return true
+                }
+                lastFocusedInput = node.view
+                reply(.success(true))
+            case "accessibility":
+                UIAccessibility.post(notification: .layoutChanged, argument: node.view)
+                reply(.success(true))
+            default:
+                reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.focus mode must be keyboard or accessibility")))
+            }
+            return true
+        case ("View", "measure"):
+            let options = args.first as? [String: Any]
+            let nodeId = options?["nodeId"] as? String ?? (args.first as? String) ?? ""
+            guard !nodeId.isEmpty else {
+                reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.measure needs a nodeId")))
+                return true
+            }
+            guard let node = renderedNode(nodeId) else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_FOUND", message: "View.measure could not find mounted node \(nodeId)")))
+                return true
+            }
+            guard node.view.window != nil else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_MOUNTED", message: "View.measure requires a mounted node")))
+                return true
+            }
+            view.layoutIfNeeded()
+            let bounds = node.view.convert(node.view.bounds, to: view)
+            guard bounds.origin.x.isFinite, bounds.origin.y.isFinite, bounds.width.isFinite, bounds.height.isFinite else {
+                reply(.failure(CraftNativeActionError(code: "MEASURE_FAILED", message: "The mounted view has no finite layout")))
+                return true
+            }
+            reply(.success([
+                "x": bounds.origin.x,
+                "y": bounds.origin.y,
+                "width": bounds.width,
+                "height": bounds.height,
+                "viewportWidth": view.bounds.width,
+                "viewportHeight": view.bounds.height,
+                "unit": "points",
+                "coordinateSpace": "screenViewport",
+            ]))
+            return true
+        case ("View", "scrollTo"):
+            let options = args.first as? [String: Any]
+            let nodeId = options?["nodeId"] as? String ?? (args.first as? String) ?? ""
+            guard !nodeId.isEmpty else {
+                reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.scrollTo needs a nodeId")))
+                return true
+            }
+            guard let node = renderedNode(nodeId) else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_FOUND", message: "View.scrollTo could not find mounted node \(nodeId)")))
+                return true
+            }
+            guard node.view.window != nil else {
+                reply(.failure(CraftNativeActionError(code: "VIEW_NOT_MOUNTED", message: "View.scrollTo requires a mounted node")))
+                return true
+            }
+            guard let scrollView = node.view as? UIScrollView else {
+                reply(.failure(CraftNativeActionError(code: "UNSUPPORTED_TARGET", message: "View.scrollTo is supported only for scroll views")))
+                return true
+            }
+            let x: Double
+            if let raw = options?["x"] {
+                guard let number = craftNativeNumber(raw), number.doubleValue.isFinite else {
+                    reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.scrollTo coordinates must be finite numbers")))
+                    return true
+                }
+                x = number.doubleValue
+            } else {
+                x = scrollView.contentOffset.x
+            }
+            let y: Double
+            if let raw = options?["y"] {
+                guard let number = craftNativeNumber(raw), number.doubleValue.isFinite else {
+                    reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.scrollTo coordinates must be finite numbers")))
+                    return true
+                }
+                y = number.doubleValue
+            } else {
+                y = scrollView.contentOffset.y
+            }
+            guard x.isFinite, y.isFinite else {
+                reply(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "View.scrollTo coordinates must be finite numbers")))
+                return true
+            }
+            let minX = -scrollView.adjustedContentInset.left
+            let minY = -scrollView.adjustedContentInset.top
+            let maxX = max(minX, scrollView.contentSize.width - scrollView.bounds.width + scrollView.adjustedContentInset.right)
+            let maxY = max(minY, scrollView.contentSize.height - scrollView.bounds.height + scrollView.adjustedContentInset.bottom)
+            let target = CGPoint(x: min(max(x, minX), maxX), y: min(max(y, minY), maxY))
+            scrollView.setContentOffset(target, animated: options?["animated"] as? Bool ?? false)
+            reply(.success(["x": target.x, "y": target.y, "unit": "points"]))
+            return true
         case ("Network", "stream"):
             let options = args.first as? [String: Any] ?? [:]
             let streamId = options["id"] as? String ?? ""
@@ -6398,7 +7005,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         statusBarStyleOverride = nil
         statusBarHiddenOverride = nil
         let previous = renderedRoot
+        previousNodesByProtocolID.removeAll(keepingCapacity: true)
+        adoptedPreviousProtocolIDs.removeAll(keepingCapacity: true)
+        indexPreviousNodes(previous)
         let next = reconcile(document, identity: "root", path: "root", previous: previous)
+        previousNodesByProtocolID.removeAll(keepingCapacity: true)
+        adoptedPreviousProtocolIDs.removeAll(keepingCapacity: true)
         if previous?.view !== next.view {
             if let old = previous { detach(old, from: rootStack) }
         }
@@ -6460,6 +7072,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func canReuseView(_ node: [String: Any], previous: RenderedNode) -> Bool {
         let type = canonicalType(node["type"] as? String ?? "View")
         guard previous.type == type else { return false }
+        if type == "Text" {
+            let props = node["props"] as? [String: Any] ?? [:]
+            return (previous.view is CraftNativeSelectableTextView) == (props["selectable"] as? Bool == true)
+        }
         guard type == "TextInput" else { return true }
         let props = node["props"] as? [String: Any] ?? [:]
         return (previous.view is UITextView) == (props["multiline"] as? Bool == true)
@@ -6486,16 +7102,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let style = node["style"] as? [String: Any] ?? [:]
         let events = node["events"] as? [String: String] ?? [:]
         let children = node["children"] as? [Any] ?? []
+        let protocolId = node["id"] as? String
+        let retained = previous ?? protocolId.flatMap { id in
+            guard !adoptedPreviousProtocolIDs.contains(id) else { return nil }
+            return previousNodesByProtocolID[id]
+        }
+        let adopted = previous == nil && retained != nil
         let current: RenderedNode
-        if let previous = previous, previous.identity == identity || adopting, canReuseView(node, previous: previous) {
-            current = previous
+        if let retained, (retained.identity == identity || adopting || adopted), canReuseView(node, previous: retained) {
+            current = retained
+            if let protocolId { adoptedPreviousProtocolIDs.insert(protocolId) }
             current.identity = identity
         } else {
             current = RenderedNode(identity: identity, type: type, view: makeView(type, props: props))
         }
 
         let result = current.view
-        current.protocolId = node["id"] as? String
+        current.protocolId = protocolId
         current.style = style
         let linkTarget = ["href", "to"].lazy.compactMap { props[$0] as? String }
             .first(where: { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })?
@@ -6529,11 +7152,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             result.isHidden = true
             result.isUserInteractionEnabled = false
         case "Text":
-            let label = result as! UILabel
-            label.numberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
-            label.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
-            (label as? CraftNativeLabel)?.insets = paddingInsets(style)
-            configureText(label, text: children.compactMap { $0 as? String }.joined(), style: style)
+            let text = children.compactMap { $0 as? String }.joined()
+            if let selectable = result as? CraftNativeSelectableTextView {
+                selectable.textContainer.maximumNumberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                selectable.textContainer.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
+                configureSelectableText(selectable, text: text, style: style)
+            } else {
+                let label = result as! UILabel
+                label.numberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                label.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
+                (label as? CraftNativeLabel)?.insets = paddingInsets(style)
+                configureText(label, text: text, style: style)
+            }
         case "Button", "Link":
             let button = result as! UIButton
             let title = props["title"] as? String ?? children.compactMap { $0 as? String }.joined()
@@ -6704,6 +7334,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             updateHandler(nonEmptyHandler(events["onValueChange"]) ?? nonEmptyHandler(events["onChange"]), for: picker)
         case "Modal":
             let modal = result as! CraftNativeModalView
+            let focusBeforeContent = firstResponder(in: rootStack) ?? lastFocusedInput
             modal.transparent = props["transparent"] as? Bool == true
             let visible: Bool
             if let propVisible = props["visible"] as? Bool {
@@ -6718,10 +7349,22 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let modalID = ObjectIdentifier(modal)
             let wasVisible = modalVisibility[modalID]
             modalVisibility[modalID] = visible
+            if visible, wasVisible != true, let focusBeforeContent,
+               !focusBeforeContent.isDescendant(of: modal) {
+                modalFocusRestore[modalID] = focusBeforeContent
+            }
             if visible, wasVisible != true { positionModals() }
             modal.setVisible(visible, opacity: number(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
+            if !visible, wasVisible == true {
+                let restore = modalFocusRestore.removeValue(forKey: modalID)
+                DispatchQueue.main.async { [weak self, weak restore] in
+                    guard let self, let restore, restore.window != nil, restore.isDescendant(of: self.view) else { return }
+                    self.lastFocusedInput = restore
+                    _ = restore.becomeFirstResponder()
+                }
+            }
             modal.onRequestClose = nonEmptyHandler(events["onRequestClose"]).map { handler in
-                { [weak self] in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": [:]]) }
+                { [weak self] reason in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["reason": reason]]) }
             }
             if visible { modal.clearDismissSuppression() }
             let suppressDismiss = !visible && modal.consumeDismissSuppression()
@@ -6744,10 +7387,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             pressable.pressUnderlayColor = type == "TouchableHighlight" && !disabled ? color(props["underlayColor"]) : nil
         case "Switch":
             let toggle = result as! UISwitch
-            let value = props["value"] as? Bool ?? props["checked"] as? Bool ?? false
-            // UIKit has already changed the value before emitting the event.
-            // Echoing it through the script must not restart its native animation.
-            if toggle.isOn != value { toggle.isOn = value }
+            // A supplied value controls the switch; without one, UIKit owns
+            // the state and a reconciliation must not erase a user's tap.
+            // `value: null` deliberately falls through to `checked`, matching
+            // the host-neutral precedence used by the other renderer.
+            if let value = props["value"] as? Bool ?? props["checked"] as? Bool {
+                // UIKit has already changed the value before emitting the
+                // event. Echoing it through the script must not restart its
+                // native animation.
+                if toggle.isOn != value { toggle.isOn = value }
+            }
             toggle.isEnabled = props["disabled"] as? Bool != true
             if let track = props["trackColor"] as? [String: Any] {
                 toggle.onTintColor = color(track["true"])
@@ -6795,8 +7444,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             indicator.hidesWhenStopped = props["hidesWhenStopped"] as? Bool ?? true
             if props["animating"] as? Bool == false {
                 indicator.stopAnimating()
+                // UIKit does not retroactively reveal an indicator when an
+                // already-stopped view changes hidesWhenStopped to false.
+                // Android applies the requested visibility on every render;
+                // keep the two hosts in lockstep for dynamic prop changes.
+                indicator.isHidden = indicator.hidesWhenStopped
             } else {
                 indicator.startAnimating()
+                indicator.isHidden = false
             }
         case "Svg":
             let drawing = result as! CraftNativeSvgView
@@ -6822,7 +7477,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let current = image.image { image.image = imageForDisplay(current, view: image) }
             let requestedResizeMode = style["resizeMode"] as? String ?? props["resizeMode"] as? String
             image.contentMode = imageContentMode(requestedResizeMode)
-            image.clipsToBounds = image.clipsToBounds || image.contentMode == .scaleAspectFill
+            applyImageClipping(image, contentMode: image.contentMode, style: style)
             updateAuxiliaryHandler(events["onLoadStart"], in: &imageLoadStartHandlers, for: image)
             updateAuxiliaryHandler(events["onLoad"], in: &imageLoadHandlers, for: image)
             updateAuxiliaryHandler(events["onLoadEnd"], in: &imageLoadEndHandlers, for: image)
@@ -6841,7 +7496,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let current = background.image { background.image = imageForDisplay(current, view: background) }
             let requestedResizeMode = style["resizeMode"] as? String ?? props["resizeMode"] as? String
             background.contentMode = imageContentMode(requestedResizeMode)
-            background.clipsToBounds = background.clipsToBounds || background.contentMode == .scaleAspectFill
+            applyImageClipping(background, contentMode: background.contentMode, style: style)
             updateAuxiliaryHandler(events["onLoadStart"], in: &imageLoadStartHandlers, for: background)
             updateAuxiliaryHandler(events["onLoad"], in: &imageLoadHandlers, for: background)
             updateAuxiliaryHandler(events["onLoadEnd"], in: &imageLoadEndHandlers, for: background)
@@ -6985,6 +7640,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func makeView(_ type: String, props: [String: Any]) -> UIView {
         switch type {
         case "Text":
+            if props["selectable"] as? Bool == true {
+                return CraftNativeSelectableTextView()
+            }
             let label = CraftNativeLabel()
             label.numberOfLines = 0
             return label
@@ -7169,7 +7827,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let key = explicitKey(node, props: node["props"] as? [String: Any] ?? [:])
             // Keys are local to a parent. Ambiguous sibling keys fall back to
             // position so a move never attaches the wrong live control.
-            let identity = key.flatMap { counts[$0] == 1 ? "key:\($0)" : nil } ?? "index:\(index)"
+            let localIdentity = key.flatMap { counts[$0] == 1 ? "key:\($0)" : nil } ?? "index:\(index)"
+            // A keyed row can live in either FlatList or an ordinary
+            // ScrollView. Scope its descendants to the row so two rows cannot
+            // share an uncontrolled input draft or retained native handler.
+            let identity = parent.identity.hasPrefix("list:") || parent.identity.hasPrefix("key:")
+                ? "\(parent.identity)/\(localIdentity)"
+                : localIdentity
             let child = reconcile(node, identity: identity, path: "\(path).\(index)", previous: old[identity])
             next.append(child)
         }
@@ -7302,6 +7966,21 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 recycled[ObjectIdentifier(row.view)] = row
                 self.flatListRecycled[listKey] = recycled
             },
+            removeItem: { [weak self] identity in
+                guard let self else { return }
+                let scopedIdentity = "list:\(identity)"
+                if let row = self.flatListRows[listKey]?.removeValue(forKey: identity) {
+                    self.forgetHandlers(row)
+                }
+                guard var recycled = self.flatListRecycled[listKey] else { return }
+                let staleViewIDs = recycled.compactMap { viewID, row in
+                    row.identity == scopedIdentity ? viewID : nil
+                }
+                for viewID in staleViewIDs {
+                    if let row = recycled.removeValue(forKey: viewID) { self.forgetHandlers(row) }
+                }
+                self.flatListRecycled[listKey] = recycled
+            },
             endReached: nonEmptyHandler(events["onEndReached"]).map { [weak self] handler in
                 { self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": [:]]) }
             }
@@ -7333,24 +8012,52 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func detach(_ node: RenderedNode, from stack: CraftNativeFlowView) {
-        forgetHandlers(node)
+        let retainedByReparent = node.protocolId.map { adoptedPreviousProtocolIDs.contains($0) } == true
+        if !retainedByReparent { forgetHandlers(node) }
         if node.type == "Modal" {
-            node.view.removeFromSuperview()
+            if node.view.superview === stack { node.view.removeFromSuperview() }
             return
         }
-        stack.removeLayoutStyle(for: node.view)
-        stack.removeArrangedSubview(node.view)
-        node.view.removeFromSuperview()
+        if node.view.superview === stack {
+            stack.removeLayoutStyle(for: node.view)
+            stack.removeArrangedSubview(node.view)
+            node.view.removeFromSuperview()
+        }
+    }
+
+    private func indexPreviousNodes(_ node: RenderedNode?) {
+        guard let node else { return }
+        if let id = node.protocolId, !id.isEmpty { previousNodesByProtocolID[id] = node }
+        node.children.forEach { indexPreviousNodes($0) }
     }
 
     private func forgetHandlers(_ node: RenderedNode, preservingInputDrafts: Bool = false) {
         (node.view as? CraftNativeScrollView)?.setRefreshHandler(nil, refreshing: false)
+        // Recycled list rows keep their native delegates and targets until
+        // they are rebound. A permanently detached node must release those
+        // UIKit hooks as well as the handler maps below, otherwise a picker,
+        // text view, or control can still call back into this screen after
+        // its subtree is gone.
+        if !preservingInputDrafts {
+            if let textView = node.view as? UITextView { textView.delegate = nil }
+            if let picker = node.view as? UIPickerView {
+                picker.delegate = nil
+                picker.dataSource = nil
+            }
+            if let scroll = node.view as? UIScrollView { scroll.delegate = nil }
+            (node.view as? UIControl)?.removeTarget(self, action: nil, for: .allEvents)
+        }
         if let list = node.view as? CraftNativeFlatList {
             let listKey = ObjectIdentifier(list)
             list.setRefreshHandler(nil, refreshing: false)
             list.discardAll()
+            if !preservingInputDrafts { list.resetForTeardown() }
             flatListRows.removeValue(forKey: listKey)
-            flatListRecycled.removeValue(forKey: listKey)
+            if !preservingInputDrafts {
+                flatListRecycled.removeValue(forKey: listKey)?.values.forEach { forgetHandlers($0) }
+            } else {
+                flatListRecycled.removeValue(forKey: listKey)
+            }
             if let owner = node.protocolId { flatListOwners = flatListOwners.filter { $0.value != owner } }
         }
         if node.view is CraftNativeSvgView, let owner = node.protocolId { svgOwners = svgOwners.filter { $0.value != owner } }
@@ -7408,6 +8115,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         imageErrorHandlers.removeValue(forKey: id)
         checkboxIndeterminate.removeValue(forKey: id)
         if let video = node.view as? CraftNativeVideoView { video.stop() }
+        if let map = node.view as? CraftNativeMapView { map.destroy() }
         for child in node.children { forgetHandlers(child, preservingInputDrafts: preservingInputDrafts) }
     }
 
@@ -7773,6 +8481,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         stack.columnGap = max(0, number(style["columnGap"]) ?? gap)
         stack.grid = style["display"] as? String == "grid"
         stack.gridColumns = craftNativeGridColumnCount(style["gridTemplateColumns"] ?? style["gridColumns"])
+        stack.gridRows = craftNativeGridRowCount(style["gridTemplateRows"])
         stack.gridAutoRows = CraftNativeLength(style["gridAutoRows"])
         stack.padding = paddingInsets(style)
         stack.invalidateMeasurements()
@@ -7939,6 +8648,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         label.lineBreakMode = lineBreakMode
     }
 
+    private func configureSelectableText(_ textView: UITextView, text: String, style: [String: Any]) {
+        let label = CraftNativeLabel()
+        label.numberOfLines = 0
+        configureText(label, text: text, style: style)
+        textView.attributedText = label.attributedText
+        if label.attributedText == nil { textView.text = label.text }
+        textView.font = label.font
+        textView.textColor = label.textColor
+        textView.textAlignment = label.textAlignment
+        textView.textContainerInset = paddingInsets(style)
+        textView.textContainer.lineFragmentPadding = 0
+        textView.isEditable = false
+        textView.isSelectable = true
+        textView.isScrollEnabled = false
+        textView.backgroundColor = .clear
+    }
+
     private func textLineBreakMode(_ value: Any?) -> NSLineBreakMode {
         switch value as? String {
         case "head": return .byTruncatingHead
@@ -8186,6 +8912,30 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         return ["localhost", "127.0.0.1", "::1"].contains(bare) || bare.hasSuffix(".localhost")
     }
 
+    /// Native screens have no document URL to resolve a path against. A
+    /// leading slash is an app URL (for example `/api/avatar`), while a bare
+    /// name remains a bundled asset for backwards compatibility.
+    private func imageURL(for uri: String) -> URL? {
+        let candidate: URL?
+        if uri.hasPrefix("/") {
+            guard let base = config.devServerURL.flatMap(URL.init(string:)) else { return nil }
+            candidate = URL(string: uri, relativeTo: base)?.absoluteURL
+        } else {
+            candidate = URL(string: uri)
+        }
+        guard let candidate, Self.loadsImage(from: candidate) else { return nil }
+        return candidate
+    }
+
+    private func applyImageClipping(_ view: UIImageView, contentMode: UIView.ContentMode, style: [String: Any]) {
+        let authored = (style["overflow"] as? String) == "hidden"
+            || (view.craftRequestedCornerRadius ?? 0) > 0
+            || view.craftRequestedCornerRadii != nil
+        let clips = authored || contentMode == .scaleAspectFill
+        view.clipsToBounds = clips
+        view.layer.masksToBounds = clips
+    }
+
     private func updateImage(_ view: UIImageView, source: Any?, defaultSource: Any? = nil) {
         let sourceObject = source as? [String: Any]
         let uri = (source as? String) ?? sourceObject?["uri"] as? String
@@ -8225,7 +8975,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             emitImageEvent(view, handler: imageLoadEndHandlers[id])
             return
         }
-        if let url = URL(string: uri), Self.loadsImage(from: url) {
+        if let url = imageURL(for: uri) {
             // Decoded at the size it is drawn, when the style fixes that size.
             let pixels = Self.displayPixels(of: view)
             let fill = view.contentMode == .scaleAspectFill
@@ -8267,6 +9017,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             task.resume()
             return
         }
+        if uri.hasPrefix("/") {
+            imageFailure(view, uri: uri, message: "Relative image source requires devServerURL")
+            return
+        }
         if !uri.contains(":") {
             guard let image = UIImage(named: uri) else {
                 imageFailure(view, uri: uri, message: "Bundled image was not found")
@@ -8341,7 +9095,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         let hasLinkTarget = ["href", "to"].contains { !(props[$0] as? String ?? "").isEmpty }
         let linkedControl = ["Link", "TouchableOpacity", "TouchableHighlight", "Pressable"].contains(type) && hasLinkTarget
-        let role = (props["accessibilityRole"] as? String) ?? (linkedControl ? "link" : nil)
+        let touchable = ["TouchableOpacity", "TouchableHighlight", "Pressable"].contains(type)
+        let role = (props["accessibilityRole"] as? String) ?? (linkedControl ? "link" : touchable ? "button" : nil)
         // A scroll view, a list or a group of controls holds what VoiceOver
         // reads: its label names the group, as a tab strip or a pager's
         // name, and never stands in for its content. As an element of its
@@ -8349,7 +9104,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // A video with its system controls is a group too: VoiceOver reaches
         // play, the scrubber, skipping and full screen inside it.
         let controlledVideo = type == "Video" && (props["controls"] as? Bool) == true
-        let container = ["ScrollView", "FlatList", "SectionList"].contains(type)
+        // UIPickerView exposes adjustable component wheels. Making the
+        // picker itself a leaf hides those wheels and their selected values.
+        let container = ["ScrollView", "FlatList", "SectionList", "Picker"].contains(type)
             || ["tablist", "radiogroup", "list", "menu", "menubar", "toolbar"].contains(role ?? "")
             || controlledVideo
         view.isAccessibilityElement = !container && role != "none" && (view.accessibilityLabel != nil || role != nil || ["Text", "Button", "Link", "Checkbox", "Image", "ImageBackground", "Video", "TextInput", "Picker", "DatePicker", "Switch", "Slider"].contains(type))
@@ -8360,7 +9117,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // screen omits redundant accessibility metadata.
         var traits: UIAccessibilityTraits = []
         switch type {
-        case "Slider", "Picker", "DatePicker": traits.insert(.adjustable)
+        case "Slider", "DatePicker": traits.insert(.adjustable)
         default: break
         }
         switch role ?? type.lowercased() {
@@ -8428,7 +9185,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     @objc private func buttonPressed(_ sender: UIButton) {
         let focused = firstResponder(in: rootStack) ?? lastFocusedInput
         if let target = linkTargets[ObjectIdentifier(sender)] {
-            hybridEvents?.nativeScreen(self, open: target)
+        hybridEvents?.nativeScreen(self, open: target, props: [:])
             return
         }
         guard let handler = handlers[ObjectIdentifier(sender)] else { return }
@@ -8719,7 +9476,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         guard let view = sender.view else { return }
         let id = ObjectIdentifier(view)
         if let target = linkTargets[id] {
-            hybridEvents?.nativeScreen(self, open: target)
+        hybridEvents?.nativeScreen(self, open: target, props: [:])
             return
         }
         guard let handler = handlers[id] else { return }