@describe-me/vitest 0.5.4 → 0.6.0

package/dist/live-test-context.js

@@ -0,0 +1,26 @@
+import { liveStop } from '@describe-me/core/live';
+import { liveExport } from './live-export.js';
+function ignore() {
+    return undefined;
+}
+/**
+ * The one context that the hooks and the body of a live test get, with the
+ * fixtures they use once the runner computed them. `skip()` stops the test
+ * without a render, so the page reports `no-render`.
+ */
+export function liveTestContext(match, signal) {
+    return {
+        task: { name: match.test.name, fullName: match.path.join(' > ') },
+        expect: liveExport('vitest', 'expect'),
+        skip(condition) {
+            if (condition === false) {
+                return;
+            }
+            throw liveStop();
+        },
+        signal,
+        onTestFinished: ignore,
+        onTestFailed: ignore,
+        annotate: () => Promise.resolve(),
+    };
+}

package/dist/live-test-files-source.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The source of a build's map of test files: each path from the root to a
+ * lazy import of the file, so the bundler gives every test file a chunk of
+ * its own and the page loads only the one it shows.
+ */
+export declare function liveTestFilesSource(testFiles: string[]): string;

package/dist/live-test-files-source.js

@@ -0,0 +1,10 @@
+import { liveStringLiteral } from './live-string-literal.js';
+/**
+ * The source of a build's map of test files: each path from the root to a
+ * lazy import of the file, so the bundler gives every test file a chunk of
+ * its own and the page loads only the one it shows.
+ */
+export function liveTestFilesSource(testFiles) {
+    const entries = testFiles.map((file) => `  ${liveStringLiteral(file)}: () => import(${liveStringLiteral(`/${file}`)}),`);
+    return ['export default {', ...entries, '}', ''].join('\n');
+}

package/dist/live-vi.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `vi` and its alias `vitest` on the live page. Keys it does not know do
+ * nothing and return `vi`, so fake timers are skipped and time is real.
+ * `vi.mock` and `vi.doMock` change nothing either, but post a notice that
+ * names the module. `await vi.waitFor(…)` ends, because `vi` has no `then`.
+ */
+export declare function liveVi(): object;

package/dist/live-vi.js

@@ -0,0 +1,50 @@
+import { liveMock } from './live-mock.js';
+import { liveSpyOn } from './live-spy-on.js';
+import { noticeLiveModuleMock } from './notice-live-module-mock.js';
+let vi;
+function isMockFunction(value) {
+    return (typeof value === 'function' && value._isMockFunction === true);
+}
+function createVi() {
+    const known = {
+        fn: (implementation) => liveMock({ implementation }),
+        spyOn: liveSpyOn,
+        hoisted: (factory) => factory(),
+        stubGlobal: (name, value) => {
+            const scope = globalThis;
+            scope[name] = value;
+            return proxy;
+        },
+        isMockFunction,
+        mock: (path) => {
+            noticeLiveModuleMock('vi.mock', path);
+            return proxy;
+        },
+        doMock: (path) => {
+            noticeLiveModuleMock('vi.doMock', path);
+            return proxy;
+        },
+    };
+    const proxy = new Proxy(known, {
+        get(target, key) {
+            if (typeof key !== 'string' || key === 'then') {
+                return undefined;
+            }
+            if (Object.hasOwn(target, key)) {
+                return target[key];
+            }
+            return () => proxy;
+        },
+    });
+    return proxy;
+}
+/**
+ * `vi` and its alias `vitest` on the live page. Keys it does not know do
+ * nothing and return `vi`, so fake timers are skipped and time is real.
+ * `vi.mock` and `vi.doMock` change nothing either, but post a notice that
+ * names the module. `await vi.waitFor(…)` ends, because `vi` has no `then`.
+ */
+export function liveVi() {
+    vi ??= createVi();
+    return vi;
+}

package/dist/live.d.ts

@@ -0,0 +1,2 @@
+export { buildLive, type LiveBuild, type LiveBuildOptions } from './build-live.js';
+export { createLiveServer, type LiveServer, type LiveServerOptions } from './create-live-server.js';

package/dist/live.js

@@ -0,0 +1,3 @@
+// The live preview's server and static build, for Node. It never loads the runtime of the live page.
+export { buildLive } from './build-live.js';
+export { createLiveServer } from './create-live-server.js';

package/dist/load-live-config.d.ts

@@ -0,0 +1,9 @@
+import type { Vite } from 'vitest/node';
+type LoadedConfig = NonNullable<Awaited<ReturnType<typeof Vite.loadConfigFromFile>>>;
+/**
+ * Loads the project's config the way Vitest serves it, with `describeMe()`
+ * in live mode. The flag is set only while the config file runs, so nothing
+ * else in this process sees it.
+ */
+export declare function loadLiveConfig(vite: typeof Vite, configFile: string, root: string): Promise<LoadedConfig>;
+export {};

package/dist/load-live-config.js

@@ -0,0 +1,25 @@
+import { LIVE_ENV } from './live-env.js';
+/**
+ * Loads the project's config the way Vitest serves it, with `describeMe()`
+ * in live mode. The flag is set only while the config file runs, so nothing
+ * else in this process sees it.
+ */
+export async function loadLiveConfig(vite, configFile, root) {
+    const previous = process.env[LIVE_ENV];
+    process.env[LIVE_ENV] = '1';
+    try {
+        const loaded = await vite.loadConfigFromFile({ command: 'serve', mode: 'test', isSsrBuild: false, isPreview: false }, configFile, root);
+        if (loaded === null) {
+            throw new Error(`describe-me: cannot load ${configFile}`);
+        }
+        return loaded;
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env[LIVE_ENV];
+        }
+        else {
+            process.env[LIVE_ENV] = previous;
+        }
+    }
+}

package/dist/load-profile.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentProfile } from './environment-profile.js';
+import type { DescribeMeEnvironment } from './plugin.js';
+/** Imported on demand, so browser mode never loads the code for DOM environments. */
+export declare function loadProfile(environment: DescribeMeEnvironment): Promise<EnvironmentProfile>;

package/dist/load-profile.js

@@ -0,0 +1,9 @@
+/** Imported on demand, so browser mode never loads the code for DOM environments. */
+export async function loadProfile(environment) {
+    if (environment === 'browser') {
+        const { browserProfile } = await import('./browser-profile.js');
+        return browserProfile;
+    }
+    const { domProfile } = await import('./dom-profile.js');
+    return domProfile;
+}

package/dist/notice-live-module-mock.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tells the viewer that a `vi.mock` or `vi.doMock` call has no effect on the
+ * live page. Each distinct call posts one notice per page.
+ */
+export declare function noticeLiveModuleMock(method: 'vi.mock' | 'vi.doMock', path: unknown): void;

package/dist/notice-live-module-mock.js

@@ -0,0 +1,25 @@
+import { postLiveMessage } from '@describe-me/core/live';
+const posted = new Set();
+function isThenable(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        typeof value.then === 'function');
+}
+function pathOf(path) {
+    if (typeof path === 'string') {
+        return JSON.stringify(path);
+    }
+    return isThenable(path) ? 'import(…)' : String(path);
+}
+/**
+ * Tells the viewer that a `vi.mock` or `vi.doMock` call has no effect on the
+ * live page. Each distinct call posts one notice per page.
+ */
+export function noticeLiveModuleMock(method, path) {
+    const message = `${method}(${pathOf(path)}) does not apply in the live preview, so the component uses the real module.`;
+    if (posted.has(message)) {
+        return;
+    }
+    posted.add(message);
+    postLiveMessage({ type: 'notice', message });
+}

package/dist/package-name-of.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The package an adapter entry point belongs to, e.g.
+ * `@describe-me/react/testing-library` → `@describe-me/react`.
+ */
+export declare function packageNameOf(specifier: string): string;

package/dist/package-name-of.js

@@ -0,0 +1,7 @@
+/**
+ * The package an adapter entry point belongs to, e.g.
+ * `@describe-me/react/testing-library` → `@describe-me/react`.
+ */
+export function packageNameOf(specifier) {
+    return specifier.split('/').slice(0, 2).join('/');
+}

package/dist/plugin.d.ts

@@ -1,5 +1,5 @@
 import type { ViteUserConfig } from 'vitest/config';
-import type { RenderFrameMode } from '@describe-me/core/types';
+import { type RenderFrameMode } from '@describe-me/core/types';
 /** Where the tests run: Vitest browser mode, or a simulated DOM such as jsdom. */
 export type DescribeMeEnvironment = 'browser' | 'dom';
 export interface DescribeMeOptions {
@@ -51,6 +51,14 @@ export interface DescribeMeOptions {
      * selector. Default: `'eager'`.
      */
     renderFrame?: RenderFrameMode;
+    /**
+     * The live preview of this project. `setupFiles` replaces `test.setupFiles`
+     * on the live page, for a setup file that needs Node. `false` switches the
+     * preview off. Test runs ignore it. Default: on, with `test.setupFiles`.
+     */
+    live?: false | {
+        setupFiles?: string | string[];
+    };
 }
 type VitePlugin = NonNullable<ViteUserConfig['plugins']>[number];
 /**
@@ -60,7 +68,8 @@ type VitePlugin = NonNullable<ViteUserConfig['plugins']>[number];
  * `render` import to our adapter so existing tests record frames unchanged.
  * Works in browser mode and in DOM environments such as jsdom; the adapter
  * itself still needs the real module, so imports coming from inside it are
- * left alone.
+ * left alone. While `createLiveServer()` or `buildLive()` loads the config,
+ * it returns the live preview's plugin instead.
  */
 export declare function describeMe(options?: DescribeMeOptions): VitePlugin;
 export {};

package/dist/plugin.js

@@ -1,86 +1,19 @@
+import { LIVE_PROTOCOL } from '@describe-me/core/types';
 import { adapterPackageRoot } from './adapter-package-root.js';
 import { compileGlobs } from './compile-globs.js';
 import { compileInclude } from './compile-include.js';
 import { defaultReporters } from './default-reporters.js';
+import { detectEnvironment } from './detect-environment.js';
+import { isAdapterModule } from './is-adapter-module.js';
+import { LIVE_ENV } from './live-env.js';
+import { livePlugin } from './live-plugin.js';
+import { loadProfile } from './load-profile.js';
+import { packageNameOf } from './package-name-of.js';
 import { projectModulePath } from './project-module-path.js';
 import { registerExports } from './register-exports.js';
 import DescribeMeReporter from './reporter.js';
 import { RUNTIME_OPTIONS_KEY } from './runtime-options.js';
-import { styledComponentsBrowserBuild, } from './styled-components-browser-build.js';
 import { validateRenderFrame } from './validate-render-frame.js';
-/** For each framework and environment: the render module tests import, and our adapter that wraps it. */
-const RENDER_MODULES = {
-    react: {
-        browser: { original: 'vitest-browser-react', adapter: '@describe-me/react' },
-        dom: { original: '@testing-library/react', adapter: '@describe-me/react/testing-library' },
-    },
-};
-/**
- * The package an adapter entry point belongs to, e.g.
- * `@describe-me/react/testing-library` → `@describe-me/react`.
- */
-function packageNameOf(specifier) {
-    return specifier.split('/').slice(0, 2).join('/');
-}
-/**
- * Whether a module is one of the adapter's own files, whose imports of the
- * original module must stay unredirected. `/node_modules/<package>/` is the
- * fallback for when the project root could not resolve the package.
- */
-function isAdapterModule(id, adapterRoot, adapterPackage) {
-    if (adapterRoot !== null && id.startsWith(adapterRoot)) {
-        return true;
-    }
-    return id.includes(`/node_modules/${adapterPackage}/`);
-}
-function detectEnvironment(userConfig) {
-    return userConfig.test?.browser?.enabled ? 'browser' : 'dom';
-}
-function browserConfig(renderModule) {
-    return {
-        // Vite's dependency scanner runs before our `resolveId` redirect, so it
-        // never sees the adapter. Discovering it mid-run makes Vite re-optimize
-        // and reload, and the test ends up with two copies of the bundled deps
-        // ("Vitest failed to find the runner"). Declaring the adapter up front
-        // keeps a single optimization pass.
-        optimizeDeps: {
-            include: [renderModule.adapter, renderModule.original],
-        },
-        test: {
-            setupFiles: ['@describe-me/vitest/setup'],
-        },
-    };
-}
-function domConfig(userConfig, styledComponents) {
-    const userTest = userConfig.test;
-    const test = {
-        setupFiles: ['@describe-me/vitest/setup-dom'],
-        // Testing Library would otherwise unmount in its own afterEach, before the
-        // closing frame is taken. The adapter unmounts through the recorder instead.
-        env: { RTL_SKIP_AUTO_CLEANUP: 'true' },
-    };
-    // Vitest stubs CSS imports by default, which would leave every imported
-    // stylesheet out of the snapshots. An explicit choice by the user wins.
-    if (userTest?.css === undefined) {
-        test.css = true;
-    }
-    else if (userTest.css === false) {
-        console.warn('describe-me: `test.css` is false, so imported stylesheets are stubbed and will be missing from the snapshots.');
-    }
-    if (!styledComponents) {
-        return { test };
-    }
-    console.info('describe-me: using the browser build of styled-components, for createGlobalStyle');
-    const { config } = styledComponents;
-    return { resolve: config.resolve, test: { ...test, ...config.test } };
-}
-/** Looked up before the reporter is created, which needs its warning. */
-function styledComponentsFor(environment, userConfig, options) {
-    if (environment !== 'dom' || options.styledComponentsBrowserBuild === false) {
-        return undefined;
-    }
-    return styledComponentsBrowserBuild(userConfig.root ?? process.cwd());
-}
 /**
  * One-line integration: `plugins: [describeMe()]`.
  *
@@ -88,11 +21,17 @@ function styledComponentsFor(environment, userConfig, options) {
  * `render` import to our adapter so existing tests record frames unchanged.
  * Works in browser mode and in DOM environments such as jsdom; the adapter
  * itself still needs the real module, so imports coming from inside it are
- * left alone.
+ * left alone. While `createLiveServer()` or `buildLive()` loads the config,
+ * it returns the live preview's plugin instead.
  */
 export function describeMe(options = {}) {
+    if (process.env[LIVE_ENV] === '1') {
+        return livePlugin(options);
+    }
     const { enabled = true, framework = 'react', outDir } = options;
-    let renderModule = RENDER_MODULES[framework].browser;
+    // Set by `config()`, which Vite runs before `configResolved` and `resolveId`.
+    // Stays null while the plugin is disabled.
+    let renderModule = null;
     // Known once Vite has resolved its config. Vitest always serves; a production
     // build that shares the config must not carry the export registration.
     let root = '';
@@ -103,12 +42,13 @@ export function describeMe(options = {}) {
     return {
         name: 'describe-me',
         enforce: 'pre',
-        config(userConfig) {
+        // In both modes, so a tool can check the live protocol on any config it loads.
+        api: { live: { protocol: LIVE_PROTOCOL, enabled: options.live !== false } },
+        async config(userConfig) {
             if (!enabled) {
                 return {};
             }
             const environment = options.environment ?? detectEnvironment(userConfig);
-            renderModule = RENDER_MODULES[framework][environment];
             // Checked here, so invalid options fail before any test runs. Vite
             // deep-merges `provide`, so the user's own keys survive.
             const runtimeOptions = {
@@ -117,8 +57,9 @@ export function describeMe(options = {}) {
                 renderFrame: validateRenderFrame(options.renderFrame),
             };
             const provide = { [RUNTIME_OPTIONS_KEY]: runtimeOptions };
-            const styledComponents = styledComponentsFor(environment, userConfig, options);
-            const setupWarnings = styledComponents?.warning ? [styledComponents.warning] : [];
+            const profile = await loadProfile(environment);
+            renderModule = profile.renderModules[framework];
+            const { config, setupWarnings } = profile.configFor({ userConfig, options, renderModule });
             const reporter = new DescribeMeReporter({
                 outDir,
                 include: options.include,
@@ -130,13 +71,13 @@ export function describeMe(options = {}) {
             // reporters Vitest picks on its own, so without one of the user's, ours
             // joins Vitest's defaults.
             const reporters = userConfig.test?.reporters ? [reporter] : [...defaultReporters(), reporter];
-            const config = environment === 'browser'
-                ? browserConfig(renderModule)
-                : domConfig(userConfig, styledComponents);
-            return { ...config, test: { ...config.test, reporters, provide } };
+            return {
+                ...config,
+                test: { setupFiles: [profile.setupFile], ...config.test, reporters, provide },
+            };
         },
         async resolveId(source, importer) {
-            if (!enabled || source !== renderModule.original) {
+            if (!enabled || renderModule === null || source !== renderModule.original) {
                 return null;
             }
             const fromAdapter = importer !== undefined &&
@@ -156,7 +97,9 @@ export function describeMe(options = {}) {
         configResolved(config) {
             root = config.root;
             serving = config.command === 'serve';
-            adapterRoot = adapterPackageRoot(config.root, packageNameOf(renderModule.adapter));
+            if (renderModule !== null) {
+                adapterRoot = adapterPackageRoot(config.root, packageNameOf(renderModule.adapter));
+            }
         },
         // Names components after their export (see registerExports). `order: 'post'`
         // runs it after the TypeScript and JSX transforms, so it parses plain

package/dist/read-live-browser-names.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The names that the project's `vitest/browser` declares. Importing it in
+ * Node throws, but its file still declares every name for static analysis.
+ */
+export declare function readLiveBrowserNames(root: string): string[];

package/dist/read-live-browser-names.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+const DECLARED = /\bexport\s+const\s+([A-Za-z_$][\w$]*)/g;
+const KNOWN_NAMES = ['page', 'server', 'userEvent', 'cdp', 'commands', 'locators', 'utils'];
+/**
+ * The names that the project's `vitest/browser` declares. Importing it in
+ * Node throws, but its file still declares every name for static analysis.
+ */
+export function readLiveBrowserNames(root) {
+    try {
+        const file = createRequire(join(root, 'package.json')).resolve('vitest/browser');
+        const names = Array.from(readFileSync(file, 'utf8').matchAll(DECLARED), (match) => match[1]);
+        return names.length > 0 ? [...new Set(names)] : KNOWN_NAMES;
+    }
+    catch {
+        return KNOWN_NAMES;
+    }
+}

package/dist/read-live-params.d.ts

@@ -0,0 +1,18 @@
+/** The test that the page URL names, or why the URL names none. */
+export type LiveParams = {
+    file: string;
+    path: string[];
+    occurrence: number;
+} | {
+    problem: string;
+};
+/** The parts of `window.location` that the page reads. */
+export interface LivePageLocation {
+    search: string;
+    origin: string;
+}
+/**
+ * Reads `file`, `path` and `occurrence` from the query of the live page.
+ * `path` holds the suite names, outermost first, then the test name.
+ */
+export declare function readLiveParams(location: LivePageLocation): LiveParams;

package/dist/read-live-params.js

@@ -0,0 +1,63 @@
+const OCCURRENCE = /^[1-9]\d*$/;
+function hasControlCharacter(text) {
+    return Array.from(text).some((character) => {
+        const code = character.charCodeAt(0);
+        return code < 0x20 || code === 0x7f;
+    });
+}
+/** Whether `/file` on the page's origin names exactly that file, with no query, hash or dot segment. */
+function namesOnlyFile(file, origin) {
+    try {
+        const url = new URL(`/${file}`, origin);
+        const exact = decodeURIComponent(url.pathname) === `/${file}`;
+        return url.origin === origin && url.search === '' && url.hash === '' && exact;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A path relative to the root that stays on the page's origin. The URL
+ * parser drops tabs and newlines and reads a leading `//` as another host, so
+ * a `file` such as `\t/host/x.js` would load code from that host. The last
+ * rule checks the URL the page imports, not only the text.
+ */
+function isRelativePath(file, origin) {
+    if (file === '' || file.startsWith('/') || file.includes(':') || hasControlCharacter(file)) {
+        return false;
+    }
+    return !file.split('/').includes('..') && namesOnlyFile(file, origin);
+}
+function namesOf(text) {
+    if (text === null) {
+        return null;
+    }
+    try {
+        const names = JSON.parse(text);
+        const valid = Array.isArray(names) && names.length > 0 && names.every((name) => typeof name === 'string');
+        return valid ? names : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Reads `file`, `path` and `occurrence` from the query of the live page.
+ * `path` holds the suite names, outermost first, then the test name.
+ */
+export function readLiveParams(location) {
+    const params = new URLSearchParams(location.search);
+    const file = params.get('file')?.replaceAll('\\', '/') ?? null;
+    if (file === null || !isRelativePath(file, location.origin)) {
+        return { problem: `file must be a path relative to the root, got ${JSON.stringify(file)}` };
+    }
+    const path = namesOf(params.get('path'));
+    if (path === null) {
+        return { problem: 'path must be a JSON array of the suite names and the test name' };
+    }
+    const occurrence = params.get('occurrence') ?? '1';
+    if (!OCCURRENCE.test(occurrence)) {
+        return { problem: `occurrence must be a positive integer, got ${JSON.stringify(occurrence)}` };
+    }
+    return { file, path, occurrence: Number(occurrence) };
+}

package/dist/read-live-vitest-major.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The major version of the `vitest` that the root resolves, whose rules the
+ * live page names `each` and `for` rows by. Vitest exports its
+ * `package.json`. Falls back to 5 when it cannot be read.
+ */
+export declare function readLiveVitestMajor(root: string): number;

package/dist/read-live-vitest-major.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+const DEFAULT_MAJOR = 5;
+/**
+ * The major version of the `vitest` that the root resolves, whose rules the
+ * live page names `each` and `for` rows by. Vitest exports its
+ * `package.json`. Falls back to 5 when it cannot be read.
+ */
+export function readLiveVitestMajor(root) {
+    try {
+        const file = createRequire(join(root, 'package.json')).resolve('vitest/package.json');
+        const { version } = JSON.parse(readFileSync(file, 'utf8'));
+        const major = typeof version === 'string' ? Number.parseInt(version, 10) : Number.NaN;
+        return Number.isInteger(major) && major > 0 ? major : DEFAULT_MAJOR;
+    }
+    catch {
+        return DEFAULT_MAJOR;
+    }
+}

package/dist/read-live-vitest-names.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The names that the installed `vitest` exports. The shim exports the same
+ * ones, so a test that imports any of them links in the live page.
+ */
+export declare function readLiveVitestNames(): Promise<string[]>;

package/dist/read-live-vitest-names.js

@@ -0,0 +1,40 @@
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/** The names of `vitest` that the shim knows, for when Vitest cannot be imported. */
+const KNOWN_NAMES = [
+    'describe',
+    'suite',
+    'it',
+    'test',
+    'beforeAll',
+    'beforeEach',
+    'afterEach',
+    'afterAll',
+    'aroundEach',
+    'aroundAll',
+    'onTestFinished',
+    'onTestFailed',
+    'vi',
+    'vitest',
+    'expect',
+    'assert',
+    'chai',
+    'should',
+    'expectTypeOf',
+    'assertType',
+    'createExpect',
+    'inject',
+    'recordArtifact',
+];
+/**
+ * The names that the installed `vitest` exports. The shim exports the same
+ * ones, so a test that imports any of them links in the live page.
+ */
+export async function readLiveVitestNames() {
+    try {
+        const names = Object.keys(await import('vitest'));
+        return names.filter((name) => name !== 'default' && IDENTIFIER.test(name));
+    }
+    catch {
+        return KNOWN_NAMES;
+    }
+}

package/dist/register-recording-hooks.d.ts

@@ -6,6 +6,7 @@ import type { RuntimeOptions } from './runtime-options.js';
  * reporter via task.meta, and only then let adapters unmount. Teardown runs
  * for unrecorded tests too, because Testing Library's auto-cleanup is off in
  * jsdom. Concurrent tests would share the one recorder, so they are not
- * recorded.
+ * recorded. The hooks destructure the context, because Vitest rejects any
+ * other first parameter in a test that has `test.extend` fixtures.
  */
 export declare function registerRecordingHooks(options: RuntimeOptions, aroundWait?: AroundWait): void;