@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/addon-vitest/node/vitest.js

@@ -0,0 +1,674 @@
+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 {
+  errorToErrorLike,
+  log
+} from "../../_node-chunks/chunk-VLOXOXXE.js";
+import {
+  ADDON_ID2 as ADDON_ID,
+  COVERAGE_DIRECTORY,
+  FORKBOOK_TEST_PROVIDE_KEY,
+  STATUS_TYPE_ID_A11Y,
+  STATUS_TYPE_ID_COMPONENT_TEST,
+  STORY_INDEX_CHANNEL_EVENT_NAME,
+  storeOptions
+} from "../../_node-chunks/chunk-H32DYT6P.js";
+import {
+  throttle
+} from "../../_node-chunks/chunk-YCMRA6RX.js";
+import {
+  escapeRegExp
+} from "../../_node-chunks/chunk-EWOX7HPJ.js";
+import "../../_node-chunks/chunk-HMP2G23X.js";
+import "../../_node-chunks/chunk-OUW6R7C3.js";
+import {
+  any,
+  up
+} from "../../_node-chunks/chunk-JDXXX6LB.js";
+import "../../_node-chunks/chunk-2BUPBPFB.js";
+import {
+  slash
+} from "../../_node-chunks/chunk-DC7DKR5K.js";
+import "../../_node-chunks/chunk-CXRU72ET.js";
+
+// src/addon-vitest/node/vitest.ts
+import process2 from "node:process";
+import { Channel } from "@aussieljk/forkbook/internal/channels";
+import {
+  internal_UniversalStore,
+  experimental_getStatusStore,
+  experimental_getTestProviderStore
+} from "@aussieljk/forkbook/internal/core-server";
+
+// src/addon-vitest/node/vitest-manager.ts
+import { existsSync, readFileSync } from "node:fs";
+import { getProjectRoot, resolvePathInStorybookCache } from "@aussieljk/forkbook/internal/common";
+import { Tag } from "@aussieljk/forkbook/internal/core-server";
+import path, { dirname, join, normalize, resolve } from "pathe";
+
+// src/addon-vitest/node/reporter.ts
+var StorybookReporter = class {
+  constructor(testManager2) {
+    this.testManager = testManager2;
+  }
+  onInit(ctx) {
+    this.ctx = ctx;
+  }
+  onTestCaseResult(testCase) {
+    let { storyId, reports } = testCase.meta(), testResult = testCase.result();
+    this.testManager.onTestCaseResult({
+      storyId,
+      testResult,
+      reports
+    });
+  }
+  async onTestRunEnd(testModules, unhandledErrors) {
+    let totalTestCount = testModules.flatMap(
+      (t) => Array.from(t.children.allTests("passed")).concat(Array.from(t.children.allTests("failed")))
+    ).length, testModulesErrors = testModules.flatMap((t) => t.errors()), serializedErrors = unhandledErrors.concat(testModulesErrors).map((e) => ({
+      ...e,
+      name: e.name,
+      message: e.message,
+      stack: e.stack?.replace(e.message, ""),
+      cause: e.cause
+    }));
+    this.testManager.onTestRunEnd({
+      totalTestCount,
+      unhandledErrors: serializedErrors
+    }), this.clearVitestState();
+  }
+  // TODO: Clearing the whole internal state of Vitest might be too aggressive
+  async clearVitestState() {
+    this.ctx.state.filesMap.clear(), this.ctx.state.pathsSet.clear(), this.ctx.state.idMap.clear(), this.ctx.state.errorsSet.clear(), this.ctx.state.processTimeoutCauses?.clear();
+  }
+};
+
+// src/addon-vitest/node/vitest-manager.ts
+var VITEST_CONFIG_FILE_EXTENSIONS = ["mts", "mjs", "cts", "cjs", "ts", "tsx", "js", "jsx"];
+process.env.VITEST_STORYBOOK = "true";
+var DOUBLE_SPACES = "  ", getTestName = (name) => `${name}${DOUBLE_SPACES}`, VitestManager = class {
+  constructor(testManager2) {
+    this.testManager = testManager2;
+    this.vitest = null;
+    this.testNameSeparator = " ";
+    this.vitestStartupCounter = 0;
+    this.vitestRestartPromise = null;
+    this.runningPromise = null;
+  }
+  async startVitest({ coverage }) {
+    let { createVitest, version } = await import("vitest/node");
+    this.testNameSeparator = Number.parseInt(version, 10) >= 5 ? " > " : " ";
+    let storybookCoverageReporter = [
+      "@aussieljk/forkbook/addon-vitest/internal/coverage-reporter",
+      {
+        testManager: this.testManager
+      }
+    ], coverageOptions = coverage ? {
+      enabled: !0,
+      clean: !0,
+      cleanOnRerun: !0,
+      reportOnFailure: !0,
+      reporter: [["html", {}], storybookCoverageReporter],
+      reportsDirectory: resolvePathInStorybookCache(COVERAGE_DIRECTORY)
+    } : { enabled: !1 }, configDir = this.testManager.storybookOptions.configDir, packageRoot = configDir ? dirname(resolve(configDir)) : void 0, configFiles = [
+      ...VITEST_CONFIG_FILE_EXTENSIONS.flatMap((ext) => [
+        `vitest.config.${ext}`,
+        `vite.config.${ext}`
+      ])
+    ], potentialConfigFileLocations = up(packageRoot || process.cwd(), {
+      last: getProjectRoot()
+    }), vitestConfigLocation, firstVitestConfig;
+    for (let location of potentialConfigFileLocations) {
+      for (let file of configFiles) {
+        let maybe = any([file], {
+          cwd: location,
+          last: getProjectRoot()
+        });
+        if (maybe && existsSync(maybe)) {
+          firstVitestConfig ??= dirname(maybe);
+          let content = readFileSync(maybe, "utf8");
+          if (content.includes("storybookTest") || content.includes("@aussieljk/forkbook/addon-vitest")) {
+            vitestConfigLocation = dirname(maybe);
+            break;
+          }
+        }
+      }
+      if (vitestConfigLocation)
+        break;
+    }
+    let projectName = "storybook:" + process.env.FORKBOOK_CONFIG_DIR, vitestConfigFallbackLocation = firstVitestConfig || packageRoot || process.cwd();
+    try {
+      this.vitest = await createVitest("test", {
+        root: vitestConfigLocation ?? vitestConfigFallbackLocation,
+        configLoader: this.testManager.configLoader,
+        watch: !0,
+        passWithNoTests: !1,
+        project: [projectName],
+        // TODO:
+        // Do we want to enable Vite's default reporter?
+        // The output in the terminal might be too spamy and it might be better to
+        // find a way to just show errors and warnings for example
+        // Otherwise it might be hard for the user to discover Forkbook related logs
+        reporters: ["default", new StorybookReporter(this.testManager)],
+        coverage: coverageOptions
+      });
+    } catch (err) {
+      let originalMessage = String(err.message);
+      if (originalMessage.includes("Found multiple projects")) {
+        let custom = [
+          "Forkbook was unable to start the test run because you have multiple Vitest projects (or browsers) in headed mode.",
+          "Please set `headless: true` in your Forkbook vitest config.\n\n"
+        ].join(`
+`);
+        originalMessage.startsWith(custom) || (err.message = `${custom}${originalMessage}`);
+      }
+      throw err;
+    }
+    this.vitest && this.vitest.onCancel(() => {
+    });
+    try {
+      typeof this.vitest.standalone == "function" ? await this.vitest.standalone() : await this.vitest.init();
+    } catch (e) {
+      let message = "Failed to initialize Vitest", isV8 = e.message?.includes("@vitest/coverage-v8"), isIstanbul = e.message?.includes("@vitest/coverage-istanbul");
+      (e.message?.includes("Failed to load url") && (isIstanbul || isV8) || // Vitest will sometimes not throw the correct missing-package-detection error, so we have to check for this as well
+      e instanceof TypeError && e?.message === "Cannot read properties of undefined (reading 'name')") && (message += `
+
+Please install the @vitest/${isIstanbul ? "coverage-istanbul" : "coverage-v8"} package to collect coverage
+`), this.testManager.reportFatalError(message, e);
+      return;
+    }
+    await this.setupWatchers();
+  }
+  async restartVitest({ coverage }) {
+    return await this.vitestRestartPromise, this.vitestRestartPromise = new Promise(async (resolve2, reject) => {
+      try {
+        await this.runningPromise, await this.vitest?.close(), this.vitest = null, await this.startVitest({ coverage }), resolve2();
+      } catch (e) {
+        reject(e);
+      } finally {
+        this.vitestRestartPromise = null;
+      }
+    }), this.vitestRestartPromise;
+  }
+  resetGlobalTestNamePattern() {
+    this.vitest?.setGlobalTestNamePattern("");
+  }
+  updateLastChanged(filepath) {
+    this.vitest.projects.forEach(({ browser, vite }) => {
+      vite && vite.moduleGraph.getModulesByFile(filepath)?.forEach((mod) => vite.moduleGraph.invalidateModule(mod)), browser && browser.vite.moduleGraph.getModulesByFile(filepath)?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
+    });
+  }
+  getStories(requestStoryIds) {
+    let index = this.testManager.storyIndex;
+    if (requestStoryIds) {
+      let stories = [];
+      for (let id of requestStoryIds) {
+        let entry = index.entries[id];
+        entry?.type === "story" && stories.push(entry);
+      }
+      return stories;
+    }
+    return Object.values(index.entries).filter((entry) => entry.type === "story");
+  }
+  /**
+   * Builds the exact Vitest name-pattern fragment for one selected Forkbook entry.
+   *
+   * The pattern differs by entry type:
+   *
+   * - Component entry (has child stories/tests): match the whole describe block prefix
+   * - Story-test entry (has parent): match "parent describe + test name" exactly
+   * - Regular story entry: match the story name exactly
+   */
+  buildStoryTestNamePattern(story, allStories, storiesById) {
+    if (allStories.some((candidate) => story.id === candidate.parent))
+      return `^${escapeRegExp(getTestName(story.name))}`;
+    if (story.parent) {
+      let parentStory = storiesById[story.parent];
+      if (!parentStory)
+        throw new Error(`Parent story not found for story ${story.id}`);
+      return `^${escapeRegExp(getTestName(parentStory.name))}${this.testNameSeparator}${escapeRegExp(story.name)}$`;
+    }
+    return `^${escapeRegExp(story.name)}$`;
+  }
+  /**
+   * Combines multiple per-story patterns into one global regex so Vitest can run an exact subset of
+   * tests across one or more files in a single invocation.
+   */
+  buildTestNamePatternForStories(selectedStories, allStories) {
+    let storiesById = Object.fromEntries(allStories.map((story) => [story.id, story])), storyPatterns = [
+      ...new Set(
+        selectedStories.map(
+          (story) => this.buildStoryTestNamePattern(story, allStories, storiesById)
+        )
+      )
+    ];
+    if (storyPatterns.length)
+      return storyPatterns.length === 1 ? new RegExp(storyPatterns[0]) : new RegExp(`(?:${storyPatterns.map((pattern) => `(?:${pattern})`).join("|")})`);
+  }
+  filterTestSpecifications(testSpecifications, stories) {
+    let filteredTestSpecifications = [], filteredStoryIds = [], storiesByImportPath = {};
+    for (let story of stories) {
+      let absoluteImportPath = path.join(process.cwd(), story.importPath);
+      storiesByImportPath[absoluteImportPath] || (storiesByImportPath[absoluteImportPath] = []), storiesByImportPath[absoluteImportPath].push(story);
+    }
+    for (let testSpecification of testSpecifications) {
+      let { env = {} } = testSpecification.project.config, include = env.__VITEST_INCLUDE_TAGS__?.split(",").filter(Boolean) ?? [Tag.TEST], exclude = env.__VITEST_EXCLUDE_TAGS__?.split(",").filter(Boolean) ?? [], skip = env.__VITEST_SKIP_TAGS__?.split(",").filter(Boolean) ?? [], filteredStories = (storiesByImportPath[testSpecification.moduleId] ?? []).filter((story) => !(include.length && !include.some((tag) => story.tags?.includes(tag)) || exclude.some((tag) => story.tags?.includes(tag))));
+      filteredStories.length && (this.testManager.store.getState().watching || this.updateLastChanged(testSpecification.moduleId), filteredTestSpecifications.push(testSpecification), filteredStoryIds.push(
+        ...filteredStories.filter((story) => !skip.some((tag) => story.tags?.includes(tag))).map((story) => story.id)
+      ));
+    }
+    return { filteredTestSpecifications, filteredStoryIds };
+  }
+  getCurrentRunConfig() {
+    return this.testManager.store.getState().currentRun.config;
+  }
+  provideRunConfig() {
+    this.vitest?.provide(FORKBOOK_TEST_PROVIDE_KEY, this.getCurrentRunConfig());
+  }
+  async runTests(runPayload) {
+    let { watching } = this.testManager.store.getState(), coverageShouldBeEnabled = !!this.getCurrentRunConfig().coverage && !watching && (runPayload?.storyIds?.length ?? 0) === 0, currentCoverage = this.vitest?.config.coverage?.enabled;
+    this.vitest ? currentCoverage !== coverageShouldBeEnabled ? await this.restartVitest({ coverage: coverageShouldBeEnabled }) : await this.vitestRestartPromise : await this.startVitest({ coverage: coverageShouldBeEnabled }), this.provideRunConfig(), this.resetGlobalTestNamePattern(), await this.cancelCurrentRun();
+    let testSpecifications = await this.getStorybookTestSpecifications(), allStories = this.getStories(), filteredStories = runPayload.storyIds ? allStories.filter((story) => runPayload.storyIds?.includes(story.id)) : allStories;
+    if (runPayload.storyIds?.length) {
+      let regex = this.buildTestNamePatternForStories(filteredStories, allStories);
+      regex && this.vitest.setGlobalTestNamePattern(regex);
+    }
+    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+      testSpecifications,
+      filteredStories
+    );
+    this.testManager.store.setState((s) => ({
+      ...s,
+      currentRun: {
+        ...s.currentRun,
+        totalTestCount: filteredStoryIds.length
+      }
+    })), await this.vitest.runTestSpecifications(filteredTestSpecifications, !0), this.resetGlobalTestNamePattern();
+  }
+  async cancelCurrentRun() {
+    await this.vitest?.cancelCurrentRun("keyboard-input"), await this.runningPromise;
+  }
+  async getStorybookTestSpecifications() {
+    return (await this.vitest?.globTestSpecifications() ?? []).filter(
+      (workspaceSpec) => this.isStorybookProject(workspaceSpec.project)
+    ) ?? [];
+  }
+  async runAffectedTestsAfterChange(changedFilePath, event) {
+    let id = slash(changedFilePath);
+    if (this.vitest?.logger.clearHighlightCache(id), this.updateLastChanged(id), event === "add" && this.vitest?.projects.find(this.isStorybookProject.bind(this))?.matchesTestGlob(id), !this.testManager.store.getState().watching || !this.vitest)
+      return;
+    this.resetGlobalTestNamePattern();
+    let storybookProject = this.vitest.projects.find((p) => this.isStorybookProject(p)), previewAnnotationSpecifications = this.testManager.previewAnnotations.map(
+      (previewAnnotation) => ({
+        project: storybookProject ?? this.vitest.projects[0],
+        moduleId: typeof previewAnnotation == "string" ? previewAnnotation : previewAnnotation.absolute
+      })
+    ), setupFilesSpecifications = this.vitest.projects.flatMap(
+      (project) => project.config.setupFiles.map((setupFile) => ({
+        project,
+        moduleId: setupFile
+      }))
+    ), syntheticGlobalTestSpecifications = previewAnnotationSpecifications.concat(setupFilesSpecifications), testSpecifications = await this.getStorybookTestSpecifications(), allStories = this.getStories(), affectsGlobalFiles = !1, affectedTestSpecifications = (await Promise.all(
+      syntheticGlobalTestSpecifications.concat(testSpecifications).map(async (testSpecification) => {
+        let dependencies = await this.getTestDependencies(testSpecification);
+        if (changedFilePath === testSpecification.moduleId || dependencies.has(changedFilePath))
+          return syntheticGlobalTestSpecifications.includes(testSpecification) && (affectsGlobalFiles = !0), testSpecification;
+      })
+    )).filter(Boolean), testSpecificationsToRun = affectsGlobalFiles ? testSpecifications : affectedTestSpecifications;
+    if (!testSpecificationsToRun.length)
+      return;
+    let { filteredTestSpecifications, filteredStoryIds } = this.filterTestSpecifications(
+      testSpecificationsToRun,
+      allStories
+    );
+    await this.testManager.runTestsWithState({
+      storyIds: filteredStoryIds,
+      triggeredBy: "watch",
+      callback: async () => {
+        this.testManager.store.setState((s) => ({
+          ...s,
+          currentRun: {
+            ...s.currentRun,
+            totalTestCount: filteredStoryIds.length
+          }
+        })), await this.vitest.cancelCurrentRun("keyboard-input"), await this.runningPromise, this.provideRunConfig(), await this.vitest.runTestSpecifications(filteredTestSpecifications, !1);
+      }
+    });
+  }
+  // This is an adaptation of Vitest's own implementation
+  // see https://github.com/vitest-dev/vitest/blob/14409088166152c920ce7fa4ad4c0ba57149b869/packages/vitest/src/node/specifications.ts#L171-L198
+  async getTestDependencies(spec) {
+    let deps = /* @__PURE__ */ new Set(), addImports = async (project, filepath) => {
+      if (deps.has(filepath))
+        return;
+      deps.add(filepath);
+      let transformed = project.vite.moduleGraph.getModuleById(filepath)?.ssrTransformResult || await project.vite.transformRequest(filepath, { ssr: !0 });
+      if (!transformed)
+        return;
+      let dependencies = [...transformed.deps ?? [], ...transformed.dynamicDeps ?? []];
+      await Promise.all(
+        dependencies.map(async (dep) => {
+          let fsPath = dep.startsWith("/@fs/") ? dep.slice(process.platform === "win32" ? 5 : 4) : join(project.config.root, dep);
+          !fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath) && await addImports(project, fsPath);
+        })
+      );
+    };
+    return await addImports(spec.project, spec.moduleId), deps.delete(spec.moduleId), deps;
+  }
+  async registerVitestConfigListener() {
+    this.vitest.vite.watcher.on("change", async (file) => {
+      if (normalize(file) === this.vitest?.vite?.config.configFile) {
+        log("Restarting Vitest due to config change");
+        let { watching, config } = this.testManager.store.getState();
+        await this.restartVitest({ coverage: config.coverage && !watching });
+      }
+    });
+  }
+  async setupWatchers() {
+    this.resetGlobalTestNamePattern(), this.vitest.vite.watcher.removeAllListeners("change"), this.vitest.vite.watcher.removeAllListeners("add"), this.vitest.vite.watcher.on(
+      "change",
+      (file) => this.runAffectedTestsAfterChange(file, "change")
+    ), this.vitest.vite.watcher.on("add", (file) => {
+      this.runAffectedTestsAfterChange(file, "add");
+    }), this.registerVitestConfigListener();
+  }
+  isStorybookProject(project) {
+    return !!project.config.env?.__STORYBOOK_URL__;
+  }
+};
+
+// src/addon-vitest/node/test-manager.ts
+var DEBUG_BANNER_RE = /\n?(?:\x1B\[\d+m)?Click to debug the error directly in Forkbook: [^\n]*\n+/g;
+function formatError(error) {
+  if (!error.stacks?.length)
+    return error.stack || error.message || "";
+  let message = (error.message ?? "").replace(DEBUG_BANNER_RE, ""), frames = error.stacks.map(
+    ({ method, file, line, column }) => `    at ${method || "<anonymous>"} (${file}:${line}:${column})`
+  );
+  return [message, ...frames].join(`
+`);
+}
+var testStateToStatusValueMap = {
+  pending: "status-value:pending",
+  passed: "status-value:success",
+  warning: "status-value:warning",
+  failed: "status-value:error",
+  skipped: "status-value:unknown"
+}, TestManager = class _TestManager {
+  constructor(options) {
+    this.storyIndex = { v: 5, entries: {} };
+    this.batchedTestCaseResults = [];
+    this.runComponentTestStatuses = [];
+    this.runA11yStatuses = [];
+    this.runReports = {};
+    this.runA11yReports = {};
+    /**
+     * Throttled function to process batched test case results.
+     *
+     * This function:
+     *
+     * 1. Takes all batched test case results and clears the batch
+     * 2. Updates the status stores with the just-processed batch
+     * 3. Accumulates full-run statuses and reports locally so the per-flush store payload stays bounded
+     * 4. Updates the synced store with counts only
+     *
+     * The throttling (500ms) still batches channel traffic. Full-run arrays stay off the synced store
+     * until run end, so a late flush cannot re-serialize the whole run.
+     */
+    this.throttledFlushTestCaseResults = throttle(() => {
+      let testCaseResultsToFlush = this.batchedTestCaseResults;
+      this.batchedTestCaseResults = [];
+      let componentTestStatuses = testCaseResultsToFlush.map(({ storyId, testResult }) => ({
+        storyId,
+        typeId: STATUS_TYPE_ID_COMPONENT_TEST,
+        value: testStateToStatusValueMap[testResult.state],
+        title: "Component tests",
+        description: testResult.errors?.map(formatError).join(`
+`) ?? "",
+        sidebarContextMenu: !1
+      }));
+      this.componentTestStatusStore.set(componentTestStatuses);
+      let a11yReportsByStoryId = {}, reportsByStoryId = {}, a11yStatuses = [];
+      for (let { storyId, reports } of testCaseResultsToFlush) {
+        reports?.length && (reportsByStoryId[storyId] = reports);
+        let storyA11yReports = reports?.filter((r) => r.type === "a11y");
+        if (storyA11yReports?.length) {
+          a11yReportsByStoryId[storyId] = storyA11yReports.map((report) => report.result);
+          for (let a11yReport of storyA11yReports)
+            a11yStatuses.push({
+              storyId,
+              typeId: STATUS_TYPE_ID_A11Y,
+              value: testStateToStatusValueMap[a11yReport.status],
+              title: "Accessibility tests",
+              description: "",
+              sidebarContextMenu: !1
+            });
+        }
+      }
+      a11yStatuses.length > 0 && this.a11yStatusStore.set(a11yStatuses), componentTestStatuses.length > 0 && this.runComponentTestStatuses.push(...componentTestStatuses), a11yStatuses.length > 0 && this.runA11yStatuses.push(...a11yStatuses), Object.assign(this.runReports, reportsByStoryId), Object.assign(this.runA11yReports, a11yReportsByStoryId), this.store.setState((s) => {
+        let { success: ctSuccess, error: ctError } = s.currentRun.componentTestCount, { success: a11ySuccess, warning: a11yWarning, error: a11yError } = s.currentRun.a11yCount;
+        testCaseResultsToFlush.forEach(({ testResult, reports }) => {
+          testResult.state === "passed" ? ctSuccess++ : testResult.state === "failed" && ctError++, reports?.filter((r) => r.type === "a11y").forEach((report) => {
+            report.status === "passed" ? a11ySuccess++ : report.status === "warning" ? a11yWarning++ : report.status === "failed" && a11yError++;
+          });
+        });
+        let finishedTestCount = ctSuccess + ctError;
+        return {
+          ...s,
+          currentRun: {
+            ...s.currentRun,
+            componentTestCount: { success: ctSuccess, error: ctError },
+            a11yCount: {
+              success: a11ySuccess,
+              warning: a11yWarning,
+              error: a11yError
+            },
+            totalTestCount: finishedTestCount > (s.currentRun.totalTestCount ?? 0) ? finishedTestCount : s.currentRun.totalTestCount
+          }
+        };
+      });
+    }, 500);
+    this.store = options.store, this.componentTestStatusStore = options.componentTestStatusStore, this.a11yStatusStore = options.a11yStatusStore, this.testProviderStore = options.testProviderStore, this.onReady = options.onReady, this.storybookOptions = options.storybookOptions, this.configLoader = options.configLoader, this.previewAnnotations = options.previewAnnotations, this.vitestManager = new VitestManager(this), this.store.subscribe("TRIGGER_RUN", this.handleTriggerRunEvent.bind(this)), this.store.subscribe("CANCEL_RUN", this.handleCancelEvent.bind(this)), this.store.untilReady().then(() => this.vitestManager.startVitest({
+      coverage: this.store.getState().config.coverage
+    })).then(() => this.onReady?.()).catch((e) => {
+      this.reportFatalError("Failed to start Vitest", e);
+    });
+  }
+  async handleTriggerRunEvent(event) {
+    await this.runTestsWithState({
+      storyIds: event.payload.storyIds,
+      triggeredBy: event.payload.triggeredBy,
+      configOverride: event.payload.configOverride,
+      callback: async () => {
+        try {
+          await this.vitestManager.vitestRestartPromise, await this.vitestManager.runTests(event.payload);
+        } catch (err) {
+          throw this.reportFatalError("Failed to run tests", err), err;
+        }
+      }
+    });
+  }
+  async handleCancelEvent() {
+    try {
+      this.store.setState((s) => ({
+        ...s,
+        cancelling: !0
+      })), await this.vitestManager.cancelCurrentRun();
+    } catch (err) {
+      this.reportFatalError("Failed to cancel tests", err);
+    } finally {
+      this.store.setState((s) => ({
+        ...s,
+        cancelling: !1
+      }));
+    }
+  }
+  async runTestsWithState({
+    storyIds,
+    triggeredBy,
+    configOverride,
+    callback
+  }) {
+    this.componentTestStatusStore.unset(storyIds), this.a11yStatusStore.unset(storyIds), this.runComponentTestStatuses = [], this.runA11yStatuses = [], this.runReports = {}, this.runA11yReports = {};
+    let runConfig = configOverride ?? this.store.getState().config;
+    this.store.setState((s) => ({
+      ...s,
+      currentRun: {
+        ...storeOptions.initialState.currentRun,
+        triggeredBy,
+        startedAt: Date.now(),
+        storyIds,
+        config: runConfig
+      }
+    })), await this.testProviderStore.runWithState(async () => {
+      if (await callback(), this.store.send({
+        type: "TEST_RUN_COMPLETED",
+        payload: {
+          ...this.store.getState().currentRun,
+          componentTestStatuses: this.runComponentTestStatuses,
+          a11yStatuses: this.runA11yStatuses,
+          a11yReports: this.runA11yReports,
+          reports: this.runReports
+        }
+      }), this.store.getState().currentRun.unhandledErrors.length > 0)
+        throw new Error("Tests completed but there are unhandled errors");
+    });
+  }
+  onTestModuleCollected(collectedTestCount) {
+    this.store.setState((s) => ({
+      ...s,
+      currentRun: {
+        ...s.currentRun,
+        totalTestCount: (s.currentRun.totalTestCount ?? 0) + collectedTestCount
+      }
+    }));
+  }
+  onTestCaseResult(result) {
+    let { storyId, testResult, reports } = result;
+    if (!storyId)
+      return;
+    let requestedStoryIds = this.store.getState().currentRun.storyIds;
+    requestedStoryIds && !this.isRequestedStoryOrChild(storyId, requestedStoryIds) || (this.batchedTestCaseResults.push({ storyId, testResult, reports }), this.throttledFlushTestCaseResults());
+  }
+  isRequestedStoryOrChild(storyId, requestedStoryIds) {
+    if (requestedStoryIds.includes(storyId))
+      return !0;
+    let entry = this.storyIndex.entries[storyId];
+    return entry?.type === "story" && !!entry.parent && requestedStoryIds.includes(entry.parent);
+  }
+  onTestRunEnd(endResult) {
+    this.throttledFlushTestCaseResults.flush(), this.store.setState((s) => {
+      let focusedRunTotal = s.currentRun.componentTestCount.success + s.currentRun.componentTestCount.error;
+      return {
+        ...s,
+        currentRun: {
+          ...s.currentRun,
+          // For focused runs, keep totals aligned with filtered case results.
+          // For full runs, use Vitest's reported total.
+          totalTestCount: s.currentRun.storyIds ? focusedRunTotal : endResult.totalTestCount,
+          unhandledErrors: endResult.unhandledErrors,
+          finishedAt: Date.now()
+        }
+      };
+    });
+  }
+  onCoverageCollected(coverageSummary) {
+    this.store.setState((s) => ({
+      ...s,
+      currentRun: { ...s.currentRun, coverageSummary }
+    }));
+  }
+  async reportFatalError(message, error) {
+    await this.store.untilReady(), this.store.send({
+      type: "FATAL_ERROR",
+      payload: {
+        message,
+        error: errorToErrorLike(error)
+      }
+    });
+  }
+  static async start(options) {
+    return new Promise((resolve2) => {
+      let testManager2 = new _TestManager({
+        ...options,
+        onReady: () => {
+          resolve2(testManager2), options.onReady?.();
+        }
+      });
+    });
+  }
+};
+
+// src/addon-vitest/node/vitest.ts
+var UniversalStore = internal_UniversalStore, getStatusStore = experimental_getStatusStore, getTestProviderStore = experimental_getTestProviderStore, channel = new Channel({
+  async: !0,
+  transport: {
+    send: (event) => {
+      process2.send?.(event);
+    },
+    setHandler: (handler) => {
+      process2.on("message", handler);
+    }
+  }
+});
+UniversalStore.__prepare(channel, UniversalStore.Environment.SERVER);
+var store = UniversalStore.create(storeOptions), testManager = new TestManager({
+  store,
+  componentTestStatusStore: getStatusStore(STATUS_TYPE_ID_COMPONENT_TEST),
+  a11yStatusStore: getStatusStore(STATUS_TYPE_ID_A11Y),
+  testProviderStore: getTestProviderStore(ADDON_ID),
+  onReady: () => {
+    process2.send?.({ type: "ready" });
+  },
+  storybookOptions: {
+    configDir: process2.env.FORKBOOK_CONFIG_DIR || ""
+  },
+  configLoader: process2.env.FORKBOOK_CONFIG_LOADER,
+  previewAnnotations: JSON.parse(
+    process2.env.FORKBOOK_PREVIEW_ANNOTATIONS || "[]"
+  )
+});
+channel.on(STORY_INDEX_CHANNEL_EVENT_NAME, (index) => {
+  testManager.storyIndex = index;
+});
+var exit = (code = 0) => {
+  channel?.removeAllListeners(), process2.exit(code);
+}, createUnhandledErrorHandler = (message) => async (error) => {
+  try {
+    let payload = {
+      message,
+      error: {
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+        cause: error.cause
+      }
+    };
+    process2.send?.({
+      type: "uncaught-error",
+      payload
+    });
+  } finally {
+    exit(1);
+  }
+};
+process2.on(
+  "uncaughtException",
+  createUnhandledErrorHandler("Uncaught exception in the test runner process")
+);
+process2.on(
+  "unhandledRejection",
+  createUnhandledErrorHandler("Unhandled rejection in the test runner process")
+);
+process2.on("exit", exit);
+process2.on("SIGINT", () => exit(0));
+process2.on("SIGTERM", () => exit(0));