@appsent-co/react-native-watchos 0.1.0

package/src/render.ts

@@ -0,0 +1,78 @@
+import type { ReactNode } from 'react';
+import ReconcilerFactory from 'react-reconciler';
+
+import { createHostConfig } from './createHostConfig';
+import { installEventBridge } from './eventRegistry';
+
+// Install `globalThis.__RNW_EVENTS.dispatch` at module-import time so
+// the native side can find it as soon as the first commit hits — well
+// before any React effect fires.
+installEventBridge();
+
+// Inert sentinel — the C++ side owns the root child list directly, so the
+// container is never addressed by tag. We just need a stable object identity
+// so the reconciler can key its container state off it.
+const container: object = {};
+
+// `ReconcilerFactory`'s parameter type changes per minor version (see the
+// comment in createHostConfig.ts). The cast keeps the call site stable.
+const Reconciler = (
+  ReconcilerFactory as unknown as (config: unknown) => unknown
+)(createHostConfig()) as {
+  createContainer: (...args: unknown[]) => unknown;
+  updateContainer: (
+    element: ReactNode,
+    container: unknown,
+    parentComponent: unknown,
+    callback: unknown
+  ) => void;
+  injectIntoDevTools: () => boolean;
+};
+
+// React 19's react-reconciler dropped the auto-registration with the
+// DevTools global hook that older versions did at module-import time.
+// Consumers must now invoke `injectIntoDevTools()` to publish the
+// `scheduleRefresh` / `scheduleRoot` helpers React Refresh reads through
+// `__REACT_DEVTOOLS_GLOBAL_HOOK__`. Without this, Fast Refresh updates
+// arrive, modules re-evaluate, and `performReactRefresh()` runs — but
+// React has no registered renderer to forward the swap to, so the
+// fiber tree never re-renders.
+Reconciler.injectIntoDevTools();
+
+// Forward React's error callbacks to `console.error`. The watch host
+// routes console.error → onConsoleLog → reportToMetro (Metro terminal)
+// AND bumps `ReactNativeWatchOSHost.lastErrorAt` → triggers the
+// `RNWErrorToast` overlay. Without these hooks, React swallows every
+// render-phase throw silently (no toast, no log, no crash).
+function reportRenderError(label: string, error: unknown): void {
+  const e = error as { message?: unknown; stack?: unknown };
+  const message = typeof e?.message === 'string' ? e.message : String(error);
+  const stack = typeof e?.stack === 'string' ? `\n${e.stack}` : '';
+  const g = globalThis as unknown as {
+    console?: { error: (...args: unknown[]) => void };
+  };
+  g.console?.error?.(`[React ${label}] ${message}${stack}`);
+}
+
+// `createContainer` signature drifts across react-reconciler versions
+// (added: hydrationCallbacks, isStrictMode, concurrentUpdatesByDefault,
+//  identifierPrefix, onRecoverableError, transitionCallbacks…). All
+// trailing optional args — passing them positionally is forward-compatible.
+const root = Reconciler.createContainer(
+  container,
+  /* tag (LegacyRoot=0, ConcurrentRoot=1) */ 1,
+  /* hydrationCallbacks */ null,
+  /* isStrictMode */ false,
+  /* concurrentUpdatesByDefault */ null,
+  /* identifierPrefix */ '',
+  /* onUncaughtError */ (error: unknown) =>
+    reportRenderError('uncaught', error),
+  /* onCaughtError */ (error: unknown) => reportRenderError('caught', error),
+  /* onRecoverableError */ (error: unknown) =>
+    reportRenderError('recoverable', error),
+  /* transitionCallbacks */ null
+);
+
+export function render(element: ReactNode): void {
+  Reconciler.updateContainer(element, root, null, null);
+}

package/src/setupConsole.ts

@@ -0,0 +1,78 @@
+// Rich `console` shim. The Hermes host installs `globalThis.__RNW_log(level,
+// message)` plus a one-arg `console` bootstrap that just coerces via
+// `String()`. This module overrides that with multi-arg formatting +
+// `JSON.stringify` for objects, matching what the native side used to do
+// inline.
+//
+// Loaded as the very first side-effect import from `polyfills.ts` so the
+// rich shim is in place before anything in the bundle logs.
+
+type LogLevel = 'log' | 'warn' | 'error' | 'info';
+
+type LogBridge = (level: LogLevel, message: string) => void;
+
+const g = globalThis as unknown as {
+  __RNW_log?: LogBridge;
+  console?: Record<LogLevel, (...args: unknown[]) => void>;
+};
+
+// Without `__RNW_log` we'd silently drop logs — the host should always
+// install it before bundle eval, but bail out gracefully if it didn't.
+if (typeof g.__RNW_log === 'function') {
+  const bridge = g.__RNW_log;
+
+  const formatOne = (value: unknown, seen: WeakSet<object>): string => {
+    if (value === undefined) return 'undefined';
+    if (value === null) return 'null';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return String(value);
+    }
+    if (value instanceof Error) {
+      // Errors don't have enumerable own props, so JSON.stringify returns
+      // "{}" — useless. Prefer the stack (with message baked in) which is
+      // what every console implementation does.
+      return value.stack || `${value.name}: ${value.message}`;
+    }
+    if (typeof value === 'object') {
+      if (seen.has(value as object)) return '[Circular]';
+      seen.add(value as object);
+      try {
+        return JSON.stringify(value, (_key, v) => {
+          if (typeof v === 'object' && v !== null) {
+            if (seen.has(v)) return '[Circular]';
+            seen.add(v);
+          }
+          return v;
+        });
+      } catch {
+        return '[object]';
+      }
+    }
+    // function, symbol, bigint, etc.
+    return String(value);
+  };
+
+  const format = (args: unknown[]): string => {
+    const seen = new WeakSet<object>();
+    let out = '';
+    for (let i = 0; i < args.length; i++) {
+      if (i > 0) out += ' ';
+      out += formatOne(args[i], seen);
+    }
+    return out;
+  };
+
+  const make = (level: LogLevel) => (...args: unknown[]): void => {
+    bridge(level, format(args));
+  };
+
+  g.console = {
+    log: make('log'),
+    warn: make('warn'),
+    error: make('error'),
+    info: make('info'),
+  };
+}
+
+export {};

package/src/setupSelfGlobal.ts

@@ -0,0 +1,12 @@
+// `whatwg-fetch`'s UMD wrapper picks its install target via
+// `typeof self !== 'undefined' ? self : this`. Inside a Hermes module under
+// strict mode, top-level `this` is undefined and `self` isn't a Hermes
+// global — so without this shim the polyfill silently picks the wrong
+// target and `globalThis.fetch` stays undefined.
+//
+// Must run BEFORE `import 'whatwg-fetch'`. Babel hoists ESM imports above
+// plain statements within a single file, so we live in our own module that
+// `polyfills.ts` imports first.
+(globalThis as { self?: unknown }).self ??= globalThis;
+
+export {};

package/src/types/GridItem.ts

@@ -0,0 +1,39 @@
+/// SwiftUI `GridItem` descriptor — used by `LazyVGrid` (as a column) and
+/// `LazyHGrid` (as a row). Mirrors the three sizing variants:
+///   - `flexible(minimum:maximum:)` — share the axis, clamped to a range.
+///   - `fixed(value)`               — exact size.
+///   - `adaptive(minimum:maximum:)` — pack as many tracks as fit, each at
+///     least `minimum` wide/tall.
+export interface GridItem {
+  size:
+    | { kind: 'flexible'; minimum?: number; maximum?: number }
+    | { kind: 'fixed'; value: number }
+    | { kind: 'adaptive'; minimum: number; maximum?: number };
+  /// Distance between this item's track and the next. SwiftUI default
+  /// when omitted.
+  spacing?: number;
+  /// Cross-axis alignment of cells in this track.
+  alignment?:
+    | 'leading'
+    | 'trailing'
+    | 'center'
+    | 'top'
+    | 'bottom'
+    | 'topLeading'
+    | 'topTrailing'
+    | 'bottomLeading'
+    | 'bottomTrailing';
+}
+
+/// Convenience constructors for the three sizing variants.
+export const gridItem = {
+  flexible(opts: { minimum?: number; maximum?: number } = {}): GridItem {
+    return { size: { kind: 'flexible', ...opts } };
+  },
+  fixed(value: number): GridItem {
+    return { size: { kind: 'fixed', value } };
+  },
+  adaptive(minimum: number, maximum?: number): GridItem {
+    return { size: { kind: 'adaptive', minimum, maximum } };
+  },
+};

package/src/types.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react';
+
+/// A single SwiftUI modifier descriptor. Built by factories in
+/// `src/modifiers/` (`padding({all: 10})`, `background('red')`, …).
+/// The shape is just JSON: a `$type` discriminator plus modifier-specific
+/// params. The native side dispatches on `$type`.
+export interface ViewModifier {
+  readonly $type: string;
+  readonly [key: string]: unknown;
+}
+
+/// Common props every SwiftUI view accepts. Specific components extend
+/// this with their own typed props.
+export interface CommonProps {
+  /// Modifiers applied left-to-right in array order. Order matters — SwiftUI
+  /// modifiers are non-commutative (`padding().background()` paints the
+  /// background outside the padded region; `background().padding()` paints
+  /// it inside).
+  modifiers?: ViewModifier[];
+  /// Identifier consumed by a `<TabView>` parent: matches against its
+  /// `selection` prop. Inert when the parent isn't a `TabView`.
+  tabTag?: string;
+  children?: ReactNode;
+}

package/src/useEventHandler.ts

@@ -0,0 +1,31 @@
+import { useEffect, useRef, useState } from 'react';
+
+import { registerHandler, unregisterHandler } from './eventRegistry';
+
+/// Bridge a JS function into a stable native-friendly numeric id.
+///
+/// - Allocates the id once (in `useState`'s initializer) and keeps it
+///   stable across re-renders. Otherwise every keystroke / state change
+///   would churn the registry and leave stale entries.
+/// - The actual callback target is kept in a ref so re-renders with
+///   different closures take effect immediately, without re-allocation.
+/// - Returns `undefined` when `fn` is `undefined`, so the component can
+///   omit the prop and the native side won't see a dangling event id.
+/// - Frees the id on unmount.
+export function useEventHandler<P = void>(
+  fn: ((payload: P) => void) | undefined
+): number | undefined {
+  const fnRef = useRef(fn);
+  fnRef.current = fn;
+
+  const [id] = useState(() =>
+    registerHandler((payload) => {
+      const current = fnRef.current;
+      if (current !== undefined) current(payload as P);
+    })
+  );
+
+  useEffect(() => () => unregisterHandler(id), [id]);
+
+  return fn === undefined ? undefined : id;
+}

package/src/useModifiers.ts

@@ -0,0 +1,126 @@
+import {
+  createElement,
+  isValidElement,
+  useEffect,
+  useRef,
+  type ReactNode,
+} from 'react';
+
+import { registerHandler, unregisterHandler } from './eventRegistry';
+import type { ViewModifier } from './types';
+
+type AnyFn = (payload?: unknown) => void;
+
+interface ModifierState {
+  /// `${modifierIndex}:${paramKey}` → native handler id (kept stable across
+  /// renders so the registry doesn't churn on every keystroke / state change).
+  ids: Map<string, number>;
+  /// Same key → the latest JS callback. Updated every render so the
+  /// registered dispatcher always invokes the current closure.
+  fns: Map<string, AnyFn>;
+}
+
+/// Process a view's `modifiers` prop so callback and content modifiers can
+/// cross the bridge. Plain value modifiers pass through untouched.
+///
+///   - **Callbacks.** A modifier param whose value is a function is replaced
+///     with a stable numeric handler id. This is mandatory: the JSI → NS
+///     converter drops raw functions, so a callback left as a function would
+///     silently never fire. The id is allocated once and freed on unmount;
+///     the live closure lives in a ref so re-renders take effect without
+///     re-allocating. Native fires it via `RNWModifierContext.fire`.
+///   - **Content.** A param whose value is a React element (or array of
+///     elements) is hoisted into a `__ModifierContent` child node carrying a
+///     `slot` prop, and the param value is replaced with that slot id string.
+///     This also avoids feeding a React element (whose `_owner` fiber graph
+///     is cyclic) to the recursive bridge converter. Native pulls the
+///     rendered content back via `RNWModifierContext.content(slot)`; the
+///     hoisted node is excluded from inline children (`viewChildren`).
+///
+/// The hook-count is fixed regardless of modifier count, so this is safe to
+/// call unconditionally from any component.
+export function useModifiers(
+  modifiers: ViewModifier[] | undefined,
+  children: ReactNode
+): { modifiers: ViewModifier[] | undefined; children: ReactNode } {
+  const state = useRef<ModifierState>({ ids: new Map(), fns: new Map() });
+
+  // Free every outstanding handler id on unmount. Capture `state.current`
+  // here so the cleanup doesn't read a possibly-changed ref later.
+  useEffect(() => {
+    const s = state.current;
+    return () => {
+      for (const id of s.ids.values()) unregisterHandler(id);
+      s.ids.clear();
+      s.fns.clear();
+    };
+  }, []);
+
+  if (!modifiers || modifiers.length === 0) {
+    return { modifiers, children };
+  }
+
+  const s = state.current;
+  const seen = new Set<string>();
+  const contentChildren: ReactNode[] = [];
+
+  const processed = modifiers.map((mod, i) => {
+    let out: Record<string, unknown> | undefined;
+
+    for (const key of Object.keys(mod)) {
+      if (key === '$type') continue;
+      const value = (mod as Record<string, unknown>)[key];
+
+      if (typeof value === 'function') {
+        const mapKey = `${i}:${key}`;
+        seen.add(mapKey);
+        let id = s.ids.get(mapKey);
+        if (id === undefined) {
+          id = registerHandler((payload) => {
+            const fn = s.fns.get(mapKey);
+            if (fn) fn(payload);
+          });
+          s.ids.set(mapKey, id);
+        }
+        s.fns.set(mapKey, value as AnyFn);
+        out = out ?? { ...mod };
+        out[key] = id;
+      } else if (
+        isValidElement(value) ||
+        (Array.isArray(value) && value.some((v) => isValidElement(v)))
+      ) {
+        const slot = `__mc:${i}:${key}`;
+        contentChildren.push(
+          createElement('__ModifierContent', { key: slot, slot }, value as ReactNode)
+        );
+        out = out ?? { ...mod };
+        out[key] = slot;
+      }
+    }
+
+    return (out ?? mod) as ViewModifier;
+  });
+
+  // Release ids whose (modifier, key) pair vanished this render — a modifier
+  // was removed or its callback prop dropped.
+  for (const [mapKey, id] of s.ids) {
+    if (!seen.has(mapKey)) {
+      unregisterHandler(id);
+      s.ids.delete(mapKey);
+      s.fns.delete(mapKey);
+    }
+  }
+
+  if (contentChildren.length === 0) {
+    return { modifiers: processed, children };
+  }
+
+  const base: ReactNode[] =
+    children == null || children === false
+      ? []
+      : Array.isArray(children)
+        ? children
+        : [children];
+
+  return { modifiers: processed, children: [...base, ...contentChildren] };
+}

package/src/watchConnectivity/eventBridge.ts

@@ -0,0 +1,32 @@
+// Cross-platform event subscription for the WatchConnectivity TurboModule.
+//
+// Uses `NativeEventEmitter` from `react-native` unconditionally. On iOS
+// that's RN's real implementation (bridge → RCTDeviceEventEmitter); on
+// watchOS, Metro aliases `react-native` → `reactNativeShim`, which
+// provides a name-keyed stub that routes dispatches through
+// `__RNW_EVENTS.dispatchEvent`. The maintainer-facing API is identical
+// on both platforms.
+
+import type { Subscription } from './types';
+
+type Listener = (payload: unknown) => void;
+
+interface NativeModule {
+  addListener?(eventName: string): void;
+  removeListeners?(count: number): void;
+}
+
+export function createEventBridge(nativeModule: NativeModule) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const RN = require('react-native');
+  const NativeEventEmitter = RN.NativeEventEmitter as new (mod: unknown) => {
+    addListener(name: string, fn: Listener): { remove(): void };
+  };
+  const emitter = new NativeEventEmitter(nativeModule);
+
+  return {
+    subscribe(eventName: string, listener: Listener): Subscription {
+      return emitter.addListener(eventName, listener);
+    },
+  };
+}

package/src/watchConnectivity/index.ts

@@ -0,0 +1,195 @@
+// JavaScript-friendly facade over Apple's WatchConnectivity (WCSession).
+//
+// Same API on iOS and watchOS. Same code runs in the iOS host app's
+// React Native runtime and in the watchOS Hermes runtime — the native
+// side picks the right delegate methods to fire based on which side
+// of the pairing it's on.
+//
+// Usage:
+//
+//   import { WatchConnectivity } from '@appsent-co/react-native-watchos/watch-connectivity';
+//
+//   await WatchConnectivity.activate();
+//
+//   // Subscribe to incoming messages. Return a value from the handler
+//   // to reply (when the peer used `expectReply: true`).
+//   const sub = WatchConnectivity.on('message', ({ content }) => {
+//     return { pong: content.ping };
+//   });
+//
+//   // Send and wait for a reply.
+//   const reply = await WatchConnectivity.sendMessage(
+//     { ping: Date.now() },
+//     { expectReply: true }
+//   );
+//
+//   sub.remove();
+
+import NativeWatchConnectivity from './specs/NativeWatchConnectivity';
+import { createEventBridge } from './eventBridge';
+import type {
+  Dictionary,
+  EventMap,
+  EventName,
+  ReceivedMessage,
+  ReceivedMessageData,
+  SendMessageOptions,
+  SessionState,
+  Subscription,
+  UserInfoTransfer,
+} from './types';
+
+export type {
+  ActivationState,
+  Dictionary,
+  EventMap,
+  EventName,
+  JSONValue,
+  ReceivedMessage,
+  ReceivedMessageData,
+  SendMessageOptions,
+  SessionState,
+  Subscription,
+  UserInfoTransfer,
+} from './types';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+const bridge = createEventBridge(
+  NativeWatchConnectivity as unknown as {
+    addListener?(name: string): void;
+    removeListeners?(n: number): void;
+  }
+);
+
+export const WatchConnectivity = {
+  /** Activate `WCSession.default` and set the module as its delegate.
+   *  Idempotent — calling twice is safe. Resolves with the current
+   *  session state once activation is requested (note: the actual
+   *  `activated` state may arrive asynchronously via `'stateChanged'`). */
+  activate(): Promise<SessionState> {
+    return NativeWatchConnectivity.activate() as Promise<SessionState>;
+  },
+
+  /** Snapshot of the current `WCSession` state. */
+  getState(): Promise<SessionState> {
+    return NativeWatchConnectivity.getState() as Promise<SessionState>;
+  },
+
+  /** Send an immediate message to the peer. Peer must be reachable.
+   *  When `expectReply: true`, resolves with the peer's reply payload;
+   *  otherwise resolves once the OS accepts the send. */
+  async sendMessage(
+    message: Dictionary,
+    opts?: SendMessageOptions
+  ): Promise<Dictionary | undefined> {
+    const expectReply = opts?.expectReply ?? false;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const result = (await NativeWatchConnectivity.sendMessage(
+      message,
+      expectReply,
+      timeoutMs
+    )) as Dictionary | null;
+    return result ?? undefined;
+  },
+
+  /** Binary equivalent of `sendMessage`. Payload is base64-encoded on
+   *  the wire — callers must encode/decode themselves. */
+  async sendMessageData(
+    base64: string,
+    opts?: SendMessageOptions
+  ): Promise<string | undefined> {
+    const expectReply = opts?.expectReply ?? false;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const result = (await NativeWatchConnectivity.sendMessageData(
+      base64,
+      expectReply,
+      timeoutMs
+    )) as string | null;
+    return result ?? undefined;
+  },
+
+  /** Last-write-wins persistent context shared with the peer. The peer
+   *  reads it via `getReceivedApplicationContext()` or the
+   *  `'applicationContext'` event. Survives app restarts. */
+  updateApplicationContext(context: Dictionary): Promise<void> {
+    return NativeWatchConnectivity.updateApplicationContext(
+      context
+    ) as Promise<void>;
+  },
+
+  /** The context this side most recently pushed via
+   *  `updateApplicationContext` (may not have been delivered yet). */
+  getApplicationContext(): Promise<Dictionary> {
+    return NativeWatchConnectivity.getApplicationContext() as Promise<Dictionary>;
+  },
+
+  /** The latest context this side received from the peer. Persists
+   *  across launches — querying immediately after `activate()` returns
+   *  the value last delivered while the app was running or backgrounded. */
+  getReceivedApplicationContext(): Promise<Dictionary> {
+    return NativeWatchConnectivity.getReceivedApplicationContext() as Promise<Dictionary>;
+  },
+
+  /** Queue an opaque dictionary for background delivery to the peer.
+   *  Survives reboots; delivered FIFO when the peer is reachable. */
+  transferUserInfo(info: Dictionary): Promise<{ id: string }> {
+    return NativeWatchConnectivity.transferUserInfo(info) as Promise<{
+      id: string;
+    }>;
+  },
+
+  /** Transfers this side has enqueued but the peer hasn't acknowledged. */
+  outstandingUserInfoTransfers(): Promise<UserInfoTransfer[]> {
+    return NativeWatchConnectivity.outstandingUserInfoTransfers() as Promise<
+      UserInfoTransfer[]
+    >;
+  },
+
+  /** Subscribe to an event. Returns a `Subscription` whose `.remove()`
+   *  unsubscribes the listener. For `'message'` and `'messageData'`,
+   *  return a value from the handler (or a promise resolving to one)
+   *  to reply when the peer used `expectReply: true`. */
+  on<E extends EventName>(event: E, handler: EventMap[E]): Subscription {
+    if (event === 'message') {
+      return bridge.subscribe('message', (payload) => {
+        const msg = payload as ReceivedMessage;
+        const result = (handler as EventMap['message'])(msg);
+        if (msg.replyId == null) return;
+        Promise.resolve(result).then(
+          (value) => {
+            if (value == null) return;
+            NativeWatchConnectivity.replyToMessage(
+              msg.replyId!,
+              value as Dictionary
+            );
+          },
+          () => {
+            // Swallow — there's no way to surface a reply-handler throw
+            // back to the peer. The peer will time out instead.
+          }
+        );
+      });
+    }
+    if (event === 'messageData') {
+      return bridge.subscribe('messageData', (payload) => {
+        const msg = payload as ReceivedMessageData;
+        const result = (handler as EventMap['messageData'])(msg);
+        if (msg.replyId == null) return;
+        Promise.resolve(result).then(
+          (value) => {
+            if (value == null) return;
+            NativeWatchConnectivity.replyToMessageData(
+              msg.replyId!,
+              value as string
+            );
+          },
+          () => undefined
+        );
+      });
+    }
+    return bridge.subscribe(event, handler as (p: unknown) => void);
+  },
+};
+
+export default WatchConnectivity;

package/src/watchConnectivity/specs/NativeWatchConnectivity.ts

@@ -0,0 +1,56 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+// Shipped from the library so iOS RN codegen (driven by the package-level
+// `codegenConfig` in `package.json`) discovers it from
+// `node_modules/@appsent-co/react-native-watchos/src/watchConnectivity/specs/`. The
+// watch-side codegen plugin (`withWatchTurboModuleCodegen`) ALSO scans
+// this directory so the same spec produces the watch target's umbrella
+// header.
+
+export interface SessionState {
+  activationState: string; // 'notActivated' | 'inactive' | 'activated'
+  isReachable: boolean;
+  isPaired: boolean; // iOS only — false on watch
+  isWatchAppInstalled: boolean; // iOS only — false on watch
+  isCompanionAppInstalled: boolean; // watch only — false on iOS
+}
+
+export interface UserInfoTransfer {
+  id: string;
+  userInfo: Object;
+}
+
+export interface Spec extends TurboModule {
+  activate(): Promise<SessionState>;
+  getState(): Promise<SessionState>;
+
+  sendMessage(
+    message: Object,
+    expectReply: boolean,
+    timeoutMs: number
+  ): Promise<Object | null>;
+  sendMessageData(
+    base64: string,
+    expectReply: boolean,
+    timeoutMs: number
+  ): Promise<string | null>;
+
+  replyToMessage(replyId: string, payload: Object): void;
+  replyToMessageData(replyId: string, base64: string): void;
+
+  updateApplicationContext(context: Object): Promise<void>;
+  getApplicationContext(): Promise<Object>;
+  getReceivedApplicationContext(): Promise<Object>;
+
+  transferUserInfo(info: Object): Promise<{ id: string }>;
+  outstandingUserInfoTransfers(): Promise<UserInfoTransfer[]>;
+
+  // No-op stubs for iOS NativeEventEmitter contract; the watch side
+  // routes through `globalThis.__RNW_EVENTS.dispatchEvent` (name-keyed
+  // fan-out in the JS-side shim) and ignores these on both platforms.
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('WatchConnectivity');