@ikonai/sdk 1.4.0 → 1.5.0

package/client/ikon-client-config.d.ts

@@ -389,6 +389,10 @@ export declare const PROTOCOL_WORKER_CONNECT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_RECONNECT_BACKOFF_MS = 2000;
 export declare const DEFAULT_MAX_RECONNECT_ATTEMPTS = 2;
 export declare const DEFAULT_ACTION_ACK_TIMEOUT_MS = 5000;
+export declare const ACTION_ACK_RTT_MULTIPLIER = 3;
+export declare const ACTION_ACK_RTT_SMOOTHING = 0.125;
+export declare const MAX_ACTION_ACK_TIMEOUT_MS = 30000;
 export declare const DEFAULT_PROVISIONING_TIMEOUT_MS = 60000;
 export declare const OFFLINE_SOFT_RETRY_THRESHOLD_MS: number;
 export declare const RECONNECT_RETRY_INTERVAL_MS: number;
+export declare const JOIN_COMPLETION_TIMEOUT_MS = 10000;

package/client/ikon-client.d.ts

@@ -123,6 +123,7 @@ export declare class IkonClient {
     private readonly connectionTimeoutMs;
     private readonly actionAckTimeoutMs;
     private readonly _pendingActionAcks;
+    private _ackRttMs;
     private readonly _actionIdByCallId;
     private readonly _pendingActionResults;
     private readonly endpointSelector;
@@ -168,6 +169,7 @@ export declare class IkonClient {
     private _webRtcAudioStreams;
     private _webRtcVideoStreams;
     private _webRtcTrackMap;
+    private readonly _webRtcTrackMapListeners;
     private _pendingActiveAudioTracks;
     private _keepaliveLockAbort;
     private _fullReauthAttempted;
@@ -176,6 +178,7 @@ export declare class IkonClient {
     private _reauthInProgress;
     private _disconnectedAt;
     private _reconnectTimer;
+    private _joinWatchdogTimer;
     private _serverStopped;
     private _hasBeenConnected;
     private _waitForExternalConnectUrl;
@@ -261,8 +264,19 @@ export declare class IkonClient {
     get webRtcTrackMap(): Map<string, WebRTCTrackMapInfo>;
     /**
      * Callback fired when a WebRTC track map update is received from the server.
+     *
+     * Single-slot: assigning replaces the previous callback, so sharing it between
+     * components requires manual chaining. New code should prefer
+     * {@link addWebRtcTrackMapListener}, which supports any number of subscribers.
      */
     onWebRtcTrackMapChanged?: (info: WebRTCTrackMapInfo) => void;
+    /**
+     * Subscribe to WebRTC track map updates. Any number of listeners can subscribe
+     * independently — each call returns an unsubscribe function for its listener.
+     * Fired for every update alongside {@link onWebRtcTrackMapChanged}.
+     */
+    addWebRtcTrackMapListener(listener: (info: WebRTCTrackMapInfo) => void): () => void;
+    private notifyWebRtcTrackMapChanged;
     /**
      * Look up the WebRTC video MediaStream for a given app-level stream ID.
      * Checks remote tracks first, then falls back to local capture streams so single-user
@@ -379,12 +393,29 @@ export declare class IkonClient {
      */
     sendActionCallWithResult(actionId: string, payload?: string, timeoutMs?: number): Promise<ActionOutcome>;
     private sendActionCallCore;
+    /**
+     * How long to wait for this call's ack before treating the connection as dead.
+     *
+     * The short deadline exists for the user, not the protocol: a click that does nothing is the worst
+     * thing the UI can do, so the reconnecting overlay has to appear fast. But on a slow link the ack
+     * legitimately takes longer than the configured deadline, and firing then tears down a working
+     * connection and drops WebRTC — the reconnect makes the experience worse than the latency did.
+     * So the deadline follows the link: the configured value is the floor, and a slow link stretches
+     * it to a multiple of the observed round-trip, capped so a truly dead link is still caught quickly.
+     */
+    private getActionAckTimeoutMs;
+    /**
+     * Fold one ack round-trip into the smoothed estimate. Weighted like a TCP RTT estimator: recent
+     * samples move it, a single outlier does not.
+     */
+    private recordAckRtt;
     /**
      * Register an outstanding action call and start its ack-timeout timer. If the
-     * server does not echo back an ActionCallAck for this CallId within
-     * `actionAckTimeoutMs`, we assume the connection is dead and force reconnect.
+     * server does not echo back an ActionCallAck within the deadline, we assume the
+     * connection is dead and force reconnect.
      */
     private trackPendingActionAck;
+    private armActionAckTimer;
     private onActionAckTimeout;
     private clearPendingActionAcks;
     /**
@@ -665,6 +696,14 @@ export declare class IkonClient {
      * Try to handle joined state - only proceeds if both channels are connected and GlobalState is received.
      */
     private tryHandleJoined;
+    /**
+     * Connected channels are not a joined session: until GlobalState arrives, handleJoined has not run,
+     * so the function registry is detached and every inbound call is dropped without an ack while the UI
+     * keeps updating and actions keep dispatching. Nothing else notices — the transport is healthy, so no
+     * transport watchdog fires. Bound the wait and recover, whatever kept the payload from arriving.
+     */
+    private armJoinWatchdog;
+    private clearJoinWatchdog;
     /**
      * Handle joined state - attach function registry, call user's onJoined callback, then send ClientReady.
      * Called on every connect (including reconnects).