@stream-io/video-client 1.48.0 → 1.50.0

package/src/rtc/__tests__/Subscriber.test.ts

@@ -11,8 +11,10 @@ import {
   ErrorCode,
   PeerType,
   TrackType,
+  WebsocketReconnectStrategy,
 } from '../../gen/video/sfu/models/models';
 import { NegotiationError } from '../NegotiationError';
+import { ReconnectReason } from '../types';
 import { IceTrickleBuffer } from '../IceTrickleBuffer';
 import { StreamClient } from '../../coordinator/connection/client';
 
@@ -26,10 +28,11 @@ vi.mock('../../StreamSfuClient', () => {
 describe('Subscriber', () => {
   let sfuClient: StreamSfuClient;
   let subscriber: Subscriber;
-  const state = new CallState();
+  let state: CallState;
   let dispatcher: Dispatcher;
 
   beforeEach(() => {
+    state = new CallState();
     dispatcher = new Dispatcher();
     sfuClient = new StreamSfuClient({
       dispatcher,
@@ -62,6 +65,7 @@ describe('Subscriber', () => {
   });
 
   afterEach(() => {
+    vi.useRealTimers();
     vi.clearAllMocks();
     vi.resetModules();
     subscriber.dispose();
@@ -97,7 +101,14 @@ describe('Subscriber', () => {
       });
     });
 
+    const simulatePriorIceConnected = () => {
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'connected';
+      subscriber['onIceConnectionStateChange']();
+    };
+
     it(`should perform ICE restart when connection state changes to 'failed'`, () => {
+      simulatePriorIceConnected();
       vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
       // @ts-expect-error - private field
       subscriber['pc'].iceConnectionState = 'failed';
@@ -106,6 +117,7 @@ describe('Subscriber', () => {
     });
 
     it(`should perform ICE restart when connection state changes to 'disconnected'`, () => {
+      simulatePriorIceConnected();
       vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
       vi.useFakeTimers();
       // @ts-expect-error - private field
@@ -115,6 +127,51 @@ describe('Subscriber', () => {
       expect(subscriber.restartIce).toHaveBeenCalled();
     });
 
+    it(`does NOT perform ICE restart when ICE never connected and state goes to 'failed' — emits REJOIN with 'ice_never_connected'`, () => {
+      vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
+      subscriber['onReconnectionNeeded'] = vi.fn();
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'failed';
+      subscriber['onIceConnectionStateChange']();
+      expect(subscriber.restartIce).not.toHaveBeenCalled();
+      expect(subscriber['onReconnectionNeeded']).toHaveBeenCalledWith(
+        WebsocketReconnectStrategy.REJOIN,
+        ReconnectReason.ICE_NEVER_CONNECTED,
+        PeerType.SUBSCRIBER,
+      );
+    });
+
+    it(`isStable() returns true only when ICE is connected/completed and connectionState is connected`, () => {
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'connected';
+      // @ts-expect-error - private field
+      subscriber['pc'].connectionState = 'connected';
+      expect(subscriber.isStable()).toBe(true);
+
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'completed';
+      expect(subscriber.isStable()).toBe(true);
+
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'disconnected';
+      expect(subscriber.isStable()).toBe(false);
+
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'new';
+      expect(subscriber.isStable()).toBe(false);
+    });
+
+    it(`iceHasEverConnected tracks lifetime connectivity`, () => {
+      expect(subscriber['iceHasEverConnected']).toBe(false);
+      simulatePriorIceConnected();
+      expect(subscriber['iceHasEverConnected']).toBe(true);
+      // going disconnected does not reset the flag
+      // @ts-expect-error - private field
+      subscriber['pc'].iceConnectionState = 'disconnected';
+      subscriber['onIceConnectionStateChange']();
+      expect(subscriber['iceHasEverConnected']).toBe(true);
+    });
+
     it(`should throw NegotiationError when SFU returns an error`, async () => {
       sfuClient.iceRestart = vi.fn().mockResolvedValue({
         response: {
@@ -216,6 +273,150 @@ describe('Subscriber', () => {
     });
   });
 
+  describe('interruptedTracks', () => {
+    const setup = ({ muted = false }: { muted?: boolean } = {}) => {
+      const mediaStream = new MediaStream();
+      const track = new MediaStreamTrack();
+      // @ts-expect-error - mock
+      mediaStream.id = 'lookup:TRACK_TYPE_AUDIO';
+      // @ts-expect-error - mock
+      track.kind = 'audio';
+      Object.defineProperty(track, 'muted', {
+        configurable: true,
+        get: () => muted,
+      });
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('session-id', {
+        sessionId: 'session-id',
+        trackLookupPrefix: 'lookup',
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track });
+
+      const calls = (track.addEventListener as ReturnType<typeof vi.fn>).mock
+        .calls;
+      const handlers: Record<string, () => void> = {};
+      for (const [event, handler] of calls) {
+        handlers[event] = handler as () => void;
+      }
+      return { track, handlers };
+    };
+
+    const interruptedFor = (sessionId: string) =>
+      state.participants.find((p) => p.sessionId === sessionId)
+        ?.interruptedTracks ?? [];
+
+    it('adds the track type when the mute handler fires', () => {
+      const { handlers } = setup();
+      expect(interruptedFor('session-id')).toEqual([]);
+
+      handlers['mute']();
+
+      expect(interruptedFor('session-id')).toEqual([TrackType.AUDIO]);
+    });
+
+    it('removes the track type when the unmute handler fires', () => {
+      const { handlers } = setup();
+      handlers['mute']();
+      expect(interruptedFor('session-id')).toEqual([TrackType.AUDIO]);
+
+      handlers['unmute']();
+
+      expect(interruptedFor('session-id')).toEqual([]);
+    });
+
+    it('seeds the track type when the track arrives already muted', () => {
+      setup({ muted: true });
+
+      expect(interruptedFor('session-id')).toEqual([TrackType.AUDIO]);
+    });
+
+    it('clears the track type when the track ends', () => {
+      const { handlers } = setup();
+      handlers['mute']();
+      expect(interruptedFor('session-id')).toEqual([TrackType.AUDIO]);
+
+      handlers['ended']();
+
+      expect(interruptedFor('session-id')).toEqual([]);
+    });
+
+    it('ignores non-audio remote tracks to avoid Dynascale false positives', () => {
+      // Remote video track.muted is dominated by viewport-driven
+      // SFU unsubscriptions, so we deliberately only track audio
+      // interruption on remote participants.
+      const mediaStream = new MediaStream();
+      const track = new MediaStreamTrack();
+      // @ts-expect-error - mock
+      mediaStream.id = 'video-lookup:TRACK_TYPE_VIDEO';
+      // @ts-expect-error - mock
+      track.kind = 'video';
+      Object.defineProperty(track, 'muted', {
+        configurable: true,
+        get: () => true,
+      });
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('video-session', {
+        sessionId: 'video-session',
+        trackLookupPrefix: 'video-lookup',
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track });
+
+      // Seeded muted track is ignored.
+      expect(interruptedFor('video-session')).toEqual([]);
+
+      // Subsequent mute / unmute events are ignored too.
+      const calls = (track.addEventListener as ReturnType<typeof vi.fn>).mock
+        .calls;
+      const handlers: Record<string, () => void> = {};
+      for (const [event, handler] of calls) {
+        handlers[event] = handler as () => void;
+      }
+      handlers['mute']();
+      handlers['unmute']();
+      expect(interruptedFor('video-session')).toEqual([]);
+    });
+
+    it('does not mutate state for orphaned tracks until associated', () => {
+      const mediaStream = new MediaStream();
+      const track = new MediaStreamTrack();
+      // @ts-expect-error - mock
+      mediaStream.id = 'orphan:TRACK_TYPE_AUDIO';
+      // @ts-expect-error - mock
+      track.kind = 'audio';
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track });
+
+      const calls = (track.addEventListener as ReturnType<typeof vi.fn>).mock
+        .calls;
+      const handlers: Record<string, () => void> = {};
+      for (const [event, handler] of calls) {
+        handlers[event] = handler as () => void;
+      }
+
+      // Orphan: handler fires before the participant exists.
+      handlers['mute']();
+      expect(state.participants).toEqual([]);
+
+      // Once the participant is registered, the next event lands.
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('orphan-session', {
+        sessionId: 'orphan-session',
+        trackLookupPrefix: 'orphan',
+      });
+      handlers['mute']();
+
+      expect(interruptedFor('orphan-session')).toEqual([TrackType.AUDIO]);
+    });
+  });
+
   describe('Negotiation', () => {
     it('negotiates with the SFU', async () => {
       sfuClient.sendAnswer = vi.fn();

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -16,8 +16,8 @@ const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
     close: vi.fn(),
     connectionState: 'connected',
     signalingState: 'stable',
-    getReceivers: vi.fn(),
-    getSenders: vi.fn(),
+    getReceivers: vi.fn().mockReturnValue([]),
+    getSenders: vi.fn().mockReturnValue([]),
     removeTrack: vi.fn(),
   };
 });
@@ -109,6 +109,16 @@ const AudioContextMock = vi.fn((): Partial<AudioContext> => {
         gain: { value: 1 },
       } as unknown as GainNode;
     }),
+    // Silent keep-alive node used by DynascaleManager's probe AudioContext.
+    createConstantSource: vi.fn(() => {
+      return {
+        offset: { value: 0 },
+        connect: vi.fn((v) => v),
+        disconnect: vi.fn(),
+        start: vi.fn(),
+        stop: vi.fn(),
+      } as unknown as ConstantSourceNode;
+    }),
     close: vi.fn(async function () {
       this.state = 'closed';
     }),
@@ -119,6 +129,7 @@ const AudioContextMock = vi.fn((): Partial<AudioContext> => {
       this.sinkId = sinkId;
     }),
     addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
   };
 });
 vi.stubGlobal('AudioContext', AudioContextMock);

package/src/rtc/helpers/__tests__/degradationPreference.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { DegradationPreference } from '../../../gen/video/sfu/models/models';
+import { toRTCDegradationPreference } from '../degradationPreference';
+
+describe('toRTCDegradationPreference', () => {
+  it.each([
+    [DegradationPreference.BALANCED, 'balanced'],
+    [DegradationPreference.MAINTAIN_FRAMERATE, 'maintain-framerate'],
+    [DegradationPreference.MAINTAIN_RESOLUTION, 'maintain-resolution'],
+    [
+      DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION,
+      'maintain-framerate-and-resolution',
+    ],
+  ])('maps %s to "%s"', (preference, expected) => {
+    expect(toRTCDegradationPreference(preference)).toBe(expected);
+  });
+
+  it('returns undefined for UNSPECIFIED', () => {
+    expect(
+      toRTCDegradationPreference(DegradationPreference.UNSPECIFIED),
+    ).toBeUndefined();
+  });
+});

package/src/rtc/helpers/degradationPreference.ts

@@ -0,0 +1,22 @@
+import { DegradationPreference } from '../../gen/video/sfu/models/models';
+import { ensureExhausted } from '../../helpers/ensureExhausted';
+
+export const toRTCDegradationPreference = (
+  preference: DegradationPreference,
+): RTCDegradationPreference | undefined => {
+  switch (preference) {
+    case DegradationPreference.BALANCED:
+      return 'balanced';
+    case DegradationPreference.MAINTAIN_FRAMERATE:
+      return 'maintain-framerate';
+    case DegradationPreference.MAINTAIN_RESOLUTION:
+      return 'maintain-resolution';
+    case DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION:
+      // @ts-expect-error not in the typedefs yet
+      return 'maintain-framerate-and-resolution';
+    case DegradationPreference.UNSPECIFIED:
+      return undefined;
+    default:
+      ensureExhausted(preference, 'Unknown degradation preference');
+  }
+};

package/src/rtc/index.ts

@@ -1,5 +1,6 @@
 export * from './codecs';
 export * from './Dispatcher';
+export * from './NegotiationError';
 export * from './IceTrickleBuffer';
 export * from './Publisher';
 export * from './Subscriber';

package/src/rtc/types.ts

@@ -10,18 +10,55 @@ import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
 
+/**
+ * Canonical reasons the SDK uses to trigger a reconnection. Free-form strings
+ * are still accepted at the callback boundary (e.g. when forwarding an SFU
+ * error message), but only the members below influence reconnect-loop
+ * behavior. In particular, `Call.reconnect` programmatically inspects
+ * `ICE_NEVER_CONNECTED` to drive the unsupported-network detector — pass a
+ * canonical member when you want the SDK to react to the reason; pass a
+ * free-form string when the value is purely diagnostic.
+ */
+export const ReconnectReason = {
+  /** ICE never reached `connected`/`completed`, escalate to REJOIN. */
+  ICE_NEVER_CONNECTED: 'ice_never_connected',
+  /** RTCPeerConnection.connectionState became `failed`. */
+  CONNECTION_FAILED: 'connection_failed',
+  /** `restartIce()` rejected. */
+  RESTART_ICE_FAILED: 'restart_ice_failed',
+  /** SFU `goAway` event, migrate to a new SFU. */
+  GO_AWAY: 'go_away',
+  /** Network came back online after going offline. */
+  NETWORK_BACK_ONLINE: 'network_back_online',
+  /** SFU error event with no descriptive message. */
+  SFU_ERROR: 'sfu_error',
+} as const;
+
+export type ReconnectReason =
+  | (typeof ReconnectReason)[keyof typeof ReconnectReason]
+  | (string & {});
+
 export type OnReconnectionNeeded = (
   kind: WebsocketReconnectStrategy,
-  reason: string,
+  reason: ReconnectReason,
   peerType: PeerType,
 ) => void;
 
+/**
+ * Fires the first time a peer connection's ICE transport reaches
+ * `connected` or `completed` during its lifetime. Used by `Call` to reset
+ * the "ICE never connected" failure counter only when WebRTC has actually
+ * recovered, not merely when the SFU join handshake succeeded.
+ */
+export type OnIceConnected = (peerType: PeerType) => void;
+
 export type BasePeerConnectionOpts = {
   sfuClient: StreamSfuClient;
   state: CallState;
   connectionConfig?: RTCConfiguration;
   dispatcher: Dispatcher;
   onReconnectionNeeded?: OnReconnectionNeeded;
+  onIceConnected?: OnIceConnected;
   tag: string;
   enableTracing: boolean;
   iceRestartDelay?: number;

package/src/stats/rtc/types.ts

@@ -16,6 +16,7 @@ export type RTCStatsDataType =
   | RTCSessionDescriptionInit
   | (RTCIceCandidateInit | RTCIceCandidate) // addIceCandidate
   | object
+  | number
   | null
   | undefined;
 

package/src/store/__tests__/rxUtils.test.ts

@@ -0,0 +1,276 @@
+import { describe, expect, it, vi } from 'vitest';
+import { BehaviorSubject, Subject, throwError } from 'rxjs';
+import { promiseWithResolvers } from '../../helpers/promise';
+import {
+  createSafeAsyncSubscription,
+  createSubscription,
+  getCurrentValue,
+  setCurrentValue,
+  setCurrentValueAsync,
+  updateValue,
+} from '../rxUtils';
+
+describe('getCurrentValue', () => {
+  it('returns the current value of a BehaviorSubject', () => {
+    const subject = new BehaviorSubject(42);
+    expect(getCurrentValue(subject)).toBe(42);
+  });
+
+  it('reflects subsequent emissions', () => {
+    const subject = new BehaviorSubject('a');
+    subject.next('b');
+    expect(getCurrentValue(subject)).toBe('b');
+  });
+
+  it('rethrows errors emitted by the observable', () => {
+    const err = new Error('observable failed');
+    expect(() => getCurrentValue(throwError(() => err))).toThrow(err);
+  });
+});
+
+describe('setCurrentValue', () => {
+  it('sets a plain value and returns it', () => {
+    const subject = new BehaviorSubject(1);
+    const result = setCurrentValue(subject, 5);
+    expect(result).toBe(5);
+    expect(subject.getValue()).toBe(5);
+  });
+
+  it('applies a function patch using the current value', () => {
+    const subject = new BehaviorSubject(10);
+    const result = setCurrentValue(subject, (n) => n * 2);
+    expect(result).toBe(20);
+    expect(subject.getValue()).toBe(20);
+  });
+
+  it('emits the new value to subscribers', () => {
+    const subject = new BehaviorSubject(0);
+    const seen: number[] = [];
+    const sub = subject.subscribe((v) => seen.push(v));
+    setCurrentValue(subject, 1);
+    setCurrentValue(subject, (n) => n + 1);
+    sub.unsubscribe();
+    expect(seen).toEqual([0, 1, 2]);
+  });
+});
+
+describe('setCurrentValueAsync', () => {
+  it('passes the current value to the update fn and emits the resolved value', async () => {
+    const subject = new BehaviorSubject(1);
+    const update = vi.fn(async (n: number) => n + 1);
+
+    const result = await setCurrentValueAsync(subject, update);
+
+    expect(update).toHaveBeenCalledWith(1);
+    expect(result).toBe(2);
+    expect(subject.getValue()).toBe(2);
+  });
+
+  it('serializes concurrent calls on the same subject so each sees the previous result', async () => {
+    const subject = new BehaviorSubject(0);
+    const observed: number[] = [];
+
+    const append = (delay: number) =>
+      setCurrentValueAsync(subject, async (n) => {
+        observed.push(n);
+        await new Promise((r) => setTimeout(r, delay));
+        return n + 1;
+      });
+
+    const [a, b, c] = await Promise.all([append(10), append(0), append(0)]);
+
+    expect(observed).toEqual([0, 1, 2]);
+    expect([a, b, c]).toEqual([1, 2, 3]);
+    expect(subject.getValue()).toBe(3);
+  });
+
+  it('does not block updates on a different subject', async () => {
+    const a = new BehaviorSubject('a-0');
+    const b = new BehaviorSubject('b-0');
+
+    const gate = promiseWithResolvers();
+
+    const aPending = setCurrentValueAsync(a, async (v) => {
+      await gate.promise;
+      return `${v}-done`;
+    });
+    const bDone = await setCurrentValueAsync(b, async (v) => `${v}-done`);
+
+    expect(bDone).toBe('b-0-done');
+    expect(b.getValue()).toBe('b-0-done');
+
+    gate.resolve();
+    await expect(aPending).resolves.toBe('a-0-done');
+    expect(a.getValue()).toBe('a-0-done');
+  });
+
+  it('propagates rejections without emitting and keeps the prior value', async () => {
+    const subject = new BehaviorSubject(7);
+    const emitted: number[] = [];
+    const sub = subject.subscribe((v) => emitted.push(v));
+
+    const boom = new Error('boom');
+    await expect(
+      setCurrentValueAsync(subject, async () => {
+        throw boom;
+      }),
+    ).rejects.toBe(boom);
+
+    expect(subject.getValue()).toBe(7);
+    // Only the initial replay from the BehaviorSubject, no second emission.
+    expect(emitted).toEqual([7]);
+    sub.unsubscribe();
+  });
+
+  it('continues to process queued updates after a rejection', async () => {
+    const subject = new BehaviorSubject(0);
+
+    const failing = setCurrentValueAsync(subject, async () => {
+      throw new Error('nope');
+    });
+    const succeeding = setCurrentValueAsync(subject, async (n) => n + 5);
+
+    await expect(failing).rejects.toThrow('nope');
+    await expect(succeeding).resolves.toBe(5);
+    expect(subject.getValue()).toBe(5);
+  });
+});
+
+describe('updateValue', () => {
+  it('returns the previous and new values', () => {
+    const subject = new BehaviorSubject(1);
+    const { lastValue, value } = updateValue(subject, 2);
+    expect(lastValue).toBe(1);
+    expect(value).toBe(2);
+    expect(subject.getValue()).toBe(2);
+  });
+
+  it('rollback restores the previous value', () => {
+    const subject = new BehaviorSubject({ count: 3 });
+    const prior = subject.getValue();
+
+    const { rollback } = updateValue(subject, { count: 99 });
+    expect(subject.getValue()).toEqual({ count: 99 });
+
+    rollback();
+    expect(subject.getValue()).toBe(prior);
+  });
+
+  it('accepts a function patch', () => {
+    const subject = new BehaviorSubject(10);
+    const { value } = updateValue(subject, (n) => n + 5);
+    expect(value).toBe(15);
+    expect(subject.getValue()).toBe(15);
+  });
+});
+
+describe('createSubscription', () => {
+  it('invokes the handler with every emitted value', () => {
+    const subject = new Subject<number>();
+    const handler = vi.fn();
+    const unsubscribe = createSubscription(subject, handler);
+
+    subject.next(1);
+    subject.next(2);
+    unsubscribe();
+
+    expect(handler).toHaveBeenCalledTimes(2);
+    expect(handler).toHaveBeenNthCalledWith(1, 1);
+    expect(handler).toHaveBeenNthCalledWith(2, 2);
+  });
+
+  it('stops receiving values after unsubscribe is called', () => {
+    const subject = new Subject<number>();
+    const handler = vi.fn();
+    const unsubscribe = createSubscription(subject, handler);
+
+    subject.next(1);
+    unsubscribe();
+    subject.next(2);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(1);
+  });
+
+  it('routes errors to the provided onError handler', () => {
+    const err = new Error('observable failed');
+    const onError = vi.fn();
+    createSubscription(
+      throwError(() => err),
+      vi.fn(),
+      onError,
+    );
+    expect(onError).toHaveBeenCalledWith(err);
+  });
+
+  it('swallows errors via the default onError when none is provided', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    expect(() =>
+      createSubscription(
+        throwError(() => new Error('boom')),
+        vi.fn(),
+      ),
+    ).not.toThrow();
+    expect(warn).toHaveBeenCalled();
+
+    warn.mockRestore();
+  });
+});
+
+describe('createSafeAsyncSubscription', () => {
+  it('runs the async handler for each emission', async () => {
+    const subject = new Subject<number>();
+    const handler = vi.fn(async () => {});
+    const unsubscribe = createSafeAsyncSubscription(subject, handler);
+
+    subject.next(1);
+    subject.next(2);
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(handler).toHaveBeenCalledTimes(2);
+    expect(handler).toHaveBeenNthCalledWith(1, 1);
+    expect(handler).toHaveBeenNthCalledWith(2, 2);
+    unsubscribe();
+  });
+
+  it('serializes handlers so a slow one blocks the next', async () => {
+    const subject = new Subject<number>();
+    const events: string[] = [];
+    const gate = promiseWithResolvers();
+
+    const unsubscribe = createSafeAsyncSubscription(subject, async (v) => {
+      events.push(`start:${v}`);
+      if (v === 1) await gate.promise;
+      events.push(`end:${v}`);
+    });
+
+    subject.next(1);
+    subject.next(2);
+    await new Promise((r) => setTimeout(r, 0));
+
+    // Second handler hasn't started yet because the first is still in-flight.
+    expect(events).toEqual(['start:1']);
+
+    gate.resolve();
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(events).toEqual(['start:1', 'end:1', 'start:2', 'end:2']);
+    unsubscribe();
+  });
+
+  it('stops invoking the handler after unsubscribe', async () => {
+    const subject = new Subject<number>();
+    const handler = vi.fn(async () => {});
+    const unsubscribe = createSafeAsyncSubscription(subject, handler);
+
+    subject.next(1);
+    unsubscribe();
+    subject.next(2);
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(1);
+  });
+});