@appsent-co/react-native-watchos 0.1.0

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

@@ -0,0 +1,74 @@
+import SwiftUI
+
+/// SwiftUI `.sensoryFeedback(_:trigger:)`. Plays haptic feedback whenever the
+/// JS `trigger` value changes between renders. Requires watchOS 10 — on older
+/// systems the view is returned unchanged.
+///
+/// The trigger is coerced to a stable `String` key (mirroring `Animation`'s
+/// value key) so any bridged scalar — string or number — drives the
+/// `Equatable` comparison SwiftUI uses to decide when to replay. Best-effort:
+/// the feedback fires once per distinct trigger value.
+///
+/// `feedback`: `"success"` / `"warning"` / `"error"` / `"selection"` /
+/// `"impact"`. Unrecognized values fall back to `.selection`.
+enum RNWSensoryFeedbackModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("sensoryFeedback") { view, params, _ in
+            guard #available(watchOS 10.0, *) else { return view }
+            let feedback = Self.feedback(for: params.string("feedback"))
+            let triggerKey = RNWSensoryTriggerKey(raw: params["trigger"])
+            return AnyView(view.modifier(
+                RNWSensoryFeedbackViewModifier(feedback: feedback, trigger: triggerKey)
+            ))
+        }
+    }
+
+    @available(watchOS 10.0, *)
+    private static func feedback(for raw: String?) -> SensoryFeedback {
+        switch raw {
+        case "success":
+            return .success
+        case "warning":
+            return .warning
+        case "error":
+            return .error
+        case "impact":
+            return .impact
+        default:
+            return .selection
+        }
+    }
+}
+
+/// Holds the resolved feedback + the current trigger key. SwiftUI replays the
+/// feedback when `trigger` changes across renders.
+@available(watchOS 10.0, *)
+private struct RNWSensoryFeedbackViewModifier: ViewModifier {
+    let feedback: SensoryFeedback
+    let trigger: RNWSensoryTriggerKey
+
+    func body(content: Content) -> some View {
+        content.sensoryFeedback(feedback, trigger: trigger)
+    }
+}
+
+/// Stable `Equatable`/`Hashable` wrapper over any bridged trigger scalar.
+/// Identical inputs always produce identical keys, so SwiftUI fires the
+/// feedback exactly when the JS value changes.
+private struct RNWSensoryTriggerKey: Equatable, Hashable {
+    let key: String
+
+    init(raw: Any?) {
+        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)
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.shadow(color:radius:x:y:)`. Draws a drop shadow. When `color`
+/// is omitted or unrecognized, falls through to `.shadow(radius:x:y:)` so
+/// SwiftUI's default translucent-black shadow color is used.
+enum RNWShadowModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("shadow") { view, params, _ in
+            let radius = params.cgFloat("radius") ?? 0
+            let x = params.cgFloat("x") ?? 0
+            let y = params.cgFloat("y") ?? 0
+            if let colorString = params.string("color"),
+               let color = RNWColorParser.parse(colorString) {
+                return AnyView(view.shadow(color: color, radius: radius, x: x, y: y))
+            }
+            return AnyView(view.shadow(radius: radius, x: x, y: y))
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+import SwiftUI
+
+/// SwiftUI `.sheet(isPresented:onDismiss:content:)`. Presents the resolved
+/// `content` slot modally when `isPresented` is true.
+///
+/// The presentation flag is bound bidirectionally with the same optimistic
+/// pattern as `ToggleView`: JS owns the source of truth (`isPresented`),
+/// but a local `@State` mirror flips instantly so an interactive
+/// (swipe-down) dismiss closes the sheet without waiting for the JS
+/// round-trip and fires the handler with the new value. The next snapshot
+/// from JS converges the local state via `.onChange(of:)`.
+enum RNWSheetModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("sheet") { view, params, ctx in
+            let body = ctx.content(params.string("content"))
+            return AnyView(view.modifier(RNWSheetViewModifier(
+                remotePresented: params.bool("isPresented") ?? false,
+                handlerId: params.int("handler"),
+                bus: ctx.bus,
+                sheetBody: body
+            )))
+        }
+    }
+}
+
+private struct RNWSheetViewModifier: ViewModifier {
+    let remotePresented: Bool
+    let handlerId: Int?
+    let bus: RNWEventBus
+    let sheetBody: AnyView?
+
+    @State private var localPresented: Bool
+
+    init(remotePresented: Bool, handlerId: Int?, bus: RNWEventBus, sheetBody: AnyView?) {
+        self.remotePresented = remotePresented
+        self.handlerId = handlerId
+        self.bus = bus
+        self.sheetBody = sheetBody
+        _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
+            .sheet(isPresented: binding) {
+                sheetBody ?? AnyView(EmptyView())
+            }
+            .onChange(of: remotePresented) { newRemote in
+                if newRemote != localPresented {
+                    localPresented = newRemote
+                }
+            }
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.simultaneousGesture(_:)`. Recognizes alongside the view's own
+/// gestures. Same v1 limitation as `gesture`: only `tap`/`longPress` bridge.
+enum RNWSimultaneousGestureModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("simultaneousGesture") { view, params, ctx in
+            RNWGestureSupport.apply(.simultaneous, to: view, params: params, ctx: ctx)
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.springLoadingBehavior(_:)` (watchOS 10+). Controls whether a
+/// control spring-loads when a dragged item hovers over it. On watchOS 9 the
+/// API is unavailable, so the view is returned unchanged.
+enum RNWSpringLoadingBehaviorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("springLoadingBehavior") { view, params, _ in
+            guard #available(watchOS 10.0, *) else { return view }
+            let behavior: SpringLoadingBehavior
+            switch params.string("value") {
+            case "enabled":  behavior = .enabled
+            case "disabled": behavior = .disabled
+            default:         behavior = .automatic
+            }
+            return AnyView(view.springLoadingBehavior(behavior))
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.strikethrough(_:color:)`. Applies a strikethrough to text
+/// within the view. Defaults to active when `value` is omitted; an absent
+/// or unrecognized `color` falls back to the text's foreground color (nil).
+enum RNWStrikethroughModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("strikethrough") { view, params, _ in
+            let isActive = params.bool("value") ?? true
+            let color = params.string("color").flatMap(RNWColorParser.parse)
+            return AnyView(view.strikethrough(isActive, color: color))
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+import SwiftUI
+
+/// SwiftUI `.submitLabel(_:)`. Sets the semantic label rendered on the
+/// keyboard's submit key. `SubmitLabel` and this modifier are watchOS 9+,
+/// which matches the deployment target, so no availability gate is needed.
+/// An unrecognized `label` falls back to `.done`.
+enum RNWSubmitLabelModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("submitLabel") { view, params, _ in
+            AnyView(view.submitLabel(parse(params.string("label"))))
+        }
+    }
+
+    private static func parse(_ s: String?) -> SubmitLabel {
+        switch s {
+        case "done":     return .done
+        case "go":       return .go
+        case "send":     return .send
+        case "join":     return .join
+        case "route":    return .route
+        case "search":   return .search
+        case "return":   return .return
+        case "next":     return .next
+        case "continue": return .continue
+        default:         return .done
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.swipeActions(edge:allowsFullSwipe:) { … }`. Renders the content
+/// slot (the action `Button`s) as swipe actions on a list row. `edge` maps
+/// 'leading'/'trailing' to `HorizontalEdge` (default `.trailing`);
+/// `allowsFullSwipe` defaults to true. No-ops when no content was provided.
+enum RNWSwipeActionsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("swipeActions") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else { return view }
+            let edge: HorizontalEdge = params.string("edge") == "leading" ? .leading : .trailing
+            let allowsFullSwipe = params.bool("allowsFullSwipe") ?? true
+            return AnyView(view.swipeActions(edge: edge, allowsFullSwipe: allowsFullSwipe) {
+                body
+            })
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// SwiftUI `.tabItem { … }` (watchOS 7+). Sets the tab-bar label for a view
+/// used as a page inside a `TabView`. The `content` slot is resolved via
+/// `ctx`; with no content provided the view is returned unchanged.
+enum RNWTabItemModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("tabItem") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else {
+                return view
+            }
+            return AnyView(view.tabItem { body })
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import SwiftUI
+
+/// SwiftUI `.tabViewStyle(_:)`. Maps the `style` string to a tab-view
+/// style. `.page` / `.carousel` are watchOS 7+ and `.verticalPage` is
+/// watchOS 9+ — all available on the watchOS 9 deployment target, so no
+/// availability gating is required. Unknown values fall back to
+/// `.automatic`.
+enum RNWTabViewStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("tabViewStyle") { view, params, _ in
+            switch params.string("style") {
+            case "page":
+                return AnyView(view.tabViewStyle(.page))
+            case "verticalPage":
+                // `.verticalPage` is watchOS 10+; fall back to `.page` below.
+                if #available(watchOS 10.0, *) {
+                    return AnyView(view.tabViewStyle(.verticalPage))
+                }
+                return AnyView(view.tabViewStyle(.page))
+            case "carousel":
+                return AnyView(view.tabViewStyle(.carousel))
+            default:
+                return AnyView(view.tabViewStyle(.automatic))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.tag(_:)`. Tags the view with a `String` value used by
+/// selection-driven containers (`Picker`, `TabView`) to match the bound
+/// selection. The bridge models tag/selection values as strings.
+enum RNWTagModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("tag") { view, params, _ in
+            AnyView(view.tag(params.string("value") ?? ""))
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.task(_:)`. Runs once when the view appears; the bridged async
+/// task simply invokes the JS `handler` (it does no awaiting itself).
+enum RNWTaskModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("task") { view, params, ctx in
+            let handlerId = params.int("handler")
+            return AnyView(view.task {
+                ctx.fire(handlerId)
+            })
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.textCase(_:)`. Applies a case transform to text within the
+/// view. `'uppercase'`/`'lowercase'` map to the matching `Text.Case`;
+/// anything else (including an explicit `null`) passes `nil`, which clears
+/// any inherited transform.
+enum RNWTextCaseModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("textCase") { view, params, _ in
+            let textCase: Text.Case?
+            switch params.string("value") {
+            case "uppercase": textCase = .uppercase
+            case "lowercase": textCase = .lowercase
+            default:          textCase = nil
+            }
+            return AnyView(view.textCase(textCase))
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+import SwiftUI
+import WatchKit
+
+/// SwiftUI `.textContentType(_:)`. On watchOS this takes a `WKTextContentType`
+/// (from WatchKit), hinting the system about the field's semantic content for
+/// autofill / QuickType. The modifier overload is watchOS 6+, well under the
+/// deployment target.
+///
+/// LIMITED: watchOS does not expose the full `UITextContentType` surface, so
+/// only the broadly-available cases below are mapped. An unrecognized `type`
+/// leaves the view unchanged. Every mapped case exists at the watchOS 9
+/// deployment target.
+enum RNWTextContentTypeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("textContentType") { view, params, _ in
+            guard let type = parse(params.string("type")) else { return view }
+            return AnyView(view.textContentType(type))
+        }
+    }
+
+    private static func parse(_ s: String?) -> WKTextContentType? {
+        switch s {
+        case "username":        return .username
+        case "password":        return .password
+        case "newPassword":     return .newPassword
+        case "oneTimeCode":     return .oneTimeCode
+        case "emailAddress":    return .emailAddress
+        case "telephoneNumber": return .telephoneNumber
+        case "name":            return .name
+        case "URL":             return .URL
+        default:                return nil
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.textFieldStyle(_:)`. watchOS only ships `DefaultTextFieldStyle`
+/// (`.automatic`); `.plain` and `.roundedBorder` are unavailable on watchOS,
+/// so every value maps to `.automatic`. The `style` param is accepted for
+/// cross-platform parity but has no other effect here.
+enum RNWTextFieldStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("textFieldStyle") { view, _, _ in
+            AnyView(view.textFieldStyle(.automatic))
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import SwiftUI
+
+/// SwiftUI `.textInputAutocapitalization(_:)`. Controls how text entry
+/// auto-capitalizes. `TextInputAutocapitalization` and this modifier are
+/// watchOS 9+, which equals the deployment target, so no availability gate is
+/// required. An unrecognized `value` leaves the view unchanged.
+enum RNWTextInputAutocapitalizationModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("textInputAutocapitalization") { view, params, _ in
+            guard let value = parse(params.string("value")) else { return view }
+            return AnyView(view.textInputAutocapitalization(value))
+        }
+    }
+
+    private static func parse(_ s: String?) -> TextInputAutocapitalization? {
+        switch s {
+        case "never":      return .never
+        case "words":      return .words
+        case "sentences":  return .sentences
+        case "characters": return .characters
+        default:           return nil
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.textScale(_:)`. Scales text relative to the inherited font —
+/// `'default'` (standard) or `'secondary'` (relatively smaller).
+///
+/// `Text.Scale` and the `textScale(_:)` modifier are watchOS 11.0+, so
+/// this is gated with `#available`. On earlier versions the view is
+/// returned unchanged (no-op).
+enum RNWTextScaleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("textScale") { view, params, _ in
+            guard #available(watchOS 11.0, *) else { return view }
+            let scale: Text.Scale =
+                params.string("value") == "secondary" ? .secondary : .default
+            return AnyView(view.textScale(scale))
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.tint(_:)`. Sets the tint color applied to controls and accessory
+/// content within the view. Resolves `color` via `RNWColorParser`; leaves the
+/// view unchanged when the string is unrecognized.
+enum RNWTintModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("tint") { view, params, _ in
+            guard let colorString = params.string("color"),
+                  let color = RNWColorParser.parse(colorString) else {
+                return view
+            }
+            return AnyView(view.tint(color))
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.toggleStyle(_:)`. Maps the `style` string to a toggle style.
+/// Unknown values fall back to `.automatic`.
+enum RNWToggleStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toggleStyle") { view, params, _ in
+            switch params.string("style") {
+            case "button":
+                return AnyView(view.toggleStyle(.button))
+            case "switch":
+                return AnyView(view.toggleStyle(.switch))
+            default:
+                return AnyView(view.toggleStyle(.automatic))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// SwiftUI `.toolbar { content }`. Adds toolbar items to a view inside a
+/// `NavigationStack`. The `content` slot (resolved via `ctx.content`)
+/// supplies the toolbar body.
+///
+/// LIMITATION: watchOS exposes only a narrow set of toolbar placements, so
+/// this keeps it simple — the resolved content is handed to the trailing
+/// `toolbar { }` builder and the system chooses placement. Per-item
+/// `ToolbarItemPlacement` control is not exposed. When no content slot is
+/// present the view is returned unchanged.
+enum RNWToolbarModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbar") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else {
+                return view
+            }
+            return AnyView(view.toolbar { body })
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+import SwiftUI
+
+/// Maps a JS `bars` string to a `ToolbarPlacement` for the `for:` argument of
+/// the toolbar modifiers. Only `.automatic` and `.navigationBar` are used:
+/// they are the placements honored on watchOS (watchOS 9 safe). Unknown values
+/// fall back to `.automatic`. Defined here and reused by the other toolbar
+/// modifiers in this unit.
+enum RNWToolbarPlacement {
+    static func parse(_ s: String?) -> ToolbarPlacement {
+        switch s {
+        case "navigationBar": return .navigationBar
+        default:              return .automatic
+        }
+    }
+}
+
+/// SwiftUI `.toolbarBackground(_:for:)` (watchOS 10+). Sets the background
+/// shape style of the navigation bar. The `style` param is resolved by
+/// `RNWShapeStyleParser` (named/hex color, hierarchical level, `tint`, or a
+/// watchOS-10+ material). Returns the view unchanged on watchOS 9.
+enum RNWToolbarBackgroundModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbarBackground") { view, params, _ in
+            guard let style = RNWShapeStyleParser.parse(params.string("style")) else {
+                return view
+            }
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.toolbarBackground(
+                    style,
+                    for: RNWToolbarPlacement.parse(params.string("bars"))
+                ))
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import SwiftUI
+
+/// SwiftUI `.toolbarColorScheme(_:for:)` (watchOS 10+). Forces a `ColorScheme`
+/// on the navigation bar; a missing/`null` `colorScheme` passes `nil` to clear
+/// the override. Returns the view unchanged on watchOS 9.
+enum RNWToolbarColorSchemeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbarColorScheme") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                let scheme: ColorScheme?
+                switch params.string("colorScheme") {
+                case "light": scheme = .light
+                case "dark":  scheme = .dark
+                default:      scheme = nil
+                }
+                return AnyView(view.toolbarColorScheme(
+                    scheme,
+                    for: RNWToolbarPlacement.parse(params.string("bars"))
+                ))
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// SwiftUI `.toolbarTitleDisplayMode(_:)` (watchOS 10+). Controls how the
+/// navigation title is displayed: `automatic`, `inline`, or `large`. Returns
+/// the view unchanged on watchOS 9.
+enum RNWToolbarTitleDisplayModeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbarTitleDisplayMode") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                let mode: ToolbarTitleDisplayMode
+                switch params.string("mode") {
+                case "inline": mode = .inline
+                case "large":  mode = .large
+                default:       mode = .automatic
+                }
+                return AnyView(view.toolbarTitleDisplayMode(mode))
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// SwiftUI `.toolbarTitleMenu { … }` (watchOS 9+). Populates the menu shown
+/// from the navigation title. The `content` slot is resolved via `ctx`; with
+/// no content provided the view is returned unchanged.
+enum RNWToolbarTitleMenuModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbarTitleMenu") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else {
+                return view
+            }
+            return AnyView(view.toolbarTitleMenu { body })
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import SwiftUI
+
+/// SwiftUI bar visibility. The newer `.toolbarVisibility(_:for:)` (watchOS 11+)
+/// is intentionally not referenced so this compiles against the watchOS 9
+/// deployment target; instead it uses the watchOS-9 `.toolbar(_ Visibility,
+/// for:)`, which is the API `.toolbarVisibility` later renamed. `visibility`
+/// is resolved by `RNWVisibilityParser` (`automatic`/`visible`/`hidden`).
+enum RNWToolbarVisibilityModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("toolbarVisibility") { view, params, _ in
+            AnyView(view.toolbar(
+                RNWVisibilityParser.parse(params.string("visibility")),
+                for: RNWToolbarPlacement.parse(params.string("bars"))
+            ))
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.tracking(_:)`. Like `kerning`, but also adds spacing after
+/// the final character; takes precedence over `kerning` when both are
+/// set. Registered in the generic registry. Defaults to `0` when absent.
+enum RNWTrackingModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("tracking") { view, params, _ in
+            AnyView(view.tracking(params.cgFloat("value") ?? 0))
+        }
+    }
+}