@describe-me/vitest 0.5.4 → 0.6.1

package/dist/live-plugin-protocol.js

@@ -0,0 +1,13 @@
+import { LIVE_PROTOCOL } from '@describe-me/core/types';
+/** The live protocol of the project's describeMe() plugin, which must be this package's. */
+export function livePluginProtocol(plugins, configName) {
+    const plugin = plugins.find((candidate) => candidate.name === 'describe-me');
+    if (plugin === undefined) {
+        throw new Error(`describe-me: ${configName} has no describeMe() plugin`);
+    }
+    const protocol = plugin.api?.live?.protocol;
+    if (protocol !== LIVE_PROTOCOL) {
+        throw new Error(`describe-me: all describe-me packages must be on the same version. The describeMe() plugin in ${configName} has live protocol ${String(protocol ?? 'none')}, expected ${LIVE_PROTOCOL}. Install @describe-me/core, @describe-me/react, @describe-me/vitest and describe-me at one version.`);
+    }
+    return protocol;
+}

package/dist/live-plugin.d.ts

@@ -0,0 +1,13 @@
+import type { ViteUserConfig } from 'vitest/config';
+import type { DescribeMeOptions } from './plugin.js';
+type VitePlugin = NonNullable<ViteUserConfig['plugins']>[number];
+/**
+ * `describeMe()` while `createLiveServer()` or `buildLive()` loads the
+ * project's config. It serves the live page, or gives a build `live.html` as
+ * its input, and swaps `vitest`, `vitest/browser`, `@describe-me/vitest` and
+ * the render module for the live page's shims. It adds no setup file,
+ * reporter or recording redirect, and ignores `enabled`. With `live: false`
+ * it does nothing, and `createLiveServer()` and `buildLive()` stop.
+ */
+export declare function livePlugin(options: DescribeMeOptions): VitePlugin;
+export {};

package/dist/live-plugin.js

@@ -0,0 +1,148 @@
+import { join, resolve } from 'node:path';
+import { LIVE_PROTOCOL } from '@describe-me/core/types';
+import { adapterPackageRoot } from './adapter-package-root.js';
+import { detectEnvironment } from './detect-environment.js';
+import { isAdapterModule } from './is-adapter-module.js';
+import { liveEntrySource } from './live-entry-source.js';
+import { LIVE_MODULE_IDS } from './live-module-ids.js';
+import { liveOptimizeDeps } from './live-optimize-deps.js';
+import { livePageHtml } from './live-page-html.js';
+import { livePageMiddleware } from './live-page-middleware.js';
+import { livePageSettings } from './live-page-settings.js';
+import { liveShimSource } from './live-shim-source.js';
+import { loadProfile } from './load-profile.js';
+import { packageNameOf } from './package-name-of.js';
+import { validateLiveOption } from './validate-live-option.js';
+/** What the live page imports instead of each module, by the specifier tests use. */
+const SHIMS = new Map([
+    ['vitest', LIVE_MODULE_IDS.vitest],
+    ['vitest/browser', LIVE_MODULE_IDS.vitestBrowser],
+    ['@vitest/browser/context', LIVE_MODULE_IDS.vitestBrowser],
+    ['@describe-me/vitest', LIVE_MODULE_IDS.describeMeVitest],
+]);
+const GENERATED = new Set(Object.values(LIVE_MODULE_IDS));
+/** Where the live page of a build imports its entry from. Only a build resolves it. */
+const BUILD_ENTRY_SRC = '/@describe-me-live/entry';
+/** The source of a generated module. */
+function generatedSource(id, settings, command) {
+    if (id === LIVE_MODULE_IDS.entry) {
+        return liveEntrySource(settings, command);
+    }
+    if (id === LIVE_MODULE_IDS.vitest) {
+        return liveShimSource('vitest', settings.vitestNames);
+    }
+    if (id === LIVE_MODULE_IDS.vitestBrowser) {
+        return liveShimSource('vitest/browser', settings.browserNames);
+    }
+    if (id === LIVE_MODULE_IDS.describeMeVitest) {
+        return liveShimSource('@describe-me/vitest', ['step', 'recorder']);
+    }
+    return null;
+}
+/**
+ * All the config that live mode adds: the dependencies to bundle up front and
+ * `test.alias`, which Vitest's own `config` hook moves to `resolve.alias`.
+ */
+function liveConfig(userConfig, root, outDir, live, setupFiles) {
+    const config = {
+        optimizeDeps: liveOptimizeDeps(root, outDir, live, setupFiles),
+    };
+    const alias = userConfig.test?.alias;
+    if (alias !== undefined) {
+        config.resolve = { alias };
+    }
+    return config;
+}
+/**
+ * `describeMe()` while `createLiveServer()` or `buildLive()` loads the
+ * project's config. It serves the live page, or gives a build `live.html` as
+ * its input, and swaps `vitest`, `vitest/browser`, `@describe-me/vitest` and
+ * the render module for the live page's shims. It adds no setup file,
+ * reporter or recording redirect, and ignores `enabled`. With `live: false`
+ * it does nothing, and `createLiveServer()` and `buildLive()` stop.
+ */
+export function livePlugin(options) {
+    const { framework = 'react' } = options;
+    const enabled = options.live !== false;
+    // Set by `config()`, which Vite runs before `configResolved`, `resolveId` and `load`.
+    let renderModule = null;
+    let settings = null;
+    // Where the installed live module lives. Its own import of the original stays unredirected.
+    let adapterRoot = null;
+    let command = 'serve';
+    // The id of `live.html` in a build, which the bundler takes as its input.
+    let pageId = null;
+    return {
+        name: 'describe-me',
+        enforce: 'pre',
+        api: { live: { protocol: LIVE_PROTOCOL, enabled } },
+        async config(userConfig) {
+            const live = validateLiveOption(options.live);
+            if (!live.enabled) {
+                return {};
+            }
+            const root = resolve(userConfig.root ?? process.cwd());
+            const environment = options.environment ?? detectEnvironment(userConfig);
+            const profile = await loadProfile(environment);
+            renderModule = profile.renderModules[framework];
+            settings = await livePageSettings(userConfig, root, live);
+            return liveConfig(userConfig, root, options.outDir, renderModule.live, settings.setupFiles);
+        },
+        configResolved(config) {
+            command = config.command;
+            if (command === 'build') {
+                pageId = join(config.root, 'live.html');
+            }
+            if (renderModule !== null) {
+                adapterRoot = adapterPackageRoot(config.root, packageNameOf(renderModule.live));
+            }
+        },
+        async resolveId(source, importer) {
+            if (!enabled) {
+                return null;
+            }
+            if (GENERATED.has(source)) {
+                return source;
+            }
+            if (source === pageId) {
+                return source;
+            }
+            if (command === 'build' && source === BUILD_ENTRY_SRC) {
+                return LIVE_MODULE_IDS.entry;
+            }
+            const shim = SHIMS.get(source);
+            if (shim !== undefined) {
+                return shim;
+            }
+            if (renderModule === null || source !== renderModule.original) {
+                return null;
+            }
+            const fromAdapter = importer !== undefined &&
+                isAdapterModule(importer, adapterRoot, packageNameOf(renderModule.live));
+            if (fromAdapter) {
+                return null;
+            }
+            const resolved = await this.resolve(renderModule.live, importer, { skipSelf: true });
+            if (!resolved) {
+                throw new Error(`describe-me: cannot resolve ${renderModule.live} (the live preview's stand-in for ${renderModule.original}). Install ${packageNameOf(renderModule.live)}.`);
+            }
+            return resolved;
+        },
+        load(id) {
+            if (settings === null) {
+                return null;
+            }
+            // Only this plugin knows the preview head, so it owns the page.
+            if (id === pageId) {
+                return livePageHtml(options.previewHead, BUILD_ENTRY_SRC);
+            }
+            return generatedSource(id, settings, command);
+        },
+        configureServer(server) {
+            if (!enabled) {
+                return;
+            }
+            server.middlewares.use(livePageMiddleware(server, options.previewHead));
+        },
+    };
+}

package/dist/live-project-plugins.d.ts

@@ -0,0 +1,8 @@
+import type { Vite } from 'vitest/node';
+/**
+ * The project's plugins for the live build, flattened the way Vite flattens
+ * them: nested arrays and promises, without falsy entries. Those whose
+ * `apply` is `'build'` are left out, because the dev server never runs them.
+ * Vite itself drops those whose `apply` is `'serve'`.
+ */
+export declare function liveProjectPlugins(plugins: Vite.PluginOption[] | undefined): Promise<Vite.PluginOption[]>;

package/dist/live-project-plugins.js

@@ -0,0 +1,23 @@
+/**
+ * The project's plugins for the live build, flattened the way Vite flattens
+ * them: nested arrays and promises, without falsy entries. Those whose
+ * `apply` is `'build'` are left out, because the dev server never runs them.
+ * Vite itself drops those whose `apply` is `'serve'`.
+ */
+export async function liveProjectPlugins(plugins) {
+    const flat = [];
+    for (const option of plugins ?? []) {
+        const plugin = await option;
+        if (!plugin) {
+            continue;
+        }
+        if (Array.isArray(plugin)) {
+            flat.push(...(await liveProjectPlugins(plugin)));
+            continue;
+        }
+        if (!('apply' in plugin) || plugin.apply !== 'build') {
+            flat.push(plugin);
+        }
+    }
+    return flat;
+}

package/dist/live-registrar.d.ts

@@ -0,0 +1,10 @@
+type LiveKind = 'suite' | 'test';
+/**
+ * `describe`, `suite`, `it` or `test` on the live page. A call registers
+ * whatever modifiers come before it, because a skipped test keeps its entry
+ * in the manifest. `test.extend(…)` returns a chain whose tests keep the
+ * merged fixtures. Properties the page does not know, such as `override`,
+ * are inert.
+ */
+export declare function liveRegistrar(kind: LiveKind): unknown;
+export {};

package/dist/live-registrar.js

@@ -0,0 +1,174 @@
+import { liveInert } from '@describe-me/core/live';
+import { liveEachName } from './live-each-name.js';
+import { liveFixtureRegistrations } from './live-fixture-registrations.js';
+import { liveHook } from './live-hook.js';
+import { liveRegistry } from './live-registry.js';
+import { liveSuite } from './live-suite.js';
+/** Modifiers that change how Vitest runs a suite or a test, not whether it is registered. */
+const RUN_MODIFIERS = {
+    suite: new Set(['skip', 'only', 'concurrent', 'sequential', 'shuffle']),
+    test: new Set(['skip', 'only', 'concurrent', 'sequential', 'fails']),
+};
+/** The hooks that Vitest's `test` carries as members, so `test.beforeEach(…)` works. */
+const HOOKS = new Set([
+    'beforeAll',
+    'beforeEach',
+    'afterEach',
+    'afterAll',
+    'aroundEach',
+    'aroundAll',
+]);
+const NO_FIXTURES = new Map();
+function nameOf(name) {
+    if (typeof name === 'string') {
+        return name;
+    }
+    if (typeof name === 'function') {
+        return name.name || '<anonymous>';
+    }
+    return String(name);
+}
+function timeoutOf(options) {
+    if (typeof options === 'number') {
+        return options;
+    }
+    if (typeof options !== 'object' || options === null) {
+        return undefined;
+    }
+    const { timeout } = options;
+    return typeof timeout === 'number' ? timeout : undefined;
+}
+/** The body and timeout of `(name, fn)`, `(name, options, fn)` or `(name, fn, options | timeout)`. */
+function bodyAndTimeout(second, third) {
+    if (typeof second === 'function') {
+        return { body: second, timeout: timeoutOf(third) };
+    }
+    return {
+        body: typeof third === 'function' ? third : undefined,
+        timeout: timeoutOf(second),
+    };
+}
+function add(chain, name, body, timeout, uses) {
+    const suite = liveRegistry().current;
+    const kept = chain.todo ? undefined : body;
+    if (chain.kind === 'suite') {
+        suite.children.push(liveSuite(name, kept, timeout));
+        return;
+    }
+    suite.children.push({ kind: 'test', name, body: kept, timeout, fixtures: chain.fixtures, uses });
+}
+/** Like Vitest's `toArray`: no value is no item. */
+function toArray(row) {
+    if (row === undefined || row === null) {
+        return [];
+    }
+    return Array.isArray(row) ? row : [row];
+}
+function rowName(name, items, index) {
+    return liveEachName(nameOf(name), items, index, liveRegistry().vitestMajor);
+}
+/** The rows of a table, or of a tagged template such as `it.each\`a | b\``, as Vitest reads them. */
+function rowsOf(table, values) {
+    if (!Array.isArray(table)) {
+        return [];
+    }
+    if (values.length === 0) {
+        return table;
+    }
+    const header = table.join('').trim().replace(/ /g, '').split('\n')[0].split('|');
+    const rows = [];
+    for (let i = 0; i + header.length <= values.length; i += header.length) {
+        rows.push(Object.fromEntries(header.map((key, j) => [key, values[i + j]])));
+    }
+    return rows;
+}
+/**
+ * `each(table)`: one suite or test per row. Like Vitest, it spreads rows when
+ * every row is an array, and the body gets no context.
+ */
+function each(chain) {
+    return (table, ...values) => (name, second, third) => {
+        const rows = rowsOf(table, values);
+        const spread = rows.every((row) => Array.isArray(row));
+        const { body, timeout } = bodyAndTimeout(second, third);
+        rows.forEach((row, index) => {
+            const items = Array.isArray(row) ? row : [row];
+            const args = spread ? items : [row];
+            const rowBody = body === undefined ? undefined : () => body(...args);
+            add(chain, rowName(name, items, index), rowBody, timeout, null);
+        });
+    };
+}
+/**
+ * `for(table)`: one suite or test per row, whose body gets the row and the
+ * test context. The body names its fixtures in its second parameter.
+ */
+function forEachRow(chain) {
+    return (table, ...values) => (name, second, third) => {
+        const { body, timeout } = bodyAndTimeout(second, third);
+        const uses = body === undefined ? null : { callback: body, index: 1 };
+        rowsOf(table, values).forEach((row, index) => {
+            const rowBody = body === undefined ? undefined : (context) => body(row, context);
+            add(chain, rowName(name, toArray(row), index), rowBody, timeout, uses);
+        });
+    };
+}
+/** What Vitest's `test` carries besides modifiers: `extend`, `describe`, `suite` and the hooks. */
+function testMember(chain, key) {
+    if (key === 'extend') {
+        return (...args) => chained({
+            kind: 'test',
+            todo: false,
+            fixtures: liveFixtureRegistrations(chain.fixtures, args),
+        });
+    }
+    if (key === 'describe' || key === 'suite') {
+        return liveRegistrar('suite');
+    }
+    if (HOOKS.has(key)) {
+        return liveHook(key);
+    }
+    return undefined;
+}
+function member(chain, key, self) {
+    if (typeof key === 'string' && RUN_MODIFIERS[chain.kind].has(key)) {
+        return self;
+    }
+    if (key === 'skipIf' || key === 'runIf') {
+        return () => self;
+    }
+    if (key === 'todo') {
+        return chained({ ...chain, todo: true });
+    }
+    if (key === 'each') {
+        return each(chain);
+    }
+    if (key === 'for') {
+        return forEachRow(chain);
+    }
+    const own = chain.kind === 'test' && typeof key === 'string' ? testMember(chain, key) : undefined;
+    return own ?? Reflect.get(liveInert(), key);
+}
+function chained(chain) {
+    const register = (name, second, third) => {
+        const { body, timeout } = bodyAndTimeout(second, third);
+        const uses = body === undefined ? null : { callback: body, index: 0 };
+        add(chain, nameOf(name), body, timeout, uses);
+    };
+    const self = new Proxy(register, {
+        get(_target, key) {
+            return member(chain, key, self);
+        },
+    });
+    return self;
+}
+/**
+ * `describe`, `suite`, `it` or `test` on the live page. A call registers
+ * whatever modifiers come before it, because a skipped test keeps its entry
+ * in the manifest. `test.extend(…)` returns a chain whose tests keep the
+ * merged fixtures. Properties the page does not know, such as `override`,
+ * are inert.
+ */
+export function liveRegistrar(kind) {
+    return chained({ kind, todo: false, fixtures: NO_FIXTURES });
+}

package/dist/live-registry.d.ts

@@ -0,0 +1,14 @@
+import { type LiveSuite } from './live-suite.js';
+/** The suites, tests and hooks of the test file on the live page. */
+export interface LiveRegistry {
+    root: LiveSuite;
+    /** Where suites, tests and hooks register: the suite whose factory runs, or the root during import. */
+    current: LiveSuite;
+    /** The major version of the project's Vitest, whose rules name `each` and `for` rows. */
+    vitestMajor: number;
+}
+/**
+ * The registry of the live page. The shimmed `vitest` and the runner may come
+ * from two copies of this package, so it lives on `globalThis`.
+ */
+export declare function liveRegistry(): LiveRegistry;

package/dist/live-registry.js

@@ -0,0 +1,14 @@
+import { liveSuite } from './live-suite.js';
+const REGISTRY_KEY = Symbol.for('describe-me.live-registry');
+/**
+ * The registry of the live page. The shimmed `vitest` and the runner may come
+ * from two copies of this package, so it lives on `globalThis`.
+ */
+export function liveRegistry() {
+    const scope = globalThis;
+    if (scope[REGISTRY_KEY] === undefined) {
+        const root = liveSuite('');
+        scope[REGISTRY_KEY] = { root, current: root, vitestMajor: 5 };
+    }
+    return scope[REGISTRY_KEY];
+}

package/dist/live-runtime.d.ts

@@ -0,0 +1,2 @@
+export { liveExport } from './live-export.js';
+export { startLivePage, type LivePageOptions } from './start-live-page.js';

package/dist/live-runtime.js

@@ -0,0 +1,3 @@
+// Used by the live preview page that the plugin generates, not for import in tests.
+export { liveExport } from './live-export.js';
+export { startLivePage } from './start-live-page.js';

package/dist/live-setup-files.d.ts

@@ -0,0 +1,15 @@
+/** A setup file of the live page, as the generated entry imports it. */
+export interface LiveSetupFile {
+    /** How messages name it: its path from the root for a file inside the root, else the entry as written. */
+    name: string;
+    /** What the entry imports: `/<path from the root>`, an absolute path, or a package specifier. */
+    specifier: string;
+    /** The file, with `/` separators. Absent for a package. */
+    file?: string;
+}
+/**
+ * The setup files of the live page, in the order given. Paths resolve
+ * against the root, package specifiers stay bare. describe-me's own setup
+ * files are left out, because they record and the live page does not.
+ */
+export declare function liveSetupFiles(entries: string[], root: string): LiveSetupFile[];

package/dist/live-setup-files.js

@@ -0,0 +1,56 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { adapterPackageRoot } from './adapter-package-root.js';
+const OWN_PACKAGE = '@describe-me/vitest';
+function posix(path) {
+    return path.split(sep).join('/');
+}
+/** Vitest takes `vitest.setup.ts` without `./`, so a file under the root counts as a path too. */
+function isPath(entry, root) {
+    return (entry.startsWith('.') ||
+        entry.startsWith('/') ||
+        isAbsolute(entry) ||
+        existsSync(resolve(root, entry)));
+}
+function isOwnPackage(specifier) {
+    return specifier === OWN_PACKAGE || specifier.startsWith(`${OWN_PACKAGE}/`);
+}
+/** Whether a file lies in the installed `@describe-me/vitest`, through a link or not. */
+function isOwnFile(file, ownRoot) {
+    if (ownRoot === null) {
+        return false;
+    }
+    const real = existsSync(file) ? posix(realpathSync(file)) : file;
+    return file.startsWith(ownRoot) || real.startsWith(ownRoot);
+}
+function fileEntry(entry, root) {
+    const file = resolve(root, entry);
+    const fromRoot = relative(root, file);
+    const inRoot = fromRoot !== '' && !fromRoot.startsWith('..') && !isAbsolute(fromRoot);
+    if (inRoot) {
+        return { name: posix(fromRoot), specifier: `/${posix(fromRoot)}`, file: posix(file) };
+    }
+    return { name: entry, specifier: posix(file), file: posix(file) };
+}
+/**
+ * The setup files of the live page, in the order given. Paths resolve
+ * against the root, package specifiers stay bare. describe-me's own setup
+ * files are left out, because they record and the live page does not.
+ */
+export function liveSetupFiles(entries, root) {
+    const ownRoot = adapterPackageRoot(root, OWN_PACKAGE);
+    const setupFiles = [];
+    for (const entry of entries) {
+        if (!isPath(entry, root)) {
+            if (!isOwnPackage(entry)) {
+                setupFiles.push({ name: entry, specifier: entry });
+            }
+            continue;
+        }
+        const setupFile = fileEntry(entry, root);
+        if (!isOwnFile(setupFile.file ?? '', ownRoot)) {
+            setupFiles.push(setupFile);
+        }
+    }
+    return setupFiles;
+}

package/dist/live-shim-source.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The source of a module that the live page imports instead of `vitest`,
+ * `vitest/browser` or `@describe-me/vitest`. It exports every name the real
+ * module has, so a test that imports one still links.
+ */
+export declare function liveShimSource(module: string, names: string[]): string;

package/dist/live-shim-source.js

@@ -0,0 +1,9 @@
+/**
+ * The source of a module that the live page imports instead of `vitest`,
+ * `vitest/browser` or `@describe-me/vitest`. It exports every name the real
+ * module has, so a test that imports one still links.
+ */
+export function liveShimSource(module, names) {
+    const exports = names.map((name) => `export const ${name} = liveExport('${module}', '${name}')`);
+    return [`import { liveExport } from '@describe-me/vitest/live-runtime'`, '', ...exports, ''].join('\n');
+}

package/dist/live-spy-on.d.ts

@@ -0,0 +1,7 @@
+import { type LiveMock } from './live-mock.js';
+/**
+ * `vi.spyOn()` on the live page. It replaces a method with a mock named after
+ * the key, which calls the original. With an access type it leaves the
+ * property alone and returns a mock.
+ */
+export declare function liveSpyOn(object: object, key: PropertyKey, accessType?: 'get' | 'set'): LiveMock;

package/dist/live-spy-on.js

@@ -0,0 +1,27 @@
+import { liveMock } from './live-mock.js';
+/**
+ * `vi.spyOn()` on the live page. It replaces a method with a mock named after
+ * the key, which calls the original. With an access type it leaves the
+ * property alone and returns a mock.
+ */
+export function liveSpyOn(object, key, accessType) {
+    if (accessType !== undefined) {
+        return liveMock({ name: String(key) });
+    }
+    const target = object;
+    const original = target[key];
+    const spy = liveMock({
+        name: String(key),
+        implementation: typeof original === 'function' ? original : undefined,
+        restore: () => {
+            target[key] = original;
+        },
+    });
+    try {
+        target[key] = spy;
+    }
+    catch {
+        // A frozen object, such as a module namespace, keeps its method, and the arrange phase goes on.
+    }
+    return spy;
+}

package/dist/live-step.d.ts

@@ -0,0 +1,2 @@
+/** `step()` on the live page: it runs the body and records nothing. */
+export declare function liveStep<T>(_label: string, body: () => T | Promise<T>): Promise<T>;

package/dist/live-step.js

@@ -0,0 +1,4 @@
+/** `step()` on the live page: it runs the body and records nothing. */
+export async function liveStep(_label, body) {
+    return await body();
+}

package/dist/live-string-literal.d.ts

@@ -0,0 +1,2 @@
+/** A string literal for the modules that live mode generates. */
+export declare function liveStringLiteral(value: string): string;

package/dist/live-string-literal.js

@@ -0,0 +1,7 @@
+// JSON.stringify leaves these as they are. Escaped, a file name cannot close a
+// script tag that inlines the entry, nor end a line for an older parser.
+const UNSAFE_IN_CODE = /[<>\u2028\u2029]/g;
+/** A string literal for the modules that live mode generates. */
+export function liveStringLiteral(value) {
+    return JSON.stringify(value).replace(UNSAFE_IN_CODE, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}

package/dist/live-suite.d.ts

@@ -0,0 +1,28 @@
+import type { LiveFixtureUse } from './live-fixture-props.js';
+import type { LiveFixtures } from './live-fixture-registrations.js';
+/** When a hook runs, relative to the tests of its suite. */
+export type LiveHookKind = 'beforeAll' | 'beforeEach' | 'afterEach' | 'afterAll' | 'aroundEach' | 'aroundAll';
+/** A hook, a test body or a suite factory, as the test file wrote it. */
+export type LiveCallback = (...args: unknown[]) => unknown;
+/** A test as the live page registers it. `it.todo` registers one without a body. */
+export interface LiveTest {
+    kind: 'test';
+    name: string;
+    body?: LiveCallback;
+    timeout?: number;
+    /** The `test.extend` fixtures of the chain that registered it. */
+    fixtures: LiveFixtures;
+    /** Where the body names the fixtures it uses, or null when it gets no context, as an `each` row. */
+    uses: LiveFixtureUse | null;
+}
+/** A suite as the live page registers it, with its factory until the runner collects it. */
+export interface LiveSuite {
+    kind: 'suite';
+    name: string;
+    factory?: LiveCallback;
+    timeout?: number;
+    children: (LiveSuite | LiveTest)[];
+    hooks: Record<LiveHookKind, LiveCallback[]>;
+}
+/** A suite with nothing registered on it yet. */
+export declare function liveSuite(name: string, factory?: LiveCallback, timeout?: number): LiveSuite;

package/dist/live-suite.js

@@ -0,0 +1,18 @@
+/** A suite with nothing registered on it yet. */
+export function liveSuite(name, factory, timeout) {
+    return {
+        kind: 'suite',
+        name,
+        factory,
+        timeout,
+        children: [],
+        hooks: {
+            beforeAll: [],
+            beforeEach: [],
+            afterEach: [],
+            afterAll: [],
+            aroundEach: [],
+            aroundAll: [],
+        },
+    };
+}

package/dist/live-test-context.d.ts

@@ -0,0 +1,24 @@
+import type { LiveTestMatch } from './find-live-test.js';
+/**
+ * The parts of Vitest's test context that the live page offers. The runner
+ * adds each `test.extend` fixture it computes as a property.
+ */
+export interface LiveTestContext {
+    task: {
+        name: string;
+        fullName: string;
+    };
+    expect: unknown;
+    skip(condition?: unknown): void;
+    signal: AbortSignal;
+    onTestFinished(): void;
+    onTestFailed(): void;
+    annotate(): Promise<void>;
+    [fixture: string]: unknown;
+}
+/**
+ * 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 declare function liveTestContext(match: LiveTestMatch, signal: AbortSignal): LiveTestContext;