RxJS for advanced React state

Analyze the core Observable contract (producer-consumer, lazy execution, teardown logic) and contrast its behavior with Promises.

Explain the concept of cold vs. hot Observables and their execution semantics.

Create Observables from static data, events, and promises using `of`, `from`, and `fromEvent`.

Generate time-based and deferred Observables using `interval`, `timer`, and `defer`.

Implement a custom Observable using the `Observable` constructor to wrap a non-standard asynchronous source.

Inspect stream emissions, errors, and completions for debugging using the `tap` operator.

Transform stream values using `map` and accumulate state within a stream using `scan`.

Filter streams based on value, position, or time using `filter`, `take`, `debounceTime`, and `throttleTime`.

Control emissions based on value changes or stream activity using `distinctUntilChanged` and `sampleTime`.

Combine multiple streams declaratively using `combineLatest`, `merge`, `concat`, and `zip`.

Execute and collect a group of Observables in parallel using `forkJoin`.

Apply and contrast the four primary flattening operators (`mergeMap`, `switchMap`, `concatMap`, `exhaustMap`) to manage async concurrency patterns.

Handle stream errors gracefully using `catchError` and implement retry logic with `retry`.

Explain the dual nature of a Subject as both an Observable and an Observer.

Apply `BehaviorSubject` to manage state with an initial value and synchronous access to the current value.

Use `ReplaySubject` to cache and replay a history of emissions to late subscribers.

Convert a cold Observable to a hot, shared Observable using the `shareReplay` operator to prevent redundant work.

Analyze the differences between Subjects and `shareReplay` for creating shared, multicasted streams.

Explain the challenges of integrating Observables with React's lifecycle, including memory leaks and 'tearing' in concurrent rendering.

Implement a basic subscription hook using `useEffect` and `useState` to demonstrate the common pitfalls.

Apply the `useSyncExternalStore` hook to create a tear-free, reusable `useObservable` hook for safe component subscriptions.

Refactor a simple Subject-based event bus into a scalable, type-safe solution for cross-component communication.

Build a reactive store for centralized application state using a `BehaviorSubject`.

Implement derived state by combining multiple state sources with `combineLatest`.

Handle complex form validation with inter-field dependencies by combining value streams.

Create a Redux-like pattern with action streams and a state reducer function powered by the `scan` operator.

Implement optimistic updates with a rollback strategy using `concat`, `tap`, and `catchError`.

Build undo/redo functionality for state changes using the `buffer` and `scan` operators.

Create and manage a basic Zustand store, covering atomic state updates, actions, and selectors.

Implement Zustand middleware to bridge actions with Observable streams for handling async workflows (e.g., an 'epic' pattern).

Apply RxJS `switchMap` within Zustand middleware to handle form submission side effects while using the store for form state.

Create derived RxJS streams from Zustand selectors to combine store state with other asynchronous sources.

Handle cross-store synchronization and coordination using RxJS operators.

Implement a type-ahead search feature that cancels previous requests on new input using `switchMap`.

Wrap the WebSocket API in a custom Observable that manages its connection lifecycle and message stream.

Implement a robust automatic reconnection strategy with exponential backoff for a failing Observable stream (e.g., WebSocket).

Build an in-memory cache for API requests with time-based invalidation using `shareReplay`.

Implement a long-polling mechanism that re-initiates a request only after the previous one completes, using the `expand` operator.

Model a collaborative editing session by merging a local user input stream with a simulated remote update stream.

Debug complex Observable chains using advanced techniques like custom logging operators and RxJS DevTools.