storybook 10.2.0-alpha.16 → 10.2.0-alpha.17

package/dist/core-server/presets/common-preset.js

@@ -1,54 +1,63 @@
-import CJS_COMPAT_NODE_URL_4zwbyhk64wx from 'node:url';
-import CJS_COMPAT_NODE_PATH_4zwbyhk64wx from 'node:path';
-import CJS_COMPAT_NODE_MODULE_4zwbyhk64wx from "node:module";
+import CJS_COMPAT_NODE_URL_w8tq4vh9mzk from 'node:url';
+import CJS_COMPAT_NODE_PATH_w8tq4vh9mzk from 'node:path';
+import CJS_COMPAT_NODE_MODULE_w8tq4vh9mzk from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_4zwbyhk64wx.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_4zwbyhk64wx.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_4zwbyhk64wx.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_w8tq4vh9mzk.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_w8tq4vh9mzk.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_w8tq4vh9mzk.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
-import "../../_node-chunks/chunk-KAAWGCHX.js";
+import "../../_node-chunks/chunk-CCJGKJ27.js";
 import {
+  doesStoryFileExist,
+  generateStoryFile,
+  getStoryMetadata,
   parseStaticDir,
   sendTelemetryError,
   throttle
-} from "../../_node-chunks/chunk-XJMJA2L4.js";
-import "../../_node-chunks/chunk-MSK3YTQT.js";
-import "../../_node-chunks/chunk-CFXIZS6A.js";
-import "../../_node-chunks/chunk-K6FMM5LS.js";
+} from "../../_node-chunks/chunk-XTIFAWOB.js";
+import "../../_node-chunks/chunk-EG3WZ464.js";
+import "../../_node-chunks/chunk-IWM3WHZE.js";
+import "../../_node-chunks/chunk-FAARRTOD.js";
+import {
+  isI18nPackage,
+  isRouterPackage,
+  isStateManagementPackage,
+  isStylingPackage
+} from "../../_node-chunks/chunk-GYJ7LPFJ.js";
 import {
   globalSettings
-} from "../../_node-chunks/chunk-LOJ73E6E.js";
+} from "../../_node-chunks/chunk-VK4OWRKU.js";
 import {
   invariant
-} from "../../_node-chunks/chunk-JXU4P6K3.js";
-import "../../_node-chunks/chunk-SWN4HCJE.js";
+} from "../../_node-chunks/chunk-C3FPVGL4.js";
+import "../../_node-chunks/chunk-KKNWPXMS.js";
 import {
   resolvePackageDir
-} from "../../_node-chunks/chunk-RIEIAV32.js";
+} from "../../_node-chunks/chunk-3D4SLKEE.js";
 import {
   isAbsolute,
   join
-} from "../../_node-chunks/chunk-XWGABQX7.js";
+} from "../../_node-chunks/chunk-5Q5JEISY.js";
 import {
-  loadConfig
-} from "../../_node-chunks/chunk-TLGG6YAX.js";
-import "../../_node-chunks/chunk-5E2HAJXY.js";
+  glob
+} from "../../_node-chunks/chunk-DJ3RRSJ7.js";
+import "../../_node-chunks/chunk-VTBZVEBF.js";
 import {
   require_dist
-} from "../../_node-chunks/chunk-YFUVKP3W.js";
-import "../../_node-chunks/chunk-PGYIGHRK.js";
-import "../../_node-chunks/chunk-WVXPIXUS.js";
+} from "../../_node-chunks/chunk-G7P42ZEY.js";
+import "../../_node-chunks/chunk-IRMNO3QS.js";
+import "../../_node-chunks/chunk-MU4E5UBA.js";
 import {
   require_picocolors
-} from "../../_node-chunks/chunk-FNQ5WLS5.js";
+} from "../../_node-chunks/chunk-XI7HDOMY.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "../../_node-chunks/chunk-3PMH6BEP.js";
+} from "../../_node-chunks/chunk-25OWI2RR.js";
 
 // ../../node_modules/shell-quote/quote.js
 var require_quote = __commonJS({
@@ -472,8 +481,8 @@ var require_launch_editor = __commonJS({
 });
 
 // src/core-server/presets/common-preset.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
 import { normalizeStories, optionalEnvToBoolean } from "storybook/internal/common";
 import {
   JsPackageManagerFactory,
@@ -486,191 +495,51 @@ import {
 import { StoryIndexGenerator } from "storybook/internal/core-server";
 import { readCsf as readCsf2 } from "storybook/internal/csf-tools";
 import { logger as logger4 } from "storybook/internal/node-logger";
-import { telemetry as telemetry8 } from "storybook/internal/telemetry";
-var import_ts_dedent4 = __toESM(require_dist(), 1);
+import { telemetry as telemetry9 } from "storybook/internal/telemetry";
+var import_ts_dedent = __toESM(require_dist(), 1);
 
 // src/core-server/server-channel/create-new-story-channel.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { relative } from "node:path";
-import { getStoryId } from "storybook/internal/common";
 import {
   CREATE_NEW_STORYFILE_REQUEST,
   CREATE_NEW_STORYFILE_RESPONSE
 } from "storybook/internal/core-events";
 import { telemetry } from "storybook/internal/telemetry";
-
-// src/core-server/utils/get-new-story-file.ts
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { basename, dirname, extname, join as join2 } from "node:path";
-import {
-  extractFrameworkPackageName,
-  findConfigFile,
-  getFrameworkName,
-  getProjectRoot
-} from "storybook/internal/common";
-import { isCsfFactoryPreview } from "storybook/internal/csf-tools";
-
-// src/core-server/utils/new-story-templates/csf-factory-template.ts
-var import_ts_dedent = __toESM(require_dist(), 1);
-
-// src/core-server/utils/get-component-variable-name.ts
-var getComponentVariableName = async (name) => (await import("../../_node-chunks/camelcase-ILOVTISA.js")).default(name.replace(/^[^a-zA-Z_$]*/, ""), { pascalCase: !0 }).replace(/[^a-zA-Z_$]+/, "");
-
-// src/core-server/utils/new-story-templates/csf-factory-template.ts
-async function getCsfFactoryTemplateForNewStoryFile(data) {
-  let importName = data.componentIsDefaultExport ? await getComponentVariableName(data.basenameWithoutExtension) : data.componentExportName, importStatement = data.componentIsDefaultExport ? `import ${importName} from './${data.basenameWithoutExtension}';` : `import { ${importName} } from './${data.basenameWithoutExtension}';`;
-  return import_ts_dedent.dedent`
-  ${"import preview from '#.storybook/preview';"}
-  
-  ${importStatement}
-
-  const meta = preview.meta({
-    component: ${importName},
-  });
-  
-  export const ${data.exportedStoryName} = meta.story({});
-  `;
-}
-
-// src/core-server/utils/new-story-templates/javascript.ts
-var import_ts_dedent2 = __toESM(require_dist(), 1);
-async function getJavaScriptTemplateForNewStoryFile(data) {
-  let importName = data.componentIsDefaultExport ? await getComponentVariableName(data.basenameWithoutExtension) : data.componentExportName, importStatement = data.componentIsDefaultExport ? `import ${importName} from './${data.basenameWithoutExtension}';` : `import { ${importName} } from './${data.basenameWithoutExtension}';`;
-  return import_ts_dedent2.dedent`
-  ${importStatement}
-
-  const meta = {
-    component: ${importName},
-  };
-  
-  export default meta;
-  
-  export const ${data.exportedStoryName} = {};
-  `;
-}
-
-// src/core-server/utils/new-story-templates/typescript.ts
-var import_ts_dedent3 = __toESM(require_dist(), 1);
-async function getTypeScriptTemplateForNewStoryFile(data) {
-  let importName = data.componentIsDefaultExport ? await getComponentVariableName(data.basenameWithoutExtension) : data.componentExportName, importStatement = data.componentIsDefaultExport ? `import ${importName} from './${data.basenameWithoutExtension}'` : `import { ${importName} } from './${data.basenameWithoutExtension}'`;
-  return import_ts_dedent3.dedent`
-  import type { Meta, StoryObj } from '${data.frameworkPackage}';
-
-  ${importStatement};
-
-  const meta = {
-    component: ${importName},
-  } satisfies Meta<typeof ${importName}>;
-
-  export default meta;
-
-  type Story = StoryObj<typeof meta>;
-
-  export const ${data.exportedStoryName}: Story = {};
-  `;
-}
-
-// src/core-server/utils/get-new-story-file.ts
-async function getNewStoryFile({
-  componentFilePath,
-  componentExportName,
-  componentIsDefaultExport,
-  componentExportCount
-}, options) {
-  let frameworkPackageName = await getFrameworkName(options), sanitizedFrameworkPackageName = extractFrameworkPackageName(frameworkPackageName), base = basename(componentFilePath), extension = extname(componentFilePath), basenameWithoutExtension = base.replace(extension, ""), dir = dirname(componentFilePath), { storyFileName, isTypescript, storyFileExtension } = getStoryMetadata(componentFilePath), storyFileNameWithExtension = `${storyFileName}.${storyFileExtension}`, alternativeStoryFileNameWithExtension = `${basenameWithoutExtension}.${componentExportName}.stories.${storyFileExtension}`, exportedStoryName = "Default", useCsfFactory = !1;
-  try {
-    let previewConfig = findConfigFile("preview", options.configDir);
-    if (previewConfig) {
-      let previewContent = await readFile(previewConfig, "utf-8");
-      useCsfFactory = isCsfFactoryPreview(loadConfig(previewContent));
-    }
-  } catch {
-  }
-  let storyFileContent = "";
-  return useCsfFactory ? storyFileContent = await getCsfFactoryTemplateForNewStoryFile({
-    basenameWithoutExtension,
-    componentExportName,
-    componentIsDefaultExport,
-    exportedStoryName
-  }) : storyFileContent = isTypescript && frameworkPackageName ? await getTypeScriptTemplateForNewStoryFile({
-    basenameWithoutExtension,
-    componentExportName,
-    componentIsDefaultExport,
-    frameworkPackage: sanitizedFrameworkPackageName,
-    exportedStoryName
-  }) : await getJavaScriptTemplateForNewStoryFile({
-    basenameWithoutExtension,
-    componentExportName,
-    componentIsDefaultExport,
-    exportedStoryName
-  }), { storyFilePath: doesStoryFileExist(join2(getProjectRoot(), dir), storyFileName) && componentExportCount > 1 ? join2(getProjectRoot(), dir, alternativeStoryFileNameWithExtension) : join2(getProjectRoot(), dir, storyFileNameWithExtension), exportedStoryName, storyFileContent, dirname };
-}
-var getStoryMetadata = (componentFilePath) => {
-  let isTypescript = /\.(ts|tsx|mts|cts)$/.test(componentFilePath), base = basename(componentFilePath), extension = extname(componentFilePath), basenameWithoutExtension = base.replace(extension, ""), storyFileExtension = isTypescript ? "tsx" : "jsx";
-  return {
-    storyFileName: `${basenameWithoutExtension}.stories`,
-    storyFileExtension,
-    isTypescript
-  };
-}, doesStoryFileExist = (parentFolder, storyFileName) => existsSync(join2(parentFolder, `${storyFileName}.ts`)) || existsSync(join2(parentFolder, `${storyFileName}.tsx`)) || existsSync(join2(parentFolder, `${storyFileName}.js`)) || existsSync(join2(parentFolder, `${storyFileName}.jsx`));
-
-// src/core-server/server-channel/create-new-story-channel.ts
 function initCreateNewStoryChannel(channel, options, coreOptions) {
   return channel.on(
     CREATE_NEW_STORYFILE_REQUEST,
     async (data) => {
-      try {
-        let { storyFilePath, exportedStoryName, storyFileContent } = await getNewStoryFile(
-          data.payload,
-          options
-        ), relativeStoryFilePath = relative(process.cwd(), storyFilePath), { storyId, kind } = await getStoryId({ storyFilePath, exportedStoryName }, options);
-        if (existsSync2(storyFilePath)) {
-          channel.emit(CREATE_NEW_STORYFILE_RESPONSE, {
-            success: !1,
-            id: data.id,
-            payload: {
-              type: "STORY_FILE_EXISTS",
-              kind
-            },
-            error: `A story file already exists at ${relativeStoryFilePath}`
-          }), coreOptions.disableTelemetry || telemetry("create-new-story-file", {
-            success: !1,
-            error: "STORY_FILE_EXISTS"
-          });
-          return;
-        }
-        await writeFile(storyFilePath, storyFileContent, "utf-8"), channel.emit(CREATE_NEW_STORYFILE_RESPONSE, {
-          success: !0,
-          id: data.id,
-          payload: {
-            storyId,
-            storyFilePath: relative(process.cwd(), storyFilePath),
-            exportedStoryName
-          },
-          error: null
-        }), coreOptions.disableTelemetry || telemetry("create-new-story-file", {
-          success: !0
-        });
-      } catch (e) {
-        channel.emit(CREATE_NEW_STORYFILE_RESPONSE, {
-          success: !1,
-          id: data.id,
-          error: e?.message
-        }), coreOptions.disableTelemetry || await telemetry("create-new-story-file", {
-          success: !1,
-          error: e
-        });
-      }
+      let result = await generateStoryFile(data.payload, options);
+      result.success ? (channel.emit(CREATE_NEW_STORYFILE_RESPONSE, {
+        success: !0,
+        id: data.id,
+        payload: {
+          storyId: result.storyId,
+          storyFilePath: result.storyFilePath,
+          exportedStoryName: result.exportedStoryName
+        },
+        error: null
+      }), coreOptions.disableTelemetry || telemetry("create-new-story-file", {
+        success: !0
+      })) : (channel.emit(CREATE_NEW_STORYFILE_RESPONSE, {
+        success: !1,
+        id: data.id,
+        payload: result.errorType === "STORY_FILE_EXISTS" ? {
+          type: "STORY_FILE_EXISTS",
+          kind: result.kind
+        } : void 0,
+        error: result.error || "Unknown error occurred"
+      }), coreOptions.disableTelemetry || await telemetry("create-new-story-file", {
+        success: !1,
+        error: result.errorType || result.error
+      }));
     }
   ), channel;
 }
 
 // src/core-server/server-channel/file-search-channel.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { extractRenderer, getFrameworkName as getFrameworkName2, getProjectRoot as getProjectRoot2 } from "storybook/internal/common";
+import { readFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+import { extractRenderer, getFrameworkName, getProjectRoot } from "storybook/internal/common";
 import {
   FILE_COMPONENT_SEARCH_REQUEST,
   FILE_COMPONENT_SEARCH_RESPONSE
@@ -781,7 +650,7 @@ async function searchFiles({
   ignoredFiles = IGNORED_FILES,
   fileExtensions = FILE_EXTENSIONS
 }) {
-  let { globby, isDynamicPattern } = await import("../../_node-chunks/globby-A35XB3PP.js"), hasSearchSpecialGlobChars = isDynamicPattern(searchQuery, { cwd }), searchQueryHasExtension = /(\.[a-z]+)$/i.test(searchQuery), fileExtensionsPattern = `{${fileExtensions.join(",")}}`, globbedSearchQuery = hasSearchSpecialGlobChars ? searchQuery : searchQueryHasExtension ? [`**/*${searchQuery}*`, `**/*${searchQuery}*/**`] : [
+  let { globby, isDynamicPattern } = await import("../../_node-chunks/globby-4BDMCAAD.js"), hasSearchSpecialGlobChars = isDynamicPattern(searchQuery, { cwd }), searchQueryHasExtension = /(\.[a-z]+)$/i.test(searchQuery), fileExtensionsPattern = `{${fileExtensions.join(",")}}`, globbedSearchQuery = hasSearchSpecialGlobChars ? searchQuery : searchQueryHasExtension ? [`**/*${searchQuery}*`, `**/*${searchQuery}*/**`] : [
     `**/*${searchQuery}*.${fileExtensionsPattern}`,
     `**/*${searchQuery}*/**/*.${fileExtensionsPattern}`
   ];
@@ -803,13 +672,13 @@ async function initFileSearchChannel(channel, options, coreOptions) {
       try {
         if (!searchQuery)
           return;
-        let frameworkName = await getFrameworkName2(options), rendererName = await extractRenderer(frameworkName), entries = (await searchFiles({
+        let frameworkName = await getFrameworkName(options), rendererName = await extractRenderer(frameworkName), entries = (await searchFiles({
           searchQuery,
-          cwd: getProjectRoot2()
+          cwd: getProjectRoot()
         })).map(async (file) => {
           let parser3 = getParser(rendererName);
           try {
-            let content = await readFile2(join3(getProjectRoot2(), file), "utf-8"), { storyFileName } = getStoryMetadata(join3(getProjectRoot2(), file)), dir = dirname2(file), storyFileExists = doesStoryFileExist(join3(getProjectRoot2(), dir), storyFileName), info = await parser3.parse(content);
+            let content = await readFile(join2(getProjectRoot(), file), "utf-8"), { storyFileName } = getStoryMetadata(join2(getProjectRoot(), file)), dir = dirname(file), storyFileExists = doesStoryFileExist(join2(getProjectRoot(), dir), storyFileName), info = await parser3.parse(content);
             return {
               filepath: file,
               exportedComponents: info.exports,
@@ -854,14 +723,443 @@ ${e?.message}`
   ), channel;
 }
 
+// src/core-server/server-channel/ghost-stories-channel.ts
+import { GHOST_STORIES_REQUEST, GHOST_STORIES_RESPONSE } from "storybook/internal/core-events";
+import {
+  getLastEvents,
+  getSessionId,
+  getStorybookMetadata,
+  telemetry as telemetry3
+} from "storybook/internal/telemetry";
+
+// src/core-server/utils/ghost-stories/get-candidates.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { babelParse, traverse } from "storybook/internal/babel";
+
+// src/core-server/utils/ghost-stories/component-analyzer.ts
+var COMPLEXITY_CONFIG = {
+  /** Weight applied to non-empty lines */
+  locWeight: 1,
+  /** Imports can be cheap, so they get a lower weight */
+  importWeight: 0.5,
+  /**
+   * Defines what raw complexity value should map to the upper bound of a "simple" file For instance
+   * 30 LOC + 4 imports = 32. This would result in a score of 0.3
+   */
+  simpleBaseline: 32,
+  simpleScore: 0.3
+}, getComponentComplexity = (fileContent) => {
+  let lines = fileContent.split(`
+`), nonEmptyLines = lines.filter((line) => line.trim() !== "").length, importCount = lines.filter((line) => line.trim().startsWith("import")).length, normalizedScore = (nonEmptyLines * COMPLEXITY_CONFIG.locWeight + importCount * COMPLEXITY_CONFIG.importWeight) / (COMPLEXITY_CONFIG.simpleBaseline / COMPLEXITY_CONFIG.simpleScore);
+  return Math.min(normalizedScore, 1);
+};
+
+// src/core-server/utils/ghost-stories/get-candidates.ts
+function isValidCandidate(source) {
+  let ast = babelParse(source), hasJSX = !1, hasExport = !1;
+  return traverse(ast, {
+    JSXElement(path) {
+      hasJSX = !0, hasExport && path.stop();
+    },
+    JSXFragment(path) {
+      hasJSX = !0, hasExport && path.stop();
+    },
+    ExportNamedDeclaration(path) {
+      hasExport = !0, hasJSX && path.stop();
+    },
+    ExportDefaultDeclaration(path) {
+      hasExport = !0, hasJSX && path.stop();
+    },
+    ExportAllDeclaration(path) {
+      hasExport = !0, hasJSX && path.stop();
+    }
+  }), hasJSX && hasExport;
+}
+async function getCandidatesForStorybook(files, sampleCount) {
+  let simpleCandidates = [], analyzedCandidates = [];
+  for (let file of files) {
+    let source;
+    try {
+      if (source = await readFile2(file, "utf-8"), !isValidCandidate(source))
+        continue;
+    } catch {
+      continue;
+    }
+    let complexity = getComponentComplexity(source);
+    if (analyzedCandidates.push({ file, complexity }), complexity < 0.3 && (simpleCandidates.push({ file, complexity }), simpleCandidates.length >= sampleCount))
+      break;
+  }
+  let selectedCandidates = [];
+  simpleCandidates.length >= sampleCount ? selectedCandidates = simpleCandidates.sort((a, b) => a.complexity - b.complexity).slice(0, sampleCount) : selectedCandidates = analyzedCandidates.sort((a, b) => a.complexity - b.complexity).slice(0, sampleCount);
+  let avgComplexity = selectedCandidates.length > 0 ? Number(
+    (selectedCandidates.reduce((acc, curr) => acc + curr.complexity, 0) / selectedCandidates.length).toFixed(2)
+  ) : 0;
+  return {
+    candidates: selectedCandidates.map(({ file }) => file),
+    analyzedCount: analyzedCandidates.length,
+    avgComplexity
+  };
+}
+async function getComponentCandidates({
+  sampleSize = 20,
+  globPattern = "**/*.{tsx,jsx}"
+} = {}) {
+  let globMatchCount = 0;
+  try {
+    let files = [];
+    if (files = await glob(globPattern, {
+      cwd: process.cwd(),
+      absolute: !0,
+      ignore: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/__mocks__/**",
+        "**/build/**",
+        "**/storybook-static/**",
+        "**/*.test.*",
+        "**/*.d.*",
+        "**/*.config.*",
+        "**/*.spec.*",
+        "**/*.stories.*",
+        // skip example story files that come from the CLI
+        "**/stories/{Button,Header,Page}.*",
+        "**/stories/{button,header,page}.*"
+      ]
+    }), globMatchCount = files.length, globMatchCount === 0)
+      return {
+        candidates: [],
+        globMatchCount
+      };
+    let { analyzedCount, avgComplexity, candidates } = await getCandidatesForStorybook(
+      files,
+      sampleSize
+    );
+    return {
+      analyzedCount,
+      avgComplexity,
+      candidates,
+      globMatchCount
+    };
+  } catch (error) {
+    let errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      candidates: [],
+      error: "Failed to find candidates",
+      globMatchCount
+    };
+  }
+}
+
+// src/core-server/utils/ghost-stories/run-story-tests.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile as readFile3 } from "node:fs/promises";
+import { executeCommand, resolvePathInStorybookCache } from "storybook/internal/common";
+
+// src/shared/utils/categorize-render-errors.ts
+var ERROR_CATEGORIES = {
+  MISSING_PROVIDER: "MISSING_PROVIDER",
+  MISSING_STATE_PROVIDER: "MISSING_STATE_PROVIDER",
+  MISSING_ROUTER_PROVIDER: "MISSING_ROUTER_PROVIDER",
+  MISSING_THEME_PROVIDER: "MISSING_THEME_PROVIDER",
+  MISSING_TRANSLATION_PROVIDER: "MISSING_TRANSLATION_PROVIDER",
+  MISSING_PORTAL_ROOT: "MISSING_PORTAL_ROOT",
+  HOOK_USAGE_ERROR: "HOOK_USAGE_ERROR",
+  MODULE_IMPORT_ERROR: "MODULE_IMPORT_ERROR",
+  COMPONENT_RENDER_ERROR: "COMPONENT_RENDER_ERROR",
+  SERVER_COMPONENTS_ERROR: "SERVER_COMPONENTS_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+function buildErrorContext(message, stack) {
+  let normalizedMessage = message.toLowerCase(), normalizedStack = (stack ?? "").toLowerCase(), stackDeps = /* @__PURE__ */ new Set(), stackLines = normalizedStack.split(`
+`).filter(Boolean);
+  for (let line of stackLines) {
+    let depMatch = line.match(/\/deps\/([^:]+)\.js/);
+    depMatch && stackDeps.add(depMatch[1]);
+  }
+  return {
+    message,
+    stack,
+    normalizedMessage,
+    normalizedStack,
+    stackDeps
+  };
+}
+var CATEGORIZATION_RULES = [
+  {
+    category: ERROR_CATEGORIES.MODULE_IMPORT_ERROR,
+    priority: 100,
+    match: (ctx) => ctx.normalizedMessage.includes("cannot find module") || ctx.normalizedMessage.includes("module not found") || ctx.normalizedMessage.includes("cannot resolve module")
+  },
+  {
+    category: ERROR_CATEGORIES.HOOK_USAGE_ERROR,
+    priority: 90,
+    match: (ctx) => ctx.normalizedMessage.includes("invalid hook call") || ctx.normalizedMessage.includes("rendered more hooks than") || ctx.normalizedMessage.includes("hooks can only be called")
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_STATE_PROVIDER,
+    priority: 85,
+    match: (ctx) => Array.from(ctx.stackDeps).some(isStateManagementPackage) && (ctx.normalizedMessage.includes("context") || ctx.normalizedMessage.includes("undefined") || ctx.normalizedMessage.includes("null"))
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_ROUTER_PROVIDER,
+    priority: 85,
+    match: (ctx) => Array.from(ctx.stackDeps).some(isRouterPackage) || ctx.normalizedMessage.includes("usenavigate") || ctx.normalizedMessage.includes("router")
+  },
+  {
+    category: ERROR_CATEGORIES.SERVER_COMPONENTS_ERROR,
+    priority: 85,
+    match: (ctx) => ctx.normalizedMessage.includes("server components") || ctx.normalizedMessage.includes("use client") || ctx.normalizedMessage.includes("async/await") && ctx.normalizedMessage.includes("not supported")
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_THEME_PROVIDER,
+    priority: 80,
+    match: (ctx) => Array.from(ctx.stackDeps).some(isStylingPackage) && (ctx.normalizedMessage.includes("theme") || ctx.normalizedMessage.includes("undefined")) || ctx.normalizedMessage.includes("usetheme") || ctx.normalizedMessage.includes("theme") && ctx.normalizedMessage.includes("provider")
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_TRANSLATION_PROVIDER,
+    priority: 80,
+    match: (ctx) => Array.from(ctx.stackDeps).some(isI18nPackage) || ctx.normalizedMessage.includes("i18n") || ctx.normalizedMessage.includes("translation") || ctx.normalizedMessage.includes("locale")
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_PORTAL_ROOT,
+    priority: 70,
+    match: (ctx) => ctx.normalizedMessage.includes("portal") && (ctx.normalizedMessage.includes("container") || ctx.normalizedMessage.includes("root")) && (ctx.normalizedMessage.includes("null") || ctx.normalizedMessage.includes("not found"))
+  },
+  {
+    category: ERROR_CATEGORIES.MISSING_PROVIDER,
+    priority: 60,
+    match: (ctx) => ctx.normalizedMessage.includes("use") && ctx.normalizedMessage.includes("provider") || ctx.normalizedMessage.includes("<provider>") || (ctx.normalizedMessage.includes("could not find") || ctx.normalizedMessage.includes("missing")) && ctx.normalizedMessage.includes("context") || ctx.normalizedMessage.includes("usecontext") && (ctx.normalizedMessage.includes("null") || ctx.normalizedMessage.includes("undefined"))
+  },
+  {
+    category: ERROR_CATEGORIES.COMPONENT_RENDER_ERROR,
+    priority: 10,
+    match: (ctx) => ctx.normalizedMessage.includes("cannot read") || ctx.normalizedMessage.includes("undefined is not a function") || ctx.normalizedMessage.includes("render")
+  }
+], RULES = CATEGORIZATION_RULES.sort((a, b) => b.priority - a.priority);
+function categorizeError(message, stack) {
+  let ctx = buildErrorContext(message, stack), rule = RULES.find((r) => r.match(ctx));
+  if (!rule)
+    return { category: ERROR_CATEGORIES.UNKNOWN_ERROR, matchedDependencies: [] };
+  let matchedDependencies = getMatchedDependencies(rule.category, ctx);
+  return { category: rule.category, matchedDependencies };
+}
+function getMatchedDependencies(category, ctx) {
+  switch (category) {
+    case ERROR_CATEGORIES.MISSING_STATE_PROVIDER:
+      return Array.from(ctx.stackDeps).filter(isStateManagementPackage);
+    case ERROR_CATEGORIES.MISSING_ROUTER_PROVIDER:
+      return Array.from(ctx.stackDeps).filter(isRouterPackage);
+    case ERROR_CATEGORIES.MISSING_THEME_PROVIDER:
+      return Array.from(ctx.stackDeps).filter(isStylingPackage);
+    case ERROR_CATEGORIES.MISSING_TRANSLATION_PROVIDER:
+      return Array.from(ctx.stackDeps).filter(isI18nPackage);
+    default:
+      return [];
+  }
+}
+function getCategoryDescription(category) {
+  switch (category) {
+    case ERROR_CATEGORIES.MISSING_STATE_PROVIDER:
+      return "Component attempted to access shared state without a state management provider";
+    case ERROR_CATEGORIES.MISSING_ROUTER_PROVIDER:
+      return "Component attempted to access routing context without a router provider";
+    case ERROR_CATEGORIES.MISSING_THEME_PROVIDER:
+      return "Component attempted to access theme values without a theme provider";
+    case ERROR_CATEGORIES.MISSING_TRANSLATION_PROVIDER:
+      return "Component attempted to access translations without a translation provider";
+    case ERROR_CATEGORIES.MISSING_PROVIDER:
+      return "Component attempted to access React context without a matching provider";
+    case ERROR_CATEGORIES.MISSING_PORTAL_ROOT:
+      return "Component attempted to render a portal without a valid DOM container";
+    case ERROR_CATEGORIES.HOOK_USAGE_ERROR:
+      return "React hook was used incorrectly";
+    case ERROR_CATEGORIES.MODULE_IMPORT_ERROR:
+      return "A required dependency could not be resolved";
+    case ERROR_CATEGORIES.COMPONENT_RENDER_ERROR:
+      return "Component failed during render due to a runtime error";
+    case ERROR_CATEGORIES.SERVER_COMPONENTS_ERROR:
+      return "Server components usage in the browser";
+    default:
+      return "Error could not be categorized";
+  }
+}
+
+// src/core-server/utils/ghost-stories/parse-vitest-report.ts
+function extractCategorizedErrors(testResults) {
+  let failed = testResults.filter((r) => r.status === "FAIL" && r.error), map = /* @__PURE__ */ new Map(), uniqueErrorMessages = /* @__PURE__ */ new Set();
+  for (let r of failed) {
+    let { category, matchedDependencies } = categorizeError(r.error, r.stack);
+    map.has(category) || map.set(category, { count: 0, matchedDependencies: /* @__PURE__ */ new Set() });
+    let data = map.get(category);
+    data.count++, matchedDependencies.forEach((dep) => data.matchedDependencies.add(dep)), uniqueErrorMessages.add(r.error);
+  }
+  let categorizedErrors = Array.from(map.entries()).reduce(
+    (acc, [category, data]) => (acc[category] = {
+      description: getCategoryDescription(category),
+      count: data.count,
+      matchedDependencies: Array.from(data.matchedDependencies).sort()
+    }, acc),
+    {}
+  );
+  return {
+    totalErrors: failed.length,
+    uniqueErrorCount: uniqueErrorMessages.size,
+    categorizedErrors
+  };
+}
+function parseVitestResults(testResults) {
+  let storyTestResults = [], passedButEmptyRender = 0;
+  for (let testSuite of testResults.testResults)
+    for (let assertion of testSuite.assertionResults) {
+      let storyId = assertion.meta?.storyId || assertion.fullName, status = assertion.status === "passed" ? "PASS" : assertion.status === "failed" ? "FAIL" : "PENDING", hasEmptyRender = assertion.meta?.reports?.some(
+        (report) => report.type === "render-analysis" && report.result?.emptyRender === !0
+      );
+      status === "PASS" && hasEmptyRender && passedButEmptyRender++;
+      let error, stack;
+      assertion.failureMessages && assertion.failureMessages.length > 0 && (stack = assertion.failureMessages[0], error = stack?.split(`
+`)[0]), storyTestResults.push({
+        storyId,
+        status,
+        error,
+        stack
+      });
+    }
+  let total = testResults.numTotalTests, passed = testResults.numPassedTests, failed = testResults.numFailedTests, successRate = total > 0 ? parseFloat((passed / total).toFixed(2)) : 0, failureRate = total > 0 ? parseFloat((failed / total).toFixed(2)) : 0, successRateWithoutEmptyRender = total > 0 ? parseFloat(((passed - passedButEmptyRender) / total).toFixed(2)) : 0, errorClassification = extractCategorizedErrors(storyTestResults), categorizedErrors = errorClassification.categorizedErrors, summary = {
+    total,
+    passed,
+    passedButEmptyRender,
+    failed,
+    successRate,
+    successRateWithoutEmptyRender,
+    failureRate,
+    uniqueErrorCount: errorClassification.uniqueErrorCount,
+    categorizedErrors
+  };
+  return {
+    success: testResults.success,
+    summary
+  };
+}
+
+// src/core-server/utils/ghost-stories/run-story-tests.ts
+async function runStoryTests(componentFilePaths) {
+  try {
+    let cacheDir = resolvePathInStorybookCache("ghost-stories-tests");
+    await mkdir(cacheDir, { recursive: !0 });
+    let timestamp = Date.now(), outputFile = join(cacheDir, `test-results-${timestamp}.json`), startTime = Date.now(), testFailureMessage;
+    try {
+      await executeCommand({
+        command: "npx",
+        args: [
+          "vitest",
+          "run",
+          "--reporter=json",
+          "--testTimeout=1000",
+          `--outputFile=${outputFile}`,
+          ...componentFilePaths
+        ],
+        stdio: "pipe",
+        env: {
+          STORYBOOK_COMPONENT_PATHS: componentFilePaths.join(";")
+        }
+      });
+    } catch (error) {
+      let errorMessage = (error.stderr || String(error) || "").toLowerCase();
+      errorMessage.includes("browsertype.launch") ? testFailureMessage = "Playwright is not installed" : errorMessage.includes("startup error") ? testFailureMessage = "Startup Error" : errorMessage.includes("no tests found") ? testFailureMessage = "No tests found" : errorMessage.includes("test timeout") ? testFailureMessage = "Test timeout" : errorMessage.includes("react-native-web") ? testFailureMessage = "React Native Web error" : errorMessage.includes("unhandled rejection") && (testFailureMessage = "Unhandled Rejection");
+    }
+    let duration = Date.now() - startTime;
+    if (testFailureMessage)
+      return {
+        success: !1,
+        duration,
+        error: testFailureMessage
+      };
+    if (!existsSync(outputFile))
+      return {
+        success: !1,
+        duration,
+        error: "JSON report not found"
+      };
+    let testResults;
+    try {
+      let resultsJson = await readFile3(outputFile, "utf8");
+      testResults = JSON.parse(resultsJson);
+    } catch {
+      return {
+        success: !1,
+        duration,
+        error: "Failed to read or parse JSON report"
+      };
+    }
+    return { ...parseVitestResults(testResults), duration };
+  } catch {
+    return {
+      success: !1,
+      error: "Uncaught error running story tests",
+      duration: 0
+    };
+  }
+}
+
+// src/core-server/server-channel/ghost-stories-channel.ts
+function initGhostStoriesChannel(channel, options, coreOptions) {
+  return coreOptions.disableTelemetry || channel.on(GHOST_STORIES_REQUEST, async () => {
+    let stats = {};
+    try {
+      let ghostRunStart = Date.now(), lastEvents = await getLastEvents(), sessionId = await getSessionId(), lastInit = lastEvents?.init;
+      if (lastEvents?.["ghost-stories"] || lastInit?.body?.sessionId && lastInit?.body?.sessionId !== sessionId)
+        return;
+      let metadata = await getStorybookMetadata(options.configDir), isReactStorybook = metadata?.renderer?.includes("@storybook/react"), hasVitestAddon = !!metadata?.addons && Object.keys(metadata.addons).some(
+        (addonKey) => addonKey.includes("@storybook/addon-vitest")
+      );
+      if (!isReactStorybook || !hasVitestAddon)
+        return;
+      let candidateAnalysisStart = Date.now(), candidatesResult = await getComponentCandidates();
+      if (stats.candidateAnalysisDuration = Date.now() - candidateAnalysisStart, stats.globMatchCount = candidatesResult.globMatchCount, stats.analyzedCount = candidatesResult.analyzedCount ?? 0, stats.avgComplexity = candidatesResult.avgComplexity ?? 0, stats.candidateCount = candidatesResult.candidates.length, candidatesResult.error) {
+        stats.totalRunDuration = Date.now() - ghostRunStart, telemetry3("ghost-stories", {
+          success: !1,
+          error: candidatesResult.error,
+          stats
+        });
+        return;
+      }
+      if (candidatesResult.candidates.length === 0) {
+        stats.totalRunDuration = Date.now() - ghostRunStart, telemetry3("ghost-stories", {
+          success: !1,
+          error: "No candidates found",
+          stats
+        });
+        return;
+      }
+      let testRunResult = await runStoryTests(candidatesResult.candidates);
+      stats.totalRunDuration = Date.now() - ghostRunStart, stats.testRunDuration = testRunResult.duration, telemetry3("ghost-stories", {
+        ...testRunResult.error !== void 0 ? { error: testRunResult.error } : {},
+        success: testRunResult.success,
+        stats,
+        results: testRunResult.summary
+      });
+    } catch (error) {
+      let errorMessage = error instanceof Error ? error.message : String(error);
+      telemetry3("ghost-stories", {
+        success: !1,
+        error: errorMessage,
+        stats
+      });
+    } finally {
+      channel.emit(GHOST_STORIES_RESPONSE);
+    }
+  }), channel;
+}
+
 // src/core-server/server-channel/open-in-editor-channel.ts
 var import_launch_editor = __toESM(require_launch_editor(), 1);
 import { OPEN_IN_EDITOR_REQUEST, OPEN_IN_EDITOR_RESPONSE } from "storybook/internal/core-events";
-import { telemetry as telemetry3 } from "storybook/internal/telemetry";
+import { telemetry as telemetry4 } from "storybook/internal/telemetry";
 async function initOpenInEditorChannel(channel, _options, coreOptions) {
   return channel.on(OPEN_IN_EDITOR_REQUEST, async (payload) => {
     let sendTelemetry = (data) => {
-      coreOptions.disableTelemetry || telemetry3("open-in-editor", data);
+      coreOptions.disableTelemetry || telemetry4("open-in-editor", data);
     };
     try {
       let { file: targetFile, line, column } = payload;
@@ -890,9 +1188,9 @@ async function initOpenInEditorChannel(channel, _options, coreOptions) {
 
 // src/core-server/server-channel/preview-initialized-channel.ts
 import { PREVIEW_INITIALIZED } from "storybook/internal/core-events";
-import { telemetry as telemetry4 } from "storybook/internal/telemetry";
-import { getLastEvents } from "storybook/internal/telemetry";
-import { getSessionId } from "storybook/internal/telemetry";
+import { telemetry as telemetry5 } from "storybook/internal/telemetry";
+import { getLastEvents as getLastEvents2 } from "storybook/internal/telemetry";
+import { getSessionId as getSessionId2 } from "storybook/internal/telemetry";
 var makePayload = (userAgent, lastInit, sessionId) => {
   let payload = {
     userAgent,
@@ -905,10 +1203,10 @@ function initPreviewInitializedChannel(channel, options, _coreConfig) {
   channel.on(PREVIEW_INITIALIZED, async ({ userAgent }) => {
     if (!options.disableTelemetry)
       try {
-        let sessionId = await getSessionId(), lastEvents = await getLastEvents(), lastInit = lastEvents.init;
+        let sessionId = await getSessionId2(), lastEvents = await getLastEvents2(), lastInit = lastEvents.init;
         if (!lastEvents["preview-first-load"]) {
           let payload = makePayload(userAgent, lastInit, sessionId);
-          telemetry4("preview-first-load", payload);
+          telemetry5("preview-first-load", payload);
         }
       } catch {
       }
@@ -916,10 +1214,10 @@ function initPreviewInitializedChannel(channel, options, _coreConfig) {
 }
 
 // src/core-server/utils/checklist.ts
-import { createFileSystemCache, resolvePathInStorybookCache } from "storybook/internal/common";
+import { createFileSystemCache, resolvePathInStorybookCache as resolvePathInStorybookCache2 } from "storybook/internal/common";
 import { experimental_UniversalStore } from "storybook/internal/core-server";
 import { logger } from "storybook/internal/node-logger";
-import { telemetry as telemetry5 } from "storybook/internal/telemetry";
+import { telemetry as telemetry6 } from "storybook/internal/telemetry";
 
 // ../../node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
 function isPrimitive(value) {
@@ -1040,7 +1338,7 @@ async function initializeChecklist() {
       ...UNIVERSAL_CHECKLIST_STORE_OPTIONS,
       leader: !0
     }), cache = createFileSystemCache({
-      basePath: resolvePathInStorybookCache("checklist"),
+      basePath: resolvePathInStorybookCache2("checklist"),
       ns: "storybook"
     }), [[userState, saveUserState], [projectState, saveProjectState]] = await Promise.all([
       globalSettings().then((settings) => {
@@ -1077,13 +1375,13 @@ async function initializeChecklist() {
         },
         { mutedItems: [], statusItems: [] }
       );
-      mutedItems.length > 0 && telemetry5("onboarding-checklist-muted", {
+      mutedItems.length > 0 && telemetry6("onboarding-checklist-muted", {
         items: mutedItems,
         completedItems: entries.reduce((acc, [id, { status }]) => status === "done" || status === "accepted" ? acc.concat([id]) : acc, []),
         skippedItems: entries.reduce((acc, [id, { status }]) => status === "skipped" ? acc.concat([id]) : acc, [])
       }), statusItems.forEach((item) => {
         let { status } = state.items[item];
-        telemetry5("onboarding-checklist-status", { item, status });
+        telemetry6("onboarding-checklist-status", { item, status });
       });
     });
   } catch (err) {
@@ -1100,8 +1398,8 @@ var defaultStaticDirs = [
 ], defaultFavicon = join(resolvePackageDir("storybook"), "assets/browser/favicon.svg");
 
 // src/core-server/utils/save-story/save-story.ts
-import { writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename2, join as join4 } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
 import { formatFileContent } from "storybook/internal/common";
 import {
   SAVE_STORY_REQUEST,
@@ -1111,10 +1409,10 @@ import {
 import { storyNameFromExport, toId } from "storybook/internal/csf";
 import { printCsf, readCsf } from "storybook/internal/csf-tools";
 import { logger as logger2 } from "storybook/internal/node-logger";
-import { isExampleStoryId, telemetry as telemetry6 } from "storybook/internal/telemetry";
+import { isExampleStoryId, telemetry as telemetry7 } from "storybook/internal/telemetry";
 
 // src/core-server/utils/save-story/duplicate-story-with-new-name.ts
-import { types as t2, traverse } from "storybook/internal/babel";
+import { types as t2, traverse as traverse2 } from "storybook/internal/babel";
 
 // src/core-server/utils/save-story/utils.ts
 var SaveStoryError = class extends Error {
@@ -1126,7 +1424,7 @@ var duplicateStoryWithNewName = (csfFile, storyName, newStoryName) => {
   if (!cloned)
     throw new SaveStoryError("cannot clone Node");
   let found = !1;
-  if (traverse(cloned, {
+  if (traverse2(cloned, {
     Identifier(path) {
       found || path.node.name === storyName && (found = !0, path.node.name = newStoryName);
     },
@@ -1137,7 +1435,7 @@ var duplicateStoryWithNewName = (csfFile, storyName, newStoryName) => {
     noScope: !0
   }), !(t2.isCallExpression(cloned.init) && t2.isMemberExpression(cloned.init.callee) && t2.isIdentifier(cloned.init.callee.property) && cloned.init.callee.property.name === "story") && (t2.isArrowFunctionExpression(cloned.init) || t2.isCallExpression(cloned.init)))
     throw new SaveStoryError("Creating a new story based on a CSF2 story is not supported");
-  return traverse(csfFile._ast, {
+  return traverse2(csfFile._ast, {
     Program(path) {
       path.pushContainer(
         "body",
@@ -1148,7 +1446,7 @@ var duplicateStoryWithNewName = (csfFile, storyName, newStoryName) => {
 };
 
 // src/core-server/utils/save-story/update-args-in-csf-file.ts
-import { types as t4, traverse as traverse2 } from "storybook/internal/babel";
+import { types as t4, traverse as traverse3 } from "storybook/internal/babel";
 
 // src/core-server/utils/save-story/valueToAST.ts
 import { parser as parser2, types as t3 } from "storybook/internal/babel";
@@ -1221,7 +1519,7 @@ var updateArgsInCsfFile = async (node, input) => {
       );
     return;
   }
-  traverse2(node, {
+  traverse3(node, {
     ObjectExpression(path) {
       if (found)
         return;
@@ -1279,7 +1577,7 @@ function initializeSaveStory(channel, options, coreConfig) {
   channel.on(SAVE_STORY_REQUEST, async ({ id, payload }) => {
     let { csfId, importPath, args, name } = payload, newStoryId, newStoryName, sourceFileName, sourceFilePath, sourceStoryName;
     try {
-      sourceFileName = basename2(importPath), sourceFilePath = join4(process.cwd(), importPath);
+      sourceFileName = basename(importPath), sourceFilePath = join3(process.cwd(), importPath);
       let csf = await readCsf(sourceFilePath, {
         makeTitle: (userTitle) => userTitle || "myTitle"
       }), parsed = csf.parse(), stories = Object.entries(parsed._stories), [componentId, storyId] = csfId.split("--");
@@ -1301,7 +1599,7 @@ function initializeSaveStory(channel, options, coreConfig) {
         new Promise((resolve) => {
           channel.on(STORY_RENDERED, resolve), setTimeout(() => resolve(channel.off(STORY_RENDERED, resolve)), 3e3);
         }),
-        writeFile2(sourceFilePath, code)
+        writeFile(sourceFilePath, code)
       ]), channel.emit(SAVE_STORY_RESPONSE, {
         id,
         success: !0,
@@ -1318,7 +1616,7 @@ function initializeSaveStory(channel, options, coreConfig) {
         error: null
       });
       let isCLIExample = isExampleStoryId(newStoryId ?? csfId);
-      !coreConfig.disableTelemetry && !isCLIExample && await telemetry6("save-story", {
+      !coreConfig.disableTelemetry && !isCLIExample && await telemetry7("save-story", {
         action: name ? "createStory" : "updateStory",
         success: !0
       });
@@ -1330,7 +1628,7 @@ function initializeSaveStory(channel, options, coreConfig) {
       }), logger2.error(
         `Error writing to ${sourceFilePath}:
 ${error.stack || error.message || error.toString()}`
-      ), !coreConfig.disableTelemetry && !(error instanceof SaveStoryError) && await telemetry6("save-story", {
+      ), !coreConfig.disableTelemetry && !(error instanceof SaveStoryError) && await telemetry7("save-story", {
         action: name ? "createStory" : "updateStory",
         success: !1,
         error
@@ -1340,8 +1638,8 @@ ${error.stack || error.message || error.toString()}`
 }
 
 // src/core-server/utils/whats-new.ts
-import { writeFile as writeFile3 } from "node:fs/promises";
-import { findConfigFile as findConfigFile2, loadMainConfig } from "storybook/internal/common";
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { findConfigFile, loadMainConfig } from "storybook/internal/common";
 import {
   REQUEST_WHATS_NEW_DATA,
   RESULT_WHATS_NEW_DATA,
@@ -1351,7 +1649,7 @@ import {
 } from "storybook/internal/core-events";
 import { printConfig, readConfig } from "storybook/internal/csf-tools";
 import { logger as logger3 } from "storybook/internal/node-logger";
-import { telemetry as telemetry7 } from "storybook/internal/telemetry";
+import { telemetry as telemetry8 } from "storybook/internal/telemetry";
 var WHATS_NEW_CACHE = "whats-new-cache", WHATS_NEW_URL = "https://storybook.js.org/whats-new/v1";
 function initializeWhatsNew(channel, options, coreOptions) {
   channel.on(SET_WHATS_NEW_CACHE, async (data) => {
@@ -1381,14 +1679,14 @@ function initializeWhatsNew(channel, options, coreOptions) {
     async ({ disableWhatsNewNotifications }) => {
       let isTelemetryEnabled = coreOptions.disableTelemetry !== !0;
       try {
-        let mainPath = findConfigFile2("main", options.configDir);
+        let mainPath = findConfigFile("main", options.configDir);
         invariant(mainPath, `unable to find Storybook main file in ${options.configDir}`);
         let main = await readConfig(mainPath);
         if (!main._exportsObject)
           throw new Error(
             "Unable to parse Storybook main file while trying to read 'core' property"
           );
-        main.setFieldValue(["core", "disableWhatsNewNotifications"], disableWhatsNewNotifications), await writeFile3(mainPath, printConfig(main).code), isTelemetryEnabled && await telemetry7("core-config", { disableWhatsNewNotifications });
+        main.setFieldValue(["core", "disableWhatsNewNotifications"], disableWhatsNewNotifications), await writeFile2(mainPath, printConfig(main).code), isTelemetryEnabled && await telemetry8("core-config", { disableWhatsNewNotifications });
       } catch (error) {
         invariant(error instanceof Error), isTelemetryEnabled && await sendTelemetryError(error, "core-config", {
           cliOptions: options,
@@ -1419,9 +1717,9 @@ var interpolate = (string, data = {}) => Object.entries(data).reduce((acc, [k, v
       workingDir: process.cwd(),
       directory: dir
     }) : dir, { staticPath, targetEndpoint } = parseStaticDir(normalizedDir);
-    return ["/favicon.svg", "/favicon.ico"].includes(targetEndpoint) && results.push(staticPath), targetEndpoint === "/" && (results.push(join(staticPath, "favicon.svg")), results.push(join(staticPath, "favicon.ico"))), results.filter((path) => existsSync3(path));
+    return ["/favicon.svg", "/favicon.ico"].includes(targetEndpoint) && results.push(staticPath), targetEndpoint === "/" && (results.push(join(staticPath, "favicon.svg")), results.push(join(staticPath, "favicon.ico"))), results.filter((path) => existsSync2(path));
   }).reduce((l1, l2) => l1.concat(l2), []);
-  return faviconPaths.length > 1 && logger4.warn(import_ts_dedent4.dedent`
+  return faviconPaths.length > 1 && logger4.warn(import_ts_dedent.dedent`
       Looks like multiple favicons were detected. Using the first one.
 
       ${faviconPaths.join(", ")}
@@ -1478,7 +1776,7 @@ var interpolate = (string, data = {}) => Object.entries(data).reduce((acc, [k, v
   let removeAddon = removeAddonBase, packageManager = JsPackageManagerFactory.getPackageManager({
     configDir: options.configDir
   });
-  return options.disableTelemetry || (removeAddon = async (id, opts) => (await telemetry8("remove", { addon: id, source: "api" }), removeAddonBase(id, { ...opts, packageManager }))), { ...extension, removeAddon };
+  return options.disableTelemetry || (removeAddon = async (id, opts) => (await telemetry9("remove", { addon: id, source: "api" }), removeAddonBase(id, { ...opts, packageManager }))), { ...extension, removeAddon };
 }, core = async (existing, options) => ({
   ...existing,
   disableTelemetry: options.disableTelemetry === !0,
@@ -1505,14 +1803,14 @@ var interpolate = (string, data = {}) => Object.entries(data).reduce((acc, [k, v
   return typeof config == "string" ? {} : typeof config > "u" ? null : config.options;
 }, managerHead = async (_, options) => {
   let location = join(options.configDir, "manager-head.html");
-  if (existsSync3(location)) {
-    let contents = readFile3(location, { encoding: "utf8" }), interpolations = options.presets.apply("env");
+  if (existsSync2(location)) {
+    let contents = readFile4(location, { encoding: "utf8" }), interpolations = options.presets.apply("env");
     return interpolate(await contents, await interpolations);
   }
   return "";
 }, experimental_serverChannel = async (channel, options) => {
   let coreOptions = await options.presets.apply("core");
-  return initializeChecklist(), initializeWhatsNew(channel, options, coreOptions), initializeSaveStory(channel, options, coreOptions), initFileSearchChannel(channel, options, coreOptions), initCreateNewStoryChannel(channel, options, coreOptions), initOpenInEditorChannel(channel, options, coreOptions), initPreviewInitializedChannel(channel, options, coreOptions), channel;
+  return initializeChecklist(), initializeWhatsNew(channel, options, coreOptions), initializeSaveStory(channel, options, coreOptions), initFileSearchChannel(channel, options, coreOptions), initCreateNewStoryChannel(channel, options, coreOptions), initGhostStoriesChannel(channel, options, coreOptions), initOpenInEditorChannel(channel, options, coreOptions), initPreviewInitializedChannel(channel, options, coreOptions), channel;
 }, resolvedReact = async (existing) => {
   try {
     return {