@describe-me/vitest 0.4.0 → 0.5.0-next.1

package/README.md

@@ -19,10 +19,13 @@ plugin detects where the tests run:
 - **Browser mode** (`test.browser.enabled`): redirects `vitest-browser-react`,
   records a frame after every `Locator` action and keyboard-level `userEvent`.
 - **DOM environments** such as jsdom (anything else): redirects
-  `@testing-library/react`, records a frame after every
+  `@testing-library/react`, records a frame after every `fireEvent` and every
   `@testing-library/user-event` call, turns on `test.css` so imported
   stylesheets reach the snapshots, and sets `RTL_SKIP_AUTO_CLEANUP` so the
-  component is unmounted only after the closing frame.
+  component is unmounted only after the closing frame. The setup file sets
+  React's `IS_REACT_ACT_ENVIRONMENT` where Testing Library would, so act
+  warnings match a run without describe-me. It also works without user-event
+  installed.
 
 ```ts
 import { describeMe } from '@describe-me/vitest/plugin'
@@ -44,9 +47,23 @@ export default defineConfig({
 
 Pass `describeMe({ environment: 'browser' | 'dom' })` to override the detection.
 
-The pieces can also be wired by hand, in which case tests import `render` from
-the adapter themselves (`@describe-me/react` in browser mode,
-`@describe-me/react/testing-library` in jsdom):
+A test that records no frame before the closing one (no recording `render`,
+no interaction, no `step()`) costs no snapshot and is left out of the
+manifest. `describeMe({ include, exclude })` chooses which test files are
+recorded, with picomatch globs relative to the Vitest root. `exclude` wins.
+Tests in other files still run, but record nothing. The reporter takes the
+same two options, but on its own it only filters the manifest: without the
+plugin the setup file does not know them.
+
+`describeMe({ previewHead })` takes HTML that the viewer adds to the start of
+every frame's `<head>`, like Storybook's `preview-head.html`: typically the
+font links that the app shell loads and tests never do. It never reaches the
+test page, and the local files it links are copied into the output directory
+([Fonts](https://github.com/grzehub/describe-me#fonts) in the root README).
+
+The pieces can also be wired by hand. Tests then import from the adapter
+themselves: `render` from `@describe-me/react` in browser mode, and `render`,
+`fireEvent` and `cleanup` from `@describe-me/react/testing-library` in jsdom:
 
 ```ts
 import DescribeMeReporter from '@describe-me/vitest/reporter'

package/dist/adapter-package-root.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The directory of the adapter package the project resolves, e.g.
+ * `/repo/node_modules/@describe-me/react/`, with posix separators and a
+ * trailing slash the way Vite ids look, or null when it cannot be resolved.
+ * It is the real path, so a workspace link points at its source directory.
+ */
+export declare function adapterPackageRoot(root: string, packageName: string): string | null;

package/dist/adapter-package-root.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, sep } from 'node:path';
+/** The `name` in a directory's package.json, if it has a readable one. */
+function packageNameIn(directory) {
+    const manifest = join(directory, 'package.json');
+    if (!existsSync(manifest)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(readFileSync(manifest, 'utf8')).name;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The directory of the adapter package the project resolves, e.g.
+ * `/repo/node_modules/@describe-me/react/`, with posix separators and a
+ * trailing slash the way Vite ids look, or null when it cannot be resolved.
+ * It is the real path, so a workspace link points at its source directory.
+ */
+export function adapterPackageRoot(root, packageName) {
+    let entry;
+    // The package does not export `./package.json`, so resolve its entry and walk up.
+    try {
+        entry = createRequire(join(root, 'package.json')).resolve(packageName);
+    }
+    catch {
+        return null;
+    }
+    let directory = dirname(entry);
+    while (directory !== dirname(directory)) {
+        if (packageNameIn(directory) === packageName) {
+            return `${directory.split(sep).join('/')}/`;
+        }
+        directory = dirname(directory);
+    }
+    return null;
+}

package/dist/asset-store.d.ts

@@ -1,12 +1,16 @@
 /**
- * Content-addressed store for the project files snapshots point at (images,
- * fonts, `url()` targets of stylesheets), living in `<outDir>/assets`.
+ * Content-addressed store for the project files that snapshots and the preview
+ * head point at (images, fonts, `url()` targets of stylesheets), living in
+ * `<outDir>/assets`.
  *
  * rrweb makes most URLs absolute against the test page, whose server is gone
- * once the tests finish; a few stay root-relative, which the viewer would
+ * once the tests finish. A few stay root-relative, which the viewer would
  * resolve against itself. `rewrite()` copies each file it finds in the project
  * and swaps its URL for `ASSET_URL_PREFIX` plus the stored name, which the
- * viewer resolves against its own data directory.
+ * viewer resolves against its own data directory. `rewriteHead()` does the
+ * same for the preview head. A CSS file is stored with its own `url()` and
+ * `@import` targets copied too and written as bare sibling names, so it keeps
+ * working from `assets/`.
  */
 export declare class AssetStore {
     private readonly outDir;
@@ -15,8 +19,17 @@ export declare class AssetStore {
     /** Stored name per URL pathname in this run, or null when it is not a project file. */
     private readonly names;
     private readonly notFound;
-    /** Asset names per snapshot file. Snapshots are content-addressed, so an entry never goes stale. */
-    private readonly referencesBySnapshot;
+    /** Stored name per absolute CSS file path in this run. */
+    private readonly cssNames;
+    /** CSS files being copied right now, so an `@import` cycle ends. */
+    private readonly copying;
+    /**
+     * Asset names per snapshot or style chunk. Both are content-addressed, so an
+     * entry never goes stale.
+     */
+    private readonly referencesByFile;
+    /** Asset names per stored CSS asset, which is content-addressed too. */
+    private readonly referencesByCssAsset;
     constructor(outDir: string, root: string);
     /** Forget what the previous run found: files may have changed or appeared since. */
     startRun(): void;
@@ -28,21 +41,58 @@ export declare class AssetStore {
      * handled on their own. A `#fragment` is kept, for SVG sprites.
      */
     rewrite(json: string, origin: string | undefined): string;
-    /** Root-relative paths that snapshots in this run pointed at but that do not exist. */
+    /**
+     * Replace every URL in the preview head that points at a project file with
+     * an asset URL. A relative URL counts from the project root, the page the
+     * head is written for.
+     */
+    rewriteHead(html: string): string;
+    /**
+     * Paths that snapshots, the preview head or copied CSS files in this run
+     * pointed at but that do not exist: root-relative inside the project root,
+     * `/@fs/<absolute path>` outside it.
+     */
     missing(): string[];
     /**
-     * Drop the assets no kept snapshot refers to. Paths are relative to the
-     * output directory, as the manifest stores them. Every kept file is scanned,
-     * not only the ones written now: snapshots of modules that were not re-run
-     * were rewritten by an earlier run.
+     * Drop the assets that no kept snapshot or style chunk, no inline text such
+     * as the preview head, and no kept CSS asset refers to. Paths are relative
+     * to the output directory, as the manifest stores them. Every kept file is
+     * scanned, not only the ones written now: snapshots of modules that were not
+     * re-run were rewritten by an earlier run.
      */
-    collectGarbage(snapshotFiles: Iterable<string>): void;
+    collectGarbage(files: Iterable<string>, inlineTexts?: Iterable<string>): void;
+    /** Add what each kept CSS asset refers to, and what those refer to in turn. */
+    private keepCssTargets;
+    private cssAssetReferencesOf;
     private referencesIn;
     /** The asset URL for a root-relative URL path, or null when it is not a project file. */
     private assetUrl;
     /** The stored name for a URL pathname, copying the file on first sight in this run. */
     private nameFor;
     private copyIntoStore;
+    /** Store a project file under its content hash, and return its stored name. */
+    private store;
+    /**
+     * Store a CSS file with its `url()` and `@import` targets stored too. They
+     * are written as bare sibling names, which the browser resolves against the
+     * stylesheet's own URL, so the viewer has nothing to substitute. The name is
+     * the hash of the rewritten text.
+     */
+    private storeCss;
+    /**
+     * The stored name, with its fragment, for a target of the CSS file
+     * `cssFile`, or null to leave the target as written: a remote URL, a
+     * file type outside the allowlist, a missing file or a file being copied.
+     */
+    private siblingName;
+    /**
+     * The file behind a target path of a CSS file, reported when missing. A
+     * root-relative path is looked up like a snapshot URL, a relative one next
+     * to the CSS file on disk.
+     */
+    private cssTargetFile;
+    /** How Vite serves a file: root-relative inside the project root, `/@fs/<absolute path>` outside it. */
+    private servedPath;
     /** Where Vite serves a URL pathname from: `/@fs/`, the project root, or its `public/` folder. */
     private fileFor;
 }

package/dist/asset-store.js

@@ -1,7 +1,10 @@
 import { createHash } from 'node:crypto';
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from 'node:fs';
-import { extname, join, resolve, sep } from 'node:path';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, extname, join, resolve, sep } from 'node:path';
 import { ASSET_URL_PREFIX } from '@describe-me/core/types';
+import { cssAssetReferences } from './css-asset-references.js';
+import { rewriteCssReferences } from './rewrite-css-references.js';
+import { rewriteHeadReferences } from './rewrite-head-references.js';
 /** A URL path inside serialized JSON runs until a quote, whitespace, `)`, `\`, `<` or `>`. */
 const URL_PATH = String.raw `/[^"'\s)\\<>]*`;
 /** A root-relative path: one slash, not the two of a protocol-relative URL. */
@@ -43,12 +46,66 @@ const MODULE_EXTENSIONS = new Set([
     '.vue',
     '.svelte',
 ]);
+/** A URL with a scheme (`https:`, `data:`, `mailto:`, `describe-me-asset:`) is never a project path. */
+const URL_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/** The preview head's URLs resolve as if the page were served from the project root. */
+const PROJECT_ROOT_URL = 'http://project-root.invalid/';
+/**
+ * What a copied CSS file may pull into the store: stylesheets, fonts, images
+ * and cursors. Any other target stays as written, so a stylesheet cannot
+ * publish source files or secrets.
+ */
+const CSS_TARGET_EXTENSIONS = new Set([
+    '.css',
+    '.woff2',
+    '.woff',
+    '.ttf',
+    '.otf',
+    '.eot',
+    '.svg',
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.avif',
+    '.ico',
+    '.bmp',
+    '.cur',
+]);
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 function isFile(path) {
     return existsSync(path) && statSync(path).isFile();
 }
+function contentHash(content) {
+    return createHash('sha1').update(content).digest('hex').slice(0, 16);
+}
+function assetNamesIn(text) {
+    return Array.from(text.matchAll(ASSET_REFERENCE), (match) => match[1]);
+}
+/** Empty values, `#fragment`s, protocol-relative and scheme URLs never name a project file. */
+function isExternalUrl(url) {
+    return url === '' || url.startsWith('#') || url.startsWith('//') || URL_SCHEME.test(url);
+}
+/**
+ * A preview head URL as a root-relative path, or null when it cannot be read
+ * or leaves the project root, as `\\host\x` does.
+ */
+function rootRelativePath(url) {
+    let resolved;
+    try {
+        resolved = new URL(url, PROJECT_ROOT_URL);
+    }
+    catch {
+        return null;
+    }
+    if (!resolved.href.startsWith(PROJECT_ROOT_URL)) {
+        return null;
+    }
+    return resolved.pathname + resolved.search + resolved.hash;
+}
 function decodePath(pathname) {
     try {
         return decodeURIComponent(pathname);
@@ -78,14 +135,18 @@ function fsPathFromUrl(pathname) {
     return /^[A-Za-z]:/.test(path) ? path : `/${path}`;
 }
 /**
- * Content-addressed store for the project files snapshots point at (images,
- * fonts, `url()` targets of stylesheets), living in `<outDir>/assets`.
+ * Content-addressed store for the project files that snapshots and the preview
+ * head point at (images, fonts, `url()` targets of stylesheets), living in
+ * `<outDir>/assets`.
  *
  * rrweb makes most URLs absolute against the test page, whose server is gone
- * once the tests finish; a few stay root-relative, which the viewer would
+ * once the tests finish. A few stay root-relative, which the viewer would
  * resolve against itself. `rewrite()` copies each file it finds in the project
  * and swaps its URL for `ASSET_URL_PREFIX` plus the stored name, which the
- * viewer resolves against its own data directory.
+ * viewer resolves against its own data directory. `rewriteHead()` does the
+ * same for the preview head. A CSS file is stored with its own `url()` and
+ * `@import` targets copied too and written as bare sibling names, so it keeps
+ * working from `assets/`.
  */
 export class AssetStore {
     outDir;
@@ -94,8 +155,17 @@ export class AssetStore {
     /** Stored name per URL pathname in this run, or null when it is not a project file. */
     names = new Map();
     notFound = new Set();
-    /** Asset names per snapshot file. Snapshots are content-addressed, so an entry never goes stale. */
-    referencesBySnapshot = new Map();
+    /** Stored name per absolute CSS file path in this run. */
+    cssNames = new Map();
+    /** CSS files being copied right now, so an `@import` cycle ends. */
+    copying = new Set();
+    /**
+     * Asset names per snapshot or style chunk. Both are content-addressed, so an
+     * entry never goes stale.
+     */
+    referencesByFile = new Map();
+    /** Asset names per stored CSS asset, which is content-addressed too. */
+    referencesByCssAsset = new Map();
     constructor(outDir, root) {
         this.outDir = outDir;
         this.dir = join(outDir, 'assets');
@@ -106,6 +176,7 @@ export class AssetStore {
     startRun() {
         this.names.clear();
         this.notFound.clear();
+        this.cssNames.clear();
     }
     /**
      * Replace every URL in a serialized snapshot that points at a project file
@@ -132,45 +203,96 @@ export class AssetStore {
             return asset === null ? poster : `"poster":"${asset}`;
         });
     }
-    /** Root-relative paths that snapshots in this run pointed at but that do not exist. */
+    /**
+     * Replace every URL in the preview head that points at a project file with
+     * an asset URL. A relative URL counts from the project root, the page the
+     * head is written for.
+     */
+    rewriteHead(html) {
+        return rewriteHeadReferences(html, (url) => {
+            if (isExternalUrl(url)) {
+                return null;
+            }
+            const path = rootRelativePath(url);
+            return path === null ? null : this.assetUrl(path);
+        });
+    }
+    /**
+     * Paths that snapshots, the preview head or copied CSS files in this run
+     * pointed at but that do not exist: root-relative inside the project root,
+     * `/@fs/<absolute path>` outside it.
+     */
     missing() {
         return Array.from(this.notFound).sort();
     }
     /**
-     * Drop the assets no kept snapshot refers to. Paths are relative to the
-     * output directory, as the manifest stores them. Every kept file is scanned,
-     * not only the ones written now: snapshots of modules that were not re-run
-     * were rewritten by an earlier run.
+     * Drop the assets that no kept snapshot or style chunk, no inline text such
+     * as the preview head, and no kept CSS asset refers to. Paths are relative
+     * to the output directory, as the manifest stores them. Every kept file is
+     * scanned, not only the ones written now: snapshots of modules that were not
+     * re-run were rewritten by an earlier run.
      */
-    collectGarbage(snapshotFiles) {
+    collectGarbage(files, inlineTexts = []) {
         const stored = readdirSync(this.dir);
         if (stored.length === 0) {
             return;
         }
         const keep = new Set();
-        for (const snapshotFile of snapshotFiles) {
-            for (const name of this.referencesIn(snapshotFile)) {
+        for (const file of files) {
+            for (const name of this.referencesIn(file)) {
+                keep.add(name);
+            }
+        }
+        for (const text of inlineTexts) {
+            for (const name of assetNamesIn(text)) {
                 keep.add(name);
             }
         }
+        this.keepCssTargets(keep);
         for (const file of stored) {
             if (!keep.has(file)) {
                 rmSync(join(this.dir, file), { force: true });
             }
         }
     }
-    referencesIn(snapshotFile) {
-        const cached = this.referencesBySnapshot.get(snapshotFile);
+    /** Add what each kept CSS asset refers to, and what those refer to in turn. */
+    keepCssTargets(keep) {
+        const pending = Array.from(keep).filter((name) => name.endsWith('.css'));
+        let name = pending.pop();
+        while (name !== undefined) {
+            for (const target of this.cssAssetReferencesOf(name)) {
+                if (!keep.has(target)) {
+                    keep.add(target);
+                    pending.push(target);
+                }
+            }
+            name = pending.pop();
+        }
+    }
+    cssAssetReferencesOf(name) {
+        const cached = this.referencesByCssAsset.get(name);
+        if (cached) {
+            return cached;
+        }
+        const path = join(this.dir, name);
+        if (!name.endsWith('.css') || !isFile(path)) {
+            return [];
+        }
+        const names = cssAssetReferences(readFileSync(path, 'utf8'));
+        this.referencesByCssAsset.set(name, names);
+        return names;
+    }
+    referencesIn(file) {
+        const cached = this.referencesByFile.get(file);
         if (cached) {
             return cached;
         }
-        const path = join(this.outDir, snapshotFile);
+        const path = join(this.outDir, file);
         if (!isFile(path)) {
             return [];
         }
-        const json = readFileSync(path, 'utf8');
-        const names = Array.from(json.matchAll(ASSET_REFERENCE), (match) => match[1]);
-        this.referencesBySnapshot.set(snapshotFile, names);
+        const names = assetNamesIn(readFileSync(path, 'utf8'));
+        this.referencesByFile.set(file, names);
         return names;
     }
     /** The asset URL for a root-relative URL path, or null when it is not a project file. */
@@ -205,8 +327,15 @@ export class AssetStore {
             }
             return null;
         }
-        const hash = createHash('sha1').update(readFileSync(file)).digest('hex').slice(0, 16);
+        return this.store(file);
+    }
+    /** Store a project file under its content hash, and return its stored name. */
+    store(file) {
         const extension = extname(file).toLowerCase();
+        if (extension === '.css') {
+            return this.storeCss(file);
+        }
+        const hash = contentHash(readFileSync(file));
         const name = /^\.[a-z0-9]+$/.test(extension) ? `${hash}${extension}` : hash;
         const target = join(this.dir, name);
         if (!existsSync(target)) {
@@ -214,6 +343,80 @@ export class AssetStore {
         }
         return name;
     }
+    /**
+     * Store a CSS file with its `url()` and `@import` targets stored too. They
+     * are written as bare sibling names, which the browser resolves against the
+     * stylesheet's own URL, so the viewer has nothing to substitute. The name is
+     * the hash of the rewritten text.
+     */
+    storeCss(file) {
+        const known = this.cssNames.get(file);
+        if (known !== undefined) {
+            return known;
+        }
+        let css;
+        this.copying.add(file);
+        try {
+            css = rewriteCssReferences(readFileSync(file, 'utf8'), (url) => this.siblingName(url, file));
+        }
+        finally {
+            this.copying.delete(file);
+        }
+        const name = `${contentHash(css)}.css`;
+        const target = join(this.dir, name);
+        if (!existsSync(target)) {
+            writeFileSync(target, css);
+        }
+        this.cssNames.set(file, name);
+        return name;
+    }
+    /**
+     * The stored name, with its fragment, for a target of the CSS file
+     * `cssFile`, or null to leave the target as written: a remote URL, a
+     * file type outside the allowlist, a missing file or a file being copied.
+     */
+    siblingName(url, cssFile) {
+        if (isExternalUrl(url)) {
+            return null;
+        }
+        const { pathname, fragment } = splitUrlPath(url);
+        const path = decodePath(pathname);
+        if (!CSS_TARGET_EXTENSIONS.has(extname(path).toLowerCase())) {
+            return null;
+        }
+        const file = this.cssTargetFile(path, cssFile);
+        if (!file || this.copying.has(file)) {
+            return null;
+        }
+        return `${this.store(file)}${fragment}`;
+    }
+    /**
+     * The file behind a target path of a CSS file, reported when missing. A
+     * root-relative path is looked up like a snapshot URL, a relative one next
+     * to the CSS file on disk.
+     */
+    cssTargetFile(path, cssFile) {
+        if (path.startsWith('/')) {
+            const file = this.fileFor(path);
+            if (!file) {
+                this.notFound.add(path);
+            }
+            return file;
+        }
+        const file = resolve(dirname(cssFile), path);
+        if (!isFile(file)) {
+            this.notFound.add(this.servedPath(file));
+            return undefined;
+        }
+        return file;
+    }
+    /** How Vite serves a file: root-relative inside the project root, `/@fs/<absolute path>` outside it. */
+    servedPath(file) {
+        const path = file.startsWith(this.root + sep)
+            ? file.slice(this.root.length)
+            : `/@fs/${file.replace(/^[\\/]/, '')}`;
+        return path.split(sep).join('/');
+    }
     /** Where Vite serves a URL pathname from: `/@fs/`, the project root, or its `public/` folder. */
     fileFor(pathname) {
         if (pathname.startsWith('/@fs/')) {

package/dist/compile-globs.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledGlob } from './runtime-options.js';
+/**
+ * Plain `{ source, flags }` pairs, because the globs travel to the test
+ * runtime as JSON. Invalid input fails here, before any test runs.
+ */
+export declare function compileGlobs(patterns: string | string[] | undefined): CompiledGlob[];

package/dist/compile-globs.js

@@ -0,0 +1,20 @@
+import { inspect } from 'node:util';
+import picomatch from 'picomatch';
+/**
+ * Plain `{ source, flags }` pairs, because the globs travel to the test
+ * runtime as JSON. Invalid input fails here, before any test runs.
+ */
+export function compileGlobs(patterns) {
+    if (patterns === undefined) {
+        return [];
+    }
+    const list = Array.isArray(patterns) ? patterns : [patterns];
+    return list.map((pattern) => {
+        // picomatch throws its own unprefixed TypeError for an empty string.
+        if (typeof pattern !== 'string' || pattern === '') {
+            throw new Error(`describe-me: include and exclude expect non-empty glob strings, got ${inspect(pattern)}`);
+        }
+        const regExp = picomatch.makeRe(pattern, { dot: true, windows: false });
+        return { source: regExp.source, flags: regExp.flags };
+    });
+}

package/dist/css-asset-references.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The stored asset names a stored CSS asset refers to. The asset store writes
+ * them as bare sibling names, so garbage collection can follow them.
+ */
+export declare function cssAssetReferences(css: string): string[];

package/dist/css-asset-references.js

@@ -0,0 +1,17 @@
+import { cssReferences } from '@describe-me/core/css-references';
+/** A stored asset's name: a content hash and, when the file has one, its extension. */
+const ASSET_NAME = /^[0-9a-f]{16}(\.[a-z0-9]+)?$/;
+/**
+ * The stored asset names a stored CSS asset refers to. The asset store writes
+ * them as bare sibling names, so garbage collection can follow them.
+ */
+export function cssAssetReferences(css) {
+    const names = [];
+    for (const { url } of cssReferences(css)) {
+        const name = url.split(/[?#]/)[0];
+        if (ASSET_NAME.test(name)) {
+            names.push(name);
+        }
+    }
+    return names;
+}

package/dist/file-filter.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeOptions } from './runtime-options.js';
+/**
+ * Takes a path relative to the root, with posix separators. Build it once and
+ * reuse the returned function, which memoizes per file name. The test runtime
+ * imports this file, so no Node imports.
+ */
+export declare function fileFilter(options: Pick<RuntimeOptions, 'include' | 'exclude'>): (fileName: string) => boolean;

package/dist/file-filter.js

@@ -0,0 +1,23 @@
+function toRegExps(globs) {
+    return globs.map((glob) => new RegExp(glob.source, glob.flags));
+}
+/**
+ * Takes a path relative to the root, with posix separators. Build it once and
+ * reuse the returned function, which memoizes per file name. The test runtime
+ * imports this file, so no Node imports.
+ */
+export function fileFilter(options) {
+    const include = toRegExps(options.include);
+    const exclude = toRegExps(options.exclude);
+    const answers = new Map();
+    return (fileName) => {
+        const known = answers.get(fileName);
+        if (known !== undefined) {
+            return known;
+        }
+        const included = include.length === 0 || include.some((glob) => glob.test(fileName));
+        const answer = included && !exclude.some((glob) => glob.test(fileName));
+        answers.set(fileName, answer);
+        return answer;
+    };
+}

package/dist/is-recorded-test.d.ts

@@ -0,0 +1,6 @@
+import type { FrameKind } from '@describe-me/core/types';
+export declare function isRecordedTest(test: {
+    frames: readonly {
+        kind: FrameKind;
+    }[];
+}): boolean;

package/dist/is-recorded-test.js

@@ -0,0 +1,3 @@
+export function isRecordedTest(test) {
+    return test.frames.some((frame) => frame.kind !== 'end');
+}

package/dist/mirror-react-act-environment.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Set React's `IS_REACT_ACT_ENVIRONMENT` flag for each test file, the way
+ * Testing Library does. `RTL_SKIP_AUTO_CLEANUP` skips its whole setup block,
+ * the flag included, which silences React's act warnings. The flag is set
+ * only under Testing Library's own condition (Vitest globals), so the
+ * warnings match a run without describe-me.
+ */
+export declare function mirrorReactActEnvironment(): void;