Modern JS framework with TypeScript

Initialize a new TypeScript project and install BiomeJS.

Configure BiomeJS linter and formatter rules, leveraging your existing ESLint knowledge.

Integrate BiomeJS with VS Code for real-time feedback and set up pre-commit hooks.

Configure `tsconfig.json` for strict library type checking and declaration file generation.

Configure Vite in library mode to produce both ESM and CommonJS outputs.

Refine the Vite build by configuring Rollup options to externalize peer dependencies.

Set up Vitest for unit testing and configure code coverage reporting.

Design and implement a generic `Observer` interface with `next`, `error`, and `complete` methods.

Implement a `Subscription` class with teardown logic for resource management.

Implement the core `Observable` class using a generic type parameter for the emitted value.

Implement the `subscribe` method to manage the connection between an `Observer` and the `Observable`'s producer function, returning a `Subscription`.

Write unit tests for the complete observable lifecycle: subscription, synchronous/asynchronous emission, error, completion, and unsubscription.

Implement a `pipe` method on the `Observable` prototype for composing operators, using function overloads for type safety across multiple operators.

Implement and test static factory functions (`of`, `from`, `interval`) for creating observables, ensuring correct type inference.

Implement a generic `Subject` class that acts as both an `Observer` and an `Observable` to multicast values.

Implement and test a `share` operator that uses a `Subject` to convert a cold, unicast observable into a hot, multicast observable.

Implement and test a type-safe `map` operator function that correctly infers its output type from the projection function's return type.

Implement and test a type-safe `filter` operator function, using a type predicate in the filter function to narrow the output observable's type.

Implement and test a type-safe `scan` operator function, ensuring the accumulator's type is correctly inferred and maintained.

Implement and test a `tap` operator for performing side effects (e.g., logging) without altering the stream.

Implement and test a static `merge` operator that combines multiple observables, inferring the output type as a union of the input observable types.

Implement and test a static `combineLatest` operator, using tuple types to correctly type the combined array of latest values.

Using Vitest's fake timers, implement and test a `delay` operator to shift emissions in time.

Using Vitest's fake timers, implement and test a `debounceTime` operator to control emission rates.

Using Vitest's fake timers, implement and test a `throttleTime` operator to discard emissions for a specified duration.

Implement and test a `catchError` operator that allows switching to a new observable on error, using conditional types for a flexible return signature.

Implement and test a `retry` operator to resubscribe to a failing source observable a specified number of times.

Implement and test a `take` operator to limit the number of emissions before automatically completing.

Implement and test a `takeUntil` operator that completes the source stream based on an emission from a notifier observable.

Design a type-safe event map interface using mapped types to link event names (strings) to specific payload types.

Implement an `EventBus` class with a generic type parameter constrained by the event map.

Implement type-safe `emit` and `on` methods that enforce correct payload types for each event name using key remapping in mapped types.

Implement a method on the `EventBus` that returns a correctly typed observable for a specific event.

Ensure the `EventBus` automatically cleans up its internal listeners when the returned observable is unsubscribed.

Implement a `TestScheduler` to deterministically test asynchronous observable chains using virtual time.

Design and implement a parser for marble diagram strings to schedule events and assertions within the `TestScheduler`.

Create an assertion helper to test an observable's output against an expected marble diagram.

Implement adapters to convert between your library's observables and RxJS observables.

Write integration tests using the adapters to verify compatibility with core RxJS operators.

Write a test to detect potential memory leaks from unterminated subscriptions.

Configure `package.json` with `exports` and `typesVersions` fields for proper module resolution and type support in consuming projects.

Set up TypeDoc to generate API documentation from TSDoc comments in the source code.

Adopt the Conventional Commits specification and configure a tool (e.g., `release-it`) for automated versioning and changelog generation.

Write a comprehensive `README.md` with installation instructions, API examples, and a conceptual comparison to RxJS.

Perform a dry run to validate the package contents and then publish the library to the npm registry.