@appsent-co/react-native-watchos 0.1.0

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

@@ -0,0 +1,28 @@
+import SwiftUI
+
+/// Builds a `CGAffineTransform` from the bridged `a,b,c,d,tx,ty` params.
+/// Omitted components default to the identity matrix (`a = d = 1`).
+/// Shared by `transformEffect` and `projectionEffect`.
+enum RNWAffineTransform {
+    static func make(from params: [String: Any]) -> CGAffineTransform {
+        CGAffineTransform(
+            a: params.cgFloat("a") ?? 1,
+            b: params.cgFloat("b") ?? 0,
+            c: params.cgFloat("c") ?? 0,
+            d: params.cgFloat("d") ?? 1,
+            tx: params.cgFloat("tx") ?? 0,
+            ty: params.cgFloat("ty") ?? 0
+        )
+    }
+}
+
+/// SwiftUI `.transformEffect(_:)`. Applies an arbitrary 2D affine
+/// transform to the view's rendered output (layout is unaffected).
+enum RNWTransformEffectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("transformEffect") { view, params, _ in
+            AnyView(view.transformEffect(RNWAffineTransform.make(from: params)))
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import SwiftUI
+
+/// SwiftUI `.transition(_:)`. Maps the JS `type` preset to an
+/// `AnyTransition`; `move` additionally reads an `edge` ('top'/'bottom'/
+/// 'leading'/'trailing', defaulting to `.bottom`).
+enum RNWTransitionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("transition") { view, params, _ in
+            let type = params.string("type") ?? "opacity"
+            return AnyView(view.transition(make(type: type, edge: params.string("edge"))))
+        }
+    }
+
+    private static func make(type: String, edge: String?) -> AnyTransition {
+        switch type {
+        case "slide":    return .slide
+        case "scale":    return .scale
+        case "identity": return .identity
+        case "move":     return .move(edge: parseEdge(edge))
+        default:         return .opacity
+        }
+    }
+
+    private static func parseEdge(_ s: String?) -> Edge {
+        switch s {
+        case "top":      return .top
+        case "leading":  return .leading
+        case "trailing": return .trailing
+        default:         return .bottom
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.truncationMode(_:)`. Controls where text within the view is
+/// truncated when it doesn't fit. Defaults to `.tail` (SwiftUI's default)
+/// for an absent/unrecognized mode.
+enum RNWTruncationModeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("truncationMode") { view, params, _ in
+            let mode: Text.TruncationMode
+            switch params.string("mode") {
+            case "head":   mode = .head
+            case "middle": mode = .middle
+            default:       mode = .tail
+            }
+            return AnyView(view.truncationMode(mode))
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.underline(_:color:)`. Applies an underline 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 RNWUnderlineModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("underline") { view, params, _ in
+            let isActive = params.bool("value") ?? true
+            let color = params.string("color").flatMap(RNWColorParser.parse)
+            return AnyView(view.underline(isActive, color: color))
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.unredacted()`. Opts the subtree out of redaction applied by an
+/// ancestor `.redacted(reason:)`, rendering its real content.
+enum RNWUnredactedModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("unredacted") { view, _, _ in
+            AnyView(view.unredacted())
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.zIndex(_:)`. Sets the front-to-back ordering of this view among
+/// overlapping siblings in the same container. Defaults to `0`.
+enum RNWZIndexModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("zIndex") { view, params, _ in
+            AnyView(view.zIndex(params.double("value") ?? 0))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/RNWRootView.swift

@@ -0,0 +1,141 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI renderer over `ReactNativeWatchOSHost.root`. Per-view-type
+/// dispatch lives in `RNWNodeRenderer` + the view/modifier registries.
+public struct RNWRootView: View {
+    @ObservedObject private var host: ReactNativeWatchOSHost
+
+    public init(host: ReactNativeWatchOSHost) {
+        Self.bootstrap()
+        self.host = host
+    }
+
+    public var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            ForEach(host.root, id: \.tag) { node in
+                RNWNodeRenderer.render(node, bus: host.eventBus)
+            }
+        }
+    }
+
+    // MARK: - One-shot built-in registration
+    //
+    // Lazy (not `+load`) so consumers can pre-register their own builders
+    // before the built-ins land. `static let` gives dispatch-once for free.
+
+    private static let bootstrapOnce: Void = {
+        RNWTextView.register(into: .shared)
+        RNWVStackView.register(into: .shared)
+        RNWHStackView.register(into: .shared)
+        RNWLazyVStackView.register(into: .shared)
+        RNWLazyHStackView.register(into: .shared)
+        RNWZStackView.register(into: .shared)
+        RNWGroupView.register(into: .shared)
+        RNWSpacerView.register(into: .shared)
+        RNWDividerView.register(into: .shared)
+        RNWRectangleView.register(into: .shared)
+        RNWRoundedRectangleView.register(into: .shared)
+        RNWCircleView.register(into: .shared)
+        RNWEllipseView.register(into: .shared)
+        RNWCapsuleView.register(into: .shared)
+        RNWColorView.register(into: .shared)
+        RNWScrollViewView.register(into: .shared)
+        RNWScrollViewReaderView.register(into: .shared)
+        RNWViewThatFitsView.register(into: .shared)
+        RNWGeometryReaderView.register(into: .shared)
+        RNWButtonView.register(into: .shared)
+        RNWToggleView.register(into: .shared)
+        RNWSliderView.register(into: .shared)
+        RNWStepperView.register(into: .shared)
+        RNWPickerView.register(into: .shared)
+        RNWDatePickerView.register(into: .shared)
+        RNWTextFieldView.register(into: .shared)
+        RNWSecureFieldView.register(into: .shared)
+        RNWImageView.register(into: .shared)
+        RNWAsyncImageView.register(into: .shared)
+        RNWAsyncImageImageView.register(into: .shared)
+        RNWAsyncImagePhaseEmptyView.register(into: .shared)
+        RNWAsyncImagePhaseSuccessView.register(into: .shared)
+        RNWAsyncImagePhaseFailureView.register(into: .shared)
+        RNWLabelView.register(into: .shared)
+        RNWListView.register(into: .shared)
+        RNWSectionView.register(into: .shared)
+        RNWSectionHeaderView.register(into: .shared)
+        RNWSectionFooterView.register(into: .shared)
+        RNWFormView.register(into: .shared)
+        RNWTabViewView.register(into: .shared)
+        RNWNavigationStackView.register(into: .shared)
+        RNWNavigationLinkView.register(into: .shared)
+        RNWNavigationLinkLabelView.register(into: .shared)
+        RNWNavigationLinkDestinationView.register(into: .shared)
+        RNWProgressViewView.register(into: .shared)
+        RNWGaugeView.register(into: .shared)
+        RNWEmptyViewView.register(into: .shared)
+        RNWLazyVGridView.register(into: .shared)
+        RNWLazyHGridView.register(into: .shared)
+        RNWGridView.register(into: .shared)
+        RNWGridRowView.register(into: .shared)
+        RNWLabeledContentView.register(into: .shared)
+        RNWLabeledContentLabelView.register(into: .shared)
+        RNWLabeledContentContentView.register(into: .shared)
+        RNWContentUnavailableView.register(into: .shared)
+        RNWContentUnavailableLabelView.register(into: .shared)
+        RNWContentUnavailableDescriptionView.register(into: .shared)
+        RNWContentUnavailableActionsView.register(into: .shared)
+        RNWLinkView.register(into: .shared)
+        RNWShareLinkView.register(into: .shared)
+        RNWTimelineViewView.register(into: .shared)
+        RNWLinearGradientView.register(into: .shared)
+        RNWRadialGradientView.register(into: .shared)
+        RNWAngularGradientView.register(into: .shared)
+        // Hosts sheet/overlay/toolbar bodies.
+        RNWModifierContentView.register(into: .shared)
+
+        RNWPaddingModifier.register(into: .shared)
+        RNWBackgroundModifier.register(into: .shared)
+        RNWForegroundColorModifier.register(into: .shared)
+        RNWFontModifier.register(into: .shared)
+        RNWAspectRatioModifier.register(into: .shared)
+        RNWFrameModifier.register(into: .shared)
+        RNWAnimationModifier.register(into: .shared)
+        RNWNavigationTitleModifier.register(into: .shared)
+
+        // Image-specific — kept on the Image-typed chain so subsequent
+        // Image-only modifiers stay applicable.
+        RNWResizableModifier.register(into: .shared)
+        RNWRenderingModeModifier.register(into: .shared)
+        RNWInterpolationModifier.register(into: .shared)
+        RNWAntialiasedModifier.register(into: .shared)
+
+        RNWLayoutModifiers.registerAll()
+        RNWStylingModifiers.registerAll()
+        RNWTextModifiers.registerAll()
+        RNWInteractionModifiers.registerAll()
+        RNWWatchModifiers.registerAll()
+        RNWNavigationModifiers.registerAll()
+        RNWListsModifiers.registerAll()
+        RNWComponentStylesModifiers.registerAll()
+        RNWInputModifiers.registerAll()
+        RNWImageSymbolModifiers.registerAll()
+        RNWAccessibilityModifiers.registerAll()
+        RNWFiltersModifiers.registerAll()
+        RNWTransformsModifiers.registerAll()
+        RNWScrollModifiers.registerAll()
+        RNWToolbarModifiers.registerAll()
+        RNWPresentationModifiers.registerAll()
+        RNWContainerGridModifiers.registerAll()
+        RNWThemeModifiers.registerAll()
+        RNWControlsPolishModifiers.registerAll()
+        RNWTextPolishModifiers.registerAll()
+        RNWSearchModifiers.registerAll()
+        RNWGeometryModifiers.registerAll()
+        RNWGesturesModifiers.registerAll()
+        RNWEnvironmentModifiers.registerAll()
+        RNWGlassModifiers.registerAll()
+    }()
+
+    private static func bootstrap() {
+        _ = bootstrapOnce
+    }
+}

package/apple/Sources/ReactNativeWatchOS/ReactNativeWatchOS.swift

@@ -0,0 +1,290 @@
+import Foundation
+import ReactNativeWatchOSCxx
+
+public struct LogEntry: Identifiable, Sendable, Equatable {
+    public let id = UUID()
+    public let level: String
+    public let message: String
+    public let timestamp: Date
+}
+
+/// Public Swift facade for the watchOS Hermes runtime.
+@MainActor
+public final class ReactNativeWatchOSHost: ObservableObject {
+    /// Timestamp of the most recent `error`-level log. Drives the error
+    /// toast. Resets on the next successful bundle reload; otherwise
+    /// persists so a dismissed toast re-triggers on the next error.
+    @Published public internal(set) var lastErrorAt: Date?
+
+    /// Latest committed shadow tree. Empty until the first `completeRoot()`.
+    @Published public private(set) var root: [RNWShadowNodeSnapshot] = []
+
+    /// Swift → JS event dispatcher. Forwards to `RNWHermesHost.fireEvent`.
+    public let eventBus: RNWEventBus
+
+    /// Fires when JS invokes `globalThis.__RNW_RELOAD()` (Fast Refresh
+    /// full-reload path). The view wires this to its `load()` task.
+    public var onReloadRequest: (() -> Void)?
+
+    // Swapped out on every reload so the previous bundle's JS heap (modules,
+    // fibers, timers, websockets) and the native UIManager registry get
+    // fully torn down. See `recreateHost`.
+    private var host: RNWHermesHost
+    // Indirection box so the public `eventBus` closure can be built once
+    // and still reach the *current* host after a reload swap. The closure
+    // fires from SwiftUI action closures (any thread), so it can't read
+    // the @MainActor `host` property directly.
+    private let hostRef = HostRef()
+    private var notificationObservers: [NSObjectProtocol] = []
+    private var hasLoadedOnce = false
+
+    public init() {
+        let host = RNWHermesHost()
+        self.host = host
+        self.hostRef.current = host
+
+        let hostRef = self.hostRef
+        self.eventBus = RNWEventBus { handlerId, payload in
+            // `fireEvent` hops to the JS queue internally — safe from main.
+            hostRef.current?.fireEvent(withHandlerId: handlerId, payload: payload)
+        }
+        wireHost()
+    }
+
+    deinit {
+        for observer in notificationObservers {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+
+    /// Install the per-host callbacks (console / commit / reload) and the
+    /// `RNWEventEmitterFireEvent` observer. Called from `init` and again
+    /// from `recreateHost` after a reload swaps the runtime.
+    private func wireHost() {
+        // Drop the previous observer first — its block routes through
+        // `hostRef` so it would still target the right host, but every
+        // reload would otherwise add another fan-out subscriber.
+        for observer in notificationObservers {
+            NotificationCenter.default.removeObserver(observer)
+        }
+        notificationObservers.removeAll()
+
+        // RCTEventEmitter posts here from `sendEventWithName:body:`.
+        // Forward into `globalThis.__RNW_EVENTS.dispatchEvent`.
+        let hostRef = self.hostRef
+        let observer = NotificationCenter.default.addObserver(
+            forName: NSNotification.Name("RNWEventEmitterFireEvent"),
+            object: nil,
+            queue: nil
+        ) { notification in
+            guard let info = notification.userInfo,
+                  let eventName = info["eventName"] as? String else { return }
+            let payload = info["payload"]
+            let body: Any? = (payload is NSNull) ? nil : payload
+            hostRef.current?.fireEvent(byName: eventName, payload: body)
+        }
+        notificationObservers.append(observer)
+
+        host.onConsoleLog = { [weak self] level, message in
+        // TODO: Prod build error reporting
+        self?.lastErrorAt = Date()
+        #if DEBUG
+            Self.reportToMetro(level: Self.levelName(level), message: message)
+#endif
+        }
+        host.onCommit = { [weak self] snapshot in
+            let next = snapshot ?? []
+            Task { @MainActor [weak self] in
+                self?.root = next
+            }
+        }
+        host.onReloadRequest = { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.onReloadRequest?()
+            }
+        }
+    }
+
+    /// Tear down the current Hermes runtime and stand up a fresh one. Without
+    /// this, reload would re-evaluate the new bundle on top of the old: old
+    /// fibers never unmount, old `setInterval` callbacks keep firing, the
+    /// native UIManager registry accumulates dead shadow nodes, and the HMR
+    /// WebSocket churns. The old JS heap only goes away when its
+    /// `RNWHermesHost` is released.
+    private func recreateHost() {
+        // Hand the old host off so its dealloc — which `dispatch_sync`s
+        // onto its JS queue to drop the runtime — doesn't stall main
+        // mid-reload. The new host runs on its own private queue, so
+        // there's no ordering dependency.
+        let old = host
+        let next = RNWHermesHost()
+        host = next
+        hostRef.current = next
+        // Drop the prior bundle's tree so it doesn't linger on screen
+        // until the new bundle's first `completeRoot` lands.
+        root = []
+        wireHost()
+        DispatchQueue.global(qos: .utility).async {
+            _ = old
+        }
+    }
+
+    public static func metroBundleURL(
+        host: String = "127.0.0.1",
+        port: Int = 8081,
+        entry: String = "index",
+        dev: Bool = true
+    ) -> URL {
+        var components = URLComponents()
+        components.scheme = "http"
+        components.host = host
+        components.port = port
+        components.path = "/\(entry).bundle"
+        components.queryItems = [
+            URLQueryItem(name: "platform", value: "watchos"),
+            URLQueryItem(name: "dev", value: dev ? "true" : "false"),
+            URLQueryItem(name: "minify", value: dev ? "false" : "true"),
+        ]
+        return components.url!
+    }
+
+    public static func releaseBundleURL(name: String = "main") -> URL? {
+        Bundle.main.url(forResource: name, withExtension: "jsbundle")
+    }
+
+    public static func defaultBundleURL(
+        entry: String = "index",
+        host: String = "127.0.0.1",
+        port: Int = 8081,
+        name: String = "main"
+    ) -> URL {
+#if DEBUG
+        return metroBundleURL(host: host, port: port, entry: entry, dev: true)
+#else
+        guard let url = releaseBundleURL(name: name) else {
+            fatalError(
+                "[@appsent-co/react-native-watchos] \(name).jsbundle missing from app " +
+                "bundle. Did the Expo plugin's Run Script fire?"
+            )
+        }
+        return url
+#endif
+    }
+
+    /// Fetch a JS bundle (HTTP(S) or file://) and evaluate it in Hermes.
+    /// On every call past the first, the Hermes runtime is recreated so
+    /// the previous bundle's state (modules, fibers, timers, sockets,
+    /// shadow nodes) is dropped before the new bundle evaluates.
+    public func loadBundle(from url: URL) async throws {
+        if hasLoadedOnce {
+            recreateHost()
+        }
+        hasLoadedOnce = true
+        let data: Data
+        if url.isFileURL {
+            data = try Data(contentsOf: url, options: .mappedIfSafe)
+        } else {
+            (data, _) = try await URLSession.shared.data(from: url)
+        }
+        guard let source = String(data: data, encoding: .utf8) else {
+            throw NSError(
+                domain: "ReactNativeWatchOS",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey:
+                    "Bundle response was not valid UTF-8"]
+            )
+        }
+        // Inject `__RNW_DEV_SERVER` before the bundle so dev-support can
+        // set up Fast Refresh + HMR. Skipped for file:// / non-dev.
+        if let injection = Self.devServerInjection(for: url) {
+            try await evaluate(source: injection, url: "<rnw-dev-server>")
+        }
+        try await evaluate(source: source, url: url.absoluteString)
+    }
+
+    /// Returns nil for non-dev-server URLs — dev-support no-ops when the
+    /// global is absent.
+    private static func devServerInjection(for url: URL) -> String? {
+        guard let scheme = url.scheme,
+              scheme == "http" || scheme == "https",
+              let host = url.host else { return nil }
+        guard let comps = URLComponents(url: url, resolvingAgainstBaseURL: false) else {
+            return nil
+        }
+        let isDev = comps.queryItems?.contains(where: {
+            $0.name == "dev" && $0.value == "true"
+        }) ?? false
+        guard isDev else { return nil }
+
+        let port = url.port ?? (scheme == "https" ? 443 : 8081)
+        // /path/to/index.bundle → "path/to/index"
+        var entry = url.path
+        if entry.hasPrefix("/") { entry.removeFirst() }
+        if entry.hasSuffix(".bundle") {
+            entry.removeLast(".bundle".count)
+        }
+        let payload: [String: Any] = [
+            "host": host,
+            "port": port,
+            "entry": entry,
+            "scheme": scheme,
+        ]
+        guard let json = try? JSONSerialization.data(withJSONObject: payload),
+              let jsonStr = String(data: json, encoding: .utf8) else {
+            return nil
+        }
+        return "globalThis.__RNW_DEV_SERVER = \(jsonStr);"
+    }
+
+    /// POST to Metro's `/__watchos_log` (installed by `withWatchosMetro`).
+    /// Fire-and-forget — dev-time only, failures are dropped silently.
+    public static func reportToMetro(
+        level: String,
+        message: String,
+        stack: String? = nil,
+        serverHost: String = "127.0.0.1",
+        port: Int = 8081
+    ) {
+        guard let url = URL(string: "http://\(serverHost):\(port)/__watchos_log") else { return }
+        var payload: [String: String] = ["level": level, "message": message]
+        if let stack, !stack.isEmpty { payload["stack"] = stack }
+        guard let body = try? JSONSerialization.data(withJSONObject: payload) else { return }
+        var req = URLRequest(url: url)
+        req.httpMethod = "POST"
+        req.httpBody = body
+        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        URLSession.shared.dataTask(with: req).resume()
+    }
+
+    /// Evaluate JS source on the host's JS queue. Suspends the caller but
+    /// doesn't block main.
+    public func evaluate(source: String, url: String) async throws {
+        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+            host.evaluate(source, url: url) { error in
+                if let error {
+                    cont.resume(throwing: error)
+                } else {
+                    cont.resume()
+                }
+            }
+        }
+    }
+
+    private static func levelName(_ level: RNWLogLevel) -> String {
+        switch level {
+        case .log:   return "log"
+        case .warn:  return "warn"
+        case .error: return "error"
+        case .info:  return "info"
+        @unknown default: return "log"
+        }
+    }
+}
+
+/// Mutable holder for the current `RNWHermesHost`. Captured by event-
+/// dispatch closures whose lifetime exceeds any single runtime — they need
+/// to fan out to whichever host is live now, not the one that was current
+/// when they were created. `RNWHermesHost.fireEvent` is thread-safe.
+private final class HostRef: @unchecked Sendable {
+    var current: RNWHermesHost?
+}

package/apple/Sources/ReactNativeWatchOS/ReactNativeWatchOSView.swift

@@ -0,0 +1,100 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// Drop-in view that owns a `ReactNativeWatchOSHost`, loads JS from the
+/// given URL, renders it, and surfaces load errors. In DEBUG builds a
+/// shake gesture (~2.3g) opens a dev menu with Reload.
+///
+/// For production / advanced setups (custom error UX, statically-bundled
+/// JS, an externally-owned host), use `RNWRootView(host:)` directly and
+/// assemble your own surrounding view.
+public struct ReactNativeWatchOSView: View {
+    @StateObject private var host: ReactNativeWatchOSHost
+    @State private var hasError: Bool = false
+
+    private let bundleURL: URL
+
+    public init(bundleURL: URL) {
+        self.bundleURL = bundleURL
+        _host = StateObject(wrappedValue: ReactNativeWatchOSHost())
+    }
+
+    public var body: some View {
+        RNWRootView(host: host)
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+            .overlay(alignment: .bottom) {
+                if hasError {
+                    RNWErrorToast { hasError = false }
+                        .transition(.move(edge: .bottom).combined(with: .opacity))
+                }
+            }
+            .animation(.easeInOut(duration: 0.2), value: hasError)
+            // Runtime JS errors (uncaught throws, promise rejections,
+            // setTimeout callback throws) get stamped via console.error →
+            // lastErrorAt. Bundle-load failures still go through load().
+            .onChange(of: host.lastErrorAt) { newValue in
+                if newValue != nil {
+                    hasError = true
+                }
+            }
+            .task {
+                // Wire JS-driven reload before first load() so a parse
+                // error in the initial bundle can still trigger reload
+                // once dev-support is injected.
+                host.onReloadRequest = { Task { await load() } }
+                await load()
+            }
+            .modifier(RNWDevMenuModifier(reload: { Task { await load() } }))
+    }
+
+    private func load() async {
+        hasError = false
+        // Clear so a previous error doesn't re-trigger the toast.
+        host.lastErrorAt = nil
+        do {
+            try await host.loadBundle(from: bundleURL)
+        } catch {
+            // Forward the JS stack (in userInfo["stack"]) to Metro so the
+            // Expo CLI terminal shows the full trace.
+            let ns = error as NSError
+            let stack = ns.userInfo["stack"] as? String ?? ""
+            ReactNativeWatchOSHost.reportToMetro(
+                level: "error",
+                message: error.localizedDescription,
+                stack: stack
+            )
+            hasError = true
+        }
+    }
+}
+
+// MARK: - Dev menu
+
+#if DEBUG
+/// Shake → confirmation dialog with Reload. Release builds use the no-op
+/// variant below — no motion overhead, no `NSMotionUsageDescription`.
+private struct RNWDevMenuModifier: ViewModifier {
+    @StateObject private var shake = ShakeDetector()
+    @State private var showDevMenu: Bool = false
+    let reload: () -> Void
+
+    func body(content: Content) -> some View {
+        content
+            .onAppear { shake.start() }
+            .onChange(of: shake.shakeCount) { _ in showDevMenu = true }
+            .confirmationDialog(
+                "Dev Menu",
+                isPresented: $showDevMenu,
+                titleVisibility: .visible
+            ) {
+                Button("Reload", action: reload)
+                Button("Cancel", role: .cancel) { }
+            }
+    }
+}
+#else
+private struct RNWDevMenuModifier: ViewModifier {
+    let reload: () -> Void
+    func body(content: Content) -> some View { content }
+}
+#endif