@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/addon-vitest/vitest-plugin/global-setup.js

@@ -0,0 +1,162 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "../../_node-chunks/chunk-CXRU72ET.js";
+
+// ../../node_modules/tree-kill/index.js
+var require_tree_kill = __commonJS({
+  "../../node_modules/tree-kill/index.js"(exports, module) {
+    "use strict";
+    var childProcess = __require("child_process"), spawn2 = childProcess.spawn, exec = childProcess.exec;
+    module.exports = function(pid, signal, callback) {
+      if (typeof signal == "function" && callback === void 0 && (callback = signal, signal = void 0), pid = parseInt(pid), Number.isNaN(pid)) {
+        if (callback)
+          return callback(new Error("pid must be a number"));
+        throw new Error("pid must be a number");
+      }
+      var tree = {}, pidsToProcess = {};
+      switch (tree[pid] = [], pidsToProcess[pid] = 1, process.platform) {
+        case "win32":
+          exec("taskkill /pid " + pid + " /T /F", callback);
+          break;
+        case "darwin":
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("pgrep", ["-P", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+        // case 'sunos':
+        //     buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+        //         killAll(tree, signal, callback);
+        //     });
+        //     break;
+        default:
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+      }
+    };
+    function killAll(tree, signal, callback) {
+      var killed = {};
+      try {
+        Object.keys(tree).forEach(function(pid) {
+          tree[pid].forEach(function(pidpid) {
+            killed[pidpid] || (killPid(pidpid, signal), killed[pidpid] = 1);
+          }), killed[pid] || (killPid(pid, signal), killed[pid] = 1);
+        });
+      } catch (err) {
+        if (callback)
+          return callback(err);
+        throw err;
+      }
+      if (callback)
+        return callback();
+    }
+    function killPid(pid, signal) {
+      try {
+        process.kill(parseInt(pid, 10), signal);
+      } catch (err) {
+        if (err.code !== "ESRCH") throw err;
+      }
+    }
+    function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+      var ps = spawnChildProcessesList(parentPid), allData = "";
+      ps.stdout.on("data", function(data) {
+        var data = data.toString("ascii");
+        allData += data;
+      });
+      var onClose = function(code) {
+        if (delete pidsToProcess[parentPid], code != 0) {
+          Object.keys(pidsToProcess).length == 0 && cb();
+          return;
+        }
+        allData.match(/\d+/g).forEach(function(pid) {
+          pid = parseInt(pid, 10), tree[parentPid].push(pid), tree[pid] = [], pidsToProcess[pid] = 1, buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+        });
+      };
+      ps.on("close", onClose);
+    }
+  }
+});
+
+// src/addon-vitest/vitest-plugin/global-setup.ts
+var import_tree_kill = __toESM(require_tree_kill(), 1);
+import { spawn } from "node:child_process";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+var storybookProcess = null, getIsVitestStandaloneRun = () => {
+  try {
+    return (import.meta.env || process?.env).STORYBOOK !== "true";
+  } catch {
+    return !1;
+  }
+}, isVitestStandaloneRun = getIsVitestStandaloneRun(), checkStorybookRunning = async (storybookUrl) => {
+  try {
+    return (await fetch(`${storybookUrl}/iframe.html`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3)
+    })).ok;
+  } catch (error) {
+    return logger.verbose(
+      `Failed to get response from ${storybookUrl}: ${error instanceof Error ? error.message : String(error)}`
+    ), !1;
+  }
+}, startStorybookIfNotRunning = async () => {
+  let storybookScript = process.env.__STORYBOOK_SCRIPT__, storybookUrl = process.env.__STORYBOOK_URL__;
+  if (await checkStorybookRunning(storybookUrl)) {
+    logger.verbose("Forkbook is already running");
+    return;
+  }
+  logger.verbose(`Starting Forkbook with command: ${storybookScript}`);
+  try {
+    storybookProcess = spawn(storybookScript, {
+      shell: !0,
+      stdio: process.env.DEBUG === "storybook" ? "pipe" : "ignore",
+      cwd: process.cwd()
+    }), storybookProcess.on("error", (error) => {
+      throw logger.verbose("Failed to start Forkbook:" + error.message), error;
+    });
+  } catch (error) {
+    throw logger.verbose("Failed to start Forkbook:" + error.message), error;
+  }
+}, setup = async ({ config }) => {
+  config.watch && isVitestStandaloneRun && await startStorybookIfNotRunning();
+}, teardown = async () => {
+  storybookProcess && (logger.verbose("Stopping Forkbook process"), await new Promise((resolve, reject) => {
+    if (storybookProcess?.pid) {
+      let pid = storybookProcess.pid;
+      (0, import_tree_kill.default)(pid, "SIGTERM", (error) => {
+        if (error) {
+          if (process.platform === "win32" && "code" in error && error.code === 128) {
+            logger.verbose(
+              `Forkbook process (pid ${pid}) already exited; treating teardown as successful (code ${error.code}: ${error.message})`
+            ), resolve();
+            return;
+          }
+          logger.error("Failed to stop Forkbook process:"), reject(error);
+          return;
+        }
+        resolve();
+      });
+    }
+  }));
+};
+export {
+  setup,
+  teardown
+};

package/dist/addon-vitest/vitest-plugin/index.d.ts

@@ -0,0 +1,56 @@
+import { Plugin } from "vitest/config";
+
+//#region .dts-emit/code/core/src/addon-vitest/vitest-plugin/types.d.ts
+type UserOptions = {
+  /**
+   * The directory where the Forkbook configuration is located, relative to the vitest
+   * configuration file. If not provided, the plugin will use '.forkbook' in the current working
+   * directory.
+   *
+   * @default '.forkbook'
+   */
+  configDir?: string;
+  /**
+   * Optional script to run Forkbook. If provided, Vitest will start Forkbook using this script
+   * when ran in watch mode.
+   *
+   * @default undefined
+   */
+  storybookScript?: string;
+  /**
+   * The URL where Forkbook is hosted. This is used to provide a link to the story in the test
+   * output on failures.
+   *
+   * @default 'http://localhost:6006'
+   */
+  storybookUrl?: string; /** Tags to include, exclude, or skip. These tags are defined as annotations in your story or meta. */
+  tags?: {
+    include?: string[];
+    exclude?: string[];
+    skip?: string[];
+  };
+  /**
+   * Whether to disable addon docs features while running tests.
+   *
+   * Most users don't need addon docs for tests, the only scenario where you might need it is if you
+   * need to read and parse MDX files as part of rendering your components.
+   *
+   * @default true
+   */
+  disableAddonDocs?: boolean;
+  /**
+   * Globals applied to every story run by this project, merged under the values Forkbook sets
+   * internally. Use it to pin a toolbar global for the whole run — most usefully to test a
+   * specific theme: define one Vitest project per theme, each with a different value, e.g.
+   * `storybookTest({ initialGlobals: { theme: 'dark' } })`. Equivalent to `initialGlobals` in
+   * `.forkbook/preview`, but per project instead of global.
+   *
+   * @default {}
+   */
+  initialGlobals?: Record<string, unknown>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/addon-vitest/vitest-plugin/index.d.ts
+declare const storybookTest: (options?: UserOptions) => Promise<Plugin[]>;
+//#endregion
+export { storybookTest as default, storybookTest };

package/dist/addon-vitest/vitest-plugin/index.js

@@ -0,0 +1,463 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  require_micromatch
+} from "../../_node-chunks/chunk-QEQLR22M.js";
+import {
+  FORKBOOK_CORE_GHOST_STORIES_PROVIDE_KEY,
+  FORKBOOK_CORE_RENDER_ANALYSIS_PROVIDE_KEY,
+  FORKBOOK_TEST_FEATURES_PROVIDE_KEY,
+  FORKBOOK_TEST_INITIAL_GLOBALS_PROVIDE_KEY
+} from "../../_node-chunks/chunk-H32DYT6P.js";
+import {
+  withoutVitePlugins
+} from "../../_node-chunks/chunk-H4PPVMP5.js";
+import {
+  getAiSetupRunId
+} from "../../_node-chunks/chunk-NPO45IMH.js";
+import {
+  require_build
+} from "../../_node-chunks/chunk-XGIUVY52.js";
+import {
+  require_picocolors
+} from "../../_node-chunks/chunk-2BUPBPFB.js";
+import {
+  __toESM
+} from "../../_node-chunks/chunk-CXRU72ET.js";
+
+// src/addon-vitest/vitest-plugin/index.ts
+var import_micromatch = __toESM(require_micromatch(), 1), import_picocolors = __toESM(require_picocolors(), 1), import_sirv = __toESM(require_build(), 1);
+import { fileURLToPath } from "node:url";
+import { mergeConfig } from "vitest/config";
+import {
+  DEFAULT_FILES_PATTERN,
+  HandledError,
+  defaultConfigDir,
+  getInterpretedFile,
+  normalizeStories,
+  optionalEnvToBoolean,
+  resolvePathInStorybookCache as resolvePathInStorybookCache2,
+  validateConfigurationFiles
+} from "@aussieljk/forkbook/internal/common";
+import {
+  StoryIndexGenerator,
+  Tag,
+  experimental_loadStorybook,
+  mapStaticDir
+} from "@aussieljk/forkbook/internal/core-server";
+import {
+  componentTransform,
+  readConfig,
+  vitestTransform
+} from "@aussieljk/forkbook/internal/csf-tools";
+import { MainFileMissingError } from "@aussieljk/forkbook/internal/server-errors";
+import {
+  detectAgent,
+  isTelemetryModuleEnabled,
+  isWithinInitialSession,
+  oneWayHash,
+  telemetry as telemetry2,
+  setTelemetryEnabled
+} from "@aussieljk/forkbook/internal/telemetry";
+import { join, normalize, relative, resolve, sep } from "pathe";
+import path from "pathe";
+import { dedent } from "ts-dedent";
+
+// src/addon-vitest/vitest-plugin/agent-telemetry-reporter.ts
+import { analyzeTestResults, toStoryTestResult } from "@aussieljk/forkbook/internal/core-server";
+import { isExampleStoryId, telemetry } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/addon-vitest/vitest-plugin/agent-story-history-cache.ts
+import {
+  createFileSystemCache,
+  resolvePathInStorybookCache
+} from "@aussieljk/forkbook/internal/common";
+var CACHE_KEY = "agent-self-healing-story-history", historyCache = createFileSystemCache({
+  basePath: resolvePathInStorybookCache("agent-self-healing"),
+  ns: "storybook"
+});
+async function readStoryHistory() {
+  return await historyCache.get(CACHE_KEY) ?? {};
+}
+async function mergeAndWriteStoryHistory(results) {
+  let history = await readStoryHistory(), now = Date.now();
+  for (let result of results) {
+    let existing = history[result.storyId];
+    (!existing || existing.timestamp <= now) && (history[result.storyId] = { ...result, timestamp: now });
+  }
+  return await historyCache.set(CACHE_KEY, history), Object.values(history).map(({ timestamp, ...rest }) => rest);
+}
+
+// src/addon-vitest/vitest-plugin/agent-telemetry-reporter.ts
+var AgentTelemetryReporter = class {
+  constructor(options) {
+    this.testResults = [];
+    this.startTime = Date.now();
+    this.configDir = options.configDir, this.agent = options.agent;
+  }
+  onInit(ctx) {
+    this.ctx = ctx;
+  }
+  onTestRunStart() {
+    this.startTime = Date.now();
+  }
+  onTestCaseResult(testCase) {
+    let { storyId, reports } = testCase.meta();
+    if (!storyId || isExampleStoryId(storyId))
+      return;
+    let testResult = testCase.result(), result = toStoryTestResult({
+      storyId,
+      statusRaw: testResult.state,
+      reports,
+      errors: testResult.errors
+    });
+    result && this.testResults.push(result);
+  }
+  async onTestRunEnd(testModules, unhandledErrors) {
+    let cumulativeResults = await mergeAndWriteStoryHistory(this.testResults), analysis = analyzeTestResults(this.testResults, cumulativeResults), duration = Date.now() - this.startTime, testModulesErrors = testModules.flatMap((t) => t.errors()), unhandledErrorCount = unhandledErrors.length + testModulesErrors.length, runId = await getAiSetupRunId(this.configDir);
+    telemetry(
+      "ai-setup-self-healing-scoring",
+      {
+        agent: this.agent,
+        analysis,
+        unhandledErrorCount,
+        duration,
+        watch: this.ctx.config.watch,
+        runId
+      },
+      { configDir: this.configDir, stripMetadata: !0 }
+    ), this.testResults = [];
+  }
+};
+
+// src/addon-vitest/vitest-plugin/stack-frames.ts
+var INTERNAL_FRAME_PATTERNS = [
+  /[\\/]storybook[\\/]dist[\\/]/,
+  /[\\/]@storybook[\\/][^\\/]+[\\/]dist[\\/]/,
+  /[\\/]deps[\\/]@?storybook[@_]/
+];
+function isStorybookInternalFrame(file) {
+  return !!file && INTERNAL_FRAME_PATTERNS.some((pattern) => pattern.test(file));
+}
+
+// src/addon-vitest/vitest-plugin/index.ts
+var WORKING_DIR = process.cwd(), defaultOptions = {
+  storybookScript: void 0,
+  configDir: resolve(join(WORKING_DIR, defaultConfigDir(WORKING_DIR))),
+  storybookUrl: "http://localhost:6006",
+  disableAddonDocs: !0,
+  initialGlobals: {}
+}, extractTagsFromPreview = async (configDir) => {
+  let previewConfigPath = getInterpretedFile(join(resolve(configDir), "preview"));
+  if (!previewConfigPath)
+    return [];
+  let previewConfig = await readConfig(previewConfigPath), tags = previewConfig.getValue(["tags"]) ?? [];
+  if (previewConfig.mutationDiagnostics.some(({ code }) => code === "unsupported-value") || !Array.isArray(tags) || !tags.every((tag) => typeof tag == "string"))
+    throw new HandledError("Preview tags must be a static array of strings");
+  return tags;
+}, getStoryGlobsAndFiles = async (presets, directories) => {
+  let stories = await presets.apply("stories", []), normalizedStories = normalizeStories(stories, {
+    configDir: directories.configDir,
+    workingDir: directories.workingDir
+  }), matchingStoryFiles = await StoryIndexGenerator.findMatchingFilesForSpecifiers(
+    normalizedStories,
+    directories.workingDir
+  );
+  return {
+    storiesGlobs: stories,
+    storiesFiles: StoryIndexGenerator.storyFileNames(
+      new Map(matchingStoryFiles.map(([specifier, cache]) => [specifier, cache]))
+    )
+  };
+}, mdxStubPlugin = {
+  name: "storybook:stub-mdx-plugin",
+  enforce: "pre",
+  resolveId(id) {
+    return id.endsWith(".mdx") ? id : null;
+  },
+  load(id) {
+    return id.endsWith(".mdx") ? "export default {};" : null;
+  }
+}, getComponentTestPaths = () => {
+  let envPaths = process.env.FORKBOOK_COMPONENT_PATHS;
+  return envPaths ? envPaths.split(";").filter(Boolean) : [];
+}, createComponentTestTransformPlugin = (presets, configDir) => {
+  let storybookComponentTestPaths = getComponentTestPaths();
+  return {
+    name: "storybook:component-test-transform-plugin",
+    transform: {
+      order: "pre",
+      async handler(code, id) {
+        if (!optionalEnvToBoolean(process.env.VITEST) || storybookComponentTestPaths.length === 0)
+          return code;
+        let resolvedId = path.resolve(id);
+        return storybookComponentTestPaths.some(
+          (testPath) => resolvedId === testPath || resolvedId.startsWith(testPath + path.sep) || resolvedId.endsWith(testPath)
+        ) ? (await componentTransform({
+          code,
+          fileName: id,
+          getComponentArgTypes: async ({ componentName, fileName }) => presets.apply("internal_getArgTypesData", null, {
+            componentFilePath: fileName,
+            componentExportName: componentName,
+            configDir
+          })
+        })).code : code;
+      }
+    }
+  };
+}, toApiPermissions = (api) => api && typeof api == "object" ? api : {}, getUserApiPermissions = (testConfig) => {
+  let api = toApiPermissions(testConfig?.api), browserApi = toApiPermissions(testConfig?.browser?.api);
+  return {
+    allowWrite: api.allowWrite ?? browserApi.allowWrite,
+    allowExec: api.allowExec ?? browserApi.allowExec
+  };
+}, storybookTest = async (options) => {
+  if (!optionalEnvToBoolean(process.env.VITEST))
+    return [];
+  let finalOptions = {
+    ...defaultOptions,
+    ...options,
+    configDir: options?.configDir ? resolve(WORKING_DIR, options.configDir) : defaultOptions.configDir,
+    tags: {
+      include: options?.tags?.include ?? [Tag.TEST],
+      exclude: options?.tags?.exclude ?? [],
+      skip: options?.tags?.skip ?? []
+    }
+  };
+  optionalEnvToBoolean(process.env.DEBUG) && (finalOptions.debug = !0), process.env.__STORYBOOK_URL__ = finalOptions.storybookUrl, process.env.__STORYBOOK_SCRIPT__ = finalOptions.storybookScript;
+  let isVitestStorybook = optionalEnvToBoolean(process.env.VITEST_STORYBOOK), directories = {
+    configDir: finalOptions.configDir,
+    workingDir: WORKING_DIR
+  }, { presets } = await experimental_loadStorybook({
+    configDir: finalOptions.configDir,
+    packageJson: {}
+  }), stories = await presets.apply("stories", []), commonConfig = { root: resolve(finalOptions.configDir, "..") }, [
+    corePlugins,
+    { storiesGlobs },
+    framework,
+    viteConfigFromStorybook,
+    staticDirs,
+    previewLevelTags,
+    core,
+    features
+  ] = await Promise.all([
+    presets.apply("viteCorePlugins", []),
+    getStoryGlobsAndFiles(presets, directories),
+    presets.apply("framework", void 0),
+    presets.apply("viteFinal", commonConfig),
+    presets.apply("staticDirs", []),
+    extractTagsFromPreview(finalOptions.configDir),
+    presets.apply("core"),
+    presets.apply("features", {})
+  ]);
+  await setTelemetryEnabled(!core?.disableTelemetry);
+  let pluginsToIgnore = finalOptions.disableAddonDocs ? ["storybook:package-deduplication", "storybook:mdx-plugin"] : [], plugins = [
+    ...corePlugins,
+    ...await withoutVitePlugins(viteConfigFromStorybook.plugins ?? [], pluginsToIgnore)
+  ];
+  finalOptions.disableAddonDocs && plugins.push(mdxStubPlugin);
+  let agent, withinAgenticSetupSession = !1, userApiPermissions = {}, storybookTestPlugin = {
+    name: "vite-plugin-storybook-test",
+    async transformIndexHtml(html) {
+      let [frameworkOptions, headHtmlSnippet, bodyHtmlSnippet] = await Promise.all([
+        presets.apply("frameworkOptions"),
+        presets.apply("previewHead"),
+        presets.apply("previewBody")
+      ]);
+      return html.replace(
+        "</head>",
+        `<script>window.FRAMEWORK_OPTIONS = ${JSON.stringify(frameworkOptions)};</script>${headHtmlSnippet ?? ""}</head>`
+      ).replace("<body>", `<body>${bodyHtmlSnippet ?? ""}`);
+    },
+    async config(nonMutableInputConfig, { mode }) {
+      isTelemetryModuleEnabled() && (agent = detectAgent(), withinAgenticSetupSession = !!agent && await isWithinInitialSession("ai-setup")), mode && (process.env.BUILD_TARGET = mode);
+      try {
+        await validateConfigurationFiles(finalOptions.configDir);
+      } catch {
+        throw new MainFileMissingError({
+          location: finalOptions.configDir,
+          source: "vitest"
+        });
+      }
+      let frameworkName = typeof framework == "string" ? framework : framework.name, testConfig = nonMutableInputConfig.test;
+      finalOptions.vitestRoot = testConfig?.dir || testConfig?.root || viteConfigFromStorybook.root || nonMutableInputConfig.root || process.cwd();
+      let includeStories = stories.map((story) => {
+        let storyPath;
+        return typeof story == "string" ? storyPath = story : storyPath = `${story.directory}/${story.files ?? DEFAULT_FILES_PATTERN}`, join(finalOptions.configDir, storyPath);
+      }).map((story) => relative(finalOptions.vitestRoot, story));
+      finalOptions.includeStories = includeStories;
+      let projectId = oneWayHash(finalOptions.configDir);
+      userApiPermissions = getUserApiPermissions(testConfig);
+      let baseConfig = {
+        cacheDir: resolvePathInStorybookCache2("sb-vitest", projectId),
+        test: {
+          expect: { requireAssertions: !1 },
+          onStackTrace: (error, frame) => isStorybookInternalFrame(frame.file) ? !1 : nonMutableInputConfig.test?.onStackTrace?.(error, frame) ?? !0,
+          setupFiles: [
+            "@aussieljk/forkbook/addon-vitest/internal/setup-file",
+            "@aussieljk/forkbook/addon-vitest/internal/setup-file-with-project-annotations",
+            // if the existing setupFiles is a string, we have to include it otherwise we're overwriting it
+            typeof nonMutableInputConfig.test?.setupFiles == "string" && nonMutableInputConfig.test?.setupFiles
+          ].filter(Boolean),
+          ...finalOptions.storybookScript ? {
+            globalSetup: [
+              fileURLToPath(
+                import.meta.resolve("@aussieljk/forkbook/addon-vitest/internal/global-setup")
+              )
+            ]
+          } : {},
+          env: {
+            /**
+             * We do this late, because we need vitest's --mode to be available and set to
+             * BUILD_MODE. Unfortunately, the dependencies we use to load .env files can only be
+             * configured using that environment variable. We need it to be synced up with the mode
+             * that vitest is running in, or risk leaking envs from the wrong file.
+             *
+             * @see https://github.com/storybookjs/storybook/issues/33101
+             */
+            ...await presets.apply("env", {}),
+            // To be accessed by the setup file
+            __STORYBOOK_URL__: finalOptions.storybookUrl,
+            VITEST_STORYBOOK: isVitestStorybook ? "true" : "false",
+            __VITEST_INCLUDE_TAGS__: finalOptions.tags.include.join(","),
+            __VITEST_EXCLUDE_TAGS__: finalOptions.tags.exclude.join(","),
+            __VITEST_SKIP_TAGS__: finalOptions.tags.skip.join(",")
+          },
+          provide: {
+            [FORKBOOK_TEST_FEATURES_PROVIDE_KEY]: features,
+            [FORKBOOK_CORE_GHOST_STORIES_PROVIDE_KEY]: !!process.env.FORKBOOK_COMPONENT_PATHS,
+            [FORKBOOK_CORE_RENDER_ANALYSIS_PROVIDE_KEY]: !!process.env.FORKBOOK_COMPONENT_PATHS || withinAgenticSetupSession,
+            [FORKBOOK_TEST_INITIAL_GLOBALS_PROVIDE_KEY]: finalOptions.initialGlobals
+          },
+          include: [...includeStories, ...getComponentTestPaths()],
+          exclude: [
+            ...nonMutableInputConfig.test?.exclude ?? [],
+            join(relative(finalOptions.vitestRoot, process.cwd()), "**/*.mdx").replaceAll(sep, "/")
+          ],
+          browser: {
+            // if there is a test.browser config AND test.browser.screenshotFailures is not explicitly set, we set it to false
+            ...nonMutableInputConfig.test?.browser && nonMutableInputConfig.test.browser.screenshotFailures === void 0 ? {
+              screenshotFailures: !1
+            } : {},
+            // Inject the cursor reset command we use to prevent accidental hover states when running
+            // Forkbook tests in Chromium on Linux. There is a known race condition / special code path
+            // in Chromium causing it to sometimes apply :hover to the element under the mouse cursor even
+            // when there was no mouse movement.
+            commands: {
+              async resetMousePosition(ctx) {
+                ctx.provider.name === "playwright" && await (await ctx.frame()).page().mouse.move(-1e3, -1e3);
+              }
+            }
+          }
+        },
+        optimizeDeps: {
+          include: [
+            "@aussieljk/forkbook/addon-vitest/internal/setup-file",
+            "@aussieljk/forkbook/addon-vitest/internal/setup-file.browser.4",
+            "@aussieljk/forkbook/addon-vitest/internal/global-setup",
+            "@aussieljk/forkbook/addon-vitest/internal/test-utils",
+            "@aussieljk/forkbook/preview-api",
+            // imported by the setup files; without pinning, its CJS-only deps (via
+            // @testing-library/dom) reach the browser raw on hoisted node_modules layouts
+            "@aussieljk/forkbook/test",
+            ...frameworkName?.includes("react") || frameworkName?.includes("nextjs") ? ["react-dom/test-utils"] : []
+          ]
+        },
+        define: {
+          FEATURES: JSON.stringify(features)
+        }
+      }, config = mergeConfig(baseConfig, viteConfigFromStorybook);
+      return (nonMutableInputConfig.test?.include?.length ?? 0) > 0 && (nonMutableInputConfig.test.include = [], console.log(
+        import_picocolors.default.yellow(dedent`
+            Warning: Starting in Forkbook 8.5.0-alpha.18, the "test.include" option in Vitest is discouraged in favor of just using the "stories" field in your Forkbook configuration.
+
+            The values you passed to "test.include" will be ignored, please remove them from your Vitest configuration where the Forkbook plugin is applied.
+
+            More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#addon-test-indexing-behavior-of-storybookaddon-test-is-changed
+          `)
+      )), config;
+    },
+    async configureVitest(context) {
+      if (context.vitest.config.coverage.exclude.push("storybook-static"), context.project.config.browser?.enabled === !0) {
+        let browserSetupFile = fileURLToPath(
+          import.meta.resolve("@aussieljk/forkbook/addon-vitest/internal/setup-file.browser.4")
+        );
+        context.project.config.setupFiles.includes(browserSetupFile) || context.project.config.setupFiles.push(browserSetupFile);
+        let { api, browser } = context.project.config;
+        for (let target of [api, browser.api])
+          target && (target.allowWrite = userApiPermissions.allowWrite ?? !1, target.allowExec = userApiPermissions.allowExec ?? !1);
+      }
+      telemetry2(
+        "test-run",
+        {
+          runner: "vitest",
+          watch: context.vitest.config.watch,
+          coverage: !!context.vitest.config.coverage?.enabled
+        },
+        { configDir: finalOptions.configDir }
+      ), isTelemetryModuleEnabled() && agent && withinAgenticSetupSession && !process.env.FORKBOOK_INTERNAL_TEST_RUN && context.vitest.config.reporters.push(
+        new AgentTelemetryReporter({
+          configDir: finalOptions.configDir,
+          agent
+        })
+      );
+    },
+    async configureServer(server) {
+      if (staticDirs)
+        for (let staticDir of staticDirs)
+          try {
+            let { staticPath, targetEndpoint } = mapStaticDir(staticDir, directories.configDir);
+            server.middlewares.use(
+              targetEndpoint,
+              (0, import_sirv.default)(staticPath, {
+                dev: !0,
+                etag: !0,
+                extensions: []
+              })
+            );
+          } catch (e) {
+            console.warn(e);
+          }
+    },
+    async transform(code, id) {
+      let relativeId = relative(finalOptions.vitestRoot, id);
+      if ((0, import_micromatch.match)([relativeId], finalOptions.includeStories).length > 0)
+        return vitestTransform({
+          code,
+          fileName: id,
+          configDir: finalOptions.configDir,
+          tagsFilter: finalOptions.tags,
+          stories: storiesGlobs,
+          previewLevelTags
+        });
+    }
+  };
+  if (getComponentTestPaths().length > 0 && plugins.push(createComponentTestTransformPlugin(presets, finalOptions.configDir)), plugins.push(storybookTestPlugin), isVitestStorybook) {
+    let projectName = `storybook:${normalize(finalOptions.configDir)}`;
+    plugins.push({
+      name: "storybook:workspace-name-override",
+      config: {
+        order: "pre",
+        handler: () => ({
+          test: {
+            name: projectName
+          }
+        })
+      }
+    });
+  }
+  return plugins;
+}, vitest_plugin_default = storybookTest;
+export {
+  vitest_plugin_default as default,
+  storybookTest
+};