vitest-auto-spy 3.12.1 → 3.13.1

package/AGENTS.md

@@ -358,6 +358,8 @@ users.getName.calledWith(1).mockReturnValue('Ada');
 users.getName.mustBeCalledWith(1).mockReturnValue('Ada');
 // asymmetric matchers work in both
 users.save.calledWith(expect.objectContaining({ id: 1 })).mockReturnValue(true);
+// re-registering the same arguments replaces the answer — matcher arguments included
+users.save.calledWith(expect.objectContaining({ id: 1 })).mockReturnValue(false);
 
 // promises
 users.load.resolveWith({ id: 1 });
@@ -374,6 +376,13 @@ feed.items$.throwWith('FAKE ERROR');
 const subject = feed.items$.returnSubject(); // ReplaySubject, for anything the helpers miss
 ```
 
+An exact argument list is matched before the asymmetric configs, and those are tried in
+registration order — a narrow config written first keeps its calls. Two matchers count as the same
+argument when they accept the same values (same matcher class, sample and inversion), which is what
+makes a second `calledWith(1, expect.anything())` an override rather than a second config sitting
+behind the first. A hand-rolled `{ asymmetricMatch }` object is compared by identity instead: its
+verdict is a closure, so only re-registering that same instance overrides.
+
 `mock.settledResults` is native on Vitest and polyfilled on Bun / `node:test`, so it is identical on
 all three. Entries are `{ type: 'fulfilled' | 'incomplete' | 'rejected', value }`.
 
@@ -958,8 +967,19 @@ by a dynamic `import()` inside a test — and says so explicitly:
 export const navigation = { setFocus: keepMockRegistered(vi.fn()) };
 ```
 
-`trackMockRegistry()` installs the pair of hooks on its own, `pruneMockRegistry()` is the one-shot
-sweep (it returns how many went) and `getMockRegistrySize()` reports what is left.
+The mocks it keeps, it also guards. Staying registered means `vi.resetAllMocks()` reaches them too —
+it walks the same set and calls `mockReset()`, which puts an implementation back only when it was
+passed to `vi.fn(implementation)`; behaviour chained on with `.mockReturnValue(…)` or
+`.mockReturnThis()` is simply lost. Under `isolate: false` that surfaces in a *different* file later
+in the same worker, inside application code, as `Cannot read properties of undefined` against a
+shared double that spec never touched — and `vi.restoreAllMocks()` does not cause it (Vitest 4 walks
+`MOCK_RESTORE` there, which only `vi.spyOn` writes to), so probing with that one comes back green and
+sends the search the wrong way. The implementation a long-lived mock carried when it was classified
+is therefore remembered and put back, in `beforeEach`, but only when it has gone missing.
+
+`trackMockRegistry()` installs the hooks on its own, `pruneMockRegistry()` is the one-shot sweep (it
+returns how many went), `restoreLongLivedImplementations()` is that repair (it returns how many it
+put back) and `getMockRegistrySize()` reports what is left.
 
 Two more switches, both about the environment rather than the spies:
 

package/README.md

@@ -16,7 +16,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 [![npm version](https://img.shields.io/npm/v/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![npm downloads](https://img.shields.io/npm/dm/vitest-auto-spy?color=brightgreen&logo=npm)](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-14.6%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-14.8%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)
@@ -1231,6 +1231,24 @@ Wanted: getName(1)
 Actual: getName(2)
 ```
 
+### Matching order, and re-configuring the same arguments
+
+An exact argument list is matched first; the asymmetric configs (`expect.any(Number)`,
+`expect.objectContaining({ … })`, …) are then tried in the order they were registered, so a narrow
+config placed before a wide one keeps its calls. Registering the **same** argument list again
+replaces the answer it gave before — matcher arguments included:
+
+```ts
+myService.getName.calledWith(expect.anything()).mockReturnValue('first');
+myService.getName.calledWith(expect.anything()).mockReturnValue('second');
+expect(myService.getName(1)).toBe('second');
+```
+
+Each `expect.anything()` is a new object, so the two are compared by what they accept rather than by
+identity — same matcher class, same sample, same inversion. A hand-rolled `{ asymmetricMatch }`
+object is the exception: its verdict lives in a closure nothing can read, so two of them are always
+two configs and only the very same instance, re-registered, overrides.
+
 ## Promise-returning methods
 
 ```ts
@@ -1901,7 +1919,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `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                                                                               |
-| `trackMockRegistry()` / `keepMockRegistered(mock)`                                   | `/setup`                      | Keep @vitest/spy's mock registry to the mocks that outlive a file; mark one the split would miss ([details](#test-run-hygiene))                               |
+| `trackMockRegistry()` / `keepMockRegistered(mock)` / `restoreLongLivedImplementations()` | `/setup`                      | Keep @vitest/spy's mock registry to the mocks that outlive a file; mark one the split would miss; put back an implementation a cross-file `vi.resetAllMocks()` dropped ([details](#test-run-hygiene)) |
 | `errorHandler`                                                                       | core                          | The `mustBeCalledWith` argument-mismatch reporter — swap it to customize failure output                                                                       |
 
 A taste of the DI pair — provide the spy, inject it back fully typed:
@@ -2065,7 +2083,12 @@ expensive to diagnose when it is missing. The first three are on by default:
    component trees. Pruning it is easy to get wrong in one specific way: drop the module-level
    `vi.fn()` that six spec files import from a shared `*.mock.ts` and nothing clears it any more, so
    its calls accumulate and the file that happens to run second fails on calls its predecessor made.
-   `pruneMockRegistry` keeps what a file inherited and drops only what it added.
+   `pruneMockRegistry` keeps what a file inherited and drops only what it added. Keeping a mock
+   registered also means `vi.resetAllMocks()` can reach it — `mockReset` drops an implementation
+   that came from a chained `.mockReturnValue(…)`, which under `isolate: false` kills a *later*
+   file's test on a double it never touched — so `trackMockRegistry()` remembers the implementation
+   each long-lived mock carried and puts it back before a test that has lost it
+   (`restoreLongLivedImplementations()` is that repair on its own, and returns how many it put back).
 9. **A hook that ran out of a budget nobody meant to give it.** On by default, because it only ever
    appends a sentence to a test that has already failed. Jest applies one `testTimeout` to a hook and
    to a test body alike; Vitest resolves `hookTimeout` separately and defaults it to 10 000 ms, so a
@@ -2395,6 +2418,7 @@ names are unfindable from these messages otherwise — no `TS2739` text contains
 | `TS2345: Argument of type 'Spy<X>' is not assignable to parameter of type 'X'`   | the same, in an argument                  | `asInstance(spy)`, or `asInstances(a, b, c)`        |
 | `TS2322: Type 'Spy<X>' is not assignable to type 'Mocked<X>' …`                  | the variable was declared `Mocked<T>`     | declare it `Spy<T>`                                 |
 | `'AddPromiseSpyMethods<unknown>' is missing … from type 'WithMockReturnValue<…>'` | a generic class inferred as `Service<any>` | `asSpy<Service>(…)` / `injectSpy<Service>(…)`      |
+| `TS2345` / `TS2554` **on a call to a spied method** (wrong arguments)            | the arguments the real method rejects — the double's call signature is the method's own; it used to accept anything | fix the call; don't re-widen the spy |
 | `TS2739 … 'Spy<X>' is missing …` **on a line with `injectSpy`**                  | the provider handed back the real object  | `provideAutoSpy(X)`, or an honest `TestBed.inject`  |
 
 Two notes that cost real time when they are missing.

package/dist/angular.d.ts

@@ -1,9 +1,9 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BUNSBSIP.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-CEhs7o9p.js';
 import { Type, Signal, WritableSignal } from '@angular/core';
-import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BAzV5ITq.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-IgCwv_40.js';
-export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CuGjE0YR.js';
+import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BQndbppn.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DyjtZVoA.js';
+export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-DMx5uXie.js';
 import '@angular/core/testing';
 import 'rxjs';
 import 'vitest';

package/dist/angular.js

@@ -102,6 +102,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -172,6 +175,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -186,19 +205,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -228,6 +235,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of
@@ -1796,7 +1846,14 @@ var AutoSpyInjector = class extends Injector {
   tokens() {
     return [...this.#spies.keys()];
   }
+  knows(token) {
+    return this.#spies.has(token);
+  }
 };
+function describeToken(token) {
+  const name = Reflect.get(Object(token), "name");
+  return typeof name === "string" ? name : String(token);
+}
 function factoryOf(target) {
   const factory = Reflect.get(target, "\u0275fac");
   return typeof factory === "function" ? factory : void 0;
@@ -1811,6 +1868,14 @@ function createWithAutoSpies(target, options = {}) {
     injector,
     spies: {
       get: (token) => {
+        if (!autoSpies.knows(token) && injector.get(token, null, { optional: true }) === null) {
+          throw new Error(
+            withDocs(
+              `[vitest-auto-spy] createWithAutoSpies(${describeToken(target)}).spies.get(${describeToken(token)}): the instance never asked for that token, and nothing in \`providers\` supplies it, so the spy you would get back is not the one it uses. Auto-spied tokens: ${autoSpies.tokens().map(describeToken).join(", ") || "(none)"}.`,
+              DOCS_LINKS.angular
+            )
+          );
+        }
         return injector.get(token);
       },
       autoSpiedTokens: () => autoSpies.tokens()

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.js';
+export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CuGjE0YR.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-IgCwv_40.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-DMx5uXie.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BUNSBSIP.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-CEhs7o9p.js';
 import 'rxjs';
 import 'vitest';
 import '@angular/core';
@@ -72,6 +72,12 @@ declare function registerDomGlobals(options?: RegisterDomGlobalsOptions): Promis
  * implementation. A property the target refuses to accept is skipped rather than fatal — a locked
  * global is not worth failing a whole test run over.
  *
+ * Skipped, but **not** in silence when it is one of {@link FORCED_GLOBALS}: those are the five the
+ * DOM is useless without, so a refused `document` means the environment came up half-installed and
+ * the first spec that touches it reports `document is not defined` — naming neither this helper nor
+ * the property that refused. The rest stay quiet, because a host built-in keeping its own
+ * implementation is the documented outcome rather than a problem.
+ *
  * @example
  * ```ts
  * copyWindowGlobals(dom.window as unknown as Record<string, unknown>, globalThis as Record<string, unknown>);

package/dist/bun-angular.js

@@ -1,12 +1,12 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-JV5XRAS4.js';
+import { createSpyForToken } from './chunk-CEVEKNJZ.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-ZBVBJFNW.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass } from './chunk-7YTPHYP7.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-3AWKPZCE.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+import { createSpyFromClass } from './chunk-PCP6A6PD.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-ZY7KPBJJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import '@angular/compiler';
 import { NgModule, provideZonelessChangeDetection, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';
@@ -160,6 +160,7 @@ ${failures.join("\n") || "  - (no registrars were configured)"}`,
 }
 function copyWindowGlobals(source, target) {
   const keys = [...FORCED_GLOBALS, ...Object.getOwnPropertyNames(source)];
+  const refused = [];
   for (const key of keys) {
     if (key.startsWith("_")) {
       continue;
@@ -170,9 +171,21 @@ function copyWindowGlobals(source, target) {
     }
     try {
       Object.defineProperty(target, key, { value, configurable: true, writable: true, enumerable: true });
-    } catch {
+    } catch (error) {
+      if (FORCED_GLOBALS.includes(key)) {
+        refused.push(`${key} (${describeError(error)})`);
+      }
     }
   }
+  if (refused.length === 0) {
+    return;
+  }
+  console.warn(
+    withDocs(
+      `[vitest-auto-spy] copyWindowGlobals: the host refused to redefine ${refused.join(", ")}. The DOM is only half-installed, and the failure will arrive later as "document is not defined" or an unrelated jsdom assertion, naming neither this helper nor the property. Something sealed that global before the preload ran.`,
+      DOCS_LINKS.bunAngular
+    )
+  );
 }
 function createJsdomRegistrar(options) {
   return {
@@ -237,7 +250,14 @@ var AutoSpyInjector = class extends Injector {
   tokens() {
     return [...this.#spies.keys()];
   }
+  knows(token) {
+    return this.#spies.has(token);
+  }
 };
+function describeToken(token) {
+  const name = Reflect.get(Object(token), "name");
+  return typeof name === "string" ? name : String(token);
+}
 function factoryOf(target) {
   const factory = Reflect.get(target, "\u0275fac");
   return typeof factory === "function" ? factory : void 0;
@@ -252,6 +272,14 @@ function createWithAutoSpies(target, options = {}) {
     injector,
     spies: {
       get: (token) => {
+        if (!autoSpies.knows(token) && injector.get(token, null, { optional: true }) === null) {
+          throw new Error(
+            withDocs(
+              `[vitest-auto-spy] createWithAutoSpies(${describeToken(target)}).spies.get(${describeToken(token)}): the instance never asked for that token, and nothing in \`providers\` supplies it, so the spy you would get back is not the one it uses. Auto-spied tokens: ${autoSpies.tokens().map(describeToken).join(", ") || "(none)"}.`,
+              DOCS_LINKS.angular
+            )
+          );
+        }
         return injector.get(token);
       },
       autoSpiedTokens: () => autoSpies.tokens()

package/dist/bun.d.ts

@@ -1,7 +1,7 @@
-import { s as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, l as DeepPartial, D as DeepMockProxy, F as Func, u as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.js';
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, k as AddVoidReturnHelpers, b as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, m as Mutable, N as NextValueConfig, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, r as SpyDisposable, t as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CuGjE0YR.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-IgCwv_40.js';
+import { s as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, l as DeepPartial, D as DeepMockProxy, F as Func, u as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.js';
+export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, k as AddVoidReturnHelpers, b as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, m as Mutable, N as NextValueConfig, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, r as SpyDisposable, t as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-DMx5uXie.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
 import 'rxjs';
@@ -790,6 +790,11 @@ interface AssertMockedOptions {
      *
      * Worth naming when the factory stubs part of a module and re-exports the rest: without a list,
      * a factory that lost the one export the test drives still looks mocked.
+     *
+     * An **empty** list is rejected rather than accepted: `exports: []` — which is what
+     * `Object.keys(stubs)` or a filtered constant produces when it comes out empty — used to take the
+     * named-exports branch, find nothing to check and return, so the one call in the file whose job
+     * is to prove the mock applied proved nothing.
      */
     exports?: readonly string[];
 }

package/dist/bun.js

@@ -1,7 +1,7 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-ZBVBJFNW.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';

package/dist/{chunk-ZBVBJFNW.js → chunk-C3IZLTSJ.js}

@@ -1,6 +1,6 @@
-import { mockValueProp, mockReadonlyPropGetter } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, DISPOSE, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-7YTPHYP7.js';
-import { defineHelper, withDocs, DOCS_LINKS, serializeValue, createFunctionSpy, DEEP_CHILDREN } from './chunk-3AWKPZCE.js';
+import { mockValueProp, mockReadonlyPropGetter } from './chunk-WVW4XRL5.js';
+import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, DISPOSE, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-PCP6A6PD.js';
+import { defineHelper, withDocs, DOCS_LINKS, serializeValue, createFunctionSpy, DEEP_CHILDREN } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter } from './shared-state.js';
 export { describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, getPackageCopies, setEmissionTimeout } from './shared-state.js';
 
@@ -442,6 +442,14 @@ var SILENT_NO_OP_CAUSES = "A `vi.mock()` that does not apply reports nothing: un
 var assertMocked = defineHelper((namespace, options = {}) => {
   const target = describeTarget(options.specifier);
   const required = options.exports;
+  if (required?.length === 0) {
+    throw new Error(
+      withDocs(
+        `[vitest-auto-spy] assertMocked(${target}): the \`exports\` list is empty, so this call cannot fail and proves nothing. Drop the option to check that at least one export is a mock, or name the exports the test drives.`,
+        DOCS_LINKS.moduleMocks
+      )
+    );
+  }
   if (required) {
     const real = required.filter((name) => !isRunnerMock(Reflect.get(namespace, name)));
     if (real.length > 0) {

package/dist/{chunk-JV5XRAS4.js → chunk-CEVEKNJZ.js}

@@ -1,5 +1,5 @@
-import { createSpyFromClass, createAutoMock } from './chunk-7YTPHYP7.js';
-import { withDocs, DOCS_LINKS } from './chunk-3AWKPZCE.js';
+import { createSpyFromClass, createAutoMock } from './chunk-PCP6A6PD.js';
+import { withDocs, DOCS_LINKS } from './chunk-ZY7KPBJJ.js';
 
 // src/lib/track-injections.ts
 function createSpyForToken(token) {

package/dist/{chunk-7YTPHYP7.js → chunk-PCP6A6PD.js}

@@ -1,4 +1,4 @@
-import { runClearHook, runConfigReset, resolveUnstubbedGuard, withDocs, DOCS_LINKS, AUTO_SPY_MARK, createFunctionSpy, isMarkedMock, readDeepChildren, markAsMock } from './chunk-3AWKPZCE.js';
+import { runClearHook, runConfigReset, resolveUnstubbedGuard, withDocs, DOCS_LINKS, AUTO_SPY_MARK, createFunctionSpy, isMarkedMock, readDeepChildren, markAsMock } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter, requireObservableSupport } from './shared-state.js';
 
 // src/lib/dispose-symbol.ts

package/dist/{chunk-R4EWAG7Y.js → chunk-WVW4XRL5.js}

@@ -1,4 +1,4 @@
-import { withDocs, DOCS_LINKS } from './chunk-3AWKPZCE.js';
+import { withDocs, DOCS_LINKS } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter } from './shared-state.js';
 
 // src/lib/redefine-failure.ts

package/dist/{chunk-3AWKPZCE.js → chunk-ZY7KPBJJ.js}

@@ -81,6 +81,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -187,6 +190,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -201,19 +220,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -243,6 +250,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of

package/dist/console.d.ts

@@ -1,4 +1,4 @@
-import { j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.js';
+import { j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.js';
 import 'rxjs';
 import 'vitest';
 

package/dist/console.js

@@ -1,5 +1,5 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-import { createFunctionSpy } from './chunk-3AWKPZCE.js';
+import { createFunctionSpy } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { hasMockAdapter, registerMockAdapter, getMockAdapter } from './shared-state.js';
 

package/dist/{expect-emission-CuGjE0YR.d.ts → expect-emission-DMx5uXie.d.ts}

@@ -1,4 +1,4 @@
-import { t as StrictSpyConfiguration, n as OnlyObservablePropsOf, M as MethodReturns, l as DeepPartial, S as Spy, s as SpyOptions } from './types-it6CnDkI.js';
+import { t as StrictSpyConfiguration, n as OnlyObservablePropsOf, M as MethodReturns, l as DeepPartial, S as Spy, s as SpyOptions } from './types-Br-Usge9.js';
 
 /**
  * Create a fully-typed auto-mock of `T` from its type alone (no class).

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.js';
+export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CuGjE0YR.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-IgCwv_40.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-DMx5uXie.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';