@actuallab/rpc 14.3.34 → 14.4.11

package/dist/index.d.cts

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** Max time a call may wait for the connection before it is sent. */
+    /** Max time a call may wait for a connection - before it is sent, and again for the
+     *  duration of any outage it is still pending through. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -1003,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1012,11 +1015,13 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
      *  the connect timeout while a call still awaits the wire, the run timeout
-     *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
-     *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
-     *  time out here. */
+     *  once it has been sent, and the connect timeout again for any pending call while the
+     *  peer is away. Mirrors .NET `RpcOutboundCallTracker.HandleDisconnect` (ConnectTimeout,
+     *  per outage) plus `Maintain` (RunTimeout, per connection). Calls without timeouts
+     *  (queries) never time out here. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
+    get wireConnection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
@@ -1043,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;
@@ -1322,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;
@@ -1375,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.
@@ -1405,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;
@@ -1507,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

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** Max time a call may wait for the connection before it is sent. */
+    /** Max time a call may wait for a connection - before it is sent, and again for the
+     *  duration of any outage it is still pending through. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -1003,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1012,11 +1015,13 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
      *  the connect timeout while a call still awaits the wire, the run timeout
-     *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
-     *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
-     *  time out here. */
+     *  once it has been sent, and the connect timeout again for any pending call while the
+     *  peer is away. Mirrors .NET `RpcOutboundCallTracker.HandleDisconnect` (ConnectTimeout,
+     *  per outage) plus `Maintain` (RunTimeout, per connection). Calls without timeouts
+     *  (queries) never time out here. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
+    get wireConnection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
@@ -1043,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;
@@ -1322,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;
@@ -1375,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.
@@ -1405,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;
@@ -1507,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.