@appsent-co/react-native-watchos 0.1.0

package/apple/Sources/ReactNativeWatchOS/Modifiers/Monospaced.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.monospaced(_:)`. Renders text within the view with a fixed-
+/// width (monospaced) font. Defaults to active when `value` is omitted.
+enum RNWMonospacedModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("monospaced") { view, params, _ in
+            AnyView(view.monospaced(params.bool("value") ?? true))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/MonospacedDigit.swift

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.monospacedDigit()`. Keeps the default font but renders digits
+/// with uniform (monospaced) width so numbers don't shift horizontally as
+/// they change. Takes no parameters.
+enum RNWMonospacedDigitModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("monospacedDigit") { view, _, _ in
+            AnyView(view.monospacedDigit())
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/MoveDisabled.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.moveDisabled(_:)`. Prevents a row in an editable `List` /
+/// `ForEach` from being reordered. Defaults to `true` when unspecified.
+enum RNWMoveDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("moveDisabled") { view, params, _ in
+            AnyView(view.moveDisabled(params.bool("value") ?? true))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/MultilineTextAlignment.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.multilineTextAlignment(_:)`. Sets how multi-line text within
+/// the view is aligned. Defaults to `.center` for an absent/unrecognized
+/// value (matching `RNWAlignmentParser.textAlignment`).
+enum RNWMultilineTextAlignmentModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("multilineTextAlignment") { view, params, _ in
+            let alignment = RNWAlignmentParser.textAlignment(params.string("value"))
+            return AnyView(view.multilineTextAlignment(alignment))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/NavigationBarBackButtonHidden.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.navigationBarBackButtonHidden(_:)`. Hides the automatic back
+/// button on a view pushed inside a `NavigationStack`. Defaults to hiding
+/// (`value` absent → true) to match the JS factory's default argument.
+enum RNWNavigationBarBackButtonHiddenModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("navigationBarBackButtonHidden") { view, params, _ in
+            let hidden = params.bool("value") ?? true
+            return AnyView(view.navigationBarBackButtonHidden(hidden))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/NavigationDestination.swift

@@ -0,0 +1,64 @@
+import SwiftUI
+
+/// SwiftUI `.navigationDestination(isPresented:destination:)`. Pushes the
+/// resolved `content` slot onto the enclosing `NavigationStack` when
+/// `isPresented` is true. Available on watchOS 9.0+ (the deployment
+/// target), so no availability gate is required.
+///
+/// The presentation flag is bound bidirectionally with the same optimistic
+/// pattern as `ToggleView`: a local `@State` mirror flips instantly so a
+/// back-button pop updates immediately and fires the handler with the new
+/// value, then converges to the next JS snapshot via `.onChange(of:)`.
+enum RNWNavigationDestinationModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("navigationDestination") { view, params, ctx in
+            let body = ctx.content(params.string("content"))
+            return AnyView(view.modifier(RNWNavigationDestinationViewModifier(
+                remotePresented: params.bool("isPresented") ?? false,
+                handlerId: params.int("handler"),
+                bus: ctx.bus,
+                destinationBody: body
+            )))
+        }
+    }
+}
+
+private struct RNWNavigationDestinationViewModifier: ViewModifier {
+    let remotePresented: Bool
+    let handlerId: Int?
+    let bus: RNWEventBus
+    let destinationBody: AnyView?
+
+    @State private var localPresented: Bool
+
+    init(remotePresented: Bool, handlerId: Int?, bus: RNWEventBus, destinationBody: AnyView?) {
+        self.remotePresented = remotePresented
+        self.handlerId = handlerId
+        self.bus = bus
+        self.destinationBody = destinationBody
+        _localPresented = State(initialValue: remotePresented)
+    }
+
+    func body(content: Content) -> some View {
+        let binding = Binding<Bool>(
+            get: { localPresented },
+            set: { newValue in
+                localPresented = newValue
+                if let handlerId {
+                    bus.fire(handlerId, payload: newValue)
+                }
+            }
+        )
+
+        return content
+            .navigationDestination(isPresented: binding) {
+                destinationBody ?? AnyView(EmptyView())
+            }
+            .onChange(of: remotePresented) { newRemote in
+                if newRemote != localPresented {
+                    localPresented = newRemote
+                }
+            }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/NavigationTitle.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.navigationTitle(_:)`. Apply to a view inside a
+/// `NavigationStack` — typically the screen's root container — to show
+/// the string as the title at the top of the watchOS navigation bar.
+enum RNWNavigationTitleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("navigationTitle") { view, params, _ in
+            let title = params.string("text") ?? ""
+            return AnyView(view.navigationTitle(title))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/NavigationTransition.swift

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// SwiftUI `.navigationTransition(_:)` (watchOS 11+ / iOS 18+). Sets the
+/// transition used when this view is pushed/popped in a navigation stack.
+///
+/// LIMITATION (v1): `type: "zoom"` needs a `matchedTransitionSource` sharing
+/// a `@Namespace` with this view, which the bridge can't express across
+/// nodes — so `"zoom"` falls back to `.automatic`. On watchOS < 11 the whole
+/// modifier is a no-op (view passes through unchanged).
+enum RNWNavigationTransitionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("navigationTransition") { view, params, _ in
+            if #available(watchOS 11.0, *) {
+                // Both "automatic" and the unsupported "zoom" resolve to the
+                // automatic transition (see limitation above).
+                return AnyView(view.navigationTransition(.automatic))
+            }
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Offset.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.offset(x:y:)`. Shifts the view after layout without affecting
+/// the positions of surrounding views.
+enum RNWOffsetModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("offset") { view, params, _ in
+            AnyView(view.offset(
+                x: params.cgFloat("x") ?? 0,
+                y: params.cgFloat("y") ?? 0
+            ))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnAppear.swift

@@ -0,0 +1,11 @@
+import SwiftUI
+
+/// SwiftUI `.onAppear(perform:)`. Fires the JS `handler` when the view appears.
+enum RNWOnAppearModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onAppear") { view, params, ctx in
+            AnyView(view.onAppear { ctx.fire(params.int("handler")) })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnChange.swift

@@ -0,0 +1,60 @@
+import SwiftUI
+
+/// SwiftUI `.onChange(of:perform:)` (watchOS 7+ form). Value-driven: JS passes
+/// the observed `value` (string / number / bool) on every render, and the
+/// `handler` fires with the new value whenever it differs from the previous
+/// render. Implemented as a `ViewModifier` so SwiftUI tracks the value across
+/// commits via its own diffing.
+enum RNWOnChangeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onChange") { view, params, ctx in
+            AnyView(view.modifier(RNWOnChangeBridge(
+                value: RNWOnChangeValue(raw: params["value"]),
+                handlerId: params.int("handler"),
+                bus: ctx.bus
+            )))
+        }
+    }
+}
+
+/// Stable, comparable wrapper around the bridged JS value. `key` drives
+/// SwiftUI's `onChange(of:)` equality; `raw` is forwarded to JS unchanged so
+/// the handler receives the same primitive it observed.
+struct RNWOnChangeValue: Equatable {
+    let key: String
+    let raw: Any?
+
+    init(raw: Any?) {
+        self.raw = raw
+        switch raw {
+        case .none:
+            key = ""
+        case let s as String:
+            key = "s:" + s
+        case let n as NSNumber:
+            key = "n:" + n.stringValue
+        case let other?:
+            key = "x:" + String(describing: other)
+        }
+    }
+
+    static func == (lhs: RNWOnChangeValue, rhs: RNWOnChangeValue) -> Bool {
+        lhs.key == rhs.key
+    }
+}
+
+/// Fires `handlerId` with the new raw value whenever `value` changes between
+/// renders. `bus.fire` accepts String / NSNumber payloads as-is.
+struct RNWOnChangeBridge: ViewModifier {
+    let value: RNWOnChangeValue
+    let handlerId: Int?
+    let bus: RNWEventBus
+
+    func body(content: Content) -> some View {
+        content.onChange(of: value) { newValue in
+            guard let handlerId else { return }
+            bus.fire(handlerId, payload: newValue.raw)
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnDisappear.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.onDisappear(perform:)`. Fires the JS `handler` when the view
+/// disappears.
+enum RNWOnDisappearModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onDisappear") { view, params, ctx in
+            AnyView(view.onDisappear { ctx.fire(params.int("handler")) })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnGeometryChange.swift

@@ -0,0 +1,25 @@
+import SwiftUI
+
+/// SwiftUI `.onGeometryChange(for:of:action:)` (watchOS 11+ / iOS 16+),
+/// observing the view's `size`. Fires the JS handler with
+/// `{ width, height }` whenever the size changes. On watchOS < 11 this is a
+/// no-op (view passes through unchanged, handler never fires).
+enum RNWOnGeometryChangeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onGeometryChange") { view, params, ctx in
+            let handlerId = params.int("handler")
+            if #available(watchOS 11.0, *) {
+                return AnyView(view.onGeometryChange(for: CGSize.self) { proxy in
+                    proxy.size
+                } action: { size in
+                    ctx.fire(handlerId, [
+                        "width": size.width,
+                        "height": size.height,
+                    ])
+                })
+            }
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnLongPressGesture.swift

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.onLongPressGesture(minimumDuration:perform:)`. Fires the JS
+/// `handler` once the press is held for `minimumDuration` seconds (default
+/// 0.5, matching SwiftUI).
+enum RNWOnLongPressGestureModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onLongPressGesture") { view, params, ctx in
+            let minimumDuration = params.double("minimumDuration") ?? 0.5
+            let handlerId = params.int("handler")
+            return AnyView(view.onLongPressGesture(minimumDuration: minimumDuration) {
+                ctx.fire(handlerId)
+            })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnOpenURL.swift

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.onOpenURL(perform:)` (watchOS 9+). Fires the JS `handler` with
+/// the opened URL's absolute string. On older systems it returns the view
+/// unchanged.
+enum RNWOnOpenURLModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onOpenURL") { view, params, ctx in
+            let handlerId = params.int("handler")
+            if #available(watchOS 9.0, *) {
+                return AnyView(view.onOpenURL { url in
+                    ctx.fire(handlerId, url.absoluteString)
+                })
+            }
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnReceive.swift

@@ -0,0 +1,24 @@
+import Combine
+import SwiftUI
+
+/// SwiftUI `.onReceive(_:perform:)`.
+///
+/// LIMITATION: `.onReceive` takes an arbitrary Combine publisher, which has no
+/// JS equivalent. We map it to `NotificationCenter.default.publisher(for:)`
+/// keyed by a `name` string and fire the JS `handler` on each delivery. With
+/// no `name`, the modifier is a no-op (returns the view unchanged).
+enum RNWOnReceiveModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onReceive") { view, params, ctx in
+            guard let name = params.string("name") else { return view }
+            let handlerId = params.int("handler")
+            let publisher = NotificationCenter.default.publisher(
+                for: Notification.Name(name)
+            )
+            return AnyView(view.onReceive(publisher) { _ in
+                ctx.fire(handlerId)
+            })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnSubmit.swift

@@ -0,0 +1,24 @@
+import SwiftUI
+
+/// SwiftUI `.onSubmit(of:_:)`. Fires the JS `handler` when the user submits
+/// via the matching trigger. `triggers` maps 'text'/'search' to
+/// `SubmitTriggers` (default `.text`).
+enum RNWOnSubmitModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onSubmit") { view, params, ctx in
+            let handlerId = params.int("handler")
+            let triggers = parseTriggers(params.string("triggers"))
+            return AnyView(view.onSubmit(of: triggers) {
+                ctx.fire(handlerId)
+            })
+        }
+    }
+
+    private static func parseTriggers(_ s: String?) -> SubmitTriggers {
+        switch s {
+        case "search": return .search
+        default:       return .text
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/OnTapGesture.swift

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// SwiftUI `.onTapGesture(count:perform:)`. Fires the JS `handler` after
+/// `count` taps (default 1).
+enum RNWOnTapGestureModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("onTapGesture") { view, params, ctx in
+            let count = params.int("count") ?? 1
+            let handlerId = params.int("handler")
+            return AnyView(view.onTapGesture(count: count) {
+                ctx.fire(handlerId)
+            })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Opacity.swift

@@ -0,0 +1,11 @@
+import SwiftUI
+
+/// SwiftUI `.opacity(_:)`. Sets the transparency of the view (`0`…`1`).
+enum RNWOpacityModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("opacity") { view, params, _ in
+            AnyView(view.opacity(params.double("value") ?? 1))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Overlay.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.overlay(alignment:content:)`. Layers the modifier-content
+/// view(s) in front of the modified view. Resolves the content slot via
+/// `ctx.content`; when absent, returns the view unchanged.
+enum RNWOverlayModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("overlay") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else { return view }
+            let alignment = RNWAlignmentParser.alignment(params.string("alignment"))
+            return AnyView(view.overlay(alignment: alignment) { body })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Padding.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+
+/// SwiftUI `.padding(_:)`. Per-edge values accumulate on top of `all` /
+/// `horizontal` / `vertical` shortcuts — `{horizontal: 8, top: 12}` ⇒
+/// leading=trailing=8, top=12, bottom=0.
+enum RNWPaddingModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("padding") { view, params, _ in
+            var insets = EdgeInsets()
+            if let all = params.double("all") {
+                insets = EdgeInsets(
+                    top: all, leading: all, bottom: all, trailing: all)
+            }
+            if let h = params.double("horizontal") {
+                insets.leading = h
+                insets.trailing = h
+            }
+            if let v = params.double("vertical") {
+                insets.top = v
+                insets.bottom = v
+            }
+            if let t  = params.double("top")      { insets.top = t }
+            if let b  = params.double("bottom")   { insets.bottom = b }
+            if let l  = params.double("leading")  { insets.leading = l }
+            if let tr = params.double("trailing") { insets.trailing = tr }
+            return AnyView(view.padding(insets))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PickerStyle.swift

@@ -0,0 +1,21 @@
+import SwiftUI
+
+/// SwiftUI `.pickerStyle(_:)`. Maps the `style` string to a picker style.
+/// Unknown values fall back to `.automatic`.
+enum RNWPickerStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("pickerStyle") { view, params, _ in
+            switch params.string("style") {
+            case "navigationLink":
+                return AnyView(view.pickerStyle(.navigationLink))
+            case "wheel":
+                return AnyView(view.pickerStyle(.wheel))
+            case "inline":
+                return AnyView(view.pickerStyle(.inline))
+            default:
+                return AnyView(view.pickerStyle(.automatic))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Position.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.position(x:y:)`. Centers the view at an absolute point in its
+/// parent's coordinate space, ignoring its own layout-assigned position.
+enum RNWPositionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("position") { view, params, _ in
+            AnyView(view.position(
+                x: params.cgFloat("x") ?? 0,
+                y: params.cgFloat("y") ?? 0
+            ))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PreferredColorScheme.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.preferredColorScheme(_:)`. Sets the preferred `ColorScheme` for
+/// the enclosing presentation. A `nil`/absent `value` clears the preference
+/// so the presentation follows the system appearance.
+enum RNWPreferredColorSchemeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("preferredColorScheme") { view, params, _ in
+            // `parse` returns nil for a missing/null value, which maps to the
+            // `ColorScheme?` "no preference" case SwiftUI expects.
+            AnyView(view.preferredColorScheme(RNWColorSchemeModifier.parse(params.string("value"))))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PresentationBackground.swift

@@ -0,0 +1,23 @@
+import SwiftUI
+
+/// SwiftUI `.presentationBackground(_:)` / `.presentationBackground(_:){…}`.
+///
+/// LIMITATION: `presentationBackground` (both the shape-style and the
+/// `content`-closure overloads) is **iOS 16.4+ / macOS 13.3+ / tvOS only —
+/// not available on watchOS** (the symbol cannot be referenced here).
+/// watchOS sheets always use the system background. This modifier is
+/// registered as a no-op: it accepts the `style` / `content` params for
+/// cross-platform JS parity and returns the view unchanged.
+///
+/// Were it available, the implementation would resolve `style` through
+/// `RNWShapeStyleParser.parse(params.string("style"))` and the `content`
+/// slot through `ctx.content(params.string("content"))`.
+enum RNWPresentationBackgroundModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("presentationBackground") { view, _, _ in
+            // No-op on watchOS — `presentationBackground` is unavailable here.
+            view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PresentationCompactAdaptation.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.presentationCompactAdaptation(_:)`.
+///
+/// LIMITATION: `presentationCompactAdaptation` and the
+/// `PresentationAdaptation` type are **iOS 16.4+ / macOS 13.3+ / tvOS
+/// only — not available on watchOS** (watchOS has a single compact size
+/// class with no adaptive presentation styles, and the symbol cannot be
+/// referenced here). This modifier is registered as a no-op: it accepts
+/// the `adaptation` param for cross-platform JS parity and returns the
+/// view unchanged.
+enum RNWPresentationCompactAdaptationModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("presentationCompactAdaptation") { view, _, _ in
+            // No-op on watchOS — `presentationCompactAdaptation` is unavailable.
+            view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PresentationCornerRadius.swift

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.presentationCornerRadius(_:)`.
+///
+/// LIMITATION: `presentationCornerRadius` is **iOS 16.4+ / macOS 13.3+
+/// only — it is not available on watchOS** (the symbol cannot be
+/// referenced here). watchOS sheets use the system presentation shape and
+/// expose no corner-radius override, so this modifier is registered as a
+/// no-op: it accepts the `radius` param for cross-platform JS parity and
+/// returns the view unchanged.
+enum RNWPresentationCornerRadiusModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("presentationCornerRadius") { view, _, _ in
+            // No-op on watchOS — `presentationCornerRadius` is unavailable here.
+            view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PresentationDetents.swift

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.presentationDetents(_:)`.
+///
+/// LIMITATION: `presentationDetents` and the `PresentationDetent` type are
+/// **iOS 16+ / macOS 13+ only — they do not exist on watchOS** (sheets are
+/// always full-screen on watchOS, so there are no resting heights to
+/// configure). The symbol cannot even be referenced on this platform, so
+/// this modifier is registered as a no-op: it accepts the `detents` param
+/// for cross-platform JS parity and returns the view unchanged.
+enum RNWPresentationDetentsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("presentationDetents") { view, _, _ in
+            // No-op on watchOS — `presentationDetents` is unavailable here.
+            view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PresentationDragIndicator.swift

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.presentationDragIndicator(_:)`. Sets the visibility of the
+/// drag indicator on a sheet. `visibility` is parsed by
+/// `RNWVisibilityParser` (automatic / visible / hidden).
+///
+/// This API is available on watchOS 9+, so it applies on every supported
+/// deployment target — no `#available` fallback is needed.
+enum RNWPresentationDragIndicatorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("presentationDragIndicator") { view, params, _ in
+            let visibility = RNWVisibilityParser.parse(params.string("visibility"))
+            return AnyView(view.presentationDragIndicator(visibility))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/PrivacySensitive.swift

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.privacySensitive(_:)`. Marks the subtree as private content so
+/// the system can redact it when the device is in a privacy-sensitive state.
+/// Defaults to `true`.
+enum RNWPrivacySensitiveModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("privacySensitive") { view, params, _ in
+            AnyView(view.privacySensitive(params.bool("value") ?? true))
+        }
+    }
+}