feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorPackagerConnection.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import "RCTInspectorPackagerConnection.h"
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+@interface RCTCxxInspectorPackagerConnection : NSObject <RCTInspectorPackagerConnectionProtocol>
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorPackagerConnection.mm

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInspectorPackagerConnection.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <React/RCTDefines.h>
+#import <React/RCTInspector.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <SocketRocket/SRWebSocket.h>
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+
+#import <chrono>
+#import <memory>
+
+#import "RCTCxxInspectorPackagerConnection.h"
+#import "RCTCxxInspectorPackagerConnectionDelegate.h"
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+using namespace facebook::react::jsinspector_modern;
+@interface RCTCxxInspectorPackagerConnection () {
+  std::unique_ptr<InspectorPackagerConnection> _cxxImpl;
+}
+@end
+
+@implementation RCTCxxInspectorPackagerConnection
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithURL:(NSURL *)url
+{
+  if (self = [super init]) {
+    _cxxImpl = std::make_unique<InspectorPackagerConnection>(
+        [url absoluteString].UTF8String,
+        [[NSBundle mainBundle] bundleIdentifier].UTF8String,
+        std::make_unique<RCTCxxInspectorPackagerConnectionDelegate>());
+  }
+  return self;
+}
+
+- (void)sendEventToAllConnections:(NSString *)event
+{
+  _cxxImpl->sendEventToAllConnections(event.UTF8String);
+}
+
+- (bool)isConnected
+{
+  return _cxxImpl->isConnected();
+}
+
+- (void)connect
+{
+  _cxxImpl->connect();
+}
+
+- (void)closeQuietly
+{
+  _cxxImpl->closeQuietly();
+}
+
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorPackagerConnectionDelegate.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+
+#import <chrono>
+#import <memory>
+#import <string>
+
+namespace facebook::react::jsinspector_modern {
+/**
+ * Glue between C++ and Objective-C for InspectorPackagerConnectionDelegate.
+ */
+class RCTCxxInspectorPackagerConnectionDelegate
+    : public InspectorPackagerConnectionDelegate {
+  class WebSocket : public IWebSocket {
+   public:
+    WebSocket(RCTCxxInspectorWebSocketAdapter* adapter);
+    virtual void send(std::string_view message) override;
+    virtual ~WebSocket() override;
+
+   private:
+    RCTCxxInspectorWebSocketAdapter* const _adapter;
+  };
+
+ public:
+  virtual std::unique_ptr<IWebSocket> connectWebSocket(
+      const std::string& url,
+      std::weak_ptr<IWebSocketDelegate> delegate) override;
+
+  virtual void scheduleCallback(
+      std::function<void(void)> callback,
+      std::chrono::milliseconds delayMs) override;
+};
+} // namespace facebook::react::jsinspector_modern
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorPackagerConnectionDelegate.mm

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTCxxInspectorPackagerConnectionDelegate.h"
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <dispatch/dispatch.h>
+
+namespace facebook::react::jsinspector_modern {
+RCTCxxInspectorPackagerConnectionDelegate::WebSocket::WebSocket(RCTCxxInspectorWebSocketAdapter *adapter)
+    : _adapter(adapter)
+{
+}
+
+void RCTCxxInspectorPackagerConnectionDelegate::WebSocket::send(std::string_view message)
+{
+  [_adapter send:message];
+}
+
+RCTCxxInspectorPackagerConnectionDelegate::WebSocket::~WebSocket()
+{
+  [_adapter close];
+}
+
+std::unique_ptr<IWebSocket> RCTCxxInspectorPackagerConnectionDelegate::connectWebSocket(
+    const std::string &url,
+    std::weak_ptr<IWebSocketDelegate> delegate)
+{
+  auto *adapter = [[RCTCxxInspectorWebSocketAdapter alloc] initWithURL:url delegate:delegate];
+  return std::make_unique<WebSocket>(adapter);
+}
+
+void RCTCxxInspectorPackagerConnectionDelegate::scheduleCallback(
+    std::function<void(void)> callback,
+    std::chrono::milliseconds delayMs)
+{
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayMs.count() * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+    callback();
+  });
+}
+} // namespace facebook::react::jsinspector_modern
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorWebSocketAdapter.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+#import <memory>
+#import <string>
+
+@interface RCTCxxInspectorWebSocketAdapter : NSObject
+- (instancetype)initWithURL:(const std::string &)url
+                   delegate:(std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate>)delegate;
+- (void)send:(std::string_view)message;
+- (void)close;
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTCxxInspectorWebSocketAdapter.mm

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <React/RCTInspector.h>
+#import <React/RCTInspectorPackagerConnection.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <SocketRocket/SRWebSocket.h>
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+#import <memory>
+
+using namespace facebook::react::jsinspector_modern;
+
+namespace {
+NSString *NSStringFromUTF8StringView(std::string_view view)
+{
+  return [[NSString alloc] initWithBytes:(const char *)view.data() length:view.size() encoding:NSUTF8StringEncoding];
+}
+}
+@interface RCTCxxInspectorWebSocketAdapter () <SRWebSocketDelegate> {
+  std::weak_ptr<IWebSocketDelegate> _delegate;
+  SRWebSocket *_webSocket;
+}
+@end
+
+@implementation RCTCxxInspectorWebSocketAdapter
+- (instancetype)initWithURL:(const std::string &)url delegate:(std::weak_ptr<IWebSocketDelegate>)delegate
+{
+  if ((self = [super init])) {
+    _delegate = delegate;
+    _webSocket = [[SRWebSocket alloc] initWithURL:[NSURL URLWithString:NSStringFromUTF8StringView(url)]];
+    _webSocket.delegate = self;
+    [_webSocket open];
+  }
+  return self;
+}
+
+- (void)send:(std::string_view)message
+{
+  __weak RCTCxxInspectorWebSocketAdapter *weakSelf = self;
+  NSString *messageStr = NSStringFromUTF8StringView(message);
+  dispatch_async(dispatch_get_main_queue(), ^{
+    RCTCxxInspectorWebSocketAdapter *strongSelf = weakSelf;
+    if (strongSelf) {
+      [strongSelf->_webSocket send:messageStr];
+    }
+  });
+}
+
+- (void)close
+{
+  [_webSocket closeWithCode:1000 reason:@"End of session"];
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket didFailWithError:(NSError *)error
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didFailWithError([error code], [error description].UTF8String);
+  }
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket didReceiveMessageWithString:(NSString *)message
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didReceiveMessage([message UTF8String]);
+  }
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket
+    didCloseWithCode:(__unused NSInteger)code
+              reason:(__unused NSString *)reason
+            wasClean:(__unused BOOL)wasClean
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didClose();
+  }
+}
+
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTInspector.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+@class RCTInspectorRemoteConnection;
+
+@interface RCTInspectorLocalConnection : NSObject
+- (void)sendMessage:(NSString *)message;
+- (void)disconnect;
+@end
+
+@interface RCTInspectorPage : NSObject
+@property (nonatomic, readonly) NSInteger id;
+@property (nonatomic, readonly) NSString *title;
+@property (nonatomic, readonly) NSString *vm;
+@end
+
+@interface RCTInspector : NSObject
++ (NSArray<RCTInspectorPage *> *)pages;
++ (RCTInspectorLocalConnection *)connectPage:(NSInteger)pageId
+                         forRemoteConnection:(RCTInspectorRemoteConnection *)remote;
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTInspector.mm

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInspector.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <jsinspector-modern/InspectorInterfaces.h>
+
+#import <React/RCTDefines.h>
+#import <React/RCTInspectorPackagerConnection.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+using namespace facebook::react;
+using namespace facebook::react::jsinspector_modern;
+
+// This is a port of the Android impl, at
+// react-native-github/ReactAndroid/src/main/java/com/facebook/react/bridge/Inspector.java
+// react-native-github/ReactAndroid/src/main/jni/react/jni/JInspector.cpp
+// please keep consistent :)
+
+class RemoteConnection : public IRemoteConnection {
+ public:
+  RemoteConnection(RCTInspectorRemoteConnection *connection) : _connection(connection) {}
+
+  virtual void onMessage(std::string message) override
+  {
+    [_connection onMessage:@(message.c_str())];
+  }
+
+  virtual void onDisconnect() override
+  {
+    [_connection onDisconnect];
+  }
+
+ private:
+  const RCTInspectorRemoteConnection *_connection;
+};
+
+@interface RCTInspectorPage () {
+  NSInteger _id;
+  NSString *_title;
+  NSString *_vm;
+}
+- (instancetype)initWithId:(NSInteger)id title:(NSString *)title vm:(NSString *)vm;
+@end
+
+@interface RCTInspectorLocalConnection () {
+  std::unique_ptr<ILocalConnection> _connection;
+}
+- (instancetype)initWithConnection:(std::unique_ptr<ILocalConnection>)connection;
+@end
+
+static IInspector *getInstance()
+{
+  return &facebook::react::jsinspector_modern::getInspectorInstance();
+}
+
+@implementation RCTInspector
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
++ (NSArray<RCTInspectorPage *> *)pages
+{
+  std::vector<InspectorPageDescription> pages = getInstance()->getPages();
+  NSMutableArray<RCTInspectorPage *> *array = [NSMutableArray arrayWithCapacity:pages.size()];
+  for (size_t i = 0; i < pages.size(); i++) {
+    RCTInspectorPage *pageWrapper = [[RCTInspectorPage alloc] initWithId:pages[i].id
+                                                                   title:@(pages[i].title.c_str())
+                                                                      vm:@(pages[i].vm.c_str())];
+    [array addObject:pageWrapper];
+  }
+  return array;
+}
+
++ (RCTInspectorLocalConnection *)connectPage:(NSInteger)pageId
+                         forRemoteConnection:(RCTInspectorRemoteConnection *)remote
+{
+  auto localConnection = getInstance()->connect((int)pageId, std::make_unique<RemoteConnection>(remote));
+  return [[RCTInspectorLocalConnection alloc] initWithConnection:std::move(localConnection)];
+}
+
+@end
+
+@implementation RCTInspectorPage
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithId:(NSInteger)id title:(NSString *)title vm:(NSString *)vm
+{
+  if (self = [super init]) {
+    _id = id;
+    _title = title;
+    _vm = vm;
+  }
+  return self;
+}
+
+@end
+
+@implementation RCTInspectorLocalConnection
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithConnection:(std::unique_ptr<ILocalConnection>)connection
+{
+  if (self = [super init]) {
+    _connection = std::move(connection);
+  }
+  return self;
+}
+
+- (void)sendMessage:(NSString *)message
+{
+  _connection->sendMessage([message UTF8String]);
+}
+
+- (void)disconnect
+{
+  _connection->disconnect();
+}
+
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTInspectorPackagerConnection.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+@protocol RCTInspectorPackagerConnectionProtocol <NSObject>
+- (instancetype)initWithURL:(NSURL *)url;
+
+- (bool)isConnected;
+- (void)connect;
+- (void)closeQuietly;
+- (void)sendEventToAllConnections:(NSString *)event;
+@end
+
+@interface RCTInspectorPackagerConnection : NSObject <RCTInspectorPackagerConnectionProtocol>
+@end
+
+@interface RCTInspectorRemoteConnection : NSObject
+- (void)onMessage:(NSString *)message;
+- (void)onDisconnect;
+@end
+
+#endif

smart-app-city/frontend/node_modules/react-native/React/Inspector/RCTInspectorPackagerConnection.m

@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInspectorPackagerConnection.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <React/RCTDefines.h>
+#import <React/RCTInspector.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <SocketRocket/SRWebSocket.h>
+
+// This is a port of the Android impl, at
+// ReactAndroid/src/main/java/com/facebook/react/devsupport/InspectorPackagerConnection.java
+// please keep consistent :)
+
+const int RECONNECT_DELAY_MS = 2000;
+
+@interface RCTInspectorPackagerConnection () <SRWebSocketDelegate> {
+  NSURL *_url;
+  NSMutableDictionary<NSString *, RCTInspectorLocalConnection *> *_inspectorConnections;
+  SRWebSocket *_webSocket;
+  BOOL _closed;
+  BOOL _suppressConnectionErrors;
+}
+@end
+
+@interface RCTInspectorRemoteConnection () {
+  __weak RCTInspectorPackagerConnection *_owningPackagerConnection;
+  NSString *_pageId;
+}
+- (instancetype)initWithPackagerConnection:(RCTInspectorPackagerConnection *)owningPackagerConnection
+                                    pageId:(NSString *)pageId;
+@end
+
+static NSDictionary<NSString *, id> *makePageIdPayload(NSString *pageId)
+{
+  return @{@"pageId" : pageId};
+}
+
+@implementation RCTInspectorPackagerConnection
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithURL:(NSURL *)url
+{
+  if (self = [super init]) {
+    _url = url;
+    _inspectorConnections = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+- (void)handleProxyMessage:(NSDictionary<NSString *, id> *)message
+{
+  NSString *event = message[@"event"];
+  NSDictionary *payload = message[@"payload"];
+  if ([@"getPages" isEqualToString:event]) {
+    [self sendEvent:event payload:[self pages]];
+  } else if ([@"wrappedEvent" isEqualToString:event]) {
+    [self handleWrappedEvent:payload];
+  } else if ([@"connect" isEqualToString:event]) {
+    [self handleConnect:payload];
+  } else if ([@"disconnect" isEqualToString:event]) {
+    [self handleDisconnect:payload];
+  } else {
+    RCTLogError(@"Unknown event: %@", event);
+  }
+}
+
+- (void)sendEventToAllConnections:(NSString *)event
+{
+  for (NSString *pageId in _inspectorConnections) {
+    [_inspectorConnections[pageId] sendMessage:event];
+  }
+}
+
+- (void)closeAllConnections
+{
+  for (NSString *pageId in _inspectorConnections) {
+    [[_inspectorConnections objectForKey:pageId] disconnect];
+  }
+  [_inspectorConnections removeAllObjects];
+}
+
+- (void)handleConnect:(NSDictionary *)payload
+{
+  NSString *pageId = payload[@"pageId"];
+  RCTInspectorLocalConnection *existingConnection = _inspectorConnections[pageId];
+  if (existingConnection) {
+    [_inspectorConnections removeObjectForKey:pageId];
+    [existingConnection disconnect];
+    RCTLogWarn(@"Already connected: %@", pageId);
+    return;
+  }
+
+  RCTInspectorRemoteConnection *remoteConnection =
+      [[RCTInspectorRemoteConnection alloc] initWithPackagerConnection:self pageId:pageId];
+
+  RCTInspectorLocalConnection *inspectorConnection = [RCTInspector connectPage:[pageId integerValue]
+                                                           forRemoteConnection:remoteConnection];
+  _inspectorConnections[pageId] = inspectorConnection;
+}
+
+- (void)handleDisconnect:(NSDictionary *)payload
+{
+  NSString *pageId = payload[@"pageId"];
+  RCTInspectorLocalConnection *inspectorConnection = _inspectorConnections[pageId];
+  if (inspectorConnection) {
+    [self removeConnectionForPage:pageId];
+    [inspectorConnection disconnect];
+  }
+}
+
+- (void)removeConnectionForPage:(NSString *)pageId
+{
+  [_inspectorConnections removeObjectForKey:pageId];
+}
+
+- (void)handleWrappedEvent:(NSDictionary *)payload
+{
+  NSString *pageId = payload[@"pageId"];
+  NSString *wrappedEvent = payload[@"wrappedEvent"];
+  RCTInspectorLocalConnection *inspectorConnection = _inspectorConnections[pageId];
+  if (!inspectorConnection) {
+    RCTLogWarn(@"Not connected to page: %@ , failed trying to handle event: %@", pageId, wrappedEvent);
+    return;
+  }
+  [inspectorConnection sendMessage:wrappedEvent];
+}
+
+- (NSArray *)pages
+{
+  NSArray<RCTInspectorPage *> *pages = [RCTInspector pages];
+  NSMutableArray *array = [NSMutableArray arrayWithCapacity:pages.count];
+
+  for (RCTInspectorPage *page in pages) {
+    NSDictionary *jsonPage = @{
+      @"id" : [@(page.id) stringValue],
+      @"title" : page.title,
+      @"app" : [[NSBundle mainBundle] bundleIdentifier],
+      @"vm" : page.vm,
+    };
+    [array addObject:jsonPage];
+  }
+  return array;
+}
+
+- (void)sendWrappedEvent:(NSString *)pageId message:(NSString *)message
+{
+  NSDictionary *payload = @{
+    @"pageId" : pageId,
+    @"wrappedEvent" : message,
+  };
+  [self sendEvent:@"wrappedEvent" payload:payload];
+}
+
+- (void)sendEvent:(NSString *)name payload:(id)payload
+{
+  NSDictionary *jsonMessage = @{
+    @"event" : name,
+    @"payload" : payload,
+  };
+  [self sendToPackager:jsonMessage];
+}
+
+// analogous to InspectorPackagerConnection.Connection.onFailure(...)
+- (void)webSocket:(__unused SRWebSocket *)webSocket didFailWithError:(NSError *)error
+{
+  if (_webSocket) {
+    [self abort:@"Websocket exception" withCause:error];
+  }
+  if (!_closed && [error code] != ECONNREFUSED) {
+    [self reconnect];
+  }
+}
+
+// analogous to InspectorPackagerConnection.Connection.onMessage(...)
+- (void)webSocket:(__unused SRWebSocket *)webSocket didReceiveMessageWithString:(nonnull NSString *)messageText
+{
+  NSError *error = nil;
+  id parsedJSON = RCTJSONParse(messageText, &error);
+  if (error) {
+    RCTLogWarn(@"Unrecognized inspector message, string was not valid JSON: %@", messageText);
+    return;
+  }
+
+  [self handleProxyMessage:parsedJSON];
+}
+
+// analogous to InspectorPackagerConnection.Connection.onClosed(...)
+- (void)webSocket:(__unused SRWebSocket *)webSocket
+    didCloseWithCode:(__unused NSInteger)code
+              reason:(__unused NSString *)reason
+            wasClean:(__unused BOOL)wasClean
+{
+  _webSocket = nil;
+  [self closeAllConnections];
+  if (!_closed) {
+    [self reconnect];
+  }
+}
+
+- (bool)isConnected
+{
+  return _webSocket != nil;
+}
+
+- (void)connect
+{
+  if (_closed) {
+    RCTLogError(@"Illegal state: Can't connect after having previously been closed.");
+    return;
+  }
+
+  // The corresponding android code has a lot of custom config options for
+  // timeouts, but our previous class, RCTSRWebSocket didn't have the same
+  // implemented options. Might be worth reinvestigating for SRWebSocket?
+  _webSocket = [[SRWebSocket alloc] initWithURL:_url];
+  _webSocket.delegate = self;
+  [_webSocket open];
+}
+
+- (void)reconnect
+{
+  if (_closed) {
+    RCTLogError(@"Illegal state: Can't reconnect after having previously been closed.");
+    return;
+  }
+
+  if (_suppressConnectionErrors) {
+    RCTLogWarn(@"Couldn't connect to packager, will silently retry");
+    _suppressConnectionErrors = true;
+  }
+
+  __weak RCTInspectorPackagerConnection *weakSelf = self;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, RECONNECT_DELAY_MS * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+    RCTInspectorPackagerConnection *strongSelf = weakSelf;
+    if (strongSelf && !strongSelf->_closed) {
+      [strongSelf connect];
+    }
+  });
+}
+
+- (void)closeQuietly
+{
+  _closed = true;
+  [self disposeWebSocket];
+}
+
+- (void)sendToPackager:(NSDictionary *)messageObject
+{
+  __weak RCTInspectorPackagerConnection *weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    RCTInspectorPackagerConnection *strongSelf = weakSelf;
+    if (strongSelf && !strongSelf->_closed) {
+      NSError *error;
+      NSString *messageText = RCTJSONStringify(messageObject, &error);
+      if (error) {
+        RCTLogWarn(@"Couldn't send event to packager: %@", error);
+      } else {
+        [strongSelf->_webSocket sendString:messageText error:nil];
+      }
+    }
+  });
+}
+
+- (void)abort:(NSString *)message withCause:(NSError *)cause
+{
+  // Don't log ECONNREFUSED at all; it's expected in cases where the server isn't listening.
+  if (![cause.domain isEqual:NSPOSIXErrorDomain] || cause.code != ECONNREFUSED) {
+    RCTLogInfo(@"Error occurred, shutting down websocket connection: %@ %@", message, cause);
+  }
+
+  [self closeAllConnections];
+  [self disposeWebSocket];
+}
+
+- (void)disposeWebSocket
+{
+  if (_webSocket) {
+    [_webSocket closeWithCode:1000 reason:@"End of session"];
+    _webSocket.delegate = nil;
+    _webSocket = nil;
+  }
+}
+
+@end
+
+@implementation RCTInspectorRemoteConnection
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithPackagerConnection:(RCTInspectorPackagerConnection *)owningPackagerConnection
+                                    pageId:(NSString *)pageId
+{
+  if (self = [super init]) {
+    _owningPackagerConnection = owningPackagerConnection;
+    _pageId = pageId;
+  }
+  return self;
+}
+
+- (void)onMessage:(NSString *)message
+{
+  [_owningPackagerConnection sendWrappedEvent:_pageId message:message];
+}
+
+- (void)onDisconnect
+{
+  RCTInspectorPackagerConnection *owningPackagerConnectionStrong = _owningPackagerConnection;
+  if (owningPackagerConnectionStrong) {
+    [owningPackagerConnectionStrong removeConnectionForPage:_pageId];
+    [owningPackagerConnectionStrong sendEvent:@"disconnect" payload:makePageIdPayload(_pageId)];
+  }
+}
+
+@end
+
+#endif