@appsent-co/react-native-watchos 0.1.0

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

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// Aggregator for the "Transforms" modifier unit. Each modifier in this
+/// category registers itself from `registerAll()` so `RNWRootView`
+/// wires the whole unit with a single call. One unit owns this file —
+/// fill the body as you add `RNW<Name>Modifier` files for this category.
+enum RNWTransformsModifiers {
+    @MainActor
+    static func registerAll() {
+        RNWRotationEffectModifier.register(into: .shared)
+        RNWRotation3DEffectModifier.register(into: .shared)
+        RNWScaleEffectModifier.register(into: .shared)
+        RNWTransformEffectModifier.register(into: .shared)
+        RNWProjectionEffectModifier.register(into: .shared)
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// Aggregator for the "Watch-specific" modifier unit. Each modifier in this
+/// category registers itself from `registerAll()` so `RNWRootView`
+/// wires the whole unit with a single call. One unit owns this file —
+/// fill the body as you add `RNW<Name>Modifier` files for this category.
+enum RNWWatchModifiers {
+    @MainActor
+    static func registerAll() {
+        RNWHandGestureShortcutModifier.register(into: .shared)
+        RNWSensoryFeedbackModifier.register(into: .shared)
+        RNWDigitalCrownRotationModifier.register(into: .shared)
+        RNWDigitalCrownAccessoryModifier.register(into: .shared)
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.redacted(reason:)`. Renders the subtree as a redacted
+/// placeholder (skeleton / loading state). `RedactionReasons.placeholder`
+/// is the only public reason on watchOS, so any value maps to it.
+enum RNWRedactedModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("redacted") { view, _, _ in
+            AnyView(view.redacted(reason: .placeholder))
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import SwiftUI
+
+/// SwiftUI `.refreshable { … }`. Marks the view as refreshable and fires
+/// the JS `handler` when the user triggers pull-to-refresh. The SwiftUI
+/// closure is async, but the bridge can't await JS work, so we fire the
+/// handler and return immediately — the refresh indicator dismisses once
+/// the (synchronous) fire returns. Available watchOS 9+.
+enum RNWRefreshableModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("refreshable") { view, params, ctx in
+            let handlerId = params.int("handler")
+            return AnyView(view.refreshable {
+                ctx.fire(handlerId)
+            })
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.renderingMode(_:)` — Image-only. `.template` recolours the
+/// image with the current `foregroundStyle`; `.original` keeps source
+/// colours. Passing `nil` (`"automatic"`) restores the system default.
+enum RNWRenderingModeModifier {
+    @MainActor
+    static func register(into r: RNWImageModifierRegistry) {
+        r.register("renderingMode") { image, params in
+            switch params.string("mode") {
+            case "template": return image.renderingMode(.template)
+            case "original": return image.renderingMode(.original)
+            default:         return image.renderingMode(nil)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.resizable()` — Image-only. Registered in the image-specific
+/// registry so the typed `Image → Image` chain stays intact (otherwise
+/// subsequent Image modifiers won't resolve after erasure).
+enum RNWResizableModifier {
+    @MainActor
+    static func register(into r: RNWImageModifierRegistry) {
+        r.register("resizable") { image, _ in
+            image.resizable()
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import SwiftUI
+
+/// SwiftUI `.rotation3DEffect(_:axis:anchor:)`. Rotates the view about the
+/// 3D axis `(x, y, z)` by `degrees`. Axis defaults to the Y axis `(0,1,0)`
+/// when none of the components are supplied. `anchorZ` / `perspective` are
+/// not bridged and use SwiftUI's defaults.
+enum RNWRotation3DEffectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("rotation3DEffect") { view, params, _ in
+            let degrees = params.double("degrees") ?? 0
+            let x = params.cgFloat("axisX")
+            let y = params.cgFloat("axisY")
+            let z = params.cgFloat("axisZ")
+            // Default to the Y axis only when no component is provided.
+            let axis: (x: CGFloat, y: CGFloat, z: CGFloat)
+            if x == nil, y == nil, z == nil {
+                axis = (0, 1, 0)
+            } else {
+                axis = (x ?? 0, y ?? 0, z ?? 0)
+            }
+            let anchor = RNWTransformAnchor.unitPoint(params.string("anchor"))
+            return AnyView(view.rotation3DEffect(
+                .degrees(degrees),
+                axis: axis,
+                anchor: anchor
+            ))
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import SwiftUI
+
+/// Maps a named anchor string to a `UnitPoint` for transform modifiers.
+/// Kept namespaced (rather than a free function) to avoid colliding with
+/// the gradient views' `parseUnitPoint`. Defaults to `.center`.
+enum RNWTransformAnchor {
+    static func unitPoint(_ s: String?) -> UnitPoint {
+        switch s {
+        case "top":            return .top
+        case "bottom":         return .bottom
+        case "leading":        return .leading
+        case "trailing":       return .trailing
+        case "topLeading":     return .topLeading
+        case "topTrailing":    return .topTrailing
+        case "bottomLeading":  return .bottomLeading
+        case "bottomTrailing": return .bottomTrailing
+        default:               return .center
+        }
+    }
+}
+
+/// SwiftUI `.rotationEffect(_:anchor:)`. Rotates the view in 2D by
+/// `degrees` about `anchor` without affecting its layout.
+enum RNWRotationEffectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("rotationEffect") { view, params, _ in
+            let degrees = params.double("degrees") ?? 0
+            let anchor = RNWTransformAnchor.unitPoint(params.string("anchor"))
+            return AnyView(view.rotationEffect(.degrees(degrees), anchor: anchor))
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import SwiftUI
+
+/// SwiftUI `.safeAreaInset(edge:alignment:spacing:content:)`. Reserves space
+/// along an edge and places the slot `content` there, shrinking the main
+/// content's safe area to fit. `top`/`bottom` use a `VerticalEdge` overload
+/// (horizontal alignment); `leading`/`trailing` use a `HorizontalEdge`
+/// overload (vertical alignment). Returns the view unchanged when no content
+/// slot is provided.
+enum RNWSafeAreaInsetModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("safeAreaInset") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else {
+                return view
+            }
+            let spacing = params.cgFloat("spacing")
+            switch params.string("edge") {
+            case "bottom":
+                return AnyView(view.safeAreaInset(
+                    edge: .bottom,
+                    alignment: RNWAlignmentParser.horizontal(
+                        params.string("alignment")),
+                    spacing: spacing
+                ) { body })
+            case "leading":
+                return AnyView(view.safeAreaInset(
+                    edge: .leading,
+                    alignment: RNWAlignmentParser.vertical(
+                        params.string("alignment")),
+                    spacing: spacing
+                ) { body })
+            case "trailing":
+                return AnyView(view.safeAreaInset(
+                    edge: .trailing,
+                    alignment: RNWAlignmentParser.vertical(
+                        params.string("alignment")),
+                    spacing: spacing
+                ) { body })
+            default: // "top"
+                return AnyView(view.safeAreaInset(
+                    edge: .top,
+                    alignment: RNWAlignmentParser.horizontal(
+                        params.string("alignment")),
+                    spacing: spacing
+                ) { body })
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.saturation(_:)`. Adjusts color saturation; `1` leaves the
+/// view unchanged, `0` is grayscale.
+enum RNWSaturationModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("saturation") { view, params, _ in
+            AnyView(view.saturation(params.double("value") ?? 1))
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.scaleEffect(x:y:anchor:)`. Scales the view's rendered output
+/// about `anchor`. `x` / `y` override the uniform `scale`; any axis left
+/// unset falls back to `scale`, then to `1` (identity).
+enum RNWScaleEffectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scaleEffect") { view, params, _ in
+            let uniform = params.cgFloat("scale") ?? 1
+            let x = params.cgFloat("x") ?? uniform
+            let y = params.cgFloat("y") ?? uniform
+            let anchor = RNWTransformAnchor.unitPoint(params.string("anchor"))
+            return AnyView(view.scaleEffect(x: x, y: y, anchor: anchor))
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+import SwiftUI
+
+/// SwiftUI `.scrollBounceBehavior(_:axes:)`. Configures the bounce
+/// behavior of scrollable views along the given axes.
+///
+/// `axes` is an `Axis.Set` (not `Edge.Set`), so it's parsed locally from
+/// `'horizontal'`/`'vertical'` (string or array). Defaults to
+/// `.vertical`, matching SwiftUI's default.
+///
+/// Gated to watchOS 10+. Returns the view unchanged on older systems.
+enum RNWScrollBounceBehaviorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollBounceBehavior") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                let axes = axisSet(params["axes"])
+                switch params.string("behavior") {
+                case "always":
+                    return AnyView(view.scrollBounceBehavior(.always, axes: axes))
+                case "basedOnSize":
+                    return AnyView(view.scrollBounceBehavior(.basedOnSize, axes: axes))
+                case "automatic":
+                    return AnyView(view.scrollBounceBehavior(.automatic, axes: axes))
+                default:
+                    return view
+                }
+            }
+            return view
+        }
+    }
+
+    /// Parse an `Axis.Set` from a single axis name or an array of them.
+    /// Defaults to `.vertical`.
+    private static func axisSet(_ value: Any?) -> Axis.Set {
+        if let s = value as? String { return single(s) }
+        if let arr = value as? [Any] {
+            var set: Axis.Set = []
+            for item in arr {
+                if let s = item as? String { set.insert(single(s)) }
+            }
+            return set.isEmpty ? .vertical : set
+        }
+        return .vertical
+    }
+
+    private static func single(_ s: String) -> Axis.Set {
+        switch s {
+        case "horizontal": return .horizontal
+        case "vertical":   return .vertical
+        default:           return .vertical
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.scrollClipDisabled(_:)`. Controls whether a scrollable view
+/// clips its content to its container bounds.
+///
+/// Gated to watchOS 10+. Returns the view unchanged on older systems.
+enum RNWScrollClipDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollClipDisabled") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.scrollClipDisabled(params.bool("disabled") ?? true))
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.scrollContentBackground(_:)`. Controls whether the scroll
+/// view's background is visible (e.g. hide a `List`/`Form` background to
+/// reveal a custom one underneath). Available watchOS 9+.
+enum RNWScrollContentBackgroundModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollContentBackground") { view, params, _ in
+            AnyView(view.scrollContentBackground(
+                RNWVisibilityParser.parse(params.string("visibility"))
+            ))
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.scrollDisabled(_:)`. Disables (or re-enables) scrolling of
+/// scrollable containers nested in this view. Available watchOS 9+.
+enum RNWScrollDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollDisabled") { view, params, _ in
+            AnyView(view.scrollDisabled(params.bool("disabled") ?? true))
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+import SwiftUI
+
+/// SwiftUI `.scrollDismissesKeyboard(_:)`. Configures how a scroll view
+/// dismisses the keyboard during interaction.
+///
+/// Gated to watchOS 10+: `ScrollDismissesKeyboardMode` is only reliably
+/// constructible on watchOS 10+, so on watchOS 9 the view is returned
+/// unchanged (the system default dismiss behavior still applies).
+enum RNWScrollDismissesKeyboardModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollDismissesKeyboard") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.scrollDismissesKeyboard(mode(params.string("mode"))))
+            }
+            return view
+        }
+    }
+
+    @available(watchOS 10.0, *)
+    private static func mode(_ s: String?) -> ScrollDismissesKeyboardMode {
+        switch s {
+        case "immediately":   return .immediately
+        case "interactively": return .interactively
+        case "never":         return .never
+        default:              return .automatic
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import SwiftUI
+
+/// SwiftUI `.scrollIndicators(_:)`. Sets the visibility of scroll
+/// indicators within scrollable containers nested in this view.
+/// Available watchOS 9+.
+///
+/// Note: `ScrollIndicatorVisibility` has a `never` case that the shared
+/// `RNWVisibilityParser` (`Visibility`) doesn't model, so the mapping is
+/// kept local here.
+enum RNWScrollIndicatorsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollIndicators") { view, params, _ in
+            AnyView(view.scrollIndicators(visibility(params.string("visibility"))))
+        }
+    }
+
+    private static func visibility(_ s: String?) -> ScrollIndicatorVisibility {
+        switch s {
+        case "visible": return .visible
+        case "hidden":  return .hidden
+        case "never":   return .never
+        default:        return .automatic
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `.scrollPosition(id:)`. Two-way binds the scroll position to a
+/// target id (pair with `scrollTargetLayout()` on the scrolled content).
+/// JS owns the source of truth via `id`; we keep a local `@State` mirror
+/// so the scroll position updates instantly, and report user-driven
+/// changes back through the `handler` callback. The next snapshot from JS
+/// converges the local state via `.onChange`.
+///
+/// Gated to watchOS 10+ — `scrollPosition(id:)` and the underlying
+/// scroll-target machinery don't exist on watchOS 9, so the modifier
+/// returns the view unchanged there.
+enum RNWScrollPositionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollPosition") { view, params, ctx in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.modifier(ScrollPositionMod(
+                    remoteId: params.string("id"),
+                    handlerId: params.int("handler"),
+                    bus: ctx.bus
+                )))
+            }
+            return view
+        }
+    }
+}
+
+/// Concrete `ViewModifier` holding the `@State` mirror. `RNWNodeRenderer`
+/// stamps `.id(node.tag)` on the host node, which keeps this modifier's
+/// `@State` stable across re-renders (same pattern as `ToggleView`).
+@available(watchOS 10.0, *)
+private struct ScrollPositionMod: ViewModifier {
+    let remoteId: String?
+    let handlerId: Int?
+    let bus: RNWEventBus
+
+    @State private var localId: String?
+
+    init(remoteId: String?, handlerId: Int?, bus: RNWEventBus) {
+        self.remoteId = remoteId
+        self.handlerId = handlerId
+        self.bus = bus
+        _localId = State(initialValue: remoteId)
+    }
+
+    func body(content: Content) -> some View {
+        content
+            .scrollPosition(id: Binding(
+                get: { localId },
+                set: { newValue in
+                    localId = newValue
+                    if let handlerId {
+                        // `newValue` is String? — payload survives the
+                        // bridge as a String, or nil when scrolled to top.
+                        bus.fire(handlerId, payload: newValue)
+                    }
+                }
+            ))
+            .onChange(of: remoteId) { newRemote in
+                if newRemote != localId {
+                    localId = newRemote
+                }
+            }
+    }
+}

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

@@ -0,0 +1,26 @@
+import SwiftUI
+
+/// SwiftUI `.scrollTargetBehavior(_:)`. Sets the scroll snapping behavior
+/// of the scrollable container: `.paging` snaps a page at a time,
+/// `.viewAligned` snaps to views inside a `scrollTargetLayout()`.
+///
+/// Gated to watchOS 10+ (introduced alongside the scroll-target APIs).
+/// Returns the view unchanged on older systems.
+enum RNWScrollTargetBehaviorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollTargetBehavior") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                switch params.string("behavior") {
+                case "paging":
+                    return AnyView(view.scrollTargetBehavior(.paging))
+                case "viewAligned":
+                    return AnyView(view.scrollTargetBehavior(.viewAligned))
+                default:
+                    return view
+                }
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import SwiftUI
+
+/// SwiftUI `.scrollTargetLayout()`. Marks a layout container (e.g. the
+/// `LazyVStack` inside a `ScrollView`) so its children act as scroll
+/// targets for `scrollTargetBehavior(.viewAligned)` / `scrollPosition`.
+///
+/// Gated to watchOS 10+. Returns the view unchanged on older systems.
+enum RNWScrollTargetLayoutModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("scrollTargetLayout") { view, _, _ in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.scrollTargetLayout())
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import SwiftUI
+
+/// SwiftUI `.searchCompletion(_:)`.
+///
+/// Associates a completion string with a search-suggestion view so tapping it
+/// fills the search field. Available on watchOS 9+ (the bridge deployment
+/// target), so no availability gate is needed.
+///
+/// Only takes visible effect when the view is presented as a search
+/// suggestion (inside a `.searchSuggestions { … }` slot / searchable scope).
+/// Applied to any other view the system treats it as an inert pass-through —
+/// matching SwiftUI's own behaviour.
+enum RNWSearchCompletionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("searchCompletion") { view, params, _ in
+            guard let completion = params.string("completion") else { return view }
+            return AnyView(view.searchCompletion(completion))
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.searchPresentationToolbarBehavior(_:)`.
+///
+/// LIMITATION: this modifier and its `SearchPresentationToolbarBehavior` type
+/// are `unavailable` on watchOS — they exist only on iOS 17.0+ / macOS 14.0+.
+/// There is no watchOS equivalent, so the applier is a documented no-op that
+/// returns the view unchanged. Registered (rather than dropped) so the
+/// `searchPresentationToolbarBehavior(...)` factory stays valid in
+/// cross-platform JS and silently does nothing on the watch.
+enum RNWSearchPresentationToolbarBehaviorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("searchPresentationToolbarBehavior") { view, _, _ in
+            // No watchOS API — intentional no-op (see type-level note above).
+            view
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// SwiftUI `.searchSuggestions { … }`.
+///
+/// Supplies the suggestion views for a searchable context. The ViewBuilder
+/// overload is available on watchOS 9.0+, which is this bridge's deployment
+/// target, so the modifier is applied unconditionally — no `#available`
+/// guard is needed (one would only emit an "always true" warning here).
+///
+/// The `content` param is a hoisted `__ModifierContent` slot resolved through
+/// `ctx`. When the slot is absent the view is returned unchanged. Note the
+/// suggestions only render when the view is also marked searchable; on a
+/// non-searchable view SwiftUI treats this as an inert pass-through.
+enum RNWSearchSuggestionsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("searchSuggestions") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else { return view }
+            return AnyView(view.searchSuggestions { body })
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.searchToolbarBehavior(_:)`.
+///
+/// LIMITATION: this modifier and its `SearchToolbarBehavior` type are
+/// `unavailable` on watchOS — they exist only on iOS 17.1+ / macOS 14.1+.
+/// There is no watchOS equivalent, so the applier is a documented no-op that
+/// returns the view unchanged. Registered (rather than dropped) so the
+/// `searchToolbarBehavior(...)` factory stays valid in cross-platform JS and
+/// silently does nothing on the watch instead of raising "unknown modifier".
+enum RNWSearchToolbarBehaviorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("searchToolbarBehavior") { view, _, _ in
+            // No watchOS API — intentional no-op (see type-level note above).
+            view
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+import SwiftUI
+
+/// SwiftUI `.searchable(text:prompt:)`.
+///
+/// LIMITATION: `.searchable` is declared `@available(watchOS, unavailable)`
+/// in SwiftUI — there is NO search-field affordance on watchOS, and the
+/// modifier cannot even be referenced when compiling for the watch (an
+/// `#available` *runtime* check does not lift a platform-level
+/// unavailability). There is therefore no valid watchOS form to fall back
+/// to, so this applier is a documented no-op: it returns the view
+/// unchanged and the `text` binding / `onChange` handler never fire.
+///
+/// The `$type` and JS surface (`text` mirror + `onChange`, modeled on the
+/// other bind modifiers) are kept so callers can express intent and so this
+/// applier can be upgraded in place if a future watchOS adds the API. The
+/// handler id and text param are read here purely to document the intended
+/// wiring; no SwiftUI search modifier is applied.
+enum RNWSearchableModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("searchable") { view, _, _ in
+            // `.searchable` is unavailable on watchOS — no-op (see doc above).
+            view
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// SwiftUI `.selectionDisabled(_:)` (watchOS 10+). Prevents the view (e.g.
+/// a `List` row) from being selected. Defaults to `true`. No-op on
+/// watchOS 9 (returns the view unchanged).
+enum RNWSelectionDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("selectionDisabled") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.selectionDisabled(params.bool("value") ?? true))
+            }
+            return view
+        }
+    }
+}