# RxJS 7 to RxJS Next parity map

This generated map tracks public RxJS 7 operators and functions against the
current exploratory RxJS Next source. It is an API-surface inventory, not a
claim that present entries already have behavioral, lifecycle, overload, or
type parity.

- **RxJS 7 source:** `7.x` at `e5351d02e225e275ac0e497c7b66eaa5f0c88791`
- **Marble evidence:** `e5351d02e225e275ac0e497c7b66eaa5f0c88791`
- **Operator entries:** 113 total; 111 present or partially mapped; 2 missing
- **Creation/utility functions:** 34 total; 27 present or partially mapped; 7 missing

Regenerate after adding or changing capabilities:

```sh
pnpm --filter rxjs run test:unit:parity:generate
pnpm --filter rxjs run test:unit:parity:check
```

## Mapping rules

- RxJS 7 `source.pipe(operator(arg1, arg2))` maps to
  `source[operator](arg1, arg2)` when that exact RxJS Next Symbol exists.
- A root creation function maps to `Observable[factory](...)` when a static
  Symbol exists.
- Platform string methods are shown only as analogues. They do not satisfy
  RxJS Symbol parity.
- Unified mappings in the capability registry are executable adapters. They
  intentionally expose unsupported overloads and semantic differences as
  failing parity tests.
- Platform analogues are documentation only and are not substituted for a
  missing RxJS Symbol.
- “Present” means a current source surface can be invoked. Every behavioral
  claim remains governed by the ported tests.
- The “Marble cases” column counts inventoried cases that import the API in the
  indicated operator or value role. Counts overlap when one case uses several
  APIs.

## Pipeable operators

| RxJS 7 API                | RxJS Next status                            | Current mapping                                                                                                    | Marble cases | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `audit`                   | Present; parity verified                    | `source[throttle](durationSelector, { leading: false, trailing: true, restartOnTrailing: false })`                 | 21           | Adapts audit's duration-next boundary, non-emitting duration completion, source terminal behavior, and cancellation without restarting a duration after a trailing value. Symbol source: `packages/rxjs/src/throttle.ts`; executable adapter: `audit`.                                                                                                                                                                                                                            |
| `auditTime`               | Partial unified mapping                     | `source[throttle](milliseconds, { leading: false, trailing: true, restartOnTrailing: false })`                     | 12           | Numeric duration lifecycle is verified; scheduler arguments are not represented. Symbol source: `packages/rxjs/src/throttle.ts`; executable adapter: `auditTime`.                                                                                                                                                                                                                                                                                                                 |
| `buffer`                  | Present; parity verified                    | `source[buffer]({delay:()=>closingNotifier,emitEmpty:true,emitRemainingOnError:false,restartDelay:false})`         | 26           | Adapts the persistent RxJS 7 closing notifier, completion remainder, error policy, and cancellation lifecycle. Symbol source: `packages/rxjs/src/buffer.ts`; executable adapter: `buffer`.                                                                                                                                                                                                                                                                                        |
| `bufferCount`             | Partial unified mapping                     | `source[buffer]({ maxSize: bufferSize, startEvery: startBufferEvery ?? bufferSize, emitRemainingOnError: false })` | 9            | Adapts count-sized buffers, including overlapping and gapped startBufferEvery windows, completion partials, and RxJS 7 error behavior. Symbol source: `packages/rxjs/src/buffer.ts`; executable adapter: `bufferCount`.                                                                                                                                                                                                                                                           |
| `bufferTime`              | Present; scheduler adapted to host timing   | `source[bufferTime](span, creationInterval ?? null, maxBufferSize ?? Infinity)`                                    | 18           | Preserves tumbling and overlapping host-time windows plus max-size closure. The adapter drops only a recognized trailing SchedulerLike fourth argument. Symbol source: `packages/rxjs/src/buffer-time.ts`; executable adapter: `bufferTimeExact`.                                                                                                                                                                                                                                 |
| `bufferToggle`            | Present; parity unverified                  | `source[bufferToggle](openings, closingSelector)`                                                                  | 18           | Supports overlapping buffers, closes on the first closing value but not closing completion, and flushes live buffers in opening order on source completion. Symbol source: `packages/rxjs/src/buffer-toggle.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                  |
| `bufferWhen`              | Partial unified mapping                     | `source[buffer]({ delay: closingSelector, emitEmpty: true, emitRemainingOnError: false })`                         | 16           | Uses the unified buffer delay selector and discards the active partial buffer when the source errors. Symbol source: `packages/rxjs/src/buffer.ts`; executable adapter: `bufferWhen`.                                                                                                                                                                                                                                                                                             |
| `catchError`              | Present; parity unverified                  | `source[catchError](selector)`                                                                                     | 18           | Replaces source errors with any ObservableValue, preserves caught-source retry identity, and trampolines synchronous retries. Symbol source: `packages/rxjs/src/catch-error.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                  |
| `combineAll`              | **Missing**                                 | —                                                                                                                  | 0            | No current RxJS Next operator mapping.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `combineLatest`           | Partial unified mapping                     | `source[combineLatest]([otherSources])`                                                                            | 34           | Adapts variadic sources to the current array form; projection overloads remain unrepresented. Symbol source: `packages/rxjs/src/combine-latest.ts`; executable adapter: `sourcesArrayWithProjection`.                                                                                                                                                                                                                                                                             |
| `combineLatestAll`        | Present; parity unverified                  | `source[combineLatestAll](project?)`                                                                               | 31           | Collects inner sources until outer completion, then delegates combination to the exact static combineLatest Symbol and projection to map. Symbol source: `packages/rxjs/src/combine-latest-all.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                               |
| `combineLatestWith`       | Partial unified mapping                     | `source[combineLatest]([otherSources])`                                                                            | 30           | Maps the With variant to the unified combineLatest Symbol. Symbol source: `packages/rxjs/src/combine-latest.ts`; executable adapter: `sourcesArrayWithProjection`.                                                                                                                                                                                                                                                                                                                |
| `concat`                  | Partial unified mapping                     | `source[concat]([otherSources])`                                                                                   | 27           | Adapts variadic sources to the current array form. Symbol source: `packages/rxjs/src/concat.ts`; executable adapter: `sourcesArray`.                                                                                                                                                                                                                                                                                                                                              |
| `concatAll`               | Partial unified mapping                     | `source[mergeMap](identity, { concurrent: 1 })`                                                                    | 30           | Flattening is expressed through mergeMap with concurrency one. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `concatAll`.                                                                                                                                                                                                                                                                                                                                  |
| `concatMap`               | Partial unified mapping                     | `source[mergeMap](project, { concurrent: 1 })`                                                                     | 34           | Result-selector overloads remain unrepresented. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `concatMap`.                                                                                                                                                                                                                                                                                                                                                 |
| `concatMapTo`             | Partial unified mapping                     | `source[mergeMap](() => innerSource, { concurrent: 1 })`                                                           | 18           | Result-selector overloads remain unrepresented. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `concatMapTo`.                                                                                                                                                                                                                                                                                                                                               |
| `concatWith`              | Partial unified mapping                     | `source[concat]([otherSources])`                                                                                   | 22           | Maps the With variant to the unified concat Symbol. Symbol source: `packages/rxjs/src/concat.ts`; executable adapter: `sourcesArray`.                                                                                                                                                                                                                                                                                                                                             |
| `connect`                 | Present; parity unverified                  | `source[connect](selector, config?)`                                                                               | 50           | Creates one connector per active result run, establishes the selector result before source activation, and owns selector/source cancellation through the result signal. Symbol source: `packages/rxjs/src/connect.ts`; executable adapter: `identity`.                                                                                                                                                                                                                            |
| `count`                   | Present; parity unverified                  | `source[count](predicate?)`                                                                                        | 23           | Counts all values or predicate matches and emits the total only after successful completion. Symbol source: `packages/rxjs/src/count.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                         |
| `debounce`                | Present; parity unverified                  | `source[debounce](durationSelector)`                                                                               | 26           | Exact selector behavior remains test-driven. Symbol source: `packages/rxjs/src/debounce.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                                      |
| `debounceTime`            | Partial unified mapping                     | `source[debounce](milliseconds)`                                                                                   | 17           | Numeric delays reset a host timer, flush on completion, and cancel via AbortSignal. Scheduler arguments are not represented. Symbol source: `packages/rxjs/src/debounce.ts`; executable adapter: `firstArgument`.                                                                                                                                                                                                                                                                 |
| `defaultIfEmpty`          | Present; parity unverified                  | `source[defaultIfEmpty](defaultValue)`                                                                             | 7            | Exact type and lifecycle parity remain test-driven. Symbol source: `packages/rxjs/src/default-if-empty.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                       |
| `delay`                   | Present; scheduler adapted to host timing   | `source[delay](due)`                                                                                               | 43           | Uses host time virtualized by @rxjs/test. The compatibility adapter drops only a recognized legacy SchedulerLike second argument and rejects other extra values. Symbol source: `packages/rxjs/src/delay.ts`; executable adapter: `dropSchedulerSecondArgument`.                                                                                                                                                                                                                  |
| `delayWhen`               | Present; parity unverified                  | `source[delayWhen](durationSelector, subscriptionDelay?)`                                                          | 15           | Releases each value on its duration's first next, swallows it on empty duration completion, and supports the deprecated subscription-delay gate. Symbol source: `packages/rxjs/src/delay-when.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                |
| `dematerialize`           | Present; parity unverified                  | `source[dematerialize]()`                                                                                          | 13           | Converts next, error, and completion notification shapes back into their represented Observable signals. Symbol source: `packages/rxjs/src/dematerialize.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                     |
| `distinct`                | Present; parity unverified                  | `source[distinct](keySelector?, flushes?)`                                                                         | 22           | Uses Set equality, optional key selection, and an optional flush source that clears remembered keys. Symbol source: `packages/rxjs/src/distinct.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                              |
| `distinctUntilChanged`    | Present; parity unverified                  | `source[distinctUntilChanged](comparator?, keySelector?)`                                                          | 22           | Uses strict equality by default and compares selected keys against the last emitted key. Symbol source: `packages/rxjs/src/distinct-until-changed.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                            |
| `distinctUntilKeyChanged` | Present; parity unverified                  | `source[distinctUntilKeyChanged](key, comparator?)`                                                                | 21           | Delegates property-key comparison to the exact distinctUntilChanged Symbol contract. Symbol source: `packages/rxjs/src/distinct-until-key-changed.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                            |
| `elementAt`               | Present; partial empty behavior             | `source[elementAt](index, defaultValue?)`                                                                          | 12           | The default-value overload is present; the no-default out-of-range error remains compatibility evidence. Symbol source: `packages/rxjs/src/element-at.ts`; executable adapter: `elementAt`.                                                                                                                                                                                                                                                                                       |
| `endWith`                 | Partial unified mapping                     | `source[concat]([values])`                                                                                         | 16           | Adapts trailing values to one iterable concat source; a trailing SchedulerLike is retained as an explicit unsupported-overload failure. Symbol source: `packages/rxjs/src/concat.ts`; executable adapter: `endWith`.                                                                                                                                                                                                                                                              |
| `every`                   | Present; parity unverified                  | `source[every](predicate)`                                                                                         | 22           | Evaluates value, index, and source and cancels upstream before emitting the first false result. Symbol source: `packages/rxjs/src/every.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                      |
| `exhaust`                 | Partial unified mapping                     | `source[exhaustMap](identity)`                                                                                     | 0            | Legacy flattening alias maps to exhaustMap. Symbol source: `packages/rxjs/src/exhaust-map.ts`; executable adapter: `flattenIdentity`.                                                                                                                                                                                                                                                                                                                                             |
| `exhaustAll`              | Partial unified mapping                     | `source[exhaustMap](identity)`                                                                                     | 15           | Flattening is expressed through exhaustMap. Symbol source: `packages/rxjs/src/exhaust-map.ts`; executable adapter: `flattenIdentity`.                                                                                                                                                                                                                                                                                                                                             |
| `exhaustMap`              | Present; parity unverified                  | `source[exhaustMap](project)`                                                                                      | 18           | Legacy result-selector overloads are not represented. Symbol source: `packages/rxjs/src/exhaust-map.ts`; executable adapter: `firstArgument`.                                                                                                                                                                                                                                                                                                                                     |
| `expand`                  | Present; scheduler overload deferred        | `source[expand](project, { concurrent })`                                                                          | 13           | Adapts legacy numeric concurrency to the options contract. Scheduler arguments are not a public platform contract; their ported behavioral claims use explicit test-harness timing rewrites. Symbol source: `packages/rxjs/src/expand.ts`; executable adapter: `expand`.                                                                                                                                                                                                          |
| `filter`                  | Present; parity unverified                  | `source[filter](predicate)`                                                                                        | 21           | The RxJS Symbol form preserves predicate index, type guards, errors, and cancellation without replacing the platform string method; callback receivers must use closures or Function.prototype.bind. Symbol source: `packages/rxjs/src/filter.ts`; executable adapter: `identity`.                                                                                                                                                                                                |
| `finalize`                | Present; parity unverified                  | `source[finalize](callback)`                                                                                       | 8            | Runs once after completion, error, or last-observer cancellation without replacing the platform finally method. Symbol source: `packages/rxjs/src/finalize.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                   |
| `find`                    | Present; parity unverified                  | `source[find](predicate)`                                                                                          | 12           | Emits the first matching value or undefined with predicate index, source identity, and early cancellation, without replacing the platform find() Promise consumer; callback receivers must use closures or Function.prototype.bind. Symbol source: `packages/rxjs/src/find.ts`; executable adapter: `identity`.                                                                                                                                                                   |
| `findIndex`               | Present; parity unverified                  | `source[findIndex](predicate)`                                                                                     | 12           | Emits the first matching index or -1 with predicate source identity, errors, and early cancellation; callback receivers must use closures or Function.prototype.bind. Symbol source: `packages/rxjs/src/find-index.ts`; executable adapter: `identity`.                                                                                                                                                                                                                           |
| `first`                   | Present; parity unverified                  | `source[first](predicate?, defaultValue?)`                                                                         | 17           | Preserves predicate, default-value arity, EmptyError, early cancellation, and the distinct RxJS Symbol contract without replacing the platform first() Promise consumer. Symbol source: `packages/rxjs/src/first.ts`; executable adapter: `identity`.                                                                                                                                                                                                                             |
| `flatMap`                 | Partial unified mapping                     | `source[mergeMap](project, options?)`                                                                              | 0            | RxJS 7 flatMap is an alias of mergeMap. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `mergeMap`.                                                                                                                                                                                                                                                                                                                                                          |
| `groupBy`                 | Present; scheduler-internal cases deferred  | `source[groupBy](keySelector, optionsOrElement?, duration?, connector?)`                                           | 36           | Emits hot read-only keyed group views with options and deprecated positional selector forms; active group observers may retain source work after outer cancellation. Symbol source: `packages/rxjs/src/group-by.ts`; executable adapter: `identity`.                                                                                                                                                                                                                              |
| `ignoreElements`          | Partial unified mapping                     | `source[mergeMap](() => Observable.from([]))`                                                                      | 9            | Maps each input to an ambient empty Observable while retaining source completion and error behavior. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `ignoreElements`.                                                                                                                                                                                                                                                                                       |
| `isEmpty`                 | Present; parity unverified                  | `source[isEmpty]()`                                                                                                | 7            | Emits false and cancels upstream on the first value, or emits true after successful empty completion. Symbol source: `packages/rxjs/src/is-empty.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                             |
| `last`                    | Present; parity unverified                  | `source[last](predicate?, defaultValue?)`                                                                          | 11           | Preserves predicate, default-value arity, EmptyError, completion-time selection, and the distinct RxJS Symbol contract without replacing the platform last() Promise consumer. Symbol source: `packages/rxjs/src/last.ts`; executable adapter: `identity`.                                                                                                                                                                                                                        |
| `map`                     | Present; parity unverified                  | `source[map](project)`                                                                                             | 93           | The RxJS Symbol form preserves projection index, errors, and cancellation without replacing the platform string method; callback receivers must use closures or Function.prototype.bind. Symbol source: `packages/rxjs/src/map.ts`; executable adapter: `identity`.                                                                                                                                                                                                               |
| `mapTo`                   | Partial unified mapping                     | `source[mergeMap](() => Observable.from([value]))`                                                                 | 11           | Expresses constant projection through mergeMap and an ambient single-value Observable. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `mapTo`.                                                                                                                                                                                                                                                                                                              |
| `materialize`             | Present; parity unverified                  | `source[materialize]()`                                                                                            | 10           | Converts every source signal into a Notification next value and completes after materialized error or completion. Symbol source: `packages/rxjs/src/materialize.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                              |
| `max`                     | Present; parity unverified                  | `source[max](comparer?)`                                                                                           | 18           | Delegates unseeded maximum selection and lifecycle behavior to the exact reduce Symbol. Symbol source: `packages/rxjs/src/max.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                |
| `merge`                   | Partial unified mapping                     | `source[merge]([otherSources], { concurrency })`                                                                   | 1            | Adapts variadic sources and the numeric concurrency overload. Symbol source: `packages/rxjs/src/merge.ts`; executable adapter: `mergeSources`.                                                                                                                                                                                                                                                                                                                                    |
| `mergeAll`                | Partial unified mapping                     | `source[mergeMap](identity, { concurrent: concurrency })`                                                          | 25           | Flattening is expressed through mergeMap. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `mergeAll`.                                                                                                                                                                                                                                                                                                                                                        |
| `mergeMap`                | Partial unified mapping                     | `source[mergeMap](project, { concurrent: concurrency })`                                                           | 149          | Adapts numeric concurrency; result-selector overloads remain unrepresented. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `mergeMap`.                                                                                                                                                                                                                                                                                                                      |
| `mergeMapTo`              | Partial unified mapping                     | `source[mergeMap](() => innerSource, { concurrent: concurrency })`                                                 | 106          | Result-selector overloads remain unrepresented. Symbol source: `packages/rxjs/src/merge-map.ts`; executable adapter: `mergeMapTo`.                                                                                                                                                                                                                                                                                                                                                |
| `mergeScan`               | Present; parity unverified                  | `source[mergeScan](accumulator, seed, concurrent?)`                                                                | 20           | Updates shared accumulator state from concurrent inner emissions, queues source values at the concurrency limit, and drains before completion. Symbol source: `packages/rxjs/src/merge-scan.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                  |
| `mergeWith`               | Partial unified mapping                     | `source[merge]([otherSources])`                                                                                    | 17           | Maps the With variant to the unified merge Symbol. Symbol source: `packages/rxjs/src/merge.ts`; executable adapter: `sourcesArray`.                                                                                                                                                                                                                                                                                                                                               |
| `min`                     | Present; parity unverified                  | `source[min](comparer?)`                                                                                           | 18           | Delegates unseeded minimum selection and lifecycle behavior to the exact reduce Symbol. Symbol source: `packages/rxjs/src/min.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                |
| `multicast`               | Compatibility-only                          | `source[multicast](subjectOrFactory, selector?)`                                                                   | 70           | Returns a manually connected compatibility Observable without a selector, or delegates selector forms to the exact Symbol-keyed connect contract. Symbol source: `packages/rxjs/src/multicast.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                |
| `observeOn`               | Partial scheduler mapping                   | `source[observeOn](delay?)`                                                                                        | 7            | The exact Symbol uses virtualizable host timers and AbortSignal cancellation. Ported RxJS 7 evidence adapts only its rxTest TestScheduler argument; other SchedulerLike implementations remain unsupported. Symbol source: `packages/rxjs/src/observe-on.ts`; executable adapter: `portedTestSchedulerDelay`.                                                                                                                                                                     |
| `onErrorResumeNext`       | Partial unified mapping                     | `source[onErrorResumeNext]([otherSources])`                                                                        | 11           | Adapts variadic or single-array source arguments to the current array form. Symbol source: `packages/rxjs/src/on-error-resume-next.ts`; executable adapter: `sourcesArrayOrSingleArray`.                                                                                                                                                                                                                                                                                          |
| `pairwise`                | Present; parity unverified                  | `source[pairwise]()`                                                                                               | 7            | Emits consecutive value tuples from the second value onward with shared activation state and cancellation. Symbol source: `packages/rxjs/src/pairwise.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                        |
| `partition`               | **Missing**                                 | —                                                                                                                  | 0            | No current RxJS Next operator mapping.                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `pluck`                   | Present; parity unverified                  | `source[pluck](...properties)`                                                                                     | 14           | Traverses one or more string, number, or Symbol keys through the exact map Symbol and returns undefined after a nullish path segment. Symbol source: `packages/rxjs/src/pluck.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                |
| `publish`                 | Compatibility-only                          | `source[publish](selector?)`                                                                                       | 64           | Returns a manually connected retained-Subject result without a selector, or a fresh selector-scoped Subject for each active platform run. Symbol source: `packages/rxjs/src/publish.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                          |
| `publishBehavior`         | Compatibility-only                          | `source[publishBehavior](initialValue)`                                                                            | 62           | Returns a manually connected result backed by one retained BehaviorSubject with the requested initial value. Symbol source: `packages/rxjs/src/publish-behavior.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                              |
| `publishLast`             | Compatibility-only                          | `source[publishLast]()`                                                                                            | 61           | Returns a manually connected result backed by one retained AsyncSubject that emits only the final value after completion. Symbol source: `packages/rxjs/src/publish-last.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                     |
| `publishReplay`           | Compatibility-only                          | `source[publishReplay](bufferSize?, windowTime?, selector?, scheduler?)`                                           | 69           | Uses a retained replay connector for manual results and a fresh connector for selector runs. Defined scheduler arguments are not a public platform contract; their ported timing claims use explicit test-harness rewrites. Symbol source: `packages/rxjs/src/publish-replay.ts`; executable adapter: `identity`.                                                                                                                                                                 |
| `race`                    | Partial unified mapping                     | `source[race]([otherSources])`                                                                                     | 12           | Adapts variadic or single-array sources to the current array form. Symbol source: `packages/rxjs/src/race.ts`; executable adapter: `sourcesArrayOrSingleArray`.                                                                                                                                                                                                                                                                                                                   |
| `raceWith`                | Partial unified mapping                     | `source[race]([otherSources])`                                                                                     | 10           | Maps the With variant to the unified race Symbol. Symbol source: `packages/rxjs/src/race.ts`; executable adapter: `sourcesArray`.                                                                                                                                                                                                                                                                                                                                                 |
| `reduce`                  | Present; parity unverified                  | `source[reduce](accumulator, seed?)`                                                                               | 18           | Distinguishes omitted and explicitly undefined seeds and emits accumulated state only on successful completion. Symbol source: `packages/rxjs/src/reduce.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                     |
| `refCount`                | Compatibility-only                          | `source[refCount]()`                                                                                               | 74           | Connects a concrete ConnectableObservable on its first active platform producer run and disconnects after the final run ends. Symbol source: `packages/rxjs/src/ref-count.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                    |
| `repeat`                  | Partial unified mapping                     | `source[repeat](config)`                                                                                           | 64           | Adapts the legacy numeric count to a config object. Symbol source: `packages/rxjs/src/repeat.ts`; executable adapter: `countOrConfig`.                                                                                                                                                                                                                                                                                                                                            |
| `repeatWhen`              | Present; parity unverified                  | `source[repeatWhen](notifier)`                                                                                     | 20           | Creates one hot completion stream and one notifier per shared activation; repeats are sequential and notifier completion or error controls the shared result. Symbol source: `packages/rxjs/src/repeat-when.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                  |
| `retry`                   | Partial unified mapping                     | `source[retry](config)`                                                                                            | 67           | Adapts legacy numeric and config inputs while preserving the RxJS 7 resetOnSuccess default. Symbol source: `packages/rxjs/src/retry.ts`; executable adapter: `retryCountOrConfig`.                                                                                                                                                                                                                                                                                                |
| `retryWhen`               | Present; parity unverified                  | `source[retryWhen](notifier)`                                                                                      | 19           | Creates one hot error stream and one notifier per shared activation; retries are sequential and notifier completion or error controls the shared result. Symbol source: `packages/rxjs/src/retry-when.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                        |
| `sample`                  | Present; parity unverified                  | `source[sample](notifier)`                                                                                         | 16           | Samples the latest unseen source value on notifier emissions; notifier completion does not complete or flush the result. Symbol source: `packages/rxjs/src/sample.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                            |
| `sampleTime`              | Present; scheduler adapted to host timing   | `source[sampleTime](period)`                                                                                       | 10           | Uses a host interval virtualized by @rxjs/test; the generator marks the legacy TestScheduler argument for this adapter and other scheduler arguments remain unsupported. Symbol source: `packages/rxjs/src/sample-time.ts`; executable adapter: `hostTimeFirstArgument`.                                                                                                                                                                                                          |
| `scan`                    | Present; parity unverified                  | `source[scan](accumulator, seed?)`                                                                                 | 12           | Exact overload and no-seed behavior remain test-driven. Symbol source: `packages/rxjs/src/scan.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                               |
| `sequenceEqual`           | Present; parity verified                    | `source[sequenceEqual](otherSource, comparator?)`                                                                  | 23           | Supports strict equality by default and the RxJS 7 comparator overload. Symbol source: `packages/rxjs/src/sequence-equal.ts`; executable adapter: `sequenceEqual`.                                                                                                                                                                                                                                                                                                                |
| `share`                   | Present; platform lifecycle review required | `source[share](config?)`                                                                                           | 176          | Shares one connector and source connection per active run with configurable reset behavior. A late observer joining an already-active platform result bypasses operator initialization, so a replaying custom connector cannot replay history to that observer; ColdObservable compatibility fanout retains that behavior. Symbol source: `packages/rxjs/src/share.ts`; executable adapter: `identity`.                                                                           |
| `shareReplay`             | Present; platform lifecycle review required | `source[shareReplay](configOrBufferSize?, windowTime?)`                                                            | 16           | Uses share with a size/host-time-bounded replay connector, persistent successful terminal cache, error reset, and optional ref-count reset. Active platform late observers cannot receive connector history; ColdObservable and post-terminal activations can. Defined scheduler arguments are not a public platform contract; their ported timing claims use explicit test-harness rewrites. Symbol source: `packages/rxjs/src/share-replay.ts`; executable adapter: `identity`. |
| `single`                  | Present; parity unverified                  | `source[single](predicate?)`                                                                                       | 25           | Requires exactly one value or predicate match and preserves RxJS 7 EmptyError, NotFoundError, and SequenceError outcomes. Symbol source: `packages/rxjs/src/single.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                           |
| `skip`                    | Present; parity unverified                  | `source[skip](count)`                                                                                              | 29           | Suppresses the first count values while preserving completion, errors, and cancellation. Symbol source: `packages/rxjs/src/skip.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                              |
| `skipLast`                | Present; parity unverified                  | `source[skipLast](count)`                                                                                          | 16           | Exact edge-case parity remains test-driven. Symbol source: `packages/rxjs/src/skip-last.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                                      |
| `skipUntil`               | Present; parity unverified                  | `source[skipUntil](notifier)`                                                                                      | 19           | Subscribes to the notifier first, opens after its first value, ignores notifier-only completion, and cancels both inputs through the shared result lifecycle. Symbol source: `packages/rxjs/src/skip-until.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                   |
| `skipWhile`               | Present; parity unverified                  | `source[skipWhile](predicate)`                                                                                     | 15           | Exact predicate parity remains test-driven. Symbol source: `packages/rxjs/src/skip-while.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                                     |
| `startWith`               | Present; scheduler overload deferred        | `source[startWith](...values)`                                                                                     | 24           | Synchronously emits configured prefix values before source activation. Legacy trailing scheduler overloads are not a public platform contract; their ported behavioral claims use explicit test-harness timing rewrites. Symbol source: `packages/rxjs/src/start-with.ts`; executable adapter: `startWith`.                                                                                                                                                                       |
| `subscribeOn`             | Partial scheduler mapping                   | `source[subscribeOn](delay?)`                                                                                      | 8            | The exact Symbol delays source activation with a virtualizable host timer and AbortSignal cancellation. Ported RxJS 7 evidence adapts only its rxTest TestScheduler argument; other SchedulerLike implementations remain unsupported. Symbol source: `packages/rxjs/src/subscribe-on.ts`; executable adapter: `portedTestSchedulerDelay`.                                                                                                                                         |
| `switchAll`               | Partial unified mapping                     | `source[switchMap](identity)`                                                                                      | 11           | Flattening is expressed through switchMap. Symbol source: `packages/rxjs/src/switch-map.ts`; executable adapter: `flattenIdentity`.                                                                                                                                                                                                                                                                                                                                               |
| `switchMap`               | Present; parity unverified                  | `source[switchMap](project)`                                                                                       | 19           | Legacy result-selector overloads are not represented. Symbol source: `packages/rxjs/src/switch-map.ts`; executable adapter: `firstArgument`.                                                                                                                                                                                                                                                                                                                                      |
| `switchMapTo`             | Partial unified mapping                     | `source[switchMap](() => innerSource)`                                                                             | 15           | Legacy result-selector overloads are not represented. Symbol source: `packages/rxjs/src/switch-map.ts`; executable adapter: `switchMapTo`.                                                                                                                                                                                                                                                                                                                                        |
| `switchScan`              | Present; parity unverified                  | `source[switchScan](accumulator, seed)`                                                                            | 18           | Carries inner emissions as accumulator state, cancels the prior inner on each source value, and waits for the current inner after source completion. Symbol source: `packages/rxjs/src/switch-scan.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                           |
| `take`                    | Present; parity unverified                  | `source[take](count)`                                                                                              | 47           | Completes after the requested count and cancels upstream through the derived subscriber signal; nonpositive counts do not activate the source. Symbol source: `packages/rxjs/src/take.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                        |
| `takeLast`                | Present; parity unverified                  | `source[takeLast](count)`                                                                                          | 18           | Exact edge-case parity remains test-driven. Symbol source: `packages/rxjs/src/take-last.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                                      |
| `takeUntil`               | Present; parity unverified                  | `source[takeUntil](notifier)`                                                                                      | 23           | Subscribes to the notifier first, completes on its first value, ignores notifier-only completion, and cancels both inputs through the shared result lifecycle. Symbol source: `packages/rxjs/src/take-until.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                  |
| `takeWhile`               | Present; parity unverified                  | `source[takeWhile](predicate, inclusive ? { includeLast: true } : undefined)`                                      | 23           | Normalizes the RxJS 7 inclusive boolean to the RxJS Next configuration form. Symbol source: `packages/rxjs/src/take-while.ts`; executable adapter: `takeWhile`.                                                                                                                                                                                                                                                                                                                   |
| `tap`                     | Present; parity unverified                  | `source[tap](observerOrNext, error?, complete?)`                                                                   | 73           | Preserves notification side-effect ordering plus subscribe, unsubscribe, and finalize lifecycle hooks. Symbol source: `packages/rxjs/src/tap.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                 |
| `throttle`                | Present; parity unverified                  | `source[throttle](durationSelector, config?)`                                                                      | 28           | Exact leading/trailing behavior remains test-driven. Symbol source: `packages/rxjs/src/throttle.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                                                              |
| `throttleTime`            | Partial unified mapping                     | `source[throttle](milliseconds, config?)`                                                                          | 16           | Scheduler arguments are not represented. Symbol source: `packages/rxjs/src/throttle.ts`; executable adapter: `throttleTime`.                                                                                                                                                                                                                                                                                                                                                      |
| `throwIfEmpty`            | Present; parity unverified                  | `source[throwIfEmpty](errorFactory?)`                                                                              | 7            | Forwards nonempty sources and errors an empty completion with a fresh EmptyError or the configured factory result. Symbol source: `packages/rxjs/src/throw-if-empty.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                          |
| `timeInterval`            | Present; scheduler adapted to host timing   | `source[timeInterval]({ now: hostVirtualNow })`                                                                    | 11           | Uses a now-only provider. The port harness maps the legacy TestScheduler argument to @rxjs/test's virtual host clock and rejects other scheduler arguments. Symbol source: `packages/rxjs/src/time-interval.ts`; executable adapter: `hostTimestampProvider`.                                                                                                                                                                                                                     |
| `timeout`                 | Partial unified mapping                     | `source[timeout](config)`                                                                                          | 38           | Adapts legacy numeric and Date due arguments; scheduler arguments are not represented. Symbol source: `packages/rxjs/src/timeout.ts`; executable adapter: `timeout`.                                                                                                                                                                                                                                                                                                              |
| `timeoutWith`             | Partial unified mapping                     | `source[timeout]({ first/each: due, with: () => fallback })`                                                       | 15           | Maps fallback behavior to the unified timeout configuration; scheduler arguments are not represented. Symbol source: `packages/rxjs/src/timeout.ts`; executable adapter: `timeoutWith`.                                                                                                                                                                                                                                                                                           |
| `timestamp`               | Present; scheduler adapted to host timing   | `source[timestamp]({ now: hostVirtualNow })`                                                                       | 11           | Uses a now-only provider. The port harness maps the legacy TestScheduler argument to @rxjs/test's virtual host clock and rejects other scheduler arguments. Symbol source: `packages/rxjs/src/timestamp.ts`; executable adapter: `hostTimestampProvider`.                                                                                                                                                                                                                         |
| `toArray`                 | Partial unified mapping                     | `source[buffer]({ emitEmpty: true, emitRemainingOnError: false })`                                                 | 15           | Uses one unbounded buffer and emits it only on successful completion. Symbol source: `packages/rxjs/src/buffer.ts`; executable adapter: `toArray`.                                                                                                                                                                                                                                                                                                                                |
| `window`                  | Present; parity unverified                  | `source[window](boundaries)`                                                                                       | 18           | Emits read-only hot windows, activates source before boundaries, rotates on boundary values, and silently releases the live window on outer cancellation. Symbol source: `packages/rxjs/src/window.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                           |
| `windowCount`             | Present; parity unverified                  | `source[windowCount](windowSize, startWindowEvery?)`                                                               | 9            | Emits read-only count windows with tumbling, overlapping, or gapped cadence. Source completion completes live windows, source errors error them, and outer cancellation silently releases them. Symbol source: `packages/rxjs/src/window-count.ts`; executable adapter: `identity`.                                                                                                                                                                                               |
| `windowTime`              | Present; scheduler adapted to host timing   | `source[windowTime](span, creationInterval ?? null, maxWindowSize ?? Infinity)`                                    | 13           | Preserves tumbling and overlapping host-time windows plus max-size closure. The adapter removes recognized legacy SchedulerLike objects from optional argument positions without changing numeric arguments. Symbol source: `packages/rxjs/src/window-time.ts`; executable adapter: `windowTimeExact`.                                                                                                                                                                            |
| `windowToggle`            | Present; parity unverified                  | `source[windowToggle](openings, closingSelector)`                                                                  | 19           | Emits overlapping read-only windows, closes each window on the first closing value, and silently releases live windows on outer cancellation. This cancellation behavior intentionally does not reproduce RxJS 7's disposed-Subject ObjectUnsubscribedError. Symbol source: `packages/rxjs/src/window-toggle.ts`; executable adapter: `identity`.                                                                                                                                 |
| `windowWhen`              | Present; parity unverified                  | `source[windowWhen](closingSelector)`                                                                              | 15           | Emits consecutive read-only windows and rotates on the first closing value or completion. Synchronous closing rotation is iterative, and outer cancellation silently releases the live window. Symbol source: `packages/rxjs/src/window-when.ts`; executable adapter: `identity`.                                                                                                                                                                                                 |
| `withLatestFrom`          | Unified mapping                             | `source[withLatestFrom]([otherSources], project?)`                                                                 | 17           | Adapts variadic other sources to the current array form and preserves the optional projection overload. Symbol source: `packages/rxjs/src/with-latest-from.ts`; executable adapter: `withLatestFromSourcesArrayWithProjection`.                                                                                                                                                                                                                                                   |
| `zip`                     | Compatibility alias                         | `source[zipWith](...otherSources)[map](project?)`                                                                  | 10           | Normalizes the deprecated RxJS 7 zip operator to the exact zipWith Symbol and applies its optional result selector through the exact map Symbol. Symbol source: `packages/rxjs/src/zip-with.ts`; executable adapter: `zipSourcesWithProjection`.                                                                                                                                                                                                                                  |
| `zipAll`                  | Present; parity unverified                  | `source[zipAll](project?)`                                                                                         | 46           | Collects inner sources until outer completion, then delegates tuple formation to hardened zip and projection to the exact map Symbol. Symbol source: `packages/rxjs/src/zip-all.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                              |
| `zipWith`                 | Present; parity unverified                  | `source[zipWith](...otherSources)`                                                                                 | 32           | Delegates receiver-first variadic tuple formation to the hardened standalone zip contract. Symbol source: `packages/rxjs/src/zip-with.ts`; executable adapter: `identity`.                                                                                                                                                                                                                                                                                                        |

## Creation and combination functions

| RxJS 7 API          | RxJS Next status                     | Current mapping                                                                                               | Marble cases | Notes                                                                                                                                                                                                                                                                                                          |
| ------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `animationFrames`   | Present; parity unverified           | `Observable[animationFrames]()`                                                                               | 4            | Legacy scheduler arguments are not represented. Symbol source: `packages/rxjs/src/animation-frames.ts`. Executable adapter: `identity`.                                                                                                                                                                        |
| `bindCallback`      | **Missing**                          | —                                                                                                             | 0            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `bindNodeCallback`  | **Missing**                          | —                                                                                                             | 0            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `combineLatest`     | Partial unified mapping              | `Observable[combineLatest](sources)`                                                                          | 32           | Adapts variadic sources to an array; projection overloads remain unrepresented. Symbol source: `packages/rxjs/src/combine-latest.ts`. Executable adapter: `staticCombineLatest`.                                                                                                                               |
| `concat`            | Partial unified mapping              | `Observable[concat](sources)`                                                                                 | 115          | Adapts variadic sources to the current array form; scheduler arguments are not represented. Symbol source: `packages/rxjs/src/concat.ts`. Executable adapter: `staticSourcesArray`.                                                                                                                            |
| `connectable`       | **Missing**                          | —                                                                                                             | 2            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `defer`             | Partial platform mapping             | `new Observable(subscriber => Observable.from(factory()).subscribe(subscriber))`                              | 12           | Uses the ambient Observable constructor and defers the factory until subscription. Uses the ambient platform Observable. Executable adapter: `defer`.                                                                                                                                                          |
| `empty`             | Partial standalone mapping           | `() => EMPTY`                                                                                                 | 1            | Uses the current EMPTY singleton; the deprecated scheduler overload is not represented. Standalone source: `packages/rxjs/src/empty.ts`. Executable adapter: `standaloneConstant`.                                                                                                                             |
| `forkJoin`          | Present; parity unverified           | `Observable[forkJoin](...inputs)`                                                                             | 39           | Supports array, object, deprecated rest, empty-input, and result-selector forms while preserving last-value and early-empty cancellation behavior. Symbol source: `packages/rxjs/src/fork-join.ts`. Executable adapter: `identity`.                                                                            |
| `from`              | Platform mapping                     | `Observable.from(input)`                                                                                      | 8            | Scheduler arguments and the complete RxJS 7 input matrix remain test-driven. Uses the ambient platform Observable. Executable adapter: `from`.                                                                                                                                                                 |
| `fromEvent`         | Partial platform string mapping      | `target.when(eventName, booleanOptions ? { capture: booleanOptions } : capturePassiveOptions)`                | 1            | Maps EventTarget inputs to the platform when() surface, normalizing boolean capture options; once, unsupported option keys, non-EventTarget inputs, and third- or fourth-argument result-selector overloads fail explicitly. Uses the ambient platform Observable. Executable adapter: `fromEvent`.            |
| `fromEventPattern`  | **Missing**                          | —                                                                                                             | 1            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `generate`          | Present; scheduler overload deferred | `Observable[generate](options \| initialState, condition, iterate, resultSelector?)`                          | 13           | Supports synchronous positional and options-object generation. Scheduler fields and trailing scheduler arguments are not a public platform contract; their ported behavioral claims use explicit test-harness timing rewrites. Symbol source: `packages/rxjs/src/generate.ts`. Executable adapter: `generate`. |
| `iif`               | Partial platform mapping             | `new Observable(subscriber => Observable.from(condition() ? trueSource : falseSource).subscribe(subscriber))` | 4            | Expressed as an ambient Observable with subscription-time source selection. Uses the ambient platform Observable. Executable adapter: `iif`.                                                                                                                                                                   |
| `interval`          | Present; parity unverified           | `Observable[interval](milliseconds)`                                                                          | 12           | Scheduler arguments are not represented. Symbol source: `packages/rxjs/src/interval.ts`. Executable adapter: `firstArgument`.                                                                                                                                                                                  |
| `merge`             | Partial unified mapping              | `Observable[merge](sources, { concurrency })`                                                                 | 81           | Adapts variadic sources and the numeric concurrency overload. Symbol source: `packages/rxjs/src/merge.ts`. Executable adapter: `staticMerge`.                                                                                                                                                                  |
| `never`             | Partial standalone mapping           | `() => NEVER`                                                                                                 | 0            | Uses the current NEVER singleton. Standalone source: `packages/rxjs/src/never.ts`. Executable adapter: `standaloneConstant`.                                                                                                                                                                                   |
| `of`                | Partial platform mapping             | `Observable.from(values)`                                                                                     | 400          | Adapts variadic values to the platform Observable.from contract. Uses the ambient platform Observable. Executable adapter: `of`.                                                                                                                                                                               |
| `onErrorResumeNext` | Partial unified mapping              | `Observable[onErrorResumeNext](sources)`                                                                      | 3            | Adapts variadic or single-array source arguments to the current array form. Symbol source: `packages/rxjs/src/on-error-resume-next.ts`. Executable adapter: `staticSourcesArrayOrSingleArray`.                                                                                                                 |
| `pairs`             | Partial platform mapping             | `Observable.from(Object.entries(object))`                                                                     | 2            | Scheduler arguments are not represented. Uses the ambient platform Observable. Executable adapter: `pairs`.                                                                                                                                                                                                    |
| `partition`         | Present; parity unverified           | `Observable[partition](source, predicate)`                                                                    | 16           | Returns matching and rejected branches with independent predicate state over the platform source's shared, ref-counted activation. Symbol source: `packages/rxjs/src/partition.ts`. Executable adapter: `identity`.                                                                                            |
| `race`              | Partial unified mapping              | `Observable[race](sources)`                                                                                   | 15           | Adapts variadic or single-array sources to the current array form. Symbol source: `packages/rxjs/src/race.ts`. Executable adapter: `staticSourcesArrayOrSingleArray`.                                                                                                                                          |
| `range`             | Partial platform mapping             | `Observable.from(Array.from({ length: count }, (_, i) => start + i))`                                         | 3            | Scheduler arguments are not represented. Uses the ambient platform Observable. Executable adapter: `range`.                                                                                                                                                                                                    |
| `scheduled`         | **Missing**                          | —                                                                                                             | 5            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `throwError`        | Partial platform mapping             | `new Observable(subscriber => subscriber.error(errorFactory()))`                                              | 31           | Supports factory and legacy direct-error forms; scheduler arguments are not represented. Uses the ambient platform Observable. Executable adapter: `throwError`.                                                                                                                                               |
| `timer`             | Partial unified mapping              | `Observable[timer](delay, interval?)`                                                                         | 37           | Adapts an absolute Date to a relative delay; scheduler arguments are not represented. Symbol source: `packages/rxjs/src/timer.ts`. Executable adapter: `timer`.                                                                                                                                                |
| `using`             | **Missing**                          | —                                                                                                             | 0            | No current RxJS Next function mapping.                                                                                                                                                                                                                                                                         |
| `zip`               | Partial standalone mapping           | `zip(sources)`                                                                                                | 41           | Adapts variadic and single-array source forms plus the trailing RxJS 7 result selector to the current source-array function. Standalone source: `packages/rxjs/src/zip.ts`; executable adapter: `standaloneSourcesArrayWithProjection`.                                                                        |

## Utility and Promise-conversion functions

| RxJS 7 API       | RxJS Next status         | Current mapping                                  | Marble cases | Notes                                                                                                                                                                                     |
| ---------------- | ------------------------ | ------------------------------------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `identity`       | Present; parity verified | `identity`                                       | 1            | Uses the public generic identity utility. Symbol source: `packages/rxjs/src/identity.ts`. Executable adapter: `identity`.                                                                 |
| `isObservable`   | **Missing**              | —                                                | 0            | No current equivalent public function.                                                                                                                                                    |
| `noop`           | Present; parity verified | `noop`                                           | 6            | Uses the public no-operation callback utility. Symbol source: `packages/rxjs/src/noop.ts`. Executable adapter: `identity`.                                                                |
| `pipe`           | Partial unified mapping  | `Observable[pipe](source, ...operatorFunctions)` | 82           | Adapts RxJS 7 standalone operator composition to the current static pipe Symbol. Symbol source: `packages/rxjs/src/pipe.ts`. Executable adapter: `operatorComposition`.                   |
| `firstValueFrom` | Partial platform mapping | `source.first()`                                 | 0            | Maps Promise conversion to the platform consumer; the RxJS 7 defaultValue configuration is not represented. Uses the ambient platform Observable. Executable adapter: `platformConsumer`. |
| `lastValueFrom`  | Partial platform mapping | `source.last()`                                  | 0            | Maps Promise conversion to the platform consumer; the RxJS 7 defaultValue configuration is not represented. Uses the ambient platform Observable. Executable adapter: `platformConsumer`. |

## Other parity-critical surfaces

| RxJS 7 surface                     | RxJS Next status                  | Current mapping                                                                                       | Notes                                                                                                                                                                                                                                                              |
| ---------------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Observable`                       | Platform mapping                  | `globalThis.Observable`                                                                               | Uses the active native or fallback platform constructor.                                                                                                                                                                                                           |
| `Subject`                          | Present; observable view verified | `Subject`                                                                                             | Uses the current exploratory Subject class. Subject.asObservable() returns a distinct non-mutating Observable view without patching the platform Observable prototype.                                                                                             |
| `BehaviorSubject`                  | Partial standalone mapping        | `new BehaviorSubject(initialValue) → behaviorSubject(initialValue)`                                   | Adapts the current factory to the RxJS 7 constructor call shape; lifecycle parity is unverified.                                                                                                                                                                   |
| `ReplaySubject`                    | Partial standalone mapping        | `new ReplaySubject(bufferSize, windowTime) → replaySubject({ size: bufferSize, maxAge: windowTime })` | Adapts bufferSize and windowTime to the current factory. The exact port harness accepts only its rxTest virtual-clock marker as the third argument, relying on virtualized host Date.now/setTimeout; every other timestamp-provider or scheduler fails explicitly. |
| `AsyncSubject`                     | **Missing**                       | —                                                                                                     | No current equivalent.                                                                                                                                                                                                                                             |
| `ConnectableObservable`            | **Missing**                       | —                                                                                                     | No current equivalent.                                                                                                                                                                                                                                             |
| `GroupedObservable`                | **Missing**                       | —                                                                                                     | No current equivalent.                                                                                                                                                                                                                                             |
| `Subscription`                     | **Missing**                       | —                                                                                                     | Platform cancellation is AbortSignal-based; a compatibility facade is undecided.                                                                                                                                                                                   |
| `Subscriber`                       | Platform-only                     | `globalThis.Subscriber`                                                                               | Platform lifecycle type exists; it is not the RxJS 7 Subscriber class.                                                                                                                                                                                             |
| `Notification`                     | **Missing**                       | —                                                                                                     | No current equivalent.                                                                                                                                                                                                                                             |
| `EMPTY`                            | Present; parity unverified        | `EMPTY`                                                                                               | Uses the current standalone empty Observable singleton.                                                                                                                                                                                                            |
| `NEVER`                            | Present; parity unverified        | `NEVER`                                                                                               | Uses the current standalone never Observable singleton.                                                                                                                                                                                                            |
| `Schedulers and scheduler classes` | **Missing**                       | —                                                                                                     | Host timing plus rxTest replaces the platform-layer scheduler abstraction.                                                                                                                                                                                         |
| `RxJS 7 error classes`             | **Missing**                       | —                                                                                                     | No current public parity set.                                                                                                                                                                                                                                      |

## Test-harness relationship

The machine-readable capability mapping is
`packages/rxjs/test/ported/capability-registry.json`. The checked-in migration
evidence, generated migration-evidence ledger, and reusable `@rxjs/migrate`
tooling use the import's role:

- an operator import becomes a descriptor that invokes
  `source[targetSymbol](...adaptedArgs)`;
- a creation function invokes `Observable[factorySymbol](...args)`;
- a standalone value/function uses the registered value directly;
- an absent entry remains a registered test and fails with a source-linked
  `missing-api` diagnostic.

The complete per-case evidence remains in
`packages/rxjs/test/ported/manifest.generated.json`. Executable specs are
ordinary repository-owned files; `migration-report.json` retains their static
case-ID mapping for audits. The joined ledger is generated at
`packages/rxjs/test/ported/migration-evidence-ledger.generated.json` with its
readable view in `packages/rxjs/docs/MIGRATION_EVIDENCE_LEDGER.md`.
