shareReplay source subscription persistence limits

Answer

When shareReplay is used with { refCount: true }, the internal replay buffer is discarded and the subscription to the source Observable is torn down as soon as the number of active observers reaches zero. A new observer arriving after this teardown causes shareReplay to resubscribe to the source and start with a fresh buffer; previously emitted values are not replayed unless they fall within a configured bufferSize or windowTime that still holds them.

Confirmed facts (RxJS 6+)

1. shareReplay({ refCount: true }) unsubscribes from the source when observer count drops to 0.
2. The internal buffer is cleared at the same moment.
3. A subsequent subscription triggers a new source subscription and a new empty buffer.

Likely explanation

The operator treats the refCount flag as a lifecycle switch: it mirrors the source while there is at least one subscriber, and when the last subscriber leaves it performs a full teardown, which includes dropping the cached values. This prevents stale replays and avoids keeping a hot connection alive unnecessarily.

Verification steps (no external fetch)

import { interval } from 'rxjs';
import { shareReplay } from 'rxjs/operators';

const source = interval(1000).pipe(
  shareReplay({ bufferSize: 3, refCount: true })
);

let sub1 = source.subscribe(v => console.log('sub1:', v));
let sub2 = source.subscribe(v => console.log('sub2:', v));

// after a few seconds, unsubscribe both
setTimeout(() => {
  sub1.unsubscribe();
  sub2.unsubscribe();
  console.log('observers: 0');
}, 5000);

// new subscription after teardown
setTimeout(() => {
  source.subscribe(v => console.log('new sub:', v));
}, 12000);

Expected console output:

• Both subscriptions receive values from the start.
• After the double unsubscribe, no further logs appear (source stops emitting).
• After the resubscription, logging resumes from the next interval value; earlier values are not replayed.

What to check if behaviour differs

If you observe that the source continues to emit after all observers have left, verify whether refCount was explicitly set to false or omitted, or whether another operator is preserving the subscription.