Tear down RPC subscriptions on RN context reload

[gmaclennan]

Summary

When React Native reloads the JS bundle (dev reload, DevSettings.reload(), fast-refresh full reload) — or, on Android, when the main app process restarts — the previous JS session's MapeoClient is gone but its rpc-reflector event-listener subscriptions are still attached to the long-lived MapeoManager on the backend. The backend then keeps emitting events to a peer that no longer has anyone listening, and on every reload the listener set grows.

The fix is to make sure the AF_UNIX socket is actually closed on reload, and that the backend's per-connection cleanup actually runs when the socket closes.

Changes

Backend — SocketMessagePort.close() now emits 'close' (load-bearing)

backend/lib/message-port.js. The constructor wires framedStream.on('close') to call SocketMessagePort.close(), and ComapeoRpcServer already attached messagePort.on('close', () => server.close()) to drive rpc-reflector's per-connection cleanup. But close() never emitted the event, so the server.close() listener was dead and every reconnect leaked the previous session's listeners onto MapeoManager. One-line behaviour fix; the rest of the wiring was already correct.

Android — synchronous IPC teardown on OnDestroy

android/.../NodeJSIPC.kt, android/.../ComapeoCoreModule.kt. Adds NodeJSIPC.close() — a synchronous terminal teardown that closes the LocalSocket on the calling thread and cancels the coroutine scope. ComapeoCoreModule.OnDestroy now calls close() instead of the fire-and-forget disconnect().

Why: Expo modules on Android are bound to the AppContext, whose lifetime is the JS runtime, so OnDestroy fires on every JS context tear-down (android-lifecycle-listeners docs). The previous wiring closed the socket from a launched coroutine, so the new OnCreate could open a fresh connection before the old socket's FD was released — the backend's per-connection cleanup then ran against the wrong (or no) connection. close() closes the FD on the calling thread and cancels the scope so receive/send coroutines don't linger.

disconnect() is unchanged and still used by the FGS side (NodeJSService) and by internal IOException recovery.

iOS — relies on OnDestroy in SDK 55+

ios/ComapeoCoreModule.swift. No mechanism change — only a comment documenting that OnDestroy fires reliably on iOS JS reload as of expo-modules-core PR #33760 (merged Dec 2024, shipped in SDK 53+). Verified directly against the installed expo-modules-core@55.0.23:

• ios/Core/MainValueConverter.swift:7 — private(set) weak var appContext: AppContext?
• ios/Core/ModuleHolder.swift:140 — deinit { post(event: .moduleDestroy) }

Previously a strong-reference cycle through MainValueConverter pinned AppContext across reloads. With it weak, AppContext deinits on reload, the module registry releases each ModuleHolder, every ModuleHolder.deinit fires .moduleDestroy, and OnDestroy runs. iOS's disconnect() is already synchronous (shutdown(2) → join receive loop → close(2)), so no new mechanism is needed. The comment also points at the RCTBridgeWillReloadNotification / RCTJavaScriptWillStartLoadingNotification fallback to add if a future SDK upgrade reintroduces a leak.

Test plan

Backend (runnable now: cd backend && npm test):

• SocketMessagePort emits 'close' exactly once when the underlying socket closes
• close() is idempotent (no double-fire)
• End-to-end: rpc-reflector listener attached to a fake handler is removed when the socket closes — the contract that was silently broken before this PR
• Smoke test for the in-test pair() helper

Android (instrumented test, requires device/emulator):

• closeReleasesSocketSynchronously — blocks the mock server on read(), calls ipc.close(), asserts the read unblocks with EOF inside 1 s. Pins the synchronous-close contract.
• Existing NodeJSIPCTest suite (regression check)

iOS (Swift Package + example-app integration tests, require Xcode):

• swift test from ios/ (ComapeoCoreTests) — regression check; no new tests added since the iOS change is comment-only
• example/tests/ios integration suite — regression check that OnDestroy actually runs on real device JS reload (couldn't verify on Linux CI)

Manual:

• Subscribe to a backend event (e.g. comapeo.invite$.on('invite-received', ...)) in the app, trigger an RN reload, observe that the new JS session's listener fires once per event (not N+1 times for each prior session) and that backend logs no longer show the listener count growing across reloads.

Notes for review

• The backend test suite is new — runs via node --test, no new dependencies.
• The PR is rebased onto main after refactor: per-component lifecycle state with derived ComapeoState #47 landed; no merge conflicts.

🤖 Generated with Claude Code

---

Generated by Claude Code