@appsent-co/react-native-watchos 0.1.0

package/apple/Sources/ReactNativeWatchOS/Views/LabelView.swift

@@ -0,0 +1,18 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `Label("Title", systemImage: "star.fill")`. Leaf view with
+/// two string props — `title` (text) and `systemImage` (SF Symbol name,
+/// mirrors the `systemName` convention used by `RNWImageView`). Generic
+/// modifiers (`.padding`, `.foregroundColor`, …) flow through the
+/// renderer's reduce, so no per-view modifier handling is needed.
+enum RNWLabelView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("Label") { snapshot, _, _ in
+            let title = snapshot.props?.string("title") ?? ""
+            let systemImage = snapshot.props?.string("systemImage") ?? ""
+            return AnyView(Label(title, systemImage: systemImage))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LabeledContentView.swift

@@ -0,0 +1,55 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `LabeledContent`. Walks `snapshot.children` directly so it can
+/// route a child with `viewName == "LabeledContentLabel"` into the
+/// `label:` slot and `viewName == "LabeledContentContent"` into the
+/// `content:` slot. Anything else falls back into the content slot so the
+/// tree still produces something visible.
+enum RNWLabeledContentView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LabeledContent") { snapshot, _, bus in
+            var labelView: AnyView?
+            var contentChildren: [RNWShadowNodeSnapshot] = []
+            for child in snapshot.viewChildren {
+                if child.viewName == "LabeledContentLabel" {
+                    labelView = RNWNodeRenderer.render(child, bus: bus)
+                } else {
+                    contentChildren.append(child)
+                }
+            }
+
+            let contentView = AnyView(
+                ForEach(contentChildren, id: \.tag) { node in
+                    RNWNodeRenderer.render(node, bus: bus)
+                }
+            )
+
+            if let label = labelView {
+                return AnyView(LabeledContent { contentView } label: { label })
+            }
+            return AnyView(LabeledContent { contentView } label: { EmptyView() })
+        }
+    }
+}
+
+/// Sentinel child of `<LabeledContent>` — routes into SwiftUI's `label:` slot.
+enum RNWLabeledContentLabelView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LabeledContentLabel") { _, children, _ in
+            AnyView(children)
+        }
+    }
+}
+
+/// Sentinel child of `<LabeledContent>` — routes into SwiftUI's `content:` slot.
+enum RNWLabeledContentContentView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LabeledContentContent") { _, children, _ in
+            AnyView(children)
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LazyHGridView.swift

@@ -0,0 +1,33 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWLazyHGridView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LazyHGrid") { snapshot, children, _ in
+            let rows = RNWLazyVGridView.parseGridItems(snapshot.props?["rows"] as? [Any])
+            let alignment = parseAlignment(snapshot.props?.string("alignment"))
+            let spacing = snapshot.props?.cgFloat("spacing")
+            let pinned = RNWLazyVGridView.parsePinnedViews(
+                snapshot.props?["pinnedViews"] as? [Any])
+            return AnyView(
+                LazyHGrid(
+                    rows: rows,
+                    alignment: alignment,
+                    spacing: spacing,
+                    pinnedViews: pinned
+                ) {
+                    children
+                }
+            )
+        }
+    }
+
+    private static func parseAlignment(_ s: String?) -> VerticalAlignment {
+        switch s {
+        case "top":    return .top
+        case "bottom": return .bottom
+        default:       return .center
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LazyHStackView.swift

@@ -0,0 +1,41 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWLazyHStackView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LazyHStack") { snapshot, children, _ in
+            let alignment = parseAlignment(snapshot.props?.string("alignment"))
+            let spacing = snapshot.props?.cgFloat("spacing")
+            let pinned = parsePinnedViews(snapshot.props?["pinnedViews"] as? [Any])
+            return AnyView(
+                LazyHStack(alignment: alignment, spacing: spacing, pinnedViews: pinned) {
+                    children
+                }
+            )
+        }
+    }
+
+    private static func parseAlignment(_ s: String?) -> VerticalAlignment {
+        switch s {
+        case "top":                return .top
+        case "bottom":             return .bottom
+        case "firstTextBaseline":  return .firstTextBaseline
+        case "lastTextBaseline":   return .lastTextBaseline
+        default:                   return .center
+        }
+    }
+
+    private static func parsePinnedViews(_ raw: [Any]?) -> PinnedScrollableViews {
+        guard let raw else { return .init() }
+        var out: PinnedScrollableViews = .init()
+        for case let s as String in raw {
+            switch s {
+            case "sectionHeaders": out.insert(.sectionHeaders)
+            case "sectionFooters": out.insert(.sectionFooters)
+            default: break
+            }
+        }
+        return out
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LazyVGridView.swift

@@ -0,0 +1,97 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWLazyVGridView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LazyVGrid") { snapshot, children, _ in
+            let columns = parseGridItems(snapshot.props?["columns"] as? [Any])
+            let alignment = parseAlignment(snapshot.props?.string("alignment"))
+            let spacing = snapshot.props?.cgFloat("spacing")
+            let pinned = parsePinnedViews(snapshot.props?["pinnedViews"] as? [Any])
+            return AnyView(
+                LazyVGrid(
+                    columns: columns,
+                    alignment: alignment,
+                    spacing: spacing,
+                    pinnedViews: pinned
+                ) {
+                    children
+                }
+            )
+        }
+    }
+
+    private static func parseAlignment(_ s: String?) -> HorizontalAlignment {
+        switch s {
+        case "leading":  return .leading
+        case "trailing": return .trailing
+        default:         return .center
+        }
+    }
+
+    /// Missing `maximum` on flexible/adaptive becomes `.infinity` — matches
+    /// SwiftUI's own default. Shared with `RNWLazyHGridView`.
+    static func parseGridItems(_ raw: [Any]?) -> [GridItem] {
+        guard let raw else { return [] }
+        return raw.compactMap { entry in
+            guard let dict = entry as? [String: Any],
+                  let size = dict["size"] as? [String: Any],
+                  let kind = size["kind"] as? String else { return nil }
+
+            let spacing = dict.cgFloat("spacing")
+            let alignment = parseGridItemAlignment(dict.string("alignment"))
+
+            switch kind {
+            case "fixed":
+                guard let value = size.cgFloat("value") else { return nil }
+                return GridItem(.fixed(value), spacing: spacing, alignment: alignment)
+            case "flexible":
+                let minimum = size.cgFloat("minimum") ?? 10
+                let maximum = size.cgFloat("maximum") ?? .infinity
+                return GridItem(
+                    .flexible(minimum: minimum, maximum: maximum),
+                    spacing: spacing,
+                    alignment: alignment
+                )
+            case "adaptive":
+                guard let minimum = size.cgFloat("minimum") else { return nil }
+                let maximum = size.cgFloat("maximum") ?? .infinity
+                return GridItem(
+                    .adaptive(minimum: minimum, maximum: maximum),
+                    spacing: spacing,
+                    alignment: alignment
+                )
+            default:
+                return nil
+            }
+        }
+    }
+
+    static func parsePinnedViews(_ raw: [Any]?) -> PinnedScrollableViews {
+        guard let raw else { return [] }
+        var set: PinnedScrollableViews = []
+        for entry in raw {
+            switch entry as? String {
+            case "sectionHeaders": set.insert(.sectionHeaders)
+            case "sectionFooters": set.insert(.sectionFooters)
+            default: break
+            }
+        }
+        return set
+    }
+
+    private static func parseGridItemAlignment(_ s: String?) -> Alignment {
+        switch s {
+        case "leading":        return .leading
+        case "trailing":       return .trailing
+        case "top":            return .top
+        case "bottom":         return .bottom
+        case "topLeading":     return .topLeading
+        case "topTrailing":    return .topTrailing
+        case "bottomLeading":  return .bottomLeading
+        case "bottomTrailing": return .bottomTrailing
+        default:               return .center
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LazyVStackView.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWLazyVStackView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LazyVStack") { snapshot, children, _ in
+            let alignment = parseAlignment(snapshot.props?.string("alignment"))
+            let spacing = snapshot.props?.cgFloat("spacing")
+            let pinned = parsePinnedViews(snapshot.props?["pinnedViews"] as? [Any])
+            return AnyView(
+                LazyVStack(alignment: alignment, spacing: spacing, pinnedViews: pinned) {
+                    children
+                }
+            )
+        }
+    }
+
+    private static func parseAlignment(_ s: String?) -> HorizontalAlignment {
+        switch s {
+        case "leading":  return .leading
+        case "trailing": return .trailing
+        default:         return .center
+        }
+    }
+
+    private static func parsePinnedViews(_ raw: [Any]?) -> PinnedScrollableViews {
+        guard let raw else { return .init() }
+        var out: PinnedScrollableViews = .init()
+        for case let s as String in raw {
+            switch s {
+            case "sectionHeaders": out.insert(.sectionHeaders)
+            case "sectionFooters": out.insert(.sectionFooters)
+            default: break
+            }
+        }
+        return out
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LinearGradientView.swift

@@ -0,0 +1,44 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+func parseUnitPoint(_ raw: Any?) -> UnitPoint? {
+    if let s = raw as? String {
+        switch s {
+        case "top": return .top
+        case "bottom": return .bottom
+        case "leading": return .leading
+        case "trailing": return .trailing
+        case "center": return .center
+        case "topLeading": return .topLeading
+        case "topTrailing": return .topTrailing
+        case "bottomLeading": return .bottomLeading
+        case "bottomTrailing": return .bottomTrailing
+        default: return nil
+        }
+    }
+    if let dict = raw as? [String: Any] {
+        let x = (dict["x"] as? NSNumber)?.doubleValue ?? 0
+        let y = (dict["y"] as? NSNumber)?.doubleValue ?? 0
+        return UnitPoint(x: x, y: y)
+    }
+    return nil
+}
+
+func parseColors(_ raw: Any?) -> [Color] {
+    guard let arr = raw as? [Any] else { return [] }
+    return arr.compactMap { ($0 as? String).flatMap(RNWColorParser.parse) }
+}
+
+enum RNWLinearGradientView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("LinearGradient") { snapshot, _, _ in
+            let colors = parseColors(snapshot.props?["colors"])
+            let start = parseUnitPoint(snapshot.props?["startPoint"]) ?? .top
+            let end = parseUnitPoint(snapshot.props?["endPoint"]) ?? .bottom
+            return AnyView(
+                LinearGradient(colors: colors, startPoint: start, endPoint: end)
+            )
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/LinkView.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWLinkView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("Link") { snapshot, children, _ in
+            guard
+                let destinationString = snapshot.props?.string("destination"),
+                let url = URL(string: destinationString)
+            else {
+                return AnyView(EmptyView())
+            }
+            if let title = snapshot.props?.string("title") {
+                return AnyView(Link(title, destination: url))
+            }
+            return AnyView(Link(destination: url) { children })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/ListView.swift

@@ -0,0 +1,27 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `List`. Children render as rows; wrap a subset in `Section`
+/// (with optional `SectionHeader` / `SectionFooter` sentinels) to group.
+/// Default `.automatic` style lets SwiftUI pick the watchOS-appropriate
+/// look (usually `.carousel`). Use `.plain` if rows need exact heights —
+/// `.carousel` scales rows as they scroll, which fights `.frame(height:)`.
+enum RNWListView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("List") { snapshot, children, _ in
+            let style = snapshot.props?.string("style")
+            let list = List { children }
+            switch style {
+            case "plain":
+                return AnyView(list.listStyle(.plain))
+            case "carousel":
+                return AnyView(list.listStyle(.carousel))
+            case "elliptical":
+                return AnyView(list.listStyle(.elliptical))
+            default:
+                return AnyView(list.listStyle(.automatic))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/ModifierContentView.swift

@@ -0,0 +1,16 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// Internal host node for content handed to a modifier (the body of
+/// `.sheet`, `.overlay`, `.toolbar`, `.background(content:)`, …). The JS
+/// `useModifiers` hook hoists such content out of the modifier params and
+/// into a `__ModifierContent` child node carrying a `slot` prop; the
+/// modifier pulls it back via `RNWModifierContext.content(slot)`. It
+/// renders its children inline when asked, and is excluded from a parent's
+/// inline children by `RNWShadowNodeSnapshot.viewChildren`.
+enum RNWModifierContentView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("__ModifierContent") { _, children, _ in children }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/NavigationLinkDestinationView.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// Sentinel view consumed by `NavigationLink` — routes its contents into
+/// the pushed-screen slot. When rendered outside a `NavigationLink`
+/// (misuse), falls back to rendering its children inline.
+enum RNWNavigationLinkDestinationView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("NavigationLinkDestination") { _, children, _ in
+            AnyView(children)
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/NavigationLinkLabelView.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// Sentinel view consumed by `NavigationLink` — its presence as a direct
+/// child of `<NavigationLink>` routes its contents into SwiftUI's `label:`
+/// slot (the always-visible tap target). When rendered outside a
+/// `NavigationLink` (misuse), falls back to rendering its children inline.
+enum RNWNavigationLinkLabelView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("NavigationLinkLabel") { _, children, _ in
+            AnyView(children)
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/NavigationLinkView.swift

@@ -0,0 +1,40 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `NavigationLink`. Walks `snapshot.children` to split out the
+/// `NavigationLinkLabel` (always-visible row) from `NavigationLinkDestination`
+/// (the pushed screen). The destination is rendered inside the
+/// `NavigationLink`'s closure so SwiftUI defers evaluation until push —
+/// but note: the destination subtree still lives in the React shadow tree
+/// and gets re-committed on every JS render. Acceptable for v1.
+enum RNWNavigationLinkView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("NavigationLink") { snapshot, _, bus in
+            var labelView: AnyView?
+            var destinationView: AnyView?
+            for child in snapshot.children {
+                switch child.viewName {
+                case "NavigationLinkLabel":
+                    labelView = RNWNodeRenderer.render(child, bus: bus)
+                case "NavigationLinkDestination":
+                    destinationView = RNWNodeRenderer.render(child, bus: bus)
+                default:
+                    // Untagged children are ignored. The expected shape is
+                    // `<NavigationLink><Label/><Destination/></NavigationLink>`;
+                    // anything else is a misuse, fall through silently.
+                    break
+                }
+            }
+            let label = labelView ?? AnyView(EmptyView())
+            let destination = destinationView ?? AnyView(EmptyView())
+            return AnyView(
+                NavigationLink {
+                    destination
+                } label: {
+                    label
+                }
+            )
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/NavigationStackView.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `NavigationStack`. Pushes are declarative via `NavigationLink`
+/// children in the JS tree — no JS-side stack or `path` binding in v1.
+/// The system back gesture and back button are auto-provided by SwiftUI
+/// on watchOS.
+enum RNWNavigationStackView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("NavigationStack") { _, children, _ in
+            AnyView(NavigationStack { children })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/PickerView.swift

@@ -0,0 +1,69 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `Picker`. Options live as a prop array (not children) so the
+/// JSON tree stays flat — each entry is `{value: String, label: String}`,
+/// rendered as a `Text` tagged by its value. Selection follows the same
+/// optimistic-binding pattern as `Toggle` / `TabView`: a local `@State`
+/// mirror flips immediately on tap, fires the JS callback, and converges
+/// to the next snapshot via `.onChange`.
+enum RNWPickerView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("Picker") { snapshot, _, bus in
+            AnyView(PickerImpl(snapshot: snapshot, bus: bus))
+        }
+    }
+}
+
+private struct PickerImpl: View {
+    let snapshot: RNWShadowNodeSnapshot
+    let bus: RNWEventBus
+
+    @State private var localSelection: String
+
+    init(snapshot: RNWShadowNodeSnapshot, bus: RNWEventBus) {
+        self.snapshot = snapshot
+        self.bus = bus
+        _localSelection = State(
+            initialValue: snapshot.props?.string("selection") ?? "")
+    }
+
+    var body: some View {
+        let remote = snapshot.props?.string("selection")
+        let label = snapshot.props?.string("label") ?? ""
+        let options = decodeOptions(snapshot.props?["options"])
+        let handlerId = snapshot.eventHandlers["onSelectionChange"]?.intValue
+
+        let binding = Binding<String>(
+            get: { localSelection },
+            set: { newValue in
+                localSelection = newValue
+                if let handlerId {
+                    bus.fire(handlerId, payload: newValue)
+                }
+            }
+        )
+
+        return Picker(label, selection: binding) {
+            ForEach(options, id: \.value) { option in
+                Text(option.label).tag(option.value)
+            }
+        }
+        .onChange(of: remote) { newRemote in
+            if let v = newRemote, v != localSelection {
+                localSelection = v
+            }
+        }
+    }
+
+    private func decodeOptions(_ raw: Any?) -> [(value: String, label: String)] {
+        guard let array = raw as? [Any] else { return [] }
+        return array.compactMap { entry in
+            guard let dict = entry as? [String: Any],
+                  let value = dict["value"] as? String else { return nil }
+            let label = (dict["label"] as? String) ?? value
+            return (value: value, label: label)
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/ProgressViewView.swift

@@ -0,0 +1,44 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `ProgressView`. With no `value` prop, renders the indeterminate
+/// spinner. With `value` (and optional `total`, default 1), renders a
+/// determinate bar / ring. `tint` lives as a prop rather than a generic
+/// modifier because `foregroundColor` doesn't reliably reach SwiftUI's
+/// progress accent.
+enum RNWProgressViewView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("ProgressView") { snapshot, _, _ in
+            let value = snapshot.props?.double("value")
+            let total = snapshot.props?.double("total") ?? 1
+            let style = snapshot.props?.string("style")
+            let tint = snapshot.props?.string("tint").flatMap(RNWColorParser.parse)
+
+            let base: AnyView
+            if let value {
+                base = AnyView(ProgressView(value: value, total: total))
+            } else {
+                base = AnyView(ProgressView())
+            }
+
+            switch style {
+            case "linear":
+                if let tint {
+                    return AnyView(base.progressViewStyle(LinearProgressViewStyle(tint: tint)))
+                }
+                return AnyView(base.progressViewStyle(.linear))
+            case "circular":
+                if let tint {
+                    return AnyView(base.progressViewStyle(CircularProgressViewStyle(tint: tint)))
+                }
+                return AnyView(base.progressViewStyle(.circular))
+            default:
+                if let tint {
+                    return AnyView(base.tint(tint))
+                }
+                return base
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/RadialGradientView.swift

@@ -0,0 +1,22 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWRadialGradientView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("RadialGradient") { snapshot, _, _ in
+            let colors = parseColors(snapshot.props?["colors"])
+            let center = parseUnitPoint(snapshot.props?["center"]) ?? .center
+            let startRadius = snapshot.props?.cgFloat("startRadius") ?? 0
+            let endRadius = snapshot.props?.cgFloat("endRadius") ?? 100
+            return AnyView(
+                RadialGradient(
+                    colors: colors,
+                    center: center,
+                    startRadius: startRadius,
+                    endRadius: endRadius
+                )
+            )
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/RectangleView.swift

@@ -0,0 +1,11 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWRectangleView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("Rectangle") { _, _, _ in
+            AnyView(Rectangle())
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/RoundedRectangleView.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWRoundedRectangleView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        r.register("RoundedRectangle") { snapshot, _, _ in
+            let cornerRadius = snapshot.props?.cgFloat("cornerRadius") ?? 0
+            let style: RoundedCornerStyle = snapshot.props?.string("style") == "circular"
+                ? .circular
+                : .continuous
+            return AnyView(RoundedRectangle(cornerRadius: cornerRadius, style: style))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Views/ScrollViewReaderView.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+enum RNWScrollViewReaderView {
+    @MainActor
+    static func register(into r: RNWViewRegistry) {
+        // TODO: the `ScrollViewProxy` is not yet bridged to JS. A follow-up
+        // will pair this with an `id()` modifier and a turbomodule
+        // `scrollTo` API so JS can drive `proxy.scrollTo(id)`.
+        r.register("ScrollViewReader") { _, children, _ in
+            AnyView(ScrollViewReader { _ in children })
+        }
+    }
+}