@chitchat/sdk-react-native 0.2.0-dev.2 → 0.3.0-dev.1

package/ChitChatTcp.podspec

@@ -0,0 +1,15 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+Pod::Spec.new do |s|
+  s.name = 'ChitChatTcp'
+  s.version = package['version']
+  s.summary = 'ChitChat TLS TCP protobuf transport'
+  s.homepage = package['homepage']
+  s.license = { :type => 'UNLICENSED' }
+  s.author = 'ChitChat'
+  s.platforms = { :ios => '15.1' }
+  s.source = { :git => 'https://github.com/07Akashh/E2E-Chat.git', :tag => s.version.to_s }
+  s.source_files = 'ios/**/*.{h,m,mm}'
+  s.dependency 'React-Core'
+  s.dependency 'CocoaAsyncSocket', '7.6.5'
+end

package/README.md

@@ -1,5 +1,12 @@
 # ChitChat React Native SDK
 
+## 0.3.0-dev.0 source release
+
+Adds packaged Android/iOS TLS TCP sources, the protobuf handshake adapter, createChitChatNativeCalls and @chitchat/sdk-react-native/react. TCP + protobuf remains the default; WSS is optional and never an automatic fallback.
+
+This version is **not yet published or production-certified**. See the [calling quickstart](../docs/CALLING.md), [all-five SDK audit](../docs/GAP_AUDIT.md), [migration/support targets](../docs/RELEASE.md), and [local tarball installation](../README.md). Existing npm development tags may still resolve to older SDKs.
+
+
 `@chitchat/sdk-react-native` connects a React Native application through a native TLS TCP transport and binary Protobuf frames. It is for iOS/Android native builds; it is not a browser SDK.
 
 This package is currently a **development prerelease**. Pin the version you have tested before shipping an application.
@@ -10,11 +17,9 @@ The native SDK validates both the TLS endpoint and the linked bridge result befo
 
 ## Read this before integrating
 
-This JavaScript package needs a linked native bridge. You pass that bridge as `nativeModule`; the SDK does not secretly create TCP sockets in JavaScript.
+This package now includes an autolinkable `ChitChatTcp` byte-stream module. The default `createChitChatNativeClient({ endpoint, deviceId, tokenProvider })` loads it and handles the binary protobuf handshake. Run pods and rebuild after installing. Install `react-native-webrtc` separately for calling. Expo Go cannot load these native modules.
 
-For the current ChitChat app implementation, the bridge is exposed as `NativeModules.XMPPNativeModule` (with `NativeModules.XMPPNative` as a compatibility fallback). A third-party application must include the official ChitChat native bridge or implement the same documented bridge contract. The bridge must perform TLS validation, Protobuf framing, and certificate policy on iOS and Android.
-
-**Expo Go cannot load custom native modules.** Use a development build or a prebuilt/bare React Native application, link the bridge, then rebuild iOS/Android.
+If reusing the ChitChat app's `XMPPNativeModule`, wrap it with `createChitChatNativeBridge`; it does not directly implement the high-level SDK connection contract. Do not let both the old app singleton and the SDK control the same native module. See the calling quickstart for both paths.
 
 ## 1. Install
 
@@ -30,43 +35,19 @@ You also need a backend session endpoint made with `@chitchat/sdk-server`. It re
 ## 2. Create the client
 
 ```js
-import { NativeModules } from 'react-native';
 import { createBackendTokenProvider } from '@chitchat/sdk-core';
-import { createChitChatNativeClient } from '@chitchat/sdk-react-native';
-
-const nativeModule = NativeModules.XMPPNativeModule || NativeModules.XMPPNative;
-if (!nativeModule) {
-  throw new Error('ChitChat native bridge is not linked; rebuild a development/native app.');
-}
-
-const tokenProvider = createBackendTokenProvider({
-  endpoint: 'https://api.example.com/api/chitchat/session',
-  getHeaders: () => ({ authorization: `Bearer ${getYourAppAccessToken()}` }),
-  getBody: () => ({ deviceId: getStableInstallationId() })
-});
-
-const client = createChitChatNativeClient({
-  // TLS TCP hostname. Port 443 is applied when the port is omitted.
-  endpoint: 'realtime.example.com',
-  tokenProvider,
-  nativeModule,
-  storage: durableNativeOutbox
-});
-
-client.on('connected', () => setRealtimeState('connected'));
-client.on('message', (frame) => handleChitChatFrame(frame));
-client.on('error', (error) => reportNonSensitiveRealtimeError(error));
-
-client.connect().catch(reportNonSensitiveRealtimeError);
+import { createChitChatNativeClient, createChitChatNativeCalls } from '@chitchat/sdk-react-native';
+const tokenProvider = createBackendTokenProvider({ endpoint: 'https://your-app.example/api/session', getBody: () => ({ deviceId }) });
+const realtime = createChitChatNativeClient({ endpoint: 'realtime.example.com:443', deviceId, tokenProvider });
+const calls = createChitChatNativeCalls({ realtime, participantId, getIceServers });
+await calls.join({ callId, participantIds });
+// On logout:
+await calls.dispose();
+await realtime.close();
+tokenProvider.invalidate();
 ```
 
-On logout or account switch:
-
-```js
-client.close()
-  .then(() => tokenProvider.invalidate())
-  .catch(reportNonSensitiveRealtimeError);
-```
+`participantId`, `participantIds` and `callId` come from the application's approved session/roster. `getIceServers` calls its authenticated backend. See the quickstart for authorization boundaries, native permissions and rendering.
 
 ## Native bridge contract
 
@@ -122,4 +103,4 @@ The default core outbox is memory-only. To preserve queued messages when the app
 
 ## Current scope
 
-This package provides the React Native client lifecycle and native transport adapter boundary. Call UI, CallKit/ConnectionService, push wake-up, ringtone, WebRTC media, meetings, streaming, notifications, and agents are separate platform features and must be integrated and tested before release.
+The 0.3 source release includes the calling additions described above. See the [gap audit](../docs/GAP_AUDIT.md) for supported behavior and remaining service requirements. Calling is a foreground small-mesh implementation. Server-authoritative rooms, roles, moderation, recording, signed call webhooks, SFU meetings, background native calling and device/browser production certification remain unimplemented or unverified.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sat Sep 12 14:17:30 IST 2026
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,14 @@
+buildscript {
+    def kotlinVersion = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : '2.0.21'
+    repositories { google(); mavenCentral() }
+    dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" }
+}
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+android {
+    namespace 'com.chitchat.sdk'
+    compileSdkVersion rootProject.ext.has('compileSdkVersion') ? rootProject.ext.get('compileSdkVersion') : 35
+    defaultConfig { minSdkVersion 24; targetSdkVersion 35 }
+}
+repositories { google(); mavenCentral() }
+dependencies { implementation 'com.facebook.react:react-android' }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

package/android/src/main/java/com/chitchat/sdk/ChitChatTcpModule.kt

@@ -0,0 +1,102 @@
+package com.chitchat.sdk
+
+import android.util.Base64
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.io.DataInputStream
+import java.net.InetSocketAddress
+import java.nio.ByteBuffer
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicInteger
+import javax.net.ssl.SSLParameters
+import javax.net.ssl.SSLSocket
+import javax.net.ssl.SSLSocketFactory
+
+/** TLS byte stream only. Authentication and protobuf decoding belong to JS. */
+class ChitChatTcpModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+    private val lock = Any()
+    private var generation = 0L
+    private var socket: SSLSocket? = null
+    private val writes = Executors.newSingleThreadExecutor()
+    private val pendingBytes = AtomicInteger(0)
+    override fun getName() = "ChitChatTcp"
+    override fun getConstants(): Map<String, Any> = mapOf("supportsTLS" to true, "supportsProtobufFrames" to true)
+    @ReactMethod(isBlockingSynchronousMethod = true) fun randomUUID(): String = java.util.UUID.randomUUID().toString()
+    @ReactMethod fun addListener(name: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
+    private fun emit(name: String, data: WritableMap? = null) {
+        if (context.hasActiveReactInstance()) context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(name, data)
+    }
+    private fun current(value: Long) = synchronized(lock) { generation == value }
+    private fun closeConnection(notify: Boolean) {
+        synchronized(lock) {
+            generation++
+            try { socket?.close() } catch (_: Exception) {}
+            socket = null
+        }
+        if (notify) emit("onDisconnected")
+    }
+    @ReactMethod fun disconnect() = closeConnection(true)
+    override fun invalidate() { closeConnection(false); writes.shutdownNow(); super.invalidate() }
+
+    @ReactMethod fun connectProtobuf(host: String, port: Int, useTLS: Boolean) {
+        if (!useTLS || host.isBlank() || port !in 1..65535) {
+            emit("onError", Arguments.createMap().apply { putString("code", "INVALID_TLS_ENDPOINT") }); return
+        }
+        closeConnection(false)
+        val attempt = synchronized(lock) { generation }
+        Thread {
+            var connected: SSLSocket? = null
+            try {
+                val target = SSLSocketFactory.getDefault().createSocket() as SSLSocket
+                connected = target
+                synchronized(lock) {
+                    if (generation != attempt) { target.close(); return@Thread }
+                    socket = target
+                }
+                target.soTimeout = 15000
+                target.connect(InetSocketAddress(host, port), 15000)
+                target.sslParameters = SSLParameters().apply { endpointIdentificationAlgorithm = "HTTPS" }
+                target.enabledProtocols = target.supportedProtocols.filter { it == "TLSv1.2" || it == "TLSv1.3" }.toTypedArray()
+                target.startHandshake()
+                if (!current(attempt)) return@Thread
+                target.soTimeout = 60000
+                emit("onTransportOpen", Arguments.createMap().apply { putBoolean("tls", true) })
+                val input = DataInputStream(target.inputStream)
+                while (current(attempt)) {
+                    val length = input.readInt()
+                    if (length !in 1..1048576) throw IllegalArgumentException("Frame size")
+                    val bytes = ByteArray(length + 4)
+                    ByteBuffer.wrap(bytes).putInt(length)
+                    input.readFully(bytes, 4, length)
+                    if (current(attempt)) emit("onProtobufFrame", Arguments.createMap().apply { putString("frame", Base64.encodeToString(bytes, Base64.NO_WRAP)) })
+                }
+            } catch (_: Exception) {
+                if (current(attempt)) {
+                    emit("onError", Arguments.createMap().apply { putString("code", "TLS_TRANSPORT_FAILED") })
+                    closeConnection(true)
+                }
+            } finally { try { connected?.close() } catch (_: Exception) {} }
+        }.start()
+    }
+
+    @ReactMethod fun sendProtobufFrame(frame: String, promise: Promise) {
+        if (frame.length > 1398108) { promise.reject("FRAME_TOO_LARGE", "Frame exceeds limit"); return }
+        val bytes = try { Base64.decode(frame, Base64.NO_WRAP) } catch (_: Exception) { promise.reject("INVALID_FRAME", "Invalid binary frame"); return }
+        if (bytes.size !in 5..1048580 || ByteBuffer.wrap(bytes).int != bytes.size - 4) { promise.reject("INVALID_FRAME", "Invalid frame length"); return }
+        if (pendingBytes.addAndGet(bytes.size) > 4194320) { pendingBytes.addAndGet(-bytes.size); promise.reject("BACKPRESSURE", "Native send queue is full"); return }
+        val attempt = synchronized(lock) { generation }
+        try {
+            writes.execute {
+                try {
+                    val target = synchronized(lock) { if (attempt == generation) socket else null } ?: throw IllegalStateException()
+                    target.outputStream.write(bytes)
+                    target.outputStream.flush()
+                    promise.resolve(null)
+                } catch (_: Exception) { promise.reject("NATIVE_SEND_FAILED", "Secure transport write failed") }
+                finally { pendingBytes.addAndGet(-bytes.size) }
+            }
+        } catch (_: Exception) { pendingBytes.addAndGet(-bytes.size); promise.reject("NATIVE_CLOSED", "Native transport is closed") }
+    }
+}

package/android/src/main/java/com/chitchat/sdk/ChitChatTcpPackage.kt

@@ -0,0 +1,11 @@
+package com.chitchat.sdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ChitChatTcpPackage : ReactPackage {
+    override fun createNativeModules(context: ReactApplicationContext): List<NativeModule> = listOf(ChitChatTcpModule(context))
+    override fun createViewManagers(context: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/index.d.ts

@@ -4,4 +4,18 @@ export interface ChitChatNativeModule { connect(input: { endpoint: string; token
 export function validateNativeTlsEndpoint(endpoint: string): string;
 export function validatePinnedPublicKeyHashes(value?: string[]): string[];
 export function createNativeTcpTransportFactory(options: { nativeModule: ChitChatNativeModule; pinnedPublicKeyHashes?: string[]; minimumTlsVersion?: 'TLSv1.2' | 'TLSv1.3' }): ReliableRealtimeClientOptions['nativeTransportFactory'];
-export function createChitChatNativeClient(options: Omit<ReliableRealtimeClientOptions, 'runtime' | 'nativeTransportFactory'> & { nativeModule: ChitChatNativeModule; pinnedPublicKeyHashes?: string[]; minimumTlsVersion?: 'TLSv1.2' | 'TLSv1.3' }): ReliableRealtimeClient;
+export function createChitChatNativeClient(options: Omit<ReliableRealtimeClientOptions, 'runtime' | 'nativeTransportFactory'> & { nativeModule?: ChitChatNativeModule; protobuf?: import('@chitchat/sdk-protocol').RealtimeEnvelopeCodec; deviceId?: string; pinnedPublicKeyHashes?: string[]; minimumTlsVersion?: 'TLSv1.2' | 'TLSv1.3' }): ReliableRealtimeClient;
+
+export interface NativeMediaTrack { id: string; kind: string; enabled: boolean; stop(): void; }
+export interface NativeMediaStream { id: string; toURL(): string; getTracks(): NativeMediaTrack[]; getAudioTracks(): NativeMediaTrack[]; getVideoTracks(): NativeMediaTrack[]; }
+export type NativeCallsClient = import('@chitchat/sdk-core').CallsClient<NativeMediaStream, NativeMediaTrack>;
+export function createChitChatNativeCalls(options: Omit<import('@chitchat/sdk-core').CallsOptions, 'rtc'> & { rtc?: import('@chitchat/sdk-core').WebRtcRuntime }): NativeCallsClient;
+export const createChitChatNativeWssClient: typeof import('@chitchat/sdk-web').createChitChatWebClient;
+export interface NativeProtobufModule {
+  supportsTLS: boolean;
+  supportsProtobufFrames: boolean;
+  connectProtobuf(host: string, port: number, useTLS: true): void | Promise<void>;
+  sendProtobufFrame(base64: string): void | Promise<void>;
+  disconnect(): void | Promise<void>;
+}
+export function createChitChatNativeBridge(options: { nativeModule: NativeProtobufModule; eventEmitter: { addListener(event: string, listener: (value: any) => void): { remove(): void } }; protobuf: import('@chitchat/sdk-protocol').RealtimeEnvelopeCodec; openTimeoutMs?: number }): ChitChatNativeModule;

package/ios/ChitChatTcp.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+@interface ChitChatTcp : RCTEventEmitter <RCTBridgeModule>
+@end

package/ios/ChitChatTcp.mm

@@ -0,0 +1,84 @@
+#import "ChitChatTcp.h"
+#import <CocoaAsyncSocket/GCDAsyncSocket.h>
+#import <CFNetwork/CFNetwork.h>
+
+@interface ChitChatTcp () <GCDAsyncSocketDelegate>
+@property(nonatomic, strong) GCDAsyncSocket *socket;
+@property(nonatomic, copy) NSString *host;
+@property(nonatomic, strong) NSData *header;
+@property(nonatomic, assign) BOOL listening;
+@property(nonatomic, assign) BOOL secure;
+@property(nonatomic, assign) NSUInteger pendingBytes;
+@property(nonatomic, assign) long writeTag;
+@property(nonatomic, strong) NSMutableDictionary *pendingWrites;
+@end
+
+@implementation ChitChatTcp
+RCT_EXPORT_MODULE(ChitChatTcp)
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(randomUUID) { return [[NSUUID UUID] UUIDString]; }
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }
+- (NSDictionary *)constantsToExport { return @{ @"supportsTLS": @YES, @"supportsProtobufFrames": @YES }; }
+- (NSArray<NSString *> *)supportedEvents { return @[@"onTransportOpen", @"onProtobufFrame", @"onDisconnected", @"onError"]; }
+- (void)startObserving { self.listening = YES; }
+- (void)stopObserving { self.listening = NO; }
+- (void)emit:(NSString *)name body:(id)body { if (self.listening) [self sendEventWithName:name body:body]; }
+- (void)closeSocket {
+    self.socket.delegate = nil; [self.socket disconnect]; self.socket = nil; self.secure = NO; self.header = nil;
+    for (NSDictionary *entry in self.pendingWrites.allValues) { RCTPromiseRejectBlock reject = entry[@"reject"]; reject(@"NATIVE_CLOSED", @"Native transport closed", nil); }
+    [self.pendingWrites removeAllObjects]; self.pendingBytes = 0;
+}
+- (void)invalidate { [self closeSocket]; [super invalidate]; }
+RCT_EXPORT_METHOD(disconnect) { [self closeSocket]; [self emit:@"onDisconnected" body:@{}]; }
+RCT_EXPORT_METHOD(connectProtobuf:(NSString *)host port:(NSInteger)port useTLS:(BOOL)useTLS) {
+    [self closeSocket];
+    if (!useTLS || !host.length || port < 1 || port > 65535) { [self emit:@"onError" body:@{@"code": @"INVALID_TLS_ENDPOINT"}]; return; }
+    self.host = host; self.pendingWrites = [NSMutableDictionary dictionary];
+    self.socket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:dispatch_get_main_queue()];
+    NSError *error = nil;
+    if (![self.socket connectToHost:host onPort:(uint16_t)port withTimeout:15 error:&error]) [self emit:@"onError" body:@{@"code": @"TLS_CONNECT_FAILED"}];
+}
+- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port {
+    if (sock != self.socket) return;
+    [sock startTLS:@{ (__bridge NSString *)kCFStreamSSLPeerName: self.host,
+                     GCDAsyncSocketSSLProtocolVersionMin: @(kTLSProtocol12) }];
+}
+- (void)socketDidSecure:(GCDAsyncSocket *)sock {
+    if (sock != self.socket) return;
+    self.secure = YES; [self emit:@"onTransportOpen" body:@{@"tls": @YES}];
+    [sock readDataToLength:4 withTimeout:60 tag:1];
+}
+- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag {
+    if (sock != self.socket) return;
+    if (tag == 1) {
+        uint32_t length; [data getBytes:&length length:4]; length = CFSwapInt32BigToHost(length);
+        if (length < 1 || length > 1048576) { [sock disconnect]; return; }
+        self.header = data; [sock readDataToLength:length withTimeout:60 tag:2];
+    } else {
+        NSMutableData *frame = [self.header mutableCopy]; [frame appendData:data]; self.header = nil;
+        [self emit:@"onProtobufFrame" body:@{@"frame": [frame base64EncodedStringWithOptions:0]}];
+        [sock readDataToLength:4 withTimeout:60 tag:1];
+    }
+}
+RCT_EXPORT_METHOD(sendProtobufFrame:(NSString *)base64 resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    if (!self.secure || !self.socket) { reject(@"NATIVE_CLOSED", @"Secure transport is closed", nil); return; }
+    if (base64.length > 1398108) { reject(@"FRAME_TOO_LARGE", @"Frame exceeds limit", nil); return; }
+    NSData *frame = [[NSData alloc] initWithBase64EncodedString:base64 options:0];
+    uint32_t length = 0; if (frame.length >= 4) [frame getBytes:&length length:4];
+    if (frame.length < 5 || frame.length > 1048580 || CFSwapInt32BigToHost(length) != frame.length - 4) { reject(@"INVALID_FRAME", @"Invalid binary frame", nil); return; }
+    if (self.pendingBytes + frame.length > 4194320) { reject(@"BACKPRESSURE", @"Native send queue is full", nil); return; }
+    long tag = ++self.writeTag; self.pendingBytes += frame.length;
+    self.pendingWrites[@(tag)] = @{ @"resolve": [resolve copy], @"reject": [reject copy], @"bytes": @(frame.length) };
+    [self.socket writeData:frame withTimeout:15 tag:tag];
+}
+- (void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag {
+    if (sock != self.socket) return;
+    NSDictionary *entry = self.pendingWrites[@(tag)]; if (!entry) return;
+    self.pendingBytes -= [entry[@"bytes"] unsignedIntegerValue]; [self.pendingWrites removeObjectForKey:@(tag)];
+    RCTPromiseResolveBlock resolve = entry[@"resolve"]; resolve(nil);
+}
+- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)error {
+    if (sock != self.socket) return;
+    [self closeSocket]; [self emit:@"onDisconnected" body:@{}];
+}
+@end

package/package.json

@@ -1,19 +1,72 @@
 {
   "name": "@chitchat/sdk-react-native",
-  "version": "0.2.0-dev.2",
+  "version": "0.3.0-dev.1",
   "description": "React Native TLS transport adapter for the ChitChat Developer Platform",
-  "repository": { "type": "git", "url": "git+https://github.com/07Akashh/E2E-Chat.git", "directory": "developer-web/sdk/chitchat-native" },
-  "bugs": { "url": "https://github.com/07Akashh/E2E-Chat/issues" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/07Akashh/E2E-Chat.git",
+    "directory": "developer-web/sdk/chitchat-native"
+  },
+  "bugs": {
+    "url": "https://github.com/07Akashh/E2E-Chat/issues"
+  },
   "homepage": "https://github.com/07Akashh/E2E-Chat/tree/main/docs/developer-platform",
   "main": "src/index.js",
-  "exports": { ".": { "types": "./index.d.ts", "require": "./src/index.js", "import": "./src/index.js" } },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./src/index.js",
+      "import": "./src/index.js"
+    },
+    "./react": {
+      "types": "./react.d.ts",
+      "require": "./src/react.js",
+      "import": "./src/react.js"
+    }
+  },
   "types": "index.d.ts",
-  "files": ["src", "index.d.ts", "README.md"],
-  "engines": { "node": ">=18" },
-  "scripts": { "test": "node test/transport.test.js" },
-  "dependencies": { "@chitchat/sdk-core": "0.2.0-dev.2" },
-  "keywords": ["chitchat", "realtime", "react-native", "tls", "protobuf"],
+  "files": [
+    "src",
+    "index.d.ts",
+    "README.md",
+    "android",
+    "ios",
+    "ChitChatTcp.podspec",
+    "react-native.config.js",
+    "react.d.ts"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node test/transport.test.js"
+  },
+  "dependencies": {
+    "@chitchat/sdk-core": "0.3.0-dev.1",
+    "@chitchat/sdk-protocol": "0.3.0-dev.1",
+    "@chitchat/sdk-web": "0.3.0-dev.1"
+  },
+  "keywords": [
+    "chitchat",
+    "realtime",
+    "react-native",
+    "tls",
+    "protobuf"
+  ],
   "sideEffects": false,
   "license": "UNLICENSED",
-  "publishConfig": { "access": "public", "tag": "development" }
+  "publishConfig": {
+    "access": "public",
+    "tag": "development"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.76 <1",
+    "react-native-webrtc": ">=124 <125",
+    "react": ">=18 <20"
+  },
+  "peerDependenciesMeta": {
+    "react-native-webrtc": {
+      "optional": true
+    }
+  }
 }

package/react-native.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+        packageImportPath: 'import com.chitchat.sdk.ChitChatTcpPackage;',
+        packageInstance: 'new ChitChatTcpPackage()'
+      },
+      ios: { podspecPath: './ChitChatTcp.podspec' }
+    }
+  }
+};

package/react.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { NativeCallsClient, NativeMediaStream } from './index';
+import type { CallSnapshot } from '@chitchat/sdk-core';
+export function useCallState(client: NativeCallsClient): CallSnapshot<NativeMediaStream>;
+export function CallView(props: { stream: NativeMediaStream | null; mirror?: boolean; objectFit?: 'contain' | 'cover'; zOrder?: number; style?: unknown }): ReactElement | null;

package/src/index.js

@@ -1,7 +1,14 @@
 'use strict';
 
 let ReliableRealtimeClient;
-try { ({ ReliableRealtimeClient } = require('@chitchat/sdk-core')); } catch (_) { ({ ReliableRealtimeClient } = require('../../chitchat-core/src')); }
+try {
+  ({ ReliableRealtimeClient } = require('@chitchat/sdk-core'));
+} catch (_) {
+  // Monorepo dev fallback — constructed dynamically so Metro never statically
+  // bundles a dead relative path when the scoped package is present.
+  const monorepoCore = ['..', '..', 'chitchat-core', 'src'].join('/');
+  ({ ReliableRealtimeClient } = require(monorepoCore));
+}
 
 const validateNativeTlsEndpoint = (endpoint) => {
   if (typeof endpoint !== 'string' || !endpoint.trim() || /\s/.test(endpoint)) throw new Error('A TLS host endpoint is required');
@@ -32,23 +39,45 @@ const createNativeTcpTransportFactory = ({ nativeModule, pinnedPublicKeyHashes,
   const pins = validatePinnedPublicKeyHashes(pinnedPublicKeyHashes);
   return ({ endpoint, token, protocol }) => {
     const normalizedEndpoint = validateNativeTlsEndpoint(endpoint);
-    let connection; let onMessage = () => {}; let onClose = () => {};
+    const abort = new AbortController();
+    let connection; let cancelled = false; let onMessage = () => {}; let onClose = () => {};
     return Promise.resolve({
       onMessage: (listener) => { onMessage = listener; },
       onClose: (listener) => { onClose = listener; },
-      open: () => Promise.resolve(nativeModule.connect({ endpoint: normalizedEndpoint, token, protocol, tls: true, minimumTlsVersion, pinnedPublicKeyHashes: pins }))
+      open: () => Promise.resolve(nativeModule.connect({ endpoint: normalizedEndpoint, token, protocol, signal: abort.signal, tls: true, minimumTlsVersion, pinnedPublicKeyHashes: pins }))
         .then(assertConnection)
         .then((openedConnection) => {
+          if (cancelled) { void Promise.resolve(openedConnection.close()).catch(() => {}); throw new Error('Native connection was cancelled'); }
           connection = openedConnection;
           connection.onFrame((frame) => onMessage(frame));
           connection.onClose((reason) => onClose(reason));
         }),
       send: (frame) => connection ? Promise.resolve(connection.send(frame)) : Promise.reject(new Error('Native TCP transport is not open')),
-      close: () => connection ? Promise.resolve(connection.close()) : Promise.resolve()
+      close: () => { cancelled = true; abort.abort(); return connection ? Promise.resolve(connection.close()) : Promise.resolve(); }
     });
   };
 };
 
-const createChitChatNativeClient = ({ endpoint, tokenProvider, nativeModule, pinnedPublicKeyHashes, minimumTlsVersion, ...options }) => new ReliableRealtimeClient({ endpoint, tokenProvider, runtime: 'native', nativeTransportFactory: createNativeTcpTransportFactory({ nativeModule, pinnedPublicKeyHashes, minimumTlsVersion }), ...options });
+const createChitChatNativeClient = ({ endpoint, tokenProvider, nativeModule, protobuf, deviceId, idFactory, pinnedPublicKeyHashes, minimumTlsVersion, ...options }) => {
+  let bridge = nativeModule;
+  if (!bridge) {
+    const { NativeModules, NativeEventEmitter, Platform } = require('react-native');
+    const module = NativeModules.ChitChatTcp;
+    if (!module) throw new Error('ChitChatTcp is not linked. Install pods and rebuild the native app; Expo Go is unsupported.');
+    idFactory = idFactory || (typeof module.randomUUID === 'function' ? () => module.randomUUID() : undefined);
+    let codecs;
+    try { codecs = require('@chitchat/sdk-protocol'); } catch (_) { codecs = require(monorepoPath('protocol')); }
+    bridge = require('./protobuf-bridge').createChitChatNativeBridge({ nativeModule: module, eventEmitter: new NativeEventEmitter(module), protobuf: protobuf || codecs.createRealtimeEnvelopeCodec({ deviceId, platform: Platform.OS, idFactory }) });
+  }
+  return new ReliableRealtimeClient({ endpoint, tokenProvider, runtime: 'native', idFactory, nativeTransportFactory: createNativeTcpTransportFactory({ nativeModule: bridge, pinnedPublicKeyHashes, minimumTlsVersion }), ...options });
+};
+
+const monorepoPath = (name) => ['..', '..', `chitchat-${name}`, 'src'].join('/');
+// Dynamic monorepo fallback so Metro never statically bundles dead relative paths.
+const core = () => { try { return require('@chitchat/sdk-core'); } catch (_) { return require(monorepoPath('core')); } };
+const web = () => { try { return require('@chitchat/sdk-web'); } catch (_) { return require(monorepoPath('web')); } };
+// React Native ships WebSocket; using WSS removes the private TCP bridge requirement.
+const createChitChatNativeWssClient = (options) => web().createChitChatWebClient(options);
+const createChitChatNativeCalls = ({ rtc, ...options } = {}) => new (core().CallsClient)({ ...options, rtc: rtc || require('react-native-webrtc') });
 
-module.exports = { createChitChatNativeClient, createNativeTcpTransportFactory, validateNativeTlsEndpoint, validatePinnedPublicKeyHashes };
+module.exports = { ...require('./protobuf-bridge'), createChitChatNativeWssClient, createChitChatNativeCalls, createChitChatNativeClient, createNativeTcpTransportFactory, validateNativeTlsEndpoint, validatePinnedPublicKeyHashes };

package/src/protobuf-bridge.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// Adapts the existing iOS/Android TLS byte-stream module. The public codec,
+// handshake and frame limits live in JS; native code never sees a token string.
+let protocol;
+try { protocol = require('@chitchat/sdk-protocol'); } catch (_) { protocol = require(['..', '..', 'chitchat-protocol', 'src'].join('/')); }
+const leased = new WeakSet();
+const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const toBase64 = (bytes) => {
+  let result = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const n = (bytes[i] << 16) | ((bytes[i + 1] || 0) << 8) | (bytes[i + 2] || 0);
+    result += alphabet[(n >>> 18) & 63] + alphabet[(n >>> 12) & 63] + (i + 1 < bytes.length ? alphabet[(n >>> 6) & 63] : '=') + (i + 2 < bytes.length ? alphabet[n & 63] : '=');
+  }
+  return result;
+};
+const fromBase64 = (text) => {
+  if (typeof text !== 'string' || text.length > 1_398_108 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(text)) throw new Error('Invalid native binary frame');
+  const result = new Uint8Array(text.length / 4 * 3 - (text.endsWith('==') ? 2 : text.endsWith('=') ? 1 : 0));
+  let offset = 0;
+  for (let i = 0; i < text.length; i += 4) {
+    const n = (alphabet.indexOf(text[i]) << 18) | (alphabet.indexOf(text[i + 1]) << 12) | (Math.max(0, alphabet.indexOf(text[i + 2])) << 6) | Math.max(0, alphabet.indexOf(text[i + 3]));
+    result[offset++] = (n >>> 16) & 255; if (offset < result.length) result[offset++] = (n >>> 8) & 255; if (offset < result.length) result[offset++] = n & 255;
+  }
+  return result;
+};
+
+function createChitChatNativeBridge({ nativeModule, eventEmitter, protobuf, openTimeoutMs = 15_000 } = {}) {
+  if (!nativeModule?.supportsTLS || !nativeModule.supportsProtobufFrames || ['connectProtobuf', 'sendProtobufFrame', 'disconnect'].some((key) => typeof nativeModule[key] !== 'function')) throw new Error('A TLS-capable ChitChat protobuf native module is required');
+  if (typeof eventEmitter?.addListener !== 'function' || !protobuf?.createTcpDecoder || !protobuf.encodeAuth || !protobuf.isAuthenticationAccepted) throw new Error('Native event emitter and official protobuf codec are required');
+  if (!Number.isInteger(openTimeoutMs) || openTimeoutMs < 100 || openTimeoutMs > 120_000) throw new Error('openTimeoutMs must be between 100 and 120000');
+  return {
+    connect({ endpoint, token, protocol: subprotocol, tls, minimumTlsVersion, pinnedPublicKeyHashes = [], signal }) {
+      if (tls !== true || subprotocol !== 'chitchat.protobuf.v1') return Promise.reject(new Error('TLS protobuf is required'));
+      // Existing app modules enforce system trust and TLS >= 1.2. They do not
+      // implement pinning or a TLS-1.3-only option; never silently ignore either.
+      if (pinnedPublicKeyHashes.length || minimumTlsVersion === 'TLSv1.3') return Promise.reject(new Error('The linked native bridge does not support the requested TLS policy'));
+      if (leased.has(nativeModule)) return Promise.reject(new Error('Native module already has an active SDK connection'));
+      const url = new URL(`tls://${endpoint}`);
+      leased.add(nativeModule);
+      return new Promise((resolve, reject) => {
+        const decoder = protobuf.createTcpDecoder(); const subscriptions = [];
+        let ready = false; let closed = false; let timer; let messageListener = () => {}; let closeListener = () => {}; let authSent = false;
+        const close = (code = 'NATIVE_CONNECTION_CLOSED') => {
+          if (closed) return; closed = true; clearTimeout(timer); subscriptions.forEach((subscription) => subscription.remove()); decoder.reset(); leased.delete(nativeModule);
+          try { Promise.resolve(nativeModule.disconnect()).catch(() => {}); } catch (_) {}
+          reject(new Error(code)); closeListener({ code });
+        };
+        const sendBytes = (bytes) => Promise.resolve().then(() => { if (closed) throw new Error('Native transport is closed'); return nativeModule.sendProtobufFrame(toBase64(bytes)); });
+        const connection = {
+          onFrame: (listener) => { messageListener = listener; }, onClose: (listener) => { closeListener = listener; },
+          send: (frame) => ready && !closed ? sendBytes(protobuf.encodeTcpFrame(frame)) : Promise.reject(new Error('Native handshake is incomplete')),
+          close: async () => close()
+        };
+        const abort = () => close('NATIVE_CONNECTION_CANCELLED');
+        if (signal?.aborted) { close('NATIVE_CONNECTION_CANCELLED'); return; }
+        signal?.addEventListener('abort', abort, { once: true });
+        subscriptions.push({ remove: () => signal?.removeEventListener('abort', abort) });
+        try {
+          subscriptions.push(eventEmitter.addListener('onTransportOpen', () => {
+            if (closed || authSent) return; authSent = true;
+            void sendBytes(protocol.encodeTcpFrame(protobuf.encodeAuth({ token, protocol: subprotocol }))).catch(() => close('NATIVE_AUTH_SEND_FAILED'));
+          }));
+          subscriptions.push(eventEmitter.addListener('onProtobufFrame', (data) => {
+            if (closed) return;
+            try {
+              for (const frame of decoder.push(fromBase64(data?.frame))) {
+                if (!ready) {
+                  if (!protobuf.isAuthenticationAccepted(frame)) { close('NATIVE_AUTHENTICATION_REJECTED'); return; }
+                  ready = true; clearTimeout(timer); resolve(connection);
+                  continue;
+                }
+                // Defer a same-chunk post-auth frame until the adapter attaches.
+                Promise.resolve().then(() => Promise.resolve()).then(() => { if (!closed) messageListener(frame); });
+              }
+            } catch (_) { close('PROTOCOL_DECODE_ERROR'); }
+          }));
+          subscriptions.push(eventEmitter.addListener('onError', () => close('NATIVE_TRANSPORT_ERROR')));
+          subscriptions.push(eventEmitter.addListener('onDisconnected', () => close()));
+          timer = setTimeout(() => close('NATIVE_CONNECTION_TIMEOUT'), openTimeoutMs);
+          Promise.resolve(nativeModule.connectProtobuf(url.hostname.replace(/^\[|\]$/g, ''), Number(url.port || 443), true)).catch(() => close('NATIVE_CONNECTION_FAILED'));
+        } catch (_) { close('NATIVE_CONNECTION_FAILED'); }
+      });
+    }
+  };
+}
+module.exports = { createChitChatNativeBridge };

package/src/react.js

@@ -0,0 +1,12 @@
+'use strict';
+const React = require('react');
+function useCallState(client) {
+  const subscribe = React.useCallback((changed) => client.on('stateChange', changed), [client]);
+  const snapshot = React.useCallback(() => client.getSnapshot(), [client]);
+  return React.useSyncExternalStore(subscribe, snapshot, snapshot);
+}
+function CallView({ stream, ...props }) {
+  const { RTCView } = require('react-native-webrtc');
+  return stream ? React.createElement(RTCView, { ...props, streamURL: stream.toURL() }) : null;
+}
+module.exports = { useCallState, CallView };