ping-openmls-sdk-react-native-macos 0.2.0

package/src/NativePing.ts

@@ -0,0 +1,162 @@
+// TurboModule spec for `ping-openmls-sdk-react-native-macos`.
+//
+// react-native-codegen reads this file (declared in package.json `codegenConfig.jsSrcsDir`)
+// and generates the C++/Swift host-object wiring at build time. The interface below is
+// the authoritative contract between JS and the native module — adding a method here is
+// a separate step from implementing it natively, but both are required for it to work.
+//
+// `TurboModuleRegistry.getEnforcing` returns a JSI-backed host object on new arch and
+// falls through to the legacy `NativeModules.PingNative` proxy on old arch.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 2).
+
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  /**
+   * Stage 2 smoke test. Returns the integer 1 (the current ping-wire-contract version).
+   * Replaced in stage 4 with a call into the UniFFI-generated `WIRE_VERSION` constant.
+   */
+  getWireContractVersion(): Promise<number>;
+
+  /**
+   * Stage 3 acceptance test. Exercises the full Storage round-trip
+   * (Swift → JS → Swift) without involving Rust: put → get → listKeys → delete → get.
+   * Returns true on success; rejects with a `RoundtripMismatch` / `RoundtripError`
+   * code on failure.
+   */
+  testStorageRoundtrip(): Promise<boolean>;
+
+  /**
+   * Stage 3 internal: JS handlers call this to resolve a pending storage call.
+   * `value` shape depends on the method (see storage-bridge.ts).
+   * Consumers don't call this directly — `connectStorageBridge()` does.
+   */
+  resolveStorageCall(id: string, value: unknown): Promise<void>;
+  rejectStorageCall(id: string, message: string): Promise<void>;
+
+  /** Stage 3 internal: same shape as resolveStorageCall, but for the transport bridge. */
+  resolveTransportCall(id: string, value: unknown): Promise<void>;
+  rejectTransportCall(id: string, message: string): Promise<void>;
+
+  /**
+   * Stage 4b: generate a fresh identity. Returns the export bytes as base64. Hosts
+   * persist this and pass it back as `identityB64` on subsequent `initClient` calls.
+   */
+  generateIdentityExport(): Promise<string>;
+
+  /**
+   * Stage 4b: construct a real MessagingClient. The caller must have connected the
+   * storage + transport bridges via `connectStorageBridge` / `connectTransportBridge`
+   * before this so storage operations during init can resolve.
+   *
+   * - `identityB64` — base64 of the identity export bytes
+   * - `deviceLabel` — human-readable label (e.g. "MacBook")
+   * - `nowMs` — wall clock; pass `Date.now()`
+   *
+   * Resolves to `true` on success, rejects with `InitFailed` (Rust error) or
+   * `InvalidIdentity` (base64 decode) on failure.
+   */
+  initClient(identityB64: string, deviceLabel: string, nowMs: number): Promise<boolean>;
+
+  /** Returns the active client's user_id as a hex string. Rejects if not initialised. */
+  getUserId(): Promise<string>;
+
+  /** Returns the active client's device_id as a hex string. Rejects if not initialised. */
+  getDeviceId(): Promise<string>;
+
+  // ----- Stage 4c: messaging methods -----
+  // Byte arrays cross the bridge as `number[]` to match RN's NSArray<NSNumber> marshalling.
+
+  /** Fresh KeyPackage that peers can use to add this device to their groups. */
+  freshKeyPackage(): Promise<number[]>;
+
+  /** Create a new conversation. Returns the 16-byte conversation id. */
+  createConversation(name: string | null, nowMs: number): Promise<number[]>;
+
+  /**
+   * Join a conversation from a Welcome envelope. Returns the joined conversation id.
+   * Errors if the Welcome was for a different device's KeyPackage (the standard
+   * way to drop broadcast Welcomes on this device).
+   */
+  joinConversation(welcome: Record<string, unknown>, nowMs: number): Promise<number[]>;
+
+  /** Send an application message. Returns the wire `MessageEnvelope` as a JSON object. */
+  sendMessage(
+    conversationId: number[],
+    plaintext: number[],
+    nowMs: number,
+  ): Promise<Record<string, unknown>>;
+
+  /** Add members by their KeyPackage bytes. Resolves to null on success. */
+  addMembers(
+    conversationId: number[],
+    keyPackages: number[][],
+    nowMs: number,
+  ): Promise<null>;
+
+  /** Remove members by leaf index in the conversation's ratchet tree. */
+  removeMembers(
+    conversationId: number[],
+    leafIndexes: number[],
+    nowMs: number,
+  ): Promise<null>;
+
+  // ----- Stage 4d: sync methods -----
+
+  /**
+   * Process an incoming envelope. Returns the decrypted `IncomingMessage` JSON dict
+   * for Application envelopes, or `null` for handshake kinds (Commit/Welcome/Proposal).
+   */
+  processEnvelope(
+    envelope: Record<string, unknown>,
+    nowMs: number,
+  ): Promise<Record<string, unknown> | null>;
+
+  /**
+   * Catch-up sync — pulls envelopes from the transport for every open conversation,
+   * applies them in order, returns the decrypted application messages.
+   */
+  syncConversations(nowMs: number): Promise<Record<string, unknown>[]>;
+
+  // ----- Stage 4e: discovery + observer -----
+
+  /** Metadata for every open conversation. */
+  listConversations(): Promise<Record<string, unknown>[]>;
+
+  /** Metadata for every known device (v0.1: just the local device). */
+  listDevices(): Promise<Record<string, unknown>[]>;
+
+  /**
+   * Install the observer bridge — after this, native fires `PingApplicationMessage`
+   * and `PingConversationUpdated` events. JS subscribes via `NativeEventEmitter`
+   * (see MessagingClient.onMessage / onConversationUpdated).
+   */
+  setObserver(): Promise<null>;
+
+  // ----- Stage 4f: linking + revocation -----
+
+  /** Build a linking ticket for a new device (caller is the existing device E). */
+  buildLinkingTicket(
+    newDeviceId: number[],
+    newDeviceKp: number[],
+    nowMs: number,
+  ): Promise<Record<string, unknown>>;
+
+  /** Consume a linking ticket (caller is the new device N). */
+  consumeLinkingTicket(
+    ticket: Record<string, unknown>,
+    nowMs: number,
+  ): Promise<null>;
+
+  /** Revoke a device — Remove proposals in DeviceGroup + every conversation. */
+  revokeDevice(deviceId: number[], nowMs: number): Promise<null>;
+
+  // ----- macOS-platform helpers -----
+
+  /** Write to the macOS pasteboard. Used by `installClipboardPolyfill()`. */
+  setClipboard(text: string): Promise<null>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("PingNative");

package/src/WebSocketTransport.ts

@@ -0,0 +1,118 @@
+// Reference WebSocket transport for `ping-openmls-sdk-react-native-macos`. Mirrors the
+// shape of the web SDK's `WebSocketTransport` so consumers can swap implementations
+// with a single import-line change.
+//
+// The relay we talk to (see `examples/relay-server`) accepts the JSON projection of
+// `MessageEnvelope` (byte fields wrapped as `[number]` arrays). The bridge marshals
+// in/out of this shape via the same projection — see `bindings/react-native-macos/ios/TypeBridge.swift`.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 5).
+
+import type { Transport } from "./transport-bridge";
+
+export interface WsTransportConfig {
+  /** http[s]:// base URL of the relay. Switched to ws[s]:// for the live stream. */
+  baseUrl: string;
+  /** Optional bearer token; sent as `Authorization` header on REST requests. */
+  authHeader?: string;
+  /** Override `globalThis.fetch` (test/SSR). RN ships a usable global by default. */
+  fetchImpl?: typeof fetch;
+}
+
+export class WebSocketTransport implements Transport {
+  private readonly fetchImpl: typeof fetch;
+  private ws: WebSocket | null = null;
+  private liveHandlers = new Set<(env: Record<string, unknown>) => void>();
+  private closed = false;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(private readonly cfg: WsTransportConfig) {
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.openSocket();
+  }
+
+  private openSocket(): void {
+    if (typeof WebSocket === "undefined") return;
+    const url = `${this.cfg.baseUrl.replace(/^http/, "ws")}/stream`;
+    const ws = new WebSocket(url);
+    this.ws = ws;
+    ws.onmessage = (ev: { data: string | ArrayBuffer }) => {
+      const text = typeof ev.data === "string"
+        ? ev.data
+        : (() => { try { return new TextDecoder().decode(ev.data as ArrayBuffer); } catch { return ""; } })();
+      try {
+        const env = JSON.parse(text) as Record<string, unknown>;
+        for (const h of this.liveHandlers) h(env);
+      } catch {
+        // ignore malformed frames
+      }
+    };
+    ws.onclose = () => {
+      this.ws = null;
+      if (this.closed) return;
+      this.reconnectTimer = setTimeout(() => this.openSocket(), 1000);
+    };
+    ws.onerror = () => { /* onclose follows */ };
+  }
+
+  // ----- Transport interface -----
+
+  async send(envelope: Record<string, unknown>): Promise<void> {
+    const res = await this.fetchImpl(`${this.cfg.baseUrl}/send`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(this.cfg.authHeader ? { authorization: this.cfg.authHeader } : {}),
+      },
+      body: JSON.stringify(envelope),
+    });
+    if (res.status === 409) throw new Error("EpochOccupied");
+    if (!res.ok && res.status !== 204) {
+      throw new Error(`transport send failed: ${res.status}`);
+    }
+  }
+
+  async fetchSince(
+    conversationIdHex: string,
+    cursorBase64: string,
+    limit: number,
+  ): Promise<Record<string, unknown>[]> {
+    // Hermes doesn't fully implement `URL` / `URLSearchParams` (set is missing on RN
+    // 0.73's polyfill), so build the query string manually. encodeURIComponent is
+    // available on every JS engine.
+    const qs = `conv=${encodeURIComponent(conversationIdHex)}` +
+               `&cursor=${encodeURIComponent(cursorBase64)}` +
+               `&limit=${limit}`;
+    const res = await this.fetchImpl(`${this.cfg.baseUrl}/sync?${qs}`, {
+      headers: this.cfg.authHeader ? { authorization: this.cfg.authHeader } : {},
+    });
+    if (!res.ok) throw new Error(`transport fetch failed: ${res.status}`);
+    const body = (await res.json()) as Record<string, unknown>[];
+    return Array.isArray(body) ? body : [];
+  }
+
+  async discoverDevices(userIdHex: string): Promise<Record<string, unknown>[]> {
+    const res = await this.fetchImpl(`${this.cfg.baseUrl}/devices/${userIdHex}`, {
+      headers: this.cfg.authHeader ? { authorization: this.cfg.authHeader } : {},
+    });
+    if (!res.ok) throw new Error(`device discovery failed: ${res.status}`);
+    const body = (await res.json()) as Record<string, unknown>[];
+    return Array.isArray(body) ? body : [];
+  }
+
+  subscribe(onEvent: (env: Record<string, unknown>) => void): { unsubscribe(): void } {
+    this.liveHandlers.add(onEvent);
+    return {
+      unsubscribe: () => { this.liveHandlers.delete(onEvent); },
+    };
+  }
+
+  /** Close the WebSocket and stop reconnecting. */
+  close(): void {
+    this.closed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.ws?.close();
+    this.ws = null;
+    this.liveHandlers.clear();
+  }
+}

package/src/clipboard.ts

@@ -0,0 +1,37 @@
+// Clipboard helpers for the macOS desktop. Hermes (RN's JS engine) doesn't expose
+// `navigator.clipboard.writeText` — this module bridges to AppKit's NSPasteboard via
+// the native module.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 5).
+
+import NativePing from "./NativePing";
+
+/** Write a string to the macOS pasteboard. */
+export async function setClipboard(text: string): Promise<void> {
+  await NativePing.setClipboard(text);
+}
+
+/**
+ * Install `globalThis.navigator.clipboard.writeText` so libraries that target the
+ * browser API (like the shared `<ChatScreen>` component's copy button) work on
+ * RN-macOS without any per-call site changes.
+ *
+ * Idempotent — calling multiple times is fine. Returns the polyfilled function.
+ */
+export function installClipboardPolyfill(): (text: string) => Promise<void> {
+  const writeText = (text: string) => setClipboard(text);
+  const g = globalThis as unknown as {
+    navigator?: { clipboard?: { writeText?: (text: string) => Promise<void> } };
+  };
+  if (!g.navigator) {
+    (globalThis as unknown as { navigator: object }).navigator = {};
+  }
+  if (!g.navigator!.clipboard) {
+    g.navigator!.clipboard = {};
+  }
+  // Don't overwrite an existing clipboard impl (e.g. another polyfill already ran).
+  if (!g.navigator!.clipboard!.writeText) {
+    g.navigator!.clipboard!.writeText = writeText;
+  }
+  return writeText;
+}

package/src/index.ts

@@ -0,0 +1,112 @@
+// Public API for `ping-openmls-sdk-react-native-macos`.
+//
+// Drop-in replaceable for `ping-openmls-sdk` (the WASM-based web SDK) — a desktop app
+// can swap between the two with a single import-line change. The class shapes,
+// method signatures, and event semantics are mirrored 1:1.
+//
+// What's exported:
+//
+//   Core API:
+//     • `MessagingClient` — the top-level handle. `MessagingClient.init({...})` returns one.
+//     • `Conversation` — scoped handle returned from `client.createConversation` /
+//       `client.getConversation`. Carries `send`, `addMembers`, `removeMembers`.
+//
+//   Types:
+//     • `ClientConfig`       — shape of `MessagingClient.init`'s argument
+//     • `IncomingMessage`    — decrypted application message
+//     • `MessageEnvelope`    — wire-format envelope (the substrate; subscribers to the
+//                              transport's live stream feed these to `client.processEnvelope`)
+//     • `ConversationMeta`   — return shape of `client.listConversations`
+//     • `DeviceInfo`         — return shape of `client.listDevices`
+//     • `LinkingTicket`      — return shape of `client.buildLinkingTicket`
+//     • `Storage`, `Transport` — interfaces hosts implement and pass to `MessagingClient.init`
+//
+//   Storage helpers:
+//     • `InMemoryStorage`        — Map-backed Storage; useful for tests + the smoke flow
+//     • `connectStorageBridge`   — low-level — `MessagingClient.init` calls this internally;
+//                                   exposed for advanced multi-client setups
+//     • `connectTransportBridge` — same pattern for Transport
+//
+//   Bridge health checks:
+//     • `getWireContractVersion()` — JS↔Swift round-trip smoke test
+//     • `testStorageRoundtrip()`   — Rust→Swift→JS→Swift→Rust round-trip self-test
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md.
+
+import NativePing from "./NativePing";
+
+export {
+  connectStorageBridge,
+  InMemoryStorage,
+  type Storage,
+} from "./storage-bridge";
+
+export {
+  connectTransportBridge,
+  type Transport,
+} from "./transport-bridge";
+
+export {
+  WebSocketTransport,
+  type WsTransportConfig,
+} from "./WebSocketTransport";
+
+export {
+  setClipboard,
+  installClipboardPolyfill,
+} from "./clipboard";
+
+export {
+  MessagingClient,
+  Conversation,
+  type ClientConfig,
+  type IncomingMessage,
+  type ConversationMeta,
+  type DeviceInfo,
+  type LinkingTicket,
+} from "./MessagingClient";
+
+/**
+ * Wire-format envelope. Hosts that subscribe to the transport's live stream feed
+ * received envelopes to `client.processEnvelope`; the SDK then decrypts and emits
+ * `IncomingMessage` via `client.onMessage`.
+ *
+ * Shape mirrors `ping-openmls-sdk`'s `MessageEnvelope` exactly. Byte fields are
+ * `Uint8Array` on the public surface; the bridge marshals them as `number[]` JSON
+ * arrays internally.
+ */
+export interface MessageEnvelope {
+  v: number;
+  conversationId: Uint8Array;
+  epoch: number;
+  kind: "Application" | "Commit" | "Welcome" | "Proposal" | "KeyPackage";
+  senderDevice: Uint8Array;
+  seq: number;
+  hlc: { wallMs: number; logical: number };
+  payload: Uint8Array;
+  contentHash: Uint8Array;
+}
+
+/**
+ * Smoke test for the native bridge. Returns `1` if the JS↔Swift round-trip works.
+ *
+ * Exported in every stage so consumers can confirm their TurboModule is loaded
+ * correctly without needing to instantiate a full `MessagingClient`.
+ */
+export async function getWireContractVersion(): Promise<number> {
+  return NativePing.getWireContractVersion();
+}
+
+/**
+ * Stage 3 acceptance test. Exercises the Storage callback bridge end-to-end
+ * (Swift → JS → Swift) by performing put → get → listKeys → delete → get on a
+ * Storage object that you've previously connected via `connectStorageBridge`.
+ *
+ * Returns `true` on success. Rejects with `RoundtripMismatch` if the round-tripped
+ * bytes differ from the originals, or `RoundtripError` for any other failure.
+ *
+ * Mostly useful as a health check after install — production code should rarely call this.
+ */
+export async function testStorageRoundtrip(): Promise<boolean> {
+  return NativePing.testStorageRoundtrip();
+}

package/src/storage-bridge.ts

@@ -0,0 +1,124 @@
+// JS-side wiring for the Storage callback bridge. The user supplies a `Storage`
+// implementation (matching `ping-openmls-sdk`'s Storage interface); we attach event
+// listeners that route native bridge calls to it and pipe the results back via
+// `PingNative.resolveStorageCall` / `rejectStorageCall`.
+//
+// Stage 4 will tie this lifecycle to `MessagingClient.init` automatically. For stage 3
+// it's exposed as a standalone helper so the round-trip self-test can wire a Storage
+// up before calling `testStorageRoundtrip()`.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 3).
+
+import { NativeEventEmitter, NativeModules } from "react-native";
+
+/**
+ * Storage interface — same shape as `ping-openmls-sdk`'s `Storage` so MessagingClient.init
+ * (stage 4) can accept either.
+ */
+export interface Storage {
+  get(namespace: string, key: string): Promise<Uint8Array | null>;
+  put(namespace: string, key: string, value: Uint8Array): Promise<void>;
+  delete(namespace: string, key: string): Promise<void>;
+  listKeys(namespace: string, prefix: string): Promise<string[]>;
+}
+
+interface StorageCallEvent {
+  id: string;
+  method: "get" | "put" | "delete" | "listKeys";
+  args: Record<string, unknown>;
+}
+
+/**
+ * Connect a JS Storage implementation to the native bridge. Returns an unsubscribe
+ * function that detaches the event listener. Calling unsubscribe leaves any
+ * already-in-flight calls hanging — only do it during teardown.
+ */
+export function connectStorageBridge(storage: Storage): () => void {
+  const emitter = new NativeEventEmitter(NativeModules.PingNative);
+
+  const subscription = emitter.addListener("PingStorageCall", (event: StorageCallEvent) => {
+    void handle(event, storage);
+  });
+
+  return () => subscription.remove();
+}
+
+async function handle(event: StorageCallEvent, storage: Storage): Promise<void> {
+  const { id, method, args } = event;
+  try {
+    let result: unknown;
+    switch (method) {
+      case "get": {
+        const v = await storage.get(args.namespace as string, args.key as string);
+        result = v === null ? null : Array.from(v);
+        break;
+      }
+      case "put": {
+        const value = bytesIn(args.value);
+        await storage.put(args.namespace as string, args.key as string, value);
+        result = null;
+        break;
+      }
+      case "delete": {
+        await storage.delete(args.namespace as string, args.key as string);
+        result = null;
+        break;
+      }
+      case "listKeys": {
+        result = await storage.listKeys(args.namespace as string, args.prefix as string);
+        break;
+      }
+      default:
+        throw new Error(`unknown storage method: ${String(method)}`);
+    }
+    await NativeModules.PingNative.resolveStorageCall(id, result);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    try {
+      await NativeModules.PingNative.rejectStorageCall(id, message);
+    } catch {
+      // If even the reject fails (native module gone?), drop the call — the Swift
+      // continuation will leak but the alternative is a crash on teardown.
+    }
+  }
+}
+
+function bytesIn(v: unknown): Uint8Array {
+  if (v instanceof Uint8Array) return v;
+  if (Array.isArray(v)) return Uint8Array.from(v as number[]);
+  return new Uint8Array(0);
+}
+
+/**
+ * Trivial in-memory Storage implementation, useful for tests + the stage 3 round-trip
+ * self-test. Production consumers will use a SQLite-backed implementation (per the
+ * decision recorded in docs/RN_NATIVE_BINDINGS.md — GRDB).
+ */
+export class InMemoryStorage implements Storage {
+  private readonly map = new Map<string, Uint8Array>();
+
+  private k(ns: string, key: string): string { return `${ns}/${key}`; }
+
+  async get(namespace: string, key: string): Promise<Uint8Array | null> {
+    return this.map.get(this.k(namespace, key)) ?? null;
+  }
+
+  async put(namespace: string, key: string, value: Uint8Array): Promise<void> {
+    this.map.set(this.k(namespace, key), value);
+  }
+
+  async delete(namespace: string, key: string): Promise<void> {
+    this.map.delete(this.k(namespace, key));
+  }
+
+  async listKeys(namespace: string, prefix: string): Promise<string[]> {
+    const out: string[] = [];
+    const nsPrefix = `${namespace}/`;
+    for (const k of this.map.keys()) {
+      if (!k.startsWith(nsPrefix)) continue;
+      const rel = k.slice(nsPrefix.length);
+      if (rel.startsWith(prefix)) out.push(rel);
+    }
+    return out;
+  }
+}

package/src/transport-bridge.ts

@@ -0,0 +1,89 @@
+// JS-side wiring for the Transport callback bridge. Same pattern as
+// `storage-bridge.ts` — the user supplies a Transport-like object, we attach a listener
+// to "PingTransportCall" events, route calls to the user's object, pipe results back
+// via `PingNative.resolveTransportCall` / `rejectTransportCall`.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 3).
+
+import { NativeEventEmitter, NativeModules } from "react-native";
+
+/**
+ * Transport interface — same shape as `ping-openmls-sdk`'s web Transport.
+ *
+ * The first three methods are invoked by the Rust core (via the bridge) when it
+ * needs to send/fetch/discover. The optional `subscribe` is invoked by
+ * `MessagingClient.init` to wire the transport's live-receive path into the SDK
+ * without an explicit user-side `processEnvelope` call.
+ */
+export interface Transport {
+  send(envelopeJson: Record<string, unknown>): Promise<void>;
+  fetchSince(conversationIdHex: string, cursorBase64: string, limit: number): Promise<Record<string, unknown>[]>;
+  discoverDevices(userIdHex: string): Promise<Record<string, unknown>[]>;
+  /**
+   * Subscribe to live envelope frames (typically from a WebSocket). The SDK calls
+   * this once during `MessagingClient.init`; each frame is fed into
+   * `client.processEnvelope` automatically. Implementations return an unsubscribe
+   * handle.
+   */
+  subscribe?(onEvent: (envelopeJson: Record<string, unknown>) => void): { unsubscribe(): void };
+}
+
+interface TransportCallEvent {
+  id: string;
+  method: "send" | "fetchSince" | "discoverDevices";
+  args: Record<string, unknown>;
+}
+
+/** Connect a JS Transport implementation to the native bridge. */
+export function connectTransportBridge(transport: Transport): () => void {
+  const emitter = new NativeEventEmitter(NativeModules.PingNative);
+
+  const subscription = emitter.addListener("PingTransportCall", (event: TransportCallEvent) => {
+    void handle(event, transport);
+  });
+
+  return () => subscription.remove();
+}
+
+async function handle(event: TransportCallEvent, transport: Transport): Promise<void> {
+  const { id, method, args } = event;
+  // eslint-disable-next-line no-console
+  console.log("[transport-bridge]", method, "args=", JSON.stringify(args).slice(0, 200));
+  try {
+    let result: unknown;
+    switch (method) {
+      case "send": {
+        await transport.send(args.envelope as Record<string, unknown>);
+        result = null;
+        break;
+      }
+      case "fetchSince": {
+        result = await transport.fetchSince(
+          args.conversationIdHex as string,
+          args.cursorBase64 as string,
+          args.limit as number,
+        );
+        break;
+      }
+      case "discoverDevices": {
+        result = await transport.discoverDevices(args.userIdHex as string);
+        break;
+      }
+      default:
+        throw new Error(`unknown transport method: ${String(method)}`);
+    }
+    // eslint-disable-next-line no-console
+    console.log("[transport-bridge]", method, "OK, result-len=",
+      Array.isArray(result) ? result.length : (result === null ? "null" : typeof result));
+    await NativeModules.PingNative.resolveTransportCall(id, result);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    // eslint-disable-next-line no-console
+    console.warn("[transport-bridge]", method, "FAILED:", message);
+    try {
+      await NativeModules.PingNative.rejectTransportCall(id, message);
+    } catch {
+      // see storage-bridge.ts comment
+    }
+  }
+}