vitest-auto-spy 4.2.0 → 4.3.0

package/dist/console.js

@@ -1,6 +1,6 @@
-import { vitestMockAdapter } from './chunk-WQZ2RKS7.js';
+import { vitestMockAdapter } from './chunk-KYAJCFUA.js';
 import './chunk-YHDBRBGU.js';
-import { createFunctionSpy } from './chunk-4KK3ES4P.js';
+import { createFunctionSpy } from './chunk-FFKN6QKI.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/diagnostics.d.ts

@@ -90,4 +90,34 @@ declare function formatTestRunComparison(comparison: TestRunComparison): string;
  */
 declare function diffByField(actual: readonly unknown[], expected: readonly unknown[]): string | undefined;
 
-export { type TestRunComparison, type TestRunReport, type TestRunSummary, compareTestRuns, diffByField, formatTestRunComparison, summarizeTestRun };
+/**
+ * Explain what a double is configured to answer and what it was actually asked.
+ *
+ * With no `method`, every spied member that the double exposes is reported; with one, only that
+ * member. The result is a report to print — `console.log(explainSpy(users))` — not something to
+ * assert on.
+ *
+ * @example
+ * ```ts
+ * const users = createSpyFromClass(UserService);
+ * users.load.calledWith(1).resolveWith('ok');
+ *
+ * await users.load(2);
+ *
+ * console.log(explainSpy(users, 'load'));
+ * // [vitest-auto-spy] explainSpy
+ * //
+ * // load — 1 call, 1 configured, none matched
+ * //   configured:
+ * //     #1 calledWith(1)
+ * //   calls:
+ * //     #1 load(2) -> no configured arguments matched; the default value was used
+ * ```
+ *
+ * @param spy A double, or a single function spy off one.
+ * @param method Restrict the report to one member.
+ * @returns A human-readable report; never throws, whatever it was handed.
+ */
+declare function explainSpy(spy: object, method?: string): string;
+
+export { type TestRunComparison, type TestRunReport, type TestRunSummary, compareTestRuns, diffByField, explainSpy, formatTestRunComparison, summarizeTestRun };

package/dist/diagnostics.js

@@ -1,3 +1,5 @@
+import { getMockAdapter } from './shared-state.js';
+
 // src/lib/compare-runs.ts
 function shorten(file, root) {
   if (root === void 0) {
@@ -123,6 +125,9 @@ function serializePrimitive(value) {
   }
   return String(value);
 }
+function isDeepValue(value) {
+  return typeof value === "object" && value !== null;
+}
 function serializeInContext(value, context) {
   if (typeof value === "object" && value !== null) {
     return serializeObject(value, context);
@@ -199,4 +204,348 @@ function diffByField(actual, expected) {
   return [`${affected.size} of ${actual.length} elements differ.`, ...lines].join("\n");
 }
 
-export { compareTestRuns, diffByField, formatTestRunComparison, summarizeTestRun };
+// src/lib/args-map.ts
+function isSinglePrimitiveArgs(args) {
+  if (args.length !== 1) {
+    return false;
+  }
+  const [argument] = args;
+  const kind = typeof argument;
+  if (kind === "object" || kind === "function" || kind === "symbol") {
+    return argument === null;
+  }
+  return !Object.is(argument, -0);
+}
+function isAsymmetricMatcher(value) {
+  return typeof value === "object" && value !== null && "asymmetricMatch" in value && typeof value.asymmetricMatch === "function";
+}
+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.
+  #map = /* @__PURE__ */ Object.create(null);
+  #matcherConfigs = [];
+  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
+  // that map — two arg lists of different lengths never serialize to the same string — so the
+  // serialization can be skipped outright. That matters because the map is consulted on *every*
+  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
+  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
+  // build a key that provably cannot match, and throws it away one line later.
+  #arities = /* @__PURE__ */ new Set();
+  /**
+   * The configs of exactly one primitive argument, keyed by the argument itself.
+   *
+   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+   * do on the value with no allocation at all. The configs live in both maps: the string map still
+   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+   * changes.
+   *
+   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+   */
+  #exactSinglePrimitive = /* @__PURE__ */ new Map();
+  set(key, value) {
+    if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
+      return;
+    }
+    if (Array.isArray(key)) {
+      this.#arities.add(key.length);
+      if (isSinglePrimitiveArgs(key)) {
+        this.#exactSinglePrimitive.set(key[0], value);
+      }
+    }
+    this.#map[this.#serialize(key)] = value;
+  }
+  get(key) {
+    if (Array.isArray(key) && !this.#arities.has(key.length)) {
+      return this.#findByMatcher(key);
+    }
+    if (Array.isArray(key) && isSinglePrimitiveArgs(key)) {
+      const hit = this.#exactSinglePrimitive.get(key[0]);
+      return hit === void 0 ? this.#findByMatcher(key) : hit;
+    }
+    const serialized = this.#serialize(key);
+    if (serialized in this.#map) {
+      return this.#map[serialized];
+    }
+    return this.#findByMatcher(key);
+  }
+  /**
+   * Every configured argument list, rendered the way a lookup key is — the *wanted* half of a
+   * `mustBeCalledWith` failure.
+   *
+   * Nothing is rendered here: the exact configs are keyed by their own serialization, and an
+   * asymmetric config carries the description built when it was registered. A failure message is
+   * assembling text it already has.
+   */
+  configured() {
+    const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
+    return [...Object.keys(this.#map), ...asymmetric];
+  }
+  /**
+   * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
+   * returns, each carrying its own position and its own predicate.
+   *
+   * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
+   * registration order), so the first entry whose `matches` holds is the config `get` would have
+   * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
+   * configs and a list of calls with nothing joining them.
+   */
+  configuredEntries() {
+    const exact = Object.keys(this.#map).map((key, position) => ({
+      index: position + 1,
+      args: key,
+      matches: (actualArgs) => this.#serialize(actualArgs) === key
+    }));
+    const asymmetric = this.#matcherConfigs.map((config, position) => ({
+      index: exact.length + position + 1,
+      args: `[${config.described.join(",")}]`,
+      matches: (actualArgs) => this.#argsMatch(config, actualArgs)
+    }));
+    return [...exact, ...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
+  // only primitive args take a fast path that skips the circular-ref bookkeeping.
+  #serialize(key) {
+    if (Array.isArray(key) && !key.some(isDeepValue)) {
+      return `[${key.map((arg) => serializePrimitive(arg)).join(",")}]`;
+    }
+    return serializeValue(key);
+  }
+  /** Return the value of the first asymmetric config whose predicate matches the actual args. */
+  #findByMatcher(actualArgs) {
+    if (!Array.isArray(actualArgs)) {
+      return void 0;
+    }
+    const match = this.#matcherConfigs.find((config) => this.#argsMatch(config, actualArgs));
+    return match?.value;
+  }
+  /** Whether every configured arg matches the actual arg at the same position (same length). */
+  #argsMatch(config, actualArgs) {
+    if (config.args.length !== actualArgs.length) {
+      return false;
+    }
+    return config.args.every((configArg, index) => this.#valueMatches(configArg, config.serialized[index], actualArgs[index]));
+  }
+  /**
+   * Match a single arg: asymmetric matchers delegate to `asymmetricMatch`, others compare the
+   * config arg's serialization — rendered once at `set()` time — against the actual arg's.
+   *
+   * The branch is taken on `configArg` rather than on `serializedConfigArg === undefined`, even
+   * though the two are the same test by construction: the type guard is what narrows `configArg`
+   * to something with `asymmetricMatch` on it, and the alternative needs an assertion to say the
+   * same thing less safely.
+   */
+  #valueMatches(configArg, serializedConfigArg, actualArg) {
+    if (isAsymmetricMatcher(configArg)) {
+      return configArg.asymmetricMatch(actualArg);
+    }
+    return serializedConfigArg === this.#serialize([actualArg]);
+  }
+};
+
+// src/lib/spy-mark.ts
+var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
+function isMarkedMock(value) {
+  return typeof value === "function" && AUTO_SPY_MARK in value;
+}
+
+// src/lib/explain-spy.ts
+var CHAIN_NAMES = ["calledWith", "mustBeCalledWith"];
+var HEADER = "[vitest-auto-spy] explainSpy";
+var NOT_A_DOUBLE = "is not a spy created by vitest-auto-spy, so it has no configured arguments to read. Pass a double built by createSpyFromClass, createAutoMock, createFunctionSpy or mockDeep.";
+var NOTHING_FOUND = "nothing to explain: this value holds no spy created by vitest-auto-spy. Pass a double built by createSpyFromClass, createAutoMock, createFunctionSpy or mockDeep.";
+var NO_MATCH_OUTCOME = "no configured arguments matched; the default value was used";
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function bareArgs(bracketed) {
+  return bracketed.substring(1, bracketed.length - 1);
+}
+function asCall(name, args) {
+  return `${name}(${bareArgs(serializeValue(args))})`;
+}
+function mockNameOf(mock) {
+  const read = Reflect.get(mock, "getMockName");
+  const name = typeof read === "function" ? read.call(mock) : void 0;
+  return typeof name === "string" && name !== "vi.fn()" ? name : "spy";
+}
+function chainsOf(mock) {
+  const mark = Reflect.get(mock, AUTO_SPY_MARK);
+  const state = isObject(mark) ? Reflect.get(mark, "state") : void 0;
+  if (!isObject(state)) {
+    return [];
+  }
+  const chains = [];
+  for (const name of CHAIN_NAMES) {
+    const chain = Reflect.get(state, name);
+    const map = isObject(chain) ? Reflect.get(chain, "argsToValuesMap") : void 0;
+    if (map instanceof ArgsMap) {
+      chains.push({ name, map });
+    }
+  }
+  return chains;
+}
+function configLines(mock) {
+  const lines = [];
+  for (const chain of chainsOf(mock)) {
+    for (const entry of chain.map.configuredEntries()) {
+      lines.push({
+        index: lines.length + 1,
+        text: `${chain.name}(${bareArgs(entry.args)})`,
+        matches: (actualArgs) => entry.matches(actualArgs)
+      });
+    }
+  }
+  return lines;
+}
+function headline(name, callCount, configCount, matchedCount) {
+  const calls = callCount === 0 ? "never called" : `${callCount} ${callCount === 1 ? "call" : "calls"}`;
+  if (configCount === 0) {
+    return `${name} \u2014 ${calls}, nothing configured`;
+  }
+  const verdict = callCount > 0 && matchedCount === 0 ? ", none matched" : "";
+  return `${name} \u2014 ${calls}, ${configCount} configured${verdict}`;
+}
+function explainMember(member) {
+  const configs = configLines(member.mock);
+  const calls = getMockAdapter().getCalls(member.mock);
+  const hits = calls.map((args) => configs.find((config) => config.matches(args)));
+  const lines = [headline(member.name, calls.length, configs.length, hits.filter((hit) => hit !== void 0).length)];
+  if (configs.length > 0) {
+    lines.push("  configured:", ...configs.map((config) => `    #${config.index} ${config.text}`));
+  }
+  if (calls.length > 0) {
+    lines.push("  calls:", ...calls.map((args, position) => callLine(member.name, args, position, configs.length, hits[position])));
+  }
+  return lines.join("\n");
+}
+function callLine(name, args, position, configCount, hit) {
+  const call = `    #${position + 1} ${asCall(name, args)}`;
+  if (configCount === 0) {
+    return call;
+  }
+  return `${call} -> ${hit ? `matched #${hit.index}` : NO_MATCH_OUTCOME}`;
+}
+function accessorMembers(spy) {
+  const bag = Object.getOwnPropertyDescriptor(spy, "accessorSpies")?.value;
+  if (!isObject(bag)) {
+    return [];
+  }
+  return [...bagHalf(bag, "getters", "get"), ...bagHalf(bag, "setters", "set")];
+}
+function bagHalf(bag, half, label) {
+  const record = Reflect.get(bag, half);
+  if (!isObject(record)) {
+    return [];
+  }
+  return Object.entries(record).flatMap(
+    ([property, mock]) => isMarkedMock(mock) ? [{ name: `${label} ${property}`, property, mock }] : []
+  );
+}
+function collectMembers(spy) {
+  const found = [];
+  for (const key of Object.keys(spy)) {
+    const descriptor = Object.getOwnPropertyDescriptor(spy, key);
+    if (!descriptor || descriptor.get || descriptor.set) {
+      continue;
+    }
+    const { value } = descriptor;
+    if (isMarkedMock(value)) {
+      found.push({ name: key, property: key, mock: value });
+    }
+  }
+  return [...found, ...accessorMembers(spy)];
+}
+function membersNamed(spy, property) {
+  const accessors = accessorMembers(spy).filter((member) => member.property === property);
+  if (accessors.length > 0) {
+    return accessors;
+  }
+  const value = Reflect.get(spy, property);
+  return isMarkedMock(value) ? [{ name: property, property, mock: value }] : [];
+}
+function sections(spy, method) {
+  const members = method === void 0 ? collectMembers(spy) : membersNamed(spy, method);
+  if (members.length > 0) {
+    return members.map(explainMember);
+  }
+  if (isMarkedMock(spy)) {
+    return [explainMember({ name: method ?? mockNameOf(spy), mock: spy })];
+  }
+  return [method === void 0 ? NOTHING_FOUND : `${method} ${NOT_A_DOUBLE}`];
+}
+function explainSpy(spy, method) {
+  return `${HEADER}
+
+${sections(spy, method).join("\n\n")}`;
+}
+
+export { compareTestRuns, diffByField, explainSpy, formatTestRunComparison, summarizeTestRun };

package/dist/{expect-emission-BDuFuqTb.d.ts → expect-emission-Dy5CvsF2.d.ts}

@@ -83,6 +83,32 @@ interface AutoMockConfiguration<T> extends StrictSpyConfiguration {
  */
 declare function autoMocked<T>(overrides?: DeepPartial<T>): Spy<T> & T;
 
+/**
+ * Change the wait every emission helper uses when a call does not name one. Process-wide; belongs
+ * in a setup file, next to `setupAutoSpy()`.
+ *
+ * It exists for one shape, and that shape is common enough to deserve a knob: a suite running under
+ * **global fake timers**. The watchdog in `expect-emission.ts` deliberately runs on the real clock,
+ * so a *failing* assertion in such a suite spends a real second before it reports — and the reflex
+ * that produces, `{ timeout: 0 }` at every call site, is the worst of the options: it disables the
+ * watchdog, so the next silent stream hangs until the runner's own timeout with no message worth
+ * reading. One line here instead:
+ *
+ * ```ts
+ * // vitest.setup.ts
+ * setupAutoSpy({ globalFakeTimers: true });
+ * setEmissionTimeout(100); // the clock is frozen; a real second buys nothing
+ * ```
+ *
+ * 100 ms of *real* time is a large budget under fake timers, where the only real time that can pass
+ * is the microtask/macrotask drain between `await`s — nothing that waits on the clock can advance
+ * without the spec advancing it. Leave the default alone in a suite with real timers.
+ *
+ * `expectNoEmission` is unaffected: its wait is a quiet window, not a watchdog, and it defaults to
+ * one macrotask.
+ */
+declare function setEmissionTimeout(milliseconds: number): void;
+
 /** Minimal observer accepted by {@link SubscribableLike}. */
 interface EmissionObserver<T> {
     next: (value: T) => void;
@@ -170,31 +196,7 @@ interface EmissionOptions<T = unknown> {
      */
     advance?: () => void;
 }
-/**
- * Change the wait every emission helper uses when a call does not name one. Process-wide; belongs
- * in a setup file, next to `setupAutoSpy()`.
- *
- * It exists for one shape, and that shape is common enough to deserve a knob: a suite running under
- * **global fake timers**. The watchdog below deliberately runs on the real clock, so a *failing*
- * assertion in such a suite spends a real second before it reports — and the reflex that produces,
- * `{ timeout: 0 }` at every call site, is the worst of the options: it disables the watchdog, so
- * the next silent stream hangs until the runner's own timeout with no message worth reading. One
- * line here instead:
- *
- * ```ts
- * // vitest.setup.ts
- * setupAutoSpy({ globalFakeTimers: true });
- * setEmissionTimeout(100); // the clock is frozen; a real second buys nothing
- * ```
- *
- * 100 ms of *real* time is a large budget under fake timers, where the only real time that can pass
- * is the microtask/macrotask drain between `await`s — nothing that waits on the clock can advance
- * without the spec advancing it. Leave the default alone in a suite with real timers.
- *
- * `expectNoEmission` is unaffected: its wait is a quiet window, not a watchdog, and it defaults to
- * one macrotask.
- */
-declare function setEmissionTimeout(milliseconds: number): void;
+
 /**
  * Await **the first value** of `source$` — not a list of them — failing loudly when it never
  * arrives.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, settleDynamicImport, stubConstructor, 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-BDuFuqTb.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, 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-Dy5CvsF2.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-Dp2ZMFqj.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'vitest';