# RxJS 7 ported-test failure tracker

## Purpose and evidence

This ledger records every RxJS 7 ported test that failed in the authoritative cold or polyfill audit. Rows remain after repair and move to `FIXED`, so the document preserves the original failure cohort.

- **RxJS 7 source:** `7.x` at `e5351d02e225e275ac0e497c7b66eaa5f0c88791`
- **Evidence captured:** 2026-07-31
- **Manifest coverage:** 2,338 cases in each mode
- **Cold:** 2,296 passed; 42 failed
- **Polyfill:** 2,316 passed; 22 failed
- **Unique tracked failures:** 1,926 across 140 owner groups
- **Current failure overlap:** 15 both modes; 27 cold only; 7 polyfill only
- **Fixed since first capture:** 1,877
- **Recommended next work packet:** [RX7-TO-ARRAY](#rx7-to-array--toarray) (`toArray`)

The audit commands intentionally exit nonzero while parity failures remain:

```sh
pnpm --filter rxjs run test:unit:audit --reporter=json --outputFile=/tmp/rxjs-next-ported-cold.json
pnpm --filter rxjs run test:unit:audit:polyfill --reporter=json --outputFile=/tmp/rxjs-next-ported-polyfill.json
pnpm --filter rxjs run test:unit:failures:generate --cold-report=/tmp/rxjs-next-ported-cold.json --polyfill-report=/tmp/rxjs-next-ported-polyfill.json
```

## Status protocol

| Status       | Meaning                                                                                               |
| ------------ | ----------------------------------------------------------------------------------------------------- |
| `TODO`       | The test is still failing and is not actively assigned.                                               |
| `IN-PROCESS` | A contributor or delegated task is actively investigating or repairing the test.                      |
| `FIXED`      | The represented claim passes in both cold and polyfill modes in the latest complete audits.           |
| `BLOCKED`    | A named architectural decision, prerequisite, or external dependency prevents the next concrete step. |

Statuses are preserved in `packages/rxjs/test/ported/failure-tracker-ledger.json` by stable case ID. Set a case to `BLOCKED` only with a non-empty `blocker`; regeneration rejects unnamed blockers.

## Failure ledger

Each case appears exactly once under the RxJS 7 spec file that owns the behavior. A case that imports helper operators remains owned by its source spec rather than being duplicated across helpers.

### `@rxjs/test`

Owner source: `spec/testing/index-spec.ts`

| Case ID                                                            | Behavioral test             | Source                         | Failing mode | Classification    | Disposition | Concise failure                                               | Status  |
| ------------------------------------------------------------------ | --------------------------- | ------------------------------ | ------------ | ----------------- | ----------- | ------------------------------------------------------------- | ------- |
| `spec/testing/index-spec.ts:5:index > should export TestScheduler` | should export TestScheduler | `spec/testing/index-spec.ts:5` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'TestScheduler') | `FIXED` |

### `ajax`

Owner source: `spec/observables/dom/ajax-spec.ts`

| Case ID                                                                                        | Behavioral test                                 | Source                                  | Failing mode | Classification    | Disposition | Concise failure        | Status  |
| ---------------------------------------------------------------------------------------------- | ----------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ----------- | ---------------------- | ------- |
| `spec/observables/dom/ajax-spec.ts:534:ajax > should error on timeout of asynchronous request` | should error on timeout of asynchronous request | `spec/observables/dom/ajax-spec.ts:534` | —            | `harness-rewrite` | `active`    | ajax is not a function | `FIXED` |

### `animationFrames`

Owner source: `spec/observables/dom/animationFrames-spec.ts`

| Case ID                                                                                                     | Behavioral test                         | Source                                            | Failing mode | Classification    | Disposition | Concise failure                                      | Status  |
| ----------------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------------------- | ------- |
| `spec/observables/dom/animationFrames-spec.ts:17:animationFrames > should animate`                          | should animate                          | `spec/observables/dom/animationFrames-spec.ts:17` | —            | `portable`        | `active`    | rxTest observable assertion failed.                  | `FIXED` |
| `spec/observables/dom/animationFrames-spec.ts:37:animationFrames > should use any passed timestampProvider` | should use any passed timestampProvider | `spec/observables/dom/animationFrames-spec.ts:37` | —            | `portable`        | `active`    | Cannot read properties of undefined (reading 'stub') | `FIXED` |
| `spec/observables/dom/animationFrames-spec.ts:60:animationFrames > should compose with take`                | should compose with take                | `spec/observables/dom/animationFrames-spec.ts:60` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'spy')  | `FIXED` |
| `spec/observables/dom/animationFrames-spec.ts:86:animationFrames > should compose with takeUntil`           | should compose with takeUntil           | `spec/observables/dom/animationFrames-spec.ts:86` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'spy')  | `FIXED` |

### `AnimationFrameScheduler`

Owner source: `spec/schedulers/AnimationFrameScheduler-spec.ts`

| Case ID                                                                                                                             | Behavioral test                                     | Source                                               | Failing mode | Classification    | Disposition | Concise failure                                     | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- | ---------------------------------------------------- | ------------ | ----------------- | ----------- | --------------------------------------------------- | ------- |
| `spec/schedulers/AnimationFrameScheduler-spec.ts:24:Scheduler.animationFrame > should act like the async scheduler if delay > 0`    | should act like the async scheduler if delay > 0    | `spec/schedulers/AnimationFrameScheduler-spec.ts:24` | —            | `harness-rewrite` | `active`    | Missing operator capability: delay                  | `FIXED` |
| `spec/schedulers/AnimationFrameScheduler-spec.ts:41:Scheduler.animationFrame > should cancel animationFrame actions when delay > 0` | should cancel animationFrame actions when delay > 0 | `spec/schedulers/AnimationFrameScheduler-spec.ts:41` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'spy') | `FIXED` |

### `AsapScheduler`

Owner source: `spec/schedulers/AsapScheduler-spec.ts`

| Case ID                                                                                                      | Behavioral test                                  | Source                                     | Failing mode | Classification    | Disposition | Concise failure                                               | Status  |
| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------ | ------------------------------------------ | ------------ | ----------------- | ----------- | ------------------------------------------------------------- | ------- |
| `spec/schedulers/AsapScheduler-spec.ts:24:Scheduler.asap > should act like the async scheduler if delay > 0` | should act like the async scheduler if delay > 0 | `spec/schedulers/AsapScheduler-spec.ts:24` | —            | `harness-rewrite` | `active`    | Missing operator capability: delay                            | `FIXED` |
| `spec/schedulers/AsapScheduler-spec.ts:40:Scheduler.asap > should cancel asap actions when delay > 0`        | should cancel asap actions when delay > 0        | `spec/schedulers/AsapScheduler-spec.ts:40` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'createSandbox') | `FIXED` |

### `audit`

Owner source: `spec/operators/audit-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/audit-spec.ts:123:audit operator > should handle a busy producer emitting a regular repeating sequence`          | should handle a busy producer emitting a regular repeating sequence           | `spec/operators/audit-spec.ts:123` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:145:audit operator > should mirror source if durations are immediate`                              | should mirror source if durations are immediate                               | `spec/operators/audit-spec.ts:145` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:15:audit operator > should emit the last value in each time window`                                | should emit the last value in each time window                                | `spec/operators/audit-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:159:audit operator > should emit no values if durations are EMPTY`                                 | should emit no values if durations are EMPTY                                  | `spec/operators/audit-spec.ts:159` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:173:audit operator > should emit no values and never complete if duration is a never`              | should emit no values and never complete if duration is a never               | `spec/operators/audit-spec.ts:173` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/audit-spec.ts:189:audit operator > should unsubscribe duration Observable when source raise error`               | should unsubscribe duration Observable when source raise error                | `spec/operators/audit-spec.ts:189` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/audit-spec.ts:205:audit operator > should mirror source if durations are synchronous observables`                | should mirror source if durations are synchronous observables                 | `spec/operators/audit-spec.ts:205` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:219:audit operator > should raise error as soon as just-throw duration is used`                    | should raise error as soon as just-throw duration is used                     | `spec/operators/audit-spec.ts:219` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:235:audit operator > should audit using durations of varying lengths`                              | should audit using durations of varying lengths                               | `spec/operators/audit-spec.ts:235` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:266:audit operator > should propagate error from duration Observable`                              | should propagate error from duration Observable                               | `spec/operators/audit-spec.ts:266` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:293:audit operator > should propagate error thrown from durationSelector function`                 | should propagate error thrown from durationSelector function                  | `spec/operators/audit-spec.ts:293` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:327:audit operator > should complete when source does not emit`                                    | should complete when source does not emit                                     | `spec/operators/audit-spec.ts:327` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:355:audit operator > should handle an empty source`                                                | should handle an empty source                                                 | `spec/operators/audit-spec.ts:355` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:369:audit operator > should handle a never source`                                                 | should handle a never source                                                  | `spec/operators/audit-spec.ts:369` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/audit-spec.ts:37:audit operator > should delay the source if values are not emitted often enough`                | should delay the source if values are not emitted often enough                | `spec/operators/audit-spec.ts:37`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:470:audit operator > should emit last value after duration completes if source completes first`    | should emit last value after duration completes if source completes first     | `spec/operators/audit-spec.ts:470` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:57:audit operator > should audit with duration Observable using next to close the duration`        | should audit with duration Observable using next to close the duration        | `spec/operators/audit-spec.ts:57`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:77:audit operator > should interrupt source and duration when result is unsubscribed early`        | should interrupt source and duration when result is unsubscribed early        | `spec/operators/audit-spec.ts:77`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/audit-spec.ts:98:audit operator > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/audit-spec.ts:98`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `auditTime`

Owner source: `spec/operators/auditTime-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/auditTime-spec.ts:108:auditTime > should handle an empty source`                                                 | should handle an empty source                                                 | `spec/operators/auditTime-spec.ts:108` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:120:auditTime > should handle a never source`                                                  | should handle a never source                                                  | `spec/operators/auditTime-spec.ts:120` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/auditTime-spec.ts:144:auditTime > should not complete when source does not complete`                             | should not complete when source does not complete                             | `spec/operators/auditTime-spec.ts:144` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:15:auditTime > should emit the last value in each time window`                                 | should emit the last value in each time window                                | `spec/operators/auditTime-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:158:auditTime > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/auditTime-spec.ts:158` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:178:auditTime > should auditTime values until source raises error`                             | should auditTime values until source raises error                             | `spec/operators/auditTime-spec.ts:178` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:41:auditTime > should auditTime events multiple times`                                         | should auditTime events multiple times                                        | `spec/operators/auditTime-spec.ts:41`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:54:auditTime > should delay the source if values are not emitted often enough`                 | should delay the source if values are not emitted often enough                | `spec/operators/auditTime-spec.ts:54`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:68:auditTime > should handle a busy producer emitting a regular repeating sequence`            | should handle a busy producer emitting a regular repeating sequence           | `spec/operators/auditTime-spec.ts:68`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/auditTime-spec.ts:84:auditTime > should complete when source does not emit`                                      | should complete when source does not emit                                     | `spec/operators/auditTime-spec.ts:84`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `BehaviorSubject`

Owner source: `spec/subjects/BehaviorSubject-spec.ts`

| Case ID                                                                                                            | Behavioral test                                      | Source                                      | Failing mode | Classification    | Disposition | Concise failure                  | Status  |
| ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------- | ------------------------------------------- | ------------ | ----------------- | ----------- | -------------------------------- | ------- |
| `spec/subjects/BehaviorSubject-spec.ts:144:BehaviorSubject > should replay the previous value when subscribed`     | should replay the previous value when subscribed     | `spec/subjects/BehaviorSubject-spec.ts:144` | —            | `harness-rewrite` | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/subjects/BehaviorSubject-spec.ts:176:BehaviorSubject > should emit complete when subscribed after completed` | should emit complete when subscribed after completed | `spec/subjects/BehaviorSubject-spec.ts:176` | —            | `harness-rewrite` | `active`    | Missing operator capability: tap | `FIXED` |

### `buffer`

Owner source: `spec/operators/buffer-spec.ts`

| Case ID                                                                                                                                                  | Behavioral test                                                                         | Source                              | Failing mode | Classification    | Disposition        | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------- | ------------ | ----------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/buffer-spec.ts:103:Observable.prototype.buffer > should work with never and empty selector`                                              | should work with never and empty selector                                               | `spec/operators/buffer-spec.ts:103` | —            | `portable`        | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/buffer-spec.ts:130:Observable.prototype.buffer > should work with throw and non-empty selector`                                          | should work with throw and non-empty selector                                           | `spec/operators/buffer-spec.ts:130` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:139:Observable.prototype.buffer > should work with error`                                                                 | should work with error                                                                  | `spec/operators/buffer-spec.ts:139` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:148:Observable.prototype.buffer > should work with error and non-empty selector`                                          | should work with error and non-empty selector                                           | `spec/operators/buffer-spec.ts:148` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:194:Observable.prototype.buffer > should allow unsubscribing the result Observable early`                                 | should allow unsubscribing the result Observable early                                  | `spec/operators/buffer-spec.ts:194` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:210:Observable.prototype.buffer > should not break unsubscription chains when unsubscribed explicitly`                    | should not break unsubscription chains when unsubscribed explicitly                     | `spec/operators/buffer-spec.ts:210` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:233:Observable.prototype.buffer > should work with non-empty and selector error`                                          | should work with non-empty and selector error                                           | `spec/operators/buffer-spec.ts:233` | —            | `portable`        | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:276:Observable.prototype.buffer > should unsubscribe notifier when source unsubscribed`                                   | should unsubscribe notifier when source unsubscribed                                    | `spec/operators/buffer-spec.ts:276` | —            | `portable`        | `active`           | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/buffer-spec.ts:295:Observable.prototype.buffer > should unsubscribe notifier when source unsubscribed`                                   | should unsubscribe notifier when source unsubscribed                                    | `spec/operators/buffer-spec.ts:295` | —            | `portable`        | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/buffer-spec.ts:384:should be equivalent for case 0 [buffer-case-0]`                                                                      | should be equivalent for case 0                                                         | `spec/operators/buffer-spec.ts:384` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: window                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:384:should be equivalent for case 1 [buffer-case-1]`                                                                      | should be equivalent for case 1                                                         | `spec/operators/buffer-spec.ts:384` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: window                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:384:should be equivalent for case 2 [buffer-case-2]`                                                                      | should be equivalent for case 2                                                         | `spec/operators/buffer-spec.ts:384` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: window                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:384:should be equivalent for case 3 [buffer-case-3]`                                                                      | should be equivalent for case 3                                                         | `spec/operators/buffer-spec.ts:384` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: window                                                                  | `FIXED` |
| `spec/operators/buffer-spec.ts:44:Observable.prototype.buffer > should emit all buffered values if the source completes before the closingNotifier does` | should emit all buffered values if the source completes before the closingNotifier does | `spec/operators/buffer-spec.ts:44`  | —            | `portable`        | `active`           | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/buffer-spec.ts:94:Observable.prototype.buffer > should work with never and never selector`                                               | should work with never and never selector                                               | `spec/operators/buffer-spec.ts:94`  | —            | `portable`        | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `bufferCount`

Owner source: `spec/operators/bufferCount-spec.ts`

| Case ID                                                                                                                                                 | Behavioral test                                                                         | Source                                   | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/bufferCount-spec.ts:102:bufferCount operator > should not break unsubscription chains when result is unsubscribed explicitly`           | should not break unsubscription chains when result is unsubscribed explicitly           | `spec/operators/bufferCount-spec.ts:102` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferCount-spec.ts:124:bufferCount operator > should raise error if source raise error before reaching specified buffer count`         | should raise error if source raise error before reaching specified buffer count         | `spec/operators/bufferCount-spec.ts:124` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferCount-spec.ts:135:bufferCount operator > should emit buffers with specified skip count when skip count is less than window count` | should emit buffers with specified skip count when skip count is less than window count | `spec/operators/bufferCount-spec.ts:135` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferCount-spec.ts:15:bufferCount operator > should emit buffers at intervals`                                                         | should emit buffers at intervals                                                        | `spec/operators/bufferCount-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferCount-spec.ts:153:bufferCount operator > should emit buffers with specified skip count when skip count is more than window count` | should emit buffers with specified skip count when skip count is more than window count | `spec/operators/bufferCount-spec.ts:153` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferCount-spec.ts:86:bufferCount operator > should emit buffers at intervals, but stop when result is unsubscribed early`             | should emit buffers at intervals, but stop when result is unsubscribed early            | `spec/operators/bufferCount-spec.ts:86`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `bufferTime`

Owner source: `spec/operators/bufferTime-spec.ts`

| Case ID                                                                                                                                                                              | Behavioral test                                                                                                        | Source                                  | Failing mode | Classification | Disposition | Concise failure                             | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | ------------------------------------------- | ------- |
| `spec/operators/bufferTime-spec.ts:103:bufferTime operator > should emit buffers at intervals or when the buffer is full test 2`                                                     | should emit buffers at intervals or when the buffer is full test 2                                                     | `spec/operators/bufferTime-spec.ts:103` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:124:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay`                            | should emit buffers that have been created at intervals and close after the specified delay                            | `spec/operators/bufferTime-spec.ts:124` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:146:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay or when the buffer is full` | should emit buffers that have been created at intervals and close after the specified delay or when the buffer is full | `spec/operators/bufferTime-spec.ts:146` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:15:bufferTime operator > should emit buffers at intervals`                                                                                        | should emit buffers at intervals                                                                                       | `spec/operators/bufferTime-spec.ts:15`  | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:168:bufferTime operator > should emit buffers with timeSpan 10 and creationInterval 7`                                                            | should emit buffers with timeSpan 10 and creationInterval 7                                                            | `spec/operators/bufferTime-spec.ts:168` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:198:bufferTime operator > should emit buffers but handle source ending with an error`                                                             | should emit buffers but handle source ending with an error                                                             | `spec/operators/bufferTime-spec.ts:198` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:225:bufferTime operator > should emit buffers and allow result to unsubscribed early`                                                             | should emit buffers and allow result to unsubscribed early                                                             | `spec/operators/bufferTime-spec.ts:225` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:248:bufferTime operator > should not break unsubscription chains when result is unsubscribed explicitly`                                          | should not break unsubscription chains when result is unsubscribed explicitly                                          | `spec/operators/bufferTime-spec.ts:248` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:275:bufferTime operator > should handle empty`                                                                                                    | should handle empty                                                                                                    | `spec/operators/bufferTime-spec.ts:275` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:290:bufferTime operator > should handle never`                                                                                                    | should handle never                                                                                                    | `spec/operators/bufferTime-spec.ts:290` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:303:bufferTime operator > should handle throw`                                                                                                    | should handle throw                                                                                                    | `spec/operators/bufferTime-spec.ts:303` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:315:bufferTime operator > should handle errors`                                                                                                   | should handle errors                                                                                                   | `spec/operators/bufferTime-spec.ts:315` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:332:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay with errors`                | should emit buffers that have been created at intervals and close after the specified delay with errors                | `spec/operators/bufferTime-spec.ts:332` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:35:bufferTime operator > should emit buffers at intervals test 2`                                                                                 | should emit buffers at intervals test 2                                                                                | `spec/operators/bufferTime-spec.ts:35`  | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:355:bufferTime operator > should not throw when subscription synchronously unsubscribed after emit`                                               | should not throw when subscription synchronously unsubscribed after emit                                               | `spec/operators/bufferTime-spec.ts:355` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:373:bufferTime operator > should not have errors when take follows and maxBufferSize is provided`                                                 | should not have errors when take follows and maxBufferSize is provided                                                 | `spec/operators/bufferTime-spec.ts:373` | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |
| `spec/operators/bufferTime-spec.ts:392:bufferTime operator > should not mutate the buffer on reentrant next`                                                                         | should not mutate the buffer on reentrant next                                                                         | `spec/operators/bufferTime-spec.ts:392` | —            | `portable`     | `active`    | rxTest exceeded maxTaskExecutions (100000). | `FIXED` |
| `spec/operators/bufferTime-spec.ts:52:bufferTime operator > should emit buffers at intervals or when the buffer is full`                                                             | should emit buffers at intervals or when the buffer is full                                                            | `spec/operators/bufferTime-spec.ts:52`  | —            | `portable`     | `active`    | testScheduler is not defined                | `FIXED` |

### `bufferToggle`

Owner source: `spec/operators/bufferToggle-spec.ts`

| Case ID                                                                                                                                                                                                                   | Behavioral test                                                                                                                                          | Source                                    | Failing mode | Classification           | Disposition | Concise failure                           | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------------ | ------------------------ | ----------- | ----------------------------------------- | ------- |
| `spec/operators/bufferToggle-spec.ts:130:bufferToggle operator > should emit buffers using varying empty delayed closings`                                                                                                | should emit buffers using varying empty delayed closings                                                                                                 | `spec/operators/bufferToggle-spec.ts:130` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:15:bufferToggle operator > should emit buffers using hot openings and hot closings`                                                                                                  | should emit buffers using hot openings and hot closings                                                                                                  | `spec/operators/bufferToggle-spec.ts:15`  | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:155:bufferToggle operator > should emit buffers using varying cold closings, outer unsubscribed early`                                                                               | should emit buffers using varying cold closings, outer unsubscribed early                                                                                | `spec/operators/bufferToggle-spec.ts:155` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:183:bufferToggle operator > should not break unsubscription chains when result is unsubscribed explicitly`                                                                           | should not break unsubscription chains when result is unsubscribed explicitly                                                                            | `spec/operators/bufferToggle-spec.ts:183` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:211:bufferToggle operator > should propagate error thrown from closingSelector`                                                                                                      | should propagate error thrown from closingSelector                                                                                                       | `spec/operators/bufferToggle-spec.ts:211` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:242:bufferToggle operator > should propagate error emitted from a closing`                                                                                                           | should propagate error emitted from a closing                                                                                                            | `spec/operators/bufferToggle-spec.ts:242` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:267:bufferToggle operator > should propagate error emitted late from a closing`                                                                                                      | should propagate error emitted late from a closing                                                                                                       | `spec/operators/bufferToggle-spec.ts:267` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:295:bufferToggle operator > should handle errors`                                                                                                                                    | should handle errors                                                                                                                                     | `spec/operators/bufferToggle-spec.ts:295` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:32:bufferToggle operator > should emit buffers that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument` | should emit buffers that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument | `spec/operators/bufferToggle-spec.ts:32`  | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.       | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:325:bufferToggle operator > should handle empty source`                                                                                                                              | should handle empty source                                                                                                                               | `spec/operators/bufferToggle-spec.ts:325` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:339:bufferToggle operator > should handle throw`                                                                                                                                     | should handle throw                                                                                                                                      | `spec/operators/bufferToggle-spec.ts:339` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:353:bufferToggle operator > should handle never`                                                                                                                                     | should handle never                                                                                                                                      | `spec/operators/bufferToggle-spec.ts:353` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:374:bufferToggle operator > should handle a never opening Observable`                                                                                                                | should handle a never opening Observable                                                                                                                 | `spec/operators/bufferToggle-spec.ts:374` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:387:bufferToggle operator > should handle a never closing Observable`                                                                                                                | should handle a never closing Observable                                                                                                                 | `spec/operators/bufferToggle-spec.ts:387` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:404:bufferToggle operator > should handle opening Observable that just throws`                                                                                                       | should handle opening Observable that just throws                                                                                                        | `spec/operators/bufferToggle-spec.ts:404` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:530:bufferToggle operator > should handle empty closing observable`                                                                                                                  | should handle empty closing observable                                                                                                                   | `spec/operators/bufferToggle-spec.ts:530` | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:59:bufferToggle operator > should emit buffers using varying cold closings`                                                                                                          | should emit buffers using varying cold closings                                                                                                          | `spec/operators/bufferToggle-spec.ts:59`  | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |
| `spec/operators/bufferToggle-spec.ts:92:bufferToggle operator > should emit buffers using varying hot closings`                                                                                                           | should emit buffers using varying hot closings                                                                                                           | `spec/operators/bufferToggle-spec.ts:92`  | —            | `portable`               | `active`    | Missing operator capability: bufferToggle | `FIXED` |

### `bufferWhen`

Owner source: `spec/operators/bufferWhen-spec.ts`

| Case ID                                                                                                                                     | Behavioral test                                                               | Source                                  | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/bufferWhen-spec.ts:121:bufferWhen operator > should emit buffers using varying cold closings, outer unsubscribed early`     | should emit buffers using varying cold closings, outer unsubscribed early     | `spec/operators/bufferWhen-spec.ts:121` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferWhen-spec.ts:151:bufferWhen operator > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/bufferWhen-spec.ts:151` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferWhen-spec.ts:266:bufferWhen operator > should handle errors`                                                          | should handle errors                                                          | `spec/operators/bufferWhen-spec.ts:266` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferWhen-spec.ts:305:bufferWhen operator > should handle throw`                                                           | should handle throw                                                           | `spec/operators/bufferWhen-spec.ts:305` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferWhen-spec.ts:322:bufferWhen operator > should handle never`                                                           | should handle never                                                           | `spec/operators/bufferWhen-spec.ts:322` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/bufferWhen-spec.ts:409:bufferWhen operator > should handle disposing of source`                                             | should handle disposing of source                                             | `spec/operators/bufferWhen-spec.ts:409` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `catchError`

Owner source: `spec/operators/catchError-spec.ts`

| Case ID                                                                                                                                                    | Behavioral test                                                                              | Source                                  | Failing mode    | Classification       | Disposition        | Concise failure                         | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | --------------------------------------- | --------------- | -------------------- | ------------------ | --------------------------------------- | ------- |
| `spec/operators/catchError-spec.ts:107:catchError operator > should unsubscribe from a caught hot caught observable when unsubscribed explicitly`          | should unsubscribe from a caught hot caught observable when unsubscribed explicitly          | `spec/operators/catchError-spec.ts:107` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:124:catchError operator > should unsubscribe from a caught cold caught observable when unsubscribed explicitly`         | should unsubscribe from a caught cold caught observable when unsubscribed explicitly         | `spec/operators/catchError-spec.ts:124` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:141:catchError operator > should unsubscribe from a caught cold caught interop observable when unsubscribed explicitly` | should unsubscribe from a caught cold caught interop observable when unsubscribed explicitly | `spec/operators/catchError-spec.ts:141` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.     | `TODO`  |
| `spec/operators/catchError-spec.ts:18:catchError operator > should catch error and replace with a cold Observable`                                         | should catch error and replace with a cold Observable                                        | `spec/operators/catchError-spec.ts:18`  | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:193:catchError operator > should catch error and replace it with a hot Observable`                                      | should catch error and replace it with a hot Observable                                      | `spec/operators/catchError-spec.ts:193` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:209:catchError operator > should catch and allow the cold observable to be repeated with the third (caught) argument`   | should catch and allow the cold observable to be repeated with the third (caught) argument   | `spec/operators/catchError-spec.ts:209` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:240:catchError operator > should catch and allow the hot observable to proceed with the third (caught) argument`        | should catch and allow the hot observable to proceed with the third (caught) argument        | `spec/operators/catchError-spec.ts:240` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:271:catchError operator > should catch and replace a Observable.throw() as the source`                                  | should catch and replace a Observable.throw() as the source                                  | `spec/operators/catchError-spec.ts:271` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:284:catchError operator > should mirror the source if it does not raise errors`                                         | should mirror the source if it does not raise errors                                         | `spec/operators/catchError-spec.ts:284` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:297:catchError operator > should complete if you return Observable.empty()`                                             | should complete if you return Observable.empty()                                             | `spec/operators/catchError-spec.ts:297` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:30:catchError operator > should catch error and replace it with Observable.of()`                                        | should catch error and replace it with Observable.of()                                       | `spec/operators/catchError-spec.ts:30`  | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:313:catchError operator > should raise error if you return Observable.throw()`                                          | should raise error if you return Observable.throw()                                          | `spec/operators/catchError-spec.ts:313` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:329:catchError operator > should never terminate if you return NEVER`                                                   | should never terminate if you return NEVER                                                   | `spec/operators/catchError-spec.ts:329` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:382:catchError operator > should catch errors throw from within the constructor`                                        | should catch errors throw from within the constructor                                        | `spec/operators/catchError-spec.ts:382` | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:53:catchError operator > should catch error and replace it with a cold Observable`                                      | should catch error and replace it with a cold Observable                                     | `spec/operators/catchError-spec.ts:53`  | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:69:catchError operator > should allow unsubscribing explicitly and early`                                               | should allow unsubscribing explicitly and early                                              | `spec/operators/catchError-spec.ts:69`  | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |
| `spec/operators/catchError-spec.ts:87:catchError operator > should not break unsubscription chain when unsubscribed explicitly`                            | should not break unsubscription chain when unsubscribed explicitly                           | `spec/operators/catchError-spec.ts:87`  | —               | `portable`           | `active`           | Missing operator capability: catchError | `FIXED` |

### `combineLatest`

Owner sources: `spec/observables/combineLatest-spec.ts`, `spec/operators/combineLatest-spec.ts`

| Case ID                                                                                                                                 | Behavioral test                                                     | Source                                       | Failing mode | Classification | Disposition    | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------- | ------------ | -------------- | -------------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/combineLatest-spec.ts:100:static combineLatest > should accept array of observables`                                  | should accept array of observables                                  | `spec/observables/combineLatest-spec.ts:100` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:112:static combineLatest > should accept a dictionary of observables`                           | should accept a dictionary of observables                           | `spec/observables/combineLatest-spec.ts:112` | —            | `portable`     | `active`       | Missing operator capability: map                                                                     | `FIXED` |
| `spec/observables/combineLatest-spec.ts:126:static combineLatest > should work with two nevers`                                         | should work with two nevers                                         | `spec/observables/combineLatest-spec.ts:126` | —            | `portable`     | `active`       | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/combineLatest-spec.ts:142:static combineLatest > should work with never and empty`                                    | should work with never and empty                                    | `spec/observables/combineLatest-spec.ts:142` | —            | `portable`     | `active`       | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/combineLatest-spec.ts:158:static combineLatest > should work with empty and never`                                    | should work with empty and never                                    | `spec/observables/combineLatest-spec.ts:158` | —            | `portable`     | `active`       | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/combineLatest-spec.ts:233:static combineLatest > should work with hot-single and never`                               | should work with hot-single and never                               | `spec/observables/combineLatest-spec.ts:233` | —            | `portable`     | `active`       | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/combineLatest-spec.ts:252:static combineLatest > should work with never and hot-single`                               | should work with never and hot-single                               | `spec/observables/combineLatest-spec.ts:252` | —            | `portable`     | `active`       | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/combineLatest-spec.ts:272:static combineLatest > should work with hot and hot`                                        | should work with hot and hot                                        | `spec/observables/combineLatest-spec.ts:272` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:496:static combineLatest > should handle interleaved with tail`                                 | should handle interleaved with tail                                 | `spec/observables/combineLatest-spec.ts:496` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:512:static combineLatest > should handle two consecutive hot observables`                       | should handle two consecutive hot observables                       | `spec/observables/combineLatest-spec.ts:512` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:544:static combineLatest > should handle two consecutive hot observables with error right`      | should handle two consecutive hot observables with error right      | `spec/observables/combineLatest-spec.ts:544` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:560:static combineLatest > should handle selector throwing`                                     | should handle selector throwing                                     | `spec/observables/combineLatest-spec.ts:560` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:578:static combineLatest > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/observables/combineLatest-spec.ts:578` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:596:static combineLatest > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/observables/combineLatest-spec.ts:596` | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/combineLatest-spec.ts:61:static combineLatest > should combineLatest the provided observables`                        | should combineLatest the provided observables                       | `spec/observables/combineLatest-spec.ts:61`  | —            | `portable`     | `active`       | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-spec.ts:13:combineLatest > should accept array of observables`                                            | should accept array of observables                                  | `spec/operators/combineLatest-spec.ts:13`    | —            | `portable`     | `deduplicated` | rxTest observable assertion failed.                                                                  | `FIXED` |

### `combineLatest-legacy`

Owner source: `spec/operators/combineLatest-legacy-spec.ts`

| Case ID                                                                                                                               | Behavioral test                                                     | Source                                            | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/combineLatest-legacy-spec.ts:121:combineLatest > should work with hot-single and hot-empty`                           | should work with hot-single and hot-empty                           | `spec/operators/combineLatest-legacy-spec.ts:121` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:14:combineLatest > should combine events from two cold observables`                      | should combine events from two cold observables                     | `spec/operators/combineLatest-legacy-spec.ts:14`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:142:combineLatest > should work with hot-single and never`                               | should work with hot-single and never                               | `spec/operators/combineLatest-legacy-spec.ts:142` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:161:combineLatest > should work with never and hot-single`                               | should work with never and hot-single                               | `spec/operators/combineLatest-legacy-spec.ts:161` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:181:combineLatest > should work with hot and hot`                                        | should work with hot and hot                                        | `spec/operators/combineLatest-legacy-spec.ts:181` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:197:combineLatest > should accept array of observables`                                  | should accept array of observables                                  | `spec/operators/combineLatest-legacy-spec.ts:197` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:216:combineLatest > should work with empty and error`                                    | should work with empty and error                                    | `spec/operators/combineLatest-legacy-spec.ts:216` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:232:combineLatest > should work with error and empty`                                    | should work with error and empty                                    | `spec/operators/combineLatest-legacy-spec.ts:232` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:248:combineLatest > should work with hot and throw`                                      | should work with hot and throw                                      | `spec/operators/combineLatest-legacy-spec.ts:248` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:264:combineLatest > should work with throw and hot`                                      | should work with throw and hot                                      | `spec/operators/combineLatest-legacy-spec.ts:264` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:280:combineLatest > should work with throw and throw`                                    | should work with throw and throw                                    | `spec/operators/combineLatest-legacy-spec.ts:280` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:296:combineLatest > should work with error and throw`                                    | should work with error and throw                                    | `spec/operators/combineLatest-legacy-spec.ts:296` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:312:combineLatest > should work with throw and error`                                    | should work with throw and error                                    | `spec/operators/combineLatest-legacy-spec.ts:312` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:328:combineLatest > should work with never and throw`                                    | should work with never and throw                                    | `spec/operators/combineLatest-legacy-spec.ts:328` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:344:combineLatest > should work with throw and never`                                    | should work with throw and never                                    | `spec/operators/combineLatest-legacy-spec.ts:344` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:35:combineLatest > should work with two nevers`                                          | should work with two nevers                                         | `spec/operators/combineLatest-legacy-spec.ts:35`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:360:combineLatest > should work with some and throw`                                     | should work with some and throw                                     | `spec/operators/combineLatest-legacy-spec.ts:360` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:376:combineLatest > should work with throw and some`                                     | should work with throw and some                                     | `spec/operators/combineLatest-legacy-spec.ts:376` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:392:combineLatest > should handle throw after complete left`                             | should handle throw after complete left                             | `spec/operators/combineLatest-legacy-spec.ts:392` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:408:combineLatest > should handle throw after complete right`                            | should handle throw after complete right                            | `spec/operators/combineLatest-legacy-spec.ts:408` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:424:combineLatest > should handle interleaved with tail`                                 | should handle interleaved with tail                                 | `spec/operators/combineLatest-legacy-spec.ts:424` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:440:combineLatest > should handle two consecutive hot observables`                       | should handle two consecutive hot observables                       | `spec/operators/combineLatest-legacy-spec.ts:440` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:456:combineLatest > should handle two consecutive hot observables with error left`       | should handle two consecutive hot observables with error left       | `spec/operators/combineLatest-legacy-spec.ts:456` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:472:combineLatest > should handle two consecutive hot observables with error right`      | should handle two consecutive hot observables with error right      | `spec/operators/combineLatest-legacy-spec.ts:472` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:488:combineLatest > should handle selector throwing`                                     | should handle selector throwing                                     | `spec/operators/combineLatest-legacy-spec.ts:488` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:508:combineLatest > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/operators/combineLatest-legacy-spec.ts:508` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:51:combineLatest > should work with never and empty`                                     | should work with never and empty                                    | `spec/operators/combineLatest-legacy-spec.ts:51`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:526:combineLatest > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/operators/combineLatest-legacy-spec.ts:526` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:548:combineLatest > should emit unique array instances with the default projection`      | should emit unique array instances with the default projection      | `spec/operators/combineLatest-legacy-spec.ts:548` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:67:combineLatest > should work with empty and never`                                     | should work with empty and never                                    | `spec/operators/combineLatest-legacy-spec.ts:67`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:83:combineLatest > should work with empty and empty`                                     | should work with empty and empty                                    | `spec/operators/combineLatest-legacy-spec.ts:83`  | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/combineLatest-legacy-spec.ts:99:combineLatest > should work with hot-empty and hot-single`                            | should work with hot-empty and hot-single                           | `spec/operators/combineLatest-legacy-spec.ts:99`  | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |

### `combineLatestAll`

Owner source: `spec/operators/combineLatestAll-spec.ts`

| Case ID                                                                                                                                       | Behavioral test                                                     | Source                                        | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | --------------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/combineLatestAll-spec.ts:108:combineLatestAll operator > should work with hot-single and hot-empty`                           | should work with hot-single and hot-empty                           | `spec/operators/combineLatestAll-spec.ts:108` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:124:combineLatestAll operator > should work with hot-single and never`                               | should work with hot-single and never                               | `spec/operators/combineLatestAll-spec.ts:124` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:140:combineLatestAll operator > should work with never and hot-single`                               | should work with never and hot-single                               | `spec/operators/combineLatestAll-spec.ts:140` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:15:combineLatestAll operator > should combine events from two observables`                           | should combine events from two observables                          | `spec/operators/combineLatestAll-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:156:combineLatestAll operator > should work with hot and hot`                                        | should work with hot and hot                                        | `spec/operators/combineLatestAll-spec.ts:156` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:172:combineLatestAll operator > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/operators/combineLatestAll-spec.ts:172` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:190:combineLatestAll operator > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/operators/combineLatestAll-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:212:combineLatestAll operator > should combine 3 observables`                                        | should combine 3 observables                                        | `spec/operators/combineLatestAll-spec.ts:212` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:231:combineLatestAll operator > should work with empty and error`                                    | should work with empty and error                                    | `spec/operators/combineLatestAll-spec.ts:231` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:247:combineLatestAll operator > should work with error and empty`                                    | should work with error and empty                                    | `spec/operators/combineLatestAll-spec.ts:247` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:263:combineLatestAll operator > should work with hot and throw`                                      | should work with hot and throw                                      | `spec/operators/combineLatestAll-spec.ts:263` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:279:combineLatestAll operator > should work with throw and hot`                                      | should work with throw and hot                                      | `spec/operators/combineLatestAll-spec.ts:279` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:28:combineLatestAll operator > should work with two nevers`                                          | should work with two nevers                                         | `spec/operators/combineLatestAll-spec.ts:28`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:295:combineLatestAll operator > should work with throw and throw`                                    | should work with throw and throw                                    | `spec/operators/combineLatestAll-spec.ts:295` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:311:combineLatestAll operator > should work with error and throw`                                    | should work with error and throw                                    | `spec/operators/combineLatestAll-spec.ts:311` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:327:combineLatestAll operator > should work with throw and error`                                    | should work with throw and error                                    | `spec/operators/combineLatestAll-spec.ts:327` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:343:combineLatestAll operator > should work with never and throw`                                    | should work with never and throw                                    | `spec/operators/combineLatestAll-spec.ts:343` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:359:combineLatestAll operator > should work with throw and never`                                    | should work with throw and never                                    | `spec/operators/combineLatestAll-spec.ts:359` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:375:combineLatestAll operator > should work with some and throw`                                     | should work with some and throw                                     | `spec/operators/combineLatestAll-spec.ts:375` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:391:combineLatestAll operator > should work with throw and some`                                     | should work with throw and some                                     | `spec/operators/combineLatestAll-spec.ts:391` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:407:combineLatestAll operator > should handle throw after complete left`                             | should handle throw after complete left                             | `spec/operators/combineLatestAll-spec.ts:407` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:423:combineLatestAll operator > should handle throw after complete right`                            | should handle throw after complete right                            | `spec/operators/combineLatestAll-spec.ts:423` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:439:combineLatestAll operator > should handle interleaved with tail`                                 | should handle interleaved with tail                                 | `spec/operators/combineLatestAll-spec.ts:439` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:44:combineLatestAll operator > should work with never and empty`                                     | should work with never and empty                                    | `spec/operators/combineLatestAll-spec.ts:44`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:455:combineLatestAll operator > should handle two consecutive hot observables`                       | should handle two consecutive hot observables                       | `spec/operators/combineLatestAll-spec.ts:455` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:471:combineLatestAll operator > should handle two consecutive hot observables with error left`       | should handle two consecutive hot observables with error left       | `spec/operators/combineLatestAll-spec.ts:471` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:487:combineLatestAll operator > should handle two consecutive hot observables with error right`      | should handle two consecutive hot observables with error right      | `spec/operators/combineLatestAll-spec.ts:487` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:503:combineLatestAll operator > should handle selector throwing`                                     | should handle selector throwing                                     | `spec/operators/combineLatestAll-spec.ts:503` | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:60:combineLatestAll operator > should work with empty and never`                                     | should work with empty and never                                    | `spec/operators/combineLatestAll-spec.ts:60`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:76:combineLatestAll operator > should work with empty and empty`                                     | should work with empty and empty                                    | `spec/operators/combineLatestAll-spec.ts:76`  | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |
| `spec/operators/combineLatestAll-spec.ts:92:combineLatestAll operator > should work with hot-empty and hot-single`                            | should work with hot-empty and hot-single                           | `spec/operators/combineLatestAll-spec.ts:92`  | —            | `portable`     | `active`    | Missing operator capability: combineLatestAll                                                        | `FIXED` |

### `combineLatestWith`

Owner source: `spec/operators/combineLatestWith-spec.ts`

| Case ID                                                                                                                                | Behavioral test                                                     | Source                                         | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/combineLatestWith-spec.ts:114:combineLatestWith > should work with hot-empty and hot-single`                           | should work with hot-empty and hot-single                           | `spec/operators/combineLatestWith-spec.ts:114` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:139:combineLatestWith > should work with hot-single and hot-empty`                           | should work with hot-single and hot-empty                           | `spec/operators/combineLatestWith-spec.ts:139` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:14:combineLatestWith > should combine events from two cold observables`                      | should combine events from two cold observables                     | `spec/operators/combineLatestWith-spec.ts:14`  | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:163:combineLatestWith > should work with hot-single and never`                               | should work with hot-single and never                               | `spec/operators/combineLatestWith-spec.ts:163` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:185:combineLatestWith > should work with never and hot-single`                               | should work with never and hot-single                               | `spec/operators/combineLatestWith-spec.ts:185` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:208:combineLatestWith > should work with hot and hot`                                        | should work with hot and hot                                        | `spec/operators/combineLatestWith-spec.ts:208` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:227:combineLatestWith > should work with empty and error`                                    | should work with empty and error                                    | `spec/operators/combineLatestWith-spec.ts:227` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:246:combineLatestWith > should work with error and empty`                                    | should work with error and empty                                    | `spec/operators/combineLatestWith-spec.ts:246` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:265:combineLatestWith > should work with hot and throw`                                      | should work with hot and throw                                      | `spec/operators/combineLatestWith-spec.ts:265` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:284:combineLatestWith > should work with throw and hot`                                      | should work with throw and hot                                      | `spec/operators/combineLatestWith-spec.ts:284` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:303:combineLatestWith > should work with throw and throw`                                    | should work with throw and throw                                    | `spec/operators/combineLatestWith-spec.ts:303` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:322:combineLatestWith > should work with error and throw`                                    | should work with error and throw                                    | `spec/operators/combineLatestWith-spec.ts:322` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:341:combineLatestWith > should work with throw and error`                                    | should work with throw and error                                    | `spec/operators/combineLatestWith-spec.ts:341` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:360:combineLatestWith > should work with never and throw`                                    | should work with never and throw                                    | `spec/operators/combineLatestWith-spec.ts:360` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:379:combineLatestWith > should work with throw and never`                                    | should work with throw and never                                    | `spec/operators/combineLatestWith-spec.ts:379` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:38:combineLatestWith > should work with two nevers`                                          | should work with two nevers                                         | `spec/operators/combineLatestWith-spec.ts:38`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:398:combineLatestWith > should work with some and throw`                                     | should work with some and throw                                     | `spec/operators/combineLatestWith-spec.ts:398` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:417:combineLatestWith > should work with throw and some`                                     | should work with throw and some                                     | `spec/operators/combineLatestWith-spec.ts:417` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:436:combineLatestWith > should handle throw after complete left`                             | should handle throw after complete left                             | `spec/operators/combineLatestWith-spec.ts:436` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:455:combineLatestWith > should handle throw after complete right`                            | should handle throw after complete right                            | `spec/operators/combineLatestWith-spec.ts:455` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:474:combineLatestWith > should handle interleaved with tail`                                 | should handle interleaved with tail                                 | `spec/operators/combineLatestWith-spec.ts:474` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:493:combineLatestWith > should handle two consecutive hot observables`                       | should handle two consecutive hot observables                       | `spec/operators/combineLatestWith-spec.ts:493` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:512:combineLatestWith > should handle two consecutive hot observables with error left`       | should handle two consecutive hot observables with error left       | `spec/operators/combineLatestWith-spec.ts:512` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:531:combineLatestWith > should handle two consecutive hot observables with error right`      | should handle two consecutive hot observables with error right      | `spec/operators/combineLatestWith-spec.ts:531` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:550:combineLatestWith > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/operators/combineLatestWith-spec.ts:550` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:57:combineLatestWith > should work with never and empty`                                     | should work with never and empty                                    | `spec/operators/combineLatestWith-spec.ts:57`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:571:combineLatestWith > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/operators/combineLatestWith-spec.ts:571` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:594:combineLatestWith > should emit unique array instances with the default projection`      | should emit unique array instances with the default projection      | `spec/operators/combineLatestWith-spec.ts:594` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:76:combineLatestWith > should work with empty and never`                                     | should work with empty and never                                    | `spec/operators/combineLatestWith-spec.ts:76`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/combineLatestWith-spec.ts:95:combineLatestWith > should work with empty and empty`                                     | should work with empty and empty                                    | `spec/operators/combineLatestWith-spec.ts:95`  | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |

### `concat`

Owner source: `spec/observables/concat-spec.ts`

| Case ID                                                                                                                                                         | Behavioral test                                                                                           | Source                                | Failing mode    | Classification       | Disposition        | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------- | --------------- | -------------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/concat-spec.ts:113:static concat > should not complete if second source does not completes`                                                   | should not complete if second source does not completes                                                   | `spec/observables/concat-spec.ts:113` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/concat-spec.ts:127:static concat > should not complete if both sources do not complete`                                                       | should not complete if both sources do not complete                                                       | `spec/observables/concat-spec.ts:127` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/concat-spec.ts:211:static concat > 'should emit element from first source, and should not complete if second ' + 'source does not completes'` | 'should emit element from first source, and should not complete if second ' + 'source does not completes' | `spec/observables/concat-spec.ts:211` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/concat-spec.ts:225:static concat > should not complete if first source does not complete`                                                     | should not complete if first source does not complete                                                     | `spec/observables/concat-spec.ts:225` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/concat-spec.ts:253:static concat > should unsubscribe to inner source if outer is unsubscribed early`                                         | should unsubscribe to inner source if outer is unsubscribed early                                         | `spec/observables/concat-spec.ts:253` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/concat-spec.ts:433:static concat > should return RxJS Observable when single lowerCaseO was passed`                                           | should return RxJS Observable when single lowerCaseO was passed                                           | `spec/observables/concat-spec.ts:433` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/observables/concat-spec.ts:52:static concat > should concat the same cold observable multiple times, but the result is unsubscribed early`                | should concat the same cold observable multiple times, but the result is unsubscribed early               | `spec/observables/concat-spec.ts:52`  | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/concat-spec.ts:68:static concat > should not break unsubscription chains when result is unsubscribed explicitly`                              | should not break unsubscription chains when result is unsubscribed explicitly                             | `spec/observables/concat-spec.ts:68`  | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/concat-spec.ts:99:static concat > should not complete if first source does not completes`                                                     | should not complete if first source does not completes                                                    | `spec/observables/concat-spec.ts:99`  | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `concat-legacy`

Owner source: `spec/operators/concat-legacy-spec.ts`

| Case ID                                                                                                                                                                           | Behavioral test                                                                                                      | Source                                     | Failing mode | Classification    | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/concat-legacy-spec.ts:106:concat operator > should raise error when first source is empty, second source raises error`                                            | should raise error when first source is empty, second source raises error                                            | `spec/operators/concat-legacy-spec.ts:106` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:148:concat operator > should concat if first source emits once, second source is empty`                                                     | should concat if first source emits once, second source is empty                                                     | `spec/operators/concat-legacy-spec.ts:148` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:15:concat operator > should concatenate two cold observables`                                                                               | should concatenate two cold observables                                                                              | `spec/operators/concat-legacy-spec.ts:15`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:162:concat operator > should concat if first source is empty, second source emits once`                                                     | should concat if first source is empty, second source emits once                                                     | `spec/operators/concat-legacy-spec.ts:162` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:176:concat operator > should emit element from first source, and should not complete if second source does not complete`                    | should emit element from first source, and should not complete if second source does not complete                    | `spec/operators/concat-legacy-spec.ts:176` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:190:concat operator > should not complete if first source does not complete`                                                                | should not complete if first source does not complete                                                                | `spec/operators/concat-legacy-spec.ts:190` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:204:concat operator > should emit elements from each source when source emit once`                                                          | should emit elements from each source when source emit once                                                          | `spec/operators/concat-legacy-spec.ts:204` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:218:concat operator > should unsubscribe to inner source if outer is unsubscribed early`                                                    | should unsubscribe to inner source if outer is unsubscribed early                                                    | `spec/operators/concat-legacy-spec.ts:218` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:233:concat operator > should not break unsubscription chains when result is unsubscribed explicitly`                                        | should not break unsubscription chains when result is unsubscribed explicitly                                        | `spec/operators/concat-legacy-spec.ts:233` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:268:concat operator > should emit element from first source then raise error from second source`                                            | should emit element from first source then raise error from second source                                            | `spec/operators/concat-legacy-spec.ts:268` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:282:concat operator > should emit all elements from both hot observable sources if first source completes before second source starts emit` | should emit all elements from both hot observable sources if first source completes before second source starts emit | `spec/operators/concat-legacy-spec.ts:282` | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:296:concat operator > should emit elements from second source regardless of completion time when second source is cold observable`          | should emit elements from second source regardless of completion time when second source is cold observable          | `spec/operators/concat-legacy-spec.ts:296` | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:310:concat operator > should not emit collapsing element from second source`                                                                | should not emit collapsing element from second source                                                                | `spec/operators/concat-legacy-spec.ts:310` | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:324:concat operator > should accept scheduler with multiple observables`                                                                    | should accept scheduler with multiple observables                                                                    | `spec/operators/concat-legacy-spec.ts:324` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:341:concat operator > should accept scheduler without observable parameters`                                                                | should accept scheduler without observable parameters                                                                | `spec/operators/concat-legacy-spec.ts:341` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:352:concat operator > should emit self without parameters`                                                                                  | should emit self without parameters                                                                                  | `spec/operators/concat-legacy-spec.ts:352` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:50:concat operator > should complete without emit if both sources are empty`                                                                | should complete without emit if both sources are empty                                                               | `spec/operators/concat-legacy-spec.ts:50`  | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:64:concat operator > should not complete if first source does not complete`                                                                 | should not complete if first source does not complete                                                                | `spec/operators/concat-legacy-spec.ts:64`  | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:78:concat operator > should not complete if second source does not complete`                                                                | should not complete if second source does not complete                                                               | `spec/operators/concat-legacy-spec.ts:78`  | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concat-legacy-spec.ts:92:concat operator > should not complete if both sources do not complete`                                                                   | should not complete if both sources do not complete                                                                  | `spec/operators/concat-legacy-spec.ts:92`  | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `concatAll`

Owner source: `spec/operators/concatAll-spec.ts`

| Case ID                                                                                                                                                        | Behavioral test                                                                                    | Source                                 | Failing mode | Classification    | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/concatAll-spec.ts:130:concatAll operator > should concat all observables in an observable`                                                     | should concat all observables in an observable                                                     | `spec/operators/concatAll-spec.ts:130` | —            | `portable`        | `active`    | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/concatAll-spec.ts:139:concatAll operator > should throw if any child observable throws`                                                        | should throw if any child observable throws                                                        | `spec/operators/concatAll-spec.ts:139` | —            | `portable`        | `active`    | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/concatAll-spec.ts:206:concatAll operator > should not complete if first source does not completes`                                             | should not complete if first source does not completes                                             | `spec/operators/concatAll-spec.ts:206` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatAll-spec.ts:222:concatAll operator > should not complete if second source does not completes`                                            | should not complete if second source does not completes                                            | `spec/operators/concatAll-spec.ts:222` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatAll-spec.ts:238:concatAll operator > should not complete if both sources do not complete`                                                | should not complete if both sources do not complete                                                | `spec/operators/concatAll-spec.ts:238` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatAll-spec.ts:334:concatAll operator > should emit element from first source, and should not complete if second source does not completes` | should emit element from first source, and should not complete if second source does not completes | `spec/operators/concatAll-spec.ts:334` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatAll-spec.ts:350:concatAll operator > should not complete if first source does not complete`                                              | should not complete if first source does not complete                                              | `spec/operators/concatAll-spec.ts:350` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatAll-spec.ts:382:concatAll operator > should unsubscribe to inner source if outer is unsubscribed early`                                  | should unsubscribe to inner source if outer is unsubscribed early                                  | `spec/operators/concatAll-spec.ts:382` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatAll-spec.ts:399:concatAll operator > should not break unsubscription chains when result is unsubscribed explicitly`                      | should not break unsubscription chains when result is unsubscribed explicitly                      | `spec/operators/concatAll-spec.ts:399` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatAll-spec.ts:500:concatAll operator > should be able to work on a different scheduler`                                                    | should be able to work on a different scheduler                                                    | `spec/operators/concatAll-spec.ts:500` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/concatAll-spec.ts:532:concatAll operator > should concatAll a nested observable with a single inner observable, and a scheduler`               | should concatAll a nested observable with a single inner observable, and a scheduler               | `spec/operators/concatAll-spec.ts:532` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |

### `concatMap`

Owner source: `spec/operators/concatMap-spec.ts`

| Case ID                                                                                                                                       | Behavioral test                                                       | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/concatMap-spec.ts:145:Observable.prototype.concatMap > should handle a never source`                                          | should handle a never source                                          | `spec/operators/concatMap-spec.ts:145` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:15:Observable.prototype.concatMap > should map-and-flatten each item to an Observable`                      | should map-and-flatten each item to an Observable                     | `spec/operators/concatMap-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMap-spec.ts:210:Observable.prototype.concatMap > should return a never if the mapped inner is never`                    | should return a never if the mapped inner is never                    | `spec/operators/concatMap-spec.ts:210` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:272:Observable.prototype.concatMap > should concatMap many outer to many inner, outer never completes`      | should concatMap many outer to many inner, outer never completes      | `spec/operators/concatMap-spec.ts:272` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:294:Observable.prototype.concatMap > should concatMap many outer to many inner, inner never completes`      | should concatMap many outer to many inner, inner never completes      | `spec/operators/concatMap-spec.ts:294` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:401:Observable.prototype.concatMap > should concatMap many complex, all inners finite except one`           | should concatMap many complex, all inners finite except one           | `spec/operators/concatMap-spec.ts:401` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:436:Observable.prototype.concatMap > should concatMap many complex, inners finite, outer does not complete` | should concatMap many complex, inners finite, outer does not complete | `spec/operators/concatMap-spec.ts:436` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMap-spec.ts:726:Observable.prototype.concatMap > should concatMap many outer to an array for each value`                | should concatMap many outer to an array for each value                | `spec/operators/concatMap-spec.ts:726` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMap-spec.ts:739:Observable.prototype.concatMap > should concatMap many outer to inner arrays, outer unsubscribed early` | should concatMap many outer to inner arrays, outer unsubscribed early | `spec/operators/concatMap-spec.ts:739` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMap-spec.ts:753:Observable.prototype.concatMap > should concatMap many outer to inner arrays, project throws`           | should concatMap many outer to inner arrays, project throws           | `spec/operators/concatMap-spec.ts:753` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMap-spec.ts:81:Observable.prototype.concatMap > should concatenate many regular interval inners`                        | should concatenate many regular interval inners                       | `spec/operators/concatMap-spec.ts:81`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `concatMapTo`

Owner source: `spec/operators/concatMapTo-spec.ts`

| Case ID                                                                                                                              | Behavioral test                                                               | Source                                   | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/concatMapTo-spec.ts:114:concatMapTo > should handle a never source`                                                  | should handle a never source                                                  | `spec/operators/concatMapTo-spec.ts:114` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:167:concatMapTo > should return a never if the mapped inner is never`                            | should return a never if the mapped inner is never                            | `spec/operators/concatMapTo-spec.ts:167` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:221:concatMapTo > should concatMapTo many outer to many inner, outer never completes`            | should concatMapTo many outer to many inner, outer never completes            | `spec/operators/concatMapTo-spec.ts:221` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:243:concatMapTo > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/concatMapTo-spec.ts:243` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:269:concatMapTo > should concatMapTo many outer to many inner, inner never completes`            | should concatMapTo many outer to many inner, inner never completes            | `spec/operators/concatMapTo-spec.ts:269` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:341:concatMapTo > should concatMapTo many outer to an array`                                     | should concatMapTo many outer to an array                                     | `spec/operators/concatMapTo-spec.ts:341` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:352:concatMapTo > should concatMapTo many outer to inner arrays, and outer throws`               | should concatMapTo many outer to inner arrays, and outer throws               | `spec/operators/concatMapTo-spec.ts:352` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatMapTo-spec.ts:363:concatMapTo > should concatMapTo many outer to inner arrays, outer unsubscribed early`       | should concatMapTo many outer to inner arrays, outer unsubscribed early       | `spec/operators/concatMapTo-spec.ts:363` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `concatWith`

Owner source: `spec/operators/concatWith-spec.ts`

| Case ID                                                                                                                                                                        | Behavioral test                                                                                                      | Source                                  | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/concatWith-spec.ts:107:concat operator > should raise error when first source is empty, second source raises error`                                            | should raise error when first source is empty, second source raises error                                            | `spec/operators/concatWith-spec.ts:107` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:149:concat operator > should concat if first source emits once, second source is empty`                                                     | should concat if first source emits once, second source is empty                                                     | `spec/operators/concatWith-spec.ts:149` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:16:concat operator > should concatenate two cold observables`                                                                               | should concatenate two cold observables                                                                              | `spec/operators/concatWith-spec.ts:16`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:163:concat operator > should concat if first source is empty, second source emits once`                                                     | should concat if first source is empty, second source emits once                                                     | `spec/operators/concatWith-spec.ts:163` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:177:concat operator > should emit element from first source, and should not complete if second source does not completes`                   | should emit element from first source, and should not complete if second source does not completes                   | `spec/operators/concatWith-spec.ts:177` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatWith-spec.ts:191:concat operator > should not complete if first source does not complete`                                                                | should not complete if first source does not complete                                                                | `spec/operators/concatWith-spec.ts:191` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatWith-spec.ts:205:concat operator > should emit elements from each source when source emit once`                                                          | should emit elements from each source when source emit once                                                          | `spec/operators/concatWith-spec.ts:205` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:219:concat operator > should unsubscribe to inner source if outer is unsubscribed early`                                                    | should unsubscribe to inner source if outer is unsubscribed early                                                    | `spec/operators/concatWith-spec.ts:219` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:234:concat operator > should not break unsubscription chains when result is unsubscribed explicitly`                                        | should not break unsubscription chains when result is unsubscribed explicitly                                        | `spec/operators/concatWith-spec.ts:234` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:269:concat operator > should emit element from first source then raise error from second source`                                            | should emit element from first source then raise error from second source                                            | `spec/operators/concatWith-spec.ts:269` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:283:concat operator > should emit all elements from both hot observable sources if first source completes before second source starts emit` | should emit all elements from both hot observable sources if first source completes before second source starts emit | `spec/operators/concatWith-spec.ts:283` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concatWith-spec.ts:297:concat operator > should emit elements from second source regardless of completion time when second source is cold observable`          | should emit elements from second source regardless of completion time when second source is cold observable          | `spec/operators/concatWith-spec.ts:297` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concatWith-spec.ts:311:concat operator > should not emit collapsing element from second source`                                                                | should not emit collapsing element from second source                                                                | `spec/operators/concatWith-spec.ts:311` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/concatWith-spec.ts:325:concat operator > should emit self without parameters`                                                                                  | should emit self without parameters                                                                                  | `spec/operators/concatWith-spec.ts:325` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:51:concat operator > should complete without emit if both sources are empty`                                                                | should complete without emit if both sources are empty                                                               | `spec/operators/concatWith-spec.ts:51`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/concatWith-spec.ts:65:concat operator > should not complete if first source does not completes`                                                                | should not complete if first source does not completes                                                               | `spec/operators/concatWith-spec.ts:65`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatWith-spec.ts:79:concat operator > should not complete if second source does not completes`                                                               | should not complete if second source does not completes                                                              | `spec/operators/concatWith-spec.ts:79`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/concatWith-spec.ts:93:concat operator > should not complete if both sources do not complete`                                                                   | should not complete if both sources do not complete                                                                  | `spec/operators/concatWith-spec.ts:93`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `connect`

Owner source: `spec/operators/connect-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                                    | Source                              | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/connect-spec.ts:13:connect > should connect a source through a selector function`                                | should connect a source through a selector function                                | `spec/operators/connect-spec.ts:13` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/connect-spec.ts:25:connect > should connect a source through a selector function and use the provided connector` | should connect a source through a selector function and use the provided connector | `spec/operators/connect-spec.ts:25` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `connectable`

Owner source: `spec/observables/connectable-spec.ts`

| Case ID                                                                                                                   | Behavioral test                                                   | Source                                    | Failing mode | Classification    | Disposition | Concise failure               | Status  |
| ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------- | ------------ | ----------------- | ----------- | ----------------------------- | ------- |
| `spec/observables/connectable-spec.ts:14:connectable > should mirror a simple source Observable`                          | should mirror a simple source Observable                          | `spec/observables/connectable-spec.ts:14` | —            | `portable`        | `active`    | connectable is not a function | `FIXED` |
| `spec/observables/connectable-spec.ts:29:connectable > should do nothing if connect is not called, despite subscriptions` | should do nothing if connect is not called, despite subscriptions | `spec/observables/connectable-spec.ts:29` | —            | `harness-rewrite` | `active`    | connectable is not a function | `FIXED` |

### `count`

Owner source: `spec/operators/count-spec.ts`

| Case ID                                                                                                                  | Behavioral test                                                               | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/count-spec.ts:140:count > should work with error`                                                        | should work with error                                                        | `spec/operators/count-spec.ts:140` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:15:count > should count the values of an observable`                                       | should count the values of an observable                                      | `spec/operators/count-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:151:count > should work with throw`                                                        | should work with throw                                                        | `spec/operators/count-spec.ts:151` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:162:count > should handle an always-true predicate on an empty hot observable`             | should handle an always-true predicate on an empty hot observable             | `spec/operators/count-spec.ts:162` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:176:count > should handle an always-false predicate on an empty hot observable`            | should handle an always-false predicate on an empty hot observable            | `spec/operators/count-spec.ts:176` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:190:count > should handle an always-true predicate on a simple hot observable`             | should handle an always-true predicate on a simple hot observable             | `spec/operators/count-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:204:count > should handle an always-false predicate on a simple hot observable`            | should handle an always-false predicate on a simple hot observable            | `spec/operators/count-spec.ts:204` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:218:count > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/operators/count-spec.ts:218` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:232:count > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/count-spec.ts:232` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:250:count > should handle a match-all predicate on observable with many values`            | should handle a match-all predicate on observable with many values            | `spec/operators/count-spec.ts:250` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:26:count > should be never when source is never`                                           | should be never when source is never                                          | `spec/operators/count-spec.ts:26`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/count-spec.ts:262:count > should handle a match-none predicate on observable with many values`           | should handle a match-none predicate on observable with many values           | `spec/operators/count-spec.ts:262` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:274:count > should handle an always-true predicate on observable that throws`              | should handle an always-true predicate on observable that throws              | `spec/operators/count-spec.ts:274` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:286:count > should handle an always-false predicate on observable that throws`             | should handle an always-false predicate on observable that throws             | `spec/operators/count-spec.ts:286` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:298:count > should handle an always-true predicate on a hot never-observable`              | should handle an always-true predicate on a hot never-observable              | `spec/operators/count-spec.ts:298` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/count-spec.ts:310:count > should handle a predicate that throws, on observable with many values`         | should handle a predicate that throws, on observable with many values         | `spec/operators/count-spec.ts:310` | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:37:count > should be zero when source is empty`                                            | should be zero when source is empty                                           | `spec/operators/count-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:48:count > should be never when source doesn't complete`                                   | should be never when source doesn't complete                                  | `spec/operators/count-spec.ts:48`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/count-spec.ts:59:count > should be zero when source doesn't have values`                                 | should be zero when source doesn't have values                                | `spec/operators/count-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:70:count > should count the unique value of an observable`                                 | should count the unique value of an observable                                | `spec/operators/count-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |
| `spec/operators/count-spec.ts:81:count > should count the values of an ongoing hot observable`                           | should count the values of an ongoing hot observable                          | `spec/operators/count-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: count                                                                   | `FIXED` |

### `debounce`

Owner source: `spec/operators/debounce-spec.ts`

| Case ID                                                                                                                        | Behavioral test                                                               | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/debounce-spec.ts:123:debounce > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/operators/debounce-spec.ts:123` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:137:debounce > should not break unsubscription chains when unsubscribed explicitly`           | should not break unsubscription chains when unsubscribed explicitly           | `spec/operators/debounce-spec.ts:137` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:155:debounce > should debounce and does not complete when source does not completes`          | should debounce and does not complete when source does not completes          | `spec/operators/debounce-spec.ts:155` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounce-spec.ts:166:debounce > should not complete when source does not complete`                             | should not complete when source does not complete                             | `spec/operators/debounce-spec.ts:166` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounce-spec.ts:177:debounce > should not completes when source never completes`                              | should not completes when source never completes                              | `spec/operators/debounce-spec.ts:177` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounce-spec.ts:199:debounce > should debounce all elements while source emits by selector observable`        | should debounce all elements while source emits by selector observable        | `spec/operators/debounce-spec.ts:199` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:269:debounce > should debounce by selector observable until source completes`                 | should debounce by selector observable until source completes                 | `spec/operators/debounce-spec.ts:269` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:379:debounce > should ignore all values except last, when given an empty selector Observable` | should ignore all values except last, when given an empty selector Observable | `spec/operators/debounce-spec.ts:379` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:394:debounce > should ignore all values except last, when given a never selector Observable`  | should ignore all values except last, when given a never selector Observable  | `spec/operators/debounce-spec.ts:394` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:409:debounce > should not delay by selector observable completes when it does not emits`      | should not delay by selector observable completes when it does not emits      | `spec/operators/debounce-spec.ts:409` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounce-spec.ts:433:debounce > should not debounce by selector observable completes when it does not emits`   | should not debounce by selector observable completes when it does not emits   | `spec/operators/debounce-spec.ts:433` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `debounceTime`

Owner source: `spec/operators/debounceTime-spec.ts`

| Case ID                                                                                                                       | Behavioral test                                                      | Source                                    | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/debounceTime-spec.ts:102:debounceTime > should allow unsubscribing early and explicitly`                      | should allow unsubscribing early and explicitly                      | `spec/operators/debounceTime-spec.ts:102` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounceTime-spec.ts:117:debounceTime > should not break unsubscription chains when unsubscribed explicitly`  | should not break unsubscription chains when unsubscribed explicitly  | `spec/operators/debounceTime-spec.ts:117` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounceTime-spec.ts:136:debounceTime > should debounce and does not complete when source does not completes` | should debounce and does not complete when source does not completes | `spec/operators/debounceTime-spec.ts:136` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounceTime-spec.ts:148:debounceTime > should not completes when source does not completes`                  | should not completes when source does not completes                  | `spec/operators/debounceTime-spec.ts:148` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounceTime-spec.ts:160:debounceTime > should not completes when source never completes`                     | should not completes when source never completes                     | `spec/operators/debounceTime-spec.ts:160` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/debounceTime-spec.ts:184:debounceTime > should debounce all elements while source emits within given time`    | should debounce all elements while source emits within given time    | `spec/operators/debounceTime-spec.ts:184` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/debounceTime-spec.ts:30:debounceTime > should delay all elements by the specified time`                       | should delay all elements by the specified time                      | `spec/operators/debounceTime-spec.ts:30`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `defaultIfEmpty`

Owner source: `spec/operators/defaultIfEmpty-spec.ts`

| Case ID                                                                                                                         | Behavioral test                                                     | Source                                     | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------ | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/defaultIfEmpty-spec.ts:59:defaultIfEmpty > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/operators/defaultIfEmpty-spec.ts:59` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/defaultIfEmpty-spec.ts:73:defaultIfEmpty > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/operators/defaultIfEmpty-spec.ts:73` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `defer`

Owner source: `spec/observables/defer-spec.ts`

| Case ID                                                                                                                    | Behavioral test                                                               | Source                               | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------ | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/defer-spec.ts:130:defer > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/observables/defer-spec.ts:130` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/observables/defer-spec.ts:144:defer > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/observables/defer-spec.ts:144` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `delay`

Owner source: `spec/operators/delay-spec.ts`

| Case ID                                                                                                                  | Behavioral test                                                               | Source                             | Failing mode | Classification           | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------- | ------------ | ------------------------ | ----------- | ----------------------------------- | ------- |
| `spec/operators/delay-spec.ts:105:delay > should raise error when source raises error before absolute delay fires`       | should raise error when source raises error before absolute delay fires       | `spec/operators/delay-spec.ts:105` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:120:delay > should raise error when source raises error after absolute delay fires`        | should raise error when source raises error after absolute delay fires        | `spec/operators/delay-spec.ts:120` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:135:delay > should delay when source does not emit`                                        | should delay when source does not emit                                        | `spec/operators/delay-spec.ts:135` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:149:delay > should not delay when source is empty`                                         | should not delay when source is empty                                         | `spec/operators/delay-spec.ts:149` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:16:delay > should delay by specified timeframe`                                            | should delay by specified timeframe                                           | `spec/operators/delay-spec.ts:16`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:163:delay > should delay complete when a value is scheduled`                               | should delay complete when a value is scheduled                               | `spec/operators/delay-spec.ts:163` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:177:delay > should not complete when source does not complete`                             | should not complete when source does not complete                             | `spec/operators/delay-spec.ts:177` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:193:delay > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/delay-spec.ts:193` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:213:delay > should not complete when source never completes`                               | should not complete when source never completes                               | `spec/operators/delay-spec.ts:213` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:227:delay > should unsubscribe scheduled actions after execution`                          | should unsubscribe scheduled actions after execution                          | `spec/operators/delay-spec.ts:227` | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/delay-spec.ts:259:delay > should be possible to delay complete by composition`                           | should be possible to delay complete by composition                           | `spec/operators/delay-spec.ts:259` | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:31:delay > should not delay at all if the delay number is negative`                        | should not delay at all if the delay number is negative                       | `spec/operators/delay-spec.ts:31`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:45:delay > should delay by absolute time period`                                           | should delay by absolute time period                                          | `spec/operators/delay-spec.ts:45`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:60:delay > should not delay at all if the absolute time is in the past`                    | should not delay at all if the absolute time is in the past                   | `spec/operators/delay-spec.ts:60`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:75:delay > should delay by absolute time period after source ends`                         | should delay by absolute time period after source ends                        | `spec/operators/delay-spec.ts:75`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |
| `spec/operators/delay-spec.ts:90:delay > should raise error when source raises error`                                    | should raise error when source raises error                                   | `spec/operators/delay-spec.ts:90`  | —            | `portable`               | `active`    | Missing operator capability: delay  | `FIXED` |

### `delayWhen`

Owner source: `spec/operators/delayWhen-spec.ts`

| Case ID                                                                                                                           | Behavioral test                                                                | Source                                 | Failing mode | Classification           | Disposition | Concise failure                        | Status  |
| --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------- | ------------ | ------------------------ | ----------- | -------------------------------------- | ------- |
| `spec/operators/delayWhen-spec.ts:120:delayWhen > should delay, but not emit if the selector never emits a notification`          | should delay, but not emit if the selector never emits a notification          | `spec/operators/delayWhen-spec.ts:120` | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/delayWhen-spec.ts:141:delayWhen > should not emit for async source and sync empty selector`                       | should not emit for async source and sync empty selector                       | `spec/operators/delayWhen-spec.ts:141` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:15:delayWhen > should delay by duration selector`                                               | should delay by duration selector                                              | `spec/operators/delayWhen-spec.ts:15`  | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:154:delayWhen > should not emit if selector never emits`                                        | should not emit if selector never emits                                        | `spec/operators/delayWhen-spec.ts:154` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:175:delayWhen > should delay by first value from selector`                                      | should delay by first value from selector                                      | `spec/operators/delayWhen-spec.ts:175` | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/delayWhen-spec.ts:196:delayWhen > should delay by selector that does not completes`                               | should delay by selector that does not completes                               | `spec/operators/delayWhen-spec.ts:196` | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/delayWhen-spec.ts:217:delayWhen > should raise error if selector throws`                                          | should raise error if selector throws                                          | `spec/operators/delayWhen-spec.ts:217` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:235:delayWhen > should start subscription when subscription delay emits`                        | should start subscription when subscription delay emits                        | `spec/operators/delayWhen-spec.ts:235` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:259:delayWhen > should start subscription when subscription delay completes without emit value` | should start subscription when subscription delay completes without emit value | `spec/operators/delayWhen-spec.ts:259` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:283:delayWhen > should raise error when subscription delay raises error`                        | should raise error when subscription delay raises error                        | `spec/operators/delayWhen-spec.ts:283` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:312:delayWhen > should call predicate with indices starting at 0`                               | should call predicate with indices starting at 0                               | `spec/operators/delayWhen-spec.ts:312` | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:46:delayWhen > should delay by selector`                                                        | should delay by selector                                                       | `spec/operators/delayWhen-spec.ts:46`  | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:67:delayWhen > should raise error if source raises error`                                       | should raise error if source raises error                                      | `spec/operators/delayWhen-spec.ts:67`  | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:83:delayWhen > should raise error if selector raises error`                                     | should raise error if selector raises error                                    | `spec/operators/delayWhen-spec.ts:83`  | —            | `portable`               | `active`    | Missing operator capability: delayWhen | `FIXED` |
| `spec/operators/delayWhen-spec.ts:99:delayWhen > should delay by selector and completes after value emits`                        | should delay by selector and completes after value emits                       | `spec/operators/delayWhen-spec.ts:99`  | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.    | `FIXED` |

### `dematerialize`

Owner source: `spec/operators/dematerialize-spec.ts`

| Case ID                                                                                                                                        | Behavioral test                                                                     | Source                                     | Failing mode | Classification | Disposition | Concise failure                                                | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------ | ------------ | -------------- | ----------- | -------------------------------------------------------------- | ------- |
| `spec/operators/dematerialize-spec.ts:102:dematerialize > should dematerialize stream does not emit`                                           | should dematerialize stream does not emit                                           | `spec/operators/dematerialize-spec.ts:102` | —            | `portable`     | `active`    | Missing operator capability: dematerialize                     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:113:dematerialize > should dematerialize empty stream`                                                   | should dematerialize empty stream                                                   | `spec/operators/dematerialize-spec.ts:113` | —            | `portable`     | `active`    | Missing operator capability: dematerialize                     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:124:dematerialize > should dematerialize stream throws`                                                  | should dematerialize stream throws                                                  | `spec/operators/dematerialize-spec.ts:124` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createError')    | `FIXED` |
| `spec/operators/dematerialize-spec.ts:136:dematerialize > should allow unsubscribing early and explicitly`                                     | should allow unsubscribing early and explicitly                                     | `spec/operators/dematerialize-spec.ts:136` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext')     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:15:dematerialize > should dematerialize an Observable`                                                   | should dematerialize an Observable                                                  | `spec/operators/dematerialize-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: dematerialize                     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:155:dematerialize > should not break unsubscription chains when unsubscribed explicitly`                 | should not break unsubscription chains when unsubscribed explicitly                 | `spec/operators/dematerialize-spec.ts:155` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext')     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:178:dematerialize > should dematerialize and completes when stream completes with complete notification` | should dematerialize and completes when stream completes with complete notification | `spec/operators/dematerialize-spec.ts:178` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createComplete') | `FIXED` |
| `spec/operators/dematerialize-spec.ts:189:dematerialize > should dematerialize and completes when stream emits complete notification`          | should dematerialize and completes when stream emits complete notification          | `spec/operators/dematerialize-spec.ts:189` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createComplete') | `FIXED` |
| `spec/operators/dematerialize-spec.ts:200:dematerialize > should work with materialize`                                                        | should work with materialize                                                        | `spec/operators/dematerialize-spec.ts:200` | —            | `portable`     | `active`    | Missing operator capability: materialize                       | `FIXED` |
| `spec/operators/dematerialize-spec.ts:44:dematerialize > should dematerialize a happy stream`                                                  | should dematerialize a happy stream                                                 | `spec/operators/dematerialize-spec.ts:44`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext')     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:62:dematerialize > should dematerialize a sad stream`                                                    | should dematerialize a sad stream                                                   | `spec/operators/dematerialize-spec.ts:62`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext')     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:80:dematerialize > should dematerialize stream does not completes`                                       | should dematerialize stream does not completes                                      | `spec/operators/dematerialize-spec.ts:80`  | —            | `portable`     | `active`    | Missing operator capability: dematerialize                     | `FIXED` |
| `spec/operators/dematerialize-spec.ts:91:dematerialize > should dematerialize stream never completes`                                          | should dematerialize stream never completes                                         | `spec/operators/dematerialize-spec.ts:91`  | —            | `portable`     | `active`    | Missing operator capability: dematerialize                     | `FIXED` |

### `distinct`

Owner source: `spec/operators/distinct-spec.ts`

| Case ID                                                                                                                       | Behavioral test                                                              | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/distinct-spec.ts:101:distinct > should raises error if source raises error`                                   | should raises error if source raises error                                   | `spec/operators/distinct-spec.ts:101` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:112:distinct > should raises error if source throws`                                         | should raises error if source throws                                         | `spec/operators/distinct-spec.ts:112` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:123:distinct > should not omit if source elements are all different`                         | should not omit if source elements are all different                         | `spec/operators/distinct-spec.ts:123` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:134:distinct > should allow unsubscribing early and explicitly`                              | should allow unsubscribing early and explicitly                              | `spec/operators/distinct-spec.ts:134` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:148:distinct > should not break unsubscription chains when unsubscribed explicitly`          | should not break unsubscription chains when unsubscribed explicitly          | `spec/operators/distinct-spec.ts:148` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:15:distinct > should distinguish between values`                                             | should distinguish between values                                            | `spec/operators/distinct-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:166:distinct > should emit once if source elements are all same`                             | should emit once if source elements are all same                             | `spec/operators/distinct-spec.ts:166` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:177:distinct > should distinguish values by key`                                             | should distinguish values by key                                             | `spec/operators/distinct-spec.ts:177` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:190:distinct > should raises error when selector throws`                                     | should raises error when selector throws                                     | `spec/operators/distinct-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:207:distinct > should support a flushing stream`                                             | should support a flushing stream                                             | `spec/operators/distinct-spec.ts:207` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:221:distinct > should raise error if flush raises error`                                     | should raise error if flush raises error                                     | `spec/operators/distinct-spec.ts:221` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:235:distinct > should unsubscribe from the flushing stream when the main stream is unsubbed` | should unsubscribe from the flushing stream when the main stream is unsubbed | `spec/operators/distinct-spec.ts:235` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:250:distinct > should allow opting in to default comparator with flush`                      | should allow opting in to default comparator with flush                      | `spec/operators/distinct-spec.ts:250` | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:26:distinct > should distinguish between values and does not complete`                       | should distinguish between values and does not complete                      | `spec/operators/distinct-spec.ts:26`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinct-spec.ts:37:distinct > should not complete if source never completes`                                 | should not complete if source never completes                                | `spec/operators/distinct-spec.ts:37`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinct-spec.ts:48:distinct > should not complete if source does not complete`                               | should not complete if source does not complete                              | `spec/operators/distinct-spec.ts:48`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinct-spec.ts:59:distinct > should complete if source is empty`                                            | should complete if source is empty                                           | `spec/operators/distinct-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:70:distinct > should complete if source does not emit`                                       | should complete if source does not emit                                      | `spec/operators/distinct-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:81:distinct > should emit if source emits single element only`                               | should emit if source emits single element only                              | `spec/operators/distinct-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |
| `spec/operators/distinct-spec.ts:92:distinct > should emit if source is scalar`                                               | should emit if source is scalar                                              | `spec/operators/distinct-spec.ts:92`  | —            | `portable`     | `active`    | Missing operator capability: distinct                                                                | `FIXED` |

### `distinctUntilChanged`

Owner source: `spec/operators/distinctUntilChanged-spec.ts`

| Case ID                                                                                                                                                | Behavioral test                                                               | Source                                            | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ------------------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/distinctUntilChanged-spec.ts:103:distinctUntilChanged > should emit if source is scalar`                                               | should emit if source is scalar                                               | `spec/operators/distinctUntilChanged-spec.ts:103` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:112:distinctUntilChanged > should raise error if source raises error`                                     | should raise error if source raises error                                     | `spec/operators/distinctUntilChanged-spec.ts:112` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:123:distinctUntilChanged > should raise error if source throws`                                           | should raise error if source throws                                           | `spec/operators/distinctUntilChanged-spec.ts:123` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:134:distinctUntilChanged > should not omit if source elements are all different`                          | should not omit if source elements are all different                          | `spec/operators/distinctUntilChanged-spec.ts:134` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:145:distinctUntilChanged > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/operators/distinctUntilChanged-spec.ts:145` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:15:distinctUntilChanged > should distinguish between values`                                              | should distinguish between values                                             | `spec/operators/distinctUntilChanged-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:159:distinctUntilChanged > should not break unsubscription chains when unsubscribed explicitly`           | should not break unsubscription chains when unsubscribed explicitly           | `spec/operators/distinctUntilChanged-spec.ts:159` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:177:distinctUntilChanged > should emit once if source elements are all same`                              | should emit once if source elements are all same                              | `spec/operators/distinctUntilChanged-spec.ts:177` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:188:distinctUntilChanged > should emit once if comparator returns true always regardless of source emits` | should emit once if comparator returns true always regardless of source emits | `spec/operators/distinctUntilChanged-spec.ts:188` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:200:distinctUntilChanged > should emit all if comparator returns false always regardless of source emits` | should emit all if comparator returns false always regardless of source emits | `spec/operators/distinctUntilChanged-spec.ts:200` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:212:distinctUntilChanged > should distinguish values by comparator`                                       | should distinguish values by comparator                                       | `spec/operators/distinctUntilChanged-spec.ts:212` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:224:distinctUntilChanged > should raise error when comparator throws`                                     | should raise error when comparator throws                                     | `spec/operators/distinctUntilChanged-spec.ts:224` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:241:distinctUntilChanged > should use the keySelector to pick comparator values`                          | should use the keySelector to pick comparator values                          | `spec/operators/distinctUntilChanged-spec.ts:241` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:254:distinctUntilChanged > should use the keySelector even for the first emit`                            | should use the keySelector even for the first emit                            | `spec/operators/distinctUntilChanged-spec.ts:254` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:26:distinctUntilChanged > should distinguish between values`                                              | should distinguish between values                                             | `spec/operators/distinctUntilChanged-spec.ts:26`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:266:distinctUntilChanged > should raise error when keySelector throws`                                    | should raise error when keySelector throws                                    | `spec/operators/distinctUntilChanged-spec.ts:266` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:37:distinctUntilChanged > should distinguish between values and does not complete`                        | should distinguish between values and does not complete                       | `spec/operators/distinctUntilChanged-spec.ts:37`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:48:distinctUntilChanged > should not complete if source never completes`                                  | should not complete if source never completes                                 | `spec/operators/distinctUntilChanged-spec.ts:48`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:59:distinctUntilChanged > should not complete if source does not complete`                                | should not complete if source does not complete                               | `spec/operators/distinctUntilChanged-spec.ts:59`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:70:distinctUntilChanged > should complete if source is empty`                                             | should complete if source is empty                                            | `spec/operators/distinctUntilChanged-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:81:distinctUntilChanged > should complete if source does not emit`                                        | should complete if source does not emit                                       | `spec/operators/distinctUntilChanged-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |
| `spec/operators/distinctUntilChanged-spec.ts:92:distinctUntilChanged > should emit if source emits single element only`                                | should emit if source emits single element only                               | `spec/operators/distinctUntilChanged-spec.ts:92`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilChanged                                                    | `FIXED` |

### `distinctUntilKeyChanged`

Owner source: `spec/operators/distinctUntilKeyChanged-spec.ts`

| Case ID                                                                                                                                                    | Behavioral test                                                             | Source                                               | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/distinctUntilKeyChanged-spec.ts:110:distinctUntilKeyChanged > should complete if source does not emit`                                     | should complete if source does not emit                                     | `spec/operators/distinctUntilKeyChanged-spec.ts:110` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:121:distinctUntilKeyChanged > should emit if source emits single element only`                             | should emit if source emits single element only                             | `spec/operators/distinctUntilKeyChanged-spec.ts:121` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:133:distinctUntilKeyChanged > should emit if source is scalar`                                             | should emit if source is scalar                                             | `spec/operators/distinctUntilKeyChanged-spec.ts:133` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:143:distinctUntilKeyChanged > should raise error if source raises error`                                   | should raise error if source raises error                                   | `spec/operators/distinctUntilKeyChanged-spec.ts:143` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:15:distinctUntilKeyChanged > should distinguish between values`                                            | should distinguish between values                                           | `spec/operators/distinctUntilKeyChanged-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:155:distinctUntilKeyChanged > should raise error if source throws`                                         | should raise error if source throws                                         | `spec/operators/distinctUntilKeyChanged-spec.ts:155` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:166:distinctUntilKeyChanged > should not omit if source elements are all different`                        | should not omit if source elements are all different                        | `spec/operators/distinctUntilKeyChanged-spec.ts:166` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:178:distinctUntilKeyChanged > should allow unsubscribing early and explicitly`                             | should allow unsubscribing early and explicitly                             | `spec/operators/distinctUntilKeyChanged-spec.ts:178` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:193:distinctUntilKeyChanged > should not break unsubscription chains when unsubscribed explicitly`         | should not break unsubscription chains when unsubscribed explicitly         | `spec/operators/distinctUntilKeyChanged-spec.ts:193` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:212:distinctUntilKeyChanged > should emit once if source elements are all same`                            | should emit once if source elements are all same                            | `spec/operators/distinctUntilKeyChanged-spec.ts:212` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:224:distinctUntilKeyChanged > should emit once if comparer returns true always regardless of source emits` | should emit once if comparer returns true always regardless of source emits | `spec/operators/distinctUntilKeyChanged-spec.ts:224` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:236:distinctUntilKeyChanged > should emit all if comparer returns false always regardless of source emits` | should emit all if comparer returns false always regardless of source emits | `spec/operators/distinctUntilKeyChanged-spec.ts:236` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:248:distinctUntilKeyChanged > should distinguish values by selector`                                       | should distinguish values by selector                                       | `spec/operators/distinctUntilKeyChanged-spec.ts:248` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:261:distinctUntilKeyChanged > should raise error when comparer throws`                                     | should raise error when comparer throws                                     | `spec/operators/distinctUntilKeyChanged-spec.ts:261` | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:29:distinctUntilKeyChanged > should distinguish between values`                                            | should distinguish between values                                           | `spec/operators/distinctUntilKeyChanged-spec.ts:29`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:41:distinctUntilKeyChanged > should distinguish between values and does not complete`                      | should distinguish between values and does not complete                     | `spec/operators/distinctUntilKeyChanged-spec.ts:41`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:53:distinctUntilKeyChanged > should distinguish between values with key`                                   | should distinguish between values with key                                  | `spec/operators/distinctUntilKeyChanged-spec.ts:53`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:65:distinctUntilKeyChanged > should not compare if source does not have element with key`                  | should not compare if source does not have element with key                 | `spec/operators/distinctUntilKeyChanged-spec.ts:65`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:77:distinctUntilKeyChanged > should not complete if source never completes`                                | should not complete if source never completes                               | `spec/operators/distinctUntilKeyChanged-spec.ts:77`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:88:distinctUntilKeyChanged > should not complete if source does not complete`                              | should not complete if source does not complete                             | `spec/operators/distinctUntilKeyChanged-spec.ts:88`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/distinctUntilKeyChanged-spec.ts:99:distinctUntilKeyChanged > should complete if source is empty`                                           | should complete if source is empty                                          | `spec/operators/distinctUntilKeyChanged-spec.ts:99`  | —            | `portable`     | `active`    | Missing operator capability: distinctUntilKeyChanged                                                 | `FIXED` |

### `elementAt`

Owner source: `spec/operators/elementAt-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/elementAt-spec.ts:103:elementAt > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/operators/elementAt-spec.ts:103` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/elementAt-spec.ts:117:elementAt > should not break unsubscription chains when result Observable is unsubscribed` | should not break unsubscription chains when result Observable is unsubscribed | `spec/operators/elementAt-spec.ts:117` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/elementAt-spec.ts:141:elementAt > should raise error if index is out of range but does not have default value`   | should raise error if index is out of range but does not have default value   | `spec/operators/elementAt-spec.ts:141` | —            | `portable`     | `active`    | ArgumentOutOfRangeError is not a constructor                                                         | `FIXED` |
| `spec/operators/elementAt-spec.ts:152:elementAt > should return default value if index is out of range`                          | should return default value if index is out of range                          | `spec/operators/elementAt-spec.ts:152` | —            | `portable`     | `active`    | Unsupported RxJS 7 elementAt(index, defaultValue) overload.                                          | `FIXED` |
| `spec/operators/elementAt-spec.ts:37:elementAt > should allow undefined as a default value`                                      | should allow undefined as a default value                                     | `spec/operators/elementAt-spec.ts:37`  | —            | `portable`     | `active`    | Unsupported RxJS 7 elementAt(index, defaultValue) overload.                                          | `FIXED` |
| `spec/operators/elementAt-spec.ts:70:elementAt > should raise error if e1 is Empty Observable`                                   | should raise error if e1 is Empty Observable                                  | `spec/operators/elementAt-spec.ts:70`  | —            | `portable`     | `active`    | ArgumentOutOfRangeError is not a constructor                                                         | `FIXED` |
| `spec/operators/elementAt-spec.ts:92:elementAt > should not complete if source never completes`                                  | should not complete if source never completes                                 | `spec/operators/elementAt-spec.ts:92`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `endWith`

Owner source: `spec/operators/endWith-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                               | Source                               | Failing mode | Classification    | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------ | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/endWith-spec.ts:105:endWith > should end with given values when given more than one value`                   | should end with given values when given more than one value                   | `spec/operators/endWith-spec.ts:105` | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/endWith-spec.ts:138:endWith > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/endWith-spec.ts:138` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/endWith-spec.ts:152:endWith > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/endWith-spec.ts:152` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/endWith-spec.ts:16:endWith > should append to a cold Observable`                                             | should append to a cold Observable                                            | `spec/operators/endWith-spec.ts:16`  | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/endWith-spec.ts:170:endWith > should end with empty if given value is not specified`                         | should end with empty if given value is not specified                         | `spec/operators/endWith-spec.ts:170` | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/endWith-spec.ts:181:endWith > should accept scheduler as last argument with single value`                    | should accept scheduler as last argument with single value                    | `spec/operators/endWith-spec.ts:181` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/endWith-spec.ts:192:endWith > should accept scheduler as last argument with multiple value`                  | should accept scheduler as last argument with multiple value                  | `spec/operators/endWith-spec.ts:192` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                         | `FIXED` |
| `spec/operators/endWith-spec.ts:27:endWith > should append numbers to a cold Observable`                                     | should append numbers to a cold Observable                                    | `spec/operators/endWith-spec.ts:27`  | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/endWith-spec.ts:39:endWith > should end an observable with given value`                                      | should end an observable with given value                                     | `spec/operators/endWith-spec.ts:39`  | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/endWith-spec.ts:50:endWith > should not end with given value if source does not complete`                    | should not end with given value if source does not complete                   | `spec/operators/endWith-spec.ts:50`  | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/endWith-spec.ts:61:endWith > should not end with given value if source never emits and does not completes`   | should not end with given value if source never emits and does not completes  | `spec/operators/endWith-spec.ts:61`  | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/endWith-spec.ts:72:endWith > should end with given value if source does not emit but does complete`          | should end with given value if source does not emit but does complete         | `spec/operators/endWith-spec.ts:72`  | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/endWith-spec.ts:83:endWith > should emit given value and complete immediately if source is empty`            | should emit given value and complete immediately if source is empty           | `spec/operators/endWith-spec.ts:83`  | —            | `portable`        | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/endWith-spec.ts:94:endWith > should end with given value and source both if source emits single value`       | should end with given value and source both if source emits single value      | `spec/operators/endWith-spec.ts:94`  | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `every`

Owner source: `spec/operators/every-spec.ts`

| Case ID                                                                                                                         | Behavioral test                                                                      | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/every-spec.ts:103:every > should emit false if single source element does not match with predicate`             | should emit false if single source element does not match with predicate             | `spec/operators/every-spec.ts:103` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:114:every > should emit false if none of elements match with predicate`                           | should emit false if none of elements match with predicate                           | `spec/operators/every-spec.ts:114` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:125:every > should return false if only some of elements matches with predicate`                  | should return false if only some of elements matches with predicate                  | `spec/operators/every-spec.ts:125` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:137:every > should allow unsubscribing early and explicitly`                                      | should allow unsubscribing early and explicitly                                      | `spec/operators/every-spec.ts:137` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:152:every > should not break unsubscription chains when result observable is unsubscribed`        | should not break unsubscription chains when result observable is unsubscribed        | `spec/operators/every-spec.ts:152` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:171:every > should propagate error if predicate eventually throws`                                | should propagate error if predicate eventually throws                                | `spec/operators/every-spec.ts:171` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:190:every > should emit true if single source element matches with predicate`                     | should emit true if single source element matches with predicate                     | `spec/operators/every-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:202:every > should emit true if scalar source matches with predicate`                             | should emit true if scalar source matches with predicate                             | `spec/operators/every-spec.ts:202` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:211:every > should emit false if scalar source does not match with predicate`                     | should emit false if scalar source does not match with predicate                     | `spec/operators/every-spec.ts:211` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:220:every > should propagate error if predicate throws on scalar source`                          | should propagate error if predicate throws on scalar source                          | `spec/operators/every-spec.ts:220` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:23:every > should return false if only one of elements does not match with predicate`             | should return false if only one of elements does not match with predicate            | `spec/operators/every-spec.ts:23`  | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:233:every > should emit true if scalar array source matches with predicate`                       | should emit true if scalar array source matches with predicate                       | `spec/operators/every-spec.ts:233` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:242:every > should emit false if scalar array source does not match with predicate`               | should emit false if scalar array source does not match with predicate               | `spec/operators/every-spec.ts:242` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:251:every > should propagate error if predicate eventually throws on scalar array source`         | should propagate error if predicate eventually throws on scalar array source         | `spec/operators/every-spec.ts:251` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:267:every > should emit true if all source elements match with predicate`                         | should emit true if all source elements match with predicate                         | `spec/operators/every-spec.ts:267` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:279:every > should raise error if source raises error`                                            | should raise error if source raises error                                            | `spec/operators/every-spec.ts:279` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:290:every > should not complete if source never emits`                                            | should not complete if source never emits                                            | `spec/operators/every-spec.ts:290` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/every-spec.ts:301:every > should emit true if source element matches with predicate after subscription`         | should emit true if source element matches with predicate after subscription         | `spec/operators/every-spec.ts:301` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:313:every > should emit false if source element does not match with predicate after subscription` | should emit false if source element does not match with predicate after subscription | `spec/operators/every-spec.ts:313` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:325:every > should raise error if source raises error after subscription`                         | should raise error if source raises error after subscription                         | `spec/operators/every-spec.ts:325` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:336:every > should emit true if source does not emit after subscription`                          | should emit true if source does not emit after subscription                          | `spec/operators/every-spec.ts:336` | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |
| `spec/operators/every-spec.ts:92:every > should emit true if source is empty`                                                   | should emit true if source is empty                                                  | `spec/operators/every-spec.ts:92`  | —            | `portable`     | `active`    | Missing operator capability: every                                                                   | `FIXED` |

### `exhaustAll`

Owner source: `spec/operators/exhaustAll-spec.ts`

| Case ID                                                                                                                         | Behavioral test                                                               | Source                                  | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/exhaustAll-spec.ts:102:exhaust > should handle a hot observable of observables, outer is unsubscribed early`    | should handle a hot observable of observables, outer is unsubscribed early    | `spec/operators/exhaustAll-spec.ts:102` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:118:exhaust > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/exhaustAll-spec.ts:118` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:140:exhaust > should handle a hot observable of observables, inner never completes`          | should handle a hot observable of observables, inner never completes          | `spec/operators/exhaustAll-spec.ts:140` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:15:exhaust > should handle a hot observable of hot observables`                              | should handle a hot observable of hot observables                             | `spec/operators/exhaustAll-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:158:exhaust > should handle a synchronous switch and stay on the first inner observable`     | should handle a synchronous switch and stay on the first inner observable     | `spec/operators/exhaustAll-spec.ts:158` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:188:exhaust > should handle a hot observable of observables, outer throws`                   | should handle a hot observable of observables, outer throws                   | `spec/operators/exhaustAll-spec.ts:188` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:214:exhaust > should handle a never hot observable`                                          | should handle a never hot observable                                          | `spec/operators/exhaustAll-spec.ts:214` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:225:exhaust > should complete not before the outer completes`                                | should complete not before the outer completes                                | `spec/operators/exhaustAll-spec.ts:225` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:35:exhaust > should switch to first immediately-scheduled inner Observable`                  | should switch to first immediately-scheduled inner Observable                 | `spec/operators/exhaustAll-spec.ts:35`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:71:exhaust > should handle never`                                                            | should handle never                                                           | `spec/operators/exhaustAll-spec.ts:71`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustAll-spec.ts:82:exhaust > should handle a hot observable of observables`                                  | should handle a hot observable of observables                                 | `spec/operators/exhaustAll-spec.ts:82`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `exhaustMap`

Owner source: `spec/operators/exhaustMap-spec.ts`

| Case ID                                                                                                                                                | Behavioral test                                                                                   | Source                                  | Failing mode    | Classification       | Disposition        | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- | --------------------------------------- | --------------- | -------------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/exhaustMap-spec.ts:116:exhaustMap > should handle outer never`                                                                         | should handle outer never                                                                         | `spec/operators/exhaustMap-spec.ts:116` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:149:exhaustMap > should switch with a selector function`                                                            | should switch with a selector function                                                            | `spec/operators/exhaustMap-spec.ts:149` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:16:exhaustMap > should map-and-flatten each item to an Observable`                                                  | should map-and-flatten each item to an Observable                                                 | `spec/operators/exhaustMap-spec.ts:16`  | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:173:exhaustMap > should switch inner cold observables, outer is unsubscribed early`                                 | should switch inner cold observables, outer is unsubscribed early                                 | `spec/operators/exhaustMap-spec.ts:173` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:198:exhaustMap > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                     | `spec/operators/exhaustMap-spec.ts:198` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:227:exhaustMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly` | should not break unsubscription chains with interop inners when result is unsubscribed explicitly | `spec/operators/exhaustMap-spec.ts:227` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/operators/exhaustMap-spec.ts:291:exhaustMap > should switch inner cold observables, inner never completes`                                       | should switch inner cold observables, inner never completes                                       | `spec/operators/exhaustMap-spec.ts:291` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:315:exhaustMap > should handle a synchronous switch and stay on the first inner observable`                         | should handle a synchronous switch and stay on the first inner observable                         | `spec/operators/exhaustMap-spec.ts:315` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:336:exhaustMap > should switch inner cold observables, one inner throws`                                            | should switch inner cold observables, one inner throws                                            | `spec/operators/exhaustMap-spec.ts:336` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:357:exhaustMap > should switch inner hot observables`                                                               | should switch inner hot observables                                                               | `spec/operators/exhaustMap-spec.ts:357` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:381:exhaustMap > should switch inner empty and empty`                                                               | should switch inner empty and empty                                                               | `spec/operators/exhaustMap-spec.ts:381` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:402:exhaustMap > should switch inner empty and never`                                                               | should switch inner empty and never                                                               | `spec/operators/exhaustMap-spec.ts:402` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:423:exhaustMap > should never switch inner never`                                                                   | should never switch inner never                                                                   | `spec/operators/exhaustMap-spec.ts:423` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/exhaustMap-spec.ts:465:exhaustMap > should handle outer error`                                                                         | should handle outer error                                                                         | `spec/operators/exhaustMap-spec.ts:465` | —               | `portable`           | `active`           | rxTest subscriptions assertion failed.                                                               | `FIXED` |

### `expand`

Owner source: `spec/operators/expand-spec.ts`

| Case ID                                                                                                                     | Behavioral test                                                                | Source                              | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ----------------------------------- | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/expand-spec.ts:120:expand > should map and recursively flatten, and propagate error thrown from projection` | should map and recursively flatten, and propagate error thrown from projection | `spec/operators/expand-spec.ts:120` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:148:expand > should allow unsubscribing early`                                               | should allow unsubscribing early                                               | `spec/operators/expand-spec.ts:148` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:15:expand > should recursively map-and-flatten each item to an Observable`                   | should recursively map-and-flatten each item to an Observable                  | `spec/operators/expand-spec.ts:15`  | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:177:expand > should not break unsubscription chains when result is unsubscribed explicitly`  | should not break unsubscription chains when result is unsubscribed explicitly  | `spec/operators/expand-spec.ts:177` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:208:expand > should allow concurrent expansions`                                             | should allow concurrent expansions                                             | `spec/operators/expand-spec.ts:208` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:236:expand > should allow configuring the concurrency limit parameter to 1`                  | should allow configuring the concurrency limit parameter to 1                  | `spec/operators/expand-spec.ts:236` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:278:expand > should allow configuring the concurrency limit parameter to 2`                  | should allow configuring the concurrency limit parameter to 2                  | `spec/operators/expand-spec.ts:278` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:315:expand > should ignore concurrency limit if it is not passed`                            | should ignore concurrency limit if it is not passed                            | `spec/operators/expand-spec.ts:315` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:32:expand > should work with scheduler`                                                      | should work with scheduler                                                     | `spec/operators/expand-spec.ts:32`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined        | `FIXED` |
| `spec/operators/expand-spec.ts:349:expand > should map and recursively flatten with scalars`                                | should map and recursively flatten with scalars                                | `spec/operators/expand-spec.ts:349` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:451:expand > should work when passing undefined for the optional arguments`                  | should work when passing undefined for the optional arguments                  | `spec/operators/expand-spec.ts:451` | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:49:expand > should map and recursively flatten`                                              | should map and recursively flatten                                             | `spec/operators/expand-spec.ts:49`  | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |
| `spec/operators/expand-spec.ts:92:expand > should map and recursively flatten, and handle event raised error`               | should map and recursively flatten, and handle event raised error              | `spec/operators/expand-spec.ts:92`  | —            | `portable`        | `active`    | Missing operator capability: expand | `FIXED` |

### `filter`

Owner source: `spec/operators/filter-spec.ts`

| Case ID                                                                                                                           | Behavioral test                                                                      | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/filter-spec.ts:107:filter > should filter in only prime numbers, but predicate throws`                            | should filter in only prime numbers, but predicate throws                            | `spec/operators/filter-spec.ts:107` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:127:filter > should filter in only prime numbers, predicate with index`                            | should filter in only prime numbers, predicate with index                            | `spec/operators/filter-spec.ts:127` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:142:filter > should invoke predicate once for each checked value`                                  | should invoke predicate once for each checked value                                  | `spec/operators/filter-spec.ts:142` | —            | `portable`     | `active`    | Missing operator capability: tap                                                                     | `FIXED` |
| `spec/operators/filter-spec.ts:168:filter > should filter in only prime numbers, predicate with index, source unsubscribes early` | should filter in only prime numbers, predicate with index, source unsubscribes early | `spec/operators/filter-spec.ts:168` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:184:filter > should filter in only prime numbers, predicate with index, source throws`             | should filter in only prime numbers, predicate with index, source throws             | `spec/operators/filter-spec.ts:184` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:199:filter > should filter in only prime numbers, predicate with index and throws`                 | should filter in only prime numbers, predicate with index and throws                 | `spec/operators/filter-spec.ts:199` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:219:filter > should compose with another filter to allow multiples of six`                         | should compose with another filter to allow multiples of six                         | `spec/operators/filter-spec.ts:219` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:235:filter > should be able to accept and use a thisArg`                                           | should be able to accept and use a thisArg                                           | `spec/operators/filter-spec.ts:235` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:265:filter > should be able to use filter and map composed`                                        | should be able to use filter and map composed                                        | `spec/operators/filter-spec.ts:265` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:282:filter > should propagate errors from the source`                                              | should propagate errors from the source                                              | `spec/operators/filter-spec.ts:282` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:293:filter > should handle empty`                                                                  | should handle empty                                                                  | `spec/operators/filter-spec.ts:293` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:304:filter > should handle never`                                                                  | should handle never                                                                  | `spec/operators/filter-spec.ts:304` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/filter-spec.ts:315:filter > should handle throw`                                                                  | should handle throw                                                                  | `spec/operators/filter-spec.ts:315` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:32:filter > should filter out even values`                                                         | should filter out even values                                                        | `spec/operators/filter-spec.ts:32`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:347:filter > should not break unsubscription chain when unsubscribed explicitly`                   | should not break unsubscription chain when unsubscribed explicitly                   | `spec/operators/filter-spec.ts:347` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:425:filter > should support Boolean as a predicate`                                                | should support Boolean as a predicate                                                | `spec/operators/filter-spec.ts:425` | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:43:filter > should filter in only prime numbers`                                                   | should filter in only prime numbers                                                  | `spec/operators/filter-spec.ts:43`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:54:filter > should filter with an always-true predicate`                                           | should filter with an always-true predicate                                          | `spec/operators/filter-spec.ts:54`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:69:filter > should filter with an always-false predicate`                                          | should filter with an always-false predicate                                         | `spec/operators/filter-spec.ts:69`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:84:filter > should filter in only prime numbers, source unsubscribes early`                        | should filter in only prime numbers, source unsubscribes early                       | `spec/operators/filter-spec.ts:84`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |
| `spec/operators/filter-spec.ts:96:filter > should filter in only prime numbers, source throws`                                    | should filter in only prime numbers, source throws                                   | `spec/operators/filter-spec.ts:96`  | —            | `portable`     | `active`    | Missing operator capability: filter                                                                  | `FIXED` |

### `finalize`

Owner source: `spec/operators/finalize-spec.ts`

| Case ID                                                                              | Behavioral test                     | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------ | ----------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/finalize-spec.ts:116:finalize > should handle throw`                 | should handle throw                 | `spec/operators/finalize-spec.ts:116` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:135:finalize > should handle basic hot observable`  | should handle basic hot observable  | `spec/operators/finalize-spec.ts:135` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:154:finalize > should handle basic cold observable` | should handle basic cold observable | `spec/operators/finalize-spec.ts:154` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:173:finalize > should handle basic error`           | should handle basic error           | `spec/operators/finalize-spec.ts:173` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:192:finalize > should handle unsubscription`        | should handle unsubscription        | `spec/operators/finalize-spec.ts:192` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:78:finalize > should handle empty`                  | should handle empty                 | `spec/operators/finalize-spec.ts:78`  | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/finalize-spec.ts:97:finalize > should handle never`                  | should handle never                 | `spec/operators/finalize-spec.ts:97`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `find`

Owner source: `spec/operators/find-spec.ts`

| Case ID                                                                                                                 | Behavioral test                                                                | Source                            | Failing mode | Classification | Disposition | Concise failure                    | Status  |
| ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | --------------------------------- | ------------ | -------------- | ----------- | ---------------------------------- | ------- |
| `spec/operators/find-spec.ts:107:find > should return undefined if element does not match with predicate`               | should return undefined if element does not match with predicate               | `spec/operators/find-spec.ts:107` | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:122:find > should allow unsubscribing early and explicitly`                                | should allow unsubscribing early and explicitly                                | `spec/operators/find-spec.ts:122` | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:136:find > should not break unsubscription chains when result is unsubscribed explicitly`  | should not break unsubscription chains when result is unsubscribed explicitly  | `spec/operators/find-spec.ts:136` | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:154:find > should unsubscribe when the predicate is matched`                               | should unsubscribe when the predicate is matched                               | `spec/operators/find-spec.ts:154` | —            | `portable`     | `active`    | Missing operator capability: delay | `FIXED` |
| `spec/operators/find-spec.ts:172:find > should raise if source raise error while element does not match with predicate` | should raise if source raise error while element does not match with predicate | `spec/operators/find-spec.ts:172` | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:187:find > should raise error if predicate throws error`                                   | should raise error if predicate throws error                                   | `spec/operators/find-spec.ts:187` | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:19:find > should return matching element from source emits single element`                 | should return matching element from source emits single element                | `spec/operators/find-spec.ts:19`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:35:find > should not emit if source does not emit`                                         | should not emit if source does not emit                                        | `spec/operators/find-spec.ts:35`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:46:find > should return undefined if source is empty to match predicate`                   | should return undefined if source is empty to match predicate                  | `spec/operators/find-spec.ts:46`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:59:find > should return matching element from source emits single element`                 | should return matching element from source emits single element                | `spec/operators/find-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:74:find > should return matching element from source emits multiple elements`              | should return matching element from source emits multiple elements             | `spec/operators/find-spec.ts:74`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |
| `spec/operators/find-spec.ts:89:find > should work with a custom thisArg`                                               | should work with a custom thisArg                                              | `spec/operators/find-spec.ts:89`  | —            | `portable`     | `active`    | Missing operator capability: find  | `FIXED` |

### `findIndex`

Owner source: `spec/operators/findIndex-spec.ts`

| Case ID                                                                                                                           | Behavioral test                                                                | Source                                 | Failing mode | Classification | Disposition | Concise failure                        | Status  |
| --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------- | ------------ | -------------- | ----------- | -------------------------------------- | ------- |
| `spec/operators/findIndex-spec.ts:106:findIndex > should return negative index if element does not match with predicate`          | should return negative index if element does not match with predicate          | `spec/operators/findIndex-spec.ts:106` | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:121:findIndex > should allow unsubscribing early and explicitly`                                | should allow unsubscribing early and explicitly                                | `spec/operators/findIndex-spec.ts:121` | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:135:findIndex > should not break unsubscription chains when result is unsubscribed explicitly`  | should not break unsubscription chains when result is unsubscribed explicitly  | `spec/operators/findIndex-spec.ts:135` | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:153:findIndex > should unsubscribe when the predicate is matched`                               | should unsubscribe when the predicate is matched                               | `spec/operators/findIndex-spec.ts:153` | —            | `portable`     | `active`    | Missing operator capability: delay     | `FIXED` |
| `spec/operators/findIndex-spec.ts:171:findIndex > should raise if source raise error while element does not match with predicate` | should raise if source raise error while element does not match with predicate | `spec/operators/findIndex-spec.ts:171` | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:186:findIndex > should raise error if predicate throws error`                                   | should raise error if predicate throws error                                   | `spec/operators/findIndex-spec.ts:186` | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:19:findIndex > should return matching element from source emits single element`                 | should return matching element from source emits single element                | `spec/operators/findIndex-spec.ts:19`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:35:findIndex > should not emit if source does not emit`                                         | should not emit if source does not emit                                        | `spec/operators/findIndex-spec.ts:35`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:46:findIndex > should return negative index if source is empty to match predicate`              | should return negative index if source is empty to match predicate             | `spec/operators/findIndex-spec.ts:46`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:59:findIndex > should return index of element from source emits single element`                 | should return index of element from source emits single element                | `spec/operators/findIndex-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:74:findIndex > should return index of matching element from source emits multiple elements`     | should return index of matching element from source emits multiple elements    | `spec/operators/findIndex-spec.ts:74`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |
| `spec/operators/findIndex-spec.ts:89:findIndex > should work with a custom thisArg`                                               | should work with a custom thisArg                                              | `spec/operators/findIndex-spec.ts:89`  | —            | `portable`     | `active`    | Missing operator capability: findIndex | `FIXED` |

### `first`

Owner source: `spec/operators/first-spec.ts`

| Case ID                                                                                                                  | Behavioral test                                                               | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/first-spec.ts:106:first > should allow unsubscribing early and explicitly`                               | should allow unsubscribing early and explicitly                               | `spec/operators/first-spec.ts:106` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/first-spec.ts:118:first > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/first-spec.ts:118` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/first-spec.ts:136:first > should unsubscribe when the first value is received`                           | should unsubscribe when the first value is received                           | `spec/operators/first-spec.ts:136` | —            | `portable`     | `active`    | Missing operator capability: delay                                                                   | `FIXED` |
| `spec/operators/first-spec.ts:150:first > should return first value that matches a predicate`                            | should return first value that matches a predicate                            | `spec/operators/first-spec.ts:150` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:161:first > should return first value that matches a predicate for odd numbers`            | should return first value that matches a predicate for odd numbers            | `spec/operators/first-spec.ts:161` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:173:first > should error when no value matches the predicate`                              | should error when no value matches the predicate                              | `spec/operators/first-spec.ts:173` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:184:first > should return the default value when no value matches the predicate`           | should return the default value when no value matches the predicate           | `spec/operators/first-spec.ts:184` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:195:first > should propagate error when no value matches the predicate`                    | should propagate error when no value matches the predicate                    | `spec/operators/first-spec.ts:195` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:206:first > should return first value that matches the index in the predicate`             | should return first value that matches the index in the predicate             | `spec/operators/first-spec.ts:206` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:217:first > should propagate error from predicate`                                         | should propagate error from predicate                                         | `spec/operators/first-spec.ts:217` | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:37:first > should allow undefined as a default value`                                      | should allow undefined as a default value                                     | `spec/operators/first-spec.ts:37`  | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:48:first > should error on empty`                                                          | should error on empty                                                         | `spec/operators/first-spec.ts:48`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/first-spec.ts:59:first > should return the default value if source observable was empty`                 | should return the default value if source observable was empty                | `spec/operators/first-spec.ts:59`  | —            | `portable`     | `active`    | Unsupported RxJS 7 first predicate/default-value overload.                                           | `FIXED` |
| `spec/operators/first-spec.ts:95:first > should go on forever on never`                                                  | should go on forever on never                                                 | `spec/operators/first-spec.ts:95`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `forkJoin`

Owner source: `spec/observables/forkJoin-spec.ts`

| Case ID                                                                                                                                                                            | Behavioral test                                                                            | Source                                  | Failing mode    | Classification       | Disposition        | Concise failure                     | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | --------------------------------------- | --------------- | -------------------- | ------------------ | ----------------------------------- | ------- |
| `spec/observables/forkJoin-spec.ts:108:forkJoin > forkJoin([input1, input2, input3]) > should accept lowercase-o observables`                                                      | should accept lowercase-o observables                                                      | `spec/observables/forkJoin-spec.ts:108` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed. | `TODO`  |
| `spec/observables/forkJoin-spec.ts:120:forkJoin > forkJoin([input1, input2, input3]) > should accept empty lowercase-o observables`                                                | should accept empty lowercase-o observables                                                | `spec/observables/forkJoin-spec.ts:120` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed. | `TODO`  |
| `spec/observables/forkJoin-spec.ts:143:forkJoin > forkJoin([input1, input2, input3]) > should accept array of observables`                                                         | should accept array of observables                                                         | `spec/observables/forkJoin-spec.ts:143` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:155:forkJoin > forkJoin([input1, input2, input3]) > should not emit if any of source observable is empty`                                       | should not emit if any of source observable is empty                                       | `spec/observables/forkJoin-spec.ts:155` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:16:forkJoin > should join the last values of the provided observables into an array`                                                            | should join the last values of the provided observables into an array                      | `spec/observables/forkJoin-spec.ts:16`  | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:167:forkJoin > forkJoin([input1, input2, input3]) > should complete early if any of source is empty and completes before than others`           | should complete early if any of source is empty and completes before than others           | `spec/observables/forkJoin-spec.ts:167` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:179:forkJoin > forkJoin([input1, input2, input3]) > should complete when all sources are empty`                                                 | should complete when all sources are empty                                                 | `spec/observables/forkJoin-spec.ts:179` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:190:forkJoin > forkJoin([input1, input2, input3]) > should not complete when only source never completes`                                       | should not complete when only source never completes                                       | `spec/observables/forkJoin-spec.ts:190` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:199:forkJoin > forkJoin([input1, input2, input3]) > should not complete when one of the sources never completes`                                | should not complete when one of the sources never completes                                | `spec/observables/forkJoin-spec.ts:199` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:210:forkJoin > forkJoin([input1, input2, input3]) > should complete when one of the sources never completes but other completes without values` | should complete when one of the sources never completes but other completes without values | `spec/observables/forkJoin-spec.ts:210` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:221:forkJoin > forkJoin([input1, input2, input3]) > should complete if source is not provided`                                                  | should complete if source is not provided                                                  | `spec/observables/forkJoin-spec.ts:221` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:230:forkJoin > forkJoin([input1, input2, input3]) > should complete if sources list is empty`                                                   | should complete if sources list is empty                                                   | `spec/observables/forkJoin-spec.ts:230` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:239:forkJoin > forkJoin([input1, input2, input3]) > should raise error when any of source raises error with empty observable`                   | should raise error when any of source raises error with empty observable                   | `spec/observables/forkJoin-spec.ts:239` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:250:forkJoin > forkJoin([input1, input2, input3]) > should raise error when any of source raises error with source that never completes`        | should raise error when any of source raises error with source that never completes        | `spec/observables/forkJoin-spec.ts:250` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:261:forkJoin > forkJoin([input1, input2, input3]) > should raise error when source raises error`                                                | should raise error when source raises error                                                | `spec/observables/forkJoin-spec.ts:261` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:272:forkJoin > forkJoin([input1, input2, input3]) > should allow unsubscribing early and explicitly`                                            | should allow unsubscribing early and explicitly                                            | `spec/observables/forkJoin-spec.ts:272` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:289:forkJoin > forkJoin([input1, input2, input3]) > should unsubscribe other Observables, when one of them errors`                              | should unsubscribe other Observables, when one of them errors                              | `spec/observables/forkJoin-spec.ts:289` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:323:forkJoin > forkJoin({ foo, bar, baz }) > should join the last values of the provided observables into an array`                             | should join the last values of the provided observables into an array                      | `spec/observables/forkJoin-spec.ts:323` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:336:forkJoin > forkJoin({ foo, bar, baz }) > should allow emit null or undefined`                                                               | should allow emit null or undefined                                                        | `spec/observables/forkJoin-spec.ts:336` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:350:forkJoin > forkJoin({ foo, bar, baz }) > should accept array of observable contains single`                                                 | should accept array of observable contains single                                          | `spec/observables/forkJoin-spec.ts:350` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:361:forkJoin > forkJoin({ foo, bar, baz }) > should accept lowercase-o observables`                                                             | should accept lowercase-o observables                                                      | `spec/observables/forkJoin-spec.ts:361` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed. | `TODO`  |
| `spec/observables/forkJoin-spec.ts:374:forkJoin > forkJoin({ foo, bar, baz }) > should accept empty lowercase-o observables`                                                       | should accept empty lowercase-o observables                                                | `spec/observables/forkJoin-spec.ts:374` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed. | `TODO`  |
| `spec/observables/forkJoin-spec.ts:399:forkJoin > forkJoin({ foo, bar, baz }) > should accept an object of observables`                                                            | should accept an object of observables                                                     | `spec/observables/forkJoin-spec.ts:399` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:412:forkJoin > forkJoin({ foo, bar, baz }) > should not emit if any of source observable is empty`                                              | should not emit if any of source observable is empty                                       | `spec/observables/forkJoin-spec.ts:412` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:426:forkJoin > forkJoin({ foo, bar, baz }) > should complete early if any of source is empty and completes before than others`                  | should complete early if any of source is empty and completes before than others           | `spec/observables/forkJoin-spec.ts:426` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:439:forkJoin > forkJoin({ foo, bar, baz }) > should complete when all sources are empty`                                                        | should complete when all sources are empty                                                 | `spec/observables/forkJoin-spec.ts:439` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:451:forkJoin > forkJoin({ foo, bar, baz }) > should not complete when only source never completes`                                              | should not complete when only source never completes                                       | `spec/observables/forkJoin-spec.ts:451` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:462:forkJoin > forkJoin({ foo, bar, baz }) > should not complete when one of the sources never completes`                                       | should not complete when one of the sources never completes                                | `spec/observables/forkJoin-spec.ts:462` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:474:forkJoin > forkJoin({ foo, bar, baz }) > should complete when one of the sources never completes but other completes without values`        | should complete when one of the sources never completes but other completes without values | `spec/observables/forkJoin-spec.ts:474` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:502:forkJoin > forkJoin({ foo, bar, baz }) > should complete if sources object is empty`                                                        | should complete if sources object is empty                                                 | `spec/observables/forkJoin-spec.ts:502` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:511:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when any of source raises error with empty observable`                          | should raise error when any of source raises error with empty observable                   | `spec/observables/forkJoin-spec.ts:511` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:523:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when any of source raises error with source that never completes`               | should raise error when any of source raises error with source that never completes        | `spec/observables/forkJoin-spec.ts:523` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:535:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when source raises error`                                                       | should raise error when source raises error                                                | `spec/observables/forkJoin-spec.ts:535` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:547:forkJoin > forkJoin({ foo, bar, baz }) > should allow unsubscribing early and explicitly`                                                   | should allow unsubscribing early and explicitly                                            | `spec/observables/forkJoin-spec.ts:547` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:567:forkJoin > forkJoin({ foo, bar, baz }) > should unsubscribe other Observables, when one of them errors`                                     | should unsubscribe other Observables, when one of them errors                              | `spec/observables/forkJoin-spec.ts:567` | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:62:forkJoin > should accept single observable`                                                                                                  | should accept single observable                                                            | `spec/observables/forkJoin-spec.ts:62`  | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:72:forkJoin > forkJoin([input1, input2, input3]) > should join the last values of the provided observables into an array`                       | should join the last values of the provided observables into an array                      | `spec/observables/forkJoin-spec.ts:72`  | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:84:forkJoin > forkJoin([input1, input2, input3]) > should allow emit null or undefined`                                                         | should allow emit null or undefined                                                        | `spec/observables/forkJoin-spec.ts:84`  | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |
| `spec/observables/forkJoin-spec.ts:98:forkJoin > forkJoin([input1, input2, input3]) > should accept array of observable contains single`                                           | should accept array of observable contains single                                          | `spec/observables/forkJoin-spec.ts:98`  | —               | `portable`           | `active`           | forkJoin is not a function          | `FIXED` |

### `from`

Owner source: `spec/observables/from-spec.ts`

| Case ID                                                                             | Behavioral test                           | Source                             | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| ----------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------------------- | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/from-spec.ts:21:from > should create an observable from an array` | should create an observable from an array | `spec/observables/from-spec.ts:21` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |

### `fromEvent`

Owner source: `spec/observables/fromEvent-spec.ts`

| Case ID                                                                                                 | Behavioral test                                     | Source                                  | Failing mode | Classification    | Disposition | Concise failure                                                                    | Status  |
| ------------------------------------------------------------------------------------------------------- | --------------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------- | ------- |
| `spec/observables/fromEvent-spec.ts:16:fromEvent > should create an observable of click on the element` | should create an observable of click on the element | `spec/observables/fromEvent-spec.ts:16` | —            | `harness-rewrite` | `active`    | Unsupported RxJS 7 fromEvent target: the platform mapping requires an EventTarget. | `FIXED` |

### `fromEventPattern`

Owner source: `spec/observables/fromEventPattern-spec.ts`

| Case ID                                                                                                            | Behavioral test                                  | Source                                         | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------ | ---------------------------------------------- | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/fromEventPattern-spec.ts:18:fromEventPattern > should create an observable from the handler API` | should create an observable from the handler API | `spec/observables/fromEventPattern-spec.ts:18` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |

### `generate`

Owner source: `spec/observables/generate-spec.ts`

| Case ID                                                                                                                        | Behavioral test                                                             | Source                                  | Failing mode | Classification    | Disposition | Concise failure                | Status  |
| ------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ----------- | ------------------------------ | ------- |
| `spec/observables/generate-spec.ts:103:generate > should accept a scheduler`                                                   | should accept a scheduler                                                   | `spec/observables/generate-spec.ts:103` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/observables/generate-spec.ts:125:generate > should allow minimal possible options`                                       | should allow minimal possible options                                       | `spec/observables/generate-spec.ts:125` | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:137:generate > should emit error if result selector throws`                                 | should emit error if result selector throws                                 | `spec/observables/generate-spec.ts:137` | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:150:generate > should emit error if result selector throws on scheduler`                    | should emit error if result selector throws on scheduler                    | `spec/observables/generate-spec.ts:150` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/observables/generate-spec.ts:164:generate > should emit error after first value if iterate function throws`              | should emit error after first value if iterate function throws              | `spec/observables/generate-spec.ts:164` | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:176:generate > should emit error after first value if iterate function throws on scheduler` | should emit error after first value if iterate function throws on scheduler | `spec/observables/generate-spec.ts:176` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/observables/generate-spec.ts:189:generate > should emit error if condition function throws`                              | should emit error if condition function throws                              | `spec/observables/generate-spec.ts:189` | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:20:generate > should complete if condition does not meet`                                   | should complete if condition does not meet                                  | `spec/observables/generate-spec.ts:20`  | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:202:generate > should emit error if condition function throws on scheduler`                 | should emit error if condition function throws on scheduler                 | `spec/observables/generate-spec.ts:202` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/observables/generate-spec.ts:33:generate > should produce first value immediately`                                       | should produce first value immediately                                      | `spec/observables/generate-spec.ts:33`  | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:46:generate > should produce all values synchronously`                                      | should produce all values synchronously                                     | `spec/observables/generate-spec.ts:46`  | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:59:generate > should use result selector`                                                   | should use result selector                                                  | `spec/observables/generate-spec.ts:59`  | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |
| `spec/observables/generate-spec.ts:73:generate > should allow omit condition`                                                  | should allow omit condition                                                 | `spec/observables/generate-spec.ts:73`  | —            | `portable`        | `active`    | generate is not a function     | `FIXED` |

### `groupBy`

Owner source: `spec/operators/groupBy-spec.ts`

| Case ID                                                                                                                                                    | Behavioral test                                                                                   | Source                                | Failing mode | Classification    | Disposition        | Concise failure                                              | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------- | ------------ | ----------------- | ------------------ | ------------------------------------------------------------ | ------- |
| `spec/operators/groupBy-spec.ts:1005:groupBy operator > should allow using a durationSelector, but keySelector throws`                                     | should allow using a durationSelector, but keySelector throws                                     | `spec/operators/groupBy-spec.ts:1005` | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:1051:groupBy operator > should allow using a durationSelector, but elementSelector throws`                                 | should allow using a durationSelector, but elementSelector throws                                 | `spec/operators/groupBy-spec.ts:1051` | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:1097:groupBy operator > should allow using a durationSelector which eventually throws`                                     | should allow using a durationSelector which eventually throws                                     | `spec/operators/groupBy-spec.ts:1097` | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:1142:groupBy operator > should allow an inner to be unsubscribed early but other inners continue, with durationSelector`   | should allow an inner to be unsubscribed early but other inners continue, with durationSelector   | `spec/operators/groupBy-spec.ts:1142` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:1206:groupBy operator > should allow inners to be unsubscribed early at different times, with durationSelector`            | should allow inners to be unsubscribed early at different times, with durationSelector            | `spec/operators/groupBy-spec.ts:1206` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:1280:groupBy operator > should return inners that when subscribed late exhibit hot behavior`                               | should return inners that when subscribed late exhibit hot behavior                               | `spec/operators/groupBy-spec.ts:1280` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:1346:groupBy operator > should return inner group that when subscribed late emits complete()`                              | should return inner group that when subscribed late emits complete()                              | `spec/operators/groupBy-spec.ts:1346` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:1391:groupBy operator > should return inner group that when subscribed late emits error()`                                 | should return inner group that when subscribed late emits error()                                 | `spec/operators/groupBy-spec.ts:1391` | —            | `harness-rewrite` | `expected-failure` | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:1436:groupBy operator > should not error for late subscribed inners if outer is unsubscribed before inners are subscribed` | should not error for late subscribed inners if outer is unsubscribed before inners are subscribed | `spec/operators/groupBy-spec.ts:1436` | —            | `harness-rewrite` | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:147:groupBy operator > should handle an empty Observable`                                                                  | should handle an empty Observable                                                                 | `spec/operators/groupBy-spec.ts:147`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:16:groupBy operator > should group numbers by odd/even`                                                                    | should group numbers by odd/even                                                                  | `spec/operators/groupBy-spec.ts:16`   | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:160:groupBy operator > should handle a never Observable`                                                                   | should handle a never Observable                                                                  | `spec/operators/groupBy-spec.ts:160`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:173:groupBy operator > should handle a just-throw Observable`                                                              | should handle a just-throw Observable                                                             | `spec/operators/groupBy-spec.ts:173`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:186:groupBy operator > should handle an Observable with a single value`                                                    | should handle an Observable with a single value                                                   | `spec/operators/groupBy-spec.ts:186`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:202:groupBy operator > should group values with a keySelector`                                                             | should group values with a keySelector                                                            | `spec/operators/groupBy-spec.ts:202`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:234:groupBy operator > should emit GroupObservables`                                                                       | should emit GroupObservables                                                                      | `spec/operators/groupBy-spec.ts:234`  | cold         | `portable`        | `expected-failure` | rxTest observable assertion failed.                          | `TODO`  |
| `spec/operators/groupBy-spec.ts:261:groupBy operator > should group values with a keySelector, assert GroupSubject key`                                    | should group values with a keySelector, assert GroupSubject key                                   | `spec/operators/groupBy-spec.ts:261`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:292:groupBy operator > should group values with a keySelector, but outer throws`                                           | should group values with a keySelector, but outer throws                                          | `spec/operators/groupBy-spec.ts:292`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:323:groupBy operator > should group values with a keySelector, inners propagate error from outer`                          | should group values with a keySelector, inners propagate error from outer                         | `spec/operators/groupBy-spec.ts:323`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:355:groupBy operator > should allow outer to be unsubscribed early`                                                        | should allow outer to be unsubscribed early                                                       | `spec/operators/groupBy-spec.ts:355`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:387:groupBy operator > should unsubscribe from the source when the outer and inner subscriptions are disposed`             | should unsubscribe from the source when the outer and inner subscriptions are disposed            | `spec/operators/groupBy-spec.ts:387`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:418:groupBy operator > should not break unsubscription chain when unsubscribed explicitly`                                 | should not break unsubscription chain when unsubscribed explicitly                                | `spec/operators/groupBy-spec.ts:418`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:451:groupBy operator > should group values with a keySelector which eventually throws`                                     | should group values with a keySelector which eventually throws                                    | `spec/operators/groupBy-spec.ts:451`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:492:groupBy operator > should group values with a keySelector and elementSelector, but elementSelector throws`             | should group values with a keySelector and elementSelector, but elementSelector throws            | `spec/operators/groupBy-spec.ts:492`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:537:groupBy operator > should allow the outer to be unsubscribed early but inners continue`                                | should allow the outer to be unsubscribed early but inners continue                               | `spec/operators/groupBy-spec.ts:537`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:566:groupBy operator > should allow an inner to be unsubscribed early but other inners continue`                           | should allow an inner to be unsubscribed early but other inners continue                          | `spec/operators/groupBy-spec.ts:566`  | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:621:groupBy operator > should allow inners to be unsubscribed early at different times`                                    | should allow inners to be unsubscribed early at different times                                   | `spec/operators/groupBy-spec.ts:621`  | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:682:groupBy operator > should allow subscribing late to an inner Observable, outer completes`                              | should allow subscribing late to an inner Observable, outer completes                             | `spec/operators/groupBy-spec.ts:682`  | —            | `harness-rewrite` | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:705:groupBy operator > should allow subscribing late to an inner Observable, outer throws`                                 | should allow subscribing late to an inner Observable, outer throws                                | `spec/operators/groupBy-spec.ts:705`  | —            | `harness-rewrite` | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:733:groupBy operator > should allow subscribing late to inner, unsubscribe outer early`                                    | should allow subscribing late to inner, unsubscribe outer early                                   | `spec/operators/groupBy-spec.ts:733`  | —            | `harness-rewrite` | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:767:groupBy operator > should allow using a keySelector, elementSelector, and durationSelector`                            | should allow using a keySelector, elementSelector, and durationSelector                           | `spec/operators/groupBy-spec.ts:767`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:807:groupBy operator > should allow using a keySelector, elementSelector, and durationSelector that throws`                | should allow using a keySelector, elementSelector, and durationSelector that throws               | `spec/operators/groupBy-spec.ts:807`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:850:groupBy operator > should allow using a keySelector and a durationSelector, outer throws`                              | should allow using a keySelector and a durationSelector, outer throws                             | `spec/operators/groupBy-spec.ts:850`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:887:groupBy operator > should allow using a durationSelector, and outer unsubscribed early`                                | should allow using a durationSelector, and outer unsubscribed early                               | `spec/operators/groupBy-spec.ts:887`  | —            | `portable`        | `active`           | Missing operator capability: groupBy                         | `FIXED` |
| `spec/operators/groupBy-spec.ts:921:groupBy operator > should allow using a durationSelector, outer and all inners unsubscribed early`                     | should allow using a durationSelector, outer and all inners unsubscribed early                    | `spec/operators/groupBy-spec.ts:921`  | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'parseMarbles') | `FIXED` |
| `spec/operators/groupBy-spec.ts:974:groupBy operator > should dispose a durationSelector after closing the group`                                          | should dispose a durationSelector after closing the group                                         | `spec/operators/groupBy-spec.ts:974`  | —            | `portable`        | `active`           | time is not defined                                          | `FIXED` |

### `ignoreElements`

Owner source: `spec/operators/ignoreElements-spec.ts`

| Case ID                                                                                                                       | Behavioral test                                                   | Source                                     | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------ | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/ignoreElements-spec.ts:25:ignoreElements > should allow unsubscribing early and explicitly`                   | should allow unsubscribing early and explicitly                   | `spec/operators/ignoreElements-spec.ts:25` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/ignoreElements-spec.ts:39:ignoreElements > should allow unsubscribing early and explicitly with higher order` | should allow unsubscribing early and explicitly with higher order | `spec/operators/ignoreElements-spec.ts:39` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/ignoreElements-spec.ts:79:ignoreElements > should handle never`                                               | should handle never                                               | `spec/operators/ignoreElements-spec.ts:79` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `interval`

Owner source: `spec/observables/interval-spec.ts`

| Case ID                                                                                          | Behavioral test                                | Source                                 | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------ | ---------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/interval-spec.ts:17:interval > should set up an interval`                      | should set up an interval                      | `spec/observables/interval-spec.ts:17` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/observables/interval-spec.ts:32:interval > should emit when relative interval set to zero` | should emit when relative interval set to zero | `spec/observables/interval-spec.ts:32` | —            | `portable`     | `active`    | Missing operator capability: take   | `FIXED` |
| `spec/observables/interval-spec.ts:42:interval > should consider negative interval as zero`      | should consider negative interval as zero      | `spec/observables/interval-spec.ts:42` | —            | `portable`     | `active`    | Missing operator capability: take   | `FIXED` |

### `isEmpty`

Owner source: `spec/operators/isEmpty-spec.ts`

| Case ID                                                                                                                     | Behavioral test                                                               | Source                              | Failing mode | Classification | Disposition | Concise failure                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ------------------------------------ | ------- |
| `spec/operators/isEmpty-spec.ts:14:isEmpty > should return true if source is empty`                                         | should return true if source is empty                                         | `spec/operators/isEmpty-spec.ts:14` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:25:isEmpty > should return false if source emits element`                                   | should return false if source emits element                                   | `spec/operators/isEmpty-spec.ts:25` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:36:isEmpty > should raise error if source raises error`                                     | should raise error if source raises error                                     | `spec/operators/isEmpty-spec.ts:36` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:47:isEmpty > should not complete if source never emits`                                     | should not complete if source never emits                                     | `spec/operators/isEmpty-spec.ts:47` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:58:isEmpty > should return true if source is empty`                                         | should return true if source is empty                                         | `spec/operators/isEmpty-spec.ts:58` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:69:isEmpty > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/isEmpty-spec.ts:69` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |
| `spec/operators/isEmpty-spec.ts:81:isEmpty > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/isEmpty-spec.ts:81` | —            | `portable`     | `active`    | Missing operator capability: isEmpty | `FIXED` |

### `last`

Owner source: `spec/operators/last-spec.ts`

| Case ID                                                                                                               | Behavioral test                                                               | Source                            | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/last-spec.ts:110:last > should return a default value if no element found`                            | should return a default value if no element found                             | `spec/operators/last-spec.ts:110` | —            | `portable`     | `active`    | Unsupported RxJS 7 last predicate/default-value overload.                                            | `FIXED` |
| `spec/operators/last-spec.ts:121:last > should not return default value if an element is found`                       | should not return default value if an element is found                        | `spec/operators/last-spec.ts:121` | —            | `portable`     | `active`    | Unsupported RxJS 7 last predicate/default-value overload.                                            | `FIXED` |
| `spec/operators/last-spec.ts:132:last > should raise error when predicate throws`                                     | should raise error when predicate throws                                      | `spec/operators/last-spec.ts:132` | —            | `portable`     | `active`    | Unsupported RxJS 7 last predicate/default-value overload.                                            | `FIXED` |
| `spec/operators/last-spec.ts:25:last > should error on nothing sent but completed`                                    | should error on nothing sent but completed                                    | `spec/operators/last-spec.ts:25`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/last-spec.ts:36:last > should error on empty`                                                         | should error on empty                                                         | `spec/operators/last-spec.ts:36`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/last-spec.ts:47:last > should go on forever on never`                                                 | should go on forever on never                                                 | `spec/operators/last-spec.ts:47`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/last-spec.ts:58:last > should allow undefined as a default value`                                     | should allow undefined as a default value                                     | `spec/operators/last-spec.ts:58`  | —            | `portable`     | `active`    | Unsupported RxJS 7 last predicate/default-value overload.                                            | `FIXED` |
| `spec/operators/last-spec.ts:69:last > should return last element matches with predicate`                             | should return last element matches with predicate                             | `spec/operators/last-spec.ts:69`  | —            | `portable`     | `active`    | Unsupported RxJS 7 last predicate/default-value overload.                                            | `FIXED` |
| `spec/operators/last-spec.ts:80:last > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/last-spec.ts:80`  | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/last-spec.ts:92:last > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/last-spec.ts:92`  | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |

### `map`

Owner source: `spec/operators/map-spec.ts`

| Case ID                                                                                                   | Behavioral test                                                    | Source                           | Failing mode | Classification | Disposition | Concise failure                  | Status  |
| --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | -------------------------------- | ------------ | -------------- | ----------- | -------------------------------- | ------- |
| `spec/operators/map-spec.ts:103:map > should not map an empty observable`                                 | should not map an empty observable                                 | `spec/operators/map-spec.ts:103` | —            | `portable`     | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/operators/map-spec.ts:127:map > should allow unsubscribing explicitly and early`                    | should allow unsubscribing explicitly and early                    | `spec/operators/map-spec.ts:127` | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:141:map > should map with index`                                              | should map with index                                              | `spec/operators/map-spec.ts:141` | —            | `portable`     | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/operators/map-spec.ts:166:map > should map with index until completed`                              | should map with index until completed                              | `spec/operators/map-spec.ts:166` | —            | `portable`     | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/operators/map-spec.ts:18:map > should map multiple values`                                          | should map multiple values                                         | `spec/operators/map-spec.ts:18`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:191:map > should map with index until an error occurs`                        | should map with index until an error occurs                        | `spec/operators/map-spec.ts:191` | —            | `portable`     | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/operators/map-spec.ts:216:map > should map using a custom thisArg`                                  | should map using a custom thisArg                                  | `spec/operators/map-spec.ts:216` | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:238:map > should map twice`                                                   | should map twice                                                   | `spec/operators/map-spec.ts:238` | —            | `portable`     | `active`    | Missing operator capability: tap | `FIXED` |
| `spec/operators/map-spec.ts:269:map > should do multiple maps using a custom thisArg`                     | should do multiple maps using a custom thisArg                     | `spec/operators/map-spec.ts:269` | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:299:map > should not break unsubscription chain when unsubscribed explicitly` | should not break unsubscription chain when unsubscribed explicitly | `spec/operators/map-spec.ts:299` | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:31:map > should map one value`                                                | should map one value                                               | `spec/operators/map-spec.ts:31`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:45:map > should map multiple values`                                          | should map multiple values                                         | `spec/operators/map-spec.ts:45`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:58:map > should propagate errors from map function`                           | should propagate errors from map function                          | `spec/operators/map-spec.ts:58`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:76:map > should propagate errors from observable that emits only errors`      | should propagate errors from observable that emits only errors     | `spec/operators/map-spec.ts:76`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |
| `spec/operators/map-spec.ts:89:map > should propagate errors from observable that emit values`            | should propagate errors from observable that emit values           | `spec/operators/map-spec.ts:89`  | —            | `portable`     | `active`    | Missing operator capability: map | `FIXED` |

### `mapTo`

Owner source: `spec/operators/mapTo-spec.ts`

| Case ID                                                                                                      | Behavioral test                                                    | Source                            | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------ | --------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/mapTo-spec.ts:37:mapTo > should allow unsubscribing explicitly and early`                    | should allow unsubscribing explicitly and early                    | `spec/operators/mapTo-spec.ts:37` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/mapTo-spec.ts:99:mapTo > should not break unsubscription chain when unsubscribed explicitly` | should not break unsubscription chain when unsubscribed explicitly | `spec/operators/mapTo-spec.ts:99` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `materialize`

Owner source: `spec/operators/materialize-spec.ts`

| Case ID                                                                                                                             | Behavioral test                                                               | Source                                   | Failing mode | Classification | Disposition | Concise failure                                            | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------- | ------- |
| `spec/operators/materialize-spec.ts:114:materialize > should materialize stream that does not complete`                             | should materialize stream that does not complete                              | `spec/operators/materialize-spec.ts:114` | —            | `portable`     | `active`    | Missing operator capability: materialize                   | `FIXED` |
| `spec/operators/materialize-spec.ts:125:materialize > should materialize stream that does not emit`                                 | should materialize stream that does not emit                                  | `spec/operators/materialize-spec.ts:125` | —            | `portable`     | `active`    | Missing operator capability: materialize                   | `FIXED` |
| `spec/operators/materialize-spec.ts:136:materialize > should materialize empty stream`                                              | should materialize empty stream                                               | `spec/operators/materialize-spec.ts:136` | —            | `portable`     | `active`    | Missing operator capability: materialize                   | `FIXED` |
| `spec/operators/materialize-spec.ts:147:materialize > should materialize stream that throws`                                        | should materialize stream that throws                                         | `spec/operators/materialize-spec.ts:147` | —            | `portable`     | `active`    | Missing operator capability: materialize                   | `FIXED` |
| `spec/operators/materialize-spec.ts:15:materialize > should materialize an Observable`                                              | should materialize an Observable                                              | `spec/operators/materialize-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: materialize                   | `FIXED` |
| `spec/operators/materialize-spec.ts:38:materialize > should materialize a happy stream`                                             | should materialize a happy stream                                             | `spec/operators/materialize-spec.ts:38`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext') | `FIXED` |
| `spec/operators/materialize-spec.ts:56:materialize > should materialize a sad stream`                                               | should materialize a sad stream                                               | `spec/operators/materialize-spec.ts:56`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext') | `FIXED` |
| `spec/operators/materialize-spec.ts:74:materialize > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/materialize-spec.ts:74`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext') | `FIXED` |
| `spec/operators/materialize-spec.ts:91:materialize > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/materialize-spec.ts:91`  | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext') | `FIXED` |

### `max`

Owner source: `spec/operators/max-spec.ts`

| Case ID                                                                                                              | Behavioral test                                                               | Source                           | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/max-spec.ts:104:max > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/max-spec.ts:104` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:15:max > should find the max of values of an observable`                                 | should find the max of values of an observable                                | `spec/operators/max-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:170:max > should work with error`                                                        | should work with error                                                        | `spec/operators/max-spec.ts:170` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:181:max > should work with throw`                                                        | should work with throw                                                        | `spec/operators/max-spec.ts:181` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:192:max > should handle a constant predicate on an empty hot observable`                 | should handle a constant predicate on an empty hot observable                 | `spec/operators/max-spec.ts:192` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:207:max > should handle a constant predicate on an never hot observable`                 | should handle a constant predicate on an never hot observable                 | `spec/operators/max-spec.ts:207` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/max-spec.ts:222:max > should handle a constant predicate on a simple hot observable`                 | should handle a constant predicate on a simple hot observable                 | `spec/operators/max-spec.ts:222` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:237:max > should handle a reverse predicate on observable with many values`              | should handle a reverse predicate on observable with many values              | `spec/operators/max-spec.ts:237` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:252:max > should handle a predicate for string on observable with many values`           | should handle a predicate for string on observable with many values           | `spec/operators/max-spec.ts:252` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:26:max > should be never when source is never`                                           | should be never when source is never                                          | `spec/operators/max-spec.ts:26`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/max-spec.ts:267:max > should handle a constant predicate on observable that throws`                  | should handle a constant predicate on observable that throws                  | `spec/operators/max-spec.ts:267` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:282:max > should handle a predicate that throws, on observable with many values`         | should handle a predicate that throws, on observable with many values         | `spec/operators/max-spec.ts:282` | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:37:max > should be zero when source is empty`                                            | should be zero when source is empty                                           | `spec/operators/max-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:48:max > should be never when source doesn't complete`                                   | should be never when source doesn't complete                                  | `spec/operators/max-spec.ts:48`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/max-spec.ts:59:max > should complete when source doesn't have values`                                | should complete when source doesn't have values                               | `spec/operators/max-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:70:max > should max the unique value of an observable`                                   | should max the unique value of an observable                                  | `spec/operators/max-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:81:max > should max the values of an ongoing hot observable`                             | should max the values of an ongoing hot observable                            | `spec/operators/max-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |
| `spec/operators/max-spec.ts:92:max > should allow unsubscribing explicitly and early`                                | should allow unsubscribing explicitly and early                               | `spec/operators/max-spec.ts:92`  | —            | `portable`     | `active`    | Missing operator capability: max                                                                     | `FIXED` |

### `merge`

Owner source: `spec/observables/merge-spec.ts`

| Case ID                                                                                                                         | Behavioral test                                     | Source                               | Failing mode    | Classification       | Disposition        | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- | ------------------------------------ | --------------- | -------------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/merge-spec.ts:123:static merge(...observables) > should merge never and empty`                                | should merge never and empty                        | `spec/observables/merge-spec.ts:123` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/merge-spec.ts:139:static merge(...observables) > should merge never and never`                                | should merge never and never                        | `spec/observables/merge-spec.ts:139` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/merge-spec.ts:251:static merge(...observables) > should merge single lowerCaseO into RxJS Observable`         | should merge single lowerCaseO into RxJS Observable | `spec/observables/merge-spec.ts:251` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/observables/merge-spec.ts:262:static merge(...observables) > should merge two lowerCaseO into RxJS Observable`            | should merge two lowerCaseO into RxJS Observable    | `spec/observables/merge-spec.ts:262` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/observables/merge-spec.ts:282:merge(...observables, Scheduler) > should merge single lowerCaseO into RxJS Observable`     | should merge single lowerCaseO into RxJS Observable | `spec/observables/merge-spec.ts:282` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/observables/merge-spec.ts:311:merge(...observables, Scheduler, number) > should handle scheduler`                         | should handle scheduler                             | `spec/observables/merge-spec.ts:311` | —               | `harness-rewrite`    | `active`           | Missing operator capability: delay                                                                   | `FIXED` |
| `spec/observables/merge-spec.ts:322:merge(...observables, Scheduler, number) > should handle scheduler with concurrency limits` | should handle scheduler with concurrency limits     | `spec/observables/merge-spec.ts:322` | —               | `harness-rewrite`    | `active`           | rxTestScheduler is not defined                                                                       | `FIXED` |

### `mergeAll`

Owner source: `spec/operators/mergeAll-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                                 | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/mergeAll-spec.ts:151:mergeAll > should handle merging a hot observable of observables, outer unsubscribed early` | should handle merging a hot observable of observables, outer unsubscribed early | `spec/operators/mergeAll-spec.ts:151` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/mergeAll-spec.ts:169:mergeAll > should not break unsubscription chains when result is unsubscribed explicitly`   | should not break unsubscription chains when result is unsubscribed explicitly   | `spec/operators/mergeAll-spec.ts:169` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/mergeAll-spec.ts:247:mergeAll > should merge never and empty`                                                    | should merge never and empty                                                    | `spec/operators/mergeAll-spec.ts:247` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/mergeAll-spec.ts:264:mergeAll > should merge never and never`                                                    | should merge never and never                                                    | `spec/operators/mergeAll-spec.ts:264` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/mergeAll-spec.ts:360:mergeAll > should take a never source and return never too`                                 | should take a never source and return never too                                 | `spec/operators/mergeAll-spec.ts:360` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `mergeMap`

Owner source: `spec/operators/mergeMap-spec.ts`

| Case ID                                                                                                                                            | Behavioral test                                                                                   | Source                                | Failing mode    | Classification           | Disposition        | Concise failure                                                                                                                                           | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------- | --------------- | ------------------------ | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/mergeMap-spec.ts:108:mergeMap > should mergeMap many regular interval inners`                                                      | should mergeMap many regular interval inners                                                      | `spec/operators/mergeMap-spec.ts:108` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:16:mergeMap > should map-and-flatten each item to an Observable`                                                  | should map-and-flatten each item to an Observable                                                 | `spec/operators/mergeMap-spec.ts:16`  | —               | `intentional-divergence` | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:208:mergeMap > should mergeMap many outer values to many inner values`                                            | should mergeMap many outer values to many inner values                                            | `spec/operators/mergeMap-spec.ts:208` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:232:mergeMap > should mergeMap many outer to many inner, complete late`                                           | should mergeMap many outer to many inner, complete late                                           | `spec/operators/mergeMap-spec.ts:232` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:256:mergeMap > should mergeMap many outer to many inner, outer never completes`                                   | should mergeMap many outer to many inner, outer never completes                                   | `spec/operators/mergeMap-spec.ts:256` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:285:mergeMap > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                     | `spec/operators/mergeMap-spec.ts:285` | —               | `intentional-divergence` | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:318:mergeMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly` | should not break unsubscription chains with interop inners when result is unsubscribed explicitly | `spec/operators/mergeMap-spec.ts:318` | cold + polyfill | `compatibility-only`     | `expected-failure` | rxTest observable assertion failed.                                                                                                                       | `TODO`  |
| `spec/operators/mergeMap-spec.ts:350:mergeMap > should mergeMap many outer to many inner, inner never completes`                                   | should mergeMap many outer to many inner, inner never completes                                   | `spec/operators/mergeMap-spec.ts:350` | —               | `portable`               | `active`           | cold: rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble.; polyfill: rxTest observable assertion failed. | `FIXED` |
| `spec/operators/mergeMap-spec.ts:374:mergeMap > should mergeMap many outer to many inner, and inner throws`                                        | should mergeMap many outer to many inner, and inner throws                                        | `spec/operators/mergeMap-spec.ts:374` | polyfill        | `portable`               | `active`           | error                                                                                                                                                     | `TODO`  |
| `spec/operators/mergeMap-spec.ts:398:mergeMap > should mergeMap many outer to many inner, and outer throws`                                        | should mergeMap many outer to many inner, and outer throws                                        | `spec/operators/mergeMap-spec.ts:398` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:422:mergeMap > should mergeMap many outer to many inner, both inner and outer throw`                              | should mergeMap many outer to many inner, both inner and outer throw                              | `spec/operators/mergeMap-spec.ts:422` | polyfill        | `portable`               | `active`           | error                                                                                                                                                     | `TODO`  |
| `spec/operators/mergeMap-spec.ts:467:mergeMap > should mergeMap to many cold Observable, with parameter concurrency=2`                             | should mergeMap to many cold Observable, with parameter concurrency=2                             | `spec/operators/mergeMap-spec.ts:467` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:574:mergeMap > should mergeMap many complex, all inners finite except one`                                        | should mergeMap many complex, all inners finite except one                                        | `spec/operators/mergeMap-spec.ts:574` | —               | `portable`               | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble.                                                      | `FIXED` |
| `spec/operators/mergeMap-spec.ts:610:mergeMap > should mergeMap many complex, inners finite, outer does not complete`                              | should mergeMap many complex, inners finite, outer does not complete                              | `spec/operators/mergeMap-spec.ts:610` | —               | `portable`               | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble.                                                      | `FIXED` |
| `spec/operators/mergeMap-spec.ts:718:mergeMap > should mergeMap many complex, all inners finite, outer is unsubscribed`                            | should mergeMap many complex, all inners finite, outer is unsubscribed                            | `spec/operators/mergeMap-spec.ts:718` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:805:mergeMap > should mergeMap many outer to an array for each value`                                             | should mergeMap many outer to an array for each value                                             | `spec/operators/mergeMap-spec.ts:805` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:818:mergeMap > should mergeMap many outer to inner arrays, and outer throws`                                      | should mergeMap many outer to inner arrays, and outer throws                                      | `spec/operators/mergeMap-spec.ts:818` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:831:mergeMap > should mergeMap many outer to inner arrays, outer gets unsubscribed`                               | should mergeMap many outer to inner arrays, outer gets unsubscribed                               | `spec/operators/mergeMap-spec.ts:831` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:845:mergeMap > should mergeMap many outer to inner arrays, project throws`                                        | should mergeMap many outer to inner arrays, project throws                                        | `spec/operators/mergeMap-spec.ts:845` | —               | `portable`               | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMap-spec.ts:975:mergeMap > should properly handle errors from iterables that are processed after some async`                  | should properly handle errors from iterables that are processed after some async                  | `spec/operators/mergeMap-spec.ts:975` | —               | `harness-rewrite`        | `active`           | rxTest observable assertion failed.                                                                                                                       | `FIXED` |

### `mergeMapTo`

Owner source: `spec/operators/mergeMapTo-spec.ts`

| Case ID                                                                                                                                              | Behavioral test                                                                                 | Source                                  | Failing mode | Classification           | Disposition | Concise failure                                                                                                                                           | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | ------------------------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/mergeMapTo-spec.ts:143:mergeMapTo > should mergeMapTo many outer values to many inner values`                                        | should mergeMapTo many outer values to many inner values                                        | `spec/operators/mergeMapTo-spec.ts:143` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:15:mergeMapTo > should map-and-flatten each item to an Observable`                                                | should map-and-flatten each item to an Observable                                               | `spec/operators/mergeMapTo-spec.ts:15`  | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:165:mergeMapTo > should mergeMapTo many outer to many inner, complete late`                                       | should mergeMapTo many outer to many inner, complete late                                       | `spec/operators/mergeMapTo-spec.ts:165` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:187:mergeMapTo > should mergeMapTo many outer to many inner, outer never completes`                               | should mergeMapTo many outer to many inner, outer never completes                               | `spec/operators/mergeMapTo-spec.ts:187` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:216:mergeMapTo > should not break unsubscription chains when result is unsubscribed explicitly`                   | should not break unsubscription chains when result is unsubscribed explicitly                   | `spec/operators/mergeMapTo-spec.ts:216` | —            | `intentional-divergence` | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:249:mergeMapTo > should mergeMapTo many outer to many inner, inner never completes`                               | should mergeMapTo many outer to many inner, inner never completes                               | `spec/operators/mergeMapTo-spec.ts:249` | —            | `portable`               | `active`    | cold: rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble.; polyfill: rxTest observable assertion failed. | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:271:mergeMapTo > should mergeMapTo many outer to many inner, and inner throws`                                    | should mergeMapTo many outer to many inner, and inner throws                                    | `spec/operators/mergeMapTo-spec.ts:271` | polyfill     | `portable`               | `active`    | error                                                                                                                                                     | `TODO`  |
| `spec/operators/mergeMapTo-spec.ts:292:mergeMapTo > should mergeMapTo many outer to many inner, and outer throws`                                    | should mergeMapTo many outer to many inner, and outer throws                                    | `spec/operators/mergeMapTo-spec.ts:292` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:314:mergeMapTo > should mergeMapTo many outer to many inner, both inner and outer throw`                          | should mergeMapTo many outer to many inner, both inner and outer throw                          | `spec/operators/mergeMapTo-spec.ts:314` | polyfill     | `portable`               | `active`    | error                                                                                                                                                     | `TODO`  |
| `spec/operators/mergeMapTo-spec.ts:356:mergeMapTo > should mergeMapTo to many cold Observable, with parameter concurrency=2, without resultSelector` | should mergeMapTo to many cold Observable, with parameter concurrency=2, without resultSelector | `spec/operators/mergeMapTo-spec.ts:356` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:378:mergeMapTo > should mergeMapTo many outer to arrays`                                                          | should mergeMapTo many outer to arrays                                                          | `spec/operators/mergeMapTo-spec.ts:378` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:391:mergeMapTo > should mergeMapTo many outer to inner arrays, and outer throws`                                  | should mergeMapTo many outer to inner arrays, and outer throws                                  | `spec/operators/mergeMapTo-spec.ts:391` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:404:mergeMapTo > should mergeMapTo many outer to inner arrays, outer gets unsubscribed`                           | should mergeMapTo many outer to inner arrays, outer gets unsubscribed                           | `spec/operators/mergeMapTo-spec.ts:404` | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/mergeMapTo-spec.ts:84:mergeMapTo > should mergeMapTo many regular interval inners`                                                   | should mergeMapTo many regular interval inners                                                  | `spec/operators/mergeMapTo-spec.ts:84`  | —            | `portable`               | `active`    | rxTest observable assertion failed.                                                                                                                       | `FIXED` |

### `mergeScan`

Owner source: `spec/operators/mergeScan-spec.ts`

| Case ID                                                                                                                                | Behavioral test                                                                     | Source                                 | Failing mode | Classification | Disposition | Concise failure                        | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | -------------------------------------- | ------- |
| `spec/operators/mergeScan-spec.ts:112:mergeScan > should interrupt ongoing async projections when result is unsubscribed early`        | should interrupt ongoing async projections when result is unsubscribed early        | `spec/operators/mergeScan-spec.ts:112` | —            | `portable`     | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/mergeScan-spec.ts:135:mergeScan > should not break unsubscription chains when result is unsubscribed explicitly`       | should not break unsubscription chains when result is unsubscribed explicitly       | `spec/operators/mergeScan-spec.ts:135` | —            | `portable`     | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/mergeScan-spec.ts:15:mergeScan > should mergeScan things`                                                              | should mergeScan things                                                             | `spec/operators/mergeScan-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:191:mergeScan > should handle errors in the projection function`                                     | should handle errors in the projection function                                     | `spec/operators/mergeScan-spec.ts:191` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:216:mergeScan > should propagate errors from the projected Observable`                               | should propagate errors from the projected Observable                               | `spec/operators/mergeScan-spec.ts:216` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:229:mergeScan > should handle an empty projected Observable`                                         | should handle an empty projected Observable                                         | `spec/operators/mergeScan-spec.ts:229` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:242:mergeScan > should handle a never projected Observable`                                          | should handle a never projected Observable                                          | `spec/operators/mergeScan-spec.ts:242` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:255:mergeScan > handle empty`                                                                        | handle empty                                                                        | `spec/operators/mergeScan-spec.ts:255` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:268:mergeScan > handle never`                                                                        | handle never                                                                        | `spec/operators/mergeScan-spec.ts:268` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:281:mergeScan > handle throw`                                                                        | handle throw                                                                        | `spec/operators/mergeScan-spec.ts:281` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:294:mergeScan > should mergeScan unsubscription`                                                     | should mergeScan unsubscription                                                     | `spec/operators/mergeScan-spec.ts:294` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:315:mergeScan > should mergeScan projects cold Observable with single concurrency`                   | should mergeScan projects cold Observable with single concurrency                   | `spec/operators/mergeScan-spec.ts:315` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:341:mergeScan > should not emit accumulator if inner completes without value`                        | should not emit accumulator if inner completes without value                        | `spec/operators/mergeScan-spec.ts:341` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:354:mergeScan > should not emit accumulator if inner completes without value after source completes` | should not emit accumulator if inner completes without value after source completes | `spec/operators/mergeScan-spec.ts:354` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:37:mergeScan > should handle errors`                                                                 | should handle errors                                                                | `spec/operators/mergeScan-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:375:mergeScan > should mergeScan projects hot Observable with single concurrency`                    | should mergeScan projects hot Observable with single concurrency                    | `spec/operators/mergeScan-spec.ts:375` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:400:mergeScan > should mergeScan projects cold Observable with dual concurrency`                     | should mergeScan projects cold Observable with dual concurrency                     | `spec/operators/mergeScan-spec.ts:400` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:425:mergeScan > should mergeScan projects hot Observable with dual concurrency`                      | should mergeScan projects hot Observable with dual concurrency                      | `spec/operators/mergeScan-spec.ts:425` | —            | `portable`     | `active`    | Missing operator capability: mergeScan | `FIXED` |
| `spec/operators/mergeScan-spec.ts:56:mergeScan > should mergeScan values and be able to asynchronously project them`                   | should mergeScan values and be able to asynchronously project them                  | `spec/operators/mergeScan-spec.ts:56`  | —            | `portable`     | `active`    | rxTest observable assertion failed.    | `FIXED` |
| `spec/operators/mergeScan-spec.ts:84:mergeScan > should not stop ongoing async projections when source completes`                      | should not stop ongoing async projections when source completes                     | `spec/operators/mergeScan-spec.ts:84`  | —            | `portable`     | `active`    | rxTest observable assertion failed.    | `FIXED` |

### `mergeWith`

Owner source: `spec/operators/mergeWith-spec.ts`

| Case ID                                                                                                                               | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/mergeWith-spec.ts:131:merge operator > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/mergeWith-spec.ts:131` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/mergeWith-spec.ts:148:merge operator > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/mergeWith-spec.ts:148` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/mergeWith-spec.ts:202:merge operator > should merge never and empty`                                                  | should merge never and empty                                                  | `spec/operators/mergeWith-spec.ts:202` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/mergeWith-spec.ts:217:merge operator > should merge never and never`                                                  | should merge never and never                                                  | `spec/operators/mergeWith-spec.ts:217` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `min`

Owner source: `spec/operators/min-spec.ts`

| Case ID                                                                                                              | Behavioral test                                                               | Source                           | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/min-spec.ts:134:min > should work with error`                                                        | should work with error                                                        | `spec/operators/min-spec.ts:134` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:145:min > should work with throw`                                                        | should work with throw                                                        | `spec/operators/min-spec.ts:145` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:15:min > should min the values of an observable`                                         | should min the values of an observable                                        | `spec/operators/min-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:156:min > should handle a constant predicate on an empty hot observable`                 | should handle a constant predicate on an empty hot observable                 | `spec/operators/min-spec.ts:156` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:171:min > should handle a constant predicate on an never hot observable`                 | should handle a constant predicate on an never hot observable                 | `spec/operators/min-spec.ts:171` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/min-spec.ts:186:min > should handle a constant predicate on a simple hot observable`                 | should handle a constant predicate on a simple hot observable                 | `spec/operators/min-spec.ts:186` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:201:min > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/min-spec.ts:201` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:217:min > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/min-spec.ts:217` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:239:min > should handle a reverse predicate on observable with many values`              | should handle a reverse predicate on observable with many values              | `spec/operators/min-spec.ts:239` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:254:min > should handle a predicate for string on observable with many values`           | should handle a predicate for string on observable with many values           | `spec/operators/min-spec.ts:254` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:26:min > should be never when source is never`                                           | should be never when source is never                                          | `spec/operators/min-spec.ts:26`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/min-spec.ts:269:min > should handle a constant predicate on observable that throws`                  | should handle a constant predicate on observable that throws                  | `spec/operators/min-spec.ts:269` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:284:min > should handle a predicate that throws, on observable with many values`         | should handle a predicate that throws, on observable with many values         | `spec/operators/min-spec.ts:284` | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:37:min > should be zero when source is empty`                                            | should be zero when source is empty                                           | `spec/operators/min-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:48:min > should be never when source doesn't complete`                                   | should be never when source doesn't complete                                  | `spec/operators/min-spec.ts:48`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/min-spec.ts:59:min > should be completes when source doesn't have values`                            | should be completes when source doesn't have values                           | `spec/operators/min-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:70:min > should min the unique value of an observable`                                   | should min the unique value of an observable                                  | `spec/operators/min-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |
| `spec/operators/min-spec.ts:81:min > should min the values of an ongoing hot observable`                             | should min the values of an ongoing hot observable                            | `spec/operators/min-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: min                                                                     | `FIXED` |

### `multicast`

Owner source: `spec/operators/multicast-spec.ts`

| Case ID                                                                                                                                                         | Behavioral test                                                                                  | Source                                 | Failing mode | Classification    | Disposition        | Concise failure                        | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------- | ------------ | ----------------- | ------------------ | -------------------------------------- | ------- |
| `spec/operators/multicast-spec.ts:100:multicast > should accept a multicast selector and connect to a hot source for each subscriber`                           | should accept a multicast selector and connect to a hot source for each subscriber               | `spec/operators/multicast-spec.ts:100` | cold         | `harness-rewrite` | `expected-failure` | rxTest subscriptions assertion failed. | `TODO`  |
| `spec/operators/multicast-spec.ts:127:multicast > should accept a multicast selector and connect to a cold source for each subscriber`                          | should accept a multicast selector and connect to a cold source for each subscriber              | `spec/operators/multicast-spec.ts:127` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:15:multicast > should mirror a simple source Observable`                                                                      | should mirror a simple source Observable                                                         | `spec/operators/multicast-spec.ts:15`  | —            | `portable`        | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:155:multicast > should accept a multicast selector and respect the subject's messaging semantics`                             | should accept a multicast selector and respect the subject's messaging semantics                 | `spec/operators/multicast-spec.ts:155` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:186:multicast > should do nothing if connect is not called, despite subscriptions`                                            | should do nothing if connect is not called, despite subscriptions                                | `spec/operators/multicast-spec.ts:186` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:198:multicast > should multicast the same values to multiple observers`                                                       | should multicast the same values to multiple observers                                           | `spec/operators/multicast-spec.ts:198` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:219:multicast > should multicast an error from the source to multiple observers`                                              | should multicast an error from the source to multiple observers                                  | `spec/operators/multicast-spec.ts:219` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:240:multicast > should multicast the same values to multiple observers, but is unsubscribed explicitly and early`             | should multicast the same values to multiple observers, but is unsubscribed explicitly and early | `spec/operators/multicast-spec.ts:240` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:272:multicast > should not break unsubscription chains when result is unsubscribed explicitly`                                | should not break unsubscription chains when result is unsubscribed explicitly                    | `spec/operators/multicast-spec.ts:272` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:307:multicast > should multicast an empty source`                                                                             | should multicast an empty source                                                                 | `spec/operators/multicast-spec.ts:307` | —            | `portable`        | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:321:multicast > should multicast a never source`                                                                              | should multicast a never source                                                                  | `spec/operators/multicast-spec.ts:321` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:335:multicast > should multicast a throw source`                                                                              | should multicast a throw source                                                                  | `spec/operators/multicast-spec.ts:335` | —            | `portable`        | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:350:multicast > with refCount() and subject factory > should connect when first subscriber subscribes`                        | should connect when first subscriber subscribes                                                  | `spec/operators/multicast-spec.ts:350` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:371:multicast > with refCount() and subject factory > should disconnect when last subscriber unsubscribes`                    | should disconnect when last subscriber unsubscribes                                              | `spec/operators/multicast-spec.ts:371` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:391:multicast > with refCount() and subject factory > should be retryable when cold source is synchronous`                    | should be retryable when cold source is synchronous                                              | `spec/operators/multicast-spec.ts:391` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:432:multicast > with refCount() and subject factory > should be retryable with ReplaySubject and cold source is synchronous`  | should be retryable with ReplaySubject and cold source is synchronous                            | `spec/operators/multicast-spec.ts:432` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:473:multicast > with refCount() and subject factory > should be repeatable when cold source is synchronous`                   | should be repeatable when cold source is synchronous                                             | `spec/operators/multicast-spec.ts:473` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:516:multicast > with refCount() and subject factory > should be repeatable with ReplaySubject and cold source is synchronous` | should be repeatable with ReplaySubject and cold source is synchronous                           | `spec/operators/multicast-spec.ts:516` | —            | `harness-rewrite` | `active`           | Missing operator capability: multicast | `FIXED` |
| `spec/operators/multicast-spec.ts:559:multicast > with refCount() and subject factory > should be retryable`                                                    | should be retryable                                                                              | `spec/operators/multicast-spec.ts:559` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.    | `TODO`  |
| `spec/operators/multicast-spec.ts:597:multicast > with refCount() and subject factory > should be retryable using a ReplaySubject`                              | should be retryable using a ReplaySubject                                                        | `spec/operators/multicast-spec.ts:597` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.    | `TODO`  |
| `spec/operators/multicast-spec.ts:620:multicast > with refCount() and subject factory > should be repeatable`                                                   | should be repeatable                                                                             | `spec/operators/multicast-spec.ts:620` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.    | `TODO`  |
| `spec/operators/multicast-spec.ts:656:multicast > with refCount() and subject factory > should be repeatable using a ReplaySubject`                             | should be repeatable using a ReplaySubject                                                       | `spec/operators/multicast-spec.ts:656` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.    | `TODO`  |

### `multicasting-deprecations`

Owner source: `spec/deprecation-equivalents/multicasting-deprecations-spec.ts`

| Case ID                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Behavioral test                                                                                                                                                                                                           | Source                                                               | Failing mode | Classification    | Disposition        | Concise failure                              | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------ | ----------------- | ------------------ | -------------------------------------------- | ------- |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                          | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry                                                                                                              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                              | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry                                                        | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                          | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry                                                                                                                              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | polyfill     | `harness-rewrite` | `expected-failure` | error                                        | `TODO`  |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry  | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                            | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry               | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that retry [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                          | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources that retry                                                | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | polyfill     | `harness-rewrite` | `expected-failure` | error                                        | `TODO`  |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry  | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                                     | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources                                                                                                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                           | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                                                    | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                                         | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                                                                   | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                                     | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources                                                                                                                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`             | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                       | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                          | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                                     | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources                                                           | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`             | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                         | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat                                                                                                             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                               | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat                                        | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                             | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat                                                       | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                         | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat                                                                                                                             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]` | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                           | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that repeat [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                         | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources that repeat                                               | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]` | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                          | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry                                                                                                              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                              | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry                                                        | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                          | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry                                                                                                                              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry  | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                            | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry               | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that retry [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                          | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources that retry                                                | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry  | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134` | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                                      | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources                                                                                                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                            | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                                                    | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                                          | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                                                                   | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                                      | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources                                                                                                                                         | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`              | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                        | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources                          | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                                      | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources                                                           | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`              | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat [equivalence-0:multicast(() => new Subject()), refCount() and share()]`                                                                                                                                                                                                                          | should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat                                                                                                             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                | should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat                                        | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: multicast       | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                                                                                                              | should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat                                                       | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat [equivalence-6:publish(fn) and connect({ setup: fn })]`                                                                                                                                                                                                                                                          | should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat                                                                                                                             | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publish         | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishBehavior | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`                            | should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat              | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishLast     | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that repeat [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`                                                                                          | should be equivalent for publishReplay(3, 10, fn) and `subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })` for async sources that repeat                                               | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `FIXED` |
| `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`  | should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat | `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98`  | —            | `harness-rewrite` | `expected-failure` | Missing operator capability: publishReplay   | `FIXED` |

### `never`

Owner source: `spec/observables/never-spec.ts`

| Case ID                                                                                      | Behavioral test                                  | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------ | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/never-spec.ts:15:NEVER > should create a cold observable that never emits` | should create a cold observable that never emits | `spec/observables/never-spec.ts:15` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `Notification`

Owner source: `spec/Notification-spec.ts`

| Case ID                                                                                                            | Behavioral test                                       | Source                         | Failing mode | Classification | Disposition | Concise failure                                                | Status  |
| ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------- | ------------------------------ | ------------ | -------------- | ----------- | -------------------------------------------------------------- | ------- |
| `spec/Notification-spec.ts:57:Notification > toObservable > should create observable from a next Notification`     | should create observable from a next Notification     | `spec/Notification-spec.ts:57` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createNext')     | `FIXED` |
| `spec/Notification-spec.ts:65:Notification > toObservable > should create observable from a complete Notification` | should create observable from a complete Notification | `spec/Notification-spec.ts:65` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createComplete') | `FIXED` |
| `spec/Notification-spec.ts:72:Notification > toObservable > should create observable from a error Notification`    | should create observable from a error Notification    | `spec/Notification-spec.ts:72` | —            | `portable`     | `active`    | Cannot read properties of undefined (reading 'createError')    | `FIXED` |

### `Observable`

Owner source: `spec/Observable-spec.ts`

| Case ID                                                                                                    | Behavioral test                                                  | Source                         | Failing mode | Classification           | Disposition        | Concise failure                                                                                                                                                                                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------ | ------------ | ------------------------ | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `spec/Observable-spec.ts:1330:Observable.lift > should compose through combineLatest`                      | should compose through combineLatest                             | `spec/Observable-spec.ts:1330` | —            | `intentional-divergence` | `active`           | expected false to be true                                                                                                                                                                                                                                            | `FIXED` |
| `spec/Observable-spec.ts:1353:Observable.lift > should compose through concat`                             | should compose through concat                                    | `spec/Observable-spec.ts:1353` | —            | `intentional-divergence` | `active`           | rxTestScheduler is not defined                                                                                                                                                                                                                                       | `FIXED` |
| `spec/Observable-spec.ts:1366:Observable.lift > should compose through merge`                              | should compose through merge                                     | `spec/Observable-spec.ts:1366` | —            | `intentional-divergence` | `active`           | rxTestScheduler is not defined                                                                                                                                                                                                                                       | `FIXED` |
| `spec/Observable-spec.ts:1380:Observable.lift > should compose through race`                               | should compose through race                                      | `spec/Observable-spec.ts:1380` | —            | `intentional-divergence` | `active`           | expected false to be true                                                                                                                                                                                                                                            | `FIXED` |
| `spec/Observable-spec.ts:1400:Observable.lift > should compose through zip`                                | should compose through zip                                       | `spec/Observable-spec.ts:1400` | cold         | `intentional-divergence` | `expected-failure` | expected false to be true // Object.is equality                                                                                                                                                                                                                      | `TODO`  |
| `spec/Observable-spec.ts:50:Observable > should allow empty ctor, which is effectively a never-observable` | should allow empty ctor, which is effectively a never-observable | `spec/Observable-spec.ts:50`   | —            | `intentional-divergence` | `active`           | cold: rxTest observable assertion failed.; polyfill: this.init is not a function                                                                                                                                                                                     | `FIXED` |
| `spec/Observable-spec.ts:903:Observable > should handle sync errors within a test scheduler`               | should handle sync errors within a test scheduler                | `spec/Observable-spec.ts:903`  | —            | `harness-rewrite`        | `expected-failure` | [non-terminating-conversion] spec/Observable-spec.ts:903:Observable > should handle sync errors within a test scheduler: The source-skipped RxJS 7 case synchronously returns catchError’s caught source forever before virtual time can reach an observation bound… | `FIXED` |

### `observeOn`

Owner source: `spec/operators/observeOn-spec.ts`

| Case ID                                                                                                                             | Behavioral test                                                                   | Source                                | Failing mode | Classification    | Disposition | Concise failure              | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------- | ------- |
| `spec/operators/observeOn-spec.ts:15:observeOn > should observe on specified scheduler`                                             | should observe on specified scheduler                                             | `spec/operators/observeOn-spec.ts:15` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:26:observeOn > should observe after specified delay`                                              | should observe after specified delay                                              | `spec/operators/observeOn-spec.ts:26` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:40:observeOn > should observe when source raises error`                                           | should observe when source raises error                                           | `spec/operators/observeOn-spec.ts:40` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:51:observeOn > should observe when source is empty`                                               | should observe when source is empty                                               | `spec/operators/observeOn-spec.ts:51` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:62:observeOn > should observe when source does not complete`                                      | should observe when source does not complete                                      | `spec/operators/observeOn-spec.ts:62` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:73:observeOn > should allow unsubscribing early and explicitly`                                   | should allow unsubscribing early and explicitly                                   | `spec/operators/observeOn-spec.ts:73` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/observeOn-spec.ts:87:observeOn > should not break unsubscription chains when the result is unsubscribed explicitly` | should not break unsubscription chains when the result is unsubscribed explicitly | `spec/operators/observeOn-spec.ts:87` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |

### `of`

Owner source: `spec/observables/of-spec.ts`

| Case ID                                                                                  | Behavioral test                                    | Source                           | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ---------------------------------------------------------------------------------------- | -------------------------------------------------- | -------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/of-spec.ts:16:of > should create a cold observable that emits 1, 2, 3` | should create a cold observable that emits 1, 2, 3 | `spec/observables/of-spec.ts:16` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `onErrorResumeNext`

Owner sources: `spec/observables/onErrorResumeNext-spec.ts`, `spec/operators/onErrorResumeNext-spec.ts`

| Case ID                                                                                                                                       | Behavioral test                                                            | Source                                          | Failing mode    | Classification       | Disposition        | Concise failure                       | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------------------------------------------- | --------------- | -------------------- | ------------------ | ------------------------------------- | ------- |
| `spec/observables/onErrorResumeNext-spec.ts:55:onErrorResumeNext > should complete single observable throws`                                  | should complete single observable throws                                   | `spec/observables/onErrorResumeNext-spec.ts:55` | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:107:onErrorResumeNext > should continue after empty observable`                                     | should continue after empty observable                                     | `spec/operators/onErrorResumeNext-spec.ts:107`  | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:127:onErrorResumeNext > should not complete with observable that does not complete`                 | should not complete with observable that does not complete                 | `spec/operators/onErrorResumeNext-spec.ts:127`  | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:141:onErrorResumeNext > should not continue when source observable does not complete`               | should not continue when source observable does not complete               | `spec/operators/onErrorResumeNext-spec.ts:141`  | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:15:onErrorResumeNext > should continue observable sequence with next observable`                    | should continue observable sequence with next observable                   | `spec/operators/onErrorResumeNext-spec.ts:15`   | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:155:onErrorResumeNext > should complete observable when next observable throws`                     | should complete observable when next observable throws                     | `spec/operators/onErrorResumeNext-spec.ts:155`  | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:189:onErrorResumeNext > should unsubscribe from an interop observable upon explicit unsubscription` | should unsubscribe from an interop observable upon explicit unsubscription | `spec/operators/onErrorResumeNext-spec.ts:189`  | cold + polyfill | `compatibility-only` | `expected-failure` | [object Observable] is not observable | `TODO`  |
| `spec/operators/onErrorResumeNext-spec.ts:29:onErrorResumeNext > should continue with hot observables`                                        | should continue with hot observables                                       | `spec/operators/onErrorResumeNext-spec.ts:29`   | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:43:onErrorResumeNext > should continue with array of multiple observables that throw errors`        | should continue with array of multiple observables that throw errors       | `spec/operators/onErrorResumeNext-spec.ts:43`   | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:67:onErrorResumeNext > should continue with multiple observables that throw errors`                 | should continue with multiple observables that throw errors                | `spec/operators/onErrorResumeNext-spec.ts:67`   | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |
| `spec/operators/onErrorResumeNext-spec.ts:87:onErrorResumeNext > should continue with multiple observables that don't throw error`            | should continue with multiple observables that don't throw error           | `spec/operators/onErrorResumeNext-spec.ts:87`   | —               | `portable`           | `active`           | rxTest observable assertion failed.   | `FIXED` |

### `pairwise`

Owner source: `spec/operators/pairwise-spec.ts`

| Case ID                                                                                                      | Behavioral test                                     | Source                                | Failing mode | Classification | Disposition | Concise failure                       | Status  |
| ------------------------------------------------------------------------------------------------------------ | --------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ------------------------------------- | ------- |
| `spec/operators/pairwise-spec.ts:102:pairwise operator > should handle throw`                                | should handle throw                                 | `spec/operators/pairwise-spec.ts:102` | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:15:pairwise operator > should group consecutive emissions as arrays of two` | should group consecutive emissions as arrays of two | `spec/operators/pairwise-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:33:pairwise operator > should pairwise things`                              | should pairwise things                              | `spec/operators/pairwise-spec.ts:33`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:52:pairwise operator > should not emit on single-element streams`           | should not emit on single-element streams           | `spec/operators/pairwise-spec.ts:52`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:63:pairwise operator > should handle mid-stream throw`                      | should handle mid-stream throw                      | `spec/operators/pairwise-spec.ts:63`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:80:pairwise operator > should handle empty`                                 | should handle empty                                 | `spec/operators/pairwise-spec.ts:80`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |
| `spec/operators/pairwise-spec.ts:91:pairwise operator > should handle never`                                 | should handle never                                 | `spec/operators/pairwise-spec.ts:91`  | —            | `portable`     | `active`    | Missing operator capability: pairwise | `FIXED` |

### `partition`

Owner source: `spec/observables/partition-spec.ts`

| Case ID                                                                                                                            | Behavioral test                                                               | Source                                   | Failing mode | Classification    | Disposition        | Concise failure                        | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------- | ------------ | ----------------- | ------------------ | -------------------------------------- | ------- |
| `spec/observables/partition-spec.ts:115:partition > should pass errors to both returned observables if source throws`              | should pass errors to both returned observables if source throws              | `spec/observables/partition-spec.ts:115` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:134:partition > should pass errors to both returned observables if predicate throws`           | should pass errors to both returned observables if predicate throws           | `spec/observables/partition-spec.ts:134` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:159:partition > should partition empty observable if source does not emits`                    | should partition empty observable if source does not emits                    | `spec/observables/partition-spec.ts:159` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:178:partition > should partition empty observable if source is empty`                          | should partition empty observable if source is empty                          | `spec/observables/partition-spec.ts:178` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:197:partition > should partition if source emits single elements`                              | should partition if source emits single elements                              | `spec/observables/partition-spec.ts:197` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:216:partition > should partition if predicate matches all of source elements`                  | should partition if predicate matches all of source elements                  | `spec/observables/partition-spec.ts:216` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:22:partition > should partition an observable of integers into even and odd`                   | should partition an observable of integers into even and odd                  | `spec/observables/partition-spec.ts:22`  | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:235:partition > should partition if predicate does not match all of source elements`           | should partition if predicate does not match all of source elements           | `spec/observables/partition-spec.ts:235` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:254:partition > should partition to infinite observable if source does not completes`          | should partition to infinite observable if source does not completes          | `spec/observables/partition-spec.ts:254` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:273:partition > should partition to infinite observable if source never completes`             | should partition to infinite observable if source never completes             | `spec/observables/partition-spec.ts:273` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:292:partition > should partition into two observable with early unsubscription`                | should partition into two observable with early unsubscription                | `spec/observables/partition-spec.ts:292` | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:315:partition > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/observables/partition-spec.ts:315` | cold         | `harness-rewrite` | `expected-failure` | rxTest subscriptions assertion failed. | `TODO`  |
| `spec/observables/partition-spec.ts:39:partition > should partition an observable into two using a predicate`                      | should partition an observable into two using a predicate                     | `spec/observables/partition-spec.ts:39`  | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:58:partition > should partition an observable into two using a predicate that takes an index`  | should partition an observable into two using a predicate that takes an index | `spec/observables/partition-spec.ts:58`  | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:77:partition > should partition an observable into two using a predicate and thisArg`          | should partition an observable into two using a predicate and thisArg         | `spec/observables/partition-spec.ts:77`  | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |
| `spec/observables/partition-spec.ts:96:partition > should pass errors to both returned observables`                                | should pass errors to both returned observables                               | `spec/observables/partition-spec.ts:96`  | —            | `portable`        | `active`           | partition is not a function            | `FIXED` |

### `pluck`

Owner source: `spec/operators/pluck-spec.ts`

| Case ID                                                                                                       | Behavioral test                                                    | Source                             | Failing mode | Classification | Disposition | Concise failure                    | Status  |
| ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------- | ------- |
| `spec/operators/pluck-spec.ts:105:pluck > should work with edge cases of deep nested properties`              | should work with edge cases of deep nested properties              | `spec/operators/pluck-spec.ts:105` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:132:pluck > should propagate errors from observable that emits only errors`     | should propagate errors from observable that emits only errors     | `spec/operators/pluck-spec.ts:132` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:145:pluck > should propagate errors from observable that emit values`           | should propagate errors from observable that emit values           | `spec/operators/pluck-spec.ts:145` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:15:pluck > should dematerialize an Observable`                                  | should dematerialize an Observable                                 | `spec/operators/pluck-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:159:pluck > should not pluck an empty observable`                               | should not pluck an empty observable                               | `spec/operators/pluck-spec.ts:159` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:172:pluck > should allow unsubscribing explicitly and early`                    | should allow unsubscribing explicitly and early                    | `spec/operators/pluck-spec.ts:172` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:186:pluck > should pluck twice`                                                 | should pluck twice                                                 | `spec/operators/pluck-spec.ts:186` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:206:pluck > should not break unsubscription chain when unsubscribed explicitly` | should not break unsubscription chain when unsubscribed explicitly | `spec/operators/pluck-spec.ts:206` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:225:pluck > should support symbols`                                             | should support symbols                                             | `spec/operators/pluck-spec.ts:225` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:241:pluck > should not break on null values`                                    | should not break on null values                                    | `spec/operators/pluck-spec.ts:241` | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:37:pluck > should work for one array`                                           | should work for one array                                          | `spec/operators/pluck-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:51:pluck > should work for one object`                                          | should work for one object                                         | `spec/operators/pluck-spec.ts:51`  | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:65:pluck > should work for multiple objects`                                    | should work for multiple objects                                   | `spec/operators/pluck-spec.ts:65`  | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |
| `spec/operators/pluck-spec.ts:85:pluck > should work with deep nested properties`                             | should work with deep nested properties                            | `spec/operators/pluck-spec.ts:85`  | —            | `portable`     | `active`    | Missing operator capability: pluck | `FIXED` |

### `publish`

Owner source: `spec/operators/publish-spec.ts`

| Case ID                                                                                                                                                  | Behavioral test                                                                                  | Source                               | Failing mode | Classification    | Disposition        | Concise failure                        | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------ | ----------------- | ------------------ | -------------------------------------- | ------- |
| `spec/operators/publish-spec.ts:114:publish operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early` | should multicast the same values to multiple observers, but is unsubscribed explicitly and early | `spec/operators/publish-spec.ts:114` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:146:publish operator > should not break unsubscription chains when result is unsubscribed explicitly`                    | should not break unsubscription chains when result is unsubscribed explicitly                    | `spec/operators/publish-spec.ts:146` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:15:publish operator > should mirror a simple source Observable`                                                          | should mirror a simple source Observable                                                         | `spec/operators/publish-spec.ts:15`  | —            | `portable`        | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:182:publish operator > with refCount() > should connect when first subscriber subscribes`                                | should connect when first subscriber subscribes                                                  | `spec/operators/publish-spec.ts:182` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:201:publish operator > with refCount() > should disconnect when last subscriber unsubscribes`                            | should disconnect when last subscriber unsubscribes                                              | `spec/operators/publish-spec.ts:201` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:219:publish operator > with refCount() > should NOT be retryable`                                                        | should NOT be retryable                                                                          | `spec/operators/publish-spec.ts:219` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:238:publish operator > with refCount() > should NOT be repeatable`                                                       | should NOT be repeatable                                                                         | `spec/operators/publish-spec.ts:238` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:301:publish operator > should multicast an empty source`                                                                 | should multicast an empty source                                                                 | `spec/operators/publish-spec.ts:301` | —            | `portable`        | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:315:publish operator > should multicast a never source`                                                                  | should multicast a never source                                                                  | `spec/operators/publish-spec.ts:315` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:329:publish operator > should multicast a throw source`                                                                  | should multicast a throw source                                                                  | `spec/operators/publish-spec.ts:329` | —            | `portable`        | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:37:publish operator > should do nothing if connect is not called, despite subscriptions`                                 | should do nothing if connect is not called, despite subscriptions                                | `spec/operators/publish-spec.ts:37`  | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:378:publish operator > should be referentially-transparent`                                                              | should be referentially-transparent                                                              | `spec/operators/publish-spec.ts:378` | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:49:publish operator > should multicast the same values to multiple observers`                                            | should multicast the same values to multiple observers                                           | `spec/operators/publish-spec.ts:49`  | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |
| `spec/operators/publish-spec.ts:70:publish operator > should accept selectors`                                                                           | should accept selectors                                                                          | `spec/operators/publish-spec.ts:70`  | cold         | `harness-rewrite` | `expected-failure` | rxTest subscriptions assertion failed. | `TODO`  |
| `spec/operators/publish-spec.ts:93:publish operator > should multicast an error from the source to multiple observers`                                   | should multicast an error from the source to multiple observers                                  | `spec/operators/publish-spec.ts:93`  | —            | `harness-rewrite` | `active`           | Missing operator capability: publish   | `FIXED` |

### `publishBehavior`

Owner source: `spec/operators/publishBehavior-spec.ts`

| Case ID                                                                                                                                                                 | Behavioral test                                                                                  | Source                                       | Failing mode | Classification    | Disposition        | Concise failure                              | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------- | ------------ | ----------------- | ------------------ | -------------------------------------------- | ------- |
| `spec/operators/publishBehavior-spec.ts:123:publishBehavior operator > should not break unsubscription chains when result is unsubscribed explicitly`                   | should not break unsubscription chains when result is unsubscribed explicitly                    | `spec/operators/publishBehavior-spec.ts:123` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:15:publishBehavior operator > should mirror a simple source Observable`                                                         | should mirror a simple source Observable                                                         | `spec/operators/publishBehavior-spec.ts:15`  | —            | `portable`        | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:159:publishBehavior operator > with refCount() > should connect when first subscriber subscribes`                               | should connect when first subscriber subscribes                                                  | `spec/operators/publishBehavior-spec.ts:159` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:178:publishBehavior operator > with refCount() > should disconnect when last subscriber unsubscribes`                           | should disconnect when last subscriber unsubscribes                                              | `spec/operators/publishBehavior-spec.ts:178` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:196:publishBehavior operator > with refCount() > should NOT be retryable`                                                       | should NOT be retryable                                                                          | `spec/operators/publishBehavior-spec.ts:196` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:215:publishBehavior operator > with refCount() > should NOT be repeatable`                                                      | should NOT be repeatable                                                                         | `spec/operators/publishBehavior-spec.ts:215` | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:278:publishBehavior operator > should multicast an empty source`                                                                | should multicast an empty source                                                                 | `spec/operators/publishBehavior-spec.ts:278` | —            | `portable`        | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:292:publishBehavior operator > should multicast a never source`                                                                 | should multicast a never source                                                                  | `spec/operators/publishBehavior-spec.ts:292` | —            | `harness-rewrite` | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:306:publishBehavior operator > should multicast a throw source`                                                                 | should multicast a throw source                                                                  | `spec/operators/publishBehavior-spec.ts:306` | —            | `portable`        | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:37:publishBehavior operator > should only emit default value if connect is not called, despite subscriptions`                   | should only emit default value if connect is not called, despite subscriptions                   | `spec/operators/publishBehavior-spec.ts:37`  | —            | `harness-rewrite` | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:378:publishBehavior operator > should be referentially-transparent`                                                             | should be referentially-transparent                                                              | `spec/operators/publishBehavior-spec.ts:378` | —            | `harness-rewrite` | `active`           | Missing operator capability: publishBehavior | `FIXED` |
| `spec/operators/publishBehavior-spec.ts:49:publishBehavior operator > should multicast the same values to multiple observers`                                           | should multicast the same values to multiple observers                                           | `spec/operators/publishBehavior-spec.ts:49`  | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:70:publishBehavior operator > should multicast an error from the source to multiple observers`                                  | should multicast an error from the source to multiple observers                                  | `spec/operators/publishBehavior-spec.ts:70`  | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |
| `spec/operators/publishBehavior-spec.ts:91:publishBehavior operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early` | should multicast the same values to multiple observers, but is unsubscribed explicitly and early | `spec/operators/publishBehavior-spec.ts:91`  | cold         | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.          | `TODO`  |

### `publishLast`

Owner source: `spec/operators/publishLast-spec.ts`

| Case ID                                                                                                                                                           | Behavioral test                                                                                    | Source                                   | Failing mode | Classification    | Disposition | Concise failure                          | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------- | ------- |
| `spec/operators/publishLast-spec.ts:123:publishLast operator > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                      | `spec/operators/publishLast-spec.ts:123` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:15:publishLast operator > should emit last notification of a simple source Observable`                                        | should emit last notification of a simple source Observable                                        | `spec/operators/publishLast-spec.ts:15`  | —            | `portable`        | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:159:publishLast operator > with refCount() > should connect when first subscriber subscribes`                                 | should connect when first subscriber subscribes                                                    | `spec/operators/publishLast-spec.ts:159` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:178:publishLast operator > with refCount() > should disconnect when last subscriber unsubscribes`                             | should disconnect when last subscriber unsubscribes                                                | `spec/operators/publishLast-spec.ts:178` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:196:publishLast operator > with refCount() > should NOT be retryable`                                                         | should NOT be retryable                                                                            | `spec/operators/publishLast-spec.ts:196` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:216:publishLast operator > should multicast an empty source`                                                                  | should multicast an empty source                                                                   | `spec/operators/publishLast-spec.ts:216` | —            | `portable`        | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:230:publishLast operator > should multicast a never source`                                                                   | should multicast a never source                                                                    | `spec/operators/publishLast-spec.ts:230` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:244:publishLast operator > should multicast a throw source`                                                                   | should multicast a throw source                                                                    | `spec/operators/publishLast-spec.ts:244` | —            | `portable`        | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:293:publishLast operator > should be referentially-transparent`                                                               | should be referentially-transparent                                                                | `spec/operators/publishLast-spec.ts:293` | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:37:publishLast operator > should do nothing if connect is not called, despite subscriptions`                                  | should do nothing if connect is not called, despite subscriptions                                  | `spec/operators/publishLast-spec.ts:37`  | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:49:publishLast operator > should multicast the same values to multiple observers`                                             | should multicast the same values to multiple observers                                             | `spec/operators/publishLast-spec.ts:49`  | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:70:publishLast operator > should multicast an error from the source to multiple observers`                                    | should multicast an error from the source to multiple observers                                    | `spec/operators/publishLast-spec.ts:70`  | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |
| `spec/operators/publishLast-spec.ts:91:publishLast operator > should not cast any values to multiple observers, when source is unsubscribed explicitly and early` | should not cast any values to multiple observers, when source is unsubscribed explicitly and early | `spec/operators/publishLast-spec.ts:91`  | —            | `harness-rewrite` | `active`    | Missing operator capability: publishLast | `FIXED` |

### `publishReplay`

Owner source: `spec/operators/publishReplay-spec.ts`

| Case ID                                                                                                                                                              | Behavioral test                                                                                  | Source                                     | Failing mode | Classification           | Disposition        | Concise failure                            | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------ | ------------ | ------------------------ | ------------------ | ------------------------------------------ | ------- |
| `spec/operators/publishReplay-spec.ts:112:publishReplay operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early` | should multicast the same values to multiple observers, but is unsubscribed explicitly and early | `spec/operators/publishReplay-spec.ts:112` | cold         | `intentional-divergence` | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:144:publishReplay operator > should not break unsubscription chains when result is unsubscribed explicitly`                    | should not break unsubscription chains when result is unsubscribed explicitly                    | `spec/operators/publishReplay-spec.ts:144` | cold         | `intentional-divergence` | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:15:publishReplay operator > should mirror a simple source Observable`                                                          | should mirror a simple source Observable                                                         | `spec/operators/publishReplay-spec.ts:15`  | —            | `portable`               | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:180:publishReplay operator > with refCount() > should connect when first subscriber subscribes`                                | should connect when first subscriber subscribes                                                  | `spec/operators/publishReplay-spec.ts:180` | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:199:publishReplay operator > with refCount() > should disconnect when last subscriber unsubscribes`                            | should disconnect when last subscriber unsubscribes                                              | `spec/operators/publishReplay-spec.ts:199` | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:217:publishReplay operator > with refCount() > should NOT be retryable`                                                        | should NOT be retryable                                                                          | `spec/operators/publishReplay-spec.ts:217` | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:236:publishReplay operator > with refCount() > should NOT be repeatable`                                                       | should NOT be repeatable                                                                         | `spec/operators/publishReplay-spec.ts:236` | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:37:publishReplay operator > should do nothing if connect is not called, despite subscriptions`                                 | should do nothing if connect is not called, despite subscriptions                                | `spec/operators/publishReplay-spec.ts:37`  | —            | `harness-rewrite`        | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:409:publishReplay operator > should multicast an empty source`                                                                 | should multicast an empty source                                                                 | `spec/operators/publishReplay-spec.ts:409` | —            | `portable`               | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:423:publishReplay operator > should multicast a never source`                                                                  | should multicast a never source                                                                  | `spec/operators/publishReplay-spec.ts:423` | —            | `harness-rewrite`        | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:438:publishReplay operator > should multicast a throw source`                                                                  | should multicast a throw source                                                                  | `spec/operators/publishReplay-spec.ts:438` | —            | `portable`               | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:452:publishReplay operator > should mirror a simple source Observable with selector`                                           | should mirror a simple source Observable with selector                                           | `spec/operators/publishReplay-spec.ts:452` | —            | `portable`               | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:466:publishReplay operator > should EMIT an error when the selector throws an exception`                                       | should EMIT an error when the selector throws an exception                                       | `spec/operators/publishReplay-spec.ts:466` | —            | `portable`               | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:480:publishReplay operator > should emit an error when the selector returns an Observable that emits an error`                 | should emit an error when the selector returns an Observable that emits an error                 | `spec/operators/publishReplay-spec.ts:480` | polyfill     | `portable`               | `active`           | It's broken                                | `TODO`  |
| `spec/operators/publishReplay-spec.ts:49:publishReplay operator > should multicast the same values to multiple observers, bufferSize=1`                              | should multicast the same values to multiple observers, bufferSize=1                             | `spec/operators/publishReplay-spec.ts:49`  | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:495:publishReplay operator > should terminate immediately when the selector returns an empty Observable`                       | should terminate immediately when the selector returns an empty Observable                       | `spec/operators/publishReplay-spec.ts:495` | —            | `intentional-divergence` | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:508:publishReplay operator > should not emit and should not complete/error when the selector returns never`                    | should not emit and should not complete/error when the selector returns never                    | `spec/operators/publishReplay-spec.ts:508` | —            | `harness-rewrite`        | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:521:publishReplay operator > should emit error when the selector returns Observable.throw`                                     | should emit error when the selector returns Observable.throw                                     | `spec/operators/publishReplay-spec.ts:521` | —            | `intentional-divergence` | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:535:publishReplay operator > should be referentially-transparent`                                                              | should be referentially-transparent                                                              | `spec/operators/publishReplay-spec.ts:535` | —            | `harness-rewrite`        | `active`           | Missing operator capability: publishReplay | `FIXED` |
| `spec/operators/publishReplay-spec.ts:70:publishReplay operator > should multicast the same values to multiple observers, bufferSize=2`                              | should multicast the same values to multiple observers, bufferSize=2                             | `spec/operators/publishReplay-spec.ts:70`  | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |
| `spec/operators/publishReplay-spec.ts:91:publishReplay operator > should multicast an error from the source to multiple observers`                                   | should multicast an error from the source to multiple observers                                  | `spec/operators/publishReplay-spec.ts:91`  | cold         | `harness-rewrite`        | `expected-failure` | rxTest observable assertion failed.        | `TODO`  |

### `QueueScheduler`

Owner source: `spec/schedulers/QueueScheduler-spec.ts`

| Case ID                                                                                                        | Behavioral test                                  | Source                                      | Failing mode | Classification    | Disposition | Concise failure                    | Status  |
| -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | ------------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------- | ------- |
| `spec/schedulers/QueueScheduler-spec.ts:18:Scheduler.queue > should act like the async scheduler if delay > 0` | should act like the async scheduler if delay > 0 | `spec/schedulers/QueueScheduler-spec.ts:18` | —            | `harness-rewrite` | `active`    | Missing operator capability: delay | `FIXED` |

### `race`

Owner source: `spec/observables/race-spec.ts`

| Case ID                                                                                                        | Behavioral test                                                     | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/race-spec.ts:109:race > should race emit and complete`                                       | should race emit and complete                                       | `spec/observables/race-spec.ts:109` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/race-spec.ts:125:race > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                     | `spec/observables/race-spec.ts:125` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/race-spec.ts:142:race > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/observables/race-spec.ts:142` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/race-spec.ts:161:race > should never emit when given non emitting sources`                   | should never emit when given non emitting sources                   | `spec/observables/race-spec.ts:161` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/race-spec.ts:207:race > handle empty`                                                        | handle empty                                                        | `spec/observables/race-spec.ts:207` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/race-spec.ts:220:race > handle never`                                                        | handle never                                                        | `spec/observables/race-spec.ts:220` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/race-spec.ts:45:race > should race with array of observable`                                 | should race with array of observable                                | `spec/observables/race-spec.ts:45`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `race-legacy`

Owner source: `spec/operators/race-legacy-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                      | Source                                   | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/race-legacy-spec.ts:112:race operator > should allow unsubscribing early and explicitly`                     | should allow unsubscribing early and explicitly                      | `spec/operators/race-legacy-spec.ts:112` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/race-legacy-spec.ts:129:race operator > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly  | `spec/operators/race-legacy-spec.ts:129` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/race-legacy-spec.ts:150:race operator > should never emit when given non emitting sources`                   | should never emit when given non emitting sources                    | `spec/operators/race-legacy-spec.ts:150` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/race-legacy-spec.ts:32:race operator > should race cold and cold and accept an Array of Observable argument` | should race cold and cold and accept an Array of Observable argument | `spec/operators/race-legacy-spec.ts:32`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/race-legacy-spec.ts:96:race operator > should race emit and complete`                                        | should race emit and complete                                        | `spec/operators/race-legacy-spec.ts:96`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `raceWith`

Owner source: `spec/operators/raceWith-spec.ts`

| Case ID                                                                                                                       | Behavioral test                                                     | Source                                | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/raceWith-spec.ts:113:raceWith operator > should not break unsubscription chains when unsubscribed explicitly` | should not break unsubscription chains when unsubscribed explicitly | `spec/operators/raceWith-spec.ts:113` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/raceWith-spec.ts:134:raceWith operator > should never emit when given non emitting sources`                   | should never emit when given non emitting sources                   | `spec/operators/raceWith-spec.ts:134` | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/raceWith-spec.ts:80:raceWith operator > should race emit and complete`                                        | should race emit and complete                                       | `spec/operators/raceWith-spec.ts:80`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/operators/raceWith-spec.ts:96:raceWith operator > should allow unsubscribing early and explicitly`                      | should allow unsubscribing early and explicitly                     | `spec/operators/raceWith-spec.ts:96`  | —            | `portable`     | `active`    | rxTest observable assertion failed. | `FIXED` |

### `range`

Owner source: `spec/observables/range-spec.ts`

| Case ID                                                                                                                | Behavioral test                                                           | Source                               | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------ | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/observables/range-spec.ts:101:range > should accept only one argument where count is argument and start is zero` | should accept only one argument where count is argument and start is zero | `spec/observables/range-spec.ts:101` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/observables/range-spec.ts:17:range > should create an observable with numbers 1 to 10`                           | should create an observable with numbers 1 to 10                          | `spec/observables/range-spec.ts:17`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/observables/range-spec.ts:49:range > should work for two subscribers`                                            | should work for two subscribers                                           | `spec/observables/range-spec.ts:49`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |

### `reduce`

Owner source: `spec/operators/reduce-spec.ts`

| Case ID                                                                                                                    | Behavioral test                                                               | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/reduce-spec.ts:102:reduce > should reduce with seed if source is empty`                                    | should reduce with seed if source is empty                                    | `spec/operators/reduce-spec.ts:102` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:115:reduce > should raise error if reduce function throws without seed`                     | should raise error if reduce function throws without seed                     | `spec/operators/reduce-spec.ts:115` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:132:reduce > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/reduce-spec.ts:132` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:146:reduce > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/reduce-spec.ts:146` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:15:reduce > should reduce`                                                                  | should reduce                                                                 | `spec/operators/reduce-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:164:reduce > should raise error if source emits and raises error with seed`                 | should raise error if source emits and raises error with seed                 | `spec/operators/reduce-spec.ts:164` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:177:reduce > should raise error if source raises error with seed`                           | should raise error if source raises error with seed                           | `spec/operators/reduce-spec.ts:177` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:190:reduce > should raise error if reduce function throws with seed`                        | should raise error if reduce function throws with seed                        | `spec/operators/reduce-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:207:reduce > should not complete with seed if source emits but does not complete`           | should not complete with seed if source emits but does not complete           | `spec/operators/reduce-spec.ts:207` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/reduce-spec.ts:220:reduce > should not complete with seed if source never completes`                       | should not complete with seed if source never completes                       | `spec/operators/reduce-spec.ts:220` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/reduce-spec.ts:233:reduce > should not complete without seed if source emits but does not completes`       | should not complete without seed if source emits but does not completes       | `spec/operators/reduce-spec.ts:233` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/reduce-spec.ts:246:reduce > should not complete without seed if source never completes`                    | should not complete without seed if source never completes                    | `spec/operators/reduce-spec.ts:246` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/reduce-spec.ts:259:reduce > should reduce if source does not emit without seed`                            | should reduce if source does not emit without seed                            | `spec/operators/reduce-spec.ts:259` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:272:reduce > should raise error if source emits and raises error without seed`              | should raise error if source emits and raises error without seed              | `spec/operators/reduce-spec.ts:272` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:285:reduce > should raise error if source raises error without seed`                        | should raise error if source raises error without seed                        | `spec/operators/reduce-spec.ts:285` | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:29:reduce > should reduce with seed`                                                        | should reduce with seed                                                       | `spec/operators/reduce-spec.ts:29`  | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:42:reduce > should reduce with a seed of undefined`                                         | should reduce with a seed of undefined                                        | `spec/operators/reduce-spec.ts:42`  | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |
| `spec/operators/reduce-spec.ts:55:reduce > should reduce without a seed`                                                   | should reduce without a seed                                                  | `spec/operators/reduce-spec.ts:55`  | —            | `portable`     | `active`    | Missing operator capability: reduce                                                                  | `FIXED` |

### `refCount`

Owner source: `spec/operators/refCount-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                               | Source                              | Failing mode | Classification | Disposition | Concise failure                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ------------------------------------ | ------- |
| `spec/operators/refCount-spec.ts:9:refCount > should turn a multicasted Observable an automatically (dis)connecting hot one` | should turn a multicasted Observable an automatically (dis)connecting hot one | `spec/operators/refCount-spec.ts:9` | —            | `portable`     | `active`    | Missing operator capability: publish | `FIXED` |

### `repeat`

Owner source: `spec/operators/repeat-spec.ts`

| Case ID                                                                                                                                        | Behavioral test                                                                          | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/repeat-spec.ts:102:repeat operator > should not break unsubscription chain when unsubscribed explicitly`                       | should not break unsubscription chain when unsubscribed explicitly                       | `spec/operators/repeat-spec.ts:102` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:127:repeat operator > should consider negative count as no repeat, and return EMPTY`                            | should consider negative count as no repeat, and return EMPTY                            | `spec/operators/repeat-spec.ts:127` | —            | `portable`     | `active`    | rxTest exceeded maxTaskExecutions (100000).                                                          | `FIXED` |
| `spec/operators/repeat-spec.ts:15:repeat operator > should resubscribe count number of times`                                                  | should resubscribe count number of times                                                 | `spec/operators/repeat-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:178:repeat operator > should not complete when source never completes`                                          | should not complete when source never completes                                          | `spec/operators/repeat-spec.ts:178` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/repeat-spec.ts:189:repeat operator > should not complete when source does not completes`                                       | should not complete when source does not completes                                       | `spec/operators/repeat-spec.ts:189` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/repeat-spec.ts:201:repeat operator > should complete immediately when source does not complete without emit but count is zero` | should complete immediately when source does not complete without emit but count is zero | `spec/operators/repeat-spec.ts:201` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:212:repeat operator > should complete immediately when source does not complete but count is zero`              | should complete immediately when source does not complete but count is zero              | `spec/operators/repeat-spec.ts:212` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:223:repeat operator > should emit source once and does not complete when source emits but does not complete`    | should emit source once and does not complete when source emits but does not complete    | `spec/operators/repeat-spec.ts:223` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/repeat-spec.ts:234:repeat operator > should complete when source is empty`                                                     | should complete when source is empty                                                     | `spec/operators/repeat-spec.ts:234` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/repeat-spec.ts:245:repeat operator > should complete when source does not emit`                                                | should complete when source does not emit                                                | `spec/operators/repeat-spec.ts:245` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:260:repeat operator > should complete immediately when source does not emit but count is zero`                  | should complete immediately when source does not emit but count is zero                  | `spec/operators/repeat-spec.ts:260` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:30:repeat operator > should resubscribe multiple times`                                                         | should resubscribe multiple times                                                        | `spec/operators/repeat-spec.ts:30`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:304:repeat operator > should raise error after first emit succeed`                                              | should raise error after first emit succeed                                              | `spec/operators/repeat-spec.ts:304` | —            | `portable`     | `active`    | Missing operator capability: map                                                                     | `FIXED` |
| `spec/operators/repeat-spec.ts:365:repeat operator > should allow count configuration`                                                         | should allow count configuration                                                         | `spec/operators/repeat-spec.ts:365` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:380:repeat operator > should allow delay time configuration`                                                    | should allow delay time configuration                                                    | `spec/operators/repeat-spec.ts:380` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:396:repeat operator > should allow delay function configuration`                                                | should allow delay function configuration                                                | `spec/operators/repeat-spec.ts:396` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:46:repeat operator > should complete without emit when count is zero`                                           | should complete without emit when count is zero                                          | `spec/operators/repeat-spec.ts:46`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:57:repeat operator > should emit source once when count is one`                                                 | should emit source once when count is one                                                | `spec/operators/repeat-spec.ts:57`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:68:repeat operator > should repeat until gets unsubscribed`                                                     | should repeat until gets unsubscribed                                                    | `spec/operators/repeat-spec.ts:68`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/repeat-spec.ts:83:repeat operator > should be able to repeat indefinitely until unsubscribed`                                  | should be able to repeat indefinitely until unsubscribed                                 | `spec/operators/repeat-spec.ts:83`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `repeatWhen`

Owner source: `spec/operators/repeatWhen-spec.ts`

| Case ID                                                                                                                                                               | Behavioral test                                                                                         | Source                                  | Failing mode | Classification    | Disposition        | Concise failure                         | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ------------------ | --------------------------------------- | ------- |
| `spec/operators/repeatWhen-spec.ts:16:repeatWhen operator > should handle a source with eventual complete using a hot notifier`                                       | should handle a source with eventual complete using a hot notifier                                      | `spec/operators/repeatWhen-spec.ts:16`  | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:169:repeatWhen operator > should apply an empty notifier on an empty source`                                                       | should apply an empty notifier on an empty source                                                       | `spec/operators/repeatWhen-spec.ts:169` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:183:repeatWhen operator > should apply a never notifier on an empty source`                                                        | should apply a never notifier on an empty source                                                        | `spec/operators/repeatWhen-spec.ts:183` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:197:repeatWhen operator > should apply an empty notifier on a never source`                                                        | should apply an empty notifier on a never source                                                        | `spec/operators/repeatWhen-spec.ts:197` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:212:repeatWhen operator > should apply a never notifier on a never source`                                                         | should apply a never notifier on a never source                                                         | `spec/operators/repeatWhen-spec.ts:212` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:227:repeatWhen operator > should return an empty observable given a just-throw source and empty notifier`                          | should return an empty observable given a just-throw source and empty notifier                          | `spec/operators/repeatWhen-spec.ts:227` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:239:repeatWhen operator > should return a error observable given a just-throw source and never notifier`                           | should return a error observable given a just-throw source and never notifier                           | `spec/operators/repeatWhen-spec.ts:239` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:251:repeatWhen operator > should return a never-ending result if the notifier is never`                                            | should return a never-ending result if the notifier is never                                            | `spec/operators/repeatWhen-spec.ts:251` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:265:repeatWhen operator > should propagate error thrown from notifierSelector function`                                            | should propagate error thrown from notifierSelector function                                            | `spec/operators/repeatWhen-spec.ts:265` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:282:repeatWhen operator > should complete if the notifier only completes`                                                          | should complete if the notifier only completes                                                          | `spec/operators/repeatWhen-spec.ts:282` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:296:repeatWhen operator > should mirror a basic cold source with complete, given a never notifier`                                 | should mirror a basic cold source with complete, given a never notifier                                 | `spec/operators/repeatWhen-spec.ts:296` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:310:repeatWhen operator > should mirror a basic cold source with no termination, given a never notifier`                           | should mirror a basic cold source with no termination, given a never notifier                           | `spec/operators/repeatWhen-spec.ts:310` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:324:repeatWhen operator > should mirror a basic hot source with complete, given a never notifier`                                  | should mirror a basic hot source with complete, given a never notifier                                  | `spec/operators/repeatWhen-spec.ts:324` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:339:repeatWhen operator > should handle a host source that completes via operator like take, and a hot notifier`                   | should handle a host source that completes via operator like take, and a hot notifier                   | `spec/operators/repeatWhen-spec.ts:339` | —            | `harness-rewrite` | `expected-failure` | rxTest observable assertion failed.     | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:36:repeatWhen operator > should handle a source with eventual complete using a hot notifier that raises error`                     | should handle a source with eventual complete using a hot notifier that raises error                    | `spec/operators/repeatWhen-spec.ts:36`  | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:362:repeatWhen operator > should tear down resources when result is unsubscribed early`                                            | should tear down resources when result is unsubscribed early                                            | `spec/operators/repeatWhen-spec.ts:362` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:383:repeatWhen operator > should not break unsubscription chains when unsubscribed explicitly`                                     | should not break unsubscription chains when unsubscribed explicitly                                     | `spec/operators/repeatWhen-spec.ts:383` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:408:repeatWhen operator > should handle a source with eventual error using a dynamic notifier selector which eventually throws`    | should handle a source with eventual error using a dynamic notifier selector which eventually throws    | `spec/operators/repeatWhen-spec.ts:408` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |
| `spec/operators/repeatWhen-spec.ts:438:repeatWhen operator > should handle a source with eventual error using a dynamic notifier selector which eventually completes` | should handle a source with eventual error using a dynamic notifier selector which eventually completes | `spec/operators/repeatWhen-spec.ts:438` | —            | `portable`        | `active`           | Missing operator capability: repeatWhen | `FIXED` |

### `ReplaySubject`

Owner source: `spec/subjects/ReplaySubject-spec.ts`

| Case ID                                                                                                                                                   | Behavioral test                                                             | Source                                    | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------- | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/subjects/ReplaySubject-spec.ts:117:ReplaySubject > with bufferSize=2 > should replay 2 previous values when subscribed`                             | should replay 2 previous values when subscribed                             | `spec/subjects/ReplaySubject-spec.ts:117` | —            | `harness-rewrite` | `active`    | Missing operator capability: tap    | `FIXED` |
| `spec/subjects/ReplaySubject-spec.ts:149:ReplaySubject > with bufferSize=2 > should replay 2 last values for when subscribed after completed`             | should replay 2 last values for when subscribed after completed             | `spec/subjects/ReplaySubject-spec.ts:149` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed. | `FIXED` |
| `spec/subjects/ReplaySubject-spec.ts:247:ReplaySubject > with windowTime=4 > should replay previous values since 4 time units ago when subscribed`        | should replay previous values since 4 time units ago when subscribed        | `spec/subjects/ReplaySubject-spec.ts:247` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined      | `FIXED` |
| `spec/subjects/ReplaySubject-spec.ts:279:ReplaySubject > with windowTime=4 > should replay last values since 4 time units ago when subscribed`            | should replay last values since 4 time units ago when subscribed            | `spec/subjects/ReplaySubject-spec.ts:279` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined      | `FIXED` |
| `spec/subjects/ReplaySubject-spec.ts:303:ReplaySubject > with windowTime=4 > should only replay bufferSize items when 4 time units ago more were emitted` | should only replay bufferSize items when 4 time units ago more were emitted | `spec/subjects/ReplaySubject-spec.ts:303` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined      | `FIXED` |

### `retry`

Owner source: `spec/operators/retry-spec.ts`

| Case ID                                                                                                                                             | Behavioral test                                                                           | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/retry-spec.ts:15:retry > should handle a basic source that emits next then errors, count=3`                                         | should handle a basic source that emits next then errors, count=3                         | `spec/operators/retry-spec.ts:15`  | —            | `portable`     | `active`    | rxTest exceeded maxTaskExecutions (100000).                                                          | `FIXED` |
| `spec/operators/retry-spec.ts:239:retry > should handle a never source`                                                                             | should handle a never source                                                              | `spec/operators/retry-spec.ts:239` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/retry-spec.ts:277:retry > should handle a basic source that emits next but does not complete`                                       | should handle a basic source that emits next but does not complete                        | `spec/operators/retry-spec.ts:277` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/retry-spec.ts:290:retry > should handle a basic source that emits next then errors, no count`                                       | should handle a basic source that emits next then errors, no count                        | `spec/operators/retry-spec.ts:290` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:314:retry > should handle a source which eventually throws, count=3, and result is unsubscribed early`                | should handle a source which eventually throws, count=3, and result is unsubscribed early | `spec/operators/retry-spec.ts:314` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:333:retry > should not break unsubscription chain when unsubscribed explicitly`                                       | should not break unsubscription chain when unsubscribed explicitly                        | `spec/operators/retry-spec.ts:333` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:399:retry > should not alter the source when the number of retries is smaller than 1`                                 | should not alter the source when the number of retries is smaller than 1                  | `spec/operators/retry-spec.ts:399` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:483:retry > with delay config > of a number > should honor count as the max retries`                                  | should honor count as the max retries                                                     | `spec/operators/retry-spec.ts:483` | —            | `portable`     | `active`    | rxTest exceeded maxTaskExecutions (100000).                                                          | `FIXED` |
| `spec/operators/retry-spec.ts:507:retry > with delay config > of a function > should delay the retry with a function that returns a notifier`       | should delay the retry with a function that returns a notifier                            | `spec/operators/retry-spec.ts:507` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:532:retry > with delay config > of a function > should delay the retry with a function that returns a hot observable` | should delay the retry with a function that returns a hot observable                      | `spec/operators/retry-spec.ts:532` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/retry-spec.ts:561:retry > with delay config > of a function > should complete if the notifier completes`                            | should complete if the notifier completes                                                 | `spec/operators/retry-spec.ts:561` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:584:retry > with delay config > of a function > should error if the notifier errors`                                  | should error if the notifier errors                                                       | `spec/operators/retry-spec.ts:584` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:607:retry > with delay config > of a function > should error if the delay function throws`                            | should error if the delay function throws                                                 | `spec/operators/retry-spec.ts:607` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/retry-spec.ts:634:retry > with delay config > of a function > should be usable for exponential backoff`                             | should be usable for exponential backoff                                                  | `spec/operators/retry-spec.ts:634` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `retryWhen`

Owner source: `spec/operators/retryWhen-spec.ts`

| Case ID                                                                                                                                                    | Behavioral test                                                                                         | Source                                 | Failing mode | Classification | Disposition | Concise failure                        | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | -------------------------------------- | ------- |
| `spec/operators/retryWhen-spec.ts:116:retryWhen > should apply an empty notifier on an empty source`                                                       | should apply an empty notifier on an empty source                                                       | `spec/operators/retryWhen-spec.ts:116` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:130:retryWhen > should apply a never notifier on an empty source`                                                        | should apply a never notifier on an empty source                                                        | `spec/operators/retryWhen-spec.ts:130` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:144:retryWhen > should apply an empty notifier on a never source`                                                        | should apply an empty notifier on a never source                                                        | `spec/operators/retryWhen-spec.ts:144` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:15:retryWhen > should handle a source with eventual error using a hot notifier`                                          | should handle a source with eventual error using a hot notifier                                         | `spec/operators/retryWhen-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:159:retryWhen > should apply a never notifier on a never source`                                                         | should apply a never notifier on a never source                                                         | `spec/operators/retryWhen-spec.ts:159` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:174:retryWhen > should return an empty observable given a just-throw source and empty notifier`                          | should return an empty observable given a just-throw source and empty notifier                          | `spec/operators/retryWhen-spec.ts:174` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:186:retryWhen > should return a never observable given a just-throw source and never notifier`                           | should return a never observable given a just-throw source and never notifier                           | `spec/operators/retryWhen-spec.ts:186` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:198:retryWhen > should hide errors using a never notifier on a source with eventual error`                               | should hide errors using a never notifier on a source with eventual error                               | `spec/operators/retryWhen-spec.ts:198` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:212:retryWhen > should propagate error thrown from notifierSelector function`                                            | should propagate error thrown from notifierSelector function                                            | `spec/operators/retryWhen-spec.ts:212` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:229:retryWhen > should replace error with complete using an empty notifier on a source with eventual error`              | should replace error with complete using an empty notifier on a source with eventual error              | `spec/operators/retryWhen-spec.ts:229` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:243:retryWhen > should mirror a basic cold source with complete, given an empty notifier`                                | should mirror a basic cold source with complete, given an empty notifier                                | `spec/operators/retryWhen-spec.ts:243` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:257:retryWhen > should mirror a basic cold source with no termination, given an empty notifier`                          | should mirror a basic cold source with no termination, given an empty notifier                          | `spec/operators/retryWhen-spec.ts:257` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:271:retryWhen > should mirror a basic hot source with complete, given an empty notifier`                                 | should mirror a basic hot source with complete, given an empty notifier                                 | `spec/operators/retryWhen-spec.ts:271` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:285:retryWhen > should handle a hot source that raises error but eventually completes`                                   | should handle a hot source that raises error but eventually completes                                   | `spec/operators/retryWhen-spec.ts:285` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:312:retryWhen > should tear down resources when result is unsubscribed early`                                            | should tear down resources when result is unsubscribed early                                            | `spec/operators/retryWhen-spec.ts:312` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:335:retryWhen > should not break unsubscription chains when unsubscribed explicitly`                                     | should not break unsubscription chains when unsubscribed explicitly                                     | `spec/operators/retryWhen-spec.ts:335` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:35:retryWhen > should handle a source with eventual error using a hot notifier that raises error`                        | should handle a source with eventual error using a hot notifier that raises error                       | `spec/operators/retryWhen-spec.ts:35`  | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:362:retryWhen > should handle a source with eventual error using a dynamic notifier selector which eventually throws`    | should handle a source with eventual error using a dynamic notifier selector which eventually throws    | `spec/operators/retryWhen-spec.ts:362` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |
| `spec/operators/retryWhen-spec.ts:394:retryWhen > should handle a source with eventual error using a dynamic notifier selector which eventually completes` | should handle a source with eventual error using a dynamic notifier selector which eventually completes | `spec/operators/retryWhen-spec.ts:394` | —            | `portable`     | `active`    | Missing operator capability: retryWhen | `FIXED` |

### `sample`

Owner source: `spec/operators/sample-spec.ts`

| Case ID                                                                                                                                        | Behavioral test                                                                                    | Source                              | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/sample-spec.ts:112:sample > should allow unsubscribing explicitly and early`                                                   | should allow unsubscribing explicitly and early                                                    | `spec/operators/sample-spec.ts:112` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:127:sample > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                      | `spec/operators/sample-spec.ts:127` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:148:sample > should only sample when a new value arrives, even if it is the same value`                         | should only sample when a new value arrives, even if it is the same value                          | `spec/operators/sample-spec.ts:148` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:15:sample > should get samples when the notifier emits`                                                         | should get samples when the notifier emits                                                         | `spec/operators/sample-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:162:sample > should raise error if source raises error`                                                         | should raise error if source raises error                                                          | `spec/operators/sample-spec.ts:162` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:176:sample > should completes if source does not emits`                                                         | should completes if source does not emits                                                          | `spec/operators/sample-spec.ts:176` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:190:sample > should raise error if source throws immediately`                                                   | should raise error if source throws immediately                                                    | `spec/operators/sample-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:204:sample > should raise error if notification raises error`                                                   | should raise error if notification raises error                                                    | `spec/operators/sample-spec.ts:204` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:218:sample > should not completes if source does not complete`                                                  | should not completes if source does not complete                                                   | `spec/operators/sample-spec.ts:218` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:232:sample > should sample only until source completes`                                                         | should sample only until source completes                                                          | `spec/operators/sample-spec.ts:232` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:246:sample > should complete sampling if sample observable completes`                                           | should complete sampling if sample observable completes                                            | `spec/operators/sample-spec.ts:246` | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:29:sample > should sample nothing if source has not nexted at all`                                              | should sample nothing if source has not nexted at all                                              | `spec/operators/sample-spec.ts:29`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:56:sample > should sample nothing if source has nexted after all notifications, but notifier does not complete` | should sample nothing if source has nexted after all notifications, but notifier does not complete | `spec/operators/sample-spec.ts:56`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:70:sample > should not sample when the notifier completes`                                                      | should not sample when the notifier completes                                                      | `spec/operators/sample-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:84:sample > should not complete when the notifier completes, nor should it emit`                                | should not complete when the notifier completes, nor should it emit                                | `spec/operators/sample-spec.ts:84`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |
| `spec/operators/sample-spec.ts:98:sample > should complete only when the source completes, if notifier completes early`                        | should complete only when the source completes, if notifier completes early                        | `spec/operators/sample-spec.ts:98`  | —            | `portable`     | `active`    | Missing operator capability: sample | `FIXED` |

### `sampleTime`

Owner source: `spec/operators/sampleTime-spec.ts`

| Case ID                                                                                                                           | Behavioral test                                                               | Source                                  | Failing mode | Classification | Disposition | Concise failure                         | Status  |
| --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | --------------------------------------- | ------- |
| `spec/operators/sampleTime-spec.ts:113:sampleTime > should completes if source does not emits`                                    | should completes if source does not emits                                     | `spec/operators/sampleTime-spec.ts:113` | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:125:sampleTime > should raise error if source throws immediately`                              | should raise error if source throws immediately                               | `spec/operators/sampleTime-spec.ts:125` | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:137:sampleTime > should not complete if source does not complete`                              | should not complete if source does not complete                               | `spec/operators/sampleTime-spec.ts:137` | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:14:sampleTime > should get samples on a delay`                                                 | should get samples on a delay                                                 | `spec/operators/sampleTime-spec.ts:14`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:27:sampleTime > should sample nothing if new value has not arrived`                            | should sample nothing if new value has not arrived                            | `spec/operators/sampleTime-spec.ts:27`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:40:sampleTime > should sample if new value has arrived, even if it is the same value`          | should sample if new value has arrived, even if it is the same value          | `spec/operators/sampleTime-spec.ts:40`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:53:sampleTime > should sample nothing if source has not nexted by time of sample`              | should sample nothing if source has not nexted by time of sample              | `spec/operators/sampleTime-spec.ts:53`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:66:sampleTime > should raise error if source raises error`                                     | should raise error if source raises error                                     | `spec/operators/sampleTime-spec.ts:66`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:79:sampleTime > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/sampleTime-spec.ts:79`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |
| `spec/operators/sampleTime-spec.ts:93:sampleTime > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/sampleTime-spec.ts:93`  | —            | `portable`     | `active`    | Missing operator capability: sampleTime | `FIXED` |

### `scan`

Owner source: `spec/operators/scan-spec.ts`

| Case ID                                                                                                                | Behavioral test                                                               | Source                            | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/scan-spec.ts:171:scan > handle never`                                                                  | handle never                                                                  | `spec/operators/scan-spec.ts:171` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/scan-spec.ts:197:scan > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/scan-spec.ts:197` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/scan-spec.ts:219:scan > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/scan-spec.ts:219` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/scan-spec.ts:245:scan > should pass current index to accumulator`                                      | should pass current index to accumulator                                      | `spec/operators/scan-spec.ts:245` | —            | `portable`     | `active`    | Missing operator capability: finalize                                                                | `FIXED` |
| `spec/operators/scan-spec.ts:91:scan > should scan without seed`                                                       | should scan without seed                                                      | `spec/operators/scan-spec.ts:91`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `scheduled`

Owner source: `spec/scheduled/scheduled-spec.ts`

| Case ID                                                                              | Behavioral test                    | Source                                | Failing mode    | Classification       | Disposition        | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------ | ---------------------------------- | ------------------------------------- | --------------- | -------------------- | ------------------ | ----------------------------------- | ------- |
| `spec/scheduled/scheduled-spec.ts:14:scheduled > should schedule a sync observable`  | should schedule a sync observable  | `spec/scheduled/scheduled-spec.ts:14` | —               | `harness-rewrite`    | `active`           | testScheduler is not defined        | `FIXED` |
| `spec/scheduled/scheduled-spec.ts:21:scheduled > should schedule an array`           | should schedule an array           | `spec/scheduled/scheduled-spec.ts:21` | —               | `harness-rewrite`    | `active`           | testScheduler is not defined        | `FIXED` |
| `spec/scheduled/scheduled-spec.ts:28:scheduled > should schedule an iterable`        | should schedule an iterable        | `spec/scheduled/scheduled-spec.ts:28` | —               | `harness-rewrite`    | `active`           | testScheduler is not defined        | `FIXED` |
| `spec/scheduled/scheduled-spec.ts:35:scheduled > should schedule an observable-like` | should schedule an observable-like | `spec/scheduled/scheduled-spec.ts:35` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed. | `TODO`  |

### `sequenceEqual`

Owner source: `spec/operators/sequenceEqual-spec.ts`

| Case ID                                                                                                                                           | Behavioral test                                                                        | Source                                     | Failing mode | Classification    | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------ | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/sequenceEqual-spec.ts:129:sequenceEqual > should never return if source is a never`                                               | should never return if source is a never                                               | `spec/operators/sequenceEqual-spec.ts:129` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:141:sequenceEqual > should never return if compareTo is a never`                                            | should never return if compareTo is a never                                            | `spec/operators/sequenceEqual-spec.ts:141` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:153:sequenceEqual > should return false if source is empty and compareTo is not`                            | should return false if source is empty and compareTo is not                            | `spec/operators/sequenceEqual-spec.ts:153` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:169:sequenceEqual > should return false if compareTo is empty and source is not`                            | should return false if compareTo is empty and source is not                            | `spec/operators/sequenceEqual-spec.ts:169` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:185:sequenceEqual > should return never if compareTo is empty and source is never`                          | should return never if compareTo is empty and source is never                          | `spec/operators/sequenceEqual-spec.ts:185` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:197:sequenceEqual > should return never if source is empty and compareTo is never`                          | should return never if source is empty and compareTo is never                          | `spec/operators/sequenceEqual-spec.ts:197` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:209:sequenceEqual > should error if the comparator function errors`                                         | should error if the comparator function errors                                         | `spec/operators/sequenceEqual-spec.ts:209` | —            | `portable`        | `active`    | Unsupported RxJS 7 sequenceEqual comparator overload.                                                | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:243:sequenceEqual > should use the provided comparator function`                                            | should use the provided comparator function                                            | `spec/operators/sequenceEqual-spec.ts:243` | —            | `portable`        | `active`    | Unsupported RxJS 7 sequenceEqual comparator overload.                                                | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:301:sequenceEqual > should return false when the source emits an extra value after the compareTo completes` | should return false when the source emits an extra value after the compareTo completes | `spec/operators/sequenceEqual-spec.ts:301` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:317:sequenceEqual > should return false when the compareTo emits an extra value after the source completes` | should return false when the compareTo emits an extra value after the source completes | `spec/operators/sequenceEqual-spec.ts:317` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:344:sequenceEqual > should return false for an empty observable and an observable that emits`               | should return false for an empty observable and an observable that emits               | `spec/operators/sequenceEqual-spec.ts:344` | —            | `portable`        | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/sequenceEqual-spec.ts:355:sequenceEqual > should return compare hot and cold observables`                                         | should return compare hot and cold observables                                         | `spec/operators/sequenceEqual-spec.ts:355` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `share`

Owner source: `spec/operators/share-spec.ts`

| Case ID                                                                                                                                                                                                                                                                                                                                                                        | Behavioral test                                                                                                                                                                                              | Source                             | Failing mode | Classification    | Disposition        | Concise failure                                                  | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------- | ------------ | ----------------- | ------------------ | ---------------------------------------------------------------- | ------- |
| `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                      | should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                     | `spec/operators/share-spec.ts:113` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                        | should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                      | `spec/operators/share-spec.ts:113` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                    | should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                    | `spec/operators/share-spec.ts:113` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                | should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config]                                                                                  | `spec/operators/share-spec.ts:113` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                | should not change the output of the observable when error [share()]                                                                                                                                          | `spec/operators/share-spec.ts:113` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`            | should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]           | `spec/operators/share-spec.ts:124` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`              | should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]            | `spec/operators/share-spec.ts:124` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`          | should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]          | `spec/operators/share-spec.ts:124` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                      | should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config]                                                        | `spec/operators/share-spec.ts:124` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share()] [share-config-0:share()]`                                                                                                                                                                                                                      | should not change the output of the observable when successful with cold observable [share()]                                                                                                                | `spec/operators/share-spec.ts:124` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                 | should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                | `spec/operators/share-spec.ts:135` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                   | should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                 | `spec/operators/share-spec.ts:135` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`               | should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]               | `spec/operators/share-spec.ts:135` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                           | should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config]                                                             | `spec/operators/share-spec.ts:135` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share()] [share-config-0:share()]`                                                                                                                                                                                                                           | should not change the output of the observable when error with cold observable [share()]                                                                                                                     | `spec/operators/share-spec.ts:135` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                         | should retry just fine [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                        | `spec/operators/share-spec.ts:146` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                           | should retry just fine [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                         | `spec/operators/share-spec.ts:146` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                       | should retry just fine [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                       | `spec/operators/share-spec.ts:146` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                                   | should retry just fine [share() using sync reset notifiers equivalent to default config]                                                                                                                     | `spec/operators/share-spec.ts:146` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:146:should retry just fine [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                                   | should retry just fine [share()]                                                                                                                                                                             | `spec/operators/share-spec.ts:146` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                             | should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                            | `spec/operators/share-spec.ts:161` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                               | should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                             | `spec/operators/share-spec.ts:161` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                           | should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                           | `spec/operators/share-spec.ts:161` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                       | should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config]                                                                                         | `spec/operators/share-spec.ts:161` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                       | should share the same values to multiple observers [share()]                                                                                                                                                 | `spec/operators/share-spec.ts:161` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                    | should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                   | `spec/operators/share-spec.ts:181` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                      | should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                    | `spec/operators/share-spec.ts:181` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                  | should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                  | `spec/operators/share-spec.ts:181` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                              | should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config]                                                                                | `spec/operators/share-spec.ts:181` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share()] [share-config-0:share()]`                                                                                                                                                                                                                                              | should share an error from the source to multiple observers [share()]                                                                                                                                        | `spec/operators/share-spec.ts:181` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`   | should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]  | `spec/operators/share-spec.ts:201` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`     | should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]   | `spec/operators/share-spec.ts:201` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]` | should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] | `spec/operators/share-spec.ts:201` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                             | should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config]                                               | `spec/operators/share-spec.ts:201` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share()] [share-config-0:share()]`                                                                                                                                                                                                             | should share the same values to multiple observers, but is unsubscribed explicitly and early [share()]                                                                                                       | `spec/operators/share-spec.ts:201` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                   | should share an empty source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                  | `spec/operators/share-spec.ts:222` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                     | should share an empty source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                   | `spec/operators/share-spec.ts:222` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                 | should share an empty source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                 | `spec/operators/share-spec.ts:222` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                             | should share an empty source [share() using sync reset notifiers equivalent to default config]                                                                                                               | `spec/operators/share-spec.ts:222` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:222:should share an empty source [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                             | should share an empty source [share()]                                                                                                                                                                       | `spec/operators/share-spec.ts:222` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                    | should share a never source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                   | `spec/operators/share-spec.ts:235` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                      | should share a never source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                    | `spec/operators/share-spec.ts:235` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                  | should share a never source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                  | `spec/operators/share-spec.ts:235` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                              | should share a never source [share() using sync reset notifiers equivalent to default config]                                                                                                                | `spec/operators/share-spec.ts:235` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:235:should share a never source [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                              | should share a never source [share()]                                                                                                                                                                        | `spec/operators/share-spec.ts:235` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                    | should share a throw source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                   | `spec/operators/share-spec.ts:248` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                      | should share a throw source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                    | `spec/operators/share-spec.ts:248` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                  | should share a throw source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                  | `spec/operators/share-spec.ts:248` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                              | should share a throw source [share() using sync reset notifiers equivalent to default config]                                                                                                                | `spec/operators/share-spec.ts:248` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:248:should share a throw source [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                              | should share a throw source [share()]                                                                                                                                                                        | `spec/operators/share-spec.ts:248` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                | should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                               | `spec/operators/share-spec.ts:261` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                  | should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                | `spec/operators/share-spec.ts:261` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                              | should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                              | `spec/operators/share-spec.ts:261` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                          | should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config]                                                                                            | `spec/operators/share-spec.ts:261` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                          | should connect when first subscriber subscribes [share()]                                                                                                                                                    | `spec/operators/share-spec.ts:261` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                            | should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                           | `spec/operators/share-spec.ts:281` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                              | should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                            | `spec/operators/share-spec.ts:281` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                          | should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                          | `spec/operators/share-spec.ts:281` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                      | should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config]                                                                                        | `spec/operators/share-spec.ts:281` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                      | should disconnect when last subscriber unsubscribes [share()]                                                                                                                                                | `spec/operators/share-spec.ts:281` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                        | should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                       | `spec/operators/share-spec.ts:300` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                          | should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                        | `spec/operators/share-spec.ts:300` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                      | should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                      | `spec/operators/share-spec.ts:300` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                  | should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config]                                                                    | `spec/operators/share-spec.ts:300` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share()] [share-config-0:share()]`                                                                                                                                                                                                                                  | should not break unsubscription chain when last subscriber unsubscribes [share()]                                                                                                                            | `spec/operators/share-spec.ts:300` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                            | should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                           | `spec/operators/share-spec.ts:323` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                              | should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                            | `spec/operators/share-spec.ts:323` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                          | should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                          | `spec/operators/share-spec.ts:323` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                      | should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config]                                                                                        | `spec/operators/share-spec.ts:323` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                      | should be retryable when cold source is synchronous [share()]                                                                                                                                                | `spec/operators/share-spec.ts:323` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                           | should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                          | `spec/operators/share-spec.ts:359` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                             | should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                           | `spec/operators/share-spec.ts:359` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                         | should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                         | `spec/operators/share-spec.ts:359` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                     | should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config]                                                                                       | `spec/operators/share-spec.ts:359` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                     | should be repeatable when cold source is synchronous [share()]                                                                                                                                               | `spec/operators/share-spec.ts:359` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                            | should be retryable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                           | `spec/operators/share-spec.ts:395` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                              | should be retryable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                            | `spec/operators/share-spec.ts:395` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                          | should be retryable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                          | `spec/operators/share-spec.ts:395` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                                      | should be retryable [share() using sync reset notifiers equivalent to default config]                                                                                                                        | `spec/operators/share-spec.ts:395` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:395:should be retryable [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                                      | should be retryable [share()]                                                                                                                                                                                | `spec/operators/share-spec.ts:395` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                                           | should be repeatable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                                          | `spec/operators/share-spec.ts:430` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                                             | should be repeatable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                                           | `spec/operators/share-spec.ts:430` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                                         | should be repeatable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                                         | `spec/operators/share-spec.ts:430` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                                     | should be repeatable [share() using sync reset notifiers equivalent to default config]                                                                                                                       | `spec/operators/share-spec.ts:430` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:430:should be repeatable [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                                     | should be repeatable [share()]                                                                                                                                                                               | `spec/operators/share-spec.ts:430` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                      | should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                     | `spec/operators/share-spec.ts:465` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                        | should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                      | `spec/operators/share-spec.ts:465` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                    | should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                    | `spec/operators/share-spec.ts:465` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                | should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config]                                                                                  | `spec/operators/share-spec.ts:465` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                | should not change the output of the observable when never [share()]                                                                                                                                          | `spec/operators/share-spec.ts:465` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                      | should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                     | `spec/operators/share-spec.ts:474` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                        | should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                      | `spec/operators/share-spec.ts:474` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                    | should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                    | `spec/operators/share-spec.ts:474` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                | should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config]                                                                                  | `spec/operators/share-spec.ts:474` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                | should not change the output of the observable when empty [share()]                                                                                                                                          | `spec/operators/share-spec.ts:474` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                      | should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                     | `spec/operators/share-spec.ts:501` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                        | should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                      | `spec/operators/share-spec.ts:501` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                    | should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                    | `spec/operators/share-spec.ts:501` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                | should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config]                                                                                                  | `spec/operators/share-spec.ts:501` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                | should not fail on reentrant subscription [share()]                                                                                                                                                          | `spec/operators/share-spec.ts:501` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`                                                                                                                                               | should not reset on error if configured to do so [share(config) using EMPTY as sync reset notifier equivalents]                                                                                              | `spec/operators/share-spec.ts:538` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`                                                                                                                                               | should not reset on error if configured to do so [share(config) using NEVER as sync reset notifier equivalents]                                                                                              | `spec/operators/share-spec.ts:538` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config)] [share-config-0:share(config)]`                                                                                                                                                                                                                                             | should not reset on error if configured to do so [share(config)]                                                                                                                                             | `spec/operators/share-spec.ts:538` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`                                                                                                                                            | should not reset on complete if configured to do so [share(config) using EMPTY as sync reset notifier equivalents]                                                                                           | `spec/operators/share-spec.ts:559` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`                                                                                                                                            | should not reset on complete if configured to do so [share(config) using NEVER as sync reset notifier equivalents]                                                                                           | `spec/operators/share-spec.ts:559` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config)] [share-config-0:share(config)]`                                                                                                                                                                                                                                          | should not reset on complete if configured to do so [share(config)]                                                                                                                                          | `spec/operators/share-spec.ts:559` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`                                                                                                                                          | should not reset on refCount 0 if configured to do so [share(config) using EMPTY as sync reset notifier equivalents]                                                                                         | `spec/operators/share-spec.ts:593` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`                                                                                                                                          | should not reset on refCount 0 if configured to do so [share(config) using NEVER as sync reset notifier equivalents]                                                                                         | `spec/operators/share-spec.ts:593` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config)] [share-config-0:share(config)]`                                                                                                                                                                                                                                        | should not reset on refCount 0 if configured to do so [share(config)]                                                                                                                                        | `spec/operators/share-spec.ts:593` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`                                                                                                                                                            | should be referentially-transparent [share(config) using EMPTY as sync reset notifier equivalents]                                                                                                           | `spec/operators/share-spec.ts:622` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`                                                                                                                                                            | should be referentially-transparent [share(config) using NEVER as sync reset notifier equivalents]                                                                                                           | `spec/operators/share-spec.ts:622` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config)] [share-config-0:share(config)]`                                                                                                                                                                                                                                                          | should be referentially-transparent [share(config)]                                                                                                                                                          | `spec/operators/share-spec.ts:622` | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:649:share > share(config) > should use the connector function provided`                                                                                                                                                                                                                                                                          | should use the connector function provided                                                                                                                                                                   | `spec/operators/share-spec.ts:649` | —            | `harness-rewrite` | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:703:share > share(config) with async/deferred reset notifiers > should reset on refCount 0 when synchronously resubscribing and using a sync reset notifier`                                                                                                                                                                                     | should reset on refCount 0 when synchronously resubscribing and using a sync reset notifier                                                                                                                  | `spec/operators/share-spec.ts:703` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:723:share > share(config) with async/deferred reset notifiers > should not reset on refCount 0 when synchronously resubscribing and using a deferred reset notifier`                                                                                                                                                                             | should not reset on refCount 0 when synchronously resubscribing and using a deferred reset notifier                                                                                                          | `spec/operators/share-spec.ts:723` | —            | `harness-rewrite` | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:739:share > share(config) with async/deferred reset notifiers > should reset on refCount 0 only after reset notifier emitted`                                                                                                                                                                                                                    | should reset on refCount 0 only after reset notifier emitted                                                                                                                                                 | `spec/operators/share-spec.ts:739` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:763:share > share(config) with async/deferred reset notifiers > should reset on error only after reset notifier emitted`                                                                                                                                                                                                                         | should reset on error only after reset notifier emitted                                                                                                                                                      | `spec/operators/share-spec.ts:763` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:788:share > share(config) with async/deferred reset notifiers > should reset on complete only after reset notifier emitted`                                                                                                                                                                                                                      | should reset on complete only after reset notifier emitted                                                                                                                                                   | `spec/operators/share-spec.ts:788` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:813:share > share(config) with async/deferred reset notifiers > should not reset on refCount 0 if reset notifier errors before emitting any value`                                                                                                                                                                                               | should not reset on refCount 0 if reset notifier errors before emitting any value                                                                                                                            | `spec/operators/share-spec.ts:813` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'onUnhandledError') | `FIXED` |
| `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`                                                        | should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified]                                                      | `spec/operators/share-spec.ts:84`  | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`                                                          | should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]                                                       | `spec/operators/share-spec.ts:84`  | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`                                                      | should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]                                                     | `spec/operators/share-spec.ts:84`  | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`                                                                                                                                                  | should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config]                                                                                                   | `spec/operators/share-spec.ts:84`  | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share()] [share-config-0:share()]`                                                                                                                                                                                                                                                                  | should mirror a simple source Observable [share()]                                                                                                                                                           | `spec/operators/share-spec.ts:84`  | —            | `harness-rewrite` | `expected-failure` | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:840:share > share(config) with async/deferred reset notifiers > should not reset on error if reset notifier errors before emitting any value`                                                                                                                                                                                                    | should not reset on error if reset notifier errors before emitting any value                                                                                                                                 | `spec/operators/share-spec.ts:840` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'onUnhandledError') | `FIXED` |
| `spec/operators/share-spec.ts:865:share > share(config) with async/deferred reset notifiers > should not reset on complete if reset notifier errors before emitting any value`                                                                                                                                                                                                 | should not reset on complete if reset notifier errors before emitting any value                                                                                                                              | `spec/operators/share-spec.ts:865` | —            | `harness-rewrite` | `active`           | Cannot read properties of undefined (reading 'onUnhandledError') | `FIXED` |
| `spec/operators/share-spec.ts:890:share > share(config) with async/deferred reset notifiers > should not call "resetOnRefCountZero" on error`                                                                                                                                                                                                                                  | should not call "resetOnRefCountZero" on error                                                                                                                                                               | `spec/operators/share-spec.ts:890` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |
| `spec/operators/share-spec.ts:917:share > share(config) with async/deferred reset notifiers > should not call "resetOnRefCountZero" on complete`                                                                                                                                                                                                                               | should not call "resetOnRefCountZero" on complete                                                                                                                                                            | `spec/operators/share-spec.ts:917` | —            | `portable`        | `active`           | scheduled is not a function                                      | `FIXED` |

### `shareReplay`

Owner source: `spec/operators/shareReplay-spec.ts`

| Case ID                                                                                                                                            | Behavioral test                                                                             | Source                                   | Failing mode | Classification    | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ---------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/shareReplay-spec.ts:111:shareReplay > should multicast a never source`                                                             | should multicast a never source                                                             | `spec/operators/shareReplay-spec.ts:111` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/shareReplay-spec.ts:124:shareReplay > should multicast a throw source`                                                             | should multicast a throw source                                                             | `spec/operators/shareReplay-spec.ts:124` | —            | `portable`        | `active`    | Missing operator capability: shareReplay                                                             | `FIXED` |
| `spec/operators/shareReplay-spec.ts:137:shareReplay > should replay results to subsequent subscriptions if source completes, bufferSize=2`         | should replay results to subsequent subscriptions if source completes, bufferSize=2         | `spec/operators/shareReplay-spec.ts:137` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:157:shareReplay > should completely restart for subsequent subscriptions if source errors, bufferSize=2`       | should completely restart for subsequent subscriptions if source errors, bufferSize=2       | `spec/operators/shareReplay-spec.ts:157` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:16:shareReplay > should mirror a simple source Observable`                                                     | should mirror a simple source Observable                                                    | `spec/operators/shareReplay-spec.ts:16`  | —            | `portable`        | `active`    | Missing operator capability: shareReplay                                                             | `FIXED` |
| `spec/operators/shareReplay-spec.ts:178:shareReplay > should be retryable, bufferSize=2`                                                           | should be retryable, bufferSize=2                                                           | `spec/operators/shareReplay-spec.ts:178` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:209:shareReplay > should not restart due to unsubscriptions if refCount is false`                              | should not restart due to unsubscriptions if refCount is false                              | `spec/operators/shareReplay-spec.ts:209` | —            | `harness-rewrite` | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/shareReplay-spec.ts:226:shareReplay > should restart due to unsubscriptions if refCount is true`                                   | should restart due to unsubscriptions if refCount is true                                   | `spec/operators/shareReplay-spec.ts:226` | —            | `harness-rewrite` | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/shareReplay-spec.ts:245:shareReplay > should not restart due to unsubscriptions if refCount is true when the source has completed` | should not restart due to unsubscriptions if refCount is true when the source has completed | `spec/operators/shareReplay-spec.ts:245` | —            | `harness-rewrite` | `active`    | Missing operator capability: shareReplay                                                             | `FIXED` |
| `spec/operators/shareReplay-spec.ts:291:shareReplay > should default to refCount being false`                                                      | should default to refCount being false                                                      | `spec/operators/shareReplay-spec.ts:291` | —            | `harness-rewrite` | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/shareReplay-spec.ts:343:shareReplay > should not skip values on a sync source`                                                     | should not skip values on a sync source                                                     | `spec/operators/shareReplay-spec.ts:343` | —            | `portable`        | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/shareReplay-spec.ts:38:shareReplay > should multicast the same values to multiple observers, bufferSize=1`                         | should multicast the same values to multiple observers, bufferSize=1                        | `spec/operators/shareReplay-spec.ts:38`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:404:shareReplay > should be referentially-transparent`                                                         | should be referentially-transparent                                                         | `spec/operators/shareReplay-spec.ts:404` | —            | `harness-rewrite` | `active`    | Missing operator capability: shareReplay                                                             | `FIXED` |
| `spec/operators/shareReplay-spec.ts:58:shareReplay > should multicast the same values to multiple observers, bufferSize=2`                         | should multicast the same values to multiple observers, bufferSize=2                        | `spec/operators/shareReplay-spec.ts:58`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:78:shareReplay > should multicast an error from the source to multiple observers`                              | should multicast an error from the source to multiple observers                             | `spec/operators/shareReplay-spec.ts:78`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/shareReplay-spec.ts:98:shareReplay > should multicast an empty source`                                                             | should multicast an empty source                                                            | `spec/operators/shareReplay-spec.ts:98`  | —            | `portable`        | `active`    | Missing operator capability: shareReplay                                                             | `FIXED` |

### `single`

Owner source: `spec/operators/single-spec.ts`

| Case ID                                                                                                                                                | Behavioral test                                                                                  | Source                              | Failing mode | Classification | Disposition | Concise failure                     | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ | ----------------------------------- | ------------ | -------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/single-spec.ts:100:single operator > should raise error if predicate throws error`                                                     | should raise error if predicate throws error                                                     | `spec/operators/single-spec.ts:100` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:120:single operator > should return element from predicate if observable have single matching element`                  | should return element from predicate if observable have single matching element                  | `spec/operators/single-spec.ts:120` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:131:single operator > should raise error from predicate if observable have multiple matching element`                   | should raise error from predicate if observable have multiple matching element                   | `spec/operators/single-spec.ts:131` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:142:single operator > should raise error from predicate if observable does not emit`                                    | should raise error from predicate if observable does not emit                                    | `spec/operators/single-spec.ts:142` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:15:single operator > should raise error from empty predicate if observable emits multiple time`                         | should raise error from empty predicate if observable emits multiple time                        | `spec/operators/single-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:153:single operator > should raise error from predicate if observable does not contain matching element`                | should raise error from predicate if observable does not contain matching element                | `spec/operators/single-spec.ts:153` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:164:single operator > should call predicate with indices starting at 0`                                                 | should call predicate with indices starting at 0                                                 | `spec/operators/single-spec.ts:164` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:190:single operator > should error for synchronous empty observables when no arguments are provided`                    | should error for synchronous empty observables when no arguments are provided                    | `spec/operators/single-spec.ts:190` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:202:single operator > should error for async empty observables when no arguments are provided`                          | should error for async empty observables when no arguments are provided                          | `spec/operators/single-spec.ts:202` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:214:single operator > should error for hot observables that do not emit while active when no arguments are provided`    | should error for hot observables that do not emit while active when no arguments are provided    | `spec/operators/single-spec.ts:214` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:226:single operator > should error for synchronous empty observables when predicate never passes`                       | should error for synchronous empty observables when predicate never passes                       | `spec/operators/single-spec.ts:226` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:238:single operator > should error for async empty observables when predicate never passes`                             | should error for async empty observables when predicate never passes                             | `spec/operators/single-spec.ts:238` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:250:single operator > should error for hot observables that do not emit while active when predicate never passes`       | should error for hot observables that do not emit while active when predicate never passes       | `spec/operators/single-spec.ts:250` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:26:single operator > should raise error from empty predicate if observable does not emit`                               | should raise error from empty predicate if observable does not emit                              | `spec/operators/single-spec.ts:26`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:262:single operator > should error for synchronous observables that emit when predicate never passes`                   | should error for synchronous observables that emit when predicate never passes                   | `spec/operators/single-spec.ts:262` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:274:single operator > should error for async observables that emit when predicate never passes`                         | should error for async observables that emit when predicate never passes                         | `spec/operators/single-spec.ts:274` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:286:single operator > should error for hot observables that emit while active when predicate never passes`              | should error for hot observables that emit while active when predicate never passes              | `spec/operators/single-spec.ts:286` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:298:single operator > should error for synchronous observables when the predicate passes more than once`                | should error for synchronous observables when the predicate passes more than once                | `spec/operators/single-spec.ts:298` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:310:single operator > should error for async observables that emit when the predicate passes more than once`            | should error for async observables that emit when the predicate passes more than once            | `spec/operators/single-spec.ts:310` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:322:single operator > should error for hot observables that emit while active when the predicate passes more than once` | should error for hot observables that emit while active when the predicate passes more than once | `spec/operators/single-spec.ts:322` | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:37:single operator > should return only element from empty predicate if observable emits only once`                     | should return only element from empty predicate if observable emits only once                    | `spec/operators/single-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:48:single operator > should allow unsubscribing explicitly and early`                                                   | should allow unsubscribing explicitly and early                                                  | `spec/operators/single-spec.ts:48`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:60:single operator > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                    | `spec/operators/single-spec.ts:60`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:78:single operator > should raise error from empty predicate if observable emits error`                                 | should raise error from empty predicate if observable emits error                                | `spec/operators/single-spec.ts:78`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |
| `spec/operators/single-spec.ts:89:single operator > should raise error from predicate if observable emits error`                                       | should raise error from predicate if observable emits error                                      | `spec/operators/single-spec.ts:89`  | —            | `portable`     | `active`    | Missing operator capability: single | `FIXED` |

### `skip`

Owner source: `spec/operators/skip-spec.ts`

| Case ID                                                                                                                                                 | Behavioral test                                                                                                | Source                            | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/skip-spec.ts:100:skip > should raise error if skip count is more than actual number of emits and source raises error`                   | should raise error if skip count is more than actual number of emits and source raises error                   | `spec/operators/skip-spec.ts:100` | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:111:skip > should raise error if skip count is same as emits of source and source raises error`                            | should raise error if skip count is same as emits of source and source raises error                            | `spec/operators/skip-spec.ts:111` | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:122:skip > should skip values before a total and raises error if source raises error`                                      | should skip values before a total and raises error if source raises error                                      | `spec/operators/skip-spec.ts:122` | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:133:skip > should complete regardless of skip count if source is empty`                                                    | should complete regardless of skip count if source is empty                                                    | `spec/operators/skip-spec.ts:133` | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:144:skip > should not complete if source never completes without emit`                                                     | should not complete if source never completes without emit                                                     | `spec/operators/skip-spec.ts:144` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/skip-spec.ts:15:skip > should skip values before a total`                                                                               | should skip values before a total                                                                              | `spec/operators/skip-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:155:skip > should skip values before total and never completes if source emits and does not complete`                      | should skip values before total and never completes if source emits and does not complete                      | `spec/operators/skip-spec.ts:155` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/skip-spec.ts:166:skip > should skip all values and never completes if total is more than numbers of value and source does not complete` | should skip all values and never completes if total is more than numbers of value and source does not complete | `spec/operators/skip-spec.ts:166` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/skip-spec.ts:177:skip > should skip all values and never completes if total is same asnumbers of value and source does not complete`    | should skip all values and never completes if total is same asnumbers of value and source does not complete    | `spec/operators/skip-spec.ts:177` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/skip-spec.ts:188:skip > should raise error if source throws`                                                                            | should raise error if source throws                                                                            | `spec/operators/skip-spec.ts:188` | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:26:skip > should skip all values without error if total is more than actual number of values`                              | should skip all values without error if total is more than actual number of values                             | `spec/operators/skip-spec.ts:26`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:37:skip > should skip all values without error if total is same as actual number of values`                                | should skip all values without error if total is same as actual number of values                               | `spec/operators/skip-spec.ts:37`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:48:skip > should not skip if count is zero`                                                                                | should not skip if count is zero                                                                               | `spec/operators/skip-spec.ts:48`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:59:skip > should not skip if count is negative value`                                                                      | should not skip if count is negative value                                                                     | `spec/operators/skip-spec.ts:59`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:70:skip > should allow unsubscribing explicitly and early`                                                                 | should allow unsubscribing explicitly and early                                                                | `spec/operators/skip-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |
| `spec/operators/skip-spec.ts:82:skip > should not break unsubscription chains when result is unsubscribed explicitly`                                   | should not break unsubscription chains when result is unsubscribed explicitly                                  | `spec/operators/skip-spec.ts:82`  | —            | `portable`     | `active`    | Missing operator capability: skip                                                                    | `FIXED` |

### `skipLast`

Owner source: `spec/operators/skipLast-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                    | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/skipLast-spec.ts:158:skipLast operator > should allow unsubscribing explicitly and early`                    | should allow unsubscribing explicitly and early                    | `spec/operators/skipLast-spec.ts:158` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/skipLast-spec.ts:181:skipLast operator > should not break unsubscription chain when unsubscribed explicitly` | should not break unsubscription chain when unsubscribed explicitly | `spec/operators/skipLast-spec.ts:181` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/skipLast-spec.ts:59:skipLast operator > should not skip any values`                                          | should not skip any values                                         | `spec/operators/skipLast-spec.ts:59`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/skipLast-spec.ts:70:skipLast operator > should not skip any values if provided with negative value`          | should not skip any values if provided with negative value         | `spec/operators/skipLast-spec.ts:70`  | —            | `portable`     | `active`    | cold: rxTest observable assertion failed.; polyfill: Invalid array length                            | `FIXED` |
| `spec/operators/skipLast-spec.ts:92:skipLast operator > should go on forever on never`                                       | should go on forever on never                                      | `spec/operators/skipLast-spec.ts:92`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `skipUntil`

Owner source: `spec/operators/skipUntil-spec.ts`

| Case ID                                                                                                                                              | Behavioral test                                                                                   | Source                                 | Failing mode    | Classification       | Disposition        | Concise failure                        | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | -------------------------------------- | --------------- | -------------------- | ------------------ | -------------------------------------- | ------- |
| `spec/operators/skipUntil-spec.ts:105:skipUntil > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                     | `spec/operators/skipUntil-spec.ts:105` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:126:skipUntil > should not break unsubscription chains with interop inners when result is unsubscribed explicitly` | should not break unsubscription chains with interop inners when result is unsubscribed explicitly | `spec/operators/skipUntil-spec.ts:126` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.    | `TODO`  |
| `spec/operators/skipUntil-spec.ts:153:skipUntil > should skip all elements when notifier is empty`                                                   | should skip all elements when notifier is empty                                                   | `spec/operators/skipUntil-spec.ts:153` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:16:skipUntil > should skip values until another observable notifies`                                               | should skip values until another observable notifies                                              | `spec/operators/skipUntil-spec.ts:16`  | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:167:skipUntil > should keep subscription to source, to wait for its eventual completion`                           | should keep subscription to source, to wait for its eventual completion                           | `spec/operators/skipUntil-spec.ts:167` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:181:skipUntil > should not complete if hot source observable does not complete`                                    | should not complete if hot source observable does not complete                                    | `spec/operators/skipUntil-spec.ts:181` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:195:skipUntil > should not complete if cold source observable never completes`                                     | should not complete if cold source observable never completes                                     | `spec/operators/skipUntil-spec.ts:195` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:209:skipUntil > should raise error if cold source is never and notifier errors`                                    | should raise error if cold source is never and notifier errors                                    | `spec/operators/skipUntil-spec.ts:209` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:223:skipUntil > should skip all elements and complete if notifier is cold never`                                   | should skip all elements and complete if notifier is cold never                                   | `spec/operators/skipUntil-spec.ts:223` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:237:skipUntil > should skip all elements and complete if notifier is a hot never`                                  | should skip all elements and complete if notifier is a hot never                                  | `spec/operators/skipUntil-spec.ts:237` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:251:skipUntil > should skip all elements and complete, even if notifier would not complete until later`            | should skip all elements and complete, even if notifier would not complete until later            | `spec/operators/skipUntil-spec.ts:251` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:265:skipUntil > should not complete if source does not complete if notifier completes without emission`            | should not complete if source does not complete if notifier completes without emission            | `spec/operators/skipUntil-spec.ts:265` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:279:skipUntil > should not complete if source and notifier are both hot never`                                     | should not complete if source and notifier are both hot never                                     | `spec/operators/skipUntil-spec.ts:279` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:293:skipUntil > should skip all elements if notifier is unsubscribed explicitly before the notifier emits`         | should skip all elements if notifier is unsubscribed explicitly before the notifier emits         | `spec/operators/skipUntil-spec.ts:293` | —               | `harness-rewrite`    | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:30:skipUntil > should emit elements after notifier emits`                                                          | should emit elements after notifier emits                                                         | `spec/operators/skipUntil-spec.ts:30`  | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:316:skipUntil > should unsubscribe the notifier after its first nexted value`                                      | should unsubscribe the notifier after its first nexted value                                      | `spec/operators/skipUntil-spec.ts:316` | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:62:skipUntil > should raise an error if notifier throws and source is hot`                                         | should raise an error if notifier throws and source is hot                                        | `spec/operators/skipUntil-spec.ts:62`  | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:76:skipUntil > should skip all elements when notifier does not emit and completes early`                           | should skip all elements when notifier does not emit and completes early                          | `spec/operators/skipUntil-spec.ts:76`  | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |
| `spec/operators/skipUntil-spec.ts:90:skipUntil > should allow unsubscribing explicitly and early`                                                    | should allow unsubscribing explicitly and early                                                   | `spec/operators/skipUntil-spec.ts:90`  | —               | `portable`           | `active`           | Missing operator capability: skipUntil | `FIXED` |

### `skipWhile`

Owner source: `spec/operators/skipWhile-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/skipWhile-spec.ts:122:skipWhile > should skip using index with source unsubscribes early`                        | should skip using index with source unsubscribes early                        | `spec/operators/skipWhile-spec.ts:122` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/skipWhile-spec.ts:140:skipWhile > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/skipWhile-spec.ts:140` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/skipWhile-spec.ts:183:skipWhile > should invoke predicate while its false and never again`                       | should invoke predicate while its false and never again                       | `spec/operators/skipWhile-spec.ts:183` | —            | `portable`     | `active`    | Missing operator capability: tap                                                                     | `FIXED` |
| `spec/operators/skipWhile-spec.ts:243:skipWhile > should handle Observable.never`                                                | should handle Observable.never                                                | `spec/operators/skipWhile-spec.ts:243` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/skipWhile-spec.ts:88:skipWhile > should skip elements on hot source`                                             | should skip elements on hot source                                            | `spec/operators/skipWhile-spec.ts:88`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `startWith`

Owner source: `spec/operators/startWith-spec.ts`

| Case ID                                                                                                                              | Behavioral test                                                                   | Source                                 | Failing mode | Classification    | Disposition | Concise failure                        | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------- | -------------------------------------- | ------------ | ----------------- | ----------- | -------------------------------------- | ------- |
| `spec/operators/startWith-spec.ts:107:startWith > should start with given values when given value is more than one`                  | should start with given values when given value is more than one                  | `spec/operators/startWith-spec.ts:107` | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:120:startWith > should start with given value and raises error if source raises error`             | should start with given value and raises error if source raises error             | `spec/operators/startWith-spec.ts:120` | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:133:startWith > should start with given value and raises error immediately if source throws error` | should start with given value and raises error immediately if source throws error | `spec/operators/startWith-spec.ts:133` | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:146:startWith > should allow unsubscribing explicitly and early`                                   | should allow unsubscribing explicitly and early                                   | `spec/operators/startWith-spec.ts:146` | —            | `harness-rewrite` | `active`    | testScheduler is not defined           | `FIXED` |
| `spec/operators/startWith-spec.ts:16:startWith > should prepend to a cold Observable`                                                | should prepend to a cold Observable                                               | `spec/operators/startWith-spec.ts:16`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:161:startWith > should not break unsubscription chains when result is unsubscribed explicitly`     | should not break unsubscription chains when result is unsubscribed explicitly     | `spec/operators/startWith-spec.ts:161` | —            | `harness-rewrite` | `active`    | testScheduler is not defined           | `FIXED` |
| `spec/operators/startWith-spec.ts:180:startWith > should start with empty if given value is not specified`                           | should start with empty if given value is not specified                           | `spec/operators/startWith-spec.ts:180` | —            | `harness-rewrite` | `active`    | testScheduler is not defined           | `FIXED` |
| `spec/operators/startWith-spec.ts:193:startWith > should accept scheduler as last argument with single value`                        | should accept scheduler as last argument with single value                        | `spec/operators/startWith-spec.ts:193` | —            | `harness-rewrite` | `active`    | testScheduler is not defined           | `FIXED` |
| `spec/operators/startWith-spec.ts:206:startWith > should accept scheduler as last argument with multiple value`                      | should accept scheduler as last argument with multiple value                      | `spec/operators/startWith-spec.ts:206` | —            | `harness-rewrite` | `active`    | testScheduler is not defined           | `FIXED` |
| `spec/operators/startWith-spec.ts:29:startWith > should start an observable with given value`                                        | should start an observable with given value                                       | `spec/operators/startWith-spec.ts:29`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:42:startWith > should start with given value and does not completes if source does not completes`  | should start with given value and does not completes if source does not completes | `spec/operators/startWith-spec.ts:42`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:55:startWith > should start with given value and does not completes if source never emits`         | should start with given value and does not completes if source never emits        | `spec/operators/startWith-spec.ts:55`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:68:startWith > should start with given value and completes if source does not emits`               | should start with given value and completes if source does not emits              | `spec/operators/startWith-spec.ts:68`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:81:startWith > should start with given value and complete immediately if source is empty`          | should start with given value and complete immediately if source is empty         | `spec/operators/startWith-spec.ts:81`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |
| `spec/operators/startWith-spec.ts:94:startWith > should start with given value and source both if source emits single value`         | should start with given value and source both if source emits single value        | `spec/operators/startWith-spec.ts:94`  | —            | `portable`        | `active`    | Missing operator capability: startWith | `FIXED` |

### `Subject`

Owner source: `spec/Subject-spec.ts`

| Case ID                                                                                           | Behavioral test                               | Source                     | Failing mode | Classification | Disposition | Concise failure                         | Status  |
| ------------------------------------------------------------------------------------------------- | --------------------------------------------- | -------------------------- | ------------ | -------------- | ----------- | --------------------------------------- | ------- |
| `spec/Subject-spec.ts:608:Subject > asObservable > should handle subject never emits`             | should handle subject never emits             | `spec/Subject-spec.ts:608` | —            | `portable`     | `active`    | hot(...).asObservable is not a function | `FIXED` |
| `spec/Subject-spec.ts:616:Subject > asObservable > should handle subject completes without emits` | should handle subject completes without emits | `spec/Subject-spec.ts:616` | —            | `portable`     | `active`    | hot(...).asObservable is not a function | `FIXED` |
| `spec/Subject-spec.ts:625:Subject > asObservable > should handle subject throws`                  | should handle subject throws                  | `spec/Subject-spec.ts:625` | —            | `portable`     | `active`    | hot(...).asObservable is not a function | `FIXED` |
| `spec/Subject-spec.ts:634:Subject > asObservable > should handle subject emits`                   | should handle subject emits                   | `spec/Subject-spec.ts:634` | —            | `portable`     | `active`    | hot(...).asObservable is not a function | `FIXED` |

### `subscribeOn`

Owner source: `spec/operators/subscribeOn-spec.ts`

| Case ID                                                                                                                                 | Behavioral test                                                                   | Source                                   | Failing mode | Classification    | Disposition | Concise failure              | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ---------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------- | ------- |
| `spec/operators/subscribeOn-spec.ts:113:subscribeOn > should properly support a delayTime of Infinity`                                  | should properly support a delayTime of Infinity                                   | `spec/operators/subscribeOn-spec.ts:113` | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:15:subscribeOn > should subscribe on specified scheduler`                                           | should subscribe on specified scheduler                                           | `spec/operators/subscribeOn-spec.ts:15`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:28:subscribeOn > should start subscribe after specified delay`                                      | should start subscribe after specified delay                                      | `spec/operators/subscribeOn-spec.ts:28`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:42:subscribeOn > should unsubscribe when source raises error`                                       | should unsubscribe when source raises error                                       | `spec/operators/subscribeOn-spec.ts:42`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:55:subscribeOn > should subscribe when source is empty`                                             | should subscribe when source is empty                                             | `spec/operators/subscribeOn-spec.ts:55`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:68:subscribeOn > should subscribe when source does not complete`                                    | should subscribe when source does not complete                                    | `spec/operators/subscribeOn-spec.ts:68`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:81:subscribeOn > should allow unsubscribing early and explicitly`                                   | should allow unsubscribing early and explicitly                                   | `spec/operators/subscribeOn-spec.ts:81`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |
| `spec/operators/subscribeOn-spec.ts:95:subscribeOn > should not break unsubscription chains when the result is unsubscribed explicitly` | should not break unsubscription chains when the result is unsubscribed explicitly | `spec/operators/subscribeOn-spec.ts:95`  | —            | `harness-rewrite` | `active`    | testScheduler is not defined | `FIXED` |

### `switchAll`

Owner source: `spec/operators/switchAll-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/switchAll-spec.ts:104:switchAll > should handle a hot observable of observables, outer is unsubscribed early`    | should handle a hot observable of observables, outer is unsubscribed early    | `spec/operators/switchAll-spec.ts:104` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchAll-spec.ts:122:switchAll > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/switchAll-spec.ts:122` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchAll-spec.ts:144:switchAll > should handle a hot observable of observables, inner never completes`          | should handle a hot observable of observables, inner never completes          | `spec/operators/switchAll-spec.ts:144` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/switchAll-spec.ts:225:switchAll > should handle a never hot observable`                                          | should handle a never hot observable                                          | `spec/operators/switchAll-spec.ts:225` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `switchMap`

Owner source: `spec/operators/switchMap-spec.ts`

| Case ID                                                                                                                                              | Behavioral test                                                                                   | Source                                 | Failing mode    | Classification       | Disposition        | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | -------------------------------------- | --------------- | -------------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/switchMap-spec.ts:139:switchMap > should switch inner cold observables, outer is unsubscribed early`                                 | should switch inner cold observables, outer is unsubscribed early                                 | `spec/operators/switchMap-spec.ts:139` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchMap-spec.ts:16:switchMap > should map-and-flatten each item to an Observable`                                                  | should map-and-flatten each item to an Observable                                                 | `spec/operators/switchMap-spec.ts:16`  | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchMap-spec.ts:161:switchMap > should not break unsubscription chains when result is unsubscribed explicitly`                     | should not break unsubscription chains when result is unsubscribed explicitly                     | `spec/operators/switchMap-spec.ts:161` | —               | `portable`           | `active`           | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchMap-spec.ts:187:switchMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly` | should not break unsubscription chains with interop inners when result is unsubscribed explicitly | `spec/operators/switchMap-spec.ts:187` | cold + polyfill | `compatibility-only` | `expected-failure` | rxTest observable assertion failed.                                                                  | `TODO`  |
| `spec/operators/switchMap-spec.ts:248:switchMap > should switch inner cold observables, inner never completes`                                       | should switch inner cold observables, inner never completes                                       | `spec/operators/switchMap-spec.ts:248` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/switchMap-spec.ts:353:switchMap > should switch inner empty and never`                                                               | should switch inner empty and never                                                               | `spec/operators/switchMap-spec.ts:353` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/switchMap-spec.ts:450:switchMap > should handle outer never`                                                                         | should handle outer never                                                                         | `spec/operators/switchMap-spec.ts:450` | —               | `portable`           | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `switchMapTo`

Owner source: `spec/operators/switchMapTo-spec.ts`

| Case ID                                                                                                                              | Behavioral test                                                               | Source                                   | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/switchMapTo-spec.ts:140:switchMapTo > should switch to an inner cold observable, outer is unsubscribed early`        | should switch to an inner cold observable, outer is unsubscribed early        | `spec/operators/switchMapTo-spec.ts:140` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchMapTo-spec.ts:159:switchMapTo > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/switchMapTo-spec.ts:159` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/switchMapTo-spec.ts:184:switchMapTo > should switch to an inner cold observable, inner never completes`              | should switch to an inner cold observable, inner never completes              | `spec/operators/switchMapTo-spec.ts:184` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/switchMapTo-spec.ts:270:switchMapTo > should switch to an inner never`                                               | should switch to an inner never                                               | `spec/operators/switchMapTo-spec.ts:270` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/switchMapTo-spec.ts:313:switchMapTo > should handle a never outer`                                                   | should handle a never outer                                                   | `spec/operators/switchMapTo-spec.ts:313` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `switchScan`

Owner source: `spec/operators/switchScan-spec.ts`

| Case ID                                                                                                                                   | Behavioral test                                                                       | Source                                  | Failing mode | Classification | Disposition | Concise failure                         | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | --------------------------------------- | ------- |
| `spec/operators/switchScan-spec.ts:104:switchScan > should switch inner cold observables, outer is unsubscribed early`                    | should switch inner cold observables, outer is unsubscribed early                     | `spec/operators/switchScan-spec.ts:104` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:126:switchScan > should not break unsubscription chains when result is unsubscribed explicitly`        | should not break unsubscription chains when result is unsubscribed explicitly         | `spec/operators/switchScan-spec.ts:126` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:15:switchScan > should map-and-flatten each item to an Observable while passing the accumulated value` | should map-and-flatten each item to an Observable while passing the accumulated value | `spec/operators/switchScan-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:181:switchScan > should switch inner cold observables, inner never completes`                          | should switch inner cold observables, inner never completes                           | `spec/operators/switchScan-spec.ts:181` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:202:switchScan > should handle a synchronous switch to the second inner observable`                    | should handle a synchronous switch to the second inner observable                     | `spec/operators/switchScan-spec.ts:202` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:223:switchScan > should switch inner cold observables, one inner throws`                               | should switch inner cold observables, one inner throws                                | `spec/operators/switchScan-spec.ts:223` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:244:switchScan > should switch inner hot observables`                                                  | should switch inner hot observables                                                   | `spec/operators/switchScan-spec.ts:244` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:265:switchScan > should switch inner empty and empty`                                                  | should switch inner empty and empty                                                   | `spec/operators/switchScan-spec.ts:265` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:286:switchScan > should switch inner empty and never`                                                  | should switch inner empty and never                                                   | `spec/operators/switchScan-spec.ts:286` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:307:switchScan > should switch inner never and empty`                                                  | should switch inner never and empty                                                   | `spec/operators/switchScan-spec.ts:307` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:328:switchScan > should switch inner never and throw`                                                  | should switch inner never and throw                                                   | `spec/operators/switchScan-spec.ts:328` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:349:switchScan > should switch inner empty and throw`                                                  | should switch inner empty and throw                                                   | `spec/operators/switchScan-spec.ts:349` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:370:switchScan > should handle outer empty`                                                            | should handle outer empty                                                             | `spec/operators/switchScan-spec.ts:370` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:383:switchScan > should handle outer never`                                                            | should handle outer never                                                             | `spec/operators/switchScan-spec.ts:383` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:396:switchScan > should handle outer throw`                                                            | should handle outer throw                                                             | `spec/operators/switchScan-spec.ts:396` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:409:switchScan > should handle outer error`                                                            | should handle outer error                                                             | `spec/operators/switchScan-spec.ts:409` | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:68:switchScan > should switch inner cold observables`                                                  | should switch inner cold observables                                                  | `spec/operators/switchScan-spec.ts:68`  | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |
| `spec/operators/switchScan-spec.ts:89:switchScan > should raise error when projection throws`                                             | should raise error when projection throws                                             | `spec/operators/switchScan-spec.ts:89`  | —            | `portable`     | `active`    | Missing operator capability: switchScan | `FIXED` |

### `take`

Owner source: `spec/operators/take-spec.ts`

| Case ID                                                                                                                                                         | Behavioral test                                                                                                        | Source                            | Failing mode | Classification | Disposition        | Concise failure                                                                                      | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | --------------------------------- | ------------ | -------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/take-spec.ts:103:take > should propagate error from the source observable`                                                                      | should propagate error from the source observable                                                                      | `spec/operators/take-spec.ts:103` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:114:take > should propagate error from an observable with values`                                                                  | should propagate error from an observable with values                                                                  | `spec/operators/take-spec.ts:114` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:125:take > should allow unsubscribing explicitly and early`                                                                        | should allow unsubscribing explicitly and early                                                                        | `spec/operators/take-spec.ts:125` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:137:take > should work with throw`                                                                                                 | should work with throw                                                                                                 | `spec/operators/take-spec.ts:137` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:148:take > should not break unsubscription chain when unsubscribed explicitly`                                                     | should not break unsubscription chain when unsubscribed explicitly                                                     | `spec/operators/take-spec.ts:148` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:15:take > should take two values of an observable with many values`                                                                | should take two values of an observable with many values                                                               | `spec/operators/take-spec.ts:15`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:209:take > should complete even if the parameter is a string`                                                                      | should complete even if the parameter is a string                                                                      | `spec/operators/take-spec.ts:209` | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:222:take > should unsubscribe from the source when it reaches the limit before a recursive synchronous upstream error is notified` | should unsubscribe from the source when it reaches the limit before a recursive synchronous upstream error is notified | `spec/operators/take-spec.ts:222` | —            | `portable`     | `expected-failure` | Missing operator capability: tap                                                                     | `FIXED` |
| `spec/operators/take-spec.ts:26:take > should work with empty`                                                                                                  | should work with empty                                                                                                 | `spec/operators/take-spec.ts:26`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:37:take > should go on forever on never`                                                                                           | should go on forever on never                                                                                          | `spec/operators/take-spec.ts:37`  | —            | `portable`     | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/take-spec.ts:48:take > should be empty on take(0)`                                                                                              | should be empty on take(0)                                                                                             | `spec/operators/take-spec.ts:48`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:59:take > should be empty if provided with negative value`                                                                         | should be empty if provided with negative value                                                                        | `spec/operators/take-spec.ts:59`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:70:take > should take one value of an observable with one value`                                                                   | should take one value of an observable with one value                                                                  | `spec/operators/take-spec.ts:70`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:81:take > should take one values of an observable with many values`                                                                | should take one values of an observable with many values                                                               | `spec/operators/take-spec.ts:81`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |
| `spec/operators/take-spec.ts:92:take > should error on empty`                                                                                                   | should error on empty                                                                                                  | `spec/operators/take-spec.ts:92`  | —            | `portable`     | `active`           | Missing operator capability: take                                                                    | `FIXED` |

### `takeLast`

Owner source: `spec/operators/takeLast-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                    | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/takeLast-spec.ts:102:takeLast operator > should be empty on takeLast(0)`                                     | should be empty on takeLast(0)                                     | `spec/operators/takeLast-spec.ts:102` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeLast-spec.ts:168:takeLast operator > should allow unsubscribing explicitly and early`                    | should allow unsubscribing explicitly and early                    | `spec/operators/takeLast-spec.ts:168` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/takeLast-spec.ts:191:takeLast operator > should not break unsubscription chain when unsubscribed explicitly` | should not break unsubscription chain when unsubscribed explicitly | `spec/operators/takeLast-spec.ts:191` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/takeLast-spec.ts:58:takeLast operator > should not take any values`                                          | should not take any values                                         | `spec/operators/takeLast-spec.ts:58`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeLast-spec.ts:69:takeLast operator > should not take any values if provided with negative value`          | should not take any values if provided with negative value         | `spec/operators/takeLast-spec.ts:69`  | —            | `portable`     | `active`    | cold: rxTest observable assertion failed.; polyfill: Invalid array length                            | `FIXED` |
| `spec/operators/takeLast-spec.ts:91:takeLast operator > should go on forever on never`                                       | should go on forever on never                                      | `spec/operators/takeLast-spec.ts:91`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |

### `takeUntil`

Owner source: `spec/operators/takeUntil-spec.ts`

| Case ID                                                                                                                                          | Behavioral test                                                                       | Source                                 | Failing mode | Classification | Disposition | Concise failure                        | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | -------------------------------------- | ------- |
| `spec/operators/takeUntil-spec.ts:108:takeUntil operator > should complete when notifier emits if source observable does not complete`           | should complete when notifier emits if source observable does not complete            | `spec/operators/takeUntil-spec.ts:108` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:122:takeUntil operator > should raise error when notifier raises error if source observable does not complete` | should raise error when notifier raises error if source observable does not complete  | `spec/operators/takeUntil-spec.ts:122` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:136:takeUntil operator > should not complete when notifier is empty if source observable does not complete`    | should not complete when notifier is empty if source observable does not complete     | `spec/operators/takeUntil-spec.ts:136` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:14:takeUntil operator > should take values until notifier emits`                                               | should take values until notifier emits                                               | `spec/operators/takeUntil-spec.ts:14`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:150:takeUntil operator > should not complete when source and notifier do not complete`                         | should not complete when source and notifier do not complete                          | `spec/operators/takeUntil-spec.ts:150` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:164:takeUntil operator > should complete when notifier emits before source observable emits`                   | should complete when notifier emits before source observable emits                    | `spec/operators/takeUntil-spec.ts:164` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:178:takeUntil operator > should raise error if source raises error before notifier emits`                      | should raise error if source raises error before notifier emits                       | `spec/operators/takeUntil-spec.ts:178` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:192:takeUntil operator > should raise error immediately if source throws`                                      | should raise error immediately if source throws                                       | `spec/operators/takeUntil-spec.ts:192` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:206:takeUntil operator > should dispose source observable if notifier emits before source emits`               | should dispose source observable if notifier emits before source emits                | `spec/operators/takeUntil-spec.ts:206` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:220:takeUntil operator > should dispose notifier if source observable completes`                               | should dispose notifier if source observable completes                                | `spec/operators/takeUntil-spec.ts:220` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:234:takeUntil operator > should not break unsubscription chain when unsubscribed explicitly`                   | should not break unsubscription chain when unsubscribed explicitly                    | `spec/operators/takeUntil-spec.ts:234` | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:28:takeUntil operator > should take values and raises error when notifier raises error`                        | should take values and raises error when notifier raises error                        | `spec/operators/takeUntil-spec.ts:28`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:42:takeUntil operator > should take all values when notifier is empty`                                         | should take all values when notifier is empty                                         | `spec/operators/takeUntil-spec.ts:42`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:56:takeUntil operator > should take all values when notifier does not complete`                                | should take all values when notifier does not complete                                | `spec/operators/takeUntil-spec.ts:56`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:70:takeUntil operator > should complete without subscribing to the source when notifier synchronously emits`   | should complete without subscribing to the source when notifier synchronously emits   | `spec/operators/takeUntil-spec.ts:70`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:81:takeUntil operator > should subscribe to the source when notifier synchronously completes without emitting` | should subscribe to the source when notifier synchronously completes without emitting | `spec/operators/takeUntil-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |
| `spec/operators/takeUntil-spec.ts:93:takeUntil operator > should allow unsubscribing explicitly and early`                                       | should allow unsubscribing explicitly and early                                       | `spec/operators/takeUntil-spec.ts:93`  | —            | `portable`     | `active`    | Missing operator capability: takeUntil | `FIXED` |

### `takeWhile`

Owner source: `spec/operators/takeWhile-spec.ts`

| Case ID                                                                                                                                          | Behavioral test                                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/takeWhile-spec.ts:101:takeWhile > should take all elements up to and including the element that made the predicate return false` | should take all elements up to and including the element that made the predicate return false | `spec/operators/takeWhile-spec.ts:101` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:119:takeWhile > should take elements with predicate when source does not complete`                             | should take elements with predicate when source does not complete                             | `spec/operators/takeWhile-spec.ts:119` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/takeWhile-spec.ts:132:takeWhile > should not complete when source never completes`                                               | should not complete when source never completes                                               | `spec/operators/takeWhile-spec.ts:132` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/takeWhile-spec.ts:145:takeWhile > should complete when source does not emit`                                                     | should complete when source does not emit                                                     | `spec/operators/takeWhile-spec.ts:145` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:158:takeWhile > should complete when source is empty`                                                          | should complete when source is empty                                                          | `spec/operators/takeWhile-spec.ts:158` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:188:takeWhile > should raise error when source raises error`                                                   | should raise error when source raises error                                                   | `spec/operators/takeWhile-spec.ts:188` | —            | `portable`     | `active`    | cold: rxTest observable assertion failed.; polyfill: error                                           | `FIXED` |
| `spec/operators/takeWhile-spec.ts:201:takeWhile > should raise error when source throws`                                                         | should raise error when source throws                                                         | `spec/operators/takeWhile-spec.ts:201` | —            | `portable`     | `active`    | cold: rxTest observable assertion failed.; polyfill: error                                           | `FIXED` |
| `spec/operators/takeWhile-spec.ts:214:takeWhile > should invoke predicate until return false`                                                    | should invoke predicate until return false                                                    | `spec/operators/takeWhile-spec.ts:214` | —            | `portable`     | `active`    | Missing operator capability: tap                                                                     | `FIXED` |
| `spec/operators/takeWhile-spec.ts:256:takeWhile > should take elements until unsubscribed`                                                       | should take elements until unsubscribed                                                       | `spec/operators/takeWhile-spec.ts:256` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:274:takeWhile > should not break unsubscription chain when unsubscribed explicitly`                            | should not break unsubscription chain when unsubscribed explicitly                            | `spec/operators/takeWhile-spec.ts:274` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:28:takeWhile > should take all elements with predicate returns true`                                           | should take all elements with predicate returns true                                          | `spec/operators/takeWhile-spec.ts:28`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/takeWhile-spec.ts:41:takeWhile > should take all elements with truthy predicate`                                                 | should take all elements with truthy predicate                                                | `spec/operators/takeWhile-spec.ts:41`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `tap`

Owner source: `spec/operators/tap-spec.ts`

| Case ID                                                                                                              | Behavioral test                                                               | Source                           | Failing mode | Classification | Disposition    | Concise failure                  | Status  |
| -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------- | ------------ | -------------- | -------------- | -------------------------------- | ------- |
| `spec/operators/tap-spec.ts:15:tap > should mirror multiple values and complete`                                     | should mirror multiple values and complete                                    | `spec/operators/tap-spec.ts:15`  | —            | `portable`     | `active`       | Missing operator capability: tap | `FIXED` |
| `spec/operators/tap-spec.ts:223:tap > should allow unsubscribing explicitly and early`                               | should allow unsubscribing explicitly and early                               | `spec/operators/tap-spec.ts:223` | —            | `portable`     | `active`       | Missing operator capability: tap | `FIXED` |
| `spec/operators/tap-spec.ts:240:tap > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/tap-spec.ts:240` | —            | `portable`     | `active`       | Missing operator capability: tap | `FIXED` |
| `spec/operators/tap-spec.ts:260:tap > should mirror multiple values and complete`                                    | should mirror multiple values and complete                                    | `spec/operators/tap-spec.ts:260` | —            | `portable`     | `deduplicated` | Missing operator capability: tap | `FIXED` |
| `spec/operators/tap-spec.ts:276:tap > should mirror multiple values and terminate with error`                        | should mirror multiple values and terminate with error                        | `spec/operators/tap-spec.ts:276` | —            | `portable`     | `active`       | Missing operator capability: tap | `FIXED` |

### `TestScheduler`

Owner source: `spec/schedulers/TestScheduler-spec.ts`

| Case ID                                                                                                                                                                 | Behavioral test                                                             | Source                                      | Failing mode | Classification    | Disposition | Concise failure                                                                                                                                                                                                                                         | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------- | ------------ | ----------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `spec/schedulers/TestScheduler-spec.ts:102:TestScheduler > parseMarbles() > should support emoji characters`                                                            | should support emoji characters                                             | `spec/schedulers/TestScheduler-spec.ts:102` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:114:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string into a subscriptionLog`            | should parse a subscription marble string into a subscriptionLog            | `spec/schedulers/TestScheduler-spec.ts:114` | —            | `harness-rewrite` | `active`    | expected 3 to equal 30                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:120:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string with an unsubscription`            | should parse a subscription marble string with an unsubscription            | `spec/schedulers/TestScheduler-spec.ts:120` | —            | `harness-rewrite` | `active`    | expected 3 to equal 30                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:126:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string with a synchronous unsubscription` | should parse a subscription marble string with a synchronous unsubscription | `spec/schedulers/TestScheduler-spec.ts:126` | —            | `harness-rewrite` | `active`    | Time marble diagrams cannot contain "(".                                                                                                                                                                                                                | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:132:TestScheduler > parseMarblesAsSubscriptions() > should ignore whitespace when runMode=true`                                  | should ignore whitespace when runMode=true                                  | `spec/schedulers/TestScheduler-spec.ts:132` | —            | `harness-rewrite` | `active`    | expected 4 to equal 40                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:139:TestScheduler > parseMarblesAsSubscriptions() > should support time progression syntax when runMode=true`                    | should support time progression syntax when runMode=true                    | `spec/schedulers/TestScheduler-spec.ts:139` | —            | `harness-rewrite` | `active`    | expected 61212.2 to equal 61230.2                                                                                                                                                                                                                       | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:146:TestScheduler > parseMarblesAsSubscriptions() > should throw if found more than one subscription point`                      | should throw if found more than one subscription point                      | `spec/schedulers/TestScheduler-spec.ts:146` | —            | `harness-rewrite` | `active`    | expected [Function] to throw an error                                                                                                                                                                                                                   | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:150:TestScheduler > parseMarblesAsSubscriptions() > should throw if found more than one unsubscription point`                    | should throw if found more than one unsubscription point                    | `spec/schedulers/TestScheduler-spec.ts:150` | —            | `harness-rewrite` | `active`    | expected [Function] to throw an error                                                                                                                                                                                                                   | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:156:TestScheduler > createTime() > should parse a simple time marble string to a number`                                         | should parse a simple time marble string to a number                        | `spec/schedulers/TestScheduler-spec.ts:156` | —            | `harness-rewrite` | `active`    | expected 5 to equal 50                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:16:TestScheduler > should exist`                                                                                                 | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:16`  | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:162:TestScheduler > createTime() > should progress time with whitespace`                                                         | should progress time with whitespace                                        | `spec/schedulers/TestScheduler-spec.ts:162` | —            | `harness-rewrite` | `active`    | expected +0 to equal 50                                                                                                                                                                                                                                 | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:169:TestScheduler > createTime() > should progress time with mix of whitespace and dashes`                                       | should progress time with mix of whitespace and dashes                      | `spec/schedulers/TestScheduler-spec.ts:169` | —            | `harness-rewrite` | `active`    | expected 2 to equal 40                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:198:TestScheduler > createHotObservable() > should create a hot observable`                                                      | should create a hot observable                                              | `spec/schedulers/TestScheduler-spec.ts:198` | —            | `harness-rewrite` | `active`    | [non-terminating-conversion] spec/schedulers/TestScheduler-spec.ts:198:TestScheduler > createHotObservable() > should create a hot observable: The direct-subscription manual-TestScheduler conversion does not yield control or finalize under rxTest. | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:21:TestScheduler > should have frameTimeFactor set initially`                                                                    | should have frameTimeFactor set initially                                   | `spec/schedulers/TestScheduler-spec.ts:21`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'frameTimeFactor')                                                                                                                                                                                         | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:213:TestScheduler > jasmine helpers > rxTestScheduler > should exist`                                                            | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:213` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined                                                                                                                                                                                                                          | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:219:TestScheduler > jasmine helpers > cold() > should exist`                                                                     | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:219` | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:237:TestScheduler > jasmine helpers > hot() > should exist`                                                                      | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:237` | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:242:TestScheduler > jasmine helpers > hot() > should create a hot observable`                                                    | should create a hot observable                                              | `spec/schedulers/TestScheduler-spec.ts:242` | —            | `harness-rewrite` | `active`    | expected [Observable] to be an instance of Subject                                                                                                                                                                                                      | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:250:TestScheduler > jasmine helpers > time() > should exist`                                                                     | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:250` | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:255:TestScheduler > jasmine helpers > time() > should parse a simple time marble string to a number`                             | should parse a simple time marble string to a number                        | `spec/schedulers/TestScheduler-spec.ts:255` | —            | `harness-rewrite` | `active`    | expected 5 to equal 50                                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:26:TestScheduler > parseMarbles() > should parse a marble string into a series of notifications and types`                       | should parse a marble string into a series of notifications and types       | `spec/schedulers/TestScheduler-spec.ts:26`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:261:TestScheduler > jasmine helpers > expectObservable() > should exist`                                                         | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:261` | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:270:TestScheduler > jasmine helpers > expectObservable() > should append to flushTests array`                                    | should append to flushTests array                                           | `spec/schedulers/TestScheduler-spec.ts:270` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined                                                                                                                                                                                                                          | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:279:TestScheduler > jasmine helpers > expectObservable() > should handle never`                                                  | should handle never                                                         | `spec/schedulers/TestScheduler-spec.ts:279` | —            | `harness-rewrite` | `active`    | rxTest finished with 2 open observation(s). Complete the source or provide an unsubscription marble.                                                                                                                                                    | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:284:TestScheduler > jasmine helpers > expectObservable() > should accept an unsubscription marble diagram`                       | should accept an unsubscription marble diagram                              | `spec/schedulers/TestScheduler-spec.ts:284` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:291:TestScheduler > jasmine helpers > expectObservable() > should accept a subscription marble diagram`                          | should accept a subscription marble diagram                                 | `spec/schedulers/TestScheduler-spec.ts:291` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:300:TestScheduler > jasmine helpers > expectSubscriptions() > should exist`                                                      | should exist                                                                | `spec/schedulers/TestScheduler-spec.ts:300` | —            | `harness-rewrite` | `active`    | expected undefined to exist                                                                                                                                                                                                                             | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:309:TestScheduler > jasmine helpers > expectSubscriptions() > should append to flushTests array`                                 | should append to flushTests array                                           | `spec/schedulers/TestScheduler-spec.ts:309` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined                                                                                                                                                                                                                          | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:35:TestScheduler > parseMarbles() > should parse a marble string, allowing spaces too`                                           | should parse a marble string, allowing spaces too                           | `spec/schedulers/TestScheduler-spec.ts:35`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:361:TestScheduler > TestScheduler.run() > marble diagrams > should ignore whitespace`                                            | should ignore whitespace                                                    | `spec/schedulers/TestScheduler-spec.ts:361` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:390:TestScheduler > TestScheduler.run() > should provide the correct helpers`                                                    | should provide the correct helpers                                          | `spec/schedulers/TestScheduler-spec.ts:390` | —            | `harness-rewrite` | `active`    | rxTest subscriptions assertion failed.                                                                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:427:TestScheduler > TestScheduler.run() > should have no maximum frame count`                                                    | should have no maximum frame count                                          | `spec/schedulers/TestScheduler-spec.ts:427` | —            | `harness-rewrite` | `active`    | Missing operator capability: delay                                                                                                                                                                                                                      | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:44:TestScheduler > parseMarbles() > should parse a marble string with a subscription point`                                      | should parse a marble string with a subscription point                      | `spec/schedulers/TestScheduler-spec.ts:44`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:451:TestScheduler > TestScheduler.run() > should flush automatically`                                                            | should flush automatically                                                  | `spec/schedulers/TestScheduler-spec.ts:451` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:472:TestScheduler > TestScheduler.run() > should support explicit flushing`                                                      | should support explicit flushing                                            | `spec/schedulers/TestScheduler-spec.ts:472` | —            | `harness-rewrite` | `active`    | testScheduler is not defined                                                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:497:TestScheduler > TestScheduler.run() > should pass-through return values, e.g. Promises`                                      | should pass-through return values, e.g. Promises                            | `spec/schedulers/TestScheduler-spec.ts:497` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'then')                                                                                                                                                                                                    | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:508:TestScheduler > TestScheduler.run() > should restore changes upon thrown errors`                                             | should restore changes upon thrown errors                                   | `spec/schedulers/TestScheduler-spec.ts:508` | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'frameTimeFactor')                                                                                                                                                                                         | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:53:TestScheduler > parseMarbles() > should parse a marble string with an error`                                                  | should parse a marble string with an error                                  | `spec/schedulers/TestScheduler-spec.ts:53`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:569:TestScheduler > TestScheduler.run() > animate > should schedule async requests within animate()`                             | should schedule async requests within animate()                             | `spec/schedulers/TestScheduler-spec.ts:569` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'schedule' of 'animationFrameProvider' as it is undefined.                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:591:TestScheduler > TestScheduler.run() > animate > should schedule sync requests within animate()`                              | should schedule sync requests within animate()                              | `spec/schedulers/TestScheduler-spec.ts:591` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'schedule' of 'animationFrameProvider' as it is undefined.                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:610:TestScheduler > TestScheduler.run() > animate > should support request cancellation within animate()`                        | should support request cancellation within animate()                        | `spec/schedulers/TestScheduler-spec.ts:610` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'schedule' of 'animationFrameProvider' as it is undefined.                                                                                                                                                                  | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:62:TestScheduler > parseMarbles() > should default in the letter for the value if no value hash was passed`                      | should default in the letter for the value if no value hash was passed      | `spec/schedulers/TestScheduler-spec.ts:62`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:632:TestScheduler > TestScheduler.run() > immediate and interval > should schedule immediates`                                   | should schedule immediates                                                  | `spec/schedulers/TestScheduler-spec.ts:632` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setImmediate' of 'immediateProvider' as it is undefined.                                                                                                                                                                   | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:647:TestScheduler > TestScheduler.run() > immediate and interval > should support clearing immediates`                           | should support clearing immediates                                          | `spec/schedulers/TestScheduler-spec.ts:647` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setImmediate' of 'immediateProvider' as it is undefined.                                                                                                                                                                   | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:663:TestScheduler > TestScheduler.run() > immediate and interval > should schedule intervals`                                    | should schedule intervals                                                   | `spec/schedulers/TestScheduler-spec.ts:663` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setInterval' of 'intervalProvider' as it is undefined.                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:679:TestScheduler > TestScheduler.run() > immediate and interval > should reschedule intervals until cleared`                    | should reschedule intervals until cleared                                   | `spec/schedulers/TestScheduler-spec.ts:679` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setInterval' of 'intervalProvider' as it is undefined.                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:698:TestScheduler > TestScheduler.run() > immediate and interval > should schedule timeouts`                                     | should schedule timeouts                                                    | `spec/schedulers/TestScheduler-spec.ts:698` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setTimeout' of 'timeoutProvider' as it is undefined.                                                                                                                                                                       | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:71:TestScheduler > parseMarbles() > should handle grouped values`                                                                | should handle grouped values                                                | `spec/schedulers/TestScheduler-spec.ts:71`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:713:TestScheduler > TestScheduler.run() > immediate and interval > should schedule immediates before intervals and timeouts`     | should schedule immediates before intervals and timeouts                    | `spec/schedulers/TestScheduler-spec.ts:713` | —            | `harness-rewrite` | `active`    | Cannot destructure property 'setImmediate' of 'immediateProvider' as it is undefined.                                                                                                                                                                   | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:739:TestScheduler > TestScheduler.run() > schedulers > should support animationFrame, async and asap schedulers`                 | should support animationFrame, async and asap schedulers                    | `spec/schedulers/TestScheduler-spec.ts:739` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:756:TestScheduler > TestScheduler.run() > schedulers > should emit asap notifications before async notifications`                | should emit asap notifications before async notifications                   | `spec/schedulers/TestScheduler-spec.ts:756` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:769:TestScheduler > TestScheduler.run() > schedulers > should support intervals with zero duration`                              | should support intervals with zero duration                                 | `spec/schedulers/TestScheduler-spec.ts:769` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.                                                                                                                                                                                                                     | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:80:TestScheduler > parseMarbles() > should ignore whitespace when runMode=true`                                                  | should ignore whitespace when runMode=true                                  | `spec/schedulers/TestScheduler-spec.ts:80`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |
| `spec/schedulers/TestScheduler-spec.ts:91:TestScheduler > parseMarbles() > should support time progression syntax when runMode=true`                                    | should support time progression syntax when runMode=true                    | `spec/schedulers/TestScheduler-spec.ts:91`  | —            | `harness-rewrite` | `active`    | Cannot read properties of undefined (reading 'parseMarbles')                                                                                                                                                                                            | `FIXED` |

### `throttle`

Owner source: `spec/operators/throttle-spec.ts`

| Case ID                                                                                                                                                                               | Behavioral test                                                                   | Source                                | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/throttle-spec.ts:106:throttle > should not break unsubscription chains when result is unsubscribed explicitly`                                                        | should not break unsubscription chains when result is unsubscribed explicitly     | `spec/operators/throttle-spec.ts:106` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:127:throttle > should handle a busy producer emitting a regular repeating sequence`                                                                  | should handle a busy producer emitting a regular repeating sequence               | `spec/operators/throttle-spec.ts:127` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:149:throttle > should mirror source if durations are immediate`                                                                                      | should mirror source if durations are immediate                                   | `spec/operators/throttle-spec.ts:149` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:15:throttle > should immediately emit the first value in each time window`                                                                           | should immediately emit the first value in each time window                       | `spec/operators/throttle-spec.ts:15`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:163:throttle > should mirror source if durations are empty`                                                                                          | should mirror source if durations are empty                                       | `spec/operators/throttle-spec.ts:163` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:177:throttle > should take only the first value emitted if duration is a never`                                                                      | should take only the first value emitted if duration is a never                   | `spec/operators/throttle-spec.ts:177` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:225:throttle > should throttle using durations of varying lengths`                                                                                   | should throttle using durations of varying lengths                                | `spec/operators/throttle-spec.ts:225` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:256:throttle > should propagate error from duration Observable`                                                                                      | should propagate error from duration Observable                                   | `spec/operators/throttle-spec.ts:256` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:310:throttle > should complete when source does not emit`                                                                                            | should complete when source does not emit                                         | `spec/operators/throttle-spec.ts:310` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:340:throttle > should handle an empty source`                                                                                                        | should handle an empty source                                                     | `spec/operators/throttle-spec.ts:340` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:355:throttle > should handle a never source`                                                                                                         | should handle a never source                                                      | `spec/operators/throttle-spec.ts:355` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/throttle-spec.ts:409:throttle > throttle(fn, { leading: true, trailing: true }) > should work for individual values`                                                  | should work for individual values                                                 | `spec/operators/throttle-spec.ts:409` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:446:throttle > throttle(fn, { leading: false, trailing: true }) > should immediately emit the first value in each time window`                       | should immediately emit the first value in each time window                       | `spec/operators/throttle-spec.ts:446` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:469:throttle > throttle(fn, { leading: false, trailing: true }) > should work for individual values`                                                 | should work for individual values                                                 | `spec/operators/throttle-spec.ts:469` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:484:throttle > throttle(fn, { leading: false, trailing: true }) > should wait for trailing throttle before completing, even if source completes`     | should wait for trailing throttle before completing, even if source completes     | `spec/operators/throttle-spec.ts:484` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:49:throttle > should simply mirror the source if values are not emitted often enough`                                                                | should simply mirror the source if values are not emitted often enough            | `spec/operators/throttle-spec.ts:49`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:499:throttle > throttle(fn, { leading: false, trailing: true }) > should emit trailing value after throttle duration when source completes`          | should emit trailing value after throttle duration when source completes          | `spec/operators/throttle-spec.ts:499` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:520:throttle > throttle(fn, { leading: false, trailing: true }) > should emit the last trailing value after throttle duration when source completes` | should emit the last trailing value after throttle duration when source completes | `spec/operators/throttle-spec.ts:520` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:541:throttle > throttle(fn, { leading: false, trailing: true }) > should complete when source completes if no value is available`                    | should complete when source completes if no value is available                    | `spec/operators/throttle-spec.ts:541` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:69:throttle > should throttle with duration Observable using next to close the duration`                                                             | should throttle with duration Observable using next to close the duration         | `spec/operators/throttle-spec.ts:69`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttle-spec.ts:89:throttle > should interrupt source and duration when result is unsubscribed early`                                                                | should interrupt source and duration when result is unsubscribed early            | `spec/operators/throttle-spec.ts:89`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `throttleTime`

Owner source: `spec/operators/throttleTime-spec.ts`

| Case ID                                                                                                                                                                                               | Behavioral test                                                               | Source                                    | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/throttleTime-spec.ts:105:throttleTime operator > default behavior { leading: true, trailing: false } > should handle an empty source`                                                 | should handle an empty source                                                 | `spec/operators/throttleTime-spec.ts:105` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:116:throttleTime operator > default behavior { leading: true, trailing: false } > should handle a never source`                                                  | should handle a never source                                                  | `spec/operators/throttleTime-spec.ts:116` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/throttleTime-spec.ts:138:throttleTime operator > default behavior { leading: true, trailing: false } > should throttle and does not complete when source does not completes`          | should throttle and does not complete when source does not completes          | `spec/operators/throttleTime-spec.ts:138` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:150:throttleTime operator > default behavior { leading: true, trailing: false } > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/throttleTime-spec.ts:150` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:16:throttleTime operator > default behavior { leading: true, trailing: false } > should immediately emit the first value in each time window`                    | should immediately emit the first value in each time window                   | `spec/operators/throttleTime-spec.ts:16`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:196:throttleTime operator > throttleTime(fn, { leading: true, trailing: true }) > should emit the value if only a single one is given`                           | should emit the value if only a single one is given                           | `spec/operators/throttleTime-spec.ts:196` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:210:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should immediately emit the last value in each time window`                   | should immediately emit the last value in each time window                    | `spec/operators/throttleTime-spec.ts:210` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:225:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should emit the last throttled value when complete`                           | should emit the last throttled value when complete                            | `spec/operators/throttleTime-spec.ts:225` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:240:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should emit the value if only a single one is given`                          | should emit the value if only a single one is given                           | `spec/operators/throttleTime-spec.ts:240` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:61:throttleTime operator > default behavior { leading: true, trailing: false } > should simply mirror the source if values are not emitted often enough`         | should simply mirror the source if values are not emitted often enough        | `spec/operators/throttleTime-spec.ts:61`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:72:throttleTime operator > default behavior { leading: true, trailing: false } > should handle a busy producer emitting a regular repeating sequence`            | should handle a busy producer emitting a regular repeating sequence           | `spec/operators/throttleTime-spec.ts:72`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/throttleTime-spec.ts:83:throttleTime operator > default behavior { leading: true, trailing: false } > should complete when source does not emit`                                      | should complete when source does not emit                                     | `spec/operators/throttleTime-spec.ts:83`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |

### `throwIfEmpty`

Owner source: `spec/operators/throwIfEmpty-spec.ts`

| Case ID                                                                                                    | Behavioral test            | Source                                    | Failing mode | Classification | Disposition | Concise failure                           | Status  |
| ---------------------------------------------------------------------------------------------------------- | -------------------------- | ----------------------------------------- | ------------ | -------------- | ----------- | ----------------------------------------- | ------- |
| `spec/operators/throwIfEmpty-spec.ts:156:throwIfEmpty > without errorFactory > should pass values through` | should pass values through | `spec/operators/throwIfEmpty-spec.ts:156` | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:16:throwIfEmpty > with errorFactory > should error when empty`        | should error when empty    | `spec/operators/throwIfEmpty-spec.ts:16`  | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:169:throwIfEmpty > without errorFactory > should never when never`    | should never when never    | `spec/operators/throwIfEmpty-spec.ts:169` | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:182:throwIfEmpty > without errorFactory > should error when empty`    | should error when empty    | `spec/operators/throwIfEmpty-spec.ts:182` | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:55:throwIfEmpty > with errorFactory > should pass values through`     | should pass values through | `spec/operators/throwIfEmpty-spec.ts:55`  | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:68:throwIfEmpty > with errorFactory > should never when never`        | should never when never    | `spec/operators/throwIfEmpty-spec.ts:68`  | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |
| `spec/operators/throwIfEmpty-spec.ts:81:throwIfEmpty > with errorFactory > should error when empty`        | should error when empty    | `spec/operators/throwIfEmpty-spec.ts:81`  | —            | `portable`     | `active`    | Missing operator capability: throwIfEmpty | `FIXED` |

### `timeInterval`

Owner source: `spec/operators/timeInterval-spec.ts`

| Case ID                                                                                                                                  | Behavioral test                                                                  | Source                                    | Failing mode | Classification | Disposition | Concise failure                   | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ----------------------------------------- | ------------ | -------------- | ----------- | --------------------------------- | ------- |
| `spec/operators/timeInterval-spec.ts:108:timeInterval > should not break unsubscription chains when result is unsubscribed explicitly`   | should not break unsubscription chains when result is unsubscribed explicitly    | `spec/operators/timeInterval-spec.ts:108` | —            | `portable`     | `active`    | TimeInterval is not a constructor | `FIXED` |
| `spec/operators/timeInterval-spec.ts:131:timeInterval > should not completes if source never completes`                                  | should not completes if source never completes                                   | `spec/operators/timeInterval-spec.ts:131` | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:142:timeInterval > raise error if source raises error`                                              | raise error if source raises error                                               | `spec/operators/timeInterval-spec.ts:142` | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:153:timeInterval > should record interval then raise error if source raises error after emit`       | should record interval then raise error if source raises error after emit        | `spec/operators/timeInterval-spec.ts:153` | —            | `portable`     | `active`    | TimeInterval is not a constructor | `FIXED` |
| `spec/operators/timeInterval-spec.ts:16:timeInterval > should record the time interval between source elements`                          | should record the time interval between source elements                          | `spec/operators/timeInterval-spec.ts:16`  | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:169:timeInterval > should raise error if source immediately throws`                                 | should raise error if source immediately throws                                  | `spec/operators/timeInterval-spec.ts:169` | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:33:timeInterval > should record interval if source emit elements`                                   | should record interval if source emit elements                                   | `spec/operators/timeInterval-spec.ts:33`  | —            | `portable`     | `active`    | TimeInterval is not a constructor | `FIXED` |
| `spec/operators/timeInterval-spec.ts:51:timeInterval > should completes without record interval if source does not emits`                | should completes without record interval if source does not emits                | `spec/operators/timeInterval-spec.ts:51`  | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:62:timeInterval > should complete immediately if source is empty`                                   | should complete immediately if source is empty                                   | `spec/operators/timeInterval-spec.ts:62`  | —            | `portable`     | `active`    | rxTestScheduler is not defined    | `FIXED` |
| `spec/operators/timeInterval-spec.ts:73:timeInterval > should record interval then does not completes if source emits but not completes` | should record interval then does not completes if source emits but not completes | `spec/operators/timeInterval-spec.ts:73`  | —            | `portable`     | `active`    | TimeInterval is not a constructor | `FIXED` |
| `spec/operators/timeInterval-spec.ts:89:timeInterval > should allow unsubscribing explicitly and early`                                  | should allow unsubscribing explicitly and early                                  | `spec/operators/timeInterval-spec.ts:89`  | —            | `portable`     | `active`    | TimeInterval is not a constructor | `FIXED` |

### `timeout`

Owner source: `spec/operators/timeout-spec.ts`

| Case ID                                                                                                                                                                                     | Behavioral test                                                                                                        | Source                               | Failing mode | Classification | Disposition | Concise failure                   | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ------------ | -------------- | ----------- | --------------------------------- | ------- |
| `spec/operators/timeout-spec.ts:106:timeout operator > should not timeout if source emits within timeout period`                                                                            | should not timeout if source emits within timeout period                                                               | `spec/operators/timeout-spec.ts:106` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:118:timeout operator > should allow unsubscribing explicitly and early`                                                                                     | should allow unsubscribing explicitly and early                                                                        | `spec/operators/timeout-spec.ts:118` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:133:timeout operator > should not break unsubscription chains when result is unsubscribed explicitly`                                                       | should not break unsubscription chains when result is unsubscribed explicitly                                          | `spec/operators/timeout-spec.ts:133` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:152:timeout operator > should timeout after a specified timeout period between emit with default error while source emits`                                  | should timeout after a specified timeout period between emit with default error while source emits                     | `spec/operators/timeout-spec.ts:152` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:166:timeout operator > should timeout at a specified Date`                                                                                                  | should timeout at a specified Date                                                                                     | `spec/operators/timeout-spec.ts:166` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:17:timeout operator > should timeout after a specified timeout period`                                                                                      | should timeout after a specified timeout period                                                                        | `spec/operators/timeout-spec.ts:17`  | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:188:timeout operator > config > should timeout after a specified timeout period`                                                                            | should timeout after a specified timeout period                                                                        | `spec/operators/timeout-spec.ts:188` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:206:timeout operator > config > should emit and TimeoutError on timeout with appropriate due as number`                                                     | should emit and TimeoutError on timeout with appropriate due as number                                                 | `spec/operators/timeout-spec.ts:206` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:234:timeout operator > config > should emit and TimeoutError on timeout with appropriate due as Date`                                                       | should emit and TimeoutError on timeout with appropriate due as Date                                                   | `spec/operators/timeout-spec.ts:234` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:266:timeout operator > config > should not timeout if source completes within absolute timeout period`                                                      | should not timeout if source completes within absolute timeout period                                                  | `spec/operators/timeout-spec.ts:266` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:278:timeout operator > config > should not timeout if source emits within timeout period`                                                                   | should not timeout if source emits within timeout period                                                               | `spec/operators/timeout-spec.ts:278` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:290:timeout operator > config > should allow unsubscribing explicitly and early`                                                                            | should allow unsubscribing explicitly and early                                                                        | `spec/operators/timeout-spec.ts:290` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:305:timeout operator > config > should not break unsubscription chains when result is unsubscribed explicitly`                                              | should not break unsubscription chains when result is unsubscribed explicitly                                          | `spec/operators/timeout-spec.ts:305` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:31:timeout operator > should emit and TimeoutError on timeout with appropriate due as number`                                                               | should emit and TimeoutError on timeout with appropriate due as number                                                 | `spec/operators/timeout-spec.ts:31`  | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:324:timeout operator > config > should timeout after a specified timeout period between emit with default error while source emits`                         | should timeout after a specified timeout period between emit with default error while source emits                     | `spec/operators/timeout-spec.ts:324` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:338:timeout operator > config > should timeout at a specified Date`                                                                                         | should timeout at a specified Date                                                                                     | `spec/operators/timeout-spec.ts:338` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:353:timeout operator > config > should timeout at a specified time for first value only`                                                                    | should timeout at a specified time for first value only                                                                | `spec/operators/timeout-spec.ts:353` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:368:timeout operator > config > should not timeout for long delays if only first is specified`                                                              | should not timeout for long delays if only first is specified                                                          | `spec/operators/timeout-spec.ts:368` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:383:timeout operator > config > should not timeout for long delays if only first is specified as Date`                                                      | should not timeout for long delays if only first is specified as Date                                                  | `spec/operators/timeout-spec.ts:383` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:398:timeout operator > config > should timeout for long delays if first is specified as Date AND each is specified`                                         | should timeout for long delays if first is specified as Date AND each is specified                                     | `spec/operators/timeout-spec.ts:398` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:416:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable`                                        | should timeout after a specified period then subscribe to the passed observable                                        | `spec/operators/timeout-spec.ts:416` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:438:timeout operator > using with > should timeout at a specified date then subscribe to the passed observable`                                             | should timeout at a specified date then subscribe to the passed observable                                             | `spec/operators/timeout-spec.ts:438` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:461:timeout operator > using with > should timeout after a specified period between emit then subscribe to the passed observable when source emits`         | should timeout after a specified period between emit then subscribe to the passed observable when source emits         | `spec/operators/timeout-spec.ts:461` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:483:timeout operator > using with > should allow unsubscribing explicitly and early`                                                                        | should allow unsubscribing explicitly and early                                                                        | `spec/operators/timeout-spec.ts:483` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:501:timeout operator > using with > should not break unsubscription chain when unsubscribed explicitly`                                                     | should not break unsubscription chain when unsubscribed explicitly                                                     | `spec/operators/timeout-spec.ts:501` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:523:timeout operator > using with > should not subscribe to withObservable after explicit unsubscription`                                                   | should not subscribe to withObservable after explicit unsubscription                                                   | `spec/operators/timeout-spec.ts:523` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:544:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable when source is empty`                   | should timeout after a specified period then subscribe to the passed observable when source is empty                   | `spec/operators/timeout-spec.ts:544` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:561:timeout operator > using with > should timeout after a specified period between emit then never completes if other source does not complete`            | should timeout after a specified period between emit then never completes if other source does not complete            | `spec/operators/timeout-spec.ts:561` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:578:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable when source raises error after timeout` | should timeout after a specified period then subscribe to the passed observable when source raises error after timeout | `spec/operators/timeout-spec.ts:578` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:59:timeout operator > should emit and TimeoutError on timeout with appropriate due as Date`                                                                 | should emit and TimeoutError on timeout with appropriate due as Date                                                   | `spec/operators/timeout-spec.ts:59`  | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:595:timeout operator > using with > should timeout after a specified period between emit then never completes if other source emits but not complete`       | should timeout after a specified period between emit then never completes if other source emits but not complete       | `spec/operators/timeout-spec.ts:595` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:612:timeout operator > using with > should not timeout if source completes within timeout period`                                                           | should not timeout if source completes within timeout period                                                           | `spec/operators/timeout-spec.ts:612` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:628:timeout operator > using with > should not timeout if source raises error within timeout period`                                                        | should not timeout if source raises error within timeout period                                                        | `spec/operators/timeout-spec.ts:628` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:644:timeout operator > using with > should not timeout if source emits within timeout period`                                                               | should not timeout if source emits within timeout period                                                               | `spec/operators/timeout-spec.ts:644` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:660:timeout operator > using with > should not timeout if source completes within specified Date`                                                           | should not timeout if source completes within specified Date                                                           | `spec/operators/timeout-spec.ts:660` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:677:timeout operator > using with > should not timeout if source raises error within specified Date`                                                        | should not timeout if source raises error within specified Date                                                        | `spec/operators/timeout-spec.ts:677` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:694:timeout operator > using with > should not timeout if source emits synchronously when subscribed`                                                       | should not timeout if source emits synchronously when subscribed                                                       | `spec/operators/timeout-spec.ts:694` | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |
| `spec/operators/timeout-spec.ts:91:timeout operator > should not timeout if source completes within absolute timeout period`                                                                | should not timeout if source completes within absolute timeout period                                                  | `spec/operators/timeout-spec.ts:91`  | —            | `portable`     | `active`    | TimeoutError is not a constructor | `FIXED` |

### `timeoutWith`

Owner source: `spec/operators/timeoutWith-spec.ts`

| Case ID                                                                                                                                                                                | Behavioral test                                                                                                        | Source                                   | Failing mode | Classification | Disposition | Concise failure                | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ------------ | -------------- | ----------- | ------------------------------ | ------- |
| `spec/operators/timeoutWith-spec.ts:107:timeoutWith operator > should not subscribe to withObservable after explicit unsubscription`                                                   | should not subscribe to withObservable after explicit unsubscription                                                   | `spec/operators/timeoutWith-spec.ts:107` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:128:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable when source is empty`                   | should timeout after a specified period then subscribe to the passed observable when source is empty                   | `spec/operators/timeoutWith-spec.ts:128` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:145:timeoutWith operator > should timeout after a specified period between emit then never completes if other source does not complete`            | should timeout after a specified period between emit then never completes if other source does not complete            | `spec/operators/timeoutWith-spec.ts:145` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:15:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable`                                         | should timeout after a specified period then subscribe to the passed observable                                        | `spec/operators/timeoutWith-spec.ts:15`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:162:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable when source raises error after timeout` | should timeout after a specified period then subscribe to the passed observable when source raises error after timeout | `spec/operators/timeoutWith-spec.ts:162` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:179:timeoutWith operator > should timeout after a specified period between emit then never completes if other source emits but not complete`       | should timeout after a specified period between emit then never completes if other source emits but not complete       | `spec/operators/timeoutWith-spec.ts:179` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:196:timeoutWith operator > should not timeout if source completes within timeout period`                                                           | should not timeout if source completes within timeout period                                                           | `spec/operators/timeoutWith-spec.ts:196` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:212:timeoutWith operator > should not timeout if source raises error within timeout period`                                                        | should not timeout if source raises error within timeout period                                                        | `spec/operators/timeoutWith-spec.ts:212` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:228:timeoutWith operator > should not timeout if source emits within timeout period`                                                               | should not timeout if source emits within timeout period                                                               | `spec/operators/timeoutWith-spec.ts:228` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:244:timeoutWith operator > should not timeout if source completes within specified Date`                                                           | should not timeout if source completes within specified Date                                                           | `spec/operators/timeoutWith-spec.ts:244` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:261:timeoutWith operator > should not timeout if source raises error within specified Date`                                                        | should not timeout if source raises error within specified Date                                                        | `spec/operators/timeoutWith-spec.ts:261` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:32:timeoutWith operator > should timeout at a specified date then subscribe to the passed observable`                                              | should timeout at a specified date then subscribe to the passed observable                                             | `spec/operators/timeoutWith-spec.ts:32`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:50:timeoutWith operator > should timeout after a specified period between emit then subscribe to the passed observable when source emits`          | should timeout after a specified period between emit then subscribe to the passed observable when source emits         | `spec/operators/timeoutWith-spec.ts:50`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:67:timeoutWith operator > should allow unsubscribing explicitly and early`                                                                         | should allow unsubscribing explicitly and early                                                                        | `spec/operators/timeoutWith-spec.ts:67`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timeoutWith-spec.ts:85:timeoutWith operator > should not break unsubscription chain when unsubscribed explicitly`                                                      | should not break unsubscription chain when unsubscribed explicitly                                                     | `spec/operators/timeoutWith-spec.ts:85`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |

### `timer`

Owner source: `spec/observables/timer-spec.ts`

| Case ID                                                                                                                                      | Behavioral test                                                                                 | Source                               | Failing mode | Classification    | Disposition | Concise failure                             | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------ | ------------ | ----------------- | ----------- | ------------------------------------------- | ------- |
| `spec/observables/timer-spec.ts:112:timer > 'should still target the same date if a date is provided even for the ' + 'second subscription'` | 'should still target the same date if a date is provided even for the ' + 'second subscription' | `spec/observables/timer-spec.ts:112` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |
| `spec/observables/timer-spec.ts:128:timer > should accept Infinity as the first argument`                                                    | should accept Infinity as the first argument                                                    | `spec/observables/timer-spec.ts:128` | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |
| `spec/observables/timer-spec.ts:136:timer > should accept Infinity as the second argument`                                                   | should accept Infinity as the second argument                                                   | `spec/observables/timer-spec.ts:136` | —            | `harness-rewrite` | `active`    | rxTest exceeded maxTaskExecutions (100000). | `FIXED` |
| `spec/observables/timer-spec.ts:14:timer > should create an observable emitting periodically`                                                | should create an observable emitting periodically                                               | `spec/observables/timer-spec.ts:14`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |
| `spec/observables/timer-spec.ts:153:timer > should accept 0 as the second argument`                                                          | should accept 0 as the second argument                                                          | `spec/observables/timer-spec.ts:153` | —            | `portable`        | `active`    | Missing operator capability: take           | `FIXED` |
| `spec/observables/timer-spec.ts:51:timer > should start after delay and periodically emit values`                                            | should start after delay and periodically emit values                                           | `spec/observables/timer-spec.ts:51`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |
| `spec/observables/timer-spec.ts:63:timer > should start immediately and periodically emit values`                                            | should start immediately and periodically emit values                                           | `spec/observables/timer-spec.ts:63`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |
| `spec/observables/timer-spec.ts:75:timer > should stop emitting values when subscription is done`                                            | should stop emitting values when subscription is done                                           | `spec/observables/timer-spec.ts:75`  | —            | `harness-rewrite` | `active`    | rxTest exceeded maxTaskExecutions (100000). | `FIXED` |
| `spec/observables/timer-spec.ts:99:timer > should start after delay and periodically emit values`                                            | should start after delay and periodically emit values                                           | `spec/observables/timer-spec.ts:99`  | —            | `harness-rewrite` | `active`    | rxTest observable assertion failed.         | `FIXED` |

### `timestamp`

Owner source: `spec/operators/timestamp-spec.ts`

| Case ID                                                                                                                          | Behavioral test                                                               | Source                                 | Failing mode | Classification | Disposition | Concise failure                | Status  |
| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------- | ------------ | -------------- | ----------- | ------------------------------ | ------- |
| `spec/operators/timestamp-spec.ts:107:timestamp > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/timestamp-spec.ts:107` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:130:timestamp > should not completes if source never completes`                                | should not completes if source never completes                                | `spec/operators/timestamp-spec.ts:130` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:141:timestamp > raise error if source raises error`                                            | raise error if source raises error                                            | `spec/operators/timestamp-spec.ts:141` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:15:timestamp > should record the time stamp per each source elements`                          | should record the time stamp per each source elements                         | `spec/operators/timestamp-spec.ts:15`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:152:timestamp > should record stamp then raise error if source raises error after emit`        | should record stamp then raise error if source raises error after emit        | `spec/operators/timestamp-spec.ts:152` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:168:timestamp > should raise error if source immediately throws`                               | should raise error if source immediately throws                               | `spec/operators/timestamp-spec.ts:168` | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:32:timestamp > should record stamp if source emit elements`                                    | should record stamp if source emit elements                                   | `spec/operators/timestamp-spec.ts:32`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:50:timestamp > should completes without record stamp if source does not emits`                 | should completes without record stamp if source does not emits                | `spec/operators/timestamp-spec.ts:50`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:61:timestamp > should complete immediately if source is empty`                                 | should complete immediately if source is empty                                | `spec/operators/timestamp-spec.ts:61`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:72:timestamp > should record stamp then does not completes if source emits but not completes`  | should record stamp then does not completes if source emits but not completes | `spec/operators/timestamp-spec.ts:72`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/timestamp-spec.ts:88:timestamp > should allow unsubscribing explicitly and early`                                | should allow unsubscribing explicitly and early                               | `spec/operators/timestamp-spec.ts:88`  | —            | `portable`     | `active`    | rxTestScheduler is not defined | `FIXED` |

### `toArray`

Owner source: `spec/operators/toArray-spec.ts`

| Case ID                                                                                                                      | Behavioral test                                                               | Source                               | Failing mode | Classification    | Disposition        | Concise failure                                                                                      | Status  |
| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------ | ------------ | ----------------- | ------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/toArray-spec.ts:105:toArray > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/toArray-spec.ts:105` | —            | `portable`        | `active`           | rxTest subscriptions assertion failed.                                                               | `FIXED` |
| `spec/operators/toArray-spec.ts:25:toArray > should be never when source is never`                                           | should be never when source is never                                          | `spec/operators/toArray-spec.ts:25`  | —            | `portable`        | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/toArray-spec.ts:47:toArray > should be never when source doesn't complete`                                   | should be never when source doesn't complete                                  | `spec/operators/toArray-spec.ts:47`  | —            | `portable`        | `active`           | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/toArray-spec.ts:80:toArray > should allow multiple subscriptions`                                            | should allow multiple subscriptions                                           | `spec/operators/toArray-spec.ts:80`  | cold         | `harness-rewrite` | `expected-failure` | rxTest subscriptions assertion failed.                                                               | `TODO`  |
| `spec/operators/toArray-spec.ts:93:toArray > should allow unsubscribing explicitly and early`                                | should allow unsubscribing explicitly and early                               | `spec/operators/toArray-spec.ts:93`  | —            | `portable`        | `active`           | rxTest subscriptions assertion failed.                                                               | `FIXED` |

### `window`

Owner source: `spec/operators/window-spec.ts`

| Case ID                                                                                                                                | Behavioral test                                                                            | Source                              | Failing mode | Classification    | Disposition | Concise failure                     | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ----------------------------------- | ------------ | ----------------- | ----------- | ----------------------------------- | ------- |
| `spec/operators/window-spec.ts:105:window > should return a single Never window if source is Never`                                    | should return a single Never window if source is Never                                     | `spec/operators/window-spec.ts:105` | —            | `harness-rewrite` | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:123:window > should be able to split a never Observable into timely empty windows`                      | should be able to split a never Observable into timely empty windows                       | `spec/operators/window-spec.ts:123` | —            | `harness-rewrite` | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:143:window > should emit an error-only window if outer is a simple throw-Observable`                    | should emit an error-only window if outer is a simple throw-Observable                     | `spec/operators/window-spec.ts:143` | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:15:window > should emit windows that close and reopen`                                                  | should emit windows that close and reopen                                                  | `spec/operators/window-spec.ts:15`  | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:161:window > should handle basic case with window closings`                                             | should handle basic case with window closings                                              | `spec/operators/window-spec.ts:161` | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:182:window > should handle basic case with window closings, but outer throws`                           | should handle basic case with window closings, but outer throws                            | `spec/operators/window-spec.ts:182` | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:203:window > should stop emitting windows when outer is unsubscribed early`                             | should stop emitting windows when outer is unsubscribed early                              | `spec/operators/window-spec.ts:203` | —            | `harness-rewrite` | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:223:window > should not break unsubscription chains when result is unsubscribed explicitly`             | should not break unsubscription chains when result is unsubscribed explicitly              | `spec/operators/window-spec.ts:223` | —            | `harness-rewrite` | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:247:window > should make outer emit error when closing throws`                                          | should make outer emit error when closing throws                                           | `spec/operators/window-spec.ts:247` | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:265:window > should complete the resulting Observable when window closings completes`                   | should complete the resulting Observable when window closings completes                    | `spec/operators/window-spec.ts:265` | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:35:window > should return a single empty window if source is empty and closings are basic`              | should return a single empty window if source is empty and closings are basic              | `spec/operators/window-spec.ts:35`  | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:53:window > should return a single empty window if source is empty and closing is empty`                | should return a single empty window if source is empty and closing is empty                | `spec/operators/window-spec.ts:53`  | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:71:window > should return a single empty window if source is sync empty and closing is sync empty`      | should return a single empty window if source is sync empty and closing is sync empty      | `spec/operators/window-spec.ts:71`  | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |
| `spec/operators/window-spec.ts:87:window > should split a Just source into a single window identical to source, using a Never closing` | should split a Just source into a single window identical to source, using a Never closing | `spec/operators/window-spec.ts:87`  | —            | `portable`        | `active`    | Missing operator capability: window | `FIXED` |

### `windowCount`

Owner source: `spec/operators/windowCount-spec.ts`

| Case ID                                                                                                                              | Behavioral test                                                               | Source                                   | Failing mode | Classification    | Disposition | Concise failure                          | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ---------------------------------------- | ------------ | ----------------- | ----------- | ---------------------------------------- | ------- |
| `spec/operators/windowCount-spec.ts:100:windowCount > should propagate error from a just-throw source`                               | should propagate error from a just-throw source                               | `spec/operators/windowCount-spec.ts:100` | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:115:windowCount > should raise error if source raises error`                                     | should raise error if source raises error                                     | `spec/operators/windowCount-spec.ts:115` | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:136:windowCount > should dispose of inner windows once outer is unsubscribed early`              | should dispose of inner windows once outer is unsubscribed early              | `spec/operators/windowCount-spec.ts:136` | —            | `harness-rewrite` | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:15:windowCount > should emit windows with count 3, no skip specified`                            | should emit windows with count 3, no skip specified                           | `spec/operators/windowCount-spec.ts:15`  | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:155:windowCount > should not break unsubscription chains when result is unsubscribed explicitly` | should not break unsubscription chains when result is unsubscribed explicitly | `spec/operators/windowCount-spec.ts:155` | —            | `harness-rewrite` | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:33:windowCount > should emit windows with count 2 and skip 1`                                    | should emit windows with count 2 and skip 1                                   | `spec/operators/windowCount-spec.ts:33`  | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:52:windowCount > should emit windows with count 2, and skip unspecified`                         | should emit windows with count 2, and skip unspecified                        | `spec/operators/windowCount-spec.ts:52`  | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:70:windowCount > should return empty if source is empty`                                         | should return empty if source is empty                                        | `spec/operators/windowCount-spec.ts:70`  | —            | `portable`        | `active`    | Missing operator capability: windowCount | `FIXED` |
| `spec/operators/windowCount-spec.ts:85:windowCount > should return Never if source if Never`                                         | should return Never if source if Never                                        | `spec/operators/windowCount-spec.ts:85`  | —            | `harness-rewrite` | `active`    | Missing operator capability: windowCount | `FIXED` |

### `windowTime`

Owner source: `spec/operators/windowTime-spec.ts`

| Case ID                                                                                                                                                   | Behavioral test                                                                                      | Source                                  | Failing mode | Classification    | Disposition | Concise failure                | Status  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ----------- | ------------------------------ | ------- |
| `spec/operators/windowTime-spec.ts:102:windowTime > should emit windows given windowTimeSpan and windowCreationInterval`                                  | should emit windows given windowTimeSpan and windowCreationInterval                                  | `spec/operators/windowTime-spec.ts:102` | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:126:windowTime > should return a single empty window if source is empty`                                               | should return a single empty window if source is empty                                               | `spec/operators/windowTime-spec.ts:126` | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:14:windowTime > should emit windows given windowTimeSpan and windowCreationInterval`                                   | should emit windows given windowTimeSpan and windowCreationInterval                                  | `spec/operators/windowTime-spec.ts:14`  | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:143:windowTime > should split a Just source into a single window identical to source`                                  | should split a Just source into a single window identical to source                                  | `spec/operators/windowTime-spec.ts:143` | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:160:windowTime > should be able to split a never Observable into timely empty windows`                                 | should be able to split a never Observable into timely empty windows                                 | `spec/operators/windowTime-spec.ts:160` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:184:windowTime > should emit an error-only window if outer is a simple throw-Observable`                               | should emit an error-only window if outer is a simple throw-Observable                               | `spec/operators/windowTime-spec.ts:184` | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:201:windowTime > should handle source Observable which eventually emits an error`                                      | should handle source Observable which eventually emits an error                                      | `spec/operators/windowTime-spec.ts:201` | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:224:windowTime > should emit windows given windowTimeSpan and windowCreationInterval, but outer is unsubscribed early` | should emit windows given windowTimeSpan and windowCreationInterval, but outer is unsubscribed early | `spec/operators/windowTime-spec.ts:224` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:247:windowTime > should not break unsubscription chains when result is unsubscribed explicitly`                        | should not break unsubscription chains when result is unsubscribed explicitly                        | `spec/operators/windowTime-spec.ts:247` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:274:windowTime > should not error if maxWindowSize is hit while nexting to other windows.`                             | should not error if maxWindowSize is hit while nexting to other windows.                             | `spec/operators/windowTime-spec.ts:274` | —            | `harness-rewrite` | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:38:windowTime > should close windows after max count is reached`                                                       | should close windows after max count is reached                                                      | `spec/operators/windowTime-spec.ts:38`  | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:60:windowTime > should close window after max count is reached with windowCreationInterval`                            | should close window after max count is reached with windowCreationInterval                           | `spec/operators/windowTime-spec.ts:60`  | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |
| `spec/operators/windowTime-spec.ts:81:windowTime > should emit windows given windowTimeSpan`                                                              | should emit windows given windowTimeSpan                                                             | `spec/operators/windowTime-spec.ts:81`  | —            | `portable`        | `active`    | rxTestScheduler is not defined | `FIXED` |

### `windowToggle`

Owner source: `spec/operators/windowToggle-spec.ts`

| Case ID                                                                                                                                                                                                          | Behavioral test                                                                                                                                          | Source                                    | Failing mode | Classification           | Disposition | Concise failure                           | Status  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------------ | ------------------------ | ----------- | ----------------------------------------- | ------- |
| `spec/operators/windowToggle-spec.ts:114:windowToggle > should emit windows using varying hot closings`                                                                                                          | should emit windows using varying hot closings                                                                                                           | `spec/operators/windowToggle-spec.ts:114` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:149:windowToggle > should emit windows using varying empty delayed closings`                                                                                                | should emit windows using varying empty delayed closings                                                                                                 | `spec/operators/windowToggle-spec.ts:149` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:15:windowToggle > should emit windows governed by openings and closings`                                                                                                    | should emit windows governed by openings and closings                                                                                                    | `spec/operators/windowToggle-spec.ts:15`  | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:176:windowToggle > should emit windows using varying cold closings, outer unsubscribed early`                                                                               | should emit windows using varying cold closings, outer unsubscribed early                                                                                | `spec/operators/windowToggle-spec.ts:176` | —            | `harness-rewrite`        | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:210:windowToggle > should not break unsubscription chains when result is unsubscribed explicitly`                                                                           | should not break unsubscription chains when result is unsubscribed explicitly                                                                            | `spec/operators/windowToggle-spec.ts:210` | —            | `harness-rewrite`        | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:246:windowToggle > should dispose window Subjects if the outer is unsubscribed early`                                                                                       | should dispose window Subjects if the outer is unsubscribed early                                                                                        | `spec/operators/windowToggle-spec.ts:246` | —            | `intentional-divergence` | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:275:windowToggle > should propagate error thrown from closingSelector`                                                                                                      | should propagate error thrown from closingSelector                                                                                                       | `spec/operators/windowToggle-spec.ts:275` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:307:windowToggle > should propagate error emitted from a closing`                                                                                                           | should propagate error emitted from a closing                                                                                                            | `spec/operators/windowToggle-spec.ts:307` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:333:windowToggle > should propagate error emitted late from a closing`                                                                                                      | should propagate error emitted late from a closing                                                                                                       | `spec/operators/windowToggle-spec.ts:333` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:359:windowToggle > should handle errors`                                                                                                                                    | should handle errors                                                                                                                                     | `spec/operators/windowToggle-spec.ts:359` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:385:windowToggle > should handle empty source`                                                                                                                              | should handle empty source                                                                                                                               | `spec/operators/windowToggle-spec.ts:385` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:403:windowToggle > should handle throw`                                                                                                                                     | should handle throw                                                                                                                                      | `spec/operators/windowToggle-spec.ts:403` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:421:windowToggle > should handle never`                                                                                                                                     | should handle never                                                                                                                                      | `spec/operators/windowToggle-spec.ts:421` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:44:windowToggle > should emit windows that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument` | should emit windows that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument | `spec/operators/windowToggle-spec.ts:44`  | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:446:windowToggle > should handle a never opening Observable`                                                                                                                | should handle a never opening Observable                                                                                                                 | `spec/operators/windowToggle-spec.ts:446` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:464:windowToggle > should handle a never closing Observable`                                                                                                                | should handle a never closing Observable                                                                                                                 | `spec/operators/windowToggle-spec.ts:464` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:486:windowToggle > should handle opening Observable that just throws`                                                                                                       | should handle opening Observable that just throws                                                                                                        | `spec/operators/windowToggle-spec.ts:486` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:506:windowToggle > should handle empty closing observable`                                                                                                                  | should handle empty closing observable                                                                                                                   | `spec/operators/windowToggle-spec.ts:506` | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |
| `spec/operators/windowToggle-spec.ts:79:windowToggle > should emit windows using varying cold closings`                                                                                                          | should emit windows using varying cold closings                                                                                                          | `spec/operators/windowToggle-spec.ts:79`  | —            | `portable`               | `active`    | Missing operator capability: windowToggle | `FIXED` |

### `windowWhen`

Owner source: `spec/operators/windowWhen-spec.ts`

| Case ID                                                                                                                        | Behavioral test                                                           | Source                                  | Failing mode | Classification    | Disposition | Concise failure                         | Status  |
| ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------- | --------------------------------------- | ------------ | ----------------- | ----------- | --------------------------------------- | ------- |
| `spec/operators/windowWhen-spec.ts:105:windowWhen > should emit windows using varying empty delayed closings`                  | should emit windows using varying empty delayed closings                  | `spec/operators/windowWhen-spec.ts:105` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:137:windowWhen > should emit windows using varying cold closings, outer unsubscribed early` | should emit windows using varying cold closings, outer unsubscribed early | `spec/operators/windowWhen-spec.ts:137` | —            | `harness-rewrite` | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:14:windowWhen > should emit windows that close and reopen`                                  | should emit windows that close and reopen                                 | `spec/operators/windowWhen-spec.ts:14`  | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:166:windowWhen > should not break unsubscription chain when unsubscribed explicitly`        | should not break unsubscription chain when unsubscribed explicitly        | `spec/operators/windowWhen-spec.ts:166` | —            | `harness-rewrite` | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:199:windowWhen > should propagate error thrown from closingSelector`                        | should propagate error thrown from closingSelector                        | `spec/operators/windowWhen-spec.ts:199` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:231:windowWhen > should propagate error emitted from a closing`                             | should propagate error emitted from a closing                             | `spec/operators/windowWhen-spec.ts:231` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:259:windowWhen > should propagate error emitted late from a closing`                        | should propagate error emitted late from a closing                        | `spec/operators/windowWhen-spec.ts:259` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:287:windowWhen > should propagate errors emitted from the source`                           | should propagate errors emitted from the source                           | `spec/operators/windowWhen-spec.ts:287` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:317:windowWhen > should handle empty source`                                                | should handle empty source                                                | `spec/operators/windowWhen-spec.ts:317` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:335:windowWhen > should handle a never source`                                              | should handle a never source                                              | `spec/operators/windowWhen-spec.ts:335` | —            | `harness-rewrite` | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:366:windowWhen > should handle throw`                                                       | should handle throw                                                       | `spec/operators/windowWhen-spec.ts:366` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:384:windowWhen > should handle a never closing Observable`                                  | should handle a never closing Observable                                  | `spec/operators/windowWhen-spec.ts:384` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:403:windowWhen > should handle a throw closing Observable`                                  | should handle a throw closing Observable                                  | `spec/operators/windowWhen-spec.ts:403` | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:41:windowWhen > should emit windows using varying cold closings`                            | should emit windows using varying cold closings                           | `spec/operators/windowWhen-spec.ts:41`  | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |
| `spec/operators/windowWhen-spec.ts:73:windowWhen > should emit windows using varying hot closings`                             | should emit windows using varying hot closings                            | `spec/operators/windowWhen-spec.ts:73`  | —            | `portable`        | `active`    | Missing operator capability: windowWhen | `FIXED` |

### `withLatestFrom`

Owner source: `spec/operators/withLatestFrom-spec.ts`

| Case ID                                                                                                                                                                 | Behavioral test                                                                                             | Source                                      | Failing mode | Classification | Disposition | Concise failure                                                                                                                                              | Status  |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------- | ------------ | -------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
| `spec/operators/withLatestFrom-spec.ts:107:withLatestFrom > should not break unsubscription chains when result is unsubscribed explicitly`                              | should not break unsubscription chains when result is unsubscribed explicitly                               | `spec/operators/withLatestFrom-spec.ts:107` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:137:withLatestFrom > should handle empty`                                                                                        | should handle empty                                                                                         | `spec/operators/withLatestFrom-spec.ts:137` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:156:withLatestFrom > should handle never`                                                                                        | should handle never                                                                                         | `spec/operators/withLatestFrom-spec.ts:156` | —            | `portable`     | `active`    | cold: rxTest subscriptions assertion failed.; polyfill: rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:16:withLatestFrom > should combine events from cold observables`                                                                 | should combine events from cold observables                                                                 | `spec/operators/withLatestFrom-spec.ts:16`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:175:withLatestFrom > should handle throw`                                                                                        | should handle throw                                                                                         | `spec/operators/withLatestFrom-spec.ts:175` | —            | `portable`     | `active`    | rxTest subscriptions assertion failed.                                                                                                                       | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:194:withLatestFrom > should handle error`                                                                                        | should handle error                                                                                         | `spec/operators/withLatestFrom-spec.ts:194` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:216:withLatestFrom > should handle error with project argument`                                                                  | should handle error with project argument                                                                   | `spec/operators/withLatestFrom-spec.ts:216` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:239:withLatestFrom > should handle merging with empty`                                                                           | should handle merging with empty                                                                            | `spec/operators/withLatestFrom-spec.ts:239` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:258:withLatestFrom > should handle merging with never`                                                                           | should handle merging with never                                                                            | `spec/operators/withLatestFrom-spec.ts:258` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:32:withLatestFrom > should merge the value with the latest values from the other observables into arrays`                        | should merge the value with the latest values from the other observables into arrays                        | `spec/operators/withLatestFrom-spec.ts:32`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:56:withLatestFrom > should merge the value with the latest values from the other observables into arrays and a project argument` | should merge the value with the latest values from the other observables into arrays and a project argument | `spec/operators/withLatestFrom-spec.ts:56`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |
| `spec/operators/withLatestFrom-spec.ts:81:withLatestFrom > should allow unsubscribing early and explicitly`                                                             | should allow unsubscribing early and explicitly                                                             | `spec/operators/withLatestFrom-spec.ts:81`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                                                                          | `FIXED` |

### `zip`

Owner sources: `spec/observables/zip-spec.ts`, `spec/operators/zip-spec.ts`

| Case ID                                                                                                                                           | Behavioral test                                                                                           | Source                             | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/observables/zip-spec.ts:136:zip > with iterables > should complete instantly if given an empty iterable`                                    | should complete instantly if given an empty iterable                                                      | `spec/observables/zip-spec.ts:136` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:148:zip > with iterables > should work with never observable and non-empty iterable`                                | should work with never observable and non-empty iterable                                                  | `spec/observables/zip-spec.ts:148` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/zip-spec.ts:160:zip > with iterables > should work with non-empty observable and non-empty iterable`                            | should work with non-empty observable and non-empty iterable                                              | `spec/observables/zip-spec.ts:160` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:17:zip > should combine a source with a second`                                                                     | should combine a source with a second                                                                     | `spec/observables/zip-spec.ts:17`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/zip-spec.ts:184:zip > with iterables > should work with non-empty many observable and non-empty many iterable`                  | should work with non-empty many observable and non-empty many iterable                                    | `spec/observables/zip-spec.ts:184` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:196:zip > with iterables > should work with non-empty observable and non-empty iterable selector that throws`       | should work with non-empty observable and non-empty iterable selector that throws                         | `spec/observables/zip-spec.ts:196` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:216:zip > should combine two observables and selector`                                                              | should combine two observables and selector                                                               | `spec/observables/zip-spec.ts:216` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:230:zip > should work with n-ary symmetric`                                                                         | should work with n-ary symmetric                                                                          | `spec/observables/zip-spec.ts:230` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:245:zip > should work with n-ary symmetric selector`                                                                | should work with n-ary symmetric selector                                                                 | `spec/observables/zip-spec.ts:245` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:261:zip > should work with n-ary symmetric array selector`                                                          | should work with n-ary symmetric array selector                                                           | `spec/observables/zip-spec.ts:261` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:277:zip > should work with some data asymmetric 1`                                                                  | should work with some data asymmetric 1                                                                   | `spec/observables/zip-spec.ts:277` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:291:zip > should work with some data asymmetric 2`                                                                  | should work with some data asymmetric 2                                                                   | `spec/observables/zip-spec.ts:291` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:305:zip > should work with some data symmetric`                                                                     | should work with some data symmetric                                                                      | `spec/observables/zip-spec.ts:305` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:319:zip > should work with selector throws`                                                                         | should work with selector throws                                                                          | `spec/observables/zip-spec.ts:319` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:341:zip > should work with right completes first`                                                                   | should work with right completes first                                                                    | `spec/observables/zip-spec.ts:341` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:355:zip > should work with two nevers`                                                                              | should work with two nevers                                                                               | `spec/observables/zip-spec.ts:355` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/zip-spec.ts:369:zip > should work with never and empty`                                                                         | should work with never and empty                                                                          | `spec/observables/zip-spec.ts:369` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:383:zip > should work with empty and never`                                                                         | should work with empty and never                                                                          | `spec/observables/zip-spec.ts:383` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:411:zip > should work with empty and non-empty`                                                                     | should work with empty and non-empty                                                                      | `spec/observables/zip-spec.ts:411` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:425:zip > should work with non-empty and empty`                                                                     | should work with non-empty and empty                                                                      | `spec/observables/zip-spec.ts:425` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:43:zip > should end once one observable completes and its buffer is empty`                                          | should end once one observable completes and its buffer is empty                                          | `spec/observables/zip-spec.ts:43`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:439:zip > should work with never and non-empty`                                                                     | should work with never and non-empty                                                                      | `spec/observables/zip-spec.ts:439` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/zip-spec.ts:453:zip > should work with non-empty and never`                                                                     | should work with non-empty and never                                                                      | `spec/observables/zip-spec.ts:453` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/observables/zip-spec.ts:467:zip > should work with empty and error`                                                                         | should work with empty and error                                                                          | `spec/observables/zip-spec.ts:467` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:481:zip > should work with error and empty`                                                                         | should work with error and empty                                                                          | `spec/observables/zip-spec.ts:481` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:65:zip > should end once one observable nexts and zips value from completed other observable whose buffer is empty` | should end once one observable nexts and zips value from completed other observable whose buffer is empty | `spec/observables/zip-spec.ts:65`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/observables/zip-spec.ts:88:zip > with iterables > should zip them with values`                                                              | should zip them with values                                                                               | `spec/observables/zip-spec.ts:88`  | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/zip-spec.ts:13:zip > should work with non-empty observable and non-empty iterable selector that throws`                           | should work with non-empty observable and non-empty iterable selector that throws                         | `spec/operators/zip-spec.ts:13`    | —            | `portable`     | `active`    | Missing operator capability: zip                                                                     | `FIXED` |

### `zip-legacy`

Owner source: `spec/operators/zip-legacy-spec.ts`

| Case ID                                                                                              | Behavioral test                                 | Source                                  | Failing mode | Classification | Disposition | Concise failure                  | Status  |
| ---------------------------------------------------------------------------------------------------- | ----------------------------------------------- | --------------------------------------- | ------------ | -------------- | ----------- | -------------------------------- | ------- |
| `spec/operators/zip-legacy-spec.ts:113:zip legacy > should work with n-ary symmetric selector`       | should work with n-ary symmetric selector       | `spec/operators/zip-legacy-spec.ts:113` | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:133:zip legacy > should work with n-ary symmetric array selector` | should work with n-ary symmetric array selector | `spec/operators/zip-legacy-spec.ts:133` | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:153:zip legacy > should combine two observables and selector`     | should combine two observables and selector     | `spec/operators/zip-legacy-spec.ts:153` | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:31:zip legacy > should work with selector throws`                 | should work with selector throws                | `spec/operators/zip-legacy-spec.ts:31`  | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:53:zip legacy > should work with some data asymmetric 1`          | should work with some data asymmetric 1         | `spec/operators/zip-legacy-spec.ts:53`  | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:73:zip legacy > should work with some data asymmetric 2`          | should work with some data asymmetric 2         | `spec/operators/zip-legacy-spec.ts:73`  | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |
| `spec/operators/zip-legacy-spec.ts:93:zip legacy > should work with some data symmetric`             | should work with some data symmetric            | `spec/operators/zip-legacy-spec.ts:93`  | —            | `portable`     | `active`    | Missing operator capability: zip | `FIXED` |

### `zipAll`

Owner source: `spec/operators/zipAll-spec.ts`

| Case ID                                                                                                                                                        | Behavioral test                                                                                           | Source                              | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ----------------------------------- | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/zipAll-spec.ts:101:zipAll operator > with iterables > should zip them with values`                                                             | should zip them with values                                                                               | `spec/operators/zipAll-spec.ts:101` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:125:zipAll operator > with iterables > should complete instantly with never observable and empty iterable`                      | should complete instantly with never observable and empty iterable                                        | `spec/operators/zipAll-spec.ts:125` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:137:zipAll operator > with iterables > should work with empty observable and empty iterable`                                    | should work with empty observable and empty iterable                                                      | `spec/operators/zipAll-spec.ts:137` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:149:zipAll operator > with iterables > should work with empty observable and non-empty iterable`                                | should work with empty observable and non-empty iterable                                                  | `spec/operators/zipAll-spec.ts:149` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:15:zipAll operator > should combine paired events from two observables`                                                         | should combine paired events from two observables                                                         | `spec/operators/zipAll-spec.ts:15`  | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:161:zipAll operator > with iterables > should work with non-empty observable and empty iterable`                                | should work with non-empty observable and empty iterable                                                  | `spec/operators/zipAll-spec.ts:161` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:173:zipAll operator > with iterables > should work with never observable and non-empty iterable`                                | should work with never observable and non-empty iterable                                                  | `spec/operators/zipAll-spec.ts:173` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:185:zipAll operator > with iterables > should work with non-empty observable and non-empty iterable`                            | should work with non-empty observable and non-empty iterable                                              | `spec/operators/zipAll-spec.ts:185` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:197:zipAll operator > with iterables > should work with observable which raises error and non-empty iterable`                   | should work with observable which raises error and non-empty iterable                                     | `spec/operators/zipAll-spec.ts:197` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:209:zipAll operator > with iterables > should work with non-empty many observable and non-empty many iterable`                  | should work with non-empty many observable and non-empty many iterable                                    | `spec/operators/zipAll-spec.ts:209` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:221:zipAll operator > with iterables > should work with non-empty observable and non-empty iterable selector that throws`       | should work with non-empty observable and non-empty iterable selector that throws                         | `spec/operators/zipAll-spec.ts:221` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:241:zipAll operator > should combine two observables and selector`                                                              | should combine two observables and selector                                                               | `spec/operators/zipAll-spec.ts:241` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:255:zipAll operator > should work with n-ary symmetric`                                                                         | should work with n-ary symmetric                                                                          | `spec/operators/zipAll-spec.ts:255` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:270:zipAll operator > should work with n-ary symmetric selector`                                                                | should work with n-ary symmetric selector                                                                 | `spec/operators/zipAll-spec.ts:270` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:28:zipAll operator > should combine two observables`                                                                            | should combine two observables                                                                            | `spec/operators/zipAll-spec.ts:28`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:286:zipAll operator > should work with n-ary symmetric array selector`                                                          | should work with n-ary symmetric array selector                                                           | `spec/operators/zipAll-spec.ts:286` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:302:zipAll operator > should work with some data asymmetric 1`                                                                  | should work with some data asymmetric 1                                                                   | `spec/operators/zipAll-spec.ts:302` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:316:zipAll operator > should work with some data asymmetric 2`                                                                  | should work with some data asymmetric 2                                                                   | `spec/operators/zipAll-spec.ts:316` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:330:zipAll operator > should work with some data symmetric`                                                                     | should work with some data symmetric                                                                      | `spec/operators/zipAll-spec.ts:330` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:344:zipAll operator > should work with selector throws`                                                                         | should work with selector throws                                                                          | `spec/operators/zipAll-spec.ts:344` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:367:zipAll operator > should work with right completes first`                                                                   | should work with right completes first                                                                    | `spec/operators/zipAll-spec.ts:367` | —            | `portable`     | `active`    | rxTest observable assertion failed.                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:394:zipAll operator > should handle a hot observable of observables`                                                            | should handle a hot observable of observables                                                             | `spec/operators/zipAll-spec.ts:394` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:416:zipAll operator > should handle merging a hot observable of non-overlapped observables`                                     | should handle merging a hot observable of non-overlapped observables                                      | `spec/operators/zipAll-spec.ts:416` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:440:zipAll operator > should raise error if inner observable raises error`                                                      | should raise error if inner observable raises error                                                       | `spec/operators/zipAll-spec.ts:440` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:465:zipAll operator > should raise error if outer observable raises error`                                                      | should raise error if outer observable raises error                                                       | `spec/operators/zipAll-spec.ts:465` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:478:zipAll operator > should work with two nevers`                                                                              | should work with two nevers                                                                               | `spec/operators/zipAll-spec.ts:478` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:492:zipAll operator > should work with never and empty`                                                                         | should work with never and empty                                                                          | `spec/operators/zipAll-spec.ts:492` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:506:zipAll operator > should work with empty and never`                                                                         | should work with empty and never                                                                          | `spec/operators/zipAll-spec.ts:506` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:520:zipAll operator > should work with empty and empty`                                                                         | should work with empty and empty                                                                          | `spec/operators/zipAll-spec.ts:520` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:534:zipAll operator > should work with empty and non-empty`                                                                     | should work with empty and non-empty                                                                      | `spec/operators/zipAll-spec.ts:534` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:548:zipAll operator > should work with non-empty and empty`                                                                     | should work with non-empty and empty                                                                      | `spec/operators/zipAll-spec.ts:548` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:56:zipAll operator > should end once one observable completes and its buffer is empty`                                          | should end once one observable completes and its buffer is empty                                          | `spec/operators/zipAll-spec.ts:56`  | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:562:zipAll operator > should work with never and non-empty`                                                                     | should work with never and non-empty                                                                      | `spec/operators/zipAll-spec.ts:562` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:576:zipAll operator > should work with non-empty and never`                                                                     | should work with non-empty and never                                                                      | `spec/operators/zipAll-spec.ts:576` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:590:zipAll operator > should combine a source with a second`                                                                    | should combine a source with a second                                                                     | `spec/operators/zipAll-spec.ts:590` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipAll-spec.ts:604:zipAll operator > should work with empty and error`                                                                         | should work with empty and error                                                                          | `spec/operators/zipAll-spec.ts:604` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:618:zipAll operator > should work with error and empty`                                                                         | should work with error and empty                                                                          | `spec/operators/zipAll-spec.ts:618` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:632:zipAll operator > should work with error`                                                                                   | should work with error                                                                                    | `spec/operators/zipAll-spec.ts:632` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:646:zipAll operator > should work with never and error`                                                                         | should work with never and error                                                                          | `spec/operators/zipAll-spec.ts:646` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:660:zipAll operator > should work with error and never`                                                                         | should work with error and never                                                                          | `spec/operators/zipAll-spec.ts:660` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:674:zipAll operator > should work with error and error`                                                                         | should work with error and error                                                                          | `spec/operators/zipAll-spec.ts:674` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:688:zipAll operator > should work with two sources that eventually raise errors`                                                | should work with two sources that eventually raise errors                                                 | `spec/operators/zipAll-spec.ts:688` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:702:zipAll operator > should work with two sources that eventually raise errors (swapped)`                                      | should work with two sources that eventually raise errors (swapped)                                       | `spec/operators/zipAll-spec.ts:702` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:716:zipAll operator > should work with error and some`                                                                          | should work with error and some                                                                           | `spec/operators/zipAll-spec.ts:716` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:772:zipAll operator > should not break unsubscription chain when unsubscribed explicitly`                                       | should not break unsubscription chain when unsubscribed explicitly                                        | `spec/operators/zipAll-spec.ts:772` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:78:zipAll operator > should end once one observable nexts and zips value from completed other observable whose buffer is empty` | should end once one observable nexts and zips value from completed other observable whose buffer is empty | `spec/operators/zipAll-spec.ts:78`  | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |
| `spec/operators/zipAll-spec.ts:794:zipAll operator > should complete when empty source`                                                                        | should complete when empty source                                                                         | `spec/operators/zipAll-spec.ts:794` | —            | `portable`     | `active`    | Missing operator capability: zipAll                                                                  | `FIXED` |

### `zipWith`

Owner source: `spec/operators/zipWith-spec.ts`

| Case ID                                                                                                                                                 | Behavioral test                                                                                           | Source                               | Failing mode | Classification | Disposition | Concise failure                                                                                      | Status  |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------ | ------------ | -------------- | ----------- | ---------------------------------------------------------------------------------------------------- | ------- |
| `spec/operators/zipWith-spec.ts:109:zipWith > with iterables > should work with empty observable and empty iterable`                                    | should work with empty observable and empty iterable                                                      | `spec/operators/zipWith-spec.ts:109` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:121:zipWith > with iterables > should work with empty observable and non-empty iterable`                                | should work with empty observable and non-empty iterable                                                  | `spec/operators/zipWith-spec.ts:121` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:133:zipWith > with iterables > should complete instantly with non-empty observable and empty iterable`                  | should complete instantly with non-empty observable and empty iterable                                    | `spec/operators/zipWith-spec.ts:133` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:145:zipWith > with iterables > should work with never observable and non-empty iterable`                                | should work with never observable and non-empty iterable                                                  | `spec/operators/zipWith-spec.ts:145` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipWith-spec.ts:15:zipWith > should combine a source with a second`                                                                     | should combine a source with a second                                                                     | `spec/operators/zipWith-spec.ts:15`  | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipWith-spec.ts:157:zipWith > with iterables > should work with non-empty observable and non-empty iterable`                            | should work with non-empty observable and non-empty iterable                                              | `spec/operators/zipWith-spec.ts:157` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:169:zipWith > with iterables > should work with observable which raises error and non-empty iterable`                   | should work with observable which raises error and non-empty iterable                                     | `spec/operators/zipWith-spec.ts:169` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:181:zipWith > with iterables > should work with non-empty many observable and non-empty many iterable`                  | should work with non-empty many observable and non-empty many iterable                                    | `spec/operators/zipWith-spec.ts:181` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:194:zipWith > should work with n-ary symmetric`                                                                         | should work with n-ary symmetric                                                                          | `spec/operators/zipWith-spec.ts:194` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:209:zipWith > should work with right completes first`                                                                   | should work with right completes first                                                                    | `spec/operators/zipWith-spec.ts:209` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:223:zipWith > should work with two nevers`                                                                              | should work with two nevers                                                                               | `spec/operators/zipWith-spec.ts:223` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipWith-spec.ts:237:zipWith > should work with never and empty`                                                                         | should work with never and empty                                                                          | `spec/operators/zipWith-spec.ts:237` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:251:zipWith > should work with empty and never`                                                                         | should work with empty and never                                                                          | `spec/operators/zipWith-spec.ts:251` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:265:zipWith > should work with empty and empty`                                                                         | should work with empty and empty                                                                          | `spec/operators/zipWith-spec.ts:265` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:279:zipWith > should work with empty and non-empty`                                                                     | should work with empty and non-empty                                                                      | `spec/operators/zipWith-spec.ts:279` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:28:zipWith > should end once one observable completes and its buffer is empty`                                          | should end once one observable completes and its buffer is empty                                          | `spec/operators/zipWith-spec.ts:28`  | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:293:zipWith > should work with non-empty and empty`                                                                     | should work with non-empty and empty                                                                      | `spec/operators/zipWith-spec.ts:293` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:307:zipWith > should work with never and non-empty`                                                                     | should work with never and non-empty                                                                      | `spec/operators/zipWith-spec.ts:307` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipWith-spec.ts:321:zipWith > should work with non-empty and never`                                                                     | should work with non-empty and never                                                                      | `spec/operators/zipWith-spec.ts:321` | —            | `portable`     | `active`    | rxTest finished with 1 open observation(s). Complete the source or provide an unsubscription marble. | `FIXED` |
| `spec/operators/zipWith-spec.ts:335:zipWith > should work with empty and error`                                                                         | should work with empty and error                                                                          | `spec/operators/zipWith-spec.ts:335` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:349:zipWith > should work with error and empty`                                                                         | should work with error and empty                                                                          | `spec/operators/zipWith-spec.ts:349` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:363:zipWith > should work with error`                                                                                   | should work with error                                                                                    | `spec/operators/zipWith-spec.ts:363` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:377:zipWith > should work with never and error`                                                                         | should work with never and error                                                                          | `spec/operators/zipWith-spec.ts:377` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:391:zipWith > should work with error and never`                                                                         | should work with error and never                                                                          | `spec/operators/zipWith-spec.ts:391` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:405:zipWith > should work with error and error`                                                                         | should work with error and error                                                                          | `spec/operators/zipWith-spec.ts:405` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:419:zipWith > should work with two sources that eventually raise errors`                                                | should work with two sources that eventually raise errors                                                 | `spec/operators/zipWith-spec.ts:419` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:433:zipWith > should work with two sources that eventually raise errors (swapped)`                                      | should work with two sources that eventually raise errors (swapped)                                       | `spec/operators/zipWith-spec.ts:433` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:447:zipWith > should work with error and some`                                                                          | should work with error and some                                                                           | `spec/operators/zipWith-spec.ts:447` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:479:zipWith > should not break unsubscription chain when unsubscribed explicitly`                                       | should not break unsubscription chain when unsubscribed explicitly                                        | `spec/operators/zipWith-spec.ts:479` | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:50:zipWith > should end once one observable nexts and zips value from completed other observable whose buffer is empty` | should end once one observable nexts and zips value from completed other observable whose buffer is empty | `spec/operators/zipWith-spec.ts:50`  | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:73:zipWith > with iterables > should zip them with values`                                                              | should zip them with values                                                                               | `spec/operators/zipWith-spec.ts:73`  | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |
| `spec/operators/zipWith-spec.ts:97:zipWith > with iterables > should complete instantly for an empty iterable`                                          | should complete instantly for an empty iterable                                                           | `spec/operators/zipWith-spec.ts:97`  | —            | `portable`     | `active`    | Missing operator capability: zipWith                                                                 | `FIXED` |

## Actionable work packets

Work packets are ordered for delegation: the small portable `never` harness correction first, then groups with portable or harness-rewrite evidence, mixed groups, and finally compatibility-only groups whose final surface may depend on the package and compatibility decisions. Claim a packet by changing its unresolved ledger rows to `IN-PROCESS`; do not introduce another project-level `NEXT` marker.

### RX7-NEVER — `never`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Repair the migrated NEVER test by adding an explicit observation/unsubscription boundary so `rxTest` can finish while preserving the claim that the source emits and completes neither; do not change NEVER runtime semantics.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/never-spec.ts:15:NEVER > should create a cold observable that never emits`

</details>

### RX7-RXJS-TEST — `@rxjs/test`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/testing/index-spec.ts:5:index > should export TestScheduler`

</details>

### RX7-AJAX — `ajax`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/dom/ajax-spec.ts:534:ajax > should error on timeout of asynchronous request`

</details>

### RX7-FROM — `from`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/from-spec.ts:21:from > should create an observable from an array`

</details>

### RX7-FROM-EVENT — `fromEvent`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/fromEvent-spec.ts:16:fromEvent > should create an observable of click on the element`

</details>

### RX7-FROM-EVENT-PATTERN — `fromEventPattern`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/fromEventPattern-spec.ts:18:fromEventPattern > should create an observable from the handler API`

</details>

### RX7-OF — `of`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/observables/of-spec.ts:16:of > should create a cold observable that emits 1, 2, 3`

</details>

### RX7-QUEUE-SCHEDULER — `QueueScheduler`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/schedulers/QueueScheduler-spec.ts:18:Scheduler.queue > should act like the async scheduler if delay > 0`

</details>

### RX7-REF-COUNT — `refCount`

- **Packet status:** `FIXED`
- **Evidence:** 1 tracked case(s); 0 cold failures; 0 polyfill failures; 1 fixed.
- **Current surface/gap:** 1 active-registration failure(s).
- **Required classification review:** 1 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (1)</summary>

- `spec/operators/refCount-spec.ts:9:refCount > should turn a multicasted Observable an automatically (dis)connecting hot one`

</details>

### RX7-ANIMATION-FRAME-SCHEDULER — `AnimationFrameScheduler`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/schedulers/AnimationFrameScheduler-spec.ts:24:Scheduler.animationFrame > should act like the async scheduler if delay > 0`
- `spec/schedulers/AnimationFrameScheduler-spec.ts:41:Scheduler.animationFrame > should cancel animationFrame actions when delay > 0`

</details>

### RX7-ASAP-SCHEDULER — `AsapScheduler`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/schedulers/AsapScheduler-spec.ts:24:Scheduler.asap > should act like the async scheduler if delay > 0`
- `spec/schedulers/AsapScheduler-spec.ts:40:Scheduler.asap > should cancel asap actions when delay > 0`

</details>

### RX7-BEHAVIOR-SUBJECT — `BehaviorSubject`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/subjects/BehaviorSubject-spec.ts:144:BehaviorSubject > should replay the previous value when subscribed`
- `spec/subjects/BehaviorSubject-spec.ts:176:BehaviorSubject > should emit complete when subscribed after completed`

</details>

### RX7-CONNECT — `connect`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/operators/connect-spec.ts:13:connect > should connect a source through a selector function`
- `spec/operators/connect-spec.ts:25:connect > should connect a source through a selector function and use the provided connector`

</details>

### RX7-CONNECTABLE — `connectable`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 1 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/observables/connectable-spec.ts:14:connectable > should mirror a simple source Observable`
- `spec/observables/connectable-spec.ts:29:connectable > should do nothing if connect is not called, despite subscriptions`

</details>

### RX7-DEFAULT-IF-EMPTY — `defaultIfEmpty`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/operators/defaultIfEmpty-spec.ts:59:defaultIfEmpty > should allow unsubscribing early and explicitly`
- `spec/operators/defaultIfEmpty-spec.ts:73:defaultIfEmpty > should not break unsubscription chains when unsubscribed explicitly`

</details>

### RX7-DEFER — `defer`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/observables/defer-spec.ts:130:defer > should allow unsubscribing early and explicitly`
- `spec/observables/defer-spec.ts:144:defer > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-MAP-TO — `mapTo`

- **Packet status:** `FIXED`
- **Evidence:** 2 tracked case(s); 0 cold failures; 0 polyfill failures; 2 fixed.
- **Current surface/gap:** 2 active-registration failure(s).
- **Required classification review:** 2 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (2)</summary>

- `spec/operators/mapTo-spec.ts:37:mapTo > should allow unsubscribing explicitly and early`
- `spec/operators/mapTo-spec.ts:99:mapTo > should not break unsubscription chain when unsubscribed explicitly`

</details>

### RX7-IGNORE-ELEMENTS — `ignoreElements`

- **Packet status:** `FIXED`
- **Evidence:** 3 tracked case(s); 0 cold failures; 0 polyfill failures; 3 fixed.
- **Current surface/gap:** 3 active-registration failure(s).
- **Required classification review:** 3 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (3)</summary>

- `spec/operators/ignoreElements-spec.ts:25:ignoreElements > should allow unsubscribing early and explicitly`
- `spec/operators/ignoreElements-spec.ts:39:ignoreElements > should allow unsubscribing early and explicitly with higher order`
- `spec/operators/ignoreElements-spec.ts:79:ignoreElements > should handle never`

</details>

### RX7-INTERVAL — `interval`

- **Packet status:** `FIXED`
- **Evidence:** 3 tracked case(s); 0 cold failures; 0 polyfill failures; 3 fixed.
- **Current surface/gap:** 3 active-registration failure(s).
- **Required classification review:** 3 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (3)</summary>

- `spec/observables/interval-spec.ts:17:interval > should set up an interval`
- `spec/observables/interval-spec.ts:32:interval > should emit when relative interval set to zero`
- `spec/observables/interval-spec.ts:42:interval > should consider negative interval as zero`

</details>

### RX7-NOTIFICATION — `Notification`

- **Packet status:** `FIXED`
- **Evidence:** 3 tracked case(s); 0 cold failures; 0 polyfill failures; 3 fixed.
- **Current surface/gap:** 3 active-registration failure(s).
- **Required classification review:** 3 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (3)</summary>

- `spec/Notification-spec.ts:57:Notification > toObservable > should create observable from a next Notification`
- `spec/Notification-spec.ts:65:Notification > toObservable > should create observable from a complete Notification`
- `spec/Notification-spec.ts:72:Notification > toObservable > should create observable from a error Notification`

</details>

### RX7-RANGE — `range`

- **Packet status:** `FIXED`
- **Evidence:** 3 tracked case(s); 0 cold failures; 0 polyfill failures; 3 fixed.
- **Current surface/gap:** 3 active-registration failure(s).
- **Required classification review:** 3 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (3)</summary>

- `spec/observables/range-spec.ts:101:range > should accept only one argument where count is argument and start is zero`
- `spec/observables/range-spec.ts:17:range > should create an observable with numbers 1 to 10`
- `spec/observables/range-spec.ts:49:range > should work for two subscribers`

</details>

### RX7-ANIMATION-FRAMES — `animationFrames`

- **Packet status:** `FIXED`
- **Evidence:** 4 tracked case(s); 0 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 4 active-registration failure(s).
- **Required classification review:** 2 portable; 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/observables/dom/animationFrames-spec.ts:17:animationFrames > should animate`
- `spec/observables/dom/animationFrames-spec.ts:37:animationFrames > should use any passed timestampProvider`
- `spec/observables/dom/animationFrames-spec.ts:60:animationFrames > should compose with take`
- `spec/observables/dom/animationFrames-spec.ts:86:animationFrames > should compose with takeUntil`

</details>

### RX7-MERGE-WITH — `mergeWith`

- **Packet status:** `FIXED`
- **Evidence:** 4 tracked case(s); 0 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 4 active-registration failure(s).
- **Required classification review:** 4 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/operators/mergeWith-spec.ts:131:merge operator > should allow unsubscribing explicitly and early`
- `spec/operators/mergeWith-spec.ts:148:merge operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/mergeWith-spec.ts:202:merge operator > should merge never and empty`
- `spec/operators/mergeWith-spec.ts:217:merge operator > should merge never and never`

</details>

### RX7-RACE-WITH — `raceWith`

- **Packet status:** `FIXED`
- **Evidence:** 4 tracked case(s); 0 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 4 active-registration failure(s).
- **Required classification review:** 4 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/operators/raceWith-spec.ts:113:raceWith operator > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/raceWith-spec.ts:134:raceWith operator > should never emit when given non emitting sources`
- `spec/operators/raceWith-spec.ts:80:raceWith operator > should race emit and complete`
- `spec/operators/raceWith-spec.ts:96:raceWith operator > should allow unsubscribing early and explicitly`

</details>

### RX7-SUBJECT — `Subject`

- **Packet status:** `FIXED`
- **Evidence:** 4 tracked case(s); 0 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 4 active-registration failure(s).
- **Required classification review:** 4 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/Subject-spec.ts:608:Subject > asObservable > should handle subject never emits`
- `spec/Subject-spec.ts:616:Subject > asObservable > should handle subject completes without emits`
- `spec/Subject-spec.ts:625:Subject > asObservable > should handle subject throws`
- `spec/Subject-spec.ts:634:Subject > asObservable > should handle subject emits`

</details>

### RX7-SWITCH-ALL — `switchAll`

- **Packet status:** `FIXED`
- **Evidence:** 4 tracked case(s); 0 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 4 active-registration failure(s).
- **Required classification review:** 4 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/operators/switchAll-spec.ts:104:switchAll > should handle a hot observable of observables, outer is unsubscribed early`
- `spec/operators/switchAll-spec.ts:122:switchAll > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/switchAll-spec.ts:144:switchAll > should handle a hot observable of observables, inner never completes`
- `spec/operators/switchAll-spec.ts:225:switchAll > should handle a never hot observable`

</details>

### RX7-MERGE-ALL — `mergeAll`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/mergeAll-spec.ts:151:mergeAll > should handle merging a hot observable of observables, outer unsubscribed early`
- `spec/operators/mergeAll-spec.ts:169:mergeAll > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/mergeAll-spec.ts:247:mergeAll > should merge never and empty`
- `spec/operators/mergeAll-spec.ts:264:mergeAll > should merge never and never`
- `spec/operators/mergeAll-spec.ts:360:mergeAll > should take a never source and return never too`

</details>

### RX7-RACE-LEGACY — `race-legacy`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/race-legacy-spec.ts:112:race operator > should allow unsubscribing early and explicitly`
- `spec/operators/race-legacy-spec.ts:129:race operator > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/race-legacy-spec.ts:150:race operator > should never emit when given non emitting sources`
- `spec/operators/race-legacy-spec.ts:32:race operator > should race cold and cold and accept an Array of Observable argument`
- `spec/operators/race-legacy-spec.ts:96:race operator > should race emit and complete`

</details>

### RX7-REPLAY-SUBJECT — `ReplaySubject`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/subjects/ReplaySubject-spec.ts:117:ReplaySubject > with bufferSize=2 > should replay 2 previous values when subscribed`
- `spec/subjects/ReplaySubject-spec.ts:149:ReplaySubject > with bufferSize=2 > should replay 2 last values for when subscribed after completed`
- `spec/subjects/ReplaySubject-spec.ts:247:ReplaySubject > with windowTime=4 > should replay previous values since 4 time units ago when subscribed`
- `spec/subjects/ReplaySubject-spec.ts:279:ReplaySubject > with windowTime=4 > should replay last values since 4 time units ago when subscribed`
- `spec/subjects/ReplaySubject-spec.ts:303:ReplaySubject > with windowTime=4 > should only replay bufferSize items when 4 time units ago more were emitted`

</details>

### RX7-SCAN — `scan`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/scan-spec.ts:171:scan > handle never`
- `spec/operators/scan-spec.ts:197:scan > should allow unsubscribing explicitly and early`
- `spec/operators/scan-spec.ts:219:scan > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/scan-spec.ts:245:scan > should pass current index to accumulator`
- `spec/operators/scan-spec.ts:91:scan > should scan without seed`

</details>

### RX7-SKIP-LAST — `skipLast`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/skipLast-spec.ts:158:skipLast operator > should allow unsubscribing explicitly and early`
- `spec/operators/skipLast-spec.ts:181:skipLast operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/skipLast-spec.ts:59:skipLast operator > should not skip any values`
- `spec/operators/skipLast-spec.ts:70:skipLast operator > should not skip any values if provided with negative value`
- `spec/operators/skipLast-spec.ts:92:skipLast operator > should go on forever on never`

</details>

### RX7-SKIP-WHILE — `skipWhile`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/skipWhile-spec.ts:122:skipWhile > should skip using index with source unsubscribes early`
- `spec/operators/skipWhile-spec.ts:140:skipWhile > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/skipWhile-spec.ts:183:skipWhile > should invoke predicate while its false and never again`
- `spec/operators/skipWhile-spec.ts:243:skipWhile > should handle Observable.never`
- `spec/operators/skipWhile-spec.ts:88:skipWhile > should skip elements on hot source`

</details>

### RX7-SWITCH-MAP-TO — `switchMapTo`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 5 active-registration failure(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/switchMapTo-spec.ts:140:switchMapTo > should switch to an inner cold observable, outer is unsubscribed early`
- `spec/operators/switchMapTo-spec.ts:159:switchMapTo > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/switchMapTo-spec.ts:184:switchMapTo > should switch to an inner cold observable, inner never completes`
- `spec/operators/switchMapTo-spec.ts:270:switchMapTo > should switch to an inner never`
- `spec/operators/switchMapTo-spec.ts:313:switchMapTo > should handle a never outer`

</details>

### RX7-TAP — `tap`

- **Packet status:** `FIXED`
- **Evidence:** 5 tracked case(s); 0 cold failures; 0 polyfill failures; 5 fixed.
- **Current surface/gap:** 4 active-registration failure(s); 1 duplicate registration(s).
- **Required classification review:** 5 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/tap-spec.ts:15:tap > should mirror multiple values and complete`
- `spec/operators/tap-spec.ts:223:tap > should allow unsubscribing explicitly and early`
- `spec/operators/tap-spec.ts:240:tap > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/tap-spec.ts:260:tap > should mirror multiple values and complete`
- `spec/operators/tap-spec.ts:276:tap > should mirror multiple values and terminate with error`

</details>

### RX7-TO-ARRAY — `toArray`

- **Packet status:** `TODO`
- **Evidence:** 5 tracked case(s); 1 cold failures; 0 polyfill failures; 4 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 4 active-registration failure(s).
- **Required classification review:** 4 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (5)</summary>

- `spec/operators/toArray-spec.ts:105:toArray > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/toArray-spec.ts:25:toArray > should be never when source is never`
- `spec/operators/toArray-spec.ts:47:toArray > should be never when source doesn't complete`
- `spec/operators/toArray-spec.ts:80:toArray > should allow multiple subscriptions`
- `spec/operators/toArray-spec.ts:93:toArray > should allow unsubscribing explicitly and early`

</details>

### RX7-BUFFER-COUNT — `bufferCount`

- **Packet status:** `FIXED`
- **Evidence:** 6 tracked case(s); 0 cold failures; 0 polyfill failures; 6 fixed.
- **Current surface/gap:** 6 active-registration failure(s).
- **Required classification review:** 6 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (6)</summary>

- `spec/operators/bufferCount-spec.ts:102:bufferCount operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/bufferCount-spec.ts:124:bufferCount operator > should raise error if source raise error before reaching specified buffer count`
- `spec/operators/bufferCount-spec.ts:135:bufferCount operator > should emit buffers with specified skip count when skip count is less than window count`
- `spec/operators/bufferCount-spec.ts:15:bufferCount operator > should emit buffers at intervals`
- `spec/operators/bufferCount-spec.ts:153:bufferCount operator > should emit buffers with specified skip count when skip count is more than window count`
- `spec/operators/bufferCount-spec.ts:86:bufferCount operator > should emit buffers at intervals, but stop when result is unsubscribed early`

</details>

### RX7-BUFFER-WHEN — `bufferWhen`

- **Packet status:** `FIXED`
- **Evidence:** 6 tracked case(s); 0 cold failures; 0 polyfill failures; 6 fixed.
- **Current surface/gap:** 6 active-registration failure(s).
- **Required classification review:** 6 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (6)</summary>

- `spec/operators/bufferWhen-spec.ts:121:bufferWhen operator > should emit buffers using varying cold closings, outer unsubscribed early`
- `spec/operators/bufferWhen-spec.ts:151:bufferWhen operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/bufferWhen-spec.ts:266:bufferWhen operator > should handle errors`
- `spec/operators/bufferWhen-spec.ts:305:bufferWhen operator > should handle throw`
- `spec/operators/bufferWhen-spec.ts:322:bufferWhen operator > should handle never`
- `spec/operators/bufferWhen-spec.ts:409:bufferWhen operator > should handle disposing of source`

</details>

### RX7-TAKE-LAST — `takeLast`

- **Packet status:** `FIXED`
- **Evidence:** 6 tracked case(s); 0 cold failures; 0 polyfill failures; 6 fixed.
- **Current surface/gap:** 6 active-registration failure(s).
- **Required classification review:** 6 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (6)</summary>

- `spec/operators/takeLast-spec.ts:102:takeLast operator > should be empty on takeLast(0)`
- `spec/operators/takeLast-spec.ts:168:takeLast operator > should allow unsubscribing explicitly and early`
- `spec/operators/takeLast-spec.ts:191:takeLast operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/takeLast-spec.ts:58:takeLast operator > should not take any values`
- `spec/operators/takeLast-spec.ts:69:takeLast operator > should not take any values if provided with negative value`
- `spec/operators/takeLast-spec.ts:91:takeLast operator > should go on forever on never`

</details>

### RX7-DEBOUNCE-TIME — `debounceTime`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/debounceTime-spec.ts:102:debounceTime > should allow unsubscribing early and explicitly`
- `spec/operators/debounceTime-spec.ts:117:debounceTime > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/debounceTime-spec.ts:136:debounceTime > should debounce and does not complete when source does not completes`
- `spec/operators/debounceTime-spec.ts:148:debounceTime > should not completes when source does not completes`
- `spec/operators/debounceTime-spec.ts:160:debounceTime > should not completes when source never completes`
- `spec/operators/debounceTime-spec.ts:184:debounceTime > should debounce all elements while source emits within given time`
- `spec/operators/debounceTime-spec.ts:30:debounceTime > should delay all elements by the specified time`

</details>

### RX7-ELEMENT-AT — `elementAt`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/elementAt-spec.ts:103:elementAt > should allow unsubscribing early and explicitly`
- `spec/operators/elementAt-spec.ts:117:elementAt > should not break unsubscription chains when result Observable is unsubscribed`
- `spec/operators/elementAt-spec.ts:141:elementAt > should raise error if index is out of range but does not have default value`
- `spec/operators/elementAt-spec.ts:152:elementAt > should return default value if index is out of range`
- `spec/operators/elementAt-spec.ts:37:elementAt > should allow undefined as a default value`
- `spec/operators/elementAt-spec.ts:70:elementAt > should raise error if e1 is Empty Observable`
- `spec/operators/elementAt-spec.ts:92:elementAt > should not complete if source never completes`

</details>

### RX7-FINALIZE — `finalize`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/finalize-spec.ts:116:finalize > should handle throw`
- `spec/operators/finalize-spec.ts:135:finalize > should handle basic hot observable`
- `spec/operators/finalize-spec.ts:154:finalize > should handle basic cold observable`
- `spec/operators/finalize-spec.ts:173:finalize > should handle basic error`
- `spec/operators/finalize-spec.ts:192:finalize > should handle unsubscription`
- `spec/operators/finalize-spec.ts:78:finalize > should handle empty`
- `spec/operators/finalize-spec.ts:97:finalize > should handle never`

</details>

### RX7-IS-EMPTY — `isEmpty`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/isEmpty-spec.ts:14:isEmpty > should return true if source is empty`
- `spec/operators/isEmpty-spec.ts:25:isEmpty > should return false if source emits element`
- `spec/operators/isEmpty-spec.ts:36:isEmpty > should raise error if source raises error`
- `spec/operators/isEmpty-spec.ts:47:isEmpty > should not complete if source never emits`
- `spec/operators/isEmpty-spec.ts:58:isEmpty > should return true if source is empty`
- `spec/operators/isEmpty-spec.ts:69:isEmpty > should allow unsubscribing explicitly and early`
- `spec/operators/isEmpty-spec.ts:81:isEmpty > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-OBSERVABLE — `Observable`

- **Packet status:** `TODO`
- **Evidence:** 7 tracked case(s); 1 cold failures; 0 polyfill failures; 6 fixed.
- **Current surface/gap:** 2 known mapped mismatch(es); 5 active-registration failure(s).
- **Required classification review:** 1 harness rewrite; 6 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/Observable-spec.ts:1330:Observable.lift > should compose through combineLatest`
- `spec/Observable-spec.ts:1353:Observable.lift > should compose through concat`
- `spec/Observable-spec.ts:1366:Observable.lift > should compose through merge`
- `spec/Observable-spec.ts:1380:Observable.lift > should compose through race`
- `spec/Observable-spec.ts:1400:Observable.lift > should compose through zip`
- `spec/Observable-spec.ts:50:Observable > should allow empty ctor, which is effectively a never-observable`
- `spec/Observable-spec.ts:903:Observable > should handle sync errors within a test scheduler`

</details>

### RX7-OBSERVE-ON — `observeOn`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/observeOn-spec.ts:15:observeOn > should observe on specified scheduler`
- `spec/operators/observeOn-spec.ts:26:observeOn > should observe after specified delay`
- `spec/operators/observeOn-spec.ts:40:observeOn > should observe when source raises error`
- `spec/operators/observeOn-spec.ts:51:observeOn > should observe when source is empty`
- `spec/operators/observeOn-spec.ts:62:observeOn > should observe when source does not complete`
- `spec/operators/observeOn-spec.ts:73:observeOn > should allow unsubscribing early and explicitly`
- `spec/operators/observeOn-spec.ts:87:observeOn > should not break unsubscription chains when the result is unsubscribed explicitly`

</details>

### RX7-PAIRWISE — `pairwise`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/pairwise-spec.ts:102:pairwise operator > should handle throw`
- `spec/operators/pairwise-spec.ts:15:pairwise operator > should group consecutive emissions as arrays of two`
- `spec/operators/pairwise-spec.ts:33:pairwise operator > should pairwise things`
- `spec/operators/pairwise-spec.ts:52:pairwise operator > should not emit on single-element streams`
- `spec/operators/pairwise-spec.ts:63:pairwise operator > should handle mid-stream throw`
- `spec/operators/pairwise-spec.ts:80:pairwise operator > should handle empty`
- `spec/operators/pairwise-spec.ts:91:pairwise operator > should handle never`

</details>

### RX7-RACE — `race`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/observables/race-spec.ts:109:race > should race emit and complete`
- `spec/observables/race-spec.ts:125:race > should allow unsubscribing early and explicitly`
- `spec/observables/race-spec.ts:142:race > should not break unsubscription chains when unsubscribed explicitly`
- `spec/observables/race-spec.ts:161:race > should never emit when given non emitting sources`
- `spec/observables/race-spec.ts:207:race > handle empty`
- `spec/observables/race-spec.ts:220:race > handle never`
- `spec/observables/race-spec.ts:45:race > should race with array of observable`

</details>

### RX7-THROW-IF-EMPTY — `throwIfEmpty`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/throwIfEmpty-spec.ts:156:throwIfEmpty > without errorFactory > should pass values through`
- `spec/operators/throwIfEmpty-spec.ts:16:throwIfEmpty > with errorFactory > should error when empty`
- `spec/operators/throwIfEmpty-spec.ts:169:throwIfEmpty > without errorFactory > should never when never`
- `spec/operators/throwIfEmpty-spec.ts:182:throwIfEmpty > without errorFactory > should error when empty`
- `spec/operators/throwIfEmpty-spec.ts:55:throwIfEmpty > with errorFactory > should pass values through`
- `spec/operators/throwIfEmpty-spec.ts:68:throwIfEmpty > with errorFactory > should never when never`
- `spec/operators/throwIfEmpty-spec.ts:81:throwIfEmpty > with errorFactory > should error when empty`

</details>

### RX7-ZIP-LEGACY — `zip-legacy`

- **Packet status:** `FIXED`
- **Evidence:** 7 tracked case(s); 0 cold failures; 0 polyfill failures; 7 fixed.
- **Current surface/gap:** 7 active-registration failure(s).
- **Required classification review:** 7 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/zip-legacy-spec.ts:113:zip legacy > should work with n-ary symmetric selector`
- `spec/operators/zip-legacy-spec.ts:133:zip legacy > should work with n-ary symmetric array selector`
- `spec/operators/zip-legacy-spec.ts:153:zip legacy > should combine two observables and selector`
- `spec/operators/zip-legacy-spec.ts:31:zip legacy > should work with selector throws`
- `spec/operators/zip-legacy-spec.ts:53:zip legacy > should work with some data asymmetric 1`
- `spec/operators/zip-legacy-spec.ts:73:zip legacy > should work with some data asymmetric 2`
- `spec/operators/zip-legacy-spec.ts:93:zip legacy > should work with some data symmetric`

</details>

### RX7-CONCAT-MAP-TO — `concatMapTo`

- **Packet status:** `FIXED`
- **Evidence:** 8 tracked case(s); 0 cold failures; 0 polyfill failures; 8 fixed.
- **Current surface/gap:** 8 active-registration failure(s).
- **Required classification review:** 8 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (8)</summary>

- `spec/operators/concatMapTo-spec.ts:114:concatMapTo > should handle a never source`
- `spec/operators/concatMapTo-spec.ts:167:concatMapTo > should return a never if the mapped inner is never`
- `spec/operators/concatMapTo-spec.ts:221:concatMapTo > should concatMapTo many outer to many inner, outer never completes`
- `spec/operators/concatMapTo-spec.ts:243:concatMapTo > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/concatMapTo-spec.ts:269:concatMapTo > should concatMapTo many outer to many inner, inner never completes`
- `spec/operators/concatMapTo-spec.ts:341:concatMapTo > should concatMapTo many outer to an array`
- `spec/operators/concatMapTo-spec.ts:352:concatMapTo > should concatMapTo many outer to inner arrays, and outer throws`
- `spec/operators/concatMapTo-spec.ts:363:concatMapTo > should concatMapTo many outer to inner arrays, outer unsubscribed early`

</details>

### RX7-SUBSCRIBE-ON — `subscribeOn`

- **Packet status:** `FIXED`
- **Evidence:** 8 tracked case(s); 0 cold failures; 0 polyfill failures; 8 fixed.
- **Current surface/gap:** 8 active-registration failure(s).
- **Required classification review:** 8 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (8)</summary>

- `spec/operators/subscribeOn-spec.ts:113:subscribeOn > should properly support a delayTime of Infinity`
- `spec/operators/subscribeOn-spec.ts:15:subscribeOn > should subscribe on specified scheduler`
- `spec/operators/subscribeOn-spec.ts:28:subscribeOn > should start subscribe after specified delay`
- `spec/operators/subscribeOn-spec.ts:42:subscribeOn > should unsubscribe when source raises error`
- `spec/operators/subscribeOn-spec.ts:55:subscribeOn > should subscribe when source is empty`
- `spec/operators/subscribeOn-spec.ts:68:subscribeOn > should subscribe when source does not complete`
- `spec/operators/subscribeOn-spec.ts:81:subscribeOn > should allow unsubscribing early and explicitly`
- `spec/operators/subscribeOn-spec.ts:95:subscribeOn > should not break unsubscription chains when the result is unsubscribed explicitly`

</details>

### RX7-MATERIALIZE — `materialize`

- **Packet status:** `FIXED`
- **Evidence:** 9 tracked case(s); 0 cold failures; 0 polyfill failures; 9 fixed.
- **Current surface/gap:** 9 active-registration failure(s).
- **Required classification review:** 9 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (9)</summary>

- `spec/operators/materialize-spec.ts:114:materialize > should materialize stream that does not complete`
- `spec/operators/materialize-spec.ts:125:materialize > should materialize stream that does not emit`
- `spec/operators/materialize-spec.ts:136:materialize > should materialize empty stream`
- `spec/operators/materialize-spec.ts:147:materialize > should materialize stream that throws`
- `spec/operators/materialize-spec.ts:15:materialize > should materialize an Observable`
- `spec/operators/materialize-spec.ts:38:materialize > should materialize a happy stream`
- `spec/operators/materialize-spec.ts:56:materialize > should materialize a sad stream`
- `spec/operators/materialize-spec.ts:74:materialize > should allow unsubscribing explicitly and early`
- `spec/operators/materialize-spec.ts:91:materialize > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-TIMER — `timer`

- **Packet status:** `FIXED`
- **Evidence:** 9 tracked case(s); 0 cold failures; 0 polyfill failures; 9 fixed.
- **Current surface/gap:** 9 active-registration failure(s).
- **Required classification review:** 1 portable; 8 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (9)</summary>

- `spec/observables/timer-spec.ts:112:timer > 'should still target the same date if a date is provided even for the ' + 'second subscription'`
- `spec/observables/timer-spec.ts:128:timer > should accept Infinity as the first argument`
- `spec/observables/timer-spec.ts:136:timer > should accept Infinity as the second argument`
- `spec/observables/timer-spec.ts:14:timer > should create an observable emitting periodically`
- `spec/observables/timer-spec.ts:153:timer > should accept 0 as the second argument`
- `spec/observables/timer-spec.ts:51:timer > should start after delay and periodically emit values`
- `spec/observables/timer-spec.ts:63:timer > should start immediately and periodically emit values`
- `spec/observables/timer-spec.ts:75:timer > should stop emitting values when subscription is done`
- `spec/observables/timer-spec.ts:99:timer > should start after delay and periodically emit values`

</details>

### RX7-WINDOW-COUNT — `windowCount`

- **Packet status:** `FIXED`
- **Evidence:** 9 tracked case(s); 0 cold failures; 0 polyfill failures; 9 fixed.
- **Current surface/gap:** 9 active-registration failure(s).
- **Required classification review:** 6 portable; 3 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (9)</summary>

- `spec/operators/windowCount-spec.ts:100:windowCount > should propagate error from a just-throw source`
- `spec/operators/windowCount-spec.ts:115:windowCount > should raise error if source raises error`
- `spec/operators/windowCount-spec.ts:136:windowCount > should dispose of inner windows once outer is unsubscribed early`
- `spec/operators/windowCount-spec.ts:15:windowCount > should emit windows with count 3, no skip specified`
- `spec/operators/windowCount-spec.ts:155:windowCount > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/windowCount-spec.ts:33:windowCount > should emit windows with count 2 and skip 1`
- `spec/operators/windowCount-spec.ts:52:windowCount > should emit windows with count 2, and skip unspecified`
- `spec/operators/windowCount-spec.ts:70:windowCount > should return empty if source is empty`
- `spec/operators/windowCount-spec.ts:85:windowCount > should return Never if source if Never`

</details>

### RX7-AUDIT-TIME — `auditTime`

- **Packet status:** `FIXED`
- **Evidence:** 10 tracked case(s); 0 cold failures; 0 polyfill failures; 10 fixed.
- **Current surface/gap:** 10 active-registration failure(s).
- **Required classification review:** 10 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (10)</summary>

- `spec/operators/auditTime-spec.ts:108:auditTime > should handle an empty source`
- `spec/operators/auditTime-spec.ts:120:auditTime > should handle a never source`
- `spec/operators/auditTime-spec.ts:144:auditTime > should not complete when source does not complete`
- `spec/operators/auditTime-spec.ts:15:auditTime > should emit the last value in each time window`
- `spec/operators/auditTime-spec.ts:158:auditTime > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/auditTime-spec.ts:178:auditTime > should auditTime values until source raises error`
- `spec/operators/auditTime-spec.ts:41:auditTime > should auditTime events multiple times`
- `spec/operators/auditTime-spec.ts:54:auditTime > should delay the source if values are not emitted often enough`
- `spec/operators/auditTime-spec.ts:68:auditTime > should handle a busy producer emitting a regular repeating sequence`
- `spec/operators/auditTime-spec.ts:84:auditTime > should complete when source does not emit`

</details>

### RX7-LAST — `last`

- **Packet status:** `FIXED`
- **Evidence:** 10 tracked case(s); 0 cold failures; 0 polyfill failures; 10 fixed.
- **Current surface/gap:** 10 active-registration failure(s).
- **Required classification review:** 10 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (10)</summary>

- `spec/operators/last-spec.ts:110:last > should return a default value if no element found`
- `spec/operators/last-spec.ts:121:last > should not return default value if an element is found`
- `spec/operators/last-spec.ts:132:last > should raise error when predicate throws`
- `spec/operators/last-spec.ts:25:last > should error on nothing sent but completed`
- `spec/operators/last-spec.ts:36:last > should error on empty`
- `spec/operators/last-spec.ts:47:last > should go on forever on never`
- `spec/operators/last-spec.ts:58:last > should allow undefined as a default value`
- `spec/operators/last-spec.ts:69:last > should return last element matches with predicate`
- `spec/operators/last-spec.ts:80:last > should allow unsubscribing explicitly and early`
- `spec/operators/last-spec.ts:92:last > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-SAMPLE-TIME — `sampleTime`

- **Packet status:** `FIXED`
- **Evidence:** 10 tracked case(s); 0 cold failures; 0 polyfill failures; 10 fixed.
- **Current surface/gap:** 10 active-registration failure(s).
- **Required classification review:** 10 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (10)</summary>

- `spec/operators/sampleTime-spec.ts:113:sampleTime > should completes if source does not emits`
- `spec/operators/sampleTime-spec.ts:125:sampleTime > should raise error if source throws immediately`
- `spec/operators/sampleTime-spec.ts:137:sampleTime > should not complete if source does not complete`
- `spec/operators/sampleTime-spec.ts:14:sampleTime > should get samples on a delay`
- `spec/operators/sampleTime-spec.ts:27:sampleTime > should sample nothing if new value has not arrived`
- `spec/operators/sampleTime-spec.ts:40:sampleTime > should sample if new value has arrived, even if it is the same value`
- `spec/operators/sampleTime-spec.ts:53:sampleTime > should sample nothing if source has not nexted by time of sample`
- `spec/operators/sampleTime-spec.ts:66:sampleTime > should raise error if source raises error`
- `spec/operators/sampleTime-spec.ts:79:sampleTime > should allow unsubscribing explicitly and early`
- `spec/operators/sampleTime-spec.ts:93:sampleTime > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-CONCAT-ALL — `concatAll`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 9 portable; 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/concatAll-spec.ts:130:concatAll operator > should concat all observables in an observable`
- `spec/operators/concatAll-spec.ts:139:concatAll operator > should throw if any child observable throws`
- `spec/operators/concatAll-spec.ts:206:concatAll operator > should not complete if first source does not completes`
- `spec/operators/concatAll-spec.ts:222:concatAll operator > should not complete if second source does not completes`
- `spec/operators/concatAll-spec.ts:238:concatAll operator > should not complete if both sources do not complete`
- `spec/operators/concatAll-spec.ts:334:concatAll operator > should emit element from first source, and should not complete if second source does not completes`
- `spec/operators/concatAll-spec.ts:350:concatAll operator > should not complete if first source does not complete`
- `spec/operators/concatAll-spec.ts:382:concatAll operator > should unsubscribe to inner source if outer is unsubscribed early`
- `spec/operators/concatAll-spec.ts:399:concatAll operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/concatAll-spec.ts:500:concatAll operator > should be able to work on a different scheduler`
- `spec/operators/concatAll-spec.ts:532:concatAll operator > should concatAll a nested observable with a single inner observable, and a scheduler`

</details>

### RX7-CONCAT-MAP — `concatMap`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 11 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/concatMap-spec.ts:145:Observable.prototype.concatMap > should handle a never source`
- `spec/operators/concatMap-spec.ts:15:Observable.prototype.concatMap > should map-and-flatten each item to an Observable`
- `spec/operators/concatMap-spec.ts:210:Observable.prototype.concatMap > should return a never if the mapped inner is never`
- `spec/operators/concatMap-spec.ts:272:Observable.prototype.concatMap > should concatMap many outer to many inner, outer never completes`
- `spec/operators/concatMap-spec.ts:294:Observable.prototype.concatMap > should concatMap many outer to many inner, inner never completes`
- `spec/operators/concatMap-spec.ts:401:Observable.prototype.concatMap > should concatMap many complex, all inners finite except one`
- `spec/operators/concatMap-spec.ts:436:Observable.prototype.concatMap > should concatMap many complex, inners finite, outer does not complete`
- `spec/operators/concatMap-spec.ts:726:Observable.prototype.concatMap > should concatMap many outer to an array for each value`
- `spec/operators/concatMap-spec.ts:739:Observable.prototype.concatMap > should concatMap many outer to inner arrays, outer unsubscribed early`
- `spec/operators/concatMap-spec.ts:753:Observable.prototype.concatMap > should concatMap many outer to inner arrays, project throws`
- `spec/operators/concatMap-spec.ts:81:Observable.prototype.concatMap > should concatenate many regular interval inners`

</details>

### RX7-DEBOUNCE — `debounce`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 11 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/debounce-spec.ts:123:debounce > should allow unsubscribing early and explicitly`
- `spec/operators/debounce-spec.ts:137:debounce > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/debounce-spec.ts:155:debounce > should debounce and does not complete when source does not completes`
- `spec/operators/debounce-spec.ts:166:debounce > should not complete when source does not complete`
- `spec/operators/debounce-spec.ts:177:debounce > should not completes when source never completes`
- `spec/operators/debounce-spec.ts:199:debounce > should debounce all elements while source emits by selector observable`
- `spec/operators/debounce-spec.ts:269:debounce > should debounce by selector observable until source completes`
- `spec/operators/debounce-spec.ts:379:debounce > should ignore all values except last, when given an empty selector Observable`
- `spec/operators/debounce-spec.ts:394:debounce > should ignore all values except last, when given a never selector Observable`
- `spec/operators/debounce-spec.ts:409:debounce > should not delay by selector observable completes when it does not emits`
- `spec/operators/debounce-spec.ts:433:debounce > should not debounce by selector observable completes when it does not emits`

</details>

### RX7-EXHAUST-ALL — `exhaustAll`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 11 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/exhaustAll-spec.ts:102:exhaust > should handle a hot observable of observables, outer is unsubscribed early`
- `spec/operators/exhaustAll-spec.ts:118:exhaust > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/exhaustAll-spec.ts:140:exhaust > should handle a hot observable of observables, inner never completes`
- `spec/operators/exhaustAll-spec.ts:15:exhaust > should handle a hot observable of hot observables`
- `spec/operators/exhaustAll-spec.ts:158:exhaust > should handle a synchronous switch and stay on the first inner observable`
- `spec/operators/exhaustAll-spec.ts:188:exhaust > should handle a hot observable of observables, outer throws`
- `spec/operators/exhaustAll-spec.ts:214:exhaust > should handle a never hot observable`
- `spec/operators/exhaustAll-spec.ts:225:exhaust > should complete not before the outer completes`
- `spec/operators/exhaustAll-spec.ts:35:exhaust > should switch to first immediately-scheduled inner Observable`
- `spec/operators/exhaustAll-spec.ts:71:exhaust > should handle never`
- `spec/operators/exhaustAll-spec.ts:82:exhaust > should handle a hot observable of observables`

</details>

### RX7-TIME-INTERVAL — `timeInterval`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 11 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/timeInterval-spec.ts:108:timeInterval > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/timeInterval-spec.ts:131:timeInterval > should not completes if source never completes`
- `spec/operators/timeInterval-spec.ts:142:timeInterval > raise error if source raises error`
- `spec/operators/timeInterval-spec.ts:153:timeInterval > should record interval then raise error if source raises error after emit`
- `spec/operators/timeInterval-spec.ts:16:timeInterval > should record the time interval between source elements`
- `spec/operators/timeInterval-spec.ts:169:timeInterval > should raise error if source immediately throws`
- `spec/operators/timeInterval-spec.ts:33:timeInterval > should record interval if source emit elements`
- `spec/operators/timeInterval-spec.ts:51:timeInterval > should completes without record interval if source does not emits`
- `spec/operators/timeInterval-spec.ts:62:timeInterval > should complete immediately if source is empty`
- `spec/operators/timeInterval-spec.ts:73:timeInterval > should record interval then does not completes if source emits but not completes`
- `spec/operators/timeInterval-spec.ts:89:timeInterval > should allow unsubscribing explicitly and early`

</details>

### RX7-TIMESTAMP — `timestamp`

- **Packet status:** `FIXED`
- **Evidence:** 11 tracked case(s); 0 cold failures; 0 polyfill failures; 11 fixed.
- **Current surface/gap:** 11 active-registration failure(s).
- **Required classification review:** 11 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/operators/timestamp-spec.ts:107:timestamp > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/timestamp-spec.ts:130:timestamp > should not completes if source never completes`
- `spec/operators/timestamp-spec.ts:141:timestamp > raise error if source raises error`
- `spec/operators/timestamp-spec.ts:15:timestamp > should record the time stamp per each source elements`
- `spec/operators/timestamp-spec.ts:152:timestamp > should record stamp then raise error if source raises error after emit`
- `spec/operators/timestamp-spec.ts:168:timestamp > should raise error if source immediately throws`
- `spec/operators/timestamp-spec.ts:32:timestamp > should record stamp if source emit elements`
- `spec/operators/timestamp-spec.ts:50:timestamp > should completes without record stamp if source does not emits`
- `spec/operators/timestamp-spec.ts:61:timestamp > should complete immediately if source is empty`
- `spec/operators/timestamp-spec.ts:72:timestamp > should record stamp then does not completes if source emits but not completes`
- `spec/operators/timestamp-spec.ts:88:timestamp > should allow unsubscribing explicitly and early`

</details>

### RX7-FIND — `find`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 12 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/find-spec.ts:107:find > should return undefined if element does not match with predicate`
- `spec/operators/find-spec.ts:122:find > should allow unsubscribing early and explicitly`
- `spec/operators/find-spec.ts:136:find > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/find-spec.ts:154:find > should unsubscribe when the predicate is matched`
- `spec/operators/find-spec.ts:172:find > should raise if source raise error while element does not match with predicate`
- `spec/operators/find-spec.ts:187:find > should raise error if predicate throws error`
- `spec/operators/find-spec.ts:19:find > should return matching element from source emits single element`
- `spec/operators/find-spec.ts:35:find > should not emit if source does not emit`
- `spec/operators/find-spec.ts:46:find > should return undefined if source is empty to match predicate`
- `spec/operators/find-spec.ts:59:find > should return matching element from source emits single element`
- `spec/operators/find-spec.ts:74:find > should return matching element from source emits multiple elements`
- `spec/operators/find-spec.ts:89:find > should work with a custom thisArg`

</details>

### RX7-FIND-INDEX — `findIndex`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 12 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/findIndex-spec.ts:106:findIndex > should return negative index if element does not match with predicate`
- `spec/operators/findIndex-spec.ts:121:findIndex > should allow unsubscribing early and explicitly`
- `spec/operators/findIndex-spec.ts:135:findIndex > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/findIndex-spec.ts:153:findIndex > should unsubscribe when the predicate is matched`
- `spec/operators/findIndex-spec.ts:171:findIndex > should raise if source raise error while element does not match with predicate`
- `spec/operators/findIndex-spec.ts:186:findIndex > should raise error if predicate throws error`
- `spec/operators/findIndex-spec.ts:19:findIndex > should return matching element from source emits single element`
- `spec/operators/findIndex-spec.ts:35:findIndex > should not emit if source does not emit`
- `spec/operators/findIndex-spec.ts:46:findIndex > should return negative index if source is empty to match predicate`
- `spec/operators/findIndex-spec.ts:59:findIndex > should return index of element from source emits single element`
- `spec/operators/findIndex-spec.ts:74:findIndex > should return index of matching element from source emits multiple elements`
- `spec/operators/findIndex-spec.ts:89:findIndex > should work with a custom thisArg`

</details>

### RX7-SEQUENCE-EQUAL — `sequenceEqual`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 11 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/sequenceEqual-spec.ts:129:sequenceEqual > should never return if source is a never`
- `spec/operators/sequenceEqual-spec.ts:141:sequenceEqual > should never return if compareTo is a never`
- `spec/operators/sequenceEqual-spec.ts:153:sequenceEqual > should return false if source is empty and compareTo is not`
- `spec/operators/sequenceEqual-spec.ts:169:sequenceEqual > should return false if compareTo is empty and source is not`
- `spec/operators/sequenceEqual-spec.ts:185:sequenceEqual > should return never if compareTo is empty and source is never`
- `spec/operators/sequenceEqual-spec.ts:197:sequenceEqual > should return never if source is empty and compareTo is never`
- `spec/operators/sequenceEqual-spec.ts:209:sequenceEqual > should error if the comparator function errors`
- `spec/operators/sequenceEqual-spec.ts:243:sequenceEqual > should use the provided comparator function`
- `spec/operators/sequenceEqual-spec.ts:301:sequenceEqual > should return false when the source emits an extra value after the compareTo completes`
- `spec/operators/sequenceEqual-spec.ts:317:sequenceEqual > should return false when the compareTo emits an extra value after the source completes`
- `spec/operators/sequenceEqual-spec.ts:344:sequenceEqual > should return false for an empty observable and an observable that emits`
- `spec/operators/sequenceEqual-spec.ts:355:sequenceEqual > should return compare hot and cold observables`

</details>

### RX7-TAKE-WHILE — `takeWhile`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 12 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/takeWhile-spec.ts:101:takeWhile > should take all elements up to and including the element that made the predicate return false`
- `spec/operators/takeWhile-spec.ts:119:takeWhile > should take elements with predicate when source does not complete`
- `spec/operators/takeWhile-spec.ts:132:takeWhile > should not complete when source never completes`
- `spec/operators/takeWhile-spec.ts:145:takeWhile > should complete when source does not emit`
- `spec/operators/takeWhile-spec.ts:158:takeWhile > should complete when source is empty`
- `spec/operators/takeWhile-spec.ts:188:takeWhile > should raise error when source raises error`
- `spec/operators/takeWhile-spec.ts:201:takeWhile > should raise error when source throws`
- `spec/operators/takeWhile-spec.ts:214:takeWhile > should invoke predicate until return false`
- `spec/operators/takeWhile-spec.ts:256:takeWhile > should take elements until unsubscribed`
- `spec/operators/takeWhile-spec.ts:274:takeWhile > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/takeWhile-spec.ts:28:takeWhile > should take all elements with predicate returns true`
- `spec/operators/takeWhile-spec.ts:41:takeWhile > should take all elements with truthy predicate`

</details>

### RX7-THROTTLE-TIME — `throttleTime`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 12 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/throttleTime-spec.ts:105:throttleTime operator > default behavior { leading: true, trailing: false } > should handle an empty source`
- `spec/operators/throttleTime-spec.ts:116:throttleTime operator > default behavior { leading: true, trailing: false } > should handle a never source`
- `spec/operators/throttleTime-spec.ts:138:throttleTime operator > default behavior { leading: true, trailing: false } > should throttle and does not complete when source does not completes`
- `spec/operators/throttleTime-spec.ts:150:throttleTime operator > default behavior { leading: true, trailing: false } > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/throttleTime-spec.ts:16:throttleTime operator > default behavior { leading: true, trailing: false } > should immediately emit the first value in each time window`
- `spec/operators/throttleTime-spec.ts:196:throttleTime operator > throttleTime(fn, { leading: true, trailing: true }) > should emit the value if only a single one is given`
- `spec/operators/throttleTime-spec.ts:210:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should immediately emit the last value in each time window`
- `spec/operators/throttleTime-spec.ts:225:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should emit the last throttled value when complete`
- `spec/operators/throttleTime-spec.ts:240:throttleTime operator > throttleTime(fn, { leading: false, trailing: true }) > should emit the value if only a single one is given`
- `spec/operators/throttleTime-spec.ts:61:throttleTime operator > default behavior { leading: true, trailing: false } > should simply mirror the source if values are not emitted often enough`
- `spec/operators/throttleTime-spec.ts:72:throttleTime operator > default behavior { leading: true, trailing: false } > should handle a busy producer emitting a regular repeating sequence`
- `spec/operators/throttleTime-spec.ts:83:throttleTime operator > default behavior { leading: true, trailing: false } > should complete when source does not emit`

</details>

### RX7-WITH-LATEST-FROM — `withLatestFrom`

- **Packet status:** `FIXED`
- **Evidence:** 12 tracked case(s); 0 cold failures; 0 polyfill failures; 12 fixed.
- **Current surface/gap:** 12 active-registration failure(s).
- **Required classification review:** 12 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (12)</summary>

- `spec/operators/withLatestFrom-spec.ts:107:withLatestFrom > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/withLatestFrom-spec.ts:137:withLatestFrom > should handle empty`
- `spec/operators/withLatestFrom-spec.ts:156:withLatestFrom > should handle never`
- `spec/operators/withLatestFrom-spec.ts:16:withLatestFrom > should combine events from cold observables`
- `spec/operators/withLatestFrom-spec.ts:175:withLatestFrom > should handle throw`
- `spec/operators/withLatestFrom-spec.ts:194:withLatestFrom > should handle error`
- `spec/operators/withLatestFrom-spec.ts:216:withLatestFrom > should handle error with project argument`
- `spec/operators/withLatestFrom-spec.ts:239:withLatestFrom > should handle merging with empty`
- `spec/operators/withLatestFrom-spec.ts:258:withLatestFrom > should handle merging with never`
- `spec/operators/withLatestFrom-spec.ts:32:withLatestFrom > should merge the value with the latest values from the other observables into arrays`
- `spec/operators/withLatestFrom-spec.ts:56:withLatestFrom > should merge the value with the latest values from the other observables into arrays and a project argument`
- `spec/operators/withLatestFrom-spec.ts:81:withLatestFrom > should allow unsubscribing early and explicitly`

</details>

### RX7-DEMATERIALIZE — `dematerialize`

- **Packet status:** `FIXED`
- **Evidence:** 13 tracked case(s); 0 cold failures; 0 polyfill failures; 13 fixed.
- **Current surface/gap:** 13 active-registration failure(s).
- **Required classification review:** 13 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (13)</summary>

- `spec/operators/dematerialize-spec.ts:102:dematerialize > should dematerialize stream does not emit`
- `spec/operators/dematerialize-spec.ts:113:dematerialize > should dematerialize empty stream`
- `spec/operators/dematerialize-spec.ts:124:dematerialize > should dematerialize stream throws`
- `spec/operators/dematerialize-spec.ts:136:dematerialize > should allow unsubscribing early and explicitly`
- `spec/operators/dematerialize-spec.ts:15:dematerialize > should dematerialize an Observable`
- `spec/operators/dematerialize-spec.ts:155:dematerialize > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/dematerialize-spec.ts:178:dematerialize > should dematerialize and completes when stream completes with complete notification`
- `spec/operators/dematerialize-spec.ts:189:dematerialize > should dematerialize and completes when stream emits complete notification`
- `spec/operators/dematerialize-spec.ts:200:dematerialize > should work with materialize`
- `spec/operators/dematerialize-spec.ts:44:dematerialize > should dematerialize a happy stream`
- `spec/operators/dematerialize-spec.ts:62:dematerialize > should dematerialize a sad stream`
- `spec/operators/dematerialize-spec.ts:80:dematerialize > should dematerialize stream does not completes`
- `spec/operators/dematerialize-spec.ts:91:dematerialize > should dematerialize stream never completes`

</details>

### RX7-EXPAND — `expand`

- **Packet status:** `FIXED`
- **Evidence:** 13 tracked case(s); 0 cold failures; 0 polyfill failures; 13 fixed.
- **Current surface/gap:** 13 active-registration failure(s).
- **Required classification review:** 12 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (13)</summary>

- `spec/operators/expand-spec.ts:120:expand > should map and recursively flatten, and propagate error thrown from projection`
- `spec/operators/expand-spec.ts:148:expand > should allow unsubscribing early`
- `spec/operators/expand-spec.ts:15:expand > should recursively map-and-flatten each item to an Observable`
- `spec/operators/expand-spec.ts:177:expand > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/expand-spec.ts:208:expand > should allow concurrent expansions`
- `spec/operators/expand-spec.ts:236:expand > should allow configuring the concurrency limit parameter to 1`
- `spec/operators/expand-spec.ts:278:expand > should allow configuring the concurrency limit parameter to 2`
- `spec/operators/expand-spec.ts:315:expand > should ignore concurrency limit if it is not passed`
- `spec/operators/expand-spec.ts:32:expand > should work with scheduler`
- `spec/operators/expand-spec.ts:349:expand > should map and recursively flatten with scalars`
- `spec/operators/expand-spec.ts:451:expand > should work when passing undefined for the optional arguments`
- `spec/operators/expand-spec.ts:49:expand > should map and recursively flatten`
- `spec/operators/expand-spec.ts:92:expand > should map and recursively flatten, and handle event raised error`

</details>

### RX7-GENERATE — `generate`

- **Packet status:** `FIXED`
- **Evidence:** 13 tracked case(s); 0 cold failures; 0 polyfill failures; 13 fixed.
- **Current surface/gap:** 13 active-registration failure(s).
- **Required classification review:** 9 portable; 4 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (13)</summary>

- `spec/observables/generate-spec.ts:103:generate > should accept a scheduler`
- `spec/observables/generate-spec.ts:125:generate > should allow minimal possible options`
- `spec/observables/generate-spec.ts:137:generate > should emit error if result selector throws`
- `spec/observables/generate-spec.ts:150:generate > should emit error if result selector throws on scheduler`
- `spec/observables/generate-spec.ts:164:generate > should emit error after first value if iterate function throws`
- `spec/observables/generate-spec.ts:176:generate > should emit error after first value if iterate function throws on scheduler`
- `spec/observables/generate-spec.ts:189:generate > should emit error if condition function throws`
- `spec/observables/generate-spec.ts:20:generate > should complete if condition does not meet`
- `spec/observables/generate-spec.ts:202:generate > should emit error if condition function throws on scheduler`
- `spec/observables/generate-spec.ts:33:generate > should produce first value immediately`
- `spec/observables/generate-spec.ts:46:generate > should produce all values synchronously`
- `spec/observables/generate-spec.ts:59:generate > should use result selector`
- `spec/observables/generate-spec.ts:73:generate > should allow omit condition`

</details>

### RX7-PUBLISH-LAST — `publishLast`

- **Packet status:** `FIXED`
- **Evidence:** 13 tracked case(s); 0 cold failures; 0 polyfill failures; 13 fixed.
- **Current surface/gap:** 13 active-registration failure(s).
- **Required classification review:** 3 portable; 10 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (13)</summary>

- `spec/operators/publishLast-spec.ts:123:publishLast operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/publishLast-spec.ts:15:publishLast operator > should emit last notification of a simple source Observable`
- `spec/operators/publishLast-spec.ts:159:publishLast operator > with refCount() > should connect when first subscriber subscribes`
- `spec/operators/publishLast-spec.ts:178:publishLast operator > with refCount() > should disconnect when last subscriber unsubscribes`
- `spec/operators/publishLast-spec.ts:196:publishLast operator > with refCount() > should NOT be retryable`
- `spec/operators/publishLast-spec.ts:216:publishLast operator > should multicast an empty source`
- `spec/operators/publishLast-spec.ts:230:publishLast operator > should multicast a never source`
- `spec/operators/publishLast-spec.ts:244:publishLast operator > should multicast a throw source`
- `spec/operators/publishLast-spec.ts:293:publishLast operator > should be referentially-transparent`
- `spec/operators/publishLast-spec.ts:37:publishLast operator > should do nothing if connect is not called, despite subscriptions`
- `spec/operators/publishLast-spec.ts:49:publishLast operator > should multicast the same values to multiple observers`
- `spec/operators/publishLast-spec.ts:70:publishLast operator > should multicast an error from the source to multiple observers`
- `spec/operators/publishLast-spec.ts:91:publishLast operator > should not cast any values to multiple observers, when source is unsubscribed explicitly and early`

</details>

### RX7-WINDOW-TIME — `windowTime`

- **Packet status:** `FIXED`
- **Evidence:** 13 tracked case(s); 0 cold failures; 0 polyfill failures; 13 fixed.
- **Current surface/gap:** 13 active-registration failure(s).
- **Required classification review:** 9 portable; 4 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (13)</summary>

- `spec/operators/windowTime-spec.ts:102:windowTime > should emit windows given windowTimeSpan and windowCreationInterval`
- `spec/operators/windowTime-spec.ts:126:windowTime > should return a single empty window if source is empty`
- `spec/operators/windowTime-spec.ts:14:windowTime > should emit windows given windowTimeSpan and windowCreationInterval`
- `spec/operators/windowTime-spec.ts:143:windowTime > should split a Just source into a single window identical to source`
- `spec/operators/windowTime-spec.ts:160:windowTime > should be able to split a never Observable into timely empty windows`
- `spec/operators/windowTime-spec.ts:184:windowTime > should emit an error-only window if outer is a simple throw-Observable`
- `spec/operators/windowTime-spec.ts:201:windowTime > should handle source Observable which eventually emits an error`
- `spec/operators/windowTime-spec.ts:224:windowTime > should emit windows given windowTimeSpan and windowCreationInterval, but outer is unsubscribed early`
- `spec/operators/windowTime-spec.ts:247:windowTime > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/windowTime-spec.ts:274:windowTime > should not error if maxWindowSize is hit while nexting to other windows.`
- `spec/operators/windowTime-spec.ts:38:windowTime > should close windows after max count is reached`
- `spec/operators/windowTime-spec.ts:60:windowTime > should close window after max count is reached with windowCreationInterval`
- `spec/operators/windowTime-spec.ts:81:windowTime > should emit windows given windowTimeSpan`

</details>

### RX7-END-WITH — `endWith`

- **Packet status:** `FIXED`
- **Evidence:** 14 tracked case(s); 0 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 12 portable; 2 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/endWith-spec.ts:105:endWith > should end with given values when given more than one value`
- `spec/operators/endWith-spec.ts:138:endWith > should allow unsubscribing explicitly and early`
- `spec/operators/endWith-spec.ts:152:endWith > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/endWith-spec.ts:16:endWith > should append to a cold Observable`
- `spec/operators/endWith-spec.ts:170:endWith > should end with empty if given value is not specified`
- `spec/operators/endWith-spec.ts:181:endWith > should accept scheduler as last argument with single value`
- `spec/operators/endWith-spec.ts:192:endWith > should accept scheduler as last argument with multiple value`
- `spec/operators/endWith-spec.ts:27:endWith > should append numbers to a cold Observable`
- `spec/operators/endWith-spec.ts:39:endWith > should end an observable with given value`
- `spec/operators/endWith-spec.ts:50:endWith > should not end with given value if source does not complete`
- `spec/operators/endWith-spec.ts:61:endWith > should not end with given value if source never emits and does not completes`
- `spec/operators/endWith-spec.ts:72:endWith > should end with given value if source does not emit but does complete`
- `spec/operators/endWith-spec.ts:83:endWith > should emit given value and complete immediately if source is empty`
- `spec/operators/endWith-spec.ts:94:endWith > should end with given value and source both if source emits single value`

</details>

### RX7-FIRST — `first`

- **Packet status:** `FIXED`
- **Evidence:** 14 tracked case(s); 0 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 14 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/first-spec.ts:106:first > should allow unsubscribing early and explicitly`
- `spec/operators/first-spec.ts:118:first > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/first-spec.ts:136:first > should unsubscribe when the first value is received`
- `spec/operators/first-spec.ts:150:first > should return first value that matches a predicate`
- `spec/operators/first-spec.ts:161:first > should return first value that matches a predicate for odd numbers`
- `spec/operators/first-spec.ts:173:first > should error when no value matches the predicate`
- `spec/operators/first-spec.ts:184:first > should return the default value when no value matches the predicate`
- `spec/operators/first-spec.ts:195:first > should propagate error when no value matches the predicate`
- `spec/operators/first-spec.ts:206:first > should return first value that matches the index in the predicate`
- `spec/operators/first-spec.ts:217:first > should propagate error from predicate`
- `spec/operators/first-spec.ts:37:first > should allow undefined as a default value`
- `spec/operators/first-spec.ts:48:first > should error on empty`
- `spec/operators/first-spec.ts:59:first > should return the default value if source observable was empty`
- `spec/operators/first-spec.ts:95:first > should go on forever on never`

</details>

### RX7-MERGE-MAP-TO — `mergeMapTo`

- **Packet status:** `TODO`
- **Evidence:** 14 tracked case(s); 0 cold failures; 2 polyfill failures; 12 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 13 portable; 1 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/mergeMapTo-spec.ts:143:mergeMapTo > should mergeMapTo many outer values to many inner values`
- `spec/operators/mergeMapTo-spec.ts:15:mergeMapTo > should map-and-flatten each item to an Observable`
- `spec/operators/mergeMapTo-spec.ts:165:mergeMapTo > should mergeMapTo many outer to many inner, complete late`
- `spec/operators/mergeMapTo-spec.ts:187:mergeMapTo > should mergeMapTo many outer to many inner, outer never completes`
- `spec/operators/mergeMapTo-spec.ts:216:mergeMapTo > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/mergeMapTo-spec.ts:249:mergeMapTo > should mergeMapTo many outer to many inner, inner never completes`
- `spec/operators/mergeMapTo-spec.ts:271:mergeMapTo > should mergeMapTo many outer to many inner, and inner throws`
- `spec/operators/mergeMapTo-spec.ts:292:mergeMapTo > should mergeMapTo many outer to many inner, and outer throws`
- `spec/operators/mergeMapTo-spec.ts:314:mergeMapTo > should mergeMapTo many outer to many inner, both inner and outer throw`
- `spec/operators/mergeMapTo-spec.ts:356:mergeMapTo > should mergeMapTo to many cold Observable, with parameter concurrency=2, without resultSelector`
- `spec/operators/mergeMapTo-spec.ts:378:mergeMapTo > should mergeMapTo many outer to arrays`
- `spec/operators/mergeMapTo-spec.ts:391:mergeMapTo > should mergeMapTo many outer to inner arrays, and outer throws`
- `spec/operators/mergeMapTo-spec.ts:404:mergeMapTo > should mergeMapTo many outer to inner arrays, outer gets unsubscribed`
- `spec/operators/mergeMapTo-spec.ts:84:mergeMapTo > should mergeMapTo many regular interval inners`

</details>

### RX7-PLUCK — `pluck`

- **Packet status:** `FIXED`
- **Evidence:** 14 tracked case(s); 0 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 14 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/pluck-spec.ts:105:pluck > should work with edge cases of deep nested properties`
- `spec/operators/pluck-spec.ts:132:pluck > should propagate errors from observable that emits only errors`
- `spec/operators/pluck-spec.ts:145:pluck > should propagate errors from observable that emit values`
- `spec/operators/pluck-spec.ts:15:pluck > should dematerialize an Observable`
- `spec/operators/pluck-spec.ts:159:pluck > should not pluck an empty observable`
- `spec/operators/pluck-spec.ts:172:pluck > should allow unsubscribing explicitly and early`
- `spec/operators/pluck-spec.ts:186:pluck > should pluck twice`
- `spec/operators/pluck-spec.ts:206:pluck > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/pluck-spec.ts:225:pluck > should support symbols`
- `spec/operators/pluck-spec.ts:241:pluck > should not break on null values`
- `spec/operators/pluck-spec.ts:37:pluck > should work for one array`
- `spec/operators/pluck-spec.ts:51:pluck > should work for one object`
- `spec/operators/pluck-spec.ts:65:pluck > should work for multiple objects`
- `spec/operators/pluck-spec.ts:85:pluck > should work with deep nested properties`

</details>

### RX7-PUBLISH-BEHAVIOR — `publishBehavior`

- **Packet status:** `TODO`
- **Evidence:** 14 tracked case(s); 8 cold failures; 0 polyfill failures; 6 fixed.
- **Current surface/gap:** 8 known mapped mismatch(es); 6 active-registration failure(s).
- **Required classification review:** 3 portable; 11 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/publishBehavior-spec.ts:123:publishBehavior operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/publishBehavior-spec.ts:15:publishBehavior operator > should mirror a simple source Observable`
- `spec/operators/publishBehavior-spec.ts:159:publishBehavior operator > with refCount() > should connect when first subscriber subscribes`
- `spec/operators/publishBehavior-spec.ts:178:publishBehavior operator > with refCount() > should disconnect when last subscriber unsubscribes`
- `spec/operators/publishBehavior-spec.ts:196:publishBehavior operator > with refCount() > should NOT be retryable`
- `spec/operators/publishBehavior-spec.ts:215:publishBehavior operator > with refCount() > should NOT be repeatable`
- `spec/operators/publishBehavior-spec.ts:278:publishBehavior operator > should multicast an empty source`
- `spec/operators/publishBehavior-spec.ts:292:publishBehavior operator > should multicast a never source`
- `spec/operators/publishBehavior-spec.ts:306:publishBehavior operator > should multicast a throw source`
- `spec/operators/publishBehavior-spec.ts:37:publishBehavior operator > should only emit default value if connect is not called, despite subscriptions`
- `spec/operators/publishBehavior-spec.ts:378:publishBehavior operator > should be referentially-transparent`
- `spec/operators/publishBehavior-spec.ts:49:publishBehavior operator > should multicast the same values to multiple observers`
- `spec/operators/publishBehavior-spec.ts:70:publishBehavior operator > should multicast an error from the source to multiple observers`
- `spec/operators/publishBehavior-spec.ts:91:publishBehavior operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early`

</details>

### RX7-RETRY — `retry`

- **Packet status:** `FIXED`
- **Evidence:** 14 tracked case(s); 0 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 14 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/retry-spec.ts:15:retry > should handle a basic source that emits next then errors, count=3`
- `spec/operators/retry-spec.ts:239:retry > should handle a never source`
- `spec/operators/retry-spec.ts:277:retry > should handle a basic source that emits next but does not complete`
- `spec/operators/retry-spec.ts:290:retry > should handle a basic source that emits next then errors, no count`
- `spec/operators/retry-spec.ts:314:retry > should handle a source which eventually throws, count=3, and result is unsubscribed early`
- `spec/operators/retry-spec.ts:333:retry > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/retry-spec.ts:399:retry > should not alter the source when the number of retries is smaller than 1`
- `spec/operators/retry-spec.ts:483:retry > with delay config > of a number > should honor count as the max retries`
- `spec/operators/retry-spec.ts:507:retry > with delay config > of a function > should delay the retry with a function that returns a notifier`
- `spec/operators/retry-spec.ts:532:retry > with delay config > of a function > should delay the retry with a function that returns a hot observable`
- `spec/operators/retry-spec.ts:561:retry > with delay config > of a function > should complete if the notifier completes`
- `spec/operators/retry-spec.ts:584:retry > with delay config > of a function > should error if the notifier errors`
- `spec/operators/retry-spec.ts:607:retry > with delay config > of a function > should error if the delay function throws`
- `spec/operators/retry-spec.ts:634:retry > with delay config > of a function > should be usable for exponential backoff`

</details>

### RX7-WINDOW — `window`

- **Packet status:** `FIXED`
- **Evidence:** 14 tracked case(s); 0 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 14 active-registration failure(s).
- **Required classification review:** 10 portable; 4 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/window-spec.ts:105:window > should return a single Never window if source is Never`
- `spec/operators/window-spec.ts:123:window > should be able to split a never Observable into timely empty windows`
- `spec/operators/window-spec.ts:143:window > should emit an error-only window if outer is a simple throw-Observable`
- `spec/operators/window-spec.ts:15:window > should emit windows that close and reopen`
- `spec/operators/window-spec.ts:161:window > should handle basic case with window closings`
- `spec/operators/window-spec.ts:182:window > should handle basic case with window closings, but outer throws`
- `spec/operators/window-spec.ts:203:window > should stop emitting windows when outer is unsubscribed early`
- `spec/operators/window-spec.ts:223:window > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/window-spec.ts:247:window > should make outer emit error when closing throws`
- `spec/operators/window-spec.ts:265:window > should complete the resulting Observable when window closings completes`
- `spec/operators/window-spec.ts:35:window > should return a single empty window if source is empty and closings are basic`
- `spec/operators/window-spec.ts:53:window > should return a single empty window if source is empty and closing is empty`
- `spec/operators/window-spec.ts:71:window > should return a single empty window if source is sync empty and closing is sync empty`
- `spec/operators/window-spec.ts:87:window > should split a Just source into a single window identical to source, using a Never closing`

</details>

### RX7-BUFFER — `buffer`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 4 known mapped mismatch(es); 11 active-registration failure(s).
- **Required classification review:** 11 portable; 4 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/buffer-spec.ts:103:Observable.prototype.buffer > should work with never and empty selector`
- `spec/operators/buffer-spec.ts:130:Observable.prototype.buffer > should work with throw and non-empty selector`
- `spec/operators/buffer-spec.ts:139:Observable.prototype.buffer > should work with error`
- `spec/operators/buffer-spec.ts:148:Observable.prototype.buffer > should work with error and non-empty selector`
- `spec/operators/buffer-spec.ts:194:Observable.prototype.buffer > should allow unsubscribing the result Observable early`
- `spec/operators/buffer-spec.ts:210:Observable.prototype.buffer > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/buffer-spec.ts:233:Observable.prototype.buffer > should work with non-empty and selector error`
- `spec/operators/buffer-spec.ts:276:Observable.prototype.buffer > should unsubscribe notifier when source unsubscribed`
- `spec/operators/buffer-spec.ts:295:Observable.prototype.buffer > should unsubscribe notifier when source unsubscribed`
- `spec/operators/buffer-spec.ts:384:should be equivalent for case 0 [buffer-case-0]`
- `spec/operators/buffer-spec.ts:384:should be equivalent for case 1 [buffer-case-1]`
- `spec/operators/buffer-spec.ts:384:should be equivalent for case 2 [buffer-case-2]`
- `spec/operators/buffer-spec.ts:384:should be equivalent for case 3 [buffer-case-3]`
- `spec/operators/buffer-spec.ts:44:Observable.prototype.buffer > should emit all buffered values if the source completes before the closingNotifier does`
- `spec/operators/buffer-spec.ts:94:Observable.prototype.buffer > should work with never and never selector`

</details>

### RX7-DELAY-WHEN — `delayWhen`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 15 active-registration failure(s).
- **Required classification review:** 11 portable; 4 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/delayWhen-spec.ts:120:delayWhen > should delay, but not emit if the selector never emits a notification`
- `spec/operators/delayWhen-spec.ts:141:delayWhen > should not emit for async source and sync empty selector`
- `spec/operators/delayWhen-spec.ts:15:delayWhen > should delay by duration selector`
- `spec/operators/delayWhen-spec.ts:154:delayWhen > should not emit if selector never emits`
- `spec/operators/delayWhen-spec.ts:175:delayWhen > should delay by first value from selector`
- `spec/operators/delayWhen-spec.ts:196:delayWhen > should delay by selector that does not completes`
- `spec/operators/delayWhen-spec.ts:217:delayWhen > should raise error if selector throws`
- `spec/operators/delayWhen-spec.ts:235:delayWhen > should start subscription when subscription delay emits`
- `spec/operators/delayWhen-spec.ts:259:delayWhen > should start subscription when subscription delay completes without emit value`
- `spec/operators/delayWhen-spec.ts:283:delayWhen > should raise error when subscription delay raises error`
- `spec/operators/delayWhen-spec.ts:312:delayWhen > should call predicate with indices starting at 0`
- `spec/operators/delayWhen-spec.ts:46:delayWhen > should delay by selector`
- `spec/operators/delayWhen-spec.ts:67:delayWhen > should raise error if source raises error`
- `spec/operators/delayWhen-spec.ts:83:delayWhen > should raise error if selector raises error`
- `spec/operators/delayWhen-spec.ts:99:delayWhen > should delay by selector and completes after value emits`

</details>

### RX7-MAP — `map`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 15 active-registration failure(s).
- **Required classification review:** 15 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/map-spec.ts:103:map > should not map an empty observable`
- `spec/operators/map-spec.ts:127:map > should allow unsubscribing explicitly and early`
- `spec/operators/map-spec.ts:141:map > should map with index`
- `spec/operators/map-spec.ts:166:map > should map with index until completed`
- `spec/operators/map-spec.ts:18:map > should map multiple values`
- `spec/operators/map-spec.ts:191:map > should map with index until an error occurs`
- `spec/operators/map-spec.ts:216:map > should map using a custom thisArg`
- `spec/operators/map-spec.ts:238:map > should map twice`
- `spec/operators/map-spec.ts:269:map > should do multiple maps using a custom thisArg`
- `spec/operators/map-spec.ts:299:map > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/map-spec.ts:31:map > should map one value`
- `spec/operators/map-spec.ts:45:map > should map multiple values`
- `spec/operators/map-spec.ts:58:map > should propagate errors from map function`
- `spec/operators/map-spec.ts:76:map > should propagate errors from observable that emits only errors`
- `spec/operators/map-spec.ts:89:map > should propagate errors from observable that emit values`

</details>

### RX7-PUBLISH — `publish`

- **Packet status:** `TODO`
- **Evidence:** 15 tracked case(s); 1 cold failures; 0 polyfill failures; 14 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 14 active-registration failure(s).
- **Required classification review:** 3 portable; 12 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/publish-spec.ts:114:publish operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early`
- `spec/operators/publish-spec.ts:146:publish operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/publish-spec.ts:15:publish operator > should mirror a simple source Observable`
- `spec/operators/publish-spec.ts:182:publish operator > with refCount() > should connect when first subscriber subscribes`
- `spec/operators/publish-spec.ts:201:publish operator > with refCount() > should disconnect when last subscriber unsubscribes`
- `spec/operators/publish-spec.ts:219:publish operator > with refCount() > should NOT be retryable`
- `spec/operators/publish-spec.ts:238:publish operator > with refCount() > should NOT be repeatable`
- `spec/operators/publish-spec.ts:301:publish operator > should multicast an empty source`
- `spec/operators/publish-spec.ts:315:publish operator > should multicast a never source`
- `spec/operators/publish-spec.ts:329:publish operator > should multicast a throw source`
- `spec/operators/publish-spec.ts:37:publish operator > should do nothing if connect is not called, despite subscriptions`
- `spec/operators/publish-spec.ts:378:publish operator > should be referentially-transparent`
- `spec/operators/publish-spec.ts:49:publish operator > should multicast the same values to multiple observers`
- `spec/operators/publish-spec.ts:70:publish operator > should accept selectors`
- `spec/operators/publish-spec.ts:93:publish operator > should multicast an error from the source to multiple observers`

</details>

### RX7-START-WITH — `startWith`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 15 active-registration failure(s).
- **Required classification review:** 10 portable; 5 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/startWith-spec.ts:107:startWith > should start with given values when given value is more than one`
- `spec/operators/startWith-spec.ts:120:startWith > should start with given value and raises error if source raises error`
- `spec/operators/startWith-spec.ts:133:startWith > should start with given value and raises error immediately if source throws error`
- `spec/operators/startWith-spec.ts:146:startWith > should allow unsubscribing explicitly and early`
- `spec/operators/startWith-spec.ts:16:startWith > should prepend to a cold Observable`
- `spec/operators/startWith-spec.ts:161:startWith > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/startWith-spec.ts:180:startWith > should start with empty if given value is not specified`
- `spec/operators/startWith-spec.ts:193:startWith > should accept scheduler as last argument with single value`
- `spec/operators/startWith-spec.ts:206:startWith > should accept scheduler as last argument with multiple value`
- `spec/operators/startWith-spec.ts:29:startWith > should start an observable with given value`
- `spec/operators/startWith-spec.ts:42:startWith > should start with given value and does not completes if source does not completes`
- `spec/operators/startWith-spec.ts:55:startWith > should start with given value and does not completes if source never emits`
- `spec/operators/startWith-spec.ts:68:startWith > should start with given value and completes if source does not emits`
- `spec/operators/startWith-spec.ts:81:startWith > should start with given value and complete immediately if source is empty`
- `spec/operators/startWith-spec.ts:94:startWith > should start with given value and source both if source emits single value`

</details>

### RX7-TAKE — `take`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 14 active-registration failure(s).
- **Required classification review:** 15 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/take-spec.ts:103:take > should propagate error from the source observable`
- `spec/operators/take-spec.ts:114:take > should propagate error from an observable with values`
- `spec/operators/take-spec.ts:125:take > should allow unsubscribing explicitly and early`
- `spec/operators/take-spec.ts:137:take > should work with throw`
- `spec/operators/take-spec.ts:148:take > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/take-spec.ts:15:take > should take two values of an observable with many values`
- `spec/operators/take-spec.ts:209:take > should complete even if the parameter is a string`
- `spec/operators/take-spec.ts:222:take > should unsubscribe from the source when it reaches the limit before a recursive synchronous upstream error is notified`
- `spec/operators/take-spec.ts:26:take > should work with empty`
- `spec/operators/take-spec.ts:37:take > should go on forever on never`
- `spec/operators/take-spec.ts:48:take > should be empty on take(0)`
- `spec/operators/take-spec.ts:59:take > should be empty if provided with negative value`
- `spec/operators/take-spec.ts:70:take > should take one value of an observable with one value`
- `spec/operators/take-spec.ts:81:take > should take one values of an observable with many values`
- `spec/operators/take-spec.ts:92:take > should error on empty`

</details>

### RX7-TIMEOUT-WITH — `timeoutWith`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 15 active-registration failure(s).
- **Required classification review:** 15 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/timeoutWith-spec.ts:107:timeoutWith operator > should not subscribe to withObservable after explicit unsubscription`
- `spec/operators/timeoutWith-spec.ts:128:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable when source is empty`
- `spec/operators/timeoutWith-spec.ts:145:timeoutWith operator > should timeout after a specified period between emit then never completes if other source does not complete`
- `spec/operators/timeoutWith-spec.ts:15:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable`
- `spec/operators/timeoutWith-spec.ts:162:timeoutWith operator > should timeout after a specified period then subscribe to the passed observable when source raises error after timeout`
- `spec/operators/timeoutWith-spec.ts:179:timeoutWith operator > should timeout after a specified period between emit then never completes if other source emits but not complete`
- `spec/operators/timeoutWith-spec.ts:196:timeoutWith operator > should not timeout if source completes within timeout period`
- `spec/operators/timeoutWith-spec.ts:212:timeoutWith operator > should not timeout if source raises error within timeout period`
- `spec/operators/timeoutWith-spec.ts:228:timeoutWith operator > should not timeout if source emits within timeout period`
- `spec/operators/timeoutWith-spec.ts:244:timeoutWith operator > should not timeout if source completes within specified Date`
- `spec/operators/timeoutWith-spec.ts:261:timeoutWith operator > should not timeout if source raises error within specified Date`
- `spec/operators/timeoutWith-spec.ts:32:timeoutWith operator > should timeout at a specified date then subscribe to the passed observable`
- `spec/operators/timeoutWith-spec.ts:50:timeoutWith operator > should timeout after a specified period between emit then subscribe to the passed observable when source emits`
- `spec/operators/timeoutWith-spec.ts:67:timeoutWith operator > should allow unsubscribing explicitly and early`
- `spec/operators/timeoutWith-spec.ts:85:timeoutWith operator > should not break unsubscription chain when unsubscribed explicitly`

</details>

### RX7-WINDOW-WHEN — `windowWhen`

- **Packet status:** `FIXED`
- **Evidence:** 15 tracked case(s); 0 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 15 active-registration failure(s).
- **Required classification review:** 12 portable; 3 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (15)</summary>

- `spec/operators/windowWhen-spec.ts:105:windowWhen > should emit windows using varying empty delayed closings`
- `spec/operators/windowWhen-spec.ts:137:windowWhen > should emit windows using varying cold closings, outer unsubscribed early`
- `spec/operators/windowWhen-spec.ts:14:windowWhen > should emit windows that close and reopen`
- `spec/operators/windowWhen-spec.ts:166:windowWhen > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/windowWhen-spec.ts:199:windowWhen > should propagate error thrown from closingSelector`
- `spec/operators/windowWhen-spec.ts:231:windowWhen > should propagate error emitted from a closing`
- `spec/operators/windowWhen-spec.ts:259:windowWhen > should propagate error emitted late from a closing`
- `spec/operators/windowWhen-spec.ts:287:windowWhen > should propagate errors emitted from the source`
- `spec/operators/windowWhen-spec.ts:317:windowWhen > should handle empty source`
- `spec/operators/windowWhen-spec.ts:335:windowWhen > should handle a never source`
- `spec/operators/windowWhen-spec.ts:366:windowWhen > should handle throw`
- `spec/operators/windowWhen-spec.ts:384:windowWhen > should handle a never closing Observable`
- `spec/operators/windowWhen-spec.ts:403:windowWhen > should handle a throw closing Observable`
- `spec/operators/windowWhen-spec.ts:41:windowWhen > should emit windows using varying cold closings`
- `spec/operators/windowWhen-spec.ts:73:windowWhen > should emit windows using varying hot closings`

</details>

### RX7-COMBINE-LATEST — `combineLatest`

- **Packet status:** `FIXED`
- **Evidence:** 16 tracked case(s); 0 cold failures; 0 polyfill failures; 16 fixed.
- **Current surface/gap:** 15 active-registration failure(s); 1 duplicate registration(s).
- **Required classification review:** 16 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/observables/combineLatest-spec.ts:100:static combineLatest > should accept array of observables`
- `spec/observables/combineLatest-spec.ts:112:static combineLatest > should accept a dictionary of observables`
- `spec/observables/combineLatest-spec.ts:126:static combineLatest > should work with two nevers`
- `spec/observables/combineLatest-spec.ts:142:static combineLatest > should work with never and empty`
- `spec/observables/combineLatest-spec.ts:158:static combineLatest > should work with empty and never`
- `spec/observables/combineLatest-spec.ts:233:static combineLatest > should work with hot-single and never`
- `spec/observables/combineLatest-spec.ts:252:static combineLatest > should work with never and hot-single`
- `spec/observables/combineLatest-spec.ts:272:static combineLatest > should work with hot and hot`
- `spec/observables/combineLatest-spec.ts:496:static combineLatest > should handle interleaved with tail`
- `spec/observables/combineLatest-spec.ts:512:static combineLatest > should handle two consecutive hot observables`
- `spec/observables/combineLatest-spec.ts:544:static combineLatest > should handle two consecutive hot observables with error right`
- `spec/observables/combineLatest-spec.ts:560:static combineLatest > should handle selector throwing`
- `spec/observables/combineLatest-spec.ts:578:static combineLatest > should allow unsubscribing early and explicitly`
- `spec/observables/combineLatest-spec.ts:596:static combineLatest > should not break unsubscription chains when unsubscribed explicitly`
- `spec/observables/combineLatest-spec.ts:61:static combineLatest > should combineLatest the provided observables`
- `spec/operators/combineLatest-spec.ts:13:combineLatest > should accept array of observables`

</details>

### RX7-DELAY — `delay`

- **Packet status:** `FIXED`
- **Evidence:** 16 tracked case(s); 0 cold failures; 0 polyfill failures; 16 fixed.
- **Current surface/gap:** 16 active-registration failure(s).
- **Required classification review:** 15 portable; 1 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/operators/delay-spec.ts:105:delay > should raise error when source raises error before absolute delay fires`
- `spec/operators/delay-spec.ts:120:delay > should raise error when source raises error after absolute delay fires`
- `spec/operators/delay-spec.ts:135:delay > should delay when source does not emit`
- `spec/operators/delay-spec.ts:149:delay > should not delay when source is empty`
- `spec/operators/delay-spec.ts:16:delay > should delay by specified timeframe`
- `spec/operators/delay-spec.ts:163:delay > should delay complete when a value is scheduled`
- `spec/operators/delay-spec.ts:177:delay > should not complete when source does not complete`
- `spec/operators/delay-spec.ts:193:delay > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/delay-spec.ts:213:delay > should not complete when source never completes`
- `spec/operators/delay-spec.ts:227:delay > should unsubscribe scheduled actions after execution`
- `spec/operators/delay-spec.ts:259:delay > should be possible to delay complete by composition`
- `spec/operators/delay-spec.ts:31:delay > should not delay at all if the delay number is negative`
- `spec/operators/delay-spec.ts:45:delay > should delay by absolute time period`
- `spec/operators/delay-spec.ts:60:delay > should not delay at all if the absolute time is in the past`
- `spec/operators/delay-spec.ts:75:delay > should delay by absolute time period after source ends`
- `spec/operators/delay-spec.ts:90:delay > should raise error when source raises error`

</details>

### RX7-PARTITION — `partition`

- **Packet status:** `TODO`
- **Evidence:** 16 tracked case(s); 1 cold failures; 0 polyfill failures; 15 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 15 active-registration failure(s).
- **Required classification review:** 15 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/observables/partition-spec.ts:115:partition > should pass errors to both returned observables if source throws`
- `spec/observables/partition-spec.ts:134:partition > should pass errors to both returned observables if predicate throws`
- `spec/observables/partition-spec.ts:159:partition > should partition empty observable if source does not emits`
- `spec/observables/partition-spec.ts:178:partition > should partition empty observable if source is empty`
- `spec/observables/partition-spec.ts:197:partition > should partition if source emits single elements`
- `spec/observables/partition-spec.ts:216:partition > should partition if predicate matches all of source elements`
- `spec/observables/partition-spec.ts:22:partition > should partition an observable of integers into even and odd`
- `spec/observables/partition-spec.ts:235:partition > should partition if predicate does not match all of source elements`
- `spec/observables/partition-spec.ts:254:partition > should partition to infinite observable if source does not completes`
- `spec/observables/partition-spec.ts:273:partition > should partition to infinite observable if source never completes`
- `spec/observables/partition-spec.ts:292:partition > should partition into two observable with early unsubscription`
- `spec/observables/partition-spec.ts:315:partition > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/observables/partition-spec.ts:39:partition > should partition an observable into two using a predicate`
- `spec/observables/partition-spec.ts:58:partition > should partition an observable into two using a predicate that takes an index`
- `spec/observables/partition-spec.ts:77:partition > should partition an observable into two using a predicate and thisArg`
- `spec/observables/partition-spec.ts:96:partition > should pass errors to both returned observables`

</details>

### RX7-SAMPLE — `sample`

- **Packet status:** `FIXED`
- **Evidence:** 16 tracked case(s); 0 cold failures; 0 polyfill failures; 16 fixed.
- **Current surface/gap:** 16 active-registration failure(s).
- **Required classification review:** 16 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/operators/sample-spec.ts:112:sample > should allow unsubscribing explicitly and early`
- `spec/operators/sample-spec.ts:127:sample > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/sample-spec.ts:148:sample > should only sample when a new value arrives, even if it is the same value`
- `spec/operators/sample-spec.ts:15:sample > should get samples when the notifier emits`
- `spec/operators/sample-spec.ts:162:sample > should raise error if source raises error`
- `spec/operators/sample-spec.ts:176:sample > should completes if source does not emits`
- `spec/operators/sample-spec.ts:190:sample > should raise error if source throws immediately`
- `spec/operators/sample-spec.ts:204:sample > should raise error if notification raises error`
- `spec/operators/sample-spec.ts:218:sample > should not completes if source does not complete`
- `spec/operators/sample-spec.ts:232:sample > should sample only until source completes`
- `spec/operators/sample-spec.ts:246:sample > should complete sampling if sample observable completes`
- `spec/operators/sample-spec.ts:29:sample > should sample nothing if source has not nexted at all`
- `spec/operators/sample-spec.ts:56:sample > should sample nothing if source has nexted after all notifications, but notifier does not complete`
- `spec/operators/sample-spec.ts:70:sample > should not sample when the notifier completes`
- `spec/operators/sample-spec.ts:84:sample > should not complete when the notifier completes, nor should it emit`
- `spec/operators/sample-spec.ts:98:sample > should complete only when the source completes, if notifier completes early`

</details>

### RX7-SHARE-REPLAY — `shareReplay`

- **Packet status:** `FIXED`
- **Evidence:** 16 tracked case(s); 0 cold failures; 0 polyfill failures; 16 fixed.
- **Current surface/gap:** 16 active-registration failure(s).
- **Required classification review:** 5 portable; 11 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/operators/shareReplay-spec.ts:111:shareReplay > should multicast a never source`
- `spec/operators/shareReplay-spec.ts:124:shareReplay > should multicast a throw source`
- `spec/operators/shareReplay-spec.ts:137:shareReplay > should replay results to subsequent subscriptions if source completes, bufferSize=2`
- `spec/operators/shareReplay-spec.ts:157:shareReplay > should completely restart for subsequent subscriptions if source errors, bufferSize=2`
- `spec/operators/shareReplay-spec.ts:16:shareReplay > should mirror a simple source Observable`
- `spec/operators/shareReplay-spec.ts:178:shareReplay > should be retryable, bufferSize=2`
- `spec/operators/shareReplay-spec.ts:209:shareReplay > should not restart due to unsubscriptions if refCount is false`
- `spec/operators/shareReplay-spec.ts:226:shareReplay > should restart due to unsubscriptions if refCount is true`
- `spec/operators/shareReplay-spec.ts:245:shareReplay > should not restart due to unsubscriptions if refCount is true when the source has completed`
- `spec/operators/shareReplay-spec.ts:291:shareReplay > should default to refCount being false`
- `spec/operators/shareReplay-spec.ts:343:shareReplay > should not skip values on a sync source`
- `spec/operators/shareReplay-spec.ts:38:shareReplay > should multicast the same values to multiple observers, bufferSize=1`
- `spec/operators/shareReplay-spec.ts:404:shareReplay > should be referentially-transparent`
- `spec/operators/shareReplay-spec.ts:58:shareReplay > should multicast the same values to multiple observers, bufferSize=2`
- `spec/operators/shareReplay-spec.ts:78:shareReplay > should multicast an error from the source to multiple observers`
- `spec/operators/shareReplay-spec.ts:98:shareReplay > should multicast an empty source`

</details>

### RX7-SKIP — `skip`

- **Packet status:** `FIXED`
- **Evidence:** 16 tracked case(s); 0 cold failures; 0 polyfill failures; 16 fixed.
- **Current surface/gap:** 16 active-registration failure(s).
- **Required classification review:** 16 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (16)</summary>

- `spec/operators/skip-spec.ts:100:skip > should raise error if skip count is more than actual number of emits and source raises error`
- `spec/operators/skip-spec.ts:111:skip > should raise error if skip count is same as emits of source and source raises error`
- `spec/operators/skip-spec.ts:122:skip > should skip values before a total and raises error if source raises error`
- `spec/operators/skip-spec.ts:133:skip > should complete regardless of skip count if source is empty`
- `spec/operators/skip-spec.ts:144:skip > should not complete if source never completes without emit`
- `spec/operators/skip-spec.ts:15:skip > should skip values before a total`
- `spec/operators/skip-spec.ts:155:skip > should skip values before total and never completes if source emits and does not complete`
- `spec/operators/skip-spec.ts:166:skip > should skip all values and never completes if total is more than numbers of value and source does not complete`
- `spec/operators/skip-spec.ts:177:skip > should skip all values and never completes if total is same asnumbers of value and source does not complete`
- `spec/operators/skip-spec.ts:188:skip > should raise error if source throws`
- `spec/operators/skip-spec.ts:26:skip > should skip all values without error if total is more than actual number of values`
- `spec/operators/skip-spec.ts:37:skip > should skip all values without error if total is same as actual number of values`
- `spec/operators/skip-spec.ts:48:skip > should not skip if count is zero`
- `spec/operators/skip-spec.ts:59:skip > should not skip if count is negative value`
- `spec/operators/skip-spec.ts:70:skip > should allow unsubscribing explicitly and early`
- `spec/operators/skip-spec.ts:82:skip > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-TAKE-UNTIL — `takeUntil`

- **Packet status:** `FIXED`
- **Evidence:** 17 tracked case(s); 0 cold failures; 0 polyfill failures; 17 fixed.
- **Current surface/gap:** 17 active-registration failure(s).
- **Required classification review:** 17 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (17)</summary>

- `spec/operators/takeUntil-spec.ts:108:takeUntil operator > should complete when notifier emits if source observable does not complete`
- `spec/operators/takeUntil-spec.ts:122:takeUntil operator > should raise error when notifier raises error if source observable does not complete`
- `spec/operators/takeUntil-spec.ts:136:takeUntil operator > should not complete when notifier is empty if source observable does not complete`
- `spec/operators/takeUntil-spec.ts:14:takeUntil operator > should take values until notifier emits`
- `spec/operators/takeUntil-spec.ts:150:takeUntil operator > should not complete when source and notifier do not complete`
- `spec/operators/takeUntil-spec.ts:164:takeUntil operator > should complete when notifier emits before source observable emits`
- `spec/operators/takeUntil-spec.ts:178:takeUntil operator > should raise error if source raises error before notifier emits`
- `spec/operators/takeUntil-spec.ts:192:takeUntil operator > should raise error immediately if source throws`
- `spec/operators/takeUntil-spec.ts:206:takeUntil operator > should dispose source observable if notifier emits before source emits`
- `spec/operators/takeUntil-spec.ts:220:takeUntil operator > should dispose notifier if source observable completes`
- `spec/operators/takeUntil-spec.ts:234:takeUntil operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/takeUntil-spec.ts:28:takeUntil operator > should take values and raises error when notifier raises error`
- `spec/operators/takeUntil-spec.ts:42:takeUntil operator > should take all values when notifier is empty`
- `spec/operators/takeUntil-spec.ts:56:takeUntil operator > should take all values when notifier does not complete`
- `spec/operators/takeUntil-spec.ts:70:takeUntil operator > should complete without subscribing to the source when notifier synchronously emits`
- `spec/operators/takeUntil-spec.ts:81:takeUntil operator > should subscribe to the source when notifier synchronously completes without emitting`
- `spec/operators/takeUntil-spec.ts:93:takeUntil operator > should allow unsubscribing explicitly and early`

</details>

### RX7-BUFFER-TIME — `bufferTime`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/bufferTime-spec.ts:103:bufferTime operator > should emit buffers at intervals or when the buffer is full test 2`
- `spec/operators/bufferTime-spec.ts:124:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay`
- `spec/operators/bufferTime-spec.ts:146:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay or when the buffer is full`
- `spec/operators/bufferTime-spec.ts:15:bufferTime operator > should emit buffers at intervals`
- `spec/operators/bufferTime-spec.ts:168:bufferTime operator > should emit buffers with timeSpan 10 and creationInterval 7`
- `spec/operators/bufferTime-spec.ts:198:bufferTime operator > should emit buffers but handle source ending with an error`
- `spec/operators/bufferTime-spec.ts:225:bufferTime operator > should emit buffers and allow result to unsubscribed early`
- `spec/operators/bufferTime-spec.ts:248:bufferTime operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/bufferTime-spec.ts:275:bufferTime operator > should handle empty`
- `spec/operators/bufferTime-spec.ts:290:bufferTime operator > should handle never`
- `spec/operators/bufferTime-spec.ts:303:bufferTime operator > should handle throw`
- `spec/operators/bufferTime-spec.ts:315:bufferTime operator > should handle errors`
- `spec/operators/bufferTime-spec.ts:332:bufferTime operator > should emit buffers that have been created at intervals and close after the specified delay with errors`
- `spec/operators/bufferTime-spec.ts:35:bufferTime operator > should emit buffers at intervals test 2`
- `spec/operators/bufferTime-spec.ts:355:bufferTime operator > should not throw when subscription synchronously unsubscribed after emit`
- `spec/operators/bufferTime-spec.ts:373:bufferTime operator > should not have errors when take follows and maxBufferSize is provided`
- `spec/operators/bufferTime-spec.ts:392:bufferTime operator > should not mutate the buffer on reentrant next`
- `spec/operators/bufferTime-spec.ts:52:bufferTime operator > should emit buffers at intervals or when the buffer is full`

</details>

### RX7-BUFFER-TOGGLE — `bufferToggle`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 17 portable; 1 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/bufferToggle-spec.ts:130:bufferToggle operator > should emit buffers using varying empty delayed closings`
- `spec/operators/bufferToggle-spec.ts:15:bufferToggle operator > should emit buffers using hot openings and hot closings`
- `spec/operators/bufferToggle-spec.ts:155:bufferToggle operator > should emit buffers using varying cold closings, outer unsubscribed early`
- `spec/operators/bufferToggle-spec.ts:183:bufferToggle operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/bufferToggle-spec.ts:211:bufferToggle operator > should propagate error thrown from closingSelector`
- `spec/operators/bufferToggle-spec.ts:242:bufferToggle operator > should propagate error emitted from a closing`
- `spec/operators/bufferToggle-spec.ts:267:bufferToggle operator > should propagate error emitted late from a closing`
- `spec/operators/bufferToggle-spec.ts:295:bufferToggle operator > should handle errors`
- `spec/operators/bufferToggle-spec.ts:32:bufferToggle operator > should emit buffers that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument`
- `spec/operators/bufferToggle-spec.ts:325:bufferToggle operator > should handle empty source`
- `spec/operators/bufferToggle-spec.ts:339:bufferToggle operator > should handle throw`
- `spec/operators/bufferToggle-spec.ts:353:bufferToggle operator > should handle never`
- `spec/operators/bufferToggle-spec.ts:374:bufferToggle operator > should handle a never opening Observable`
- `spec/operators/bufferToggle-spec.ts:387:bufferToggle operator > should handle a never closing Observable`
- `spec/operators/bufferToggle-spec.ts:404:bufferToggle operator > should handle opening Observable that just throws`
- `spec/operators/bufferToggle-spec.ts:530:bufferToggle operator > should handle empty closing observable`
- `spec/operators/bufferToggle-spec.ts:59:bufferToggle operator > should emit buffers using varying cold closings`
- `spec/operators/bufferToggle-spec.ts:92:bufferToggle operator > should emit buffers using varying hot closings`

</details>

### RX7-CONCAT-WITH — `concatWith`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/concatWith-spec.ts:107:concat operator > should raise error when first source is empty, second source raises error`
- `spec/operators/concatWith-spec.ts:149:concat operator > should concat if first source emits once, second source is empty`
- `spec/operators/concatWith-spec.ts:16:concat operator > should concatenate two cold observables`
- `spec/operators/concatWith-spec.ts:163:concat operator > should concat if first source is empty, second source emits once`
- `spec/operators/concatWith-spec.ts:177:concat operator > should emit element from first source, and should not complete if second source does not completes`
- `spec/operators/concatWith-spec.ts:191:concat operator > should not complete if first source does not complete`
- `spec/operators/concatWith-spec.ts:205:concat operator > should emit elements from each source when source emit once`
- `spec/operators/concatWith-spec.ts:219:concat operator > should unsubscribe to inner source if outer is unsubscribed early`
- `spec/operators/concatWith-spec.ts:234:concat operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/concatWith-spec.ts:269:concat operator > should emit element from first source then raise error from second source`
- `spec/operators/concatWith-spec.ts:283:concat operator > should emit all elements from both hot observable sources if first source completes before second source starts emit`
- `spec/operators/concatWith-spec.ts:297:concat operator > should emit elements from second source regardless of completion time when second source is cold observable`
- `spec/operators/concatWith-spec.ts:311:concat operator > should not emit collapsing element from second source`
- `spec/operators/concatWith-spec.ts:325:concat operator > should emit self without parameters`
- `spec/operators/concatWith-spec.ts:51:concat operator > should complete without emit if both sources are empty`
- `spec/operators/concatWith-spec.ts:65:concat operator > should not complete if first source does not completes`
- `spec/operators/concatWith-spec.ts:79:concat operator > should not complete if second source does not completes`
- `spec/operators/concatWith-spec.ts:93:concat operator > should not complete if both sources do not complete`

</details>

### RX7-MAX — `max`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/max-spec.ts:104:max > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/max-spec.ts:15:max > should find the max of values of an observable`
- `spec/operators/max-spec.ts:170:max > should work with error`
- `spec/operators/max-spec.ts:181:max > should work with throw`
- `spec/operators/max-spec.ts:192:max > should handle a constant predicate on an empty hot observable`
- `spec/operators/max-spec.ts:207:max > should handle a constant predicate on an never hot observable`
- `spec/operators/max-spec.ts:222:max > should handle a constant predicate on a simple hot observable`
- `spec/operators/max-spec.ts:237:max > should handle a reverse predicate on observable with many values`
- `spec/operators/max-spec.ts:252:max > should handle a predicate for string on observable with many values`
- `spec/operators/max-spec.ts:26:max > should be never when source is never`
- `spec/operators/max-spec.ts:267:max > should handle a constant predicate on observable that throws`
- `spec/operators/max-spec.ts:282:max > should handle a predicate that throws, on observable with many values`
- `spec/operators/max-spec.ts:37:max > should be zero when source is empty`
- `spec/operators/max-spec.ts:48:max > should be never when source doesn't complete`
- `spec/operators/max-spec.ts:59:max > should complete when source doesn't have values`
- `spec/operators/max-spec.ts:70:max > should max the unique value of an observable`
- `spec/operators/max-spec.ts:81:max > should max the values of an ongoing hot observable`
- `spec/operators/max-spec.ts:92:max > should allow unsubscribing explicitly and early`

</details>

### RX7-MIN — `min`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/min-spec.ts:134:min > should work with error`
- `spec/operators/min-spec.ts:145:min > should work with throw`
- `spec/operators/min-spec.ts:15:min > should min the values of an observable`
- `spec/operators/min-spec.ts:156:min > should handle a constant predicate on an empty hot observable`
- `spec/operators/min-spec.ts:171:min > should handle a constant predicate on an never hot observable`
- `spec/operators/min-spec.ts:186:min > should handle a constant predicate on a simple hot observable`
- `spec/operators/min-spec.ts:201:min > should allow unsubscribing explicitly and early`
- `spec/operators/min-spec.ts:217:min > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/min-spec.ts:239:min > should handle a reverse predicate on observable with many values`
- `spec/operators/min-spec.ts:254:min > should handle a predicate for string on observable with many values`
- `spec/operators/min-spec.ts:26:min > should be never when source is never`
- `spec/operators/min-spec.ts:269:min > should handle a constant predicate on observable that throws`
- `spec/operators/min-spec.ts:284:min > should handle a predicate that throws, on observable with many values`
- `spec/operators/min-spec.ts:37:min > should be zero when source is empty`
- `spec/operators/min-spec.ts:48:min > should be never when source doesn't complete`
- `spec/operators/min-spec.ts:59:min > should be completes when source doesn't have values`
- `spec/operators/min-spec.ts:70:min > should min the unique value of an observable`
- `spec/operators/min-spec.ts:81:min > should min the values of an ongoing hot observable`

</details>

### RX7-REDUCE — `reduce`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/reduce-spec.ts:102:reduce > should reduce with seed if source is empty`
- `spec/operators/reduce-spec.ts:115:reduce > should raise error if reduce function throws without seed`
- `spec/operators/reduce-spec.ts:132:reduce > should allow unsubscribing explicitly and early`
- `spec/operators/reduce-spec.ts:146:reduce > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/reduce-spec.ts:15:reduce > should reduce`
- `spec/operators/reduce-spec.ts:164:reduce > should raise error if source emits and raises error with seed`
- `spec/operators/reduce-spec.ts:177:reduce > should raise error if source raises error with seed`
- `spec/operators/reduce-spec.ts:190:reduce > should raise error if reduce function throws with seed`
- `spec/operators/reduce-spec.ts:207:reduce > should not complete with seed if source emits but does not complete`
- `spec/operators/reduce-spec.ts:220:reduce > should not complete with seed if source never completes`
- `spec/operators/reduce-spec.ts:233:reduce > should not complete without seed if source emits but does not completes`
- `spec/operators/reduce-spec.ts:246:reduce > should not complete without seed if source never completes`
- `spec/operators/reduce-spec.ts:259:reduce > should reduce if source does not emit without seed`
- `spec/operators/reduce-spec.ts:272:reduce > should raise error if source emits and raises error without seed`
- `spec/operators/reduce-spec.ts:285:reduce > should raise error if source raises error without seed`
- `spec/operators/reduce-spec.ts:29:reduce > should reduce with seed`
- `spec/operators/reduce-spec.ts:42:reduce > should reduce with a seed of undefined`
- `spec/operators/reduce-spec.ts:55:reduce > should reduce without a seed`

</details>

### RX7-SWITCH-SCAN — `switchScan`

- **Packet status:** `FIXED`
- **Evidence:** 18 tracked case(s); 0 cold failures; 0 polyfill failures; 18 fixed.
- **Current surface/gap:** 18 active-registration failure(s).
- **Required classification review:** 18 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (18)</summary>

- `spec/operators/switchScan-spec.ts:104:switchScan > should switch inner cold observables, outer is unsubscribed early`
- `spec/operators/switchScan-spec.ts:126:switchScan > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/switchScan-spec.ts:15:switchScan > should map-and-flatten each item to an Observable while passing the accumulated value`
- `spec/operators/switchScan-spec.ts:181:switchScan > should switch inner cold observables, inner never completes`
- `spec/operators/switchScan-spec.ts:202:switchScan > should handle a synchronous switch to the second inner observable`
- `spec/operators/switchScan-spec.ts:223:switchScan > should switch inner cold observables, one inner throws`
- `spec/operators/switchScan-spec.ts:244:switchScan > should switch inner hot observables`
- `spec/operators/switchScan-spec.ts:265:switchScan > should switch inner empty and empty`
- `spec/operators/switchScan-spec.ts:286:switchScan > should switch inner empty and never`
- `spec/operators/switchScan-spec.ts:307:switchScan > should switch inner never and empty`
- `spec/operators/switchScan-spec.ts:328:switchScan > should switch inner never and throw`
- `spec/operators/switchScan-spec.ts:349:switchScan > should switch inner empty and throw`
- `spec/operators/switchScan-spec.ts:370:switchScan > should handle outer empty`
- `spec/operators/switchScan-spec.ts:383:switchScan > should handle outer never`
- `spec/operators/switchScan-spec.ts:396:switchScan > should handle outer throw`
- `spec/operators/switchScan-spec.ts:409:switchScan > should handle outer error`
- `spec/operators/switchScan-spec.ts:68:switchScan > should switch inner cold observables`
- `spec/operators/switchScan-spec.ts:89:switchScan > should raise error when projection throws`

</details>

### RX7-AUDIT — `audit`

- **Packet status:** `FIXED`
- **Evidence:** 19 tracked case(s); 0 cold failures; 0 polyfill failures; 19 fixed.
- **Current surface/gap:** 19 active-registration failure(s).
- **Required classification review:** 19 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (19)</summary>

- `spec/operators/audit-spec.ts:123:audit operator > should handle a busy producer emitting a regular repeating sequence`
- `spec/operators/audit-spec.ts:145:audit operator > should mirror source if durations are immediate`
- `spec/operators/audit-spec.ts:15:audit operator > should emit the last value in each time window`
- `spec/operators/audit-spec.ts:159:audit operator > should emit no values if durations are EMPTY`
- `spec/operators/audit-spec.ts:173:audit operator > should emit no values and never complete if duration is a never`
- `spec/operators/audit-spec.ts:189:audit operator > should unsubscribe duration Observable when source raise error`
- `spec/operators/audit-spec.ts:205:audit operator > should mirror source if durations are synchronous observables`
- `spec/operators/audit-spec.ts:219:audit operator > should raise error as soon as just-throw duration is used`
- `spec/operators/audit-spec.ts:235:audit operator > should audit using durations of varying lengths`
- `spec/operators/audit-spec.ts:266:audit operator > should propagate error from duration Observable`
- `spec/operators/audit-spec.ts:293:audit operator > should propagate error thrown from durationSelector function`
- `spec/operators/audit-spec.ts:327:audit operator > should complete when source does not emit`
- `spec/operators/audit-spec.ts:355:audit operator > should handle an empty source`
- `spec/operators/audit-spec.ts:369:audit operator > should handle a never source`
- `spec/operators/audit-spec.ts:37:audit operator > should delay the source if values are not emitted often enough`
- `spec/operators/audit-spec.ts:470:audit operator > should emit last value after duration completes if source completes first`
- `spec/operators/audit-spec.ts:57:audit operator > should audit with duration Observable using next to close the duration`
- `spec/operators/audit-spec.ts:77:audit operator > should interrupt source and duration when result is unsubscribed early`
- `spec/operators/audit-spec.ts:98:audit operator > should not break unsubscription chains when result is unsubscribed explicitly`

</details>

### RX7-REPEAT-WHEN — `repeatWhen`

- **Packet status:** `FIXED`
- **Evidence:** 19 tracked case(s); 0 cold failures; 0 polyfill failures; 19 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 18 active-registration failure(s).
- **Required classification review:** 18 portable; 1 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (19)</summary>

- `spec/operators/repeatWhen-spec.ts:16:repeatWhen operator > should handle a source with eventual complete using a hot notifier`
- `spec/operators/repeatWhen-spec.ts:169:repeatWhen operator > should apply an empty notifier on an empty source`
- `spec/operators/repeatWhen-spec.ts:183:repeatWhen operator > should apply a never notifier on an empty source`
- `spec/operators/repeatWhen-spec.ts:197:repeatWhen operator > should apply an empty notifier on a never source`
- `spec/operators/repeatWhen-spec.ts:212:repeatWhen operator > should apply a never notifier on a never source`
- `spec/operators/repeatWhen-spec.ts:227:repeatWhen operator > should return an empty observable given a just-throw source and empty notifier`
- `spec/operators/repeatWhen-spec.ts:239:repeatWhen operator > should return a error observable given a just-throw source and never notifier`
- `spec/operators/repeatWhen-spec.ts:251:repeatWhen operator > should return a never-ending result if the notifier is never`
- `spec/operators/repeatWhen-spec.ts:265:repeatWhen operator > should propagate error thrown from notifierSelector function`
- `spec/operators/repeatWhen-spec.ts:282:repeatWhen operator > should complete if the notifier only completes`
- `spec/operators/repeatWhen-spec.ts:296:repeatWhen operator > should mirror a basic cold source with complete, given a never notifier`
- `spec/operators/repeatWhen-spec.ts:310:repeatWhen operator > should mirror a basic cold source with no termination, given a never notifier`
- `spec/operators/repeatWhen-spec.ts:324:repeatWhen operator > should mirror a basic hot source with complete, given a never notifier`
- `spec/operators/repeatWhen-spec.ts:339:repeatWhen operator > should handle a host source that completes via operator like take, and a hot notifier`
- `spec/operators/repeatWhen-spec.ts:36:repeatWhen operator > should handle a source with eventual complete using a hot notifier that raises error`
- `spec/operators/repeatWhen-spec.ts:362:repeatWhen operator > should tear down resources when result is unsubscribed early`
- `spec/operators/repeatWhen-spec.ts:383:repeatWhen operator > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/repeatWhen-spec.ts:408:repeatWhen operator > should handle a source with eventual error using a dynamic notifier selector which eventually throws`
- `spec/operators/repeatWhen-spec.ts:438:repeatWhen operator > should handle a source with eventual error using a dynamic notifier selector which eventually completes`

</details>

### RX7-RETRY-WHEN — `retryWhen`

- **Packet status:** `FIXED`
- **Evidence:** 19 tracked case(s); 0 cold failures; 0 polyfill failures; 19 fixed.
- **Current surface/gap:** 19 active-registration failure(s).
- **Required classification review:** 19 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (19)</summary>

- `spec/operators/retryWhen-spec.ts:116:retryWhen > should apply an empty notifier on an empty source`
- `spec/operators/retryWhen-spec.ts:130:retryWhen > should apply a never notifier on an empty source`
- `spec/operators/retryWhen-spec.ts:144:retryWhen > should apply an empty notifier on a never source`
- `spec/operators/retryWhen-spec.ts:15:retryWhen > should handle a source with eventual error using a hot notifier`
- `spec/operators/retryWhen-spec.ts:159:retryWhen > should apply a never notifier on a never source`
- `spec/operators/retryWhen-spec.ts:174:retryWhen > should return an empty observable given a just-throw source and empty notifier`
- `spec/operators/retryWhen-spec.ts:186:retryWhen > should return a never observable given a just-throw source and never notifier`
- `spec/operators/retryWhen-spec.ts:198:retryWhen > should hide errors using a never notifier on a source with eventual error`
- `spec/operators/retryWhen-spec.ts:212:retryWhen > should propagate error thrown from notifierSelector function`
- `spec/operators/retryWhen-spec.ts:229:retryWhen > should replace error with complete using an empty notifier on a source with eventual error`
- `spec/operators/retryWhen-spec.ts:243:retryWhen > should mirror a basic cold source with complete, given an empty notifier`
- `spec/operators/retryWhen-spec.ts:257:retryWhen > should mirror a basic cold source with no termination, given an empty notifier`
- `spec/operators/retryWhen-spec.ts:271:retryWhen > should mirror a basic hot source with complete, given an empty notifier`
- `spec/operators/retryWhen-spec.ts:285:retryWhen > should handle a hot source that raises error but eventually completes`
- `spec/operators/retryWhen-spec.ts:312:retryWhen > should tear down resources when result is unsubscribed early`
- `spec/operators/retryWhen-spec.ts:335:retryWhen > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/retryWhen-spec.ts:35:retryWhen > should handle a source with eventual error using a hot notifier that raises error`
- `spec/operators/retryWhen-spec.ts:362:retryWhen > should handle a source with eventual error using a dynamic notifier selector which eventually throws`
- `spec/operators/retryWhen-spec.ts:394:retryWhen > should handle a source with eventual error using a dynamic notifier selector which eventually completes`

</details>

### RX7-WINDOW-TOGGLE — `windowToggle`

- **Packet status:** `FIXED`
- **Evidence:** 19 tracked case(s); 0 cold failures; 0 polyfill failures; 19 fixed.
- **Current surface/gap:** 19 active-registration failure(s).
- **Required classification review:** 16 portable; 2 harness rewrite; 1 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (19)</summary>

- `spec/operators/windowToggle-spec.ts:114:windowToggle > should emit windows using varying hot closings`
- `spec/operators/windowToggle-spec.ts:149:windowToggle > should emit windows using varying empty delayed closings`
- `spec/operators/windowToggle-spec.ts:15:windowToggle > should emit windows governed by openings and closings`
- `spec/operators/windowToggle-spec.ts:176:windowToggle > should emit windows using varying cold closings, outer unsubscribed early`
- `spec/operators/windowToggle-spec.ts:210:windowToggle > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/windowToggle-spec.ts:246:windowToggle > should dispose window Subjects if the outer is unsubscribed early`
- `spec/operators/windowToggle-spec.ts:275:windowToggle > should propagate error thrown from closingSelector`
- `spec/operators/windowToggle-spec.ts:307:windowToggle > should propagate error emitted from a closing`
- `spec/operators/windowToggle-spec.ts:333:windowToggle > should propagate error emitted late from a closing`
- `spec/operators/windowToggle-spec.ts:359:windowToggle > should handle errors`
- `spec/operators/windowToggle-spec.ts:385:windowToggle > should handle empty source`
- `spec/operators/windowToggle-spec.ts:403:windowToggle > should handle throw`
- `spec/operators/windowToggle-spec.ts:421:windowToggle > should handle never`
- `spec/operators/windowToggle-spec.ts:44:windowToggle > should emit windows that are opened by an observable from the first argument and closed by an observable returned by the function in the second argument`
- `spec/operators/windowToggle-spec.ts:446:windowToggle > should handle a never opening Observable`
- `spec/operators/windowToggle-spec.ts:464:windowToggle > should handle a never closing Observable`
- `spec/operators/windowToggle-spec.ts:486:windowToggle > should handle opening Observable that just throws`
- `spec/operators/windowToggle-spec.ts:506:windowToggle > should handle empty closing observable`
- `spec/operators/windowToggle-spec.ts:79:windowToggle > should emit windows using varying cold closings`

</details>

### RX7-CONCAT-LEGACY — `concat-legacy`

- **Packet status:** `FIXED`
- **Evidence:** 20 tracked case(s); 0 cold failures; 0 polyfill failures; 20 fixed.
- **Current surface/gap:** 20 active-registration failure(s).
- **Required classification review:** 17 portable; 3 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (20)</summary>

- `spec/operators/concat-legacy-spec.ts:106:concat operator > should raise error when first source is empty, second source raises error`
- `spec/operators/concat-legacy-spec.ts:148:concat operator > should concat if first source emits once, second source is empty`
- `spec/operators/concat-legacy-spec.ts:15:concat operator > should concatenate two cold observables`
- `spec/operators/concat-legacy-spec.ts:162:concat operator > should concat if first source is empty, second source emits once`
- `spec/operators/concat-legacy-spec.ts:176:concat operator > should emit element from first source, and should not complete if second source does not complete`
- `spec/operators/concat-legacy-spec.ts:190:concat operator > should not complete if first source does not complete`
- `spec/operators/concat-legacy-spec.ts:204:concat operator > should emit elements from each source when source emit once`
- `spec/operators/concat-legacy-spec.ts:218:concat operator > should unsubscribe to inner source if outer is unsubscribed early`
- `spec/operators/concat-legacy-spec.ts:233:concat operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/concat-legacy-spec.ts:268:concat operator > should emit element from first source then raise error from second source`
- `spec/operators/concat-legacy-spec.ts:282:concat operator > should emit all elements from both hot observable sources if first source completes before second source starts emit`
- `spec/operators/concat-legacy-spec.ts:296:concat operator > should emit elements from second source regardless of completion time when second source is cold observable`
- `spec/operators/concat-legacy-spec.ts:310:concat operator > should not emit collapsing element from second source`
- `spec/operators/concat-legacy-spec.ts:324:concat operator > should accept scheduler with multiple observables`
- `spec/operators/concat-legacy-spec.ts:341:concat operator > should accept scheduler without observable parameters`
- `spec/operators/concat-legacy-spec.ts:352:concat operator > should emit self without parameters`
- `spec/operators/concat-legacy-spec.ts:50:concat operator > should complete without emit if both sources are empty`
- `spec/operators/concat-legacy-spec.ts:64:concat operator > should not complete if first source does not complete`
- `spec/operators/concat-legacy-spec.ts:78:concat operator > should not complete if second source does not complete`
- `spec/operators/concat-legacy-spec.ts:92:concat operator > should not complete if both sources do not complete`

</details>

### RX7-DISTINCT — `distinct`

- **Packet status:** `FIXED`
- **Evidence:** 20 tracked case(s); 0 cold failures; 0 polyfill failures; 20 fixed.
- **Current surface/gap:** 20 active-registration failure(s).
- **Required classification review:** 20 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (20)</summary>

- `spec/operators/distinct-spec.ts:101:distinct > should raises error if source raises error`
- `spec/operators/distinct-spec.ts:112:distinct > should raises error if source throws`
- `spec/operators/distinct-spec.ts:123:distinct > should not omit if source elements are all different`
- `spec/operators/distinct-spec.ts:134:distinct > should allow unsubscribing early and explicitly`
- `spec/operators/distinct-spec.ts:148:distinct > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/distinct-spec.ts:15:distinct > should distinguish between values`
- `spec/operators/distinct-spec.ts:166:distinct > should emit once if source elements are all same`
- `spec/operators/distinct-spec.ts:177:distinct > should distinguish values by key`
- `spec/operators/distinct-spec.ts:190:distinct > should raises error when selector throws`
- `spec/operators/distinct-spec.ts:207:distinct > should support a flushing stream`
- `spec/operators/distinct-spec.ts:221:distinct > should raise error if flush raises error`
- `spec/operators/distinct-spec.ts:235:distinct > should unsubscribe from the flushing stream when the main stream is unsubbed`
- `spec/operators/distinct-spec.ts:250:distinct > should allow opting in to default comparator with flush`
- `spec/operators/distinct-spec.ts:26:distinct > should distinguish between values and does not complete`
- `spec/operators/distinct-spec.ts:37:distinct > should not complete if source never completes`
- `spec/operators/distinct-spec.ts:48:distinct > should not complete if source does not complete`
- `spec/operators/distinct-spec.ts:59:distinct > should complete if source is empty`
- `spec/operators/distinct-spec.ts:70:distinct > should complete if source does not emit`
- `spec/operators/distinct-spec.ts:81:distinct > should emit if source emits single element only`
- `spec/operators/distinct-spec.ts:92:distinct > should emit if source is scalar`

</details>

### RX7-MERGE-SCAN — `mergeScan`

- **Packet status:** `FIXED`
- **Evidence:** 20 tracked case(s); 0 cold failures; 0 polyfill failures; 20 fixed.
- **Current surface/gap:** 20 active-registration failure(s).
- **Required classification review:** 20 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (20)</summary>

- `spec/operators/mergeScan-spec.ts:112:mergeScan > should interrupt ongoing async projections when result is unsubscribed early`
- `spec/operators/mergeScan-spec.ts:135:mergeScan > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/mergeScan-spec.ts:15:mergeScan > should mergeScan things`
- `spec/operators/mergeScan-spec.ts:191:mergeScan > should handle errors in the projection function`
- `spec/operators/mergeScan-spec.ts:216:mergeScan > should propagate errors from the projected Observable`
- `spec/operators/mergeScan-spec.ts:229:mergeScan > should handle an empty projected Observable`
- `spec/operators/mergeScan-spec.ts:242:mergeScan > should handle a never projected Observable`
- `spec/operators/mergeScan-spec.ts:255:mergeScan > handle empty`
- `spec/operators/mergeScan-spec.ts:268:mergeScan > handle never`
- `spec/operators/mergeScan-spec.ts:281:mergeScan > handle throw`
- `spec/operators/mergeScan-spec.ts:294:mergeScan > should mergeScan unsubscription`
- `spec/operators/mergeScan-spec.ts:315:mergeScan > should mergeScan projects cold Observable with single concurrency`
- `spec/operators/mergeScan-spec.ts:341:mergeScan > should not emit accumulator if inner completes without value`
- `spec/operators/mergeScan-spec.ts:354:mergeScan > should not emit accumulator if inner completes without value after source completes`
- `spec/operators/mergeScan-spec.ts:37:mergeScan > should handle errors`
- `spec/operators/mergeScan-spec.ts:375:mergeScan > should mergeScan projects hot Observable with single concurrency`
- `spec/operators/mergeScan-spec.ts:400:mergeScan > should mergeScan projects cold Observable with dual concurrency`
- `spec/operators/mergeScan-spec.ts:425:mergeScan > should mergeScan projects hot Observable with dual concurrency`
- `spec/operators/mergeScan-spec.ts:56:mergeScan > should mergeScan values and be able to asynchronously project them`
- `spec/operators/mergeScan-spec.ts:84:mergeScan > should not stop ongoing async projections when source completes`

</details>

### RX7-REPEAT — `repeat`

- **Packet status:** `FIXED`
- **Evidence:** 20 tracked case(s); 0 cold failures; 0 polyfill failures; 20 fixed.
- **Current surface/gap:** 20 active-registration failure(s).
- **Required classification review:** 20 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (20)</summary>

- `spec/operators/repeat-spec.ts:102:repeat operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/repeat-spec.ts:127:repeat operator > should consider negative count as no repeat, and return EMPTY`
- `spec/operators/repeat-spec.ts:15:repeat operator > should resubscribe count number of times`
- `spec/operators/repeat-spec.ts:178:repeat operator > should not complete when source never completes`
- `spec/operators/repeat-spec.ts:189:repeat operator > should not complete when source does not completes`
- `spec/operators/repeat-spec.ts:201:repeat operator > should complete immediately when source does not complete without emit but count is zero`
- `spec/operators/repeat-spec.ts:212:repeat operator > should complete immediately when source does not complete but count is zero`
- `spec/operators/repeat-spec.ts:223:repeat operator > should emit source once and does not complete when source emits but does not complete`
- `spec/operators/repeat-spec.ts:234:repeat operator > should complete when source is empty`
- `spec/operators/repeat-spec.ts:245:repeat operator > should complete when source does not emit`
- `spec/operators/repeat-spec.ts:260:repeat operator > should complete immediately when source does not emit but count is zero`
- `spec/operators/repeat-spec.ts:30:repeat operator > should resubscribe multiple times`
- `spec/operators/repeat-spec.ts:304:repeat operator > should raise error after first emit succeed`
- `spec/operators/repeat-spec.ts:365:repeat operator > should allow count configuration`
- `spec/operators/repeat-spec.ts:380:repeat operator > should allow delay time configuration`
- `spec/operators/repeat-spec.ts:396:repeat operator > should allow delay function configuration`
- `spec/operators/repeat-spec.ts:46:repeat operator > should complete without emit when count is zero`
- `spec/operators/repeat-spec.ts:57:repeat operator > should emit source once when count is one`
- `spec/operators/repeat-spec.ts:68:repeat operator > should repeat until gets unsubscribed`
- `spec/operators/repeat-spec.ts:83:repeat operator > should be able to repeat indefinitely until unsubscribed`

</details>

### RX7-COUNT — `count`

- **Packet status:** `FIXED`
- **Evidence:** 21 tracked case(s); 0 cold failures; 0 polyfill failures; 21 fixed.
- **Current surface/gap:** 21 active-registration failure(s).
- **Required classification review:** 21 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (21)</summary>

- `spec/operators/count-spec.ts:140:count > should work with error`
- `spec/operators/count-spec.ts:15:count > should count the values of an observable`
- `spec/operators/count-spec.ts:151:count > should work with throw`
- `spec/operators/count-spec.ts:162:count > should handle an always-true predicate on an empty hot observable`
- `spec/operators/count-spec.ts:176:count > should handle an always-false predicate on an empty hot observable`
- `spec/operators/count-spec.ts:190:count > should handle an always-true predicate on a simple hot observable`
- `spec/operators/count-spec.ts:204:count > should handle an always-false predicate on a simple hot observable`
- `spec/operators/count-spec.ts:218:count > should allow unsubscribing early and explicitly`
- `spec/operators/count-spec.ts:232:count > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/count-spec.ts:250:count > should handle a match-all predicate on observable with many values`
- `spec/operators/count-spec.ts:26:count > should be never when source is never`
- `spec/operators/count-spec.ts:262:count > should handle a match-none predicate on observable with many values`
- `spec/operators/count-spec.ts:274:count > should handle an always-true predicate on observable that throws`
- `spec/operators/count-spec.ts:286:count > should handle an always-false predicate on observable that throws`
- `spec/operators/count-spec.ts:298:count > should handle an always-true predicate on a hot never-observable`
- `spec/operators/count-spec.ts:310:count > should handle a predicate that throws, on observable with many values`
- `spec/operators/count-spec.ts:37:count > should be zero when source is empty`
- `spec/operators/count-spec.ts:48:count > should be never when source doesn't complete`
- `spec/operators/count-spec.ts:59:count > should be zero when source doesn't have values`
- `spec/operators/count-spec.ts:70:count > should count the unique value of an observable`
- `spec/operators/count-spec.ts:81:count > should count the values of an ongoing hot observable`

</details>

### RX7-DISTINCT-UNTIL-KEY-CHANGED — `distinctUntilKeyChanged`

- **Packet status:** `FIXED`
- **Evidence:** 21 tracked case(s); 0 cold failures; 0 polyfill failures; 21 fixed.
- **Current surface/gap:** 21 active-registration failure(s).
- **Required classification review:** 21 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (21)</summary>

- `spec/operators/distinctUntilKeyChanged-spec.ts:110:distinctUntilKeyChanged > should complete if source does not emit`
- `spec/operators/distinctUntilKeyChanged-spec.ts:121:distinctUntilKeyChanged > should emit if source emits single element only`
- `spec/operators/distinctUntilKeyChanged-spec.ts:133:distinctUntilKeyChanged > should emit if source is scalar`
- `spec/operators/distinctUntilKeyChanged-spec.ts:143:distinctUntilKeyChanged > should raise error if source raises error`
- `spec/operators/distinctUntilKeyChanged-spec.ts:15:distinctUntilKeyChanged > should distinguish between values`
- `spec/operators/distinctUntilKeyChanged-spec.ts:155:distinctUntilKeyChanged > should raise error if source throws`
- `spec/operators/distinctUntilKeyChanged-spec.ts:166:distinctUntilKeyChanged > should not omit if source elements are all different`
- `spec/operators/distinctUntilKeyChanged-spec.ts:178:distinctUntilKeyChanged > should allow unsubscribing early and explicitly`
- `spec/operators/distinctUntilKeyChanged-spec.ts:193:distinctUntilKeyChanged > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/distinctUntilKeyChanged-spec.ts:212:distinctUntilKeyChanged > should emit once if source elements are all same`
- `spec/operators/distinctUntilKeyChanged-spec.ts:224:distinctUntilKeyChanged > should emit once if comparer returns true always regardless of source emits`
- `spec/operators/distinctUntilKeyChanged-spec.ts:236:distinctUntilKeyChanged > should emit all if comparer returns false always regardless of source emits`
- `spec/operators/distinctUntilKeyChanged-spec.ts:248:distinctUntilKeyChanged > should distinguish values by selector`
- `spec/operators/distinctUntilKeyChanged-spec.ts:261:distinctUntilKeyChanged > should raise error when comparer throws`
- `spec/operators/distinctUntilKeyChanged-spec.ts:29:distinctUntilKeyChanged > should distinguish between values`
- `spec/operators/distinctUntilKeyChanged-spec.ts:41:distinctUntilKeyChanged > should distinguish between values and does not complete`
- `spec/operators/distinctUntilKeyChanged-spec.ts:53:distinctUntilKeyChanged > should distinguish between values with key`
- `spec/operators/distinctUntilKeyChanged-spec.ts:65:distinctUntilKeyChanged > should not compare if source does not have element with key`
- `spec/operators/distinctUntilKeyChanged-spec.ts:77:distinctUntilKeyChanged > should not complete if source never completes`
- `spec/operators/distinctUntilKeyChanged-spec.ts:88:distinctUntilKeyChanged > should not complete if source does not complete`
- `spec/operators/distinctUntilKeyChanged-spec.ts:99:distinctUntilKeyChanged > should complete if source is empty`

</details>

### RX7-FILTER — `filter`

- **Packet status:** `FIXED`
- **Evidence:** 21 tracked case(s); 0 cold failures; 0 polyfill failures; 21 fixed.
- **Current surface/gap:** 21 active-registration failure(s).
- **Required classification review:** 21 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (21)</summary>

- `spec/operators/filter-spec.ts:107:filter > should filter in only prime numbers, but predicate throws`
- `spec/operators/filter-spec.ts:127:filter > should filter in only prime numbers, predicate with index`
- `spec/operators/filter-spec.ts:142:filter > should invoke predicate once for each checked value`
- `spec/operators/filter-spec.ts:168:filter > should filter in only prime numbers, predicate with index, source unsubscribes early`
- `spec/operators/filter-spec.ts:184:filter > should filter in only prime numbers, predicate with index, source throws`
- `spec/operators/filter-spec.ts:199:filter > should filter in only prime numbers, predicate with index and throws`
- `spec/operators/filter-spec.ts:219:filter > should compose with another filter to allow multiples of six`
- `spec/operators/filter-spec.ts:235:filter > should be able to accept and use a thisArg`
- `spec/operators/filter-spec.ts:265:filter > should be able to use filter and map composed`
- `spec/operators/filter-spec.ts:282:filter > should propagate errors from the source`
- `spec/operators/filter-spec.ts:293:filter > should handle empty`
- `spec/operators/filter-spec.ts:304:filter > should handle never`
- `spec/operators/filter-spec.ts:315:filter > should handle throw`
- `spec/operators/filter-spec.ts:32:filter > should filter out even values`
- `spec/operators/filter-spec.ts:347:filter > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/filter-spec.ts:425:filter > should support Boolean as a predicate`
- `spec/operators/filter-spec.ts:43:filter > should filter in only prime numbers`
- `spec/operators/filter-spec.ts:54:filter > should filter with an always-true predicate`
- `spec/operators/filter-spec.ts:69:filter > should filter with an always-false predicate`
- `spec/operators/filter-spec.ts:84:filter > should filter in only prime numbers, source unsubscribes early`
- `spec/operators/filter-spec.ts:96:filter > should filter in only prime numbers, source throws`

</details>

### RX7-PUBLISH-REPLAY — `publishReplay`

- **Packet status:** `TODO`
- **Evidence:** 21 tracked case(s); 9 cold failures; 1 polyfill failures; 11 fixed.
- **Current surface/gap:** 9 known mapped mismatch(es); 12 active-registration failure(s).
- **Required classification review:** 6 portable; 11 harness rewrite; 4 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (21)</summary>

- `spec/operators/publishReplay-spec.ts:112:publishReplay operator > should multicast the same values to multiple observers, but is unsubscribed explicitly and early`
- `spec/operators/publishReplay-spec.ts:144:publishReplay operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/publishReplay-spec.ts:15:publishReplay operator > should mirror a simple source Observable`
- `spec/operators/publishReplay-spec.ts:180:publishReplay operator > with refCount() > should connect when first subscriber subscribes`
- `spec/operators/publishReplay-spec.ts:199:publishReplay operator > with refCount() > should disconnect when last subscriber unsubscribes`
- `spec/operators/publishReplay-spec.ts:217:publishReplay operator > with refCount() > should NOT be retryable`
- `spec/operators/publishReplay-spec.ts:236:publishReplay operator > with refCount() > should NOT be repeatable`
- `spec/operators/publishReplay-spec.ts:37:publishReplay operator > should do nothing if connect is not called, despite subscriptions`
- `spec/operators/publishReplay-spec.ts:409:publishReplay operator > should multicast an empty source`
- `spec/operators/publishReplay-spec.ts:423:publishReplay operator > should multicast a never source`
- `spec/operators/publishReplay-spec.ts:438:publishReplay operator > should multicast a throw source`
- `spec/operators/publishReplay-spec.ts:452:publishReplay operator > should mirror a simple source Observable with selector`
- `spec/operators/publishReplay-spec.ts:466:publishReplay operator > should EMIT an error when the selector throws an exception`
- `spec/operators/publishReplay-spec.ts:480:publishReplay operator > should emit an error when the selector returns an Observable that emits an error`
- `spec/operators/publishReplay-spec.ts:49:publishReplay operator > should multicast the same values to multiple observers, bufferSize=1`
- `spec/operators/publishReplay-spec.ts:495:publishReplay operator > should terminate immediately when the selector returns an empty Observable`
- `spec/operators/publishReplay-spec.ts:508:publishReplay operator > should not emit and should not complete/error when the selector returns never`
- `spec/operators/publishReplay-spec.ts:521:publishReplay operator > should emit error when the selector returns Observable.throw`
- `spec/operators/publishReplay-spec.ts:535:publishReplay operator > should be referentially-transparent`
- `spec/operators/publishReplay-spec.ts:70:publishReplay operator > should multicast the same values to multiple observers, bufferSize=2`
- `spec/operators/publishReplay-spec.ts:91:publishReplay operator > should multicast an error from the source to multiple observers`

</details>

### RX7-THROTTLE — `throttle`

- **Packet status:** `FIXED`
- **Evidence:** 21 tracked case(s); 0 cold failures; 0 polyfill failures; 21 fixed.
- **Current surface/gap:** 21 active-registration failure(s).
- **Required classification review:** 21 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (21)</summary>

- `spec/operators/throttle-spec.ts:106:throttle > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/throttle-spec.ts:127:throttle > should handle a busy producer emitting a regular repeating sequence`
- `spec/operators/throttle-spec.ts:149:throttle > should mirror source if durations are immediate`
- `spec/operators/throttle-spec.ts:15:throttle > should immediately emit the first value in each time window`
- `spec/operators/throttle-spec.ts:163:throttle > should mirror source if durations are empty`
- `spec/operators/throttle-spec.ts:177:throttle > should take only the first value emitted if duration is a never`
- `spec/operators/throttle-spec.ts:225:throttle > should throttle using durations of varying lengths`
- `spec/operators/throttle-spec.ts:256:throttle > should propagate error from duration Observable`
- `spec/operators/throttle-spec.ts:310:throttle > should complete when source does not emit`
- `spec/operators/throttle-spec.ts:340:throttle > should handle an empty source`
- `spec/operators/throttle-spec.ts:355:throttle > should handle a never source`
- `spec/operators/throttle-spec.ts:409:throttle > throttle(fn, { leading: true, trailing: true }) > should work for individual values`
- `spec/operators/throttle-spec.ts:446:throttle > throttle(fn, { leading: false, trailing: true }) > should immediately emit the first value in each time window`
- `spec/operators/throttle-spec.ts:469:throttle > throttle(fn, { leading: false, trailing: true }) > should work for individual values`
- `spec/operators/throttle-spec.ts:484:throttle > throttle(fn, { leading: false, trailing: true }) > should wait for trailing throttle before completing, even if source completes`
- `spec/operators/throttle-spec.ts:49:throttle > should simply mirror the source if values are not emitted often enough`
- `spec/operators/throttle-spec.ts:499:throttle > throttle(fn, { leading: false, trailing: true }) > should emit trailing value after throttle duration when source completes`
- `spec/operators/throttle-spec.ts:520:throttle > throttle(fn, { leading: false, trailing: true }) > should emit the last trailing value after throttle duration when source completes`
- `spec/operators/throttle-spec.ts:541:throttle > throttle(fn, { leading: false, trailing: true }) > should complete when source completes if no value is available`
- `spec/operators/throttle-spec.ts:69:throttle > should throttle with duration Observable using next to close the duration`
- `spec/operators/throttle-spec.ts:89:throttle > should interrupt source and duration when result is unsubscribed early`

</details>

### RX7-DISTINCT-UNTIL-CHANGED — `distinctUntilChanged`

- **Packet status:** `FIXED`
- **Evidence:** 22 tracked case(s); 0 cold failures; 0 polyfill failures; 22 fixed.
- **Current surface/gap:** 22 active-registration failure(s).
- **Required classification review:** 22 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (22)</summary>

- `spec/operators/distinctUntilChanged-spec.ts:103:distinctUntilChanged > should emit if source is scalar`
- `spec/operators/distinctUntilChanged-spec.ts:112:distinctUntilChanged > should raise error if source raises error`
- `spec/operators/distinctUntilChanged-spec.ts:123:distinctUntilChanged > should raise error if source throws`
- `spec/operators/distinctUntilChanged-spec.ts:134:distinctUntilChanged > should not omit if source elements are all different`
- `spec/operators/distinctUntilChanged-spec.ts:145:distinctUntilChanged > should allow unsubscribing early and explicitly`
- `spec/operators/distinctUntilChanged-spec.ts:15:distinctUntilChanged > should distinguish between values`
- `spec/operators/distinctUntilChanged-spec.ts:159:distinctUntilChanged > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/distinctUntilChanged-spec.ts:177:distinctUntilChanged > should emit once if source elements are all same`
- `spec/operators/distinctUntilChanged-spec.ts:188:distinctUntilChanged > should emit once if comparator returns true always regardless of source emits`
- `spec/operators/distinctUntilChanged-spec.ts:200:distinctUntilChanged > should emit all if comparator returns false always regardless of source emits`
- `spec/operators/distinctUntilChanged-spec.ts:212:distinctUntilChanged > should distinguish values by comparator`
- `spec/operators/distinctUntilChanged-spec.ts:224:distinctUntilChanged > should raise error when comparator throws`
- `spec/operators/distinctUntilChanged-spec.ts:241:distinctUntilChanged > should use the keySelector to pick comparator values`
- `spec/operators/distinctUntilChanged-spec.ts:254:distinctUntilChanged > should use the keySelector even for the first emit`
- `spec/operators/distinctUntilChanged-spec.ts:26:distinctUntilChanged > should distinguish between values`
- `spec/operators/distinctUntilChanged-spec.ts:266:distinctUntilChanged > should raise error when keySelector throws`
- `spec/operators/distinctUntilChanged-spec.ts:37:distinctUntilChanged > should distinguish between values and does not complete`
- `spec/operators/distinctUntilChanged-spec.ts:48:distinctUntilChanged > should not complete if source never completes`
- `spec/operators/distinctUntilChanged-spec.ts:59:distinctUntilChanged > should not complete if source does not complete`
- `spec/operators/distinctUntilChanged-spec.ts:70:distinctUntilChanged > should complete if source is empty`
- `spec/operators/distinctUntilChanged-spec.ts:81:distinctUntilChanged > should complete if source does not emit`
- `spec/operators/distinctUntilChanged-spec.ts:92:distinctUntilChanged > should emit if source emits single element only`

</details>

### RX7-EVERY — `every`

- **Packet status:** `FIXED`
- **Evidence:** 22 tracked case(s); 0 cold failures; 0 polyfill failures; 22 fixed.
- **Current surface/gap:** 22 active-registration failure(s).
- **Required classification review:** 22 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (22)</summary>

- `spec/operators/every-spec.ts:103:every > should emit false if single source element does not match with predicate`
- `spec/operators/every-spec.ts:114:every > should emit false if none of elements match with predicate`
- `spec/operators/every-spec.ts:125:every > should return false if only some of elements matches with predicate`
- `spec/operators/every-spec.ts:137:every > should allow unsubscribing early and explicitly`
- `spec/operators/every-spec.ts:152:every > should not break unsubscription chains when result observable is unsubscribed`
- `spec/operators/every-spec.ts:171:every > should propagate error if predicate eventually throws`
- `spec/operators/every-spec.ts:190:every > should emit true if single source element matches with predicate`
- `spec/operators/every-spec.ts:202:every > should emit true if scalar source matches with predicate`
- `spec/operators/every-spec.ts:211:every > should emit false if scalar source does not match with predicate`
- `spec/operators/every-spec.ts:220:every > should propagate error if predicate throws on scalar source`
- `spec/operators/every-spec.ts:23:every > should return false if only one of elements does not match with predicate`
- `spec/operators/every-spec.ts:233:every > should emit true if scalar array source matches with predicate`
- `spec/operators/every-spec.ts:242:every > should emit false if scalar array source does not match with predicate`
- `spec/operators/every-spec.ts:251:every > should propagate error if predicate eventually throws on scalar array source`
- `spec/operators/every-spec.ts:267:every > should emit true if all source elements match with predicate`
- `spec/operators/every-spec.ts:279:every > should raise error if source raises error`
- `spec/operators/every-spec.ts:290:every > should not complete if source never emits`
- `spec/operators/every-spec.ts:301:every > should emit true if source element matches with predicate after subscription`
- `spec/operators/every-spec.ts:313:every > should emit false if source element does not match with predicate after subscription`
- `spec/operators/every-spec.ts:325:every > should raise error if source raises error after subscription`
- `spec/operators/every-spec.ts:336:every > should emit true if source does not emit after subscription`
- `spec/operators/every-spec.ts:92:every > should emit true if source is empty`

</details>

### RX7-MULTICAST — `multicast`

- **Packet status:** `TODO`
- **Evidence:** 22 tracked case(s); 5 cold failures; 0 polyfill failures; 17 fixed.
- **Current surface/gap:** 5 known mapped mismatch(es); 17 active-registration failure(s).
- **Required classification review:** 3 portable; 19 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (22)</summary>

- `spec/operators/multicast-spec.ts:100:multicast > should accept a multicast selector and connect to a hot source for each subscriber`
- `spec/operators/multicast-spec.ts:127:multicast > should accept a multicast selector and connect to a cold source for each subscriber`
- `spec/operators/multicast-spec.ts:15:multicast > should mirror a simple source Observable`
- `spec/operators/multicast-spec.ts:155:multicast > should accept a multicast selector and respect the subject's messaging semantics`
- `spec/operators/multicast-spec.ts:186:multicast > should do nothing if connect is not called, despite subscriptions`
- `spec/operators/multicast-spec.ts:198:multicast > should multicast the same values to multiple observers`
- `spec/operators/multicast-spec.ts:219:multicast > should multicast an error from the source to multiple observers`
- `spec/operators/multicast-spec.ts:240:multicast > should multicast the same values to multiple observers, but is unsubscribed explicitly and early`
- `spec/operators/multicast-spec.ts:272:multicast > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/multicast-spec.ts:307:multicast > should multicast an empty source`
- `spec/operators/multicast-spec.ts:321:multicast > should multicast a never source`
- `spec/operators/multicast-spec.ts:335:multicast > should multicast a throw source`
- `spec/operators/multicast-spec.ts:350:multicast > with refCount() and subject factory > should connect when first subscriber subscribes`
- `spec/operators/multicast-spec.ts:371:multicast > with refCount() and subject factory > should disconnect when last subscriber unsubscribes`
- `spec/operators/multicast-spec.ts:391:multicast > with refCount() and subject factory > should be retryable when cold source is synchronous`
- `spec/operators/multicast-spec.ts:432:multicast > with refCount() and subject factory > should be retryable with ReplaySubject and cold source is synchronous`
- `spec/operators/multicast-spec.ts:473:multicast > with refCount() and subject factory > should be repeatable when cold source is synchronous`
- `spec/operators/multicast-spec.ts:516:multicast > with refCount() and subject factory > should be repeatable with ReplaySubject and cold source is synchronous`
- `spec/operators/multicast-spec.ts:559:multicast > with refCount() and subject factory > should be retryable`
- `spec/operators/multicast-spec.ts:597:multicast > with refCount() and subject factory > should be retryable using a ReplaySubject`
- `spec/operators/multicast-spec.ts:620:multicast > with refCount() and subject factory > should be repeatable`
- `spec/operators/multicast-spec.ts:656:multicast > with refCount() and subject factory > should be repeatable using a ReplaySubject`

</details>

### RX7-SINGLE — `single`

- **Packet status:** `FIXED`
- **Evidence:** 25 tracked case(s); 0 cold failures; 0 polyfill failures; 25 fixed.
- **Current surface/gap:** 25 active-registration failure(s).
- **Required classification review:** 25 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (25)</summary>

- `spec/operators/single-spec.ts:100:single operator > should raise error if predicate throws error`
- `spec/operators/single-spec.ts:120:single operator > should return element from predicate if observable have single matching element`
- `spec/operators/single-spec.ts:131:single operator > should raise error from predicate if observable have multiple matching element`
- `spec/operators/single-spec.ts:142:single operator > should raise error from predicate if observable does not emit`
- `spec/operators/single-spec.ts:15:single operator > should raise error from empty predicate if observable emits multiple time`
- `spec/operators/single-spec.ts:153:single operator > should raise error from predicate if observable does not contain matching element`
- `spec/operators/single-spec.ts:164:single operator > should call predicate with indices starting at 0`
- `spec/operators/single-spec.ts:190:single operator > should error for synchronous empty observables when no arguments are provided`
- `spec/operators/single-spec.ts:202:single operator > should error for async empty observables when no arguments are provided`
- `spec/operators/single-spec.ts:214:single operator > should error for hot observables that do not emit while active when no arguments are provided`
- `spec/operators/single-spec.ts:226:single operator > should error for synchronous empty observables when predicate never passes`
- `spec/operators/single-spec.ts:238:single operator > should error for async empty observables when predicate never passes`
- `spec/operators/single-spec.ts:250:single operator > should error for hot observables that do not emit while active when predicate never passes`
- `spec/operators/single-spec.ts:26:single operator > should raise error from empty predicate if observable does not emit`
- `spec/operators/single-spec.ts:262:single operator > should error for synchronous observables that emit when predicate never passes`
- `spec/operators/single-spec.ts:274:single operator > should error for async observables that emit when predicate never passes`
- `spec/operators/single-spec.ts:286:single operator > should error for hot observables that emit while active when predicate never passes`
- `spec/operators/single-spec.ts:298:single operator > should error for synchronous observables when the predicate passes more than once`
- `spec/operators/single-spec.ts:310:single operator > should error for async observables that emit when the predicate passes more than once`
- `spec/operators/single-spec.ts:322:single operator > should error for hot observables that emit while active when the predicate passes more than once`
- `spec/operators/single-spec.ts:37:single operator > should return only element from empty predicate if observable emits only once`
- `spec/operators/single-spec.ts:48:single operator > should allow unsubscribing explicitly and early`
- `spec/operators/single-spec.ts:60:single operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/single-spec.ts:78:single operator > should raise error from empty predicate if observable emits error`
- `spec/operators/single-spec.ts:89:single operator > should raise error from predicate if observable emits error`

</details>

### RX7-ZIP — `zip`

- **Packet status:** `FIXED`
- **Evidence:** 28 tracked case(s); 0 cold failures; 0 polyfill failures; 28 fixed.
- **Current surface/gap:** 28 active-registration failure(s).
- **Required classification review:** 28 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (28)</summary>

- `spec/observables/zip-spec.ts:136:zip > with iterables > should complete instantly if given an empty iterable`
- `spec/observables/zip-spec.ts:148:zip > with iterables > should work with never observable and non-empty iterable`
- `spec/observables/zip-spec.ts:160:zip > with iterables > should work with non-empty observable and non-empty iterable`
- `spec/observables/zip-spec.ts:17:zip > should combine a source with a second`
- `spec/observables/zip-spec.ts:184:zip > with iterables > should work with non-empty many observable and non-empty many iterable`
- `spec/observables/zip-spec.ts:196:zip > with iterables > should work with non-empty observable and non-empty iterable selector that throws`
- `spec/observables/zip-spec.ts:216:zip > should combine two observables and selector`
- `spec/observables/zip-spec.ts:230:zip > should work with n-ary symmetric`
- `spec/observables/zip-spec.ts:245:zip > should work with n-ary symmetric selector`
- `spec/observables/zip-spec.ts:261:zip > should work with n-ary symmetric array selector`
- `spec/observables/zip-spec.ts:277:zip > should work with some data asymmetric 1`
- `spec/observables/zip-spec.ts:291:zip > should work with some data asymmetric 2`
- `spec/observables/zip-spec.ts:305:zip > should work with some data symmetric`
- `spec/observables/zip-spec.ts:319:zip > should work with selector throws`
- `spec/observables/zip-spec.ts:341:zip > should work with right completes first`
- `spec/observables/zip-spec.ts:355:zip > should work with two nevers`
- `spec/observables/zip-spec.ts:369:zip > should work with never and empty`
- `spec/observables/zip-spec.ts:383:zip > should work with empty and never`
- `spec/observables/zip-spec.ts:411:zip > should work with empty and non-empty`
- `spec/observables/zip-spec.ts:425:zip > should work with non-empty and empty`
- `spec/observables/zip-spec.ts:43:zip > should end once one observable completes and its buffer is empty`
- `spec/observables/zip-spec.ts:439:zip > should work with never and non-empty`
- `spec/observables/zip-spec.ts:453:zip > should work with non-empty and never`
- `spec/observables/zip-spec.ts:467:zip > should work with empty and error`
- `spec/observables/zip-spec.ts:481:zip > should work with error and empty`
- `spec/observables/zip-spec.ts:65:zip > should end once one observable nexts and zips value from completed other observable whose buffer is empty`
- `spec/observables/zip-spec.ts:88:zip > with iterables > should zip them with values`
- `spec/operators/zip-spec.ts:13:zip > should work with non-empty observable and non-empty iterable selector that throws`

</details>

### RX7-COMBINE-LATEST-WITH — `combineLatestWith`

- **Packet status:** `FIXED`
- **Evidence:** 30 tracked case(s); 0 cold failures; 0 polyfill failures; 30 fixed.
- **Current surface/gap:** 30 active-registration failure(s).
- **Required classification review:** 30 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (30)</summary>

- `spec/operators/combineLatestWith-spec.ts:114:combineLatestWith > should work with hot-empty and hot-single`
- `spec/operators/combineLatestWith-spec.ts:139:combineLatestWith > should work with hot-single and hot-empty`
- `spec/operators/combineLatestWith-spec.ts:14:combineLatestWith > should combine events from two cold observables`
- `spec/operators/combineLatestWith-spec.ts:163:combineLatestWith > should work with hot-single and never`
- `spec/operators/combineLatestWith-spec.ts:185:combineLatestWith > should work with never and hot-single`
- `spec/operators/combineLatestWith-spec.ts:208:combineLatestWith > should work with hot and hot`
- `spec/operators/combineLatestWith-spec.ts:227:combineLatestWith > should work with empty and error`
- `spec/operators/combineLatestWith-spec.ts:246:combineLatestWith > should work with error and empty`
- `spec/operators/combineLatestWith-spec.ts:265:combineLatestWith > should work with hot and throw`
- `spec/operators/combineLatestWith-spec.ts:284:combineLatestWith > should work with throw and hot`
- `spec/operators/combineLatestWith-spec.ts:303:combineLatestWith > should work with throw and throw`
- `spec/operators/combineLatestWith-spec.ts:322:combineLatestWith > should work with error and throw`
- `spec/operators/combineLatestWith-spec.ts:341:combineLatestWith > should work with throw and error`
- `spec/operators/combineLatestWith-spec.ts:360:combineLatestWith > should work with never and throw`
- `spec/operators/combineLatestWith-spec.ts:379:combineLatestWith > should work with throw and never`
- `spec/operators/combineLatestWith-spec.ts:38:combineLatestWith > should work with two nevers`
- `spec/operators/combineLatestWith-spec.ts:398:combineLatestWith > should work with some and throw`
- `spec/operators/combineLatestWith-spec.ts:417:combineLatestWith > should work with throw and some`
- `spec/operators/combineLatestWith-spec.ts:436:combineLatestWith > should handle throw after complete left`
- `spec/operators/combineLatestWith-spec.ts:455:combineLatestWith > should handle throw after complete right`
- `spec/operators/combineLatestWith-spec.ts:474:combineLatestWith > should handle interleaved with tail`
- `spec/operators/combineLatestWith-spec.ts:493:combineLatestWith > should handle two consecutive hot observables`
- `spec/operators/combineLatestWith-spec.ts:512:combineLatestWith > should handle two consecutive hot observables with error left`
- `spec/operators/combineLatestWith-spec.ts:531:combineLatestWith > should handle two consecutive hot observables with error right`
- `spec/operators/combineLatestWith-spec.ts:550:combineLatestWith > should allow unsubscribing early and explicitly`
- `spec/operators/combineLatestWith-spec.ts:57:combineLatestWith > should work with never and empty`
- `spec/operators/combineLatestWith-spec.ts:571:combineLatestWith > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/combineLatestWith-spec.ts:594:combineLatestWith > should emit unique array instances with the default projection`
- `spec/operators/combineLatestWith-spec.ts:76:combineLatestWith > should work with empty and never`
- `spec/operators/combineLatestWith-spec.ts:95:combineLatestWith > should work with empty and empty`

</details>

### RX7-COMBINE-LATEST-ALL — `combineLatestAll`

- **Packet status:** `FIXED`
- **Evidence:** 31 tracked case(s); 0 cold failures; 0 polyfill failures; 31 fixed.
- **Current surface/gap:** 31 active-registration failure(s).
- **Required classification review:** 31 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (31)</summary>

- `spec/operators/combineLatestAll-spec.ts:108:combineLatestAll operator > should work with hot-single and hot-empty`
- `spec/operators/combineLatestAll-spec.ts:124:combineLatestAll operator > should work with hot-single and never`
- `spec/operators/combineLatestAll-spec.ts:140:combineLatestAll operator > should work with never and hot-single`
- `spec/operators/combineLatestAll-spec.ts:15:combineLatestAll operator > should combine events from two observables`
- `spec/operators/combineLatestAll-spec.ts:156:combineLatestAll operator > should work with hot and hot`
- `spec/operators/combineLatestAll-spec.ts:172:combineLatestAll operator > should allow unsubscribing early and explicitly`
- `spec/operators/combineLatestAll-spec.ts:190:combineLatestAll operator > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/combineLatestAll-spec.ts:212:combineLatestAll operator > should combine 3 observables`
- `spec/operators/combineLatestAll-spec.ts:231:combineLatestAll operator > should work with empty and error`
- `spec/operators/combineLatestAll-spec.ts:247:combineLatestAll operator > should work with error and empty`
- `spec/operators/combineLatestAll-spec.ts:263:combineLatestAll operator > should work with hot and throw`
- `spec/operators/combineLatestAll-spec.ts:279:combineLatestAll operator > should work with throw and hot`
- `spec/operators/combineLatestAll-spec.ts:28:combineLatestAll operator > should work with two nevers`
- `spec/operators/combineLatestAll-spec.ts:295:combineLatestAll operator > should work with throw and throw`
- `spec/operators/combineLatestAll-spec.ts:311:combineLatestAll operator > should work with error and throw`
- `spec/operators/combineLatestAll-spec.ts:327:combineLatestAll operator > should work with throw and error`
- `spec/operators/combineLatestAll-spec.ts:343:combineLatestAll operator > should work with never and throw`
- `spec/operators/combineLatestAll-spec.ts:359:combineLatestAll operator > should work with throw and never`
- `spec/operators/combineLatestAll-spec.ts:375:combineLatestAll operator > should work with some and throw`
- `spec/operators/combineLatestAll-spec.ts:391:combineLatestAll operator > should work with throw and some`
- `spec/operators/combineLatestAll-spec.ts:407:combineLatestAll operator > should handle throw after complete left`
- `spec/operators/combineLatestAll-spec.ts:423:combineLatestAll operator > should handle throw after complete right`
- `spec/operators/combineLatestAll-spec.ts:439:combineLatestAll operator > should handle interleaved with tail`
- `spec/operators/combineLatestAll-spec.ts:44:combineLatestAll operator > should work with never and empty`
- `spec/operators/combineLatestAll-spec.ts:455:combineLatestAll operator > should handle two consecutive hot observables`
- `spec/operators/combineLatestAll-spec.ts:471:combineLatestAll operator > should handle two consecutive hot observables with error left`
- `spec/operators/combineLatestAll-spec.ts:487:combineLatestAll operator > should handle two consecutive hot observables with error right`
- `spec/operators/combineLatestAll-spec.ts:503:combineLatestAll operator > should handle selector throwing`
- `spec/operators/combineLatestAll-spec.ts:60:combineLatestAll operator > should work with empty and never`
- `spec/operators/combineLatestAll-spec.ts:76:combineLatestAll operator > should work with empty and empty`
- `spec/operators/combineLatestAll-spec.ts:92:combineLatestAll operator > should work with hot-empty and hot-single`

</details>

### RX7-COMBINE-LATEST-LEGACY — `combineLatest-legacy`

- **Packet status:** `FIXED`
- **Evidence:** 32 tracked case(s); 0 cold failures; 0 polyfill failures; 32 fixed.
- **Current surface/gap:** 32 active-registration failure(s).
- **Required classification review:** 32 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (32)</summary>

- `spec/operators/combineLatest-legacy-spec.ts:121:combineLatest > should work with hot-single and hot-empty`
- `spec/operators/combineLatest-legacy-spec.ts:14:combineLatest > should combine events from two cold observables`
- `spec/operators/combineLatest-legacy-spec.ts:142:combineLatest > should work with hot-single and never`
- `spec/operators/combineLatest-legacy-spec.ts:161:combineLatest > should work with never and hot-single`
- `spec/operators/combineLatest-legacy-spec.ts:181:combineLatest > should work with hot and hot`
- `spec/operators/combineLatest-legacy-spec.ts:197:combineLatest > should accept array of observables`
- `spec/operators/combineLatest-legacy-spec.ts:216:combineLatest > should work with empty and error`
- `spec/operators/combineLatest-legacy-spec.ts:232:combineLatest > should work with error and empty`
- `spec/operators/combineLatest-legacy-spec.ts:248:combineLatest > should work with hot and throw`
- `spec/operators/combineLatest-legacy-spec.ts:264:combineLatest > should work with throw and hot`
- `spec/operators/combineLatest-legacy-spec.ts:280:combineLatest > should work with throw and throw`
- `spec/operators/combineLatest-legacy-spec.ts:296:combineLatest > should work with error and throw`
- `spec/operators/combineLatest-legacy-spec.ts:312:combineLatest > should work with throw and error`
- `spec/operators/combineLatest-legacy-spec.ts:328:combineLatest > should work with never and throw`
- `spec/operators/combineLatest-legacy-spec.ts:344:combineLatest > should work with throw and never`
- `spec/operators/combineLatest-legacy-spec.ts:35:combineLatest > should work with two nevers`
- `spec/operators/combineLatest-legacy-spec.ts:360:combineLatest > should work with some and throw`
- `spec/operators/combineLatest-legacy-spec.ts:376:combineLatest > should work with throw and some`
- `spec/operators/combineLatest-legacy-spec.ts:392:combineLatest > should handle throw after complete left`
- `spec/operators/combineLatest-legacy-spec.ts:408:combineLatest > should handle throw after complete right`
- `spec/operators/combineLatest-legacy-spec.ts:424:combineLatest > should handle interleaved with tail`
- `spec/operators/combineLatest-legacy-spec.ts:440:combineLatest > should handle two consecutive hot observables`
- `spec/operators/combineLatest-legacy-spec.ts:456:combineLatest > should handle two consecutive hot observables with error left`
- `spec/operators/combineLatest-legacy-spec.ts:472:combineLatest > should handle two consecutive hot observables with error right`
- `spec/operators/combineLatest-legacy-spec.ts:488:combineLatest > should handle selector throwing`
- `spec/operators/combineLatest-legacy-spec.ts:508:combineLatest > should allow unsubscribing early and explicitly`
- `spec/operators/combineLatest-legacy-spec.ts:51:combineLatest > should work with never and empty`
- `spec/operators/combineLatest-legacy-spec.ts:526:combineLatest > should not break unsubscription chains when unsubscribed explicitly`
- `spec/operators/combineLatest-legacy-spec.ts:548:combineLatest > should emit unique array instances with the default projection`
- `spec/operators/combineLatest-legacy-spec.ts:67:combineLatest > should work with empty and never`
- `spec/operators/combineLatest-legacy-spec.ts:83:combineLatest > should work with empty and empty`
- `spec/operators/combineLatest-legacy-spec.ts:99:combineLatest > should work with hot-empty and hot-single`

</details>

### RX7-ZIP-WITH — `zipWith`

- **Packet status:** `FIXED`
- **Evidence:** 32 tracked case(s); 0 cold failures; 0 polyfill failures; 32 fixed.
- **Current surface/gap:** 32 active-registration failure(s).
- **Required classification review:** 32 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (32)</summary>

- `spec/operators/zipWith-spec.ts:109:zipWith > with iterables > should work with empty observable and empty iterable`
- `spec/operators/zipWith-spec.ts:121:zipWith > with iterables > should work with empty observable and non-empty iterable`
- `spec/operators/zipWith-spec.ts:133:zipWith > with iterables > should complete instantly with non-empty observable and empty iterable`
- `spec/operators/zipWith-spec.ts:145:zipWith > with iterables > should work with never observable and non-empty iterable`
- `spec/operators/zipWith-spec.ts:15:zipWith > should combine a source with a second`
- `spec/operators/zipWith-spec.ts:157:zipWith > with iterables > should work with non-empty observable and non-empty iterable`
- `spec/operators/zipWith-spec.ts:169:zipWith > with iterables > should work with observable which raises error and non-empty iterable`
- `spec/operators/zipWith-spec.ts:181:zipWith > with iterables > should work with non-empty many observable and non-empty many iterable`
- `spec/operators/zipWith-spec.ts:194:zipWith > should work with n-ary symmetric`
- `spec/operators/zipWith-spec.ts:209:zipWith > should work with right completes first`
- `spec/operators/zipWith-spec.ts:223:zipWith > should work with two nevers`
- `spec/operators/zipWith-spec.ts:237:zipWith > should work with never and empty`
- `spec/operators/zipWith-spec.ts:251:zipWith > should work with empty and never`
- `spec/operators/zipWith-spec.ts:265:zipWith > should work with empty and empty`
- `spec/operators/zipWith-spec.ts:279:zipWith > should work with empty and non-empty`
- `spec/operators/zipWith-spec.ts:28:zipWith > should end once one observable completes and its buffer is empty`
- `spec/operators/zipWith-spec.ts:293:zipWith > should work with non-empty and empty`
- `spec/operators/zipWith-spec.ts:307:zipWith > should work with never and non-empty`
- `spec/operators/zipWith-spec.ts:321:zipWith > should work with non-empty and never`
- `spec/operators/zipWith-spec.ts:335:zipWith > should work with empty and error`
- `spec/operators/zipWith-spec.ts:349:zipWith > should work with error and empty`
- `spec/operators/zipWith-spec.ts:363:zipWith > should work with error`
- `spec/operators/zipWith-spec.ts:377:zipWith > should work with never and error`
- `spec/operators/zipWith-spec.ts:391:zipWith > should work with error and never`
- `spec/operators/zipWith-spec.ts:405:zipWith > should work with error and error`
- `spec/operators/zipWith-spec.ts:419:zipWith > should work with two sources that eventually raise errors`
- `spec/operators/zipWith-spec.ts:433:zipWith > should work with two sources that eventually raise errors (swapped)`
- `spec/operators/zipWith-spec.ts:447:zipWith > should work with error and some`
- `spec/operators/zipWith-spec.ts:479:zipWith > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/zipWith-spec.ts:50:zipWith > should end once one observable nexts and zips value from completed other observable whose buffer is empty`
- `spec/operators/zipWith-spec.ts:73:zipWith > with iterables > should zip them with values`
- `spec/operators/zipWith-spec.ts:97:zipWith > with iterables > should complete instantly for an empty iterable`

</details>

### RX7-GROUP-BY — `groupBy`

- **Packet status:** `TODO`
- **Evidence:** 36 tracked case(s); 1 cold failures; 0 polyfill failures; 35 fixed.
- **Current surface/gap:** 2 known mapped mismatch(es); 34 active-registration failure(s).
- **Required classification review:** 24 portable; 12 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (36)</summary>

- `spec/operators/groupBy-spec.ts:1005:groupBy operator > should allow using a durationSelector, but keySelector throws`
- `spec/operators/groupBy-spec.ts:1051:groupBy operator > should allow using a durationSelector, but elementSelector throws`
- `spec/operators/groupBy-spec.ts:1097:groupBy operator > should allow using a durationSelector which eventually throws`
- `spec/operators/groupBy-spec.ts:1142:groupBy operator > should allow an inner to be unsubscribed early but other inners continue, with durationSelector`
- `spec/operators/groupBy-spec.ts:1206:groupBy operator > should allow inners to be unsubscribed early at different times, with durationSelector`
- `spec/operators/groupBy-spec.ts:1280:groupBy operator > should return inners that when subscribed late exhibit hot behavior`
- `spec/operators/groupBy-spec.ts:1346:groupBy operator > should return inner group that when subscribed late emits complete()`
- `spec/operators/groupBy-spec.ts:1391:groupBy operator > should return inner group that when subscribed late emits error()`
- `spec/operators/groupBy-spec.ts:1436:groupBy operator > should not error for late subscribed inners if outer is unsubscribed before inners are subscribed`
- `spec/operators/groupBy-spec.ts:147:groupBy operator > should handle an empty Observable`
- `spec/operators/groupBy-spec.ts:16:groupBy operator > should group numbers by odd/even`
- `spec/operators/groupBy-spec.ts:160:groupBy operator > should handle a never Observable`
- `spec/operators/groupBy-spec.ts:173:groupBy operator > should handle a just-throw Observable`
- `spec/operators/groupBy-spec.ts:186:groupBy operator > should handle an Observable with a single value`
- `spec/operators/groupBy-spec.ts:202:groupBy operator > should group values with a keySelector`
- `spec/operators/groupBy-spec.ts:234:groupBy operator > should emit GroupObservables`
- `spec/operators/groupBy-spec.ts:261:groupBy operator > should group values with a keySelector, assert GroupSubject key`
- `spec/operators/groupBy-spec.ts:292:groupBy operator > should group values with a keySelector, but outer throws`
- `spec/operators/groupBy-spec.ts:323:groupBy operator > should group values with a keySelector, inners propagate error from outer`
- `spec/operators/groupBy-spec.ts:355:groupBy operator > should allow outer to be unsubscribed early`
- `spec/operators/groupBy-spec.ts:387:groupBy operator > should unsubscribe from the source when the outer and inner subscriptions are disposed`
- `spec/operators/groupBy-spec.ts:418:groupBy operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/groupBy-spec.ts:451:groupBy operator > should group values with a keySelector which eventually throws`
- `spec/operators/groupBy-spec.ts:492:groupBy operator > should group values with a keySelector and elementSelector, but elementSelector throws`
- `spec/operators/groupBy-spec.ts:537:groupBy operator > should allow the outer to be unsubscribed early but inners continue`
- `spec/operators/groupBy-spec.ts:566:groupBy operator > should allow an inner to be unsubscribed early but other inners continue`
- `spec/operators/groupBy-spec.ts:621:groupBy operator > should allow inners to be unsubscribed early at different times`
- `spec/operators/groupBy-spec.ts:682:groupBy operator > should allow subscribing late to an inner Observable, outer completes`
- `spec/operators/groupBy-spec.ts:705:groupBy operator > should allow subscribing late to an inner Observable, outer throws`
- `spec/operators/groupBy-spec.ts:733:groupBy operator > should allow subscribing late to inner, unsubscribe outer early`
- `spec/operators/groupBy-spec.ts:767:groupBy operator > should allow using a keySelector, elementSelector, and durationSelector`
- `spec/operators/groupBy-spec.ts:807:groupBy operator > should allow using a keySelector, elementSelector, and durationSelector that throws`
- `spec/operators/groupBy-spec.ts:850:groupBy operator > should allow using a keySelector and a durationSelector, outer throws`
- `spec/operators/groupBy-spec.ts:887:groupBy operator > should allow using a durationSelector, and outer unsubscribed early`
- `spec/operators/groupBy-spec.ts:921:groupBy operator > should allow using a durationSelector, outer and all inners unsubscribed early`
- `spec/operators/groupBy-spec.ts:974:groupBy operator > should dispose a durationSelector after closing the group`

</details>

### RX7-TIMEOUT — `timeout`

- **Packet status:** `FIXED`
- **Evidence:** 38 tracked case(s); 0 cold failures; 0 polyfill failures; 38 fixed.
- **Current surface/gap:** 38 active-registration failure(s).
- **Required classification review:** 38 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (38)</summary>

- `spec/operators/timeout-spec.ts:106:timeout operator > should not timeout if source emits within timeout period`
- `spec/operators/timeout-spec.ts:118:timeout operator > should allow unsubscribing explicitly and early`
- `spec/operators/timeout-spec.ts:133:timeout operator > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/timeout-spec.ts:152:timeout operator > should timeout after a specified timeout period between emit with default error while source emits`
- `spec/operators/timeout-spec.ts:166:timeout operator > should timeout at a specified Date`
- `spec/operators/timeout-spec.ts:17:timeout operator > should timeout after a specified timeout period`
- `spec/operators/timeout-spec.ts:188:timeout operator > config > should timeout after a specified timeout period`
- `spec/operators/timeout-spec.ts:206:timeout operator > config > should emit and TimeoutError on timeout with appropriate due as number`
- `spec/operators/timeout-spec.ts:234:timeout operator > config > should emit and TimeoutError on timeout with appropriate due as Date`
- `spec/operators/timeout-spec.ts:266:timeout operator > config > should not timeout if source completes within absolute timeout period`
- `spec/operators/timeout-spec.ts:278:timeout operator > config > should not timeout if source emits within timeout period`
- `spec/operators/timeout-spec.ts:290:timeout operator > config > should allow unsubscribing explicitly and early`
- `spec/operators/timeout-spec.ts:305:timeout operator > config > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/timeout-spec.ts:31:timeout operator > should emit and TimeoutError on timeout with appropriate due as number`
- `spec/operators/timeout-spec.ts:324:timeout operator > config > should timeout after a specified timeout period between emit with default error while source emits`
- `spec/operators/timeout-spec.ts:338:timeout operator > config > should timeout at a specified Date`
- `spec/operators/timeout-spec.ts:353:timeout operator > config > should timeout at a specified time for first value only`
- `spec/operators/timeout-spec.ts:368:timeout operator > config > should not timeout for long delays if only first is specified`
- `spec/operators/timeout-spec.ts:383:timeout operator > config > should not timeout for long delays if only first is specified as Date`
- `spec/operators/timeout-spec.ts:398:timeout operator > config > should timeout for long delays if first is specified as Date AND each is specified`
- `spec/operators/timeout-spec.ts:416:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable`
- `spec/operators/timeout-spec.ts:438:timeout operator > using with > should timeout at a specified date then subscribe to the passed observable`
- `spec/operators/timeout-spec.ts:461:timeout operator > using with > should timeout after a specified period between emit then subscribe to the passed observable when source emits`
- `spec/operators/timeout-spec.ts:483:timeout operator > using with > should allow unsubscribing explicitly and early`
- `spec/operators/timeout-spec.ts:501:timeout operator > using with > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/timeout-spec.ts:523:timeout operator > using with > should not subscribe to withObservable after explicit unsubscription`
- `spec/operators/timeout-spec.ts:544:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable when source is empty`
- `spec/operators/timeout-spec.ts:561:timeout operator > using with > should timeout after a specified period between emit then never completes if other source does not complete`
- `spec/operators/timeout-spec.ts:578:timeout operator > using with > should timeout after a specified period then subscribe to the passed observable when source raises error after timeout`
- `spec/operators/timeout-spec.ts:59:timeout operator > should emit and TimeoutError on timeout with appropriate due as Date`
- `spec/operators/timeout-spec.ts:595:timeout operator > using with > should timeout after a specified period between emit then never completes if other source emits but not complete`
- `spec/operators/timeout-spec.ts:612:timeout operator > using with > should not timeout if source completes within timeout period`
- `spec/operators/timeout-spec.ts:628:timeout operator > using with > should not timeout if source raises error within timeout period`
- `spec/operators/timeout-spec.ts:644:timeout operator > using with > should not timeout if source emits within timeout period`
- `spec/operators/timeout-spec.ts:660:timeout operator > using with > should not timeout if source completes within specified Date`
- `spec/operators/timeout-spec.ts:677:timeout operator > using with > should not timeout if source raises error within specified Date`
- `spec/operators/timeout-spec.ts:694:timeout operator > using with > should not timeout if source emits synchronously when subscribed`
- `spec/operators/timeout-spec.ts:91:timeout operator > should not timeout if source completes within absolute timeout period`

</details>

### RX7-ZIP-ALL — `zipAll`

- **Packet status:** `FIXED`
- **Evidence:** 47 tracked case(s); 0 cold failures; 0 polyfill failures; 47 fixed.
- **Current surface/gap:** 47 active-registration failure(s).
- **Required classification review:** 47 portable. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (47)</summary>

- `spec/operators/zipAll-spec.ts:101:zipAll operator > with iterables > should zip them with values`
- `spec/operators/zipAll-spec.ts:125:zipAll operator > with iterables > should complete instantly with never observable and empty iterable`
- `spec/operators/zipAll-spec.ts:137:zipAll operator > with iterables > should work with empty observable and empty iterable`
- `spec/operators/zipAll-spec.ts:149:zipAll operator > with iterables > should work with empty observable and non-empty iterable`
- `spec/operators/zipAll-spec.ts:15:zipAll operator > should combine paired events from two observables`
- `spec/operators/zipAll-spec.ts:161:zipAll operator > with iterables > should work with non-empty observable and empty iterable`
- `spec/operators/zipAll-spec.ts:173:zipAll operator > with iterables > should work with never observable and non-empty iterable`
- `spec/operators/zipAll-spec.ts:185:zipAll operator > with iterables > should work with non-empty observable and non-empty iterable`
- `spec/operators/zipAll-spec.ts:197:zipAll operator > with iterables > should work with observable which raises error and non-empty iterable`
- `spec/operators/zipAll-spec.ts:209:zipAll operator > with iterables > should work with non-empty many observable and non-empty many iterable`
- `spec/operators/zipAll-spec.ts:221:zipAll operator > with iterables > should work with non-empty observable and non-empty iterable selector that throws`
- `spec/operators/zipAll-spec.ts:241:zipAll operator > should combine two observables and selector`
- `spec/operators/zipAll-spec.ts:255:zipAll operator > should work with n-ary symmetric`
- `spec/operators/zipAll-spec.ts:270:zipAll operator > should work with n-ary symmetric selector`
- `spec/operators/zipAll-spec.ts:28:zipAll operator > should combine two observables`
- `spec/operators/zipAll-spec.ts:286:zipAll operator > should work with n-ary symmetric array selector`
- `spec/operators/zipAll-spec.ts:302:zipAll operator > should work with some data asymmetric 1`
- `spec/operators/zipAll-spec.ts:316:zipAll operator > should work with some data asymmetric 2`
- `spec/operators/zipAll-spec.ts:330:zipAll operator > should work with some data symmetric`
- `spec/operators/zipAll-spec.ts:344:zipAll operator > should work with selector throws`
- `spec/operators/zipAll-spec.ts:367:zipAll operator > should work with right completes first`
- `spec/operators/zipAll-spec.ts:394:zipAll operator > should handle a hot observable of observables`
- `spec/operators/zipAll-spec.ts:416:zipAll operator > should handle merging a hot observable of non-overlapped observables`
- `spec/operators/zipAll-spec.ts:440:zipAll operator > should raise error if inner observable raises error`
- `spec/operators/zipAll-spec.ts:465:zipAll operator > should raise error if outer observable raises error`
- `spec/operators/zipAll-spec.ts:478:zipAll operator > should work with two nevers`
- `spec/operators/zipAll-spec.ts:492:zipAll operator > should work with never and empty`
- `spec/operators/zipAll-spec.ts:506:zipAll operator > should work with empty and never`
- `spec/operators/zipAll-spec.ts:520:zipAll operator > should work with empty and empty`
- `spec/operators/zipAll-spec.ts:534:zipAll operator > should work with empty and non-empty`
- `spec/operators/zipAll-spec.ts:548:zipAll operator > should work with non-empty and empty`
- `spec/operators/zipAll-spec.ts:56:zipAll operator > should end once one observable completes and its buffer is empty`
- `spec/operators/zipAll-spec.ts:562:zipAll operator > should work with never and non-empty`
- `spec/operators/zipAll-spec.ts:576:zipAll operator > should work with non-empty and never`
- `spec/operators/zipAll-spec.ts:590:zipAll operator > should combine a source with a second`
- `spec/operators/zipAll-spec.ts:604:zipAll operator > should work with empty and error`
- `spec/operators/zipAll-spec.ts:618:zipAll operator > should work with error and empty`
- `spec/operators/zipAll-spec.ts:632:zipAll operator > should work with error`
- `spec/operators/zipAll-spec.ts:646:zipAll operator > should work with never and error`
- `spec/operators/zipAll-spec.ts:660:zipAll operator > should work with error and never`
- `spec/operators/zipAll-spec.ts:674:zipAll operator > should work with error and error`
- `spec/operators/zipAll-spec.ts:688:zipAll operator > should work with two sources that eventually raise errors`
- `spec/operators/zipAll-spec.ts:702:zipAll operator > should work with two sources that eventually raise errors (swapped)`
- `spec/operators/zipAll-spec.ts:716:zipAll operator > should work with error and some`
- `spec/operators/zipAll-spec.ts:772:zipAll operator > should not break unsubscription chain when unsubscribed explicitly`
- `spec/operators/zipAll-spec.ts:78:zipAll operator > should end once one observable nexts and zips value from completed other observable whose buffer is empty`
- `spec/operators/zipAll-spec.ts:794:zipAll operator > should complete when empty source`

</details>

### RX7-MULTICASTING-DEPRECATIONS — `multicasting-deprecations`

- **Packet status:** `TODO`
- **Evidence:** 48 tracked case(s); 0 cold failures; 2 polyfill failures; 46 fixed.
- **Current surface/gap:** 48 known mapped mismatch(es).
- **Required classification review:** 48 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (48)</summary>

- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that retry [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:107:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:116:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that repeat [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:125:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that retry [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that retry [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that retry [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:134:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that retry [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:89:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for multicast(() => new Subject()), refCount() and share() for async sources that repeat [equivalence-0:multicast(() => new Subject()), refCount() and share()]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-1:multicast(new Subject()), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-2:publish(), refCount() and share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publish(fn) and connect({ setup: fn }) for async sources that repeat [equivalence-6:publish(fn) and connect({ setup: fn })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-4:publishBehavior("X"), refCount() and share({ connector: () => new BehaviorSubject("X"), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-3:publishLast(), refCount() and share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\` for async sources that repeat [equivalence-7:publishReplay(3, 10, fn) and \`subject = new ReplaySubject(3, 10), connect({ connector: () => subject , setup: fn })\`]`
- `spec/deprecation-equivalents/multicasting-deprecations-spec.ts:98:should be equivalent for publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }) for async sources that repeat [equivalence-5:publishReplay(3, 10), refCount() and share({ connector: () => new ReplaySubject(3, 10), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })]`

</details>

### RX7-TEST-SCHEDULER — `TestScheduler`

- **Packet status:** `FIXED`
- **Evidence:** 54 tracked case(s); 0 cold failures; 0 polyfill failures; 54 fixed.
- **Current surface/gap:** 54 active-registration failure(s).
- **Required classification review:** 54 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (54)</summary>

- `spec/schedulers/TestScheduler-spec.ts:102:TestScheduler > parseMarbles() > should support emoji characters`
- `spec/schedulers/TestScheduler-spec.ts:114:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string into a subscriptionLog`
- `spec/schedulers/TestScheduler-spec.ts:120:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string with an unsubscription`
- `spec/schedulers/TestScheduler-spec.ts:126:TestScheduler > parseMarblesAsSubscriptions() > should parse a subscription marble string with a synchronous unsubscription`
- `spec/schedulers/TestScheduler-spec.ts:132:TestScheduler > parseMarblesAsSubscriptions() > should ignore whitespace when runMode=true`
- `spec/schedulers/TestScheduler-spec.ts:139:TestScheduler > parseMarblesAsSubscriptions() > should support time progression syntax when runMode=true`
- `spec/schedulers/TestScheduler-spec.ts:146:TestScheduler > parseMarblesAsSubscriptions() > should throw if found more than one subscription point`
- `spec/schedulers/TestScheduler-spec.ts:150:TestScheduler > parseMarblesAsSubscriptions() > should throw if found more than one unsubscription point`
- `spec/schedulers/TestScheduler-spec.ts:156:TestScheduler > createTime() > should parse a simple time marble string to a number`
- `spec/schedulers/TestScheduler-spec.ts:16:TestScheduler > should exist`
- `spec/schedulers/TestScheduler-spec.ts:162:TestScheduler > createTime() > should progress time with whitespace`
- `spec/schedulers/TestScheduler-spec.ts:169:TestScheduler > createTime() > should progress time with mix of whitespace and dashes`
- `spec/schedulers/TestScheduler-spec.ts:198:TestScheduler > createHotObservable() > should create a hot observable`
- `spec/schedulers/TestScheduler-spec.ts:21:TestScheduler > should have frameTimeFactor set initially`
- `spec/schedulers/TestScheduler-spec.ts:213:TestScheduler > jasmine helpers > rxTestScheduler > should exist`
- `spec/schedulers/TestScheduler-spec.ts:219:TestScheduler > jasmine helpers > cold() > should exist`
- `spec/schedulers/TestScheduler-spec.ts:237:TestScheduler > jasmine helpers > hot() > should exist`
- `spec/schedulers/TestScheduler-spec.ts:242:TestScheduler > jasmine helpers > hot() > should create a hot observable`
- `spec/schedulers/TestScheduler-spec.ts:250:TestScheduler > jasmine helpers > time() > should exist`
- `spec/schedulers/TestScheduler-spec.ts:255:TestScheduler > jasmine helpers > time() > should parse a simple time marble string to a number`
- `spec/schedulers/TestScheduler-spec.ts:26:TestScheduler > parseMarbles() > should parse a marble string into a series of notifications and types`
- `spec/schedulers/TestScheduler-spec.ts:261:TestScheduler > jasmine helpers > expectObservable() > should exist`
- `spec/schedulers/TestScheduler-spec.ts:270:TestScheduler > jasmine helpers > expectObservable() > should append to flushTests array`
- `spec/schedulers/TestScheduler-spec.ts:279:TestScheduler > jasmine helpers > expectObservable() > should handle never`
- `spec/schedulers/TestScheduler-spec.ts:284:TestScheduler > jasmine helpers > expectObservable() > should accept an unsubscription marble diagram`
- `spec/schedulers/TestScheduler-spec.ts:291:TestScheduler > jasmine helpers > expectObservable() > should accept a subscription marble diagram`
- `spec/schedulers/TestScheduler-spec.ts:300:TestScheduler > jasmine helpers > expectSubscriptions() > should exist`
- `spec/schedulers/TestScheduler-spec.ts:309:TestScheduler > jasmine helpers > expectSubscriptions() > should append to flushTests array`
- `spec/schedulers/TestScheduler-spec.ts:35:TestScheduler > parseMarbles() > should parse a marble string, allowing spaces too`
- `spec/schedulers/TestScheduler-spec.ts:361:TestScheduler > TestScheduler.run() > marble diagrams > should ignore whitespace`
- `spec/schedulers/TestScheduler-spec.ts:390:TestScheduler > TestScheduler.run() > should provide the correct helpers`
- `spec/schedulers/TestScheduler-spec.ts:427:TestScheduler > TestScheduler.run() > should have no maximum frame count`
- `spec/schedulers/TestScheduler-spec.ts:44:TestScheduler > parseMarbles() > should parse a marble string with a subscription point`
- `spec/schedulers/TestScheduler-spec.ts:451:TestScheduler > TestScheduler.run() > should flush automatically`
- `spec/schedulers/TestScheduler-spec.ts:472:TestScheduler > TestScheduler.run() > should support explicit flushing`
- `spec/schedulers/TestScheduler-spec.ts:497:TestScheduler > TestScheduler.run() > should pass-through return values, e.g. Promises`
- `spec/schedulers/TestScheduler-spec.ts:508:TestScheduler > TestScheduler.run() > should restore changes upon thrown errors`
- `spec/schedulers/TestScheduler-spec.ts:53:TestScheduler > parseMarbles() > should parse a marble string with an error`
- `spec/schedulers/TestScheduler-spec.ts:569:TestScheduler > TestScheduler.run() > animate > should schedule async requests within animate()`
- `spec/schedulers/TestScheduler-spec.ts:591:TestScheduler > TestScheduler.run() > animate > should schedule sync requests within animate()`
- `spec/schedulers/TestScheduler-spec.ts:610:TestScheduler > TestScheduler.run() > animate > should support request cancellation within animate()`
- `spec/schedulers/TestScheduler-spec.ts:62:TestScheduler > parseMarbles() > should default in the letter for the value if no value hash was passed`
- `spec/schedulers/TestScheduler-spec.ts:632:TestScheduler > TestScheduler.run() > immediate and interval > should schedule immediates`
- `spec/schedulers/TestScheduler-spec.ts:647:TestScheduler > TestScheduler.run() > immediate and interval > should support clearing immediates`
- `spec/schedulers/TestScheduler-spec.ts:663:TestScheduler > TestScheduler.run() > immediate and interval > should schedule intervals`
- `spec/schedulers/TestScheduler-spec.ts:679:TestScheduler > TestScheduler.run() > immediate and interval > should reschedule intervals until cleared`
- `spec/schedulers/TestScheduler-spec.ts:698:TestScheduler > TestScheduler.run() > immediate and interval > should schedule timeouts`
- `spec/schedulers/TestScheduler-spec.ts:71:TestScheduler > parseMarbles() > should handle grouped values`
- `spec/schedulers/TestScheduler-spec.ts:713:TestScheduler > TestScheduler.run() > immediate and interval > should schedule immediates before intervals and timeouts`
- `spec/schedulers/TestScheduler-spec.ts:739:TestScheduler > TestScheduler.run() > schedulers > should support animationFrame, async and asap schedulers`
- `spec/schedulers/TestScheduler-spec.ts:756:TestScheduler > TestScheduler.run() > schedulers > should emit asap notifications before async notifications`
- `spec/schedulers/TestScheduler-spec.ts:769:TestScheduler > TestScheduler.run() > schedulers > should support intervals with zero duration`
- `spec/schedulers/TestScheduler-spec.ts:80:TestScheduler > parseMarbles() > should ignore whitespace when runMode=true`
- `spec/schedulers/TestScheduler-spec.ts:91:TestScheduler > parseMarbles() > should support time progression syntax when runMode=true`

</details>

### RX7-SHARE — `share`

- **Packet status:** `FIXED`
- **Evidence:** 128 tracked case(s); 0 cold failures; 0 polyfill failures; 128 fixed.
- **Current surface/gap:** 117 known mapped mismatch(es); 11 active-registration failure(s).
- **Required classification review:** 6 portable; 122 harness rewrite. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** None recorded. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (128)</summary>

- `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:113:should not change the output of the observable when error [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:124:should not change the output of the observable when successful with cold observable [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:135:should not change the output of the observable when error with cold observable [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:146:should retry just fine [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:146:should retry just fine [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:161:should share the same values to multiple observers [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:181:should share an error from the source to multiple observers [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:201:should share the same values to multiple observers, but is unsubscribed explicitly and early [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:222:should share an empty source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:222:should share an empty source [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:235:should share a never source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:235:should share a never source [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:248:should share a throw source [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:248:should share a throw source [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:261:should connect when first subscriber subscribes [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:281:should disconnect when last subscriber unsubscribes [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:300:should not break unsubscription chain when last subscriber unsubscribes [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:323:should be retryable when cold source is synchronous [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:359:should be repeatable when cold source is synchronous [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:395:should be retryable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:395:should be retryable [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:430:should be repeatable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:430:should be repeatable [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:465:should not change the output of the observable when never [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:474:should not change the output of the observable when empty [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:501:should not fail on reentrant subscription [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:538:should not reset on error if configured to do so [share(config)] [share-config-0:share(config)]`
- `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:559:should not reset on complete if configured to do so [share(config)] [share-config-0:share(config)]`
- `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:593:should not reset on refCount 0 if configured to do so [share(config)] [share-config-0:share(config)]`
- `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config) using EMPTY as sync reset notifier equivalents] [share-config-1:share(config) using EMPTY as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config) using NEVER as sync reset notifier equivalents] [share-config-2:share(config) using NEVER as sync reset notifier equivalents]`
- `spec/operators/share-spec.ts:622:should be referentially-transparent [share(config)] [share-config-0:share(config)]`
- `spec/operators/share-spec.ts:649:share > share(config) > should use the connector function provided`
- `spec/operators/share-spec.ts:703:share > share(config) with async/deferred reset notifiers > should reset on refCount 0 when synchronously resubscribing and using a sync reset notifier`
- `spec/operators/share-spec.ts:723:share > share(config) with async/deferred reset notifiers > should not reset on refCount 0 when synchronously resubscribing and using a deferred reset notifier`
- `spec/operators/share-spec.ts:739:share > share(config) with async/deferred reset notifiers > should reset on refCount 0 only after reset notifier emitted`
- `spec/operators/share-spec.ts:763:share > share(config) with async/deferred reset notifiers > should reset on error only after reset notifier emitted`
- `spec/operators/share-spec.ts:788:share > share(config) with async/deferred reset notifiers > should reset on complete only after reset notifier emitted`
- `spec/operators/share-spec.ts:813:share > share(config) with async/deferred reset notifiers > should not reset on refCount 0 if reset notifier errors before emitting any value`
- `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and never completing after reset is notified] [share-config-3:share() using sync reset notifiers equivalent to default config and never completing after reset is notified]`
- `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and notifying again after reset is notified] [share-config-2:share() using sync reset notifiers equivalent to default config and notifying again after reset is notified]`
- `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified] [share-config-4:share() using sync reset notifiers equivalent to default config and throwing an error after reset is notified]`
- `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share() using sync reset notifiers equivalent to default config] [share-config-1:share() using sync reset notifiers equivalent to default config]`
- `spec/operators/share-spec.ts:84:should mirror a simple source Observable [share()] [share-config-0:share()]`
- `spec/operators/share-spec.ts:840:share > share(config) with async/deferred reset notifiers > should not reset on error if reset notifier errors before emitting any value`
- `spec/operators/share-spec.ts:865:share > share(config) with async/deferred reset notifiers > should not reset on complete if reset notifier errors before emitting any value`
- `spec/operators/share-spec.ts:890:share > share(config) with async/deferred reset notifiers > should not call "resetOnRefCountZero" on error`
- `spec/operators/share-spec.ts:917:share > share(config) with async/deferred reset notifiers > should not call "resetOnRefCountZero" on complete`

</details>

### RX7-SCHEDULED — `scheduled`

- **Packet status:** `TODO`
- **Evidence:** 4 tracked case(s); 1 cold failures; 1 polyfill failures; 3 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 3 active-registration failure(s).
- **Required classification review:** 3 harness rewrite; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (4)</summary>

- `spec/scheduled/scheduled-spec.ts:14:scheduled > should schedule a sync observable`
- `spec/scheduled/scheduled-spec.ts:21:scheduled > should schedule an array`
- `spec/scheduled/scheduled-spec.ts:28:scheduled > should schedule an iterable`
- `spec/scheduled/scheduled-spec.ts:35:scheduled > should schedule an observable-like`

</details>

### RX7-MERGE — `merge`

- **Packet status:** `TODO`
- **Evidence:** 7 tracked case(s); 3 cold failures; 3 polyfill failures; 4 fixed.
- **Current surface/gap:** 3 known mapped mismatch(es); 4 active-registration failure(s).
- **Required classification review:** 2 portable; 2 harness rewrite; 3 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/observables/merge-spec.ts:123:static merge(...observables) > should merge never and empty`
- `spec/observables/merge-spec.ts:139:static merge(...observables) > should merge never and never`
- `spec/observables/merge-spec.ts:251:static merge(...observables) > should merge single lowerCaseO into RxJS Observable`
- `spec/observables/merge-spec.ts:262:static merge(...observables) > should merge two lowerCaseO into RxJS Observable`
- `spec/observables/merge-spec.ts:282:merge(...observables, Scheduler) > should merge single lowerCaseO into RxJS Observable`
- `spec/observables/merge-spec.ts:311:merge(...observables, Scheduler, number) > should handle scheduler`
- `spec/observables/merge-spec.ts:322:merge(...observables, Scheduler, number) > should handle scheduler with concurrency limits`

</details>

### RX7-SWITCH-MAP — `switchMap`

- **Packet status:** `TODO`
- **Evidence:** 7 tracked case(s); 1 cold failures; 1 polyfill failures; 6 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 6 active-registration failure(s).
- **Required classification review:** 6 portable; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (7)</summary>

- `spec/operators/switchMap-spec.ts:139:switchMap > should switch inner cold observables, outer is unsubscribed early`
- `spec/operators/switchMap-spec.ts:16:switchMap > should map-and-flatten each item to an Observable`
- `spec/operators/switchMap-spec.ts:161:switchMap > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/switchMap-spec.ts:187:switchMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly`
- `spec/operators/switchMap-spec.ts:248:switchMap > should switch inner cold observables, inner never completes`
- `spec/operators/switchMap-spec.ts:353:switchMap > should switch inner empty and never`
- `spec/operators/switchMap-spec.ts:450:switchMap > should handle outer never`

</details>

### RX7-CONCAT — `concat`

- **Packet status:** `TODO`
- **Evidence:** 9 tracked case(s); 1 cold failures; 1 polyfill failures; 8 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 8 active-registration failure(s).
- **Required classification review:** 8 portable; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (9)</summary>

- `spec/observables/concat-spec.ts:113:static concat > should not complete if second source does not completes`
- `spec/observables/concat-spec.ts:127:static concat > should not complete if both sources do not complete`
- `spec/observables/concat-spec.ts:211:static concat > 'should emit element from first source, and should not complete if second ' + 'source does not completes'`
- `spec/observables/concat-spec.ts:225:static concat > should not complete if first source does not complete`
- `spec/observables/concat-spec.ts:253:static concat > should unsubscribe to inner source if outer is unsubscribed early`
- `spec/observables/concat-spec.ts:433:static concat > should return RxJS Observable when single lowerCaseO was passed`
- `spec/observables/concat-spec.ts:52:static concat > should concat the same cold observable multiple times, but the result is unsubscribed early`
- `spec/observables/concat-spec.ts:68:static concat > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/observables/concat-spec.ts:99:static concat > should not complete if first source does not completes`

</details>

### RX7-ON-ERROR-RESUME-NEXT — `onErrorResumeNext`

- **Packet status:** `TODO`
- **Evidence:** 11 tracked case(s); 1 cold failures; 1 polyfill failures; 10 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 10 active-registration failure(s).
- **Required classification review:** 10 portable; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (11)</summary>

- `spec/observables/onErrorResumeNext-spec.ts:55:onErrorResumeNext > should complete single observable throws`
- `spec/operators/onErrorResumeNext-spec.ts:107:onErrorResumeNext > should continue after empty observable`
- `spec/operators/onErrorResumeNext-spec.ts:127:onErrorResumeNext > should not complete with observable that does not complete`
- `spec/operators/onErrorResumeNext-spec.ts:141:onErrorResumeNext > should not continue when source observable does not complete`
- `spec/operators/onErrorResumeNext-spec.ts:15:onErrorResumeNext > should continue observable sequence with next observable`
- `spec/operators/onErrorResumeNext-spec.ts:155:onErrorResumeNext > should complete observable when next observable throws`
- `spec/operators/onErrorResumeNext-spec.ts:189:onErrorResumeNext > should unsubscribe from an interop observable upon explicit unsubscription`
- `spec/operators/onErrorResumeNext-spec.ts:29:onErrorResumeNext > should continue with hot observables`
- `spec/operators/onErrorResumeNext-spec.ts:43:onErrorResumeNext > should continue with array of multiple observables that throw errors`
- `spec/operators/onErrorResumeNext-spec.ts:67:onErrorResumeNext > should continue with multiple observables that throw errors`
- `spec/operators/onErrorResumeNext-spec.ts:87:onErrorResumeNext > should continue with multiple observables that don't throw error`

</details>

### RX7-EXHAUST-MAP — `exhaustMap`

- **Packet status:** `TODO`
- **Evidence:** 14 tracked case(s); 1 cold failures; 1 polyfill failures; 13 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 13 active-registration failure(s).
- **Required classification review:** 13 portable; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (14)</summary>

- `spec/operators/exhaustMap-spec.ts:116:exhaustMap > should handle outer never`
- `spec/operators/exhaustMap-spec.ts:149:exhaustMap > should switch with a selector function`
- `spec/operators/exhaustMap-spec.ts:16:exhaustMap > should map-and-flatten each item to an Observable`
- `spec/operators/exhaustMap-spec.ts:173:exhaustMap > should switch inner cold observables, outer is unsubscribed early`
- `spec/operators/exhaustMap-spec.ts:198:exhaustMap > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/exhaustMap-spec.ts:227:exhaustMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly`
- `spec/operators/exhaustMap-spec.ts:291:exhaustMap > should switch inner cold observables, inner never completes`
- `spec/operators/exhaustMap-spec.ts:315:exhaustMap > should handle a synchronous switch and stay on the first inner observable`
- `spec/operators/exhaustMap-spec.ts:336:exhaustMap > should switch inner cold observables, one inner throws`
- `spec/operators/exhaustMap-spec.ts:357:exhaustMap > should switch inner hot observables`
- `spec/operators/exhaustMap-spec.ts:381:exhaustMap > should switch inner empty and empty`
- `spec/operators/exhaustMap-spec.ts:402:exhaustMap > should switch inner empty and never`
- `spec/operators/exhaustMap-spec.ts:423:exhaustMap > should never switch inner never`
- `spec/operators/exhaustMap-spec.ts:465:exhaustMap > should handle outer error`

</details>

### RX7-CATCH-ERROR — `catchError`

- **Packet status:** `TODO`
- **Evidence:** 17 tracked case(s); 1 cold failures; 1 polyfill failures; 16 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 16 active-registration failure(s).
- **Required classification review:** 16 portable; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (17)</summary>

- `spec/operators/catchError-spec.ts:107:catchError operator > should unsubscribe from a caught hot caught observable when unsubscribed explicitly`
- `spec/operators/catchError-spec.ts:124:catchError operator > should unsubscribe from a caught cold caught observable when unsubscribed explicitly`
- `spec/operators/catchError-spec.ts:141:catchError operator > should unsubscribe from a caught cold caught interop observable when unsubscribed explicitly`
- `spec/operators/catchError-spec.ts:18:catchError operator > should catch error and replace with a cold Observable`
- `spec/operators/catchError-spec.ts:193:catchError operator > should catch error and replace it with a hot Observable`
- `spec/operators/catchError-spec.ts:209:catchError operator > should catch and allow the cold observable to be repeated with the third (caught) argument`
- `spec/operators/catchError-spec.ts:240:catchError operator > should catch and allow the hot observable to proceed with the third (caught) argument`
- `spec/operators/catchError-spec.ts:271:catchError operator > should catch and replace a Observable.throw() as the source`
- `spec/operators/catchError-spec.ts:284:catchError operator > should mirror the source if it does not raise errors`
- `spec/operators/catchError-spec.ts:297:catchError operator > should complete if you return Observable.empty()`
- `spec/operators/catchError-spec.ts:30:catchError operator > should catch error and replace it with Observable.of()`
- `spec/operators/catchError-spec.ts:313:catchError operator > should raise error if you return Observable.throw()`
- `spec/operators/catchError-spec.ts:329:catchError operator > should never terminate if you return NEVER`
- `spec/operators/catchError-spec.ts:382:catchError operator > should catch errors throw from within the constructor`
- `spec/operators/catchError-spec.ts:53:catchError operator > should catch error and replace it with a cold Observable`
- `spec/operators/catchError-spec.ts:69:catchError operator > should allow unsubscribing explicitly and early`
- `spec/operators/catchError-spec.ts:87:catchError operator > should not break unsubscription chain when unsubscribed explicitly`

</details>

### RX7-SKIP-UNTIL — `skipUntil`

- **Packet status:** `TODO`
- **Evidence:** 19 tracked case(s); 1 cold failures; 1 polyfill failures; 18 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 18 active-registration failure(s).
- **Required classification review:** 17 portable; 1 harness rewrite; 1 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (19)</summary>

- `spec/operators/skipUntil-spec.ts:105:skipUntil > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/skipUntil-spec.ts:126:skipUntil > should not break unsubscription chains with interop inners when result is unsubscribed explicitly`
- `spec/operators/skipUntil-spec.ts:153:skipUntil > should skip all elements when notifier is empty`
- `spec/operators/skipUntil-spec.ts:16:skipUntil > should skip values until another observable notifies`
- `spec/operators/skipUntil-spec.ts:167:skipUntil > should keep subscription to source, to wait for its eventual completion`
- `spec/operators/skipUntil-spec.ts:181:skipUntil > should not complete if hot source observable does not complete`
- `spec/operators/skipUntil-spec.ts:195:skipUntil > should not complete if cold source observable never completes`
- `spec/operators/skipUntil-spec.ts:209:skipUntil > should raise error if cold source is never and notifier errors`
- `spec/operators/skipUntil-spec.ts:223:skipUntil > should skip all elements and complete if notifier is cold never`
- `spec/operators/skipUntil-spec.ts:237:skipUntil > should skip all elements and complete if notifier is a hot never`
- `spec/operators/skipUntil-spec.ts:251:skipUntil > should skip all elements and complete, even if notifier would not complete until later`
- `spec/operators/skipUntil-spec.ts:265:skipUntil > should not complete if source does not complete if notifier completes without emission`
- `spec/operators/skipUntil-spec.ts:279:skipUntil > should not complete if source and notifier are both hot never`
- `spec/operators/skipUntil-spec.ts:293:skipUntil > should skip all elements if notifier is unsubscribed explicitly before the notifier emits`
- `spec/operators/skipUntil-spec.ts:30:skipUntil > should emit elements after notifier emits`
- `spec/operators/skipUntil-spec.ts:316:skipUntil > should unsubscribe the notifier after its first nexted value`
- `spec/operators/skipUntil-spec.ts:62:skipUntil > should raise an error if notifier throws and source is hot`
- `spec/operators/skipUntil-spec.ts:76:skipUntil > should skip all elements when notifier does not emit and completes early`
- `spec/operators/skipUntil-spec.ts:90:skipUntil > should allow unsubscribing explicitly and early`

</details>

### RX7-MERGE-MAP — `mergeMap`

- **Packet status:** `TODO`
- **Evidence:** 20 tracked case(s); 1 cold failures; 3 polyfill failures; 17 fixed.
- **Current surface/gap:** 1 known mapped mismatch(es); 19 active-registration failure(s).
- **Required classification review:** 16 portable; 1 harness rewrite; 1 compatibility-only; 2 intentional divergence. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Correct converted harness programs while preserving their original behavioral claims; reproduce and repair mapped runtime mismatches without weakening assertions; record the accepted divergence and replace the old expectation with the approved platform behavior.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (20)</summary>

- `spec/operators/mergeMap-spec.ts:108:mergeMap > should mergeMap many regular interval inners`
- `spec/operators/mergeMap-spec.ts:16:mergeMap > should map-and-flatten each item to an Observable`
- `spec/operators/mergeMap-spec.ts:208:mergeMap > should mergeMap many outer values to many inner values`
- `spec/operators/mergeMap-spec.ts:232:mergeMap > should mergeMap many outer to many inner, complete late`
- `spec/operators/mergeMap-spec.ts:256:mergeMap > should mergeMap many outer to many inner, outer never completes`
- `spec/operators/mergeMap-spec.ts:285:mergeMap > should not break unsubscription chains when result is unsubscribed explicitly`
- `spec/operators/mergeMap-spec.ts:318:mergeMap > should not break unsubscription chains with interop inners when result is unsubscribed explicitly`
- `spec/operators/mergeMap-spec.ts:350:mergeMap > should mergeMap many outer to many inner, inner never completes`
- `spec/operators/mergeMap-spec.ts:374:mergeMap > should mergeMap many outer to many inner, and inner throws`
- `spec/operators/mergeMap-spec.ts:398:mergeMap > should mergeMap many outer to many inner, and outer throws`
- `spec/operators/mergeMap-spec.ts:422:mergeMap > should mergeMap many outer to many inner, both inner and outer throw`
- `spec/operators/mergeMap-spec.ts:467:mergeMap > should mergeMap to many cold Observable, with parameter concurrency=2`
- `spec/operators/mergeMap-spec.ts:574:mergeMap > should mergeMap many complex, all inners finite except one`
- `spec/operators/mergeMap-spec.ts:610:mergeMap > should mergeMap many complex, inners finite, outer does not complete`
- `spec/operators/mergeMap-spec.ts:718:mergeMap > should mergeMap many complex, all inners finite, outer is unsubscribed`
- `spec/operators/mergeMap-spec.ts:805:mergeMap > should mergeMap many outer to an array for each value`
- `spec/operators/mergeMap-spec.ts:818:mergeMap > should mergeMap many outer to inner arrays, and outer throws`
- `spec/operators/mergeMap-spec.ts:831:mergeMap > should mergeMap many outer to inner arrays, outer gets unsubscribed`
- `spec/operators/mergeMap-spec.ts:845:mergeMap > should mergeMap many outer to inner arrays, project throws`
- `spec/operators/mergeMap-spec.ts:975:mergeMap > should properly handle errors from iterables that are processed after some async`

</details>

### RX7-FORK-JOIN — `forkJoin`

- **Packet status:** `TODO`
- **Evidence:** 39 tracked case(s); 4 cold failures; 4 polyfill failures; 35 fixed.
- **Current surface/gap:** 4 known mapped mismatch(es); 35 active-registration failure(s).
- **Required classification review:** 35 portable; 4 compatibility-only. Reconfirm each classification before changing production behavior; preserve the original claim in any harness rewrite.
- **Implementation objective:** Reproduce and repair mapped runtime mismatches without weakening assertions.
- **Dependencies or blocker:** Compatibility-only cases must not be implemented in the platform layer; P0.2 and compatibility questions 10–13 may constrain their final package and surface. Mark individual rows `BLOCKED` only when a named dependency prevents the next concrete step.
- **Verification:** Run both complete audit modes, regenerate this tracker, and run the normal strict `pnpm --filter rxjs run test:unit` gate. Confirm no unrelated owner group regresses.
- **Completion bar:** Every affected case passes in both authoritative modes and is `FIXED`; any changed expectation has the required compatibility or intentional-divergence decision recorded.

<details><summary>Affected case IDs (39)</summary>

- `spec/observables/forkJoin-spec.ts:108:forkJoin > forkJoin([input1, input2, input3]) > should accept lowercase-o observables`
- `spec/observables/forkJoin-spec.ts:120:forkJoin > forkJoin([input1, input2, input3]) > should accept empty lowercase-o observables`
- `spec/observables/forkJoin-spec.ts:143:forkJoin > forkJoin([input1, input2, input3]) > should accept array of observables`
- `spec/observables/forkJoin-spec.ts:155:forkJoin > forkJoin([input1, input2, input3]) > should not emit if any of source observable is empty`
- `spec/observables/forkJoin-spec.ts:16:forkJoin > should join the last values of the provided observables into an array`
- `spec/observables/forkJoin-spec.ts:167:forkJoin > forkJoin([input1, input2, input3]) > should complete early if any of source is empty and completes before than others`
- `spec/observables/forkJoin-spec.ts:179:forkJoin > forkJoin([input1, input2, input3]) > should complete when all sources are empty`
- `spec/observables/forkJoin-spec.ts:190:forkJoin > forkJoin([input1, input2, input3]) > should not complete when only source never completes`
- `spec/observables/forkJoin-spec.ts:199:forkJoin > forkJoin([input1, input2, input3]) > should not complete when one of the sources never completes`
- `spec/observables/forkJoin-spec.ts:210:forkJoin > forkJoin([input1, input2, input3]) > should complete when one of the sources never completes but other completes without values`
- `spec/observables/forkJoin-spec.ts:221:forkJoin > forkJoin([input1, input2, input3]) > should complete if source is not provided`
- `spec/observables/forkJoin-spec.ts:230:forkJoin > forkJoin([input1, input2, input3]) > should complete if sources list is empty`
- `spec/observables/forkJoin-spec.ts:239:forkJoin > forkJoin([input1, input2, input3]) > should raise error when any of source raises error with empty observable`
- `spec/observables/forkJoin-spec.ts:250:forkJoin > forkJoin([input1, input2, input3]) > should raise error when any of source raises error with source that never completes`
- `spec/observables/forkJoin-spec.ts:261:forkJoin > forkJoin([input1, input2, input3]) > should raise error when source raises error`
- `spec/observables/forkJoin-spec.ts:272:forkJoin > forkJoin([input1, input2, input3]) > should allow unsubscribing early and explicitly`
- `spec/observables/forkJoin-spec.ts:289:forkJoin > forkJoin([input1, input2, input3]) > should unsubscribe other Observables, when one of them errors`
- `spec/observables/forkJoin-spec.ts:323:forkJoin > forkJoin({ foo, bar, baz }) > should join the last values of the provided observables into an array`
- `spec/observables/forkJoin-spec.ts:336:forkJoin > forkJoin({ foo, bar, baz }) > should allow emit null or undefined`
- `spec/observables/forkJoin-spec.ts:350:forkJoin > forkJoin({ foo, bar, baz }) > should accept array of observable contains single`
- `spec/observables/forkJoin-spec.ts:361:forkJoin > forkJoin({ foo, bar, baz }) > should accept lowercase-o observables`
- `spec/observables/forkJoin-spec.ts:374:forkJoin > forkJoin({ foo, bar, baz }) > should accept empty lowercase-o observables`
- `spec/observables/forkJoin-spec.ts:399:forkJoin > forkJoin({ foo, bar, baz }) > should accept an object of observables`
- `spec/observables/forkJoin-spec.ts:412:forkJoin > forkJoin({ foo, bar, baz }) > should not emit if any of source observable is empty`
- `spec/observables/forkJoin-spec.ts:426:forkJoin > forkJoin({ foo, bar, baz }) > should complete early if any of source is empty and completes before than others`
- `spec/observables/forkJoin-spec.ts:439:forkJoin > forkJoin({ foo, bar, baz }) > should complete when all sources are empty`
- `spec/observables/forkJoin-spec.ts:451:forkJoin > forkJoin({ foo, bar, baz }) > should not complete when only source never completes`
- `spec/observables/forkJoin-spec.ts:462:forkJoin > forkJoin({ foo, bar, baz }) > should not complete when one of the sources never completes`
- `spec/observables/forkJoin-spec.ts:474:forkJoin > forkJoin({ foo, bar, baz }) > should complete when one of the sources never completes but other completes without values`
- `spec/observables/forkJoin-spec.ts:502:forkJoin > forkJoin({ foo, bar, baz }) > should complete if sources object is empty`
- `spec/observables/forkJoin-spec.ts:511:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when any of source raises error with empty observable`
- `spec/observables/forkJoin-spec.ts:523:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when any of source raises error with source that never completes`
- `spec/observables/forkJoin-spec.ts:535:forkJoin > forkJoin({ foo, bar, baz }) > should raise error when source raises error`
- `spec/observables/forkJoin-spec.ts:547:forkJoin > forkJoin({ foo, bar, baz }) > should allow unsubscribing early and explicitly`
- `spec/observables/forkJoin-spec.ts:567:forkJoin > forkJoin({ foo, bar, baz }) > should unsubscribe other Observables, when one of them errors`
- `spec/observables/forkJoin-spec.ts:62:forkJoin > should accept single observable`
- `spec/observables/forkJoin-spec.ts:72:forkJoin > forkJoin([input1, input2, input3]) > should join the last values of the provided observables into an array`
- `spec/observables/forkJoin-spec.ts:84:forkJoin > forkJoin([input1, input2, input3]) > should allow emit null or undefined`
- `spec/observables/forkJoin-spec.ts:98:forkJoin > forkJoin([input1, input2, input3]) > should accept array of observable contains single`

</details>

## Tracker validation

The generator validates that both reports cover all 2,338 unique manifest case IDs, that passed and failed totals reconcile, that every tracked row maps to a manifest case, that every row belongs to exactly one work packet, and that status and blocker rules hold.

After generating, verify the committed files without rewriting them:

```sh
pnpm --filter rxjs run test:unit:failures:generate --cold-report=/tmp/rxjs-next-ported-cold.json --polyfill-report=/tmp/rxjs-next-ported-polyfill.json --check
```
