vitest-auto-spy 5.15.1 → 5.17.0

package/AGENTS.md

@@ -1662,6 +1662,28 @@ a `useValue` provider or a test double — patch the prototype of the class the
 `guardPrototypePollution(reaction)` from `/setup` registers the same check on its own, for a suite
 that does not call `setupAutoSpy()`.
 
+### Naming the test that left an attribute on `<body>`
+
+```ts
+setupAutoSpy({ documentPollution: 'throw' }); // default 'off'; 'throw' under preset: 'strict'
+setupAutoSpy({ documentPollution: { reaction: 'throw', nodes: true, ignoreAttributes: [/^data-cdk-/], ignoreNodes: 'style' } });
+```
+
+Under `isolate: false` every spec file in a worker shares one document. An attribute a component set
+on `<body>` — `renderer.setAttribute(document.body, 'data-reset-focus', '')` in an `effect` — that
+nothing took off changes the branch a later file's code takes, so that file fails, only when the two
+share a worker and never alone. The guard records the attributes of `<html>`, `<head>` and `<body>`
+before each test and compares them from `onTestFinished` — **after** the TestBed destroyed the
+fixtures in its own `afterEach`, so what a component removes in `ngOnDestroy` / `DestroyRef.onDestroy`
+is never reported. Every attribute added, changed or removed is named with both values, put back,
+and fails that test. A change made in a `beforeAll` and never undone fails the file, checked from a
+`beforeAll` cleanup after every `afterAll`. `nodes: true` also watches the child elements of `<head>`
+and `<body>`; it is off by default because a module that injects a stylesheet on first import does
+so once per worker. Blind spots: a write made while the spec file is imported, and a fixture kept
+alive by `teardown: { destroyAfterEach: false }` (reported against the test that rendered it).
+`guardDocumentPollution(option)` from `/setup` registers the same check on its own. Vitest only, like
+every `/setup` guard — `bun:test`, `node:test` and Rstest have no setup entry to host it.
+
 ### Failing on console output nothing absorbed
 
 ```ts
@@ -1701,8 +1723,8 @@ frame outside `node_modules`:
 setupAutoSpy({ preset: 'strict' });
 ```
 
-Sets `duplicateCopies`, `propsOutsideHooks`, `guardGlobals`, `prototypePollution`, `strayConsole` and
-`misconfiguration` to `'throw'`, turns `strayTimers` on, and `strayRejections` on when zone.js is
+Sets `duplicateCopies`, `propsOutsideHooks`, `guardGlobals`, `prototypePollution`, `documentPollution`,
+`strayConsole` and `misconfiguration` to `'throw'`, turns `strayTimers` on, and `strayRejections` on when zone.js is
 loaded. An option passed alongside still wins. **Not** included: `strict` (strict doubles change what
 an unconfigured call returns — a semantic switch, not a grade; the name was taken, hence `preset`) and
 `unconfiguredReads`, its read side (survey with `onUnstubbedRead` before turning it on),
@@ -3189,7 +3211,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no-private-member-access`        | `error` | —                 | `instance['privateMember']`, `(instance as any).privateMember` (and `as unknown as`, and a decoy type), `vi.spyOn(Object.getPrototypeOf(x), 'm')` → drive the member through the public API. **Type-aware**: silent without `parserOptions.project`, and silent on an index signature                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `no-dead-schemas`                 | `error` | —                 | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `prefer-render-shallow`           | `warn`  | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `prefer-set-inputs`               | `warn`  | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101`                                                                                                                                                                                                                                                                                                           |
@@ -3281,7 +3303,12 @@ passes: `export const events = [...BaseEvents]` at module scope raises
 `Spread syntax requires ...iterable[Symbol.iterator] to be a function` when a shared chunk is
 evaluated while the binding it re-exports is still `undefined`. Safe under `tsc` and under a
 browser's ESM loader, which is why nothing else catches it. A function body and an instance field are
-not reported (they run later); a `static` field is.
+not reported (they run later); a `static` field is. An **object** spread is reported through a second
+message, `noImportTimeSpreadObject`, because that half fails without failing: `[...undefined]` and
+`f(...undefined)` throw, `{ ...undefined }` is `{}`, so `{ ...ShelfItemTypeEnum, ...Local }` loads
+clean and every key it meant to copy reads `undefined` for the rest of the run. One message cannot
+carry both: a reader sent looking for `Spread syntax requires …` in an object spread finds no such
+error in the log and takes the report for a false positive.
 
 `prefer-as-spy` is the one a migration meets in bulk: a `jest-auto-spies` suite writes
 `TestBed.inject(X) as Spy<X>` once per injected double, and that cast fails here with `TS2352`.
@@ -3454,6 +3481,9 @@ packages, which a subpath export can never be.
 | `Cannot set base providers because it has already been called`                                                                                      | zone and zoneless spec files sharing one worker                                                                                                                                                                                                                             | `setupAngularTestEnv({ zoneless, initZone, initZoneless })` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | a stub that works in the first test of the file and in no other                                                                                     | installed at `describe` level or in `beforeAll`, then restored away                                                                                                                                                                                                         | install it in `beforeEach`, or `installPerTest(() => stub…())`                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | a third-party library failing every other run, no test named                                                                                        | a test sealed a global with `Object.defineProperty` (non-configurable)                                                                                                                                                                                                      | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| a spec green alone that fails only in a full run, on something it reads off `<body>` / `<html>` (`querySelector('[data-…]')`, a class)              | an earlier file in the worker left an attribute on the shared document                                                                                                                                                                                                      | `setupAutoSpy({ documentPollution: 'throw' })` (in `preset: 'strict'`) names the test; take the attribute off in `ngOnDestroy` / `DestroyRef.onDestroy` or an `afterEach`                                                                                                                                                                                                                                                                                                                                         |
+| `A metric with the name … has already been registered` as a failed suite with 0 failed tests, only in a full run                                    | under `@angular/build:unit-test` with `isolate: false` a workspace module can run its module scope once **per spec file**, while an external package such as `prom-client` keeps one default registry per worker                                                            | not something a hook can catch — it throws at import. Look the metric up before creating it: `register.getSingleMetric(name) ?? new Histogram({ name, … })`, or give the module its own `new Registry()`                                                                                                                                                                                                                                                                                                          |
+| `NotSupportedError: This name has already been registered in the registry` at import                                                                | the same per-spec-file evaluation reaching a module-scope `customElements.define` — the registry belongs to the worker's document                                                                                                                                           | `if (!customElements.get(name)) customElements.define(name, Element)`; a definition cannot be undone, so nothing can sweep it                                                                                                                                                                                                                                                                                                                                                                                     |
 | a block of files reported as failed suites with no stack, and zero failing tests                                                                    | a test left an own enumerable key on `Object.prototype`; `mergeHooks` spreads it and collection dies                                                                                                                                                                        | `setupAutoSpy()` guards it by default; `prototypePollution` tunes the reaction                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                                                                                | one field moved in every element — usually a frozen clock or an id                                                                                                                                                                                                          | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | a hand-tuned number of turns waiting for a `resource()` to load                                                                                     | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request                                                                                                                        | `flushEffects()`, flush the request, then `await settleResource(r, { label })`                                                                                                                                                                                                                                                                                                                                                                                                                                    |
@@ -3467,6 +3497,7 @@ packages, which a subpath export can never be.
 | `setInputs: … declares no input named …`                                                                                                            | the key is not an input of that component — a typo, an input renamed since, or one of its own fields                                                                                                                                                                        | set the names the message lists; a signal the component owns is moved through the signal (§13)                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `setInputs: X carries no ɵcmp, so there are no inputs to set`                                                                                       | the fixture's `componentType` is not a compiled `@Component` — a `@Directive` or `@Pipe` class, or one Angular never compiled (a barrel import that resolved to `undefined`)                                                                                                | pass a component fixture; a directive takes its inputs through the host element that applies it (`createDirectiveHost`), and for `undefined` import the class from its own file (§13)                                                                                                                                                                                                                                                                                                                             |
 | `TypeError: dependencies is not a function`, from `renderShallow({ keepTemplate: true })`                                                           | the compiled `ɵcmp.dependencies` is the flat array AOT emits when no cycle forced a factory, and the trim called it                                                                                                                                                         | upgrade — all three shapes (array, factory, `null`) are read; nothing to change in the spec                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `renderShallow(X, { keepTemplate: true }): … declared by an NgModule rather than standalone`                                                        | an AOT dependency list: ngtsc flattened an imported `NgModule`'s exported declarations into it, and Angular takes only standalone declarations and `NgModule`s in `imports`                                                                                                 | drop `keepTemplate` when the spec reads TypeScript state only, or build the component with `TestBed` directly and keep its compiled scope — the declarations named are not the thing to change                                                                                                                                                                                                                                                                                                                    |
 | `TS2540: Cannot assign to 'X' because it is a read-only property`                                                                                   | a `readonly` field of an object under test                                                                                                                                                                                                                                  | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                                                                        | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                                                                                                                                                     | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `throwWith` reaching the success branch first, with the previous test's value                                                                       | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                                                                                                                                               | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -3558,6 +3589,7 @@ diagnostic and is free to change: print it, never assert on it.
 | `it('x', (done) => …)` / `beforeEach((done) => …)`                              | `async` + `await` — Vitest passes a `TestContext`, not `done`                                                    |
 | `{ ...modelInstance, flag: true }` (drops every getter)                         | `withOverrides(modelInstance, { flag: true })`                                                                   |
 | `if ('params' in link) … else throw` in every spec                              | `narrow.byKey(link, 'params')`                                                                                   |
+| `const x = a?.b; assert.exists(x); … x …` on every optional read                | `narrow.defined(a?.b)` — it returns the value, so the narrowing sits in the expression                           |
 | five `asInstance(...)` in one call                                              | `...asInstances(a, b, c, d, e)`                                                                                  |
 | `vi.stubGlobal('Image', vi.fn(() => ({ src: '' })))`                            | `stubConstructor(globalThis, 'Image', () => ({ src: '' }))`                                                      |
 | `Object.defineProperty(document, 'cookie', { value })`                          | `mockValueProp(document, 'cookie', value)`                                                                       |

package/README.md

@@ -2408,7 +2408,14 @@ it, or `null` for a component that imports nothing — and which one is not deci
 AOT: JIT always emits the factory, AOT emits the array unless a cycle between two components forces
 it to defer the read. All three are handled; calling the array unconditionally was a
 `TypeError: dependencies is not a function` on an AOT-compiled component with no cycle in its
-imports. A child re-exported by an imported `NgModule` still renders — the module is kept whole.
+imports. A child re-exported by an imported `NgModule` still renders **under JIT**, where the module
+is in that list and is kept whole. Under AOT it is not: ngtsc resolves the module at compile time and
+flattens its exported declarations into the list, so a `standalone: false` pipe or directive is what
+arrives, and Angular takes only standalone declarations and `NgModule`s in `imports`. That scope
+cannot be rebuilt from what the definition holds, so `renderShallow` refuses it by name instead of
+letting Angular answer `The "X" pipe … is not standalone` — a message aimed at the pipe's author,
+about a pipe that is fine and that works under JIT. Drop `keepTemplate` when the spec reads
+TypeScript state only, or build the component with `TestBed` directly and keep its compiled scope.
 Reach for it when the spec reads
 something the template creates, and keep `keepChildren` for the handful of children it genuinely
 needs resolvable. Full write-up:
@@ -2882,7 +2889,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `captureArg<T>()`                                                                        | core                          | Take hold of a callback or config the code under test built, instead of describing its shape — assertions only, never `calledWith`                                                                                            |
 | `explainSpy(spy, method?)`                                                               | `/diagnostics`                | Every configured argument list next to every recorded call, each attributed to the config it hit — before anything failed                                                                                                     |
 | `asInstances(...spies)`                                                                  | core                          | `asInstance` for a whole argument list — one edit against one compiler error, not five                                                                                                                                        |
-| `narrow(value, guard)` / `narrow.byKey` / `narrow.observable`                            | core                          | The branch of a union a test knows it got, failing with the shape the value actually had                                                                                                                                      |
+| `narrow(value, guard)` / `narrow.byKey` / `narrow.defined` / `narrow.observable`         | core                          | The branch of a union a test knows it got, failing with the shape the value actually had                                                                                                                                      |
 | `withOverrides(model, overrides?)`                                                       | core                          | A fixture from a model instance: its getters read once, as data — a spread drops them                                                                                                                                         |
 | `compareTestRuns(a, b, root?)`                                                           | core                          | Whether a migration lost a test — the set of `file::name`, which matching counters cannot answer                                                                                                                              |
 | `provideAutoSpyForToken(TOKEN, overrides?)`                                              | `/angular`                    | The provider for a dependency behind an `InjectionToken` — no stand-in class to write                                                                                                                                         |
@@ -2916,6 +2923,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `withoutStrayTimerTracking(work)`                                                        | `/setup`                      | Run setup work whose timers the stray-timer tracker neither counts nor cancels — jsdom schedules one per Web Storage write                                                                                                    |
 | `describeStrayTimers()`                                                                  | `/setup`                      | Every timer still pending, with its kind, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets                                                                                           |
 | `guardPrototypePollution(reaction)`                                                      | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([details](#test-run-hygiene))                                                                                                          |
+| `guardDocumentPollution(option)`                                                         | `/setup`                      | Name the test that left an attribute on `<html>` / `<body>`, and put it back ([details](#test-run-hygiene))                                                                                                                   |
 | `installPerTest(install)`                                                                | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                                                   |
 | `setupAngularTestEnv(opts)`                                                              | `/angular`                    | Zone and zoneless spec files in one worker, switching platforms per file                                                                                                                                                      |
 | `restoreTimerGlobals()`                                                                  | `/setup`                      | Put back timer globals that uninstalling the fakes deleted rather than restored                                                                                                                                               |
@@ -3195,8 +3203,16 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
     console method a test replaced is put back after it, so one file's silence cannot reach the next,
     and the library's own warnings count like any other output. `allow: [...]` is the last resort,
     for environment noise no spec can reach.
-13. **Every guard at its strictest — `preset: 'strict'`.** `duplicateCopies`, `propsOutsideHooks`,
-    `guardGlobals`, `prototypePollution`, `strayConsole` and `misconfiguration` to `'throw'`,
+13. **Attributes left on the shared document.** Opt-in, `documentPollution: 'throw'`, and on under
+    `preset: 'strict'`. Under `isolate: false` a worker's spec files share one jsdom document, so a
+    `data-*` attribute or a class a component set on `<body>` and never took off changes what a later
+    file's code sees: `document.querySelector('[data-reset-focus]')` matches, a service returns early,
+    and 34 of 209 tests fail only when the two files share a worker. The guard compares the attributes
+    of `<html>`, `<head>` and `<body>` around every test, puts them back and fails the test that changed
+    them; `{ nodes: true }` watches their child elements too. It looks after the TestBed's own teardown,
+    so what a destroyed component cleans up is never reported.
+14. **Every guard at its strictest — `preset: 'strict'`.** `duplicateCopies`, `propsOutsideHooks`,
+    `guardGlobals`, `prototypePollution`, `documentPollution`, `strayConsole` and `misconfiguration` to `'throw'`,
     `strayTimers` on, `strayRejections` on where zone.js is loaded; an option passed alongside still
     wins. Not in it: strict doubles (a semantic switch, not a grade) and `unconfiguredReads`, their read
     side, `blockNetwork`, `restoreMocks`,
@@ -3217,6 +3233,7 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | `blockNetwork`        | `false`   | Close every network channel the environment has — `true`, or a narrowing object                                                                                                               |
 | `guardGlobals`        | `'off'`   | Report a test that redefines a global property as non-configurable                                                                                                                            |
 | `prototypePollution`  | `'throw'` | Sweep and report an enumerable key a test left on a built-in prototype                                                                                                                        |
+| `documentPollution`   | `'off'`   | Put back and report an attribute a test left on `<html>` / `<head>` / `<body>` — `'warn'`, `'throw'`, or `{ reaction, nodes, ignoreAttributes, ignoreNodes }`                                 |
 | `strayConsole`        | `'off'`   | Fail a test (or a file) whose console output nothing absorbed — `'warn'`, `'throw'`, or `{ reaction, allow }`                                                                                 |
 | `misconfiguration`    | `'warn'`  | `'throw'` fails the library's own misuse reports at the call site, every occurrence                                                                                                           |
 | `preset`              | —         | `'strict'` starts every guard above at its strictest grade; explicit options still win                                                                                                        |
@@ -3460,7 +3477,7 @@ export can never be.
 | `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `no-private-member-access`        |   `error`   | —                 | `instance['privateMember']`, `(instance as any).privateMember` and `vi.spyOn(Object.getPrototypeOf(x), 'm')` — the three spellings that get past `private`; **type-aware**, and silent without `parserOptions.project`                                                                                                                                                                                                                                                                                           |
 | `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                                                                                                                                                                                                                                                                                                                       |
-| `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                             |
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                         |
 | `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                 |
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer that with `NG0101` |
@@ -3542,7 +3559,12 @@ while a binding it re-exports is still `undefined`, so the spread throws
 `Spread syntax requires ...iterable[Symbol.iterator] to be a function`. An AST pass found exactly
 seven sites in an 8 673-file workspace, which is small enough to flag at the cursor. A function body
 and an instance field are deliberately not reported — they run later than the module does — while a
-`static` field is.
+`static` field is. An **object** spread of the same binding gets a message of its own,
+because it fails without failing: `[...undefined]` throws, `{ ...undefined }` is `{}`, so
+`export const ItemType = { ...ShelfItemTypeEnum, ...Local }` loads clean and every key it meant to
+copy reads `undefined` for the rest of the run. Told to look for `Spread syntax requires …`, a
+reader finds no such error and takes the report for a false positive — so the object message opens
+by saying there is nothing to find.
 
 `no-unregistered-inject-spy` catches `injectSpy(X)` for a token nothing in the file
 registered as an auto-spy. What comes back is whatever Angular DI already had — the real service, or
@@ -3788,6 +3810,7 @@ another, and the next one is in that same file.
 | `guardStrayConsole(reaction)` / `withoutStrayTimerTracking(work)` _(`/setup`)_                                                              | Fail a test on console output nothing absorbed; keep setup work's timers out of the stray-timer count                                                                                                                                                                         |
 | `describeStrayTimers()` _(`/setup`)_                                                                                                        | Each pending timer with the spec file and frames that scheduled it — for a suite that sweeps by hand                                                                                                                                                                          |
 | `guardPrototypePollution(reaction)` _(`/setup`)_                                                                                            | Name the test that left a key on `Object.prototype`, before the next file fails to collect                                                                                                                                                                                    |
+| `guardDocumentPollution(option)` _(`/setup`)_                                                                                               | Name the test that left an attribute on `<html>` / `<body>`, before a later file takes another branch on it                                                                                                                                                                   |
 | `consoleDebugSpy` … `consoleWarnSpy` _(`/console`)_                                                                                         | Silent typed spies replacing the global `console` methods on import                                                                                                                                                                                                           |
 | `installConsoleSpies()` / `resetConsoleSpies()` / `restoreConsole()`                                                                        | Install / clear / undo the console spies                                                                                                                                                                                                                                      |
 | `explainSpy(spy, method?)` _(`/diagnostics`)_                                                                                               | Every configured argument list next to every recorded call, attributed to the config it hit                                                                                                                                                                                   |

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-export { o as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as injectSpy, p as provideAutoSpy, q as provideAutoSpyForToken, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-C-DgtCj9.js';
+export { o as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as injectSpy, p as provideAutoSpy, q as provideAutoSpyForToken, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-BOfsdYsC.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal, ProviderToken, FactoryProvider, AbstractType, Injector, ValueProvider } from '@angular/core';
 import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-CmN9ADyN.js';
 export { C as CallbackSubscribable, E as EmissionObserver, b as EmissionOptions, c as EmissionSource, S as SubscribableLike, g as expectCompletion, h as expectEmission, i as expectEmissions, j as expectError, k as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CmN9ADyN.js';

package/dist/angular.js

@@ -3306,15 +3306,38 @@ function importsOf(definition2) {
 function isChildComponent(dependency) {
   return Reflect.get(dependency, "\u0275cmp") !== void 0;
 }
-function keptScope(definition2, options) {
+var DECLARATION_KEYS = ["\u0275cmp", "\u0275dir", "\u0275pipe"];
+function refusedInImports(dependency) {
+  if (Reflect.get(dependency, "\u0275mod") !== void 0) {
+    return void 0;
+  }
+  const definition2 = DECLARATION_KEYS.map((key) => Reflect.get(dependency, key)).find((value) => value !== void 0);
+  return definition2 !== void 0 && Reflect.get(definition2, "standalone") !== true ? dependency.name : void 0;
+}
+function assertScopeIsImportable(component, kept) {
+  const refused = kept.map(refusedInImports).filter((name) => name !== void 0);
+  if (refused.length === 0) {
+    return;
+  }
+  throw new Error(
+    withDocs(
+      `[vitest-auto-spy] renderShallow(${component.name}, { keepTemplate: true }): ${refused.length} of its template dependencies are declared by an NgModule rather than standalone \u2014 ${refused.join(", ")} \u2014 and Angular takes only standalone declarations and NgModules in \`imports\`.
+Nothing is wrong with those declarations, and the same call works under JIT. This is an AOT dependency list: ngtsc resolves an imported NgModule at compile time and flattens its exported declarations into the component, so the module that would carry them is not in the list to keep. The scope cannot be rebuilt from what the definition holds.
+Drop \`keepTemplate\` when the spec reads TypeScript state only \u2014 that is the case \`renderShallow\` is for \u2014 or build ${component.name} with \`TestBed\` directly, which keeps its compiled scope untouched, and hold the cost down by seeding the services its children inject rather than by trimming the template.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
+function keptScope(component, definition2, options) {
   const kept = importsOf(definition2).filter((dependency) => !isChildComponent(dependency));
   kept.push(...options.keepChildren ?? NOTHING);
+  assertScopeIsImportable(component, kept);
   return kept;
 }
-function buildOverride(definition2, options) {
+function buildOverride(component, definition2, options) {
   const override = {};
   if (isStandalone3(definition2)) {
-    override.imports = options.keepTemplate ? keptScope(definition2, options) : options.keepChildren ?? NOTHING;
+    override.imports = options.keepTemplate ? keptScope(component, definition2, options) : options.keepChildren ?? NOTHING;
     override.schemas = PERMISSIVE_SCHEMAS;
   }
   if (!options.keepTemplate) {
@@ -3341,7 +3364,7 @@ function renderShallow(component, options = {}) {
     // is right to report one, which made these two features of the same package cancel each other out.
     ...standalone ? {} : { schemas: PERMISSIVE_SCHEMAS }
   });
-  TestBed.overrideComponent(component, { set: buildOverride(definition2, options) });
+  TestBed.overrideComponent(component, { set: buildOverride(component, definition2, options) });
   options.beforeCreate?.();
   const fixture = TestBed.createComponent(component);
   applyInputs(fixture, options.inputs);

package/dist/bun-angular.d.ts

@@ -3,7 +3,7 @@ export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, Construct
 export { A as AutoMockConfiguration, a as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, b as EmissionOptions, c as EmissionSource, S as SubscribableLike, d as autoMocked, e as clearAutoSpyDefaults, f as createAutoMock, g as expectCompletion, h as expectEmission, i as expectEmissions, j as expectError, k as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-CmN9ADyN.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-lm-gqZAR.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-DnYNBNJL.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as injectSpy, p as provideAutoSpy, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-C-DgtCj9.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as injectSpy, p as provideAutoSpy, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-BOfsdYsC.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,7 +1,7 @@
 import { stable, flushEffects } from './chunk-M5BULP7X.js';
 export { flushEffects, stable } from './chunk-M5BULP7X.js';
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-4SJ7EGIY.js';
 import { currentSpecFile, mockValueProp } from './chunk-N3T7KWWA.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
 import { createSpyForToken } from './chunk-DUFMKOKF.js';
@@ -317,15 +317,38 @@ function importsOf(definition) {
 function isChildComponent(dependency) {
   return Reflect.get(dependency, "\u0275cmp") !== void 0;
 }
-function keptScope(definition, options) {
+var DECLARATION_KEYS = ["\u0275cmp", "\u0275dir", "\u0275pipe"];
+function refusedInImports(dependency) {
+  if (Reflect.get(dependency, "\u0275mod") !== void 0) {
+    return void 0;
+  }
+  const definition = DECLARATION_KEYS.map((key) => Reflect.get(dependency, key)).find((value) => value !== void 0);
+  return definition !== void 0 && Reflect.get(definition, "standalone") !== true ? dependency.name : void 0;
+}
+function assertScopeIsImportable(component, kept) {
+  const refused = kept.map(refusedInImports).filter((name) => name !== void 0);
+  if (refused.length === 0) {
+    return;
+  }
+  throw new Error(
+    withDocs(
+      `[vitest-auto-spy] renderShallow(${component.name}, { keepTemplate: true }): ${refused.length} of its template dependencies are declared by an NgModule rather than standalone \u2014 ${refused.join(", ")} \u2014 and Angular takes only standalone declarations and NgModules in \`imports\`.
+Nothing is wrong with those declarations, and the same call works under JIT. This is an AOT dependency list: ngtsc resolves an imported NgModule at compile time and flattens its exported declarations into the component, so the module that would carry them is not in the list to keep. The scope cannot be rebuilt from what the definition holds.
+Drop \`keepTemplate\` when the spec reads TypeScript state only \u2014 that is the case \`renderShallow\` is for \u2014 or build ${component.name} with \`TestBed\` directly, which keeps its compiled scope untouched, and hold the cost down by seeding the services its children inject rather than by trimming the template.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
+function keptScope(component, definition, options) {
   const kept = importsOf(definition).filter((dependency) => !isChildComponent(dependency));
   kept.push(...options.keepChildren ?? NOTHING);
+  assertScopeIsImportable(component, kept);
   return kept;
 }
-function buildOverride(definition, options) {
+function buildOverride(component, definition, options) {
   const override = {};
   if (isStandalone(definition)) {
-    override.imports = options.keepTemplate ? keptScope(definition, options) : options.keepChildren ?? NOTHING;
+    override.imports = options.keepTemplate ? keptScope(component, definition, options) : options.keepChildren ?? NOTHING;
     override.schemas = PERMISSIVE_SCHEMAS;
   }
   if (!options.keepTemplate) {
@@ -352,7 +375,7 @@ function renderShallow(component, options = {}) {
     // is right to report one, which made these two features of the same package cancel each other out.
     ...standalone ? {} : { schemas: PERMISSIVE_SCHEMAS }
   });
-  TestBed.overrideComponent(component, { set: buildOverride(definition, options) });
+  TestBed.overrideComponent(component, { set: buildOverride(component, definition, options) });
   options.beforeCreate?.();
   const fixture = TestBed.createComponent(component);
   applyInputs(fixture, options.inputs);

package/dist/bun.d.ts

@@ -551,6 +551,27 @@ type Subscribable<T> = [Extract<T, {
 }>] extends [never] ? T : Extract<T, {
     subscribe: Func;
 }>;
+/**
+ * The narrowing every optional read needs: neither `null` nor `undefined`, handed back.
+ *
+ * ```ts
+ * const covers = narrow.defined(row.content?.covers);
+ *
+ * expect(covers.map((cover) => cover.code)).toEqual(['a', 'b']);
+ * ```
+ *
+ * `expect(value).toBeDefined()` and `assert.exists(value)` both assert this, and neither **returns**
+ * it — so under a strict spec type-check each optional read costs two statements and a local that
+ * exists for the narrowing alone (`const x = obj.member; assert.exists(x); … x …`). That shape
+ * multiplies: one suite hit it fifteen times across four files, and twice it grew a helper function
+ * per member of a stub. This returns the value, so the narrowing sits inside the expression that
+ * needed it.
+ *
+ * It is not a replacement for `assert.exists` where the *assertion* is the point of the test. The
+ * difference is which of the two the line is about: asserting that a value arrived, or reading a
+ * value the test already knows arrived.
+ */
+declare function defined<T>(value: T, label?: string): NonNullable<T>;
 /**
  * The most common narrowing, without writing the guard: the branch that has this key.
  *
@@ -581,6 +602,8 @@ interface Narrow {
     <T>(value: T, predicate: (candidate: T) => boolean, label?: string): T;
     /** {@link byKey} */
     byKey: typeof byKey;
+    /** {@link defined} */
+    defined: typeof defined;
     /** {@link observable} */
     observable: typeof observable;
 }

package/dist/bun.js

@@ -1,5 +1,5 @@
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-4SJ7EGIY.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';

package/dist/{chunk-5XLI5JYC.js → chunk-4SJ7EGIY.js}

@@ -554,6 +554,12 @@ var narrowValue = defineHelper((value, predicate, label) => {
   }
   return value;
 });
+function defined(value, label = "a value that is neither null nor undefined") {
+  if (value === null || value === void 0) {
+    throw narrowingFailed(label, value);
+  }
+  return value;
+}
 function byKey(value, key) {
   if (typeof value !== "object" || value === null || !(key in value)) {
     throw narrowingFailed(`an object with a '${String(key)}' property`, value);
@@ -568,6 +574,7 @@ function observable(value) {
 }
 var narrow = Object.assign(narrowValue, {
   byKey: defineHelper(byKey),
+  defined: defineHelper(defined),
   observable: defineHelper(observable)
 });
 

package/dist/cli.js

@@ -2455,7 +2455,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.15.1";
+var EXPORT_MAP_VERSION = "5.17.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 17 18 19",
@@ -2571,6 +2571,8 @@ var EXPORTED_BY = {
   DirectiveHostOptions: "12",
   disableAngularDiagnostics: "12",
   disableTestBedDiagnostics: "12",
+  DocumentPollutionOptions: "20",
+  DocumentPollutionReaction: "20",
   DomRegistrar: "2",
   DuplicateCopiesReaction: "20",
   EmissionObserver: "0 1 2 3 4 12 17 18 19",
@@ -2612,6 +2614,7 @@ var EXPORTED_BY = {
   getWatchedTimerGlobals: "20",
   GlobalPatchReaction: "20",
   GlobalRegistratorOptions: "2",
+  guardDocumentPollution: "20",
   guardGlobalPatches: "20",
   guardPrototypePollution: "20",
   guardStrayConsole: "20",

package/dist/eslint-plugin.cjs

@@ -779,6 +779,8 @@ var SPY_FACTORIES = /* @__PURE__ */ new Set([
   "autoMocked",
   "createActivatedRoute",
   "createAutoMock",
+  "createComponentStub",
+  "createDirectiveHost",
   "createDocumentDouble",
   "createMock",
   "createRouterDouble",
@@ -904,6 +906,9 @@ function spreadOfImport(context, node) {
   const binding = findBinding(context.sourceCode.getScope(node), argument.name);
   return binding?.defs.some((definition) => definition.type === IMPORT_DEFINITION2) ? argument : void 0;
 }
+function spreadFailureMode(node) {
+  return isObjectExpression(node.parent) ? "object" : "iterable";
+}
 function isDeferred(node) {
   return isFunctionNode(node) || node.type === "PropertyDefinition" && Reflect.get(node, "static") !== true;
 }
@@ -3311,7 +3316,8 @@ var noImportTimeSpread = defineRule({
   description: "Do not spread an imported binding at module scope \u2014 inside a bundle it can still be undefined",
   hasSuggestions: true,
   messages: {
-    noImportTimeSpread: "This spreads `{{name}}`, a binding another module owns, while this module is still being evaluated. Under `tsc` and under a browser\u2019s ESM loader that is safe \u2014 nothing runs before its dependency. Inside one bundle it is not: the spec bundle emits shared chunks, a chunk can be evaluated while the binding it re-exports is still `undefined`, and `[...undefined]` throws `Spread syntax requires ...iterable[Symbol.iterator] to be a function` before a single test runs \u2014 on a tree whose every test passes. Build the value lazily (a function, called where it is read), or inline the constant so nothing has to be imported for this line to work. Nothing inside a function body is reported: that runs later, which is the whole repair."
+    noImportTimeSpread: "This spreads `{{name}}`, a binding another module owns, while this module is still being evaluated. Under `tsc` and under a browser\u2019s ESM loader that is safe \u2014 nothing runs before its dependency. Inside one bundle it is not: the spec bundle emits shared chunks, a chunk can be evaluated while the binding it re-exports is still `undefined`, and `[...undefined]` throws `Spread syntax requires ...iterable[Symbol.iterator] to be a function` before a single test runs \u2014 on a tree whose every test passes. Build the value lazily (a function, called where it is read), or inline the constant so nothing has to be imported for this line to work. Nothing inside a function body is reported: that runs later, which is the whole repair.",
+    noImportTimeSpreadObject: "This spreads `{{name}}`, a binding another module owns, into an object literal while this module is still being evaluated. Under `tsc` and under a browser\u2019s ESM loader that is safe \u2014 nothing runs before its dependency. Inside one bundle it is not: the spec bundle emits shared chunks, and a chunk can be evaluated while the binding it re-exports is still `undefined`. Do not look for an error \u2014 an object spread of `undefined` throws nothing, `{ ...undefined }` is `{}`, so the module loads and every key this line was meant to copy reads `undefined` for the rest of the run, on a tree whose every test passes. Build the value lazily (a function, called where it is read), or write the keys out so nothing has to be imported for this line to work. Nothing inside a function body is reported: that runs later, which is the whole repair."
   },
   create: (context) => ({
     SpreadElement: (node) => {
@@ -3320,7 +3326,8 @@ var noImportTimeSpread = defineRule({
         return;
       }
       const suggestion = lazyValueSuggestion(context, node);
-      const report = { node, messageId: "noImportTimeSpread", data: { name: imported.name } };
+      const messageId = spreadFailureMode(node) === "object" ? "noImportTimeSpreadObject" : "noImportTimeSpread";
+      const report = { node, messageId, data: { name: imported.name } };
       context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
     }
   })

package/dist/index.js

@@ -2885,6 +2885,12 @@ var narrowValue = defineHelper((value, predicate, label) => {
   }
   return value;
 });
+function defined(value, label = "a value that is neither null nor undefined") {
+  if (value === null || value === void 0) {
+    throw narrowingFailed(label, value);
+  }
+  return value;
+}
 function byKey(value, key) {
   if (typeof value !== "object" || value === null || !(key in value)) {
     throw narrowingFailed(`an object with a '${String(key)}' property`, value);
@@ -2899,6 +2905,7 @@ function observable(value) {
 }
 var narrow = Object.assign(narrowValue, {
   byKey: defineHelper(byKey),
+  defined: defineHelper(defined),
   observable: defineHelper(observable)
 });
 

package/dist/node.cjs

@@ -2618,6 +2618,12 @@ var narrowValue = defineHelper((value, predicate, label) => {
   }
   return value;
 });
+function defined(value, label = "a value that is neither null nor undefined") {
+  if (value === null || value === void 0) {
+    throw narrowingFailed(label, value);
+  }
+  return value;
+}
 function byKey(value, key) {
   if (typeof value !== "object" || value === null || !(key in value)) {
     throw narrowingFailed(`an object with a '${String(key)}' property`, value);
@@ -2632,6 +2638,7 @@ function observable(value) {
 }
 var narrow = Object.assign(narrowValue, {
   byKey: defineHelper(byKey),
+  defined: defineHelper(defined),
   observable: defineHelper(observable)
 });
 

package/dist/node.js

@@ -1,4 +1,4 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-4SJ7EGIY.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';

package/dist/react.js

@@ -1,4 +1,4 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-4SJ7EGIY.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';

package/dist/rstest.js

@@ -1,4 +1,4 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-4SJ7EGIY.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
 export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';