@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/addon-vitest/preset.js

@@ -0,0 +1,943 @@
+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_ADDON_TEST_CHANNEL,
+  STATUS_STORE_CHANNEL_EVENT_NAME,
+  STORE_CHANNEL_EVENT_NAME,
+  STORY_INDEX_CHANNEL_EVENT_NAME,
+  TEST_PROVIDER_STORE_CHANNEL_EVENT_NAME,
+  TRIGGER_TEST_RUN_REQUEST,
+  TRIGGER_TEST_RUN_RESPONSE,
+  storeOptions
+} from "../_node-chunks/chunk-H32DYT6P.js";
+import {
+  isEqual
+} from "../_node-chunks/chunk-OWNFOGTA.js";
+import "../_node-chunks/chunk-HMP2G23X.js";
+import {
+  importMetaResolve
+} from "../_node-chunks/chunk-F3ZFKBHY.js";
+import "../_node-chunks/chunk-TNJIXE37.js";
+import "../_node-chunks/chunk-2BUPBPFB.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/addon-vitest/preset.ts
+import { mkdir } from "node:fs/promises";
+import { resolvePathInStorybookCache as resolvePathInStorybookCache2 } from "@aussieljk/forkbook/internal/common";
+import {
+  registerToolset
+} from "@aussieljk/forkbook/internal/core-server";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  cleanPaths,
+  oneWayHash,
+  sanitizeError,
+  telemetry
+} from "@aussieljk/forkbook/internal/telemetry";
+
+// src/addon-vitest/node/boot-test-runner.ts
+import { fileURLToPath } from "node:url";
+import { executeNodeCommand, loadPreviewOrConfigFile } from "@aussieljk/forkbook/internal/common";
+import {
+  internal_universalStatusStore,
+  internal_universalTestProviderStore
+} from "@aussieljk/forkbook/internal/core-server";
+import { normalize } from "pathe";
+var MAX_START_TIME = 3e4, vitestModulePath = fileURLToPath(
+  importMetaResolve("@aussieljk/forkbook/addon-vitest/vitest")
+), eventQueue = [], child, ready = !1, unsubscribeBridges = [], processExitHandled = !1, storesKillingOnFatalError = /* @__PURE__ */ new WeakSet(), generation = 0, booting, killChild = () => {
+  for (let unsubscribe of unsubscribeBridges)
+    unsubscribe();
+  unsubscribeBridges = [], child?.kill(), child = null, ready = !1, eventQueue.length = 0, generation++;
+}, forwardUniversalStoreEvent = (storeEventName) => (event, eventInfo) => {
+  !ready && event.type === "TRIGGER_RUN" || child?.send({
+    type: storeEventName,
+    args: [{ event, eventInfo }],
+    from: "server"
+  });
+}, bootTestRunner = async ({
+  channel,
+  store,
+  options,
+  configLoader
+}) => {
+  let universalStoreBridges = [
+    {
+      eventName: STORE_CHANNEL_EVENT_NAME,
+      subscribe: (listener) => store.subscribe(listener)
+    },
+    {
+      eventName: STATUS_STORE_CHANNEL_EVENT_NAME,
+      subscribe: (listener) => internal_universalStatusStore.subscribe(listener)
+    },
+    {
+      eventName: TEST_PROVIDER_STORE_CHANNEL_EVENT_NAME,
+      subscribe: (listener) => internal_universalTestProviderStore.subscribe(listener)
+    }
+  ], bridgedEventNames = new Set(universalStoreBridges.map((bridge) => bridge.eventName)), stderr = [];
+  if (storesKillingOnFatalError.has(store) || (storesKillingOnFatalError.add(store), store.subscribe("FATAL_ERROR", () => {
+    let childWasReady = ready;
+    killChild(), closeOpenRun(store), childWasReady && store.getState().watching && runTestRunner({ channel, store, options, configLoader }).then(
+      () => store.setState((s) => ({ ...s, fatalError: void 0 })),
+      () => {
+      }
+    );
+  })), !processExitHandled) {
+    processExitHandled = !0;
+    let exit = (code = 0) => {
+      killChild(), process.exit(code);
+    };
+    process.on("exit", exit), process.on("SIGINT", () => exit(0)), process.on("SIGTERM", () => exit(0));
+  }
+  let bootGeneration = generation, crashAlreadyReported = new Error("The test runner process crashed"), startChildProcess = async () => {
+    let storyIndexGenerator = await options.presets.apply("storyIndexGenerator"), previewAnnotations = await getPreviewAnnotations(options);
+    if (bootGeneration !== generation)
+      throw crashAlreadyReported;
+    await new Promise((resolve, reject) => {
+      child = executeNodeCommand({
+        scriptPath: vitestModulePath,
+        options: {
+          env: {
+            VITEST: "true",
+            TEST: "true",
+            VITEST_CHILD_PROCESS: "true",
+            NODE_ENV: process.env.NODE_ENV ?? "test",
+            FORKBOOK_CONFIG_DIR: normalize(options.configDir),
+            FORKBOOK_CONFIG_LOADER: configLoader,
+            FORKBOOK_PREVIEW_ANNOTATIONS: JSON.stringify(previewAnnotations)
+          },
+          extendEnv: !0
+        }
+      }), sentStoryIndex = void 0, stderr = [];
+      let spawnedChild = child;
+      spawnedChild.on("exit", (code, signal) => {
+        child === spawnedChild && store.send({
+          type: "FATAL_ERROR",
+          payload: {
+            message: "The test runner process exited unexpectedly",
+            error: { message: signal ? `Killed by ${signal}` : `Exited with code ${code}` }
+          }
+        }), reject(crashAlreadyReported);
+      }), child.stdout?.on("data", log), child.stderr?.on("data", (data) => {
+        data.toString().match(/^\u001B\[33m/) || (log(data), stderr.push(data.toString()));
+      }), unsubscribeBridges = universalStoreBridges.map(
+        (bridge) => bridge.subscribe(forwardUniversalStoreEvent(bridge.eventName))
+      ), child.on("message", (event) => {
+        child === spawnedChild && (event.type === "ready" ? refreshStoryIndex(storyIndexGenerator).then(() => {
+          if (child === spawnedChild) {
+            for (ready = !0, sendStoryIndex(); eventQueue.length; ) {
+              let { type, args } = eventQueue.shift();
+              child?.send({ type, args, from: "server" });
+            }
+            resolve();
+          }
+        }, reject) : event.type === "uncaught-error" ? (store.send({
+          type: "FATAL_ERROR",
+          payload: event.payload
+        }), reject(crashAlreadyReported)) : bridgedEventNames.has(event.type) ? channel.receive(event) : channel.emit(event.type, ...event.args));
+      });
+    });
+  }, timeout = new Promise(
+    (_, reject) => setTimeout(
+      reject,
+      MAX_START_TIME,
+      // eslint-disable-next-line local-rules/no-uncategorized-errors
+      new Error(
+        `Aborting test runner process because it took longer than ${MAX_START_TIME / 1e3} seconds to start.`
+      )
+    )
+  );
+  await Promise.race([startChildProcess(), timeout]).catch((error) => {
+    throw bootGeneration !== generation || store.send({
+      type: "FATAL_ERROR",
+      payload: {
+        message: "Failed to start test runner process",
+        error: error instanceof Error ? errorToErrorLike(error) : { message: String(error) }
+      }
+    }), error;
+  });
+}, runTestRunner = async ({
+  channel,
+  store,
+  initEvent,
+  initArgs,
+  options,
+  configLoader
+}) => {
+  if (!ready && initEvent && eventQueue.push({ type: initEvent, args: initArgs }), !child && booting?.generation !== generation) {
+    let boot = {
+      generation,
+      promise: bootTestRunner({ channel, store, options, configLoader })
+    };
+    booting = boot, boot.promise.catch(() => {
+    }).then(() => {
+      booting === boot && (booting = void 0);
+    });
+  }
+  await booting?.promise;
+};
+var lastStoryIndex, sentStoryIndex, storyIndexRequests = 0, appliedStoryIndexRequest = 0, refreshStoryIndex = async (storyIndexGenerator) => {
+  let request = ++storyIndexRequests;
+  try {
+    let index = await storyIndexGenerator.getIndex();
+    request > appliedStoryIndexRequest && (appliedStoryIndexRequest = request, lastStoryIndex = index);
+  } catch (error) {
+    if (!lastStoryIndex)
+      throw error;
+  }
+}, sendStoryIndex = () => {
+  child && lastStoryIndex !== sentStoryIndex && (sentStoryIndex = lastStoryIndex, child.send({ type: STORY_INDEX_CHANNEL_EVENT_NAME, args: [lastStoryIndex], from: "server" }));
+}, sendStoryIndexToTestRunner = async (storyIndexGenerator) => {
+  await refreshStoryIndex(storyIndexGenerator), ready && sendStoryIndex();
+}, getPreviewAnnotations = async (options) => {
+  let previewAnnotations = await options.presets.apply(
+    "previewAnnotations",
+    [],
+    options
+  ), previewPath = loadPreviewOrConfigFile({ configDir: options.configDir });
+  return (previewAnnotations ?? []).concat(previewPath ?? []);
+}, closeOpenRun = (store) => store.setState((s) => ({
+  ...s,
+  cancelling: !1,
+  currentRun: {
+    ...s.currentRun,
+    finishedAt: s.currentRun.startedAt && !s.currentRun.finishedAt ? Date.now() : s.currentRun.finishedAt
+  }
+}));
+
+// src/addon-vitest/node/test-run-responder.ts
+import {
+  createFileSystemCache,
+  resolvePathInStorybookCache
+} from "@aussieljk/forkbook/internal/common";
+import {
+  internal_UniversalStore,
+  experimental_getTestProviderStore
+} from "@aussieljk/forkbook/internal/core-server";
+var resolvePreviewBuilderName = (core) => typeof core?.builder == "string" ? core.builder : core?.builder?.name, storePromise, ensureTestRunnerStore = ({ channel, options }) => storePromise ??= createTestRunnerStore({ channel, options }).catch((error) => {
+  throw storePromise = void 0, error;
+}), createTestRunnerStore = async ({ channel, options }) => {
+  let core = await options.presets.apply("core"), configLoader = typeof core?.builder != "string" && core?.builder?.options?.configLoader || void 0, fsCache = createFileSystemCache({
+    basePath: resolvePathInStorybookCache(ADDON_ID.replace("/", "-")),
+    ns: "storybook",
+    ttl: 336 * 60 * 60 * 1e3
+    // 14 days
+  }), cachedState = await fsCache.get("state", {
+    config: storeOptions.initialState.config
+  }), selectCachedState = (s) => ({
+    config: s.config
+  }), store = internal_UniversalStore.create({
+    ...storeOptions,
+    initialState: {
+      ...storeOptions.initialState,
+      ...selectCachedState(cachedState)
+    },
+    leader: process.env.VITEST_CHILD_PROCESS !== "true" && process.env.FORKBOOK_ATTACHED_TOOLS !== "true"
+  });
+  store.onStateChange((state, previousState) => {
+    isEqual(selectCachedState(state), selectCachedState(previousState)) || fsCache.set("state", selectCachedState(state));
+  });
+  let testProviderStore = experimental_getTestProviderStore(ADDON_ID);
+  return store.subscribe("TRIGGER_RUN", (event, eventInfo) => {
+    testProviderStore.setState("test-provider-state:running"), store.setState((s) => ({
+      ...s,
+      fatalError: void 0
+    })), runTestRunner({
+      channel,
+      store,
+      initEvent: STORE_CHANNEL_EVENT_NAME,
+      initArgs: [{ event, eventInfo }],
+      options,
+      configLoader
+    }).catch(() => {
+    });
+  }), store.subscribe("FATAL_ERROR", (event) => {
+    let { message, error } = event.payload, name = error.name || "Error";
+    log(`${name}: ${message}`), error.stack && log(error.stack);
+    function logErrorWithCauses(err) {
+      err && (log(`Caused by: ${err.name ?? "Error"}: ${err.message}`), err.stack && log(err.stack), err.cause && logErrorWithCauses(err.cause));
+    }
+    error.cause && logErrorWithCauses(error.cause), store.setState((s) => ({
+      ...s,
+      fatalError: {
+        message,
+        error
+      }
+    })), testProviderStore.setState("test-provider-state:crashed");
+  }), testProviderStore.onClearAll(() => {
+    store.setState((s) => ({
+      ...s,
+      currentRun: { ...s.currentRun, coverageSummary: void 0, unhandledErrors: [] }
+    }));
+  }), store;
+}, wireTestRunResponder = async ({
+  channel,
+  options
+}) => {
+  if (process.env.VITEST_CHILD_PROCESS === "true" || process.env.FORKBOOK_ATTACHED_TOOLS === "true" || !channel)
+    return;
+  let viteBuilder = !!resolvePreviewBuilderName(await options.presets.apply("core"))?.includes(
+    "vite"
+  ), requestInFlight = !1;
+  channel.on(TRIGGER_TEST_RUN_REQUEST, async (payload) => {
+    let { requestId, actor, storyIds, config: configOverride } = payload, sendResponse = (response) => {
+      channel.emit(TRIGGER_TEST_RUN_RESPONSE, { requestId, ...response });
+    };
+    if (!viteBuilder) {
+      sendResponse({
+        status: "error",
+        error: {
+          message: "Story tests require a Vite-based Forkbook builder."
+        }
+      });
+      return;
+    }
+    let store;
+    try {
+      store = await ensureTestRunnerStore({ channel, options });
+    } catch (error) {
+      sendResponse({
+        status: "error",
+        error: {
+          message: "Failed to set up the test runner",
+          error: error instanceof Error ? errorToErrorLike(error) : { message: String(error) }
+        }
+      });
+      return;
+    }
+    await store.untilReady();
+    let {
+      currentRun: { startedAt, finishedAt },
+      config
+    } = store.getState();
+    if (startedAt && !finishedAt || requestInFlight) {
+      sendResponse({
+        status: "error",
+        error: { message: "Tests are already running" }
+      });
+      return;
+    }
+    requestInFlight = !0;
+    let unsubscribe = store.subscribe((event) => {
+      switch (event.type) {
+        case "TEST_RUN_COMPLETED": {
+          requestInFlight = !1, unsubscribe(), sendResponse({ status: "completed", result: event.payload });
+          return;
+        }
+        case "FATAL_ERROR": {
+          requestInFlight = !1, unsubscribe(), sendResponse({ status: "error", error: event.payload });
+          return;
+        }
+        case "CANCEL_RUN": {
+          requestInFlight = !1, unsubscribe(), sendResponse({ status: "cancelled" });
+          return;
+        }
+      }
+    });
+    store.send({
+      type: "TRIGGER_RUN",
+      payload: {
+        storyIds,
+        triggeredBy: `external:${actor}`,
+        ...configOverride && {
+          configOverride: { ...config, ...configOverride }
+        }
+      }
+    });
+  });
+};
+
+// src/addon-vitest/node/toolset/definition.ts
+import * as v from "valibot";
+import {
+  storyInputArraySchema
+} from "@aussieljk/forkbook/internal/core-server";
+import {
+  defineToolset
+} from "@aussieljk/forkbook/open-service";
+
+// src/addon-vitest/node/toolset/format.ts
+function isPassing(status) {
+  return status.value === "status-value:success";
+}
+function isFailing(status) {
+  return status.value === "status-value:error";
+}
+function getA11yReports(result) {
+  return result.a11yReports;
+}
+function getA11yViolations(report) {
+  if (!("violations" in report))
+    return [];
+  let { violations } = report;
+  return Array.isArray(violations) ? violations.map((violation) => ({
+    id: violation.id,
+    description: violation.description,
+    nodes: violation.nodes.map((node) => ({
+      impact: typeof node.impact == "string" ? node.impact : void 0,
+      failureSummary: typeof node.failureSummary == "string" ? node.failureSummary : void 0,
+      html: typeof node.html == "string" ? node.html : void 0,
+      linkPath: typeof node.linkPath == "string" ? node.linkPath : void 0
+    }))
+  })) : [];
+}
+function countA11yViolations(a11yReports) {
+  let count = 0;
+  for (let reports of Object.values(a11yReports ?? {}))
+    for (let report of reports)
+      "error" in report && report.error || (count += getA11yViolations(report).length);
+  return count;
+}
+function pluralize(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function countTestRunFailures(result, a11y) {
+  return {
+    componentTests: result.componentTestCount.error,
+    a11yChecks: a11y ? result.a11yCount.error : 0,
+    unhandledErrors: result.unhandledErrors.length
+  };
+}
+function summarizeTestRun(result, a11y) {
+  return {
+    passingStoryCount: result.componentTestStatuses.filter(isPassing).length,
+    failingStoryCount: result.componentTestStatuses.filter(isFailing).length,
+    a11yViolationCount: a11y ? countA11yViolations(getA11yReports(result)) : 0,
+    unhandledErrorCount: result.unhandledErrors.length
+  };
+}
+function formatPassingStoriesSection(passingStories) {
+  return `## Passing Stories
+
+- ${passingStories.map((status) => status.storyId).join(`
+- `)}`;
+}
+var A11Y_CHECK_FAILED = "The accessibility check failed; see Accessibility Violations below.";
+function formatFailingStoriesSection(statuses) {
+  return `## Failing Stories
+
+${statuses.map((status) => {
+    let details = isFailing(status) ? status.description || "No failure details available." : A11Y_CHECK_FAILED;
+    return `### ${status.storyId}
+
+${details}`;
+  }).join(`
+
+`)}`;
+}
+function formatA11yReportsSection({
+  a11yReports,
+  origin
+}) {
+  let a11yViolationSections = [];
+  for (let [storyId, reports] of Object.entries(a11yReports))
+    for (let report of reports) {
+      if ("error" in report && report.error) {
+        a11yViolationSections.push(`### ${storyId} - Error
+
+${report.error.message}`);
+        continue;
+      }
+      let violations = getA11yViolations(report);
+      if (violations.length !== 0)
+        for (let violation of violations) {
+          let nodes = violation.nodes.map((node) => {
+            let inspectLink = origin && node.linkPath ? `${origin}${node.linkPath}` : void 0, parts = [];
+            return node.impact && parts.push(`- **Impact**: ${node.impact}`), node.failureSummary && parts.push(`  **Message**: ${node.failureSummary}`), parts.push(`  **Element**: ${node.html || "(no html available)"}`), inspectLink && parts.push(`  **Inspect**: ${inspectLink}`), parts.join(`
+`);
+          }).join(`
+`);
+          a11yViolationSections.push(`### ${storyId} - ${violation.id}
+
+${violation.description}
+
+#### Affected Elements
+${nodes}`);
+        }
+    }
+  if (a11yViolationSections.length !== 0)
+    return `## Accessibility Violations
+
+${a11yViolationSections.join(`
+
+`)}`;
+}
+function formatUnhandledErrorsSection(errors) {
+  return `## Unhandled Errors
+
+${errors.map(
+    (unhandledError) => `### ${unhandledError.name || "Unknown Error"}
+
+**Error message**: ${unhandledError.message || "No message available"}
+**Path**: ${unhandledError.VITEST_TEST_PATH || "No path available"}
+**Test name**: ${unhandledError.VITEST_TEST_NAME || "No test name available"}
+**Stack trace**:
+${unhandledError.stack || "No stack trace available"}`
+  ).join(`
+
+`)}`;
+}
+function formatA11yCounts({ success, warning, error }, a11yEnabled) {
+  let checked = success + warning + error;
+  if (checked === 0)
+    return a11yEnabled ? "Accessibility: not checked." : "Accessibility: not checked (addon-a11y is not enabled).";
+  if (warning === 0 && error === 0)
+    return `Accessibility: ${pluralize(checked, "story", "stories")} checked, no violations.`;
+  let parts = [
+    success > 0 ? `${success} without violations` : void 0,
+    warning > 0 ? `${warning} with violations reported as warnings, which do not fail the run` : void 0,
+    error > 0 ? `${error} failing the run` : void 0
+  ].filter(Boolean);
+  return `Accessibility: ${pluralize(checked, "story", "stories")} checked; ${parts.join("; ")}.`;
+}
+function formatA11yResult(result, { a11y, a11yEnabled }) {
+  if (!a11y)
+    return "Accessibility: skipped (a11y: false).";
+  let counts = formatA11yCounts(result.a11yCount, a11yEnabled);
+  return result.componentTestCount.error > 0 ? `${counts} Stories with a failing component test get no accessibility result.` : counts;
+}
+var FAILURE_LABELS = {
+  componentTests: (count) => `${pluralize(count, "component test")} failed`,
+  a11yChecks: (count) => `${pluralize(count, "accessibility check")} failed`,
+  unhandledErrors: (count) => pluralize(count, "unhandled error")
+};
+function formatResultSection(result, { a11y, a11yEnabled }) {
+  let failures = countTestRunFailures(result, a11y), failureParts = Object.keys(FAILURE_LABELS).filter((key) => failures[key] > 0).map((key) => FAILURE_LABELS[key](failures[key]));
+  return `## Result
+
+${failureParts.length > 0 ? `Failed: ${failureParts.join(", ")}.` : result.componentTestCount.success === 0 ? "No component tests ran." : `Passed: ${pluralize(result.componentTestCount.success, "component test")} passed.`}
+${formatA11yResult(result, { a11y, a11yEnabled })}`;
+}
+function formatCompletedRun(result, { a11y, a11yEnabled, origin }) {
+  let sections = [], a11yFailingStoryIds = new Set(
+    a11y ? result.a11yStatuses.filter(isFailing).map((status) => status.storyId) : []
+  ), passingStories = result.componentTestStatuses.filter(
+    (status) => isPassing(status) && !a11yFailingStoryIds.has(status.storyId)
+  ), failingStories = result.componentTestStatuses.filter(
+    (status) => isFailing(status) || a11yFailingStoryIds.has(status.storyId)
+  );
+  passingStories.length > 0 && sections.push(formatPassingStoriesSection(passingStories)), failingStories.length > 0 && sections.push(formatFailingStoriesSection(failingStories));
+  let a11yReports = getA11yReports(result);
+  if (a11y && a11yReports && Object.keys(a11yReports).length > 0) {
+    let a11ySection = formatA11yReportsSection({ a11yReports, origin });
+    a11ySection && sections.push(a11ySection);
+  }
+  return result.unhandledErrors.length > 0 && sections.push(formatUnhandledErrorsSection(result.unhandledErrors)), sections.push(formatResultSection(result, { a11y, a11yEnabled })), sections.join(`
+
+`);
+}
+function formatTestRun(data, ctx, { a11yEnabled }) {
+  switch (data.status) {
+    case "no-stories":
+      return data.notFoundMessages.length === 0 ? "No stories were given, so no tests ran. Pass story IDs in `stories`, or omit it to run every story test." : `No stories found matching the provided input.
+
+${data.notFoundMessages.join(`
+`)}`;
+    case "completed":
+      return formatCompletedRun(data.result, {
+        a11y: data.a11y,
+        a11yEnabled,
+        origin: ctx.origin
+      });
+    case "error":
+      return `Error: ${data.error.message}`;
+    case "cancelled":
+      return "Error: Test run was cancelled";
+    default:
+      return data;
+  }
+}
+
+// src/addon-vitest/node/toolset/run.ts
+import {
+  findStoryIds
+} from "@aussieljk/forkbook/internal/core-server";
+import { OpenServiceTestRunTimeoutError } from "@aussieljk/forkbook/internal/server-errors";
+var DEFAULT_TEST_RUN_TIMEOUT_MS = 1800 * 1e3;
+function createAsyncQueue() {
+  let tail = Promise.resolve();
+  async function wait() {
+    let done, gate = new Promise((resolve) => {
+      done = resolve;
+    }), previousTail = tail;
+    return tail = previousTail.then(
+      () => gate,
+      () => gate
+    ), await previousTail.catch(() => {
+    }), done;
+  }
+  return { wait };
+}
+function triggerTestRun({
+  channel,
+  requestEvent,
+  responseEvent,
+  storyIds,
+  config,
+  actor,
+  timeoutMs = DEFAULT_TEST_RUN_TIMEOUT_MS
+}) {
+  return new Promise((resolve, reject) => {
+    let requestId = `osa-test-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`, settled = !1, timeoutId, cleanup = () => {
+      timeoutId !== void 0 && (clearTimeout(timeoutId), timeoutId = void 0), channel.off(responseEvent, handleResponse);
+    }, settle = (callback) => {
+      settled || (settled = !0, cleanup(), callback());
+    }, handleResponse = (payload) => {
+      if (payload.requestId === requestId)
+        switch (payload.status) {
+          case "completed":
+          case "error":
+          case "cancelled":
+            settle(() => resolve(payload));
+            break;
+          default: {
+            let _exhaustive = payload.status;
+            settle(() => reject(new Error(`Unexpected test run response: ${_exhaustive}`)));
+          }
+        }
+    };
+    channel.on(responseEvent, handleResponse), timeoutId = setTimeout(() => {
+      settle(() => reject(new OpenServiceTestRunTimeoutError({ timeoutMs, requestId })));
+    }, timeoutMs);
+    try {
+      channel.emit(requestEvent, {
+        requestId,
+        actor,
+        storyIds,
+        config
+      });
+    } catch (error) {
+      settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+    }
+  });
+}
+async function runStoryTests({
+  channel,
+  getIndex,
+  stories,
+  a11y = !0,
+  actor = "core/test",
+  requestEvent = TRIGGER_TEST_RUN_REQUEST,
+  responseEvent = TRIGGER_TEST_RUN_RESPONSE,
+  timeoutMs = DEFAULT_TEST_RUN_TIMEOUT_MS
+}) {
+  let storyIds;
+  if (stories) {
+    let index = await getIndex(), resolved = findStoryIds(index, stories), found = resolved.filter((story) => "entry" in story), notFoundMessages = resolved.filter((story) => !("entry" in story)).map((story) => story.errorMessage);
+    if (found.length === 0)
+      return { status: "no-stories", notFoundMessages };
+    if (notFoundMessages.length > 0)
+      return {
+        status: "error",
+        error: { message: notFoundMessages.join("; ") }
+      };
+    storyIds = found.map((story) => story.entry.id);
+  }
+  let response;
+  try {
+    response = await triggerTestRun({
+      channel,
+      requestEvent,
+      responseEvent,
+      storyIds,
+      config: { a11y },
+      actor,
+      timeoutMs
+    });
+  } catch (error) {
+    return {
+      status: "error",
+      error: {
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  switch (response.status) {
+    case "completed":
+      return response.result ? { status: "completed", result: response.result } : {
+        status: "error",
+        error: { message: "Test run completed but no result was returned" }
+      };
+    case "error":
+      return {
+        status: "error",
+        error: {
+          message: response.error?.message ?? "Test run failed with unknown error",
+          ...response.error?.error !== void 0 ? { error: response.error.error } : {}
+        }
+      };
+    case "cancelled":
+      return { status: "cancelled" };
+    default:
+      return {
+        status: "error",
+        error: { message: `Unexpected test run response: ${response.status}` }
+      };
+  }
+}
+
+// src/addon-vitest/node/toolset/definition.ts
+var errorLikeSchema = v.object({
+  message: v.string(),
+  name: v.optional(v.string()),
+  stack: v.optional(v.string()),
+  cause: v.optional(v.lazy(() => errorLikeSchema))
+}), statusSchema = v.looseObject({
+  value: v.string(),
+  typeId: v.string(),
+  storyId: v.string(),
+  title: v.string(),
+  description: v.string()
+}), testRunResultSchema = v.object({
+  triggeredBy: v.optional(v.any()),
+  config: v.record(v.string(), v.any()),
+  componentTestStatuses: v.array(statusSchema),
+  a11yStatuses: v.array(statusSchema),
+  componentTestCount: v.object({
+    success: v.number(),
+    error: v.number()
+  }),
+  a11yCount: v.object({
+    success: v.number(),
+    warning: v.number(),
+    error: v.number()
+  }),
+  a11yReports: v.record(v.string(), v.array(v.any())),
+  reports: v.record(v.string(), v.array(v.any())),
+  totalTestCount: v.optional(v.number()),
+  storyIds: v.optional(v.array(v.string())),
+  startedAt: v.optional(v.number()),
+  finishedAt: v.optional(v.number()),
+  unhandledErrors: v.array(v.any()),
+  coverageSummary: v.optional(
+    v.object({
+      status: v.union([
+        v.literal("positive"),
+        v.literal("warning"),
+        v.literal("negative"),
+        v.literal("unknown")
+      ]),
+      percentage: v.number()
+    })
+  )
+}), testRunOutputSchema = v.variant("status", [
+  v.object({
+    status: v.literal("no-stories"),
+    /** Per-selector lookup failures. When nothing matched, they are the whole answer. */
+    notFoundMessages: v.array(v.string())
+  }),
+  v.object({
+    status: v.literal("completed"),
+    result: testRunResultSchema
+  }),
+  v.object({
+    status: v.literal("error"),
+    error: v.object({
+      message: v.string(),
+      error: v.optional(errorLikeSchema)
+    })
+  }),
+  v.object({
+    status: v.literal("cancelled")
+  })
+]), runInputSchema = v.strictObject({
+  stories: v.optional(
+    v.pipe(
+      storyInputArraySchema,
+      v.description(
+        `Stories to test for focused feedback. Omit this field to run tests for all available stories.
+Prefer running tests for specific stories while developing to get faster feedback,
+and only omit this when you explicitly need to run all tests for comprehensive verification.
+Prefer { storyId } when you don't already have story file context, since this avoids filesystem discovery.
+Use { storyId } when IDs were discovered from documentation tools.
+Use { absoluteStoryPath + exportName } only when you're currently working in a story file and already know those values.`
+      )
+    )
+  ),
+  a11y: v.optional(
+    v.pipe(
+      v.boolean(),
+      v.description(
+        "Whether to run accessibility tests. Defaults to true. Disable if you only need component test results."
+      )
+    ),
+    !0
+  )
+});
+function describeRun(a11yEnabled) {
+  return `Run story tests.
+Run them after editing anything that changes how the UI looks \u2014 components, stories, styles, CSS, themes, colors, or design tokens \u2014 shell-level substitutes like typecheck, lint, or package.json test scripts do not replace this.
+Provide stories for focused runs (faster while iterating),
+or omit stories to run all tests for full-project verification.
+Use this continuously to monitor test results as you work on your UI components and stories.
+Results will include passing/failing status` + (a11yEnabled ? `, and accessibility violation reports.
+For visual/design accessibility violations (for example color contrast), ask the user before changing styles.` : ".");
+}
+function runTelemetry(data, input) {
+  let inputStoryCount = input.stories?.length ?? 0;
+  if (data.status === "no-stories")
+    return {
+      payload: {
+        runA11y: data.a11y,
+        inputStoryCount,
+        matchedStoryCount: 0,
+        passingStoryCount: 0,
+        failingStoryCount: 0,
+        a11yViolationCount: 0,
+        unhandledErrorCount: 0
+      }
+    };
+  if (data.status === "completed")
+    return {
+      payload: {
+        runA11y: data.a11y,
+        inputStoryCount,
+        // A partially resolved selector list never reaches a run, so every input matched by this point.
+        matchedStoryCount: data.result.storyIds?.length ?? inputStoryCount,
+        ...summarizeTestRun(data.result, data.a11y)
+      }
+    };
+}
+function isFailedRun(data) {
+  switch (data.status) {
+    case "error":
+    case "cancelled":
+      return !0;
+    case "completed":
+      return Object.values(countTestRunFailures(data.result, data.a11y)).some((count) => count > 0);
+    case "no-stories":
+      return !1;
+    default:
+      return data;
+  }
+}
+function createTestToolset({ channel, storyIndex, a11yEnabled }) {
+  let queue = createAsyncQueue();
+  return defineToolset({
+    id: "test",
+    description: "Run Forkbook story tests via addon-vitest.",
+    methods: {
+      run: {
+        input: runInputSchema,
+        title: "Run Forkbook tests",
+        description: describeRun(a11yEnabled),
+        handler: async (input, ctx) => {
+          let done = await queue.wait();
+          try {
+            let data = { ...await runStoryTests({
+              channel,
+              getIndex: storyIndex.getIndex,
+              stories: input.stories,
+              a11y: input.a11y
+            }), a11y: input.a11y }, markdown = formatTestRun(data, ctx, { a11yEnabled }), telemetry2 = runTelemetry(data, input);
+            return isFailedRun(data) ? { ok: !1, data, markdown, telemetry: telemetry2 } : { ok: !0, data, markdown, telemetry: telemetry2 };
+          } finally {
+            done();
+          }
+        }
+      }
+    }
+  });
+}
+
+// src/addon-vitest/preset.ts
+var isAddonVitestEnabled = !0, services = async (_value, options) => {
+  let getIndex = () => options.presets.apply("storyIndexGenerator").then((generator) => generator.getIndex());
+  registerToolset(
+    createTestToolset({
+      channel: options.channel,
+      storyIndex: { getIndex },
+      a11yEnabled: await options.presets.apply("isAddonA11yEnabled", !1)
+    })
+  ), await wireTestRunResponder({ channel: options.channel, options });
+}, experimental_serverChannel = async (channel, options) => {
+  let core = await options.presets.apply("core");
+  if (!resolvePreviewBuilderName(core)?.includes("vite"))
+    return channel;
+  let configLoader = typeof core.builder != "string" && core.builder?.options?.configLoader, store = await ensureTestRunnerStore({ channel, options }), storyIndexGenerator = await options.presets.apply("storyIndexGenerator"), refreshTestRunnerStoryIndex = () => sendStoryIndexToTestRunner(storyIndexGenerator).catch((error) => {
+    logger.debug("Failed to send the story index to the test runner, Error:"), logger.debug(error);
+  });
+  refreshTestRunnerStoryIndex(), storyIndexGenerator.onInvalidated(refreshTestRunnerStoryIndex), store.subscribe("TOGGLE_WATCHING", (event, eventInfo) => {
+    store.setState((s) => ({
+      ...s,
+      watching: event.payload.to,
+      currentRun: {
+        ...s.currentRun,
+        // when enabling watch mode, clear the coverage summary too
+        ...event.payload.to && {
+          coverageSummary: void 0
+        }
+      }
+    })), event.payload.to && runTestRunner({
+      channel,
+      store,
+      initEvent: STORE_CHANNEL_EVENT_NAME,
+      initArgs: [{ event, eventInfo }],
+      options,
+      configLoader: configLoader || void 0
+    });
+  });
+  let enableCrashReports = core?.enableCrashReports || options.enableCrashReports;
+  return channel.on(FORKBOOK_ADDON_TEST_CHANNEL, (event) => {
+    event.type !== "test-run-completed" && telemetry("addon-test", () => ({
+      ...event,
+      payload: {
+        ...event.payload,
+        storyId: oneWayHash(event.payload.storyId)
+      }
+    }));
+  }), store.subscribe("TOGGLE_WATCHING", async (event) => {
+    await telemetry("addon-test", () => ({
+      watchMode: event.payload.to
+    }));
+  }), store.subscribe("TEST_RUN_COMPLETED", async (event) => {
+    let { unhandledErrors, startedAt, finishedAt, ...currentRun } = event.payload;
+    await telemetry("addon-test", () => ({
+      ...currentRun,
+      duration: (finishedAt ?? 0) - (startedAt ?? 0),
+      unhandledErrorCount: unhandledErrors.length,
+      ...enableCrashReports && unhandledErrors.length > 0 && {
+        unhandledErrors: unhandledErrors.map((error) => {
+          let { stacks, ...errorWithoutStacks } = error;
+          return sanitizeError(errorWithoutStacks);
+        })
+      }
+    }));
+  }), enableCrashReports && store.subscribe("FATAL_ERROR", async (event) => {
+    await telemetry("addon-test", () => ({
+      fatalError: cleanPaths(event.payload.error.message)
+    }));
+  }), channel;
+}, staticDirs = async (values = [], options) => {
+  if (options.configType === "PRODUCTION")
+    return values;
+  let coverageDirectory = resolvePathInStorybookCache2(COVERAGE_DIRECTORY);
+  return await mkdir(coverageDirectory, { recursive: !0 }), [
+    {
+      from: coverageDirectory,
+      to: "/coverage"
+    },
+    ...values
+  ];
+};
+export {
+  experimental_serverChannel,
+  isAddonVitestEnabled,
+  services,
+  staticDirs
+};