@appsent-co/react-native-watchos 0.1.0

package/apple/Sources/ReactNativeWatchOSCxx/include/React/RCTBridgeModule.h

@@ -0,0 +1,88 @@
+// watchOS fork of `<React/RCTBridgeModule.h>`. Upstream pulls UIKit (UIView,
+// UIDevice), RCTDefines, RCTJSThread, RCTBundleManager — none of which exist
+// on watchOS. We re-declare the slim subset that codegen-emitted spec
+// classes + maintainer module bodies actually depend on, **using the
+// upstream names** so cross-platform TurboModule sources compile against
+// either fork unchanged:
+//
+//   - `RCTBridgeModule` protocol: the `+moduleName` class method that
+//     identifies the module to JS.
+//   - `RCTPromiseResolveBlock` / `RCTPromiseRejectBlock` /
+//     `RCTResponseSenderBlock` / `RCTResponseErrorBlock` typedefs.
+//   - `RCT_EXPORT_MODULE` macro: synthesizes `+moduleName` AND a `+load`
+//     that registers the class with `RNWTurboModuleRegistry.shared`,
+//     mirroring upstream RN's auto-registration behavior. Maintainers
+//     write a single line and the module shows up in JS.
+//
+// Header layout matches upstream — this file lives at
+// `Headers/React/RCTBridgeModule.h` inside the xcframework, so a
+// maintainer's `#import <React/RCTBridgeModule.h>` resolves here on
+// watchOS and to RN's pod on iOS. The two never coexist in the same
+// translation unit (iOS host + watch extension are separate Xcode
+// targets), so the shared name causes no collision and the same `.mm`
+// gets the right auto-registration path on each platform.
+//
+// We do NOT ship the legacy `RCT_EXPORT_METHOD` / `RCT_REMAP_METHOD` /
+// `RCT_EXPORT_SYNCHRONOUS_METHOD` macros. Those exist only to feed
+// `RCTInteropTurboModule` (the runtime-parsing legacy bridge path),
+// which is not ported. Codegen-emitted modules don't use them — they
+// declare regular ObjC instance methods, and codegen wires the C++
+// `methodMap_` directly.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Sends an array response back to a JS callback.
+typedef void (^RCTResponseSenderBlock)(NSArray *response);
+
+/// Sends an error response back to a JS callback.
+typedef void (^RCTResponseErrorBlock)(NSError *error);
+
+/// Resolves the JS promise waiting for this method's result. Nil resolves
+/// to `undefined`.
+typedef void (^RCTPromiseResolveBlock)(id _Nullable result);
+
+/// Rejects the JS promise. `error` may be nil but supplying an NSError
+/// yields better stack traces on the JS side.
+typedef void (^RCTPromiseRejectBlock)(
+    NSString *code,
+    NSString * _Nullable message,
+    NSError * _Nullable error);
+
+/// Marker protocol for TurboModule-providing classes. The codegen-emitted
+/// `Native<Foo>Spec` protocol conforms to this + `RCTTurboModule`, and
+/// the maintainer's class conforms to that combined protocol. Mirrors
+/// `RCTBridgeModule` upstream, minus the bridge/registry/queue properties
+/// that don't exist on watchOS.
+@protocol RCTBridgeModule <NSObject>
+
+/// Returns the JS-facing name of this module. Synthesized by
+/// `RCT_EXPORT_MODULE(name)`. JS calls
+/// `globalThis.__turboModuleProxy('<moduleName>')` to obtain the proxy.
++ (NSString *)moduleName;
+
+@end
+
+/// C entrypoint invoked from the `+load` synthesized by `RCT_EXPORT_MODULE`.
+/// Bridges into `RNWTurboModuleRegistry.shared` without forcing every
+/// module's translation unit to import the registry header.
+///
+/// Defined in `RNWTurboModuleRegistry.mm`.
+FOUNDATION_EXTERN void RNWRegisterTurboModuleClass(NSString *name, Class moduleClass);
+
+/// Place inside an `@implementation` block to synthesize `+moduleName`
+/// AND auto-register the class with the local TurboModule registry on
+/// image load (mirrors upstream RN's iOS behavior).
+///
+/// Requires the consumer target to link with `-ObjC` so the ObjC runtime
+/// loads our class (and fires `+load`) from the static library. The
+/// `@appsent-co/react-native-watchos` Expo plugin sets this automatically via
+/// `withSPMPackage`.
+#define RCT_EXPORT_MODULE(js_name)                                      \
+  +(NSString *)moduleName { return @ #js_name; }                        \
+  +(void)load { RNWRegisterTurboModuleClass(@ #js_name, self); }
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/React/RCTCxxConvert.h

@@ -0,0 +1,7 @@
+// Stub of `<React/RCTCxxConvert.h>` for watchOS. Codegen `#import`s this
+// in every `Native<Foo>Spec.h`; the `RCTCxxConvert` ObjC class it
+// declares is only referenced by specs with struct args (it's the
+// codegen-extensible registry of JS-object → C++-struct converters).
+// v1 doesn't support struct args, so an empty header is sufficient.
+
+#pragma once

package/apple/Sources/ReactNativeWatchOSCxx/include/React/RCTEventEmitter.h

@@ -0,0 +1,71 @@
+// watchOS fork of `<React/RCTEventEmitter.h>`. Mirrors upstream RN's
+// shape so a maintainer writes
+//
+//   @interface MyModule : RCTEventEmitter <NativeMySpec>
+//
+// unconditionally and the same source compiles on both slices. The
+// implementation differs under the hood:
+//
+//   - iOS:   RN's real RCTEventEmitter (bridge → RCTDeviceEventEmitter
+//            → NativeEventEmitter on the JS side).
+//   - watch: this stub. There's no bridge, so `sendEventWithName:body:`
+//            just posts `RNWEventEmitterFireEventNotification` carrying
+//            the event name + payload. The Swift `ReactNativeWatchOSHost`
+//            observes the notification and dispatches into JS via
+//            `__RNW_EVENTS.dispatchEvent(name, payload)`, where the
+//            JS-side `NativeEventEmitter` shim's name-keyed listener
+//            map fans out to subscribers.
+//
+// Header layout matches upstream — this file lives at
+// `Headers/React/RCTEventEmitter.h` inside the xcframework, so a
+// maintainer's `#import <React/RCTEventEmitter.h>` resolves here on
+// watchOS and to RN's pod on iOS. The two never coexist in the same
+// translation unit (iOS host + watch extension are separate Xcode
+// targets), so the shared name causes no collision.
+//
+// Methods that depend on RN's bridge (`startObserving`, `stopObserving`,
+// `invalidate`, `bridge`/`moduleRegistry`/`viewRegistry_DEPRECATED`
+// properties) are intentionally omitted — they'd need RN infrastructure
+// that doesn't exist on watchOS. Cross-platform module bodies that don't
+// touch them work identically; modules that do touch them would have
+// platform-specific code anyway.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Posted by `RCTEventEmitter sendEventWithName:body:` on watchOS.
+/// `ReactNativeWatchOSHost` observes this and forwards into JS via
+/// `fireEventByName:payload:`.
+///
+/// userInfo keys:
+///   "eventName" -> NSString (the name passed to `sendEventWithName:body:`)
+///   "payload"   -> id (JSON-encodable) or NSNull
+FOUNDATION_EXTERN NSNotificationName const RNWEventEmitterFireEventNotification;
+
+/// Abstract base class for TurboModules that emit events to JS.
+/// Subclass it, conform to your codegen-emitted `Native<Foo>Spec`, and
+/// call `[self sendEventWithName:body:]` to fire events. The JS-side
+/// `NativeEventEmitter` (shimmed on watchOS) takes care of subscription.
+@interface RCTEventEmitter : NSObject <RCTBridgeModule>
+
+/// Override in your subclass to advertise the events you emit. Optional
+/// on watchOS — the watch stub doesn't validate against this list. On
+/// iOS, attempting to send an unlisted event logs a warning.
+- (NSArray<NSString *> *)supportedEvents;
+
+/// Send an event to JS.
+- (void)sendEventWithName:(NSString *)name body:(nullable id)body;
+
+/// Lifecycle hooks the JS-side `NativeEventEmitter` calls when listeners
+/// are added/removed. No-ops in the watch stub — the notification bridge
+/// is always wired regardless of listener count.
+- (void)addListener:(NSString *)eventName;
+- (void)removeListeners:(double)count;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/React/RCTManagedPointer.h

@@ -0,0 +1,7 @@
+// Stub of `<React/RCTManagedPointer.h>` for watchOS. Codegen `#import`s
+// this in every `Native<Foo>Spec.h`; the `RCTManagedPointer` ObjC class
+// it declares wraps `std::shared_ptr<void>` so struct converters can
+// return C++ structs across the ObjC boundary. v1 doesn't support
+// struct args, so an empty header is sufficient.
+
+#pragma once

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactCommon/RCTTurboModule.h

@@ -0,0 +1,187 @@
+// watchOS fork of `<ReactCommon/RCTTurboModule.h>` (the iOS platform layer
+// of RN's TurboModule core). Header layout matches upstream — this file
+// lives at `Headers/ReactCommon/RCTTurboModule.h` inside the xcframework,
+// so a maintainer's `#import <ReactCommon/RCTTurboModule.h>` resolves
+// here on watchOS and to RN's pod on iOS. The two never coexist in the
+// same translation unit (separate Xcode targets per platform), so the
+// shared name is safe.
+//
+// Differences vs upstream:
+//
+//   - `<React/RCTBridge.h>` import dropped — there's no `RCTBridge` on
+//     watchOS. The host plugs the `CallInvoker` /
+//     `NativeMethodCallInvoker` into `ObjCTurboModule::InitParams`
+//     directly via `RNWTurboModuleRegistry`.
+//   - The `RCTBridge (RCTTurboModule)` category at the end of upstream
+//     is dropped (we have no `RCTBridge`).
+//   - The class lives in `facebook::react::ObjCTurboModule` — same
+//     namespace + name as upstream. Codegen-emitted `Native<Foo>SpecJSI`
+//     classes inherit from that exact symbol; keeping the name means
+//     codegen output drops in without rewriting.
+//
+// We do NOT compile upstream's platform/ios sources, so there's no
+// duplicate-symbol risk — only our fork ends up in the static archive.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/TurboModule.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::react {
+
+using EventEmitterCallback = std::function<void(const std::string &, id)>;
+
+namespace TurboModuleConvertUtils {
+
+/// Convert an ObjC value (NSString / NSNumber / NSArray / NSDictionary /
+/// kCFNull) to its JSI equivalent. Unknown classes return `undefined`.
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+
+/// Convert a JSI value to its ObjC counterpart. Functions become
+/// `RCTResponseSenderBlock`-style callbacks bound to the JS thread via
+/// `jsInvoker`. If `useNSNull` is YES, JS `null` maps to `kCFNull`;
+/// otherwise `null` becomes `nil`.
+id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    BOOL useNSNull = NO);
+
+}  // namespace TurboModuleConvertUtils
+
+// Bridging<id> specialization so codegen-emitted spec code that reads
+// ObjC return values via the bridging templates compiles unchanged.
+template <>
+struct Bridging<id> {
+    static jsi::Value toJs(jsi::Runtime &rt, const id &value)
+    {
+        return TurboModuleConvertUtils::convertObjCObjectToJSIValue(rt, value);
+    }
+};
+
+/// Base class every codegen-emitted `Native<Foo>SpecJSI` inherits from.
+/// Holds an ObjC instance + invokers, and dispatches JS method calls
+/// through `NSInvocation` into the maintainer's ObjC class.
+class JSI_EXPORT ObjCTurboModule : public TurboModule {
+ public:
+    struct InitParams {
+        std::string moduleName;
+        id<RCTBridgeModule> instance;
+        std::shared_ptr<CallInvoker> jsInvoker;
+        std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker;
+        bool isSyncModule;
+        bool shouldVoidMethodsExecuteSync;
+    };
+
+    ObjCTurboModule(const InitParams &params);
+
+    /// Dispatch a single method call. Called from the generated method
+    /// thunks in `Native<Foo>SpecJSI::methodMap_`. Resolves the selector
+    /// against `instance_`, builds an `NSInvocation`, runs it on the
+    /// native method queue, and converts the return back to JSI.
+    jsi::Value invokeObjCMethod(
+        jsi::Runtime &runtime,
+        TurboModuleMethodValueKind returnType,
+        const std::string &methodName,
+        SEL selector,
+        const jsi::Value *args,
+        size_t count);
+
+    id<RCTBridgeModule> instance_;
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker_;
+
+ protected:
+    void setEventEmitterCallback(EventEmitterCallback eventEmitterCallback);
+
+    /// Default conversion from ObjC return value → JSI, dispatching on
+    /// the codegen-supplied `TurboModuleMethodValueKind`. Overridable by
+    /// custom subclasses, but the codegen default is fine for v1.
+    virtual jsi::Value convertReturnIdToJSIValue(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        TurboModuleMethodValueKind returnType,
+        id result);
+
+    /// Assigns one converted ObjC arg into the NSInvocation at index
+    /// `i + 2` (the `+2` skips `self` + `_cmd`). v1 supports the
+    /// JSON-mappable subset only: bool, double, NSInteger, NSString,
+    /// NSArray, NSDictionary, RCTResponseSenderBlock. Custom types
+    /// (UIColor/UIImage/structs) need a maintainer-side hop in their
+    /// method body.
+    virtual void setInvocationArg(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        const std::string &objCArgType,
+        const jsi::Value &arg,
+        size_t i,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+
+ private:
+    const bool isSyncModule_;
+    const bool shouldVoidMethodsExecuteSync_;
+
+    bool isMethodSync(TurboModuleMethodValueKind returnType);
+
+    NSInvocation *createMethodInvocation(
+        jsi::Runtime &runtime,
+        bool isSync,
+        const char *methodName,
+        SEL selector,
+        const jsi::Value *args,
+        size_t count,
+        NSMutableArray *retainedObjectsForInvocation);
+    id performMethodInvocation(
+        jsi::Runtime &runtime,
+        bool isSync,
+        const char *methodName,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+    void performVoidMethodInvocation(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+
+    using PromiseInvocationBlock = void (^)(
+        RCTPromiseResolveBlock resolveWrapper,
+        RCTPromiseRejectBlock rejectWrapper);
+    jsi::Value createPromise(
+        jsi::Runtime &runtime,
+        const std::string &methodName,
+        PromiseInvocationBlock invoke);
+};
+
+}  // namespace facebook::react
+
+/// Wraps a C++ `EventEmitterCallback` so it can be passed across the ObjC
+/// boundary in `-setEventEmitterCallback:`.
+@interface EventEmitterCallbackWrapper : NSObject {
+ @public
+    facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+@end
+
+/// Factory protocol every ObjC TurboModule conforms to. The maintainer's
+/// `-getTurboModule:` returns the codegen-emitted SpecJSI subclass.
+@protocol RCTModuleProvider <NSObject>
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+        (const facebook::react::ObjCTurboModule::InitParams &)params;
+@end
+
+/// Marker protocol so the registry can verify a class is actually meant
+/// to be exposed as a TurboModule. Conformance gives access to the
+/// optional event-emitter hookup.
+@protocol RCTTurboModule <RCTModuleProvider>
+@optional
+- (void)setEventEmitterCallback:
+        (EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+@end

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactNativeWatchOSCxx/RNWHermesHost.h

@@ -0,0 +1,58 @@
+#import <Foundation/Foundation.h>
+#import <ReactNativeWatchOSCxx/RNWShadowNode.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, RNWLogLevel) {
+    RNWLogLevelLog,
+    RNWLogLevelWarn,
+    RNWLogLevelError,
+    RNWLogLevelInfo,
+};
+
+/// Owns a Hermes JS runtime via JSI. The runtime lives on a private serial
+/// dispatch queue (the "JS queue") so main-thread SwiftUI work isn't blocked.
+/// All public methods are thread-safe — they hop to the JS queue internally.
+///
+/// Installs `globalThis.__RNW_log(level, message)` and a minimal one-arg
+/// `console` bootstrap. The rich multi-arg shim lives in
+/// `src/setupConsole.ts` and routes through `__RNW_log` to `onConsoleLog`.
+@interface RNWHermesHost : NSObject
+
+- (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Evaluate a JS source string on the JS queue. `url` is the source URL
+/// for stack traces. `completion` fires on the main queue with nil on
+/// success.
+- (void)evaluate:(NSString *)source
+             url:(NSString *)url
+      completion:(void (^)(NSError * _Nullable error))completion;
+
+/// Called on the main queue for every `console.<level>(...)`.
+@property (nonatomic, copy, nullable) void (^onConsoleLog)(RNWLogLevel level,
+                                                           NSString *message);
+
+/// Called on the main queue after every JS-side `completeRoot()`. Empty
+/// roots send `@[]`; never nil.
+@property (nonatomic, copy, nullable) void (^onCommit)(NSArray<RNWShadowNodeSnapshot *> *root);
+
+/// Called on the main queue when JS invokes `globalThis.__RNW_RELOAD()`
+/// (Fast Refresh full-reload path). Dispatched async off the current JS
+/// callstack so the runtime can safely re-evaluate.
+@property (nonatomic, copy, nullable) void (^onReloadRequest)(void);
+
+/// Bridge from SwiftUI action closures into `globalThis.__RNW_EVENTS.dispatch`.
+/// Fire-and-forget; no-op if the JS bridge isn't installed or the id is
+/// unknown.
+- (void)fireEventWithHandlerId:(NSInteger)handlerId
+                       payload:(nullable id)payload;
+
+/// Bridge from native `RCTEventEmitter sendEventWithName:body:` into
+/// `globalThis.__RNW_EVENTS.dispatchEvent`. Fire-and-forget; no-op if the
+/// bridge isn't installed or no listener is registered for the name.
+- (void)fireEventByName:(NSString *)eventName
+                payload:(nullable id)payload;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactNativeWatchOSCxx/RNWShadowNode.h

@@ -0,0 +1,49 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Node kind in the snapshot tree. `view` covers every SwiftUI view, keyed
+/// by `viewName`. `rawText` is the inert string child of a Text-like node.
+typedef NS_ENUM(NSInteger, RNWNodeKind) {
+    RNWNodeKindView,
+    RNWNodeKindRawText,
+};
+
+/// Immutable snapshot of a shadow node. SwiftUI renders directly off this.
+@interface RNWShadowNodeSnapshot : NSObject
+@property (nonatomic, readonly) NSInteger tag;
+@property (nonatomic, readonly) RNWNodeKind kind;
+
+/// JS-side view type ("Text", "Button", "VStack", ...). nil for rawText.
+@property (nonatomic, readonly, nullable) NSString *viewName;
+
+/// Values are NSString | NSNumber | NSArray | NSDictionary; per-view-type
+/// interpretation happens on the Swift side. nil for rawText.
+@property (nonatomic, readonly, nullable) NSDictionary<NSString *, id> *props;
+
+/// Modifiers in source order — SwiftUI modifiers are non-commutative.
+/// Each entry has a "$type" key plus modifier-specific params.
+@property (nonatomic, readonly) NSArray<NSDictionary<NSString *, id> *> *modifiers;
+
+/// Event-name → JS handler id. Native dispatches via
+/// `__RNW_EVENTS.dispatch(id, payload)`.
+@property (nonatomic, readonly) NSDictionary<NSString *, NSNumber *> *eventHandlers;
+
+/// rawText only.
+@property (nonatomic, readonly, nullable) NSString *text;
+
+@property (nonatomic, readonly) NSArray<RNWShadowNodeSnapshot *> *children;
+
+- (instancetype)initWithTag:(NSInteger)tag
+                       kind:(RNWNodeKind)kind
+                   viewName:(nullable NSString *)viewName
+                      props:(nullable NSDictionary<NSString *, id> *)props
+                  modifiers:(NSArray<NSDictionary<NSString *, id> *> *)modifiers
+              eventHandlers:(NSDictionary<NSString *, NSNumber *> *)eventHandlers
+                       text:(nullable NSString *)text
+                   children:(NSArray<RNWShadowNodeSnapshot *> *)children
+    NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactNativeWatchOSCxx/RNWTurboModuleRegistry+Cxx.h

@@ -0,0 +1,64 @@
+// Internal ObjC++ header — Swift can't see the C++ types, so this lives
+// outside the umbrella header and module authors include it from `.mm`.
+
+#pragma once
+
+#import <ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::react {
+class TurboModule;
+class CallInvoker;
+}  // namespace facebook::react
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Invoked lazily on the JS thread the first time JS calls
+/// `__turboModuleProxy('<name>')`. Result is cached for the registry's life.
+using RNWTurboModuleCxxFactory = std::function<
+    std::shared_ptr<facebook::react::TurboModule>(
+        std::shared_ptr<facebook::react::CallInvoker> jsInvoker)>;
+
+/// Invoked from `+load` synthesized by `RNW_EXPORT_CXX_MODULE`.
+FOUNDATION_EXTERN void RNWRegisterCxxTurboModule(NSString *name,
+                                                 RNWTurboModuleCxxFactory factory);
+
+/// Place at file scope in an `.mm` to auto-register a C++ TurboModule on
+/// image load. Requires the consumer to link with `-ObjC` (the Expo plugin
+/// sets this).
+///
+/// Example:
+///
+///   RNW_EXPORT_CXX_MODULE(Math, [](std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+///       return std::make_shared<NativeMathModule>(std::move(jsInvoker));
+///   });
+#define RNW_EXPORT_CXX_MODULE(js_name, factory_expr)                    \
+  @interface RNWCxxAutoload_##js_name : NSObject                        \
+  @end                                                                  \
+  @implementation RNWCxxAutoload_##js_name                              \
+  +(void)load { RNWRegisterCxxTurboModule(@ #js_name, factory_expr); }  \
+  @end
+
+@interface RNWTurboModuleRegistry (Cxx)
+
+/// Prefer `RNW_EXPORT_CXX_MODULE`; this is for dynamic registration only.
+- (void)registerCxxModuleNamed:(NSString *)name
+                       factory:(RNWTurboModuleCxxFactory)factory;
+
+/// Internal — resolves cached → C++ factory → ObjC factory, building the
+/// `ObjCTurboModule` wrapper for the ObjC path. Returns `nullptr` if
+/// nothing matches.
+- (std::shared_ptr<facebook::react::TurboModule>)
+        lookupModuleNamed:(NSString *)name
+                jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+            nativeInvoker:(std::shared_ptr<facebook::react::NativeMethodCallInvoker>)nativeInvoker;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Per-host registry of TurboModule factories, looked up by
+/// `__turboModuleProxy('<name>')`. Modules normally self-register on image
+/// load via `RCT_EXPORT_MODULE` (ObjC) or `RNW_EXPORT_CXX_MODULE` (C++);
+/// direct calls here are for dynamic registration only.
+///
+/// ObjC modules: use `registerModuleName:factory:` (this header).
+/// C++ modules: use `RNWTurboModuleRegistry+Cxx.h` from a `.mm` file.
+@interface RNWTurboModuleRegistry : NSObject
+
+@property (class, readonly) RNWTurboModuleRegistry *shared;
+
+/// Factory is invoked lazily on first JS access and must return an
+/// instance conforming to `<RCTBridgeModule, RCTTurboModule>`. The
+/// instance's `-getTurboModule:` constructs the C++ wrapper.
+- (void)registerModuleName:(NSString *)name
+                   factory:(id _Nonnull (^)(void))factory;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/include/ReactNativeWatchOSCxx/module.modulemap

@@ -0,0 +1,25 @@
+module ReactNativeWatchOSCxx {
+    header "ReactNativeWatchOSCxx/RNWShadowNode.h"
+    header "ReactNativeWatchOSCxx/RNWHermesHost.h"
+    header "ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h"
+
+    // Cxx category — declares C++ types (`facebook::react::TurboModule`,
+    // `std::function`, `std::shared_ptr`) that Swift can't see. Marked
+    // `textual` so the Swift module compiler treats it as a plain
+    // `#include` rather than modularizing it. ObjC++ module authors
+    // include from `.mm` files only.
+    textual header "ReactNativeWatchOSCxx/RNWTurboModuleRegistry+Cxx.h"
+
+    export *
+}
+
+// Note: `<React/RCTBridgeModule.h>` and `<ReactCommon/RCTTurboModule.h>`
+// (the watchOS-safe forks of RN's TurboModule headers) ship at
+// `Headers/React/...` and `Headers/ReactCommon/...` inside the xcframework
+// — they're not part of THIS module. Module authors include them via
+// the standard `#import <React/...>` / `#import <ReactCommon/...>` paths
+// from their own `.mm` files. The xcframework's Headers/ root is on the
+// header search path; the forks are found there. The two ObjC headers
+// would otherwise collide with React Native's pod on cross-platform
+// builds — keeping them outside this module avoids any `import
+// ReactNativeWatchOSCxx` from Swift dragging in `RCTBridgeModule`.

package/apple/Sources/WatchConnectivity/RNWWatchConnectivity.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+// `<React/RCTEventEmitter.h>` resolves to RN's pod on iOS and to our
+// watchOS fork (`apple/Sources/ReactNativeWatchOSCxx/include/React/RCTEventEmitter.h`,
+// shipped in the xcframework) on watch. Same import, same superclass
+// name, same maintainer-facing API on both — implementation differs
+// under the hood.
+#import <React/RCTEventEmitter.h>
+
+// Codegen-emitted umbrella for this package's spec. On iOS it's produced
+// by standard RN codegen at `pod install` (driven by this package's
+// `codegenConfig`). On watchOS it's produced by
+// `withWatchTurboModuleCodegen`, which scans library specs from
+// `node_modules/@appsent-co/react-native-watchos/src/watchConnectivity/specs/`.
+#import "RNWatchConnectivitySpec.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNWWatchConnectivity : RCTEventEmitter <NativeWatchConnectivitySpec>
+@end
+
+NS_ASSUME_NONNULL_END