@100mslive/hms-video-store 0.15.2-alpha.2 → 0.15.2-alpha.4

package/dist/transport/index.d.ts

@@ -79,6 +79,20 @@ export default class HMSTransport {
     publish(tracks: Array<HMSLocalTrack>): Promise<void>;
     unpublish(tracks: Array<HMSLocalTrack>): Promise<void>;
     setSFUNodeId(id?: string): void;
+    /**
+     * A part-way migration leaves the old connections closed, trackStates cleared and the
+     * republish incomplete, and nothing retries it. Counted on its own event, not `publish.failed`
+     * — that one already holds ordinary publish errors. Not onStateChange(Failed): that is
+     * internalLeave, and a transient signal loss here would eject a recoverable peer.
+     */
+    private reportSFUMigrationFailure;
+    /**
+     * True when the live publish connection will carry this track in its next offer — the
+     * transceiver is attached to that connection and trackStates still names it. Keyed on state,
+     * not on the error code: 4008 also covers 'publish connection is gone', where nothing is
+     * staged, and a WebSocketConnectionLost from signal.offer can leave the track fully staged.
+     */
+    private isTrackStagedForPublish;
     /**
      * Republishes one cloned track during migration. The old track is already stopped by the
      * time we get here, so one failure must not abort the tracks still to be republished —
@@ -86,12 +100,27 @@ export default class HMSTransport {
      */
     private republishOnMigration;
     handleSFUMigration(): Promise<void>;
+    /**
+     * A newer NodeInfo starts its own migration, which replaces publishConnection and rebuilds
+     * trackStates. Every republish below is a full offer/answer round trip, so ownership has to be
+     * re-checked between them: continuing would attach this migration's clones to the newer
+     * connection, overwrite the single RENEGOTIATION_CALLBACK_ID slot the newer one is awaiting
+     * (hanging it for the rest of the session), and clobber the auxiliaryTracks list it rebuilt.
+     */
+    private isMigrationSuperseded;
+    private performSFUMigration;
     /**
      * TODO: check if track.publishedTrackId be used instead of the hack to match with track with same type and
      * source. The hack won't work if there are multiple tracks with same source and type.
      */
     trackUpdate(track: HMSLocalTrack, enabled: boolean): void;
     private publishTrack;
+    /**
+     * Drops the track from the offer payload and returns what it dropped, so a failed unpublish
+     * can put it back — the caller leaves the track on localPeer and in the store, and without
+     * its trackState no later offer would ever carry it again.
+     */
+    private takeTrackState;
     private unpublishTrack;
     /** Local teardown for an unpublished track; one failing step must not skip the others. */
     private teardownUnpublishedTrack;
@@ -107,12 +136,6 @@ export default class HMSTransport {
      * Negotiate on first publish after changing role from non-webrtc peer to webrtc peer by sending offer
      */
     private negotiateOnFirstPublish;
-    /**
-     * Neither caller of negotiateOnFirstPublish catches: handleLocalRoleUpdate propagates into
-     * HMSSdk with no catch, and handleSFUMigration runs unawaited. A superseded answer means
-     * another negotiation owns current state, so wire renegotiation and report failure instead —
-     * without initAfterJoin every later publishTrack would await its promise forever.
-     */
     private handleFirstPublishNegotiationError;
     /**
      * An answer may only be applied to the offer it answers. Identity covers the connection
@@ -120,9 +143,19 @@ export default class HMSTransport {
      * setLocalDescription, which is legal in `have-local-offer` and so invisible to
      * signalingState. Every discard is counted so the discard rate is measurable.
      */
+    private publishAnswerDiscardReason;
+    private publishAnswerDiscardError;
+    /** Throws unless the answer still belongs to the offer this negotiation staged. */
     private assertPublishAnswerApplicable;
     /** Drops our own waiter only: a newer owner armed mid-flight must keep its entry. */
     private releaseRenegotiationCallback;
+    /**
+     * Arms the single renegotiation waiter. The slot holds one owner, so whoever takes it has to
+     * settle the one it displaces: releaseRenegotiationCallback deliberately keeps the newer
+     * entry, so a displaced owner is otherwise never settled and its caller awaits for the rest
+     * of the session with the track captured but unpublished.
+     */
+    private armRenegotiationCallback;
     private performPublishRenegotiation;
     private handleIceConnectionFailure;
     private internalConnect;

package/dist/transport/models/PublishAnswerDiscardReason.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Why a publish answer was not applied to the connection. The values are the wire values: they
+ * go out verbatim as `reason` on the `publishAnswerDiscarded` analytics event.
+ */
+export declare enum PublishAnswerDiscardReason {
+    /** handleSFUMigration swapped publishConnection for a different object mid-flight */
+    ConnectionReplaced = "connection_replaced",
+    /** same connection, but a racer staged a newer local offer */
+    SupersededOffer = "superseded_offer",
+    /** neither of the above and still not in have-local-offer; counted, never expected */
+    UnexpectedState = "unexpected_state"
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.15.2-alpha.2",
+  "version": "0.15.2-alpha.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -72,5 +72,5 @@
     "conferencing",
     "100ms"
   ],
-  "gitHead": "5a301d4301bf3bf16809df84b3eb2ac994daa3da"
+  "gitHead": "b5c2124b5888507b814cd7e99a843303f3b6f357"
 }