vitest-auto-spy 5.15.0 → 5.16.0

package/AGENTS.md

@@ -255,6 +255,12 @@ reads the member, not where the provider literal is evaluated. A `{ set }` seed
 and takes the write. Both used to be flattened as the double was built, which turned a throwing
 seed into a failure during `TestBed.configureTestingModule`, three frames from the branch under test.
 
+A **registration** is no exception, and it was the half that stayed broken one release longer: the
+merge that puts `registerAutoSpyDefaults` under a call site copied both sides with a spread, so a
+seeded getter was flattened on any class or token the registry knows — whether or not the
+registration names that key — while the same seed stayed live on one it does not. The merge copies
+descriptors now, and the seed behaves the same either way.
+
 ### What a Proxy-backed double cannot do
 
 `createAutoMock` and `mockDeep` build a Proxy, not an object, and there is one place where the
@@ -3183,7 +3189,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`                                                                                                                                                                                                                                                                                                           |
@@ -3275,7 +3281,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`.
@@ -3461,6 +3472,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`                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -3552,6 +3564,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

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-17.5%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-17.6%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -2043,6 +2043,10 @@ const platform = createAutoMock<PlatformSupport>({
 expect(() => platform.transceiver).toThrow(); // at the read, not at `TestBed.configureTestingModule`
 ```
 
+A class or token registered with `registerAutoSpyDefaults` behaves the same: the merge that puts a
+registration under the call site copies descriptors rather than spreading them, so a seeded getter
+is not flattened by the mere existence of a registration.
+
 For a double the code under test only **reads** — a DTO, a route snapshot, a config object — that
 caveat is the wrong trade, and [`createMock<T>()`](#utilities) is the other half of the pair: it
 returns a plain `T` built from the fields you seed, with no spies anywhere.
@@ -2404,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:
@@ -2878,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                                                                                                                                         |
@@ -3456,7 +3467,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` |
@@ -3538,7 +3549,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

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

@@ -729,6 +729,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -749,7 +755,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }
@@ -3300,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) {
@@ -3335,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,12 +1,12 @@
 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-63S25O6W.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-I6AIKRUJ.js';
-import { createSpyFromClass } from './chunk-C3EFC33U.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
+import { createSpyForToken } from './chunk-DUFMKOKF.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.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,7 +1,7 @@
 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-63S25O6W.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-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/{chunk-63S25O6W.js → chunk-4SJ7EGIY.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-N3T7KWWA.js';
-import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-C3EFC33U.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-WAMFS3UI.js';
 import { resolveReadGuard, createTrackedPropSpy } from './chunk-OS4PTU6D.js';
 import { redefineFailure } from './chunk-DTZCPCMA.js';
 import { DISPOSE } from './chunk-PC3FAZT3.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/{chunk-I6AIKRUJ.js → chunk-DUFMKOKF.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-C3EFC33U.js';
+import { createSpyFromClass, createAutoMock } from './chunk-WAMFS3UI.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 
 // src/lib/track-injections.ts

package/dist/{chunk-C3EFC33U.js → chunk-WAMFS3UI.js}

@@ -301,6 +301,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -317,7 +323,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }

package/dist/cli.js

@@ -2455,7 +2455,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.15.0";
+var EXPORT_MAP_VERSION = "5.16.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",

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

@@ -1892,6 +1892,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -1908,7 +1914,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }
@@ -2879,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);
@@ -2893,6 +2905,7 @@ function observable(value) {
 }
 var narrow = Object.assign(narrowValue, {
   byKey: defineHelper(byKey),
+  defined: defineHelper(defined),
   observable: defineHelper(observable)
 });
 

package/dist/jasmine.js

@@ -1,7 +1,7 @@
 import { useVitestAdapter } from './chunk-PA4ZNLNZ.js';
 import { enableJasmineCompat } from './chunk-MAKQSO2R.js';
 export { enableJasmineCompat } from './chunk-MAKQSO2R.js';
-import { createSpyFromClass } from './chunk-C3EFC33U.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/nestjs.js

@@ -1,6 +1,6 @@
-import { createSpyForToken } from './chunk-I6AIKRUJ.js';
-export { trackInjections } from './chunk-I6AIKRUJ.js';
-import { createSpyFromClass } from './chunk-C3EFC33U.js';
+import { createSpyForToken } from './chunk-DUFMKOKF.js';
+export { trackInjections } from './chunk-DUFMKOKF.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/node.cjs

@@ -1614,6 +1614,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -1630,7 +1636,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }
@@ -2612,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);
@@ -2626,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,6 +1,6 @@
-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-63S25O6W.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-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { guardAccessorSpies, createRedefineMockAdapter } from './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/react.js

@@ -1,6 +1,6 @@
-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-63S25O6W.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-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/rstest.js

@@ -1,6 +1,6 @@
-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-63S25O6W.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-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-33NJHIS2.js';
 import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-DTZCPCMA.js';

package/dist/svelte.js

@@ -1,6 +1,6 @@
-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-63S25O6W.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-C3EFC33U.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/{track-signal-runs-C-DgtCj9.d.ts → track-signal-runs-BOfsdYsC.d.ts}

@@ -239,8 +239,14 @@ interface RenderShallowOptions<T> {
     /**
      * Keep the real template instead of blanking it — for `viewChild`, content projection, host
      * bindings. The template's own pipes and directives stay resolvable; child components are still
-     * dropped, which is what keeps the render shallow. A child re-exported by an imported `NgModule`
-     * is the one thing that survives, because the module is kept whole.
+     * dropped, which is what keeps the render shallow. Under JIT a child re-exported by an imported
+     * `NgModule` survives, because the module is kept whole.
+     *
+     * Under **AOT** an imported `NgModule` is not in the compiled dependency list at all — ngtsc
+     * resolves its exported scope and flattens the declarations into the list instead — so a
+     * `standalone: false` pipe or directive is what arrives, and Angular refuses one of those in
+     * `imports`. That case throws with the declaration named rather than letting Angular blame the
+     * pipe's author; see the error for what to do instead.
      */
     keepTemplate?: boolean;
     /** Child components/directives/pipes to keep resolvable in the template (everything else is dropped). */

package/dist/vue.js

@@ -1,7 +1,7 @@
-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-63S25O6W.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';
-import { createSpyFromClass } from './chunk-C3EFC33U.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-C3EFC33U.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.15.0",
+  "version": "5.16.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",