BehaviorSubject should preserve .value after calling .pipe()

[dariomannu]

BehaviorSubject.pipe(...operators), according to the docs, returns an Observable, not another BehaviorSubject.
However, the resulting Observable still has a .next() method, which makes it like a BehaviorSubject.

const stream = new BehaviorSubject(0).pipe(
  map(x => x+1)
);

stream.subscribe(); // to just run it

stream.next(1); // This works fine, stream will emit 2
stream.value; // This is undefined, as .value is no longer available after the call to .pipe().

There is one important exception, though, which is that .value and getValue() are now missing from the above stream.

I'm pretty convinced that the return type of BehaviorSubject.pipe() should be also BehaviorSubject, not just Observable (same for Subject.pipe() which should return another Subject)

I wonder if this was an oversight, an in-progress feature under test and consideration, or something, but it would be certainly useful in a few key scenarios.

I do understand the potential for imperative-progamming misuse, but as long as BehaviorSubject exposes .value, there are many others anyway.
I don't thing we need to address these here, as I'm convinced exposing .value on the result of .pipe() would not add any more potentials for misuse other than those BehaviorSubject.value already has. Feel free to disagree with me on this, in case.

There are certain use cases in which getting the last emitted value from the stream (= from the output of the whole pipeline) has some key benefits.

1: I'm working on a UI library for RxJS, in which a BehaviorSubject can be used to statically render its initial (or latest/current) value into an HTML template. The .value property will be used and printed synchronously to the HTML. If we didn't have .value, we'd have to subscribe to the stream and asynchronously update the DOM, potentially causing unnecessary reflows on the page. .value saves us from that.
Unfortunately, that's hindered by BehaviorSubject.pipe(), as it loses .value.

2: Other use case: some advanced server-side rendering: If we have a BehaviorSubject with an initial/latest/current value, then we can stream it straight to the client and let it render its content. Subsequent emissions from the BehaviorSubject would be genuine updates that we can still send downstream requiring updates on the page.

Playground on Stackblitz

I wonder if there's still any good reason not to expose .value on the result of BehaviorSubject.pipe(), or just make .pipe() explicitly return a normal BehaviorSubject, and if so, are the RxJS team happy to support this proposal?