feat!: remove the responseController and subscription getters

They exposed the broadcast controller and the transport subscription
behind inputStream. Closing the controller or cancelling the
subscription from outside skipped the lifecycle tracking that 2.0.0
centralises, for the same reason the socket getter was removed. Nothing
outside this package's own tests used them; those tests now check the
delivered data rather than the subscription's pause state.

Author: sneurlax

CHANGELOG.md

@@ -3,6 +3,7 @@
 - **Breaking:** Remove `SOCKSSocket.socket` so transport operations cannot bypass the wrapper's write queue and lifecycle tracking. Use `destroy()`, `close()`, `write()`, `outputStream`, and `inputStream` instead.
 - **Breaking:** Caller-managed TLS through `SecureSocket.secure(socks.socket)` is no longer supported. Use `SOCKSSocket.create(sslEnabled: true, securityContext: ...)` to negotiate TLS during `connectTo()`.
 - **Breaking:** Remove the `SOCKSSocket()` constructor, deprecated since 1.2.0; it never awaited the proxy connection. Use `SOCKSSocket.create()`.
+- **Breaking:** Remove `responseController` and `subscription`, which exposed the stream controller and subscription behind `inputStream`; closing or cancelling them bypassed the lifecycle tracking. Use `inputStream`.
 - Add `destroy()` to abort without draining output; writes it cuts short fail instead of reporting success (#2). It also ends a connect, TLS handshake or `reconnect()` in flight, and a later `close()` completes normally even when it failed a close that was already draining.
 - Add `closeOnPeerEof` to `create()`; pass `false` to keep writing after the peer half-closes (#3).
 - `close()` now ends a `reconnect()` or TLS handshake in flight instead of being overtaken by the reconnect or waiting for the handshake deadline.

README.md

@@ -99,7 +99,7 @@ By default the connection closes once the peer closes its side. Pass `closeOnPee
 
 ## Migrating to 2.0.0
 
-`SOCKSSocket.socket` has been removed. All transport operations now go through the wrapper so writes and teardown share the same lifecycle tracking.
+`SOCKSSocket.socket`, `responseController` and `subscription` have been removed. All transport operations now go through the wrapper so writes and teardown share the same lifecycle tracking.
 
 | Previous operation | Replacement |
 | --- | --- |
@@ -108,6 +108,7 @@ By default the connection closes once the peer closes its side. Pass `closeOnPee
 | `socks.socket.add(bytes)` | `socks.outputStream.add(bytes)` |
 | `socks.socket.addStream(source)` | `await socks.outputStream.addStream(source)` |
 | Reading the underlying socket | `socks.inputStream` or `socks.listen(...)` |
+| `socks.responseController`, `socks.subscription` | `socks.inputStream`; pause or cancel your own subscription to it |
 | `SecureSocket.secure(socks.socket, ...)` | Set `sslEnabled: true` and, if needed, `securityContext` on `SOCKSSocket.create(...)` |
 
 For an awaited binary write, use `await socks.outputStream.addStream(Stream.value(bytes))`. The output sink accepts one stream at a time. For text, use `await socks.write(text)`. To drain and finish the connection, use `await socks.close()`.

lib/socks_socket.dart

@@ -273,12 +273,6 @@ class SOCKSSocket {
   /// Reads pause while there is no listener; earlier data is kept.
   Stream<List<int>> get inputStream => _input.stream;
 
-  /// The controller behind [inputStream].
-  StreamController<List<int>> get responseController => _input;
-
-  /// The subscription that feeds [inputStream], once connected.
-  StreamSubscription<List<int>>? get subscription => _subscription;
-
   StreamSink<List<int>> get outputStream => _outputSink ??= _newOutputSink();
 
   StreamController<List<int>> _newInput() {

test/input_lifecycle_test.dart

@@ -44,21 +44,16 @@ void main() {
       await socket.connect();
       await socket.connectTo('localhost', 443);
       final peer = await accepted.future;
-      expect(socket.subscription!.isPaused, isTrue);
       peer.add([1]);
       await peer.flush();
       expect(await socket.inputStream.first, [1]);
-      expect(socket.subscription!.isPaused, isTrue);
       peer.add([2]);
       await peer.flush();
       expect(await socket.inputStream.first, [2]);
-      expect(socket.subscription!.isPaused, isTrue);
       final first = socket.inputStream.listen((_) {});
       final second = socket.inputStream.listen((_) {});
       await first.cancel();
-      expect(socket.subscription!.isPaused, isFalse);
       await second.cancel();
-      expect(socket.subscription!.isPaused, isTrue);
     });
 
     test(
@@ -83,7 +78,6 @@ void main() {
       await socket.reconnect();
       final reply = socket.inputStream.first;
       await stale.cancel();
-      expect(socket.subscription!.isPaused, isFalse);
       await socket.write('A');
       expect(await reply.timeout(const Duration(seconds: 2)), [65]);
     });