@actuallab/rpc 14.4.3 → 14.4.11

package/dist/index.d.cts

@@ -1021,6 +1021,7 @@ declare abstract class RpcPeer {
      *  (queries) never time out here. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
+    get wireConnection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
@@ -1047,7 +1048,9 @@ declare abstract class RpcPeer {
      *  stays in the hub and all client proxies bound to it remain valid. */
     disconnect(): void;
     close(): void;
-    /** Send pre-serialized wire data through the current connection. */
+    /** Send pre-serialized wire data through the current connection. Callers are
+     *  already gated on `_isConnected`; the check is repeated here so the next one
+     *  cannot reintroduce a pre-handshake write. $sys.Handshake does not use this. */
     protected _sendWireData(data: string | Uint8Array): void;
     /** Override in subclasses to handle the remote peer's handshake response. */
     protected _onHandshakeReceived(_handshake: RemoteHandshake): void;
@@ -1326,7 +1329,11 @@ declare class RpcStreamSender<T> implements IRpcObject {
     readonly sourceUsesAbortSignal: boolean;
     /** Next stream index that will be sent (matches .NET's `index`). */
     private _nextIndex;
-    private _ended;
+    /** Torn down — `disconnect()` ran. .NET's counterpart is disposal; note it
+     *  does NOT mean "an End was sent", which .NET does not track at all. */
+    private _isDisposed;
+    /** The pump has returned. .NET's `WhenRunning.IsCompleted`. */
+    private _isCompleted;
     private _started;
     /** Highest `nextIndex` observed in an ACK so far (matches .NET's `lastAckNextIndex` idiom). */
     private _lastAckedIndex;
@@ -1379,14 +1386,17 @@ declare class RpcStreamSender<T> implements IRpcObject {
      *
      * Advances `_nextIndex` unconditionally — even if the peer is disconnected
      * the item is considered "sent" from the pump's perspective so the replay
-     * buffer indexing stays consistent. If a connection is absent, the wire
+     * buffer indexing stays consistent. If the peer isn't connected, the wire
      * message is dropped; the item will be resent from the replay buffer
      * after a reconnect (client sends `Ack(N, mustReset=true)`).
      */
     sendItem(item: T): void;
     /** Send a batch of items to the client. See {@link sendItem} for disconnect semantics. */
     sendBatch(items: T[]): void;
-    /** Signal stream completion to the client. */
+    /** Signal stream completion to the client. Re-sendable on purpose: if the
+     *  peer was not connected the frame is dropped, and the End stays in the
+     *  replay buffer for the next reset ack — .NET has no "already ended" latch
+     *  (the End is an ordinary buffer entry, RpcSharedStream.cs:185/239). */
     sendEnd(error?: Error | null): void;
     /**
      * Consume an AsyncIterable and send all items to the client.
@@ -1409,7 +1419,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
      *  ACKs the client sends right after it, so `mustReset` accumulates across
      *  the whole batch — the newest ACK alone can't represent it. */
     private _tryProcessAcks;
-    /** Wait until an ACK is pending (or `_ended`). */
+    /** Wait until an ACK is pending (or the sender is torn down). */
     private _waitAckReady;
     private _sampleRtt;
     reconnect(): void;
@@ -1511,8 +1521,11 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     /** Create a remote (target-side) stream from a parsed stream reference and peer. */
     constructor(ref: RpcStreamRef, peer: RpcPeer);
     /**
-     * For local streams: resolves when the sender finishes pumping (after `toRef()` was called).
-     * Rejects if the source throws. Throws if `toRef()` hasn't been called yet.
+     * For local streams: resolves once the consumer acknowledges the end
+     * ($sys.AckEnd) or the sender is disconnected — NOT when the source drains,
+     * since the sender keeps serving acks after End so a reconnect can replay it.
+     * A source error reaches the consumer as $sys.End(error) instead of rejecting
+     * this. Throws if `toRef()` hasn't been called yet.
      */
     get whenSent(): Promise<void>;
     /** Local sender backing this stream after `toRef()` has been called.

package/dist/index.d.ts

@@ -1021,6 +1021,7 @@ declare abstract class RpcPeer {
      *  (queries) never time out here. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
+    get wireConnection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
@@ -1047,7 +1048,9 @@ declare abstract class RpcPeer {
      *  stays in the hub and all client proxies bound to it remain valid. */
     disconnect(): void;
     close(): void;
-    /** Send pre-serialized wire data through the current connection. */
+    /** Send pre-serialized wire data through the current connection. Callers are
+     *  already gated on `_isConnected`; the check is repeated here so the next one
+     *  cannot reintroduce a pre-handshake write. $sys.Handshake does not use this. */
     protected _sendWireData(data: string | Uint8Array): void;
     /** Override in subclasses to handle the remote peer's handshake response. */
     protected _onHandshakeReceived(_handshake: RemoteHandshake): void;
@@ -1326,7 +1329,11 @@ declare class RpcStreamSender<T> implements IRpcObject {
     readonly sourceUsesAbortSignal: boolean;
     /** Next stream index that will be sent (matches .NET's `index`). */
     private _nextIndex;
-    private _ended;
+    /** Torn down — `disconnect()` ran. .NET's counterpart is disposal; note it
+     *  does NOT mean "an End was sent", which .NET does not track at all. */
+    private _isDisposed;
+    /** The pump has returned. .NET's `WhenRunning.IsCompleted`. */
+    private _isCompleted;
     private _started;
     /** Highest `nextIndex` observed in an ACK so far (matches .NET's `lastAckNextIndex` idiom). */
     private _lastAckedIndex;
@@ -1379,14 +1386,17 @@ declare class RpcStreamSender<T> implements IRpcObject {
      *
      * Advances `_nextIndex` unconditionally — even if the peer is disconnected
      * the item is considered "sent" from the pump's perspective so the replay
-     * buffer indexing stays consistent. If a connection is absent, the wire
+     * buffer indexing stays consistent. If the peer isn't connected, the wire
      * message is dropped; the item will be resent from the replay buffer
      * after a reconnect (client sends `Ack(N, mustReset=true)`).
      */
     sendItem(item: T): void;
     /** Send a batch of items to the client. See {@link sendItem} for disconnect semantics. */
     sendBatch(items: T[]): void;
-    /** Signal stream completion to the client. */
+    /** Signal stream completion to the client. Re-sendable on purpose: if the
+     *  peer was not connected the frame is dropped, and the End stays in the
+     *  replay buffer for the next reset ack — .NET has no "already ended" latch
+     *  (the End is an ordinary buffer entry, RpcSharedStream.cs:185/239). */
     sendEnd(error?: Error | null): void;
     /**
      * Consume an AsyncIterable and send all items to the client.
@@ -1409,7 +1419,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
      *  ACKs the client sends right after it, so `mustReset` accumulates across
      *  the whole batch — the newest ACK alone can't represent it. */
     private _tryProcessAcks;
-    /** Wait until an ACK is pending (or `_ended`). */
+    /** Wait until an ACK is pending (or the sender is torn down). */
     private _waitAckReady;
     private _sampleRtt;
     reconnect(): void;
@@ -1511,8 +1521,11 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     /** Create a remote (target-side) stream from a parsed stream reference and peer. */
     constructor(ref: RpcStreamRef, peer: RpcPeer);
     /**
-     * For local streams: resolves when the sender finishes pumping (after `toRef()` was called).
-     * Rejects if the source throws. Throws if `toRef()` hasn't been called yet.
+     * For local streams: resolves once the consumer acknowledges the end
+     * ($sys.AckEnd) or the sender is disconnected — NOT when the source drains,
+     * since the sender keeps serving acks after End so a reconnect can replay it.
+     * A source error reaches the consumer as $sys.End(error) instead of rejecting
+     * this. Throws if `toRef()` hasn't been called yet.
      */
     get whenSent(): Promise<void>;
     /** Local sender backing this stream after `toRef()` has been called.