@storybook/react 10.1.0-alpha.3 → 10.1.0-alpha.5

package/dist/preset.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_eqmqwiqjsm4 from 'node:url';
-import CJS_COMPAT_NODE_PATH_eqmqwiqjsm4 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_eqmqwiqjsm4 from "node:module";
+import CJS_COMPAT_NODE_URL_31a066znggx from 'node:url';
+import CJS_COMPAT_NODE_PATH_31a066znggx from 'node:path';
+import CJS_COMPAT_NODE_MODULE_31a066znggx from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_eqmqwiqjsm4.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_eqmqwiqjsm4.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_eqmqwiqjsm4.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_31a066znggx.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_31a066znggx.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_31a066znggx.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -1588,13 +1588,13 @@ var require_tsconfig_loader = __commonJS({
   "../../node_modules/tsconfig-paths/lib/tsconfig-loader.js"(exports) {
     "use strict";
     var __assign = exports && exports.__assign || function() {
-      __assign = Object.assign || function(t4) {
+      __assign = Object.assign || function(t5) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
           for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t4[p] = s[p];
+            t5[p] = s[p];
         }
-        return t4;
+        return t5;
       };
       return __assign.apply(this, arguments);
     };
@@ -1662,19 +1662,19 @@ var require_tsconfig_loader = __commonJS({
     }
     __name(walkForTsConfig, "walkForTsConfig");
     exports.walkForTsConfig = walkForTsConfig;
-    function loadTsconfig(configFilePath, existsSync3, readFileSync) {
+    function loadTsconfig(configFilePath, existsSync3, readFileSync2) {
       if (existsSync3 === void 0) {
         existsSync3 = fs.existsSync;
       }
-      if (readFileSync === void 0) {
-        readFileSync = /* @__PURE__ */ __name(function(filename) {
+      if (readFileSync2 === void 0) {
+        readFileSync2 = /* @__PURE__ */ __name(function(filename) {
           return fs.readFileSync(filename, "utf8");
         }, "readFileSync");
       }
       if (!existsSync3(configFilePath)) {
         return void 0;
       }
-      var configString = readFileSync(configFilePath);
+      var configString = readFileSync2(configFilePath);
       var cleanedJson = StripBom(configString);
       var config;
       try {
@@ -1687,10 +1687,10 @@ var require_tsconfig_loader = __commonJS({
         var base = void 0;
         if (Array.isArray(extendedConfig)) {
           base = extendedConfig.reduce(function(currBase, extendedConfigElement) {
-            return mergeTsconfigs(currBase, loadTsconfigFromExtends(configFilePath, extendedConfigElement, existsSync3, readFileSync));
+            return mergeTsconfigs(currBase, loadTsconfigFromExtends(configFilePath, extendedConfigElement, existsSync3, readFileSync2));
           }, {});
         } else {
-          base = loadTsconfigFromExtends(configFilePath, extendedConfig, existsSync3, readFileSync);
+          base = loadTsconfigFromExtends(configFilePath, extendedConfig, existsSync3, readFileSync2);
         }
         return mergeTsconfigs(base, config);
       }
@@ -1698,7 +1698,7 @@ var require_tsconfig_loader = __commonJS({
     }
     __name(loadTsconfig, "loadTsconfig");
     exports.loadTsconfig = loadTsconfig;
-    function loadTsconfigFromExtends(configFilePath, extendedConfigValue, existsSync3, readFileSync) {
+    function loadTsconfigFromExtends(configFilePath, extendedConfigValue, existsSync3, readFileSync2) {
       var _a;
       if (typeof extendedConfigValue === "string" && extendedConfigValue.indexOf(".json") === -1) {
         extendedConfigValue += ".json";
@@ -1708,7 +1708,7 @@ var require_tsconfig_loader = __commonJS({
       if (extendedConfigValue.indexOf("/") !== -1 && extendedConfigValue.indexOf(".") !== -1 && !existsSync3(extendedConfigPath)) {
         extendedConfigPath = path2.join(currentDir, "node_modules", extendedConfigValue);
       }
-      var config = loadTsconfig(extendedConfigPath, existsSync3, readFileSync) || {};
+      var config = loadTsconfig(extendedConfigPath, existsSync3, readFileSync2) || {};
       if ((_a = config.compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl) {
         var extendsDir = path2.dirname(extendedConfigValue);
         config.compilerOptions.baseUrl = path2.join(extendsDir, config.compilerOptions.baseUrl);
@@ -2095,14 +2095,14 @@ var require_register = __commonJS({
         console.warn("".concat(configLoaderResult.message, ". tsconfig-paths will be skipped"));
         return noOp;
       }
-      var matchPath = (0, match_path_sync_1.createMatchPath)(configLoaderResult.absoluteBaseUrl, configLoaderResult.paths, configLoaderResult.mainFields, configLoaderResult.addMatchAll);
+      var matchPath2 = (0, match_path_sync_1.createMatchPath)(configLoaderResult.absoluteBaseUrl, configLoaderResult.paths, configLoaderResult.mainFields, configLoaderResult.addMatchAll);
       var Module = __require("module");
       var originalResolveFilename = Module._resolveFilename;
       var coreModules = getCoreModules(Module.builtinModules);
       Module._resolveFilename = function(request, _parent) {
         var isCoreModule = coreModules.hasOwnProperty(request);
         if (!isCoreModule) {
-          var found = matchPath(request);
+          var found = matchPath2(request);
           if (found) {
             var modifiedArguments = __spreadArray([found], [].slice.call(arguments, 1), true);
             return originalResolveFilename.apply(this, modifiedArguments);
@@ -2748,8 +2748,8 @@ var require_async = __commonJS({
         cb(null, x);
       }
     }, "maybeRealpath");
-    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile2, pkgfile, cb) {
-      readFile2(pkgfile, function(readFileErr, body) {
+    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile, pkgfile, cb) {
+      readFile(pkgfile, function(readFileErr, body) {
         if (readFileErr) cb(readFileErr);
         else {
           try {
@@ -2784,7 +2784,7 @@ var require_async = __commonJS({
       opts = normalizeOptions(x, opts);
       var isFile = opts.isFile || defaultIsFile;
       var isDirectory = opts.isDirectory || defaultIsDir;
-      var readFile2 = opts.readFile || fs.readFile;
+      var readFile = opts.readFile || fs.readFile;
       var realpath = opts.realpath || defaultRealpath;
       var readPackage = opts.readPackage || defaultReadPackage;
       if (opts.readFile && opts.readPackage) {
@@ -2910,7 +2910,7 @@ var require_async = __commonJS({
           var pkgfile = path2.join(pkgdir, "package.json");
           isFile(pkgfile, function(err2, ex) {
             if (!ex) return loadpkg(path2.dirname(dir), cb2);
-            readPackage(readFile2, pkgfile, function(err3, pkgParam) {
+            readPackage(readFile, pkgfile, function(err3, pkgParam) {
               if (err3) cb2(err3);
               var pkg = pkgParam;
               if (pkg && opts.packageFilter) {
@@ -2935,7 +2935,7 @@ var require_async = __commonJS({
           isFile(pkgfile, function(err2, ex) {
             if (err2) return cb2(err2);
             if (!ex) return loadAsFile(path2.join(x2, "index"), fpkg, cb2);
-            readPackage(readFile2, pkgfile, function(err3, pkgParam) {
+            readPackage(readFile, pkgfile, function(err3, pkgParam) {
               if (err3) return cb2(err3);
               var pkg = pkgParam;
               if (pkg && opts.packageFilter) {
@@ -3254,8 +3254,8 @@ var require_sync = __commonJS({
       }
       return x;
     }, "maybeRealpathSync");
-    var defaultReadPackageSync = /* @__PURE__ */ __name(function defaultReadPackageSync2(readFileSync, pkgfile) {
-      var body = readFileSync(pkgfile);
+    var defaultReadPackageSync = /* @__PURE__ */ __name(function defaultReadPackageSync2(readFileSync2, pkgfile) {
+      var body = readFileSync2(pkgfile);
       try {
         var pkg = JSON.parse(body);
         return pkg;
@@ -3275,7 +3275,7 @@ var require_sync = __commonJS({
       }
       var opts = normalizeOptions(x, options);
       var isFile = opts.isFile || defaultIsFile;
-      var readFileSync = opts.readFileSync || fs.readFileSync;
+      var readFileSync2 = opts.readFileSync || fs.readFileSync;
       var isDirectory = opts.isDirectory || defaultIsDir;
       var realpathSync = opts.realpathSync || defaultRealpathSync;
       var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
@@ -3333,7 +3333,7 @@ var require_sync = __commonJS({
         if (!isFile(pkgfile)) {
           return loadpkg(path2.dirname(dir));
         }
-        var pkg = readPackageSync(readFileSync, pkgfile);
+        var pkg = readPackageSync(readFileSync2, pkgfile);
         if (pkg && opts.packageFilter) {
           pkg = opts.packageFilter(
             pkg,
@@ -3348,7 +3348,7 @@ var require_sync = __commonJS({
         var pkgfile = path2.join(maybeRealpathSync(realpathSync, x2, opts), "/package.json");
         if (isFile(pkgfile)) {
           try {
-            var pkg = readPackageSync(readFileSync, pkgfile);
+            var pkg = readPackageSync(readFileSync2, pkgfile);
           } catch (e) {
           }
           if (pkg && opts.packageFilter) {
@@ -3962,19 +3962,66 @@ var resolvePackageDir = /* @__PURE__ */ __name((pkg, parent) => {
 }, "resolvePackageDir");
 
 // src/componentManifest/generator.ts
-import { readFile } from "node:fs/promises";
-import { recast } from "storybook/internal/babel";
-import { loadCsf } from "storybook/internal/csf-tools";
-import { extractDescription } from "storybook/internal/csf-tools";
+import { recast as recast2 } from "storybook/internal/babel";
+import { combineTags } from "storybook/internal/csf";
+import { extractDescription, loadCsf } from "storybook/internal/csf-tools";
+import { logger as logger3 } from "storybook/internal/node-logger";
 
 // src/componentManifest/generateCodeSnippet.ts
 import { types as t } from "storybook/internal/babel";
 
+// src/componentManifest/utils.ts
+import { readFileSync } from "node:fs";
+import { resolveImport } from "storybook/internal/common";
+import { logger } from "storybook/internal/node-logger";
+
+// ../../node_modules/empathic/find.mjs
+import { join as join3 } from "node:path";
+import { existsSync, statSync } from "node:fs";
+
+// ../../node_modules/empathic/walk.mjs
+import { dirname as dirname2 } from "node:path";
+
+// ../../node_modules/empathic/resolve.mjs
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+function absolute(input, root) {
+  return isAbsolute2(input) ? input : resolve2(root || ".", input);
+}
+__name(absolute, "absolute");
+
+// ../../node_modules/empathic/walk.mjs
+function up(base, options) {
+  let { last, cwd: cwd2 } = options || {};
+  let tmp = absolute(base, cwd2);
+  let root = absolute(last || "/", cwd2);
+  let prev, arr = [];
+  while (prev !== root) {
+    arr.push(tmp);
+    tmp = dirname2(prev = tmp);
+    if (tmp === prev) break;
+  }
+  return arr;
+}
+__name(up, "up");
+
+// ../../node_modules/empathic/find.mjs
+function up2(name, options) {
+  let dir, tmp;
+  let start = options && options.cwd || "";
+  for (dir of up(start, options)) {
+    tmp = join3(dir, name);
+    if (existsSync(tmp)) return tmp;
+  }
+}
+__name(up2, "up");
+
 // src/componentManifest/utils.ts
 var groupBy = /* @__PURE__ */ __name((items, keySelector) => {
   return items.reduce((acc = {}, item, index) => {
     const key = keySelector(item, index);
-    acc[key] ??= [];
+    if (!Array.isArray(acc[key])) {
+      acc[key] = [];
+    }
     acc[key].push(item);
     return acc;
   }, {});
@@ -3986,6 +4033,41 @@ function invariant(condition, message) {
   throw new Error((typeof message === "function" ? message() : message) ?? "Invariant failed");
 }
 __name(invariant, "invariant");
+var memoStore = /* @__PURE__ */ new WeakMap();
+var cached = /* @__PURE__ */ __name((fn, opts = {}) => {
+  const keyOf2 = opts.key ?? ((...args) => {
+    try {
+      return JSON.stringify(args);
+    } catch {
+      return String(args[0]);
+    }
+  });
+  return (...args) => {
+    const k = keyOf2(...args);
+    const name = fn.name || opts.name || "anonymous";
+    let store = memoStore.get(fn);
+    if (!store) {
+      store = /* @__PURE__ */ new Map();
+      memoStore.set(fn, store);
+    }
+    if (store.has(k)) {
+      logger.verbose(`[cache] hit ${name} key=${k}`);
+      return store.get(k);
+    }
+    const start = Date.now();
+    const result = fn(...args);
+    const duration = Date.now() - start;
+    store.set(k, result);
+    logger.verbose(`[cache] miss ${name} took ${duration}ms key=${k}`);
+    return result;
+  };
+}, "cached");
+var invalidateCache = /* @__PURE__ */ __name(() => {
+  memoStore = /* @__PURE__ */ new WeakMap();
+}, "invalidateCache");
+var cachedReadFileSync = cached(readFileSync, { name: "cachedReadFile" });
+var cachedFindUp = cached(up2, { name: "findUp" });
+var cachedResolveImport = cached(resolveImport, { name: "resolveImport" });
 
 // src/componentManifest/generateCodeSnippet.ts
 function getCodeSnippet(csf, storyName, componentName) {
@@ -4376,6 +4458,24 @@ function pathForNode(program, target) {
 }
 __name(pathForNode, "pathForNode");
 
+// src/componentManifest/getComponentImports.ts
+import { dirname as dirname4 } from "node:path";
+import { babelParse as babelParse2, recast, types as t3 } from "storybook/internal/babel";
+import { logger as logger2 } from "storybook/internal/node-logger";
+
+// src/componentManifest/reactDocgen.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname3, sep as sep2 } from "node:path";
+import { babelParse, types as t2 } from "storybook/internal/babel";
+import { getProjectRoot, supportedExtensions as supportedExtensions2 } from "storybook/internal/common";
+var TsconfigPaths = __toESM(require_lib2(), 1);
+import {
+  builtinHandlers as docgenHandlers,
+  builtinResolvers as docgenResolver,
+  makeFsImporter,
+  parse as parse3
+} from "react-docgen";
+
 // ../../node_modules/comment-parser/es6/primitives.js
 var Markers;
 (function(Markers2) {
@@ -4574,9 +4674,9 @@ __name(typeTokenizer, "typeTokenizer");
 var trim = /* @__PURE__ */ __name((x) => x.trim(), "trim");
 function getJoiner(spacing) {
   if (spacing === "compact")
-    return (t4) => t4.map(trim).join("");
+    return (t5) => t5.map(trim).join("");
   else if (spacing === "preserve")
-    return (t4) => t4.join("\n");
+    return (t5) => t5.join("\n");
   else
     return spacing;
 }
@@ -4735,12 +4835,12 @@ function getParser4({ startLine = 0, fence = "```", spacing = "compact", markers
 __name(getParser4, "getParser");
 
 // ../../node_modules/comment-parser/es6/stringifier/index.js
-function join2(tokens) {
+function join4(tokens) {
   return tokens.start + tokens.delimiter + tokens.postDelimiter + tokens.tag + tokens.postTag + tokens.type + tokens.postType + tokens.name + tokens.postName + tokens.description + tokens.end + tokens.lineEnd;
 }
-__name(join2, "join");
+__name(join4, "join");
 function getStringifier() {
-  return (block) => block.source.map(({ tokens }) => join2(tokens)).join("\n");
+  return (block) => block.source.map(({ tokens }) => join4(tokens)).join("\n");
 }
 __name(getStringifier, "getStringifier");
 
@@ -4786,64 +4886,6 @@ function extractJSDocInfo(jsdocComment) {
 }
 __name(extractJSDocInfo, "extractJSDocInfo");
 
-// src/componentManifest/reactDocgen.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { sep as sep2 } from "node:path";
-import { types as t2 } from "storybook/internal/babel";
-import { getProjectRoot } from "storybook/internal/common";
-import { supportedExtensions as supportedExtensions2 } from "storybook/internal/common";
-import { resolveImport } from "storybook/internal/common";
-
-// ../../node_modules/empathic/find.mjs
-import { join as join4 } from "node:path";
-import { existsSync, statSync } from "node:fs";
-
-// ../../node_modules/empathic/walk.mjs
-import { dirname as dirname2 } from "node:path";
-
-// ../../node_modules/empathic/resolve.mjs
-import { isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
-function absolute(input, root) {
-  return isAbsolute2(input) ? input : resolve2(root || ".", input);
-}
-__name(absolute, "absolute");
-
-// ../../node_modules/empathic/walk.mjs
-function up(base, options) {
-  let { last, cwd: cwd2 } = options || {};
-  let tmp = absolute(base, cwd2);
-  let root = absolute(last || "/", cwd2);
-  let prev, arr = [];
-  while (prev !== root) {
-    arr.push(tmp);
-    tmp = dirname2(prev = tmp);
-    if (tmp === prev) break;
-  }
-  return arr;
-}
-__name(up, "up");
-
-// ../../node_modules/empathic/find.mjs
-function up2(name, options) {
-  let dir, tmp;
-  let start = options && options.cwd || "";
-  for (dir of up(start, options)) {
-    tmp = join4(dir, name);
-    if (existsSync(tmp)) return tmp;
-  }
-}
-__name(up2, "up");
-
-// src/componentManifest/reactDocgen.ts
-var TsconfigPaths = __toESM(require_lib2(), 1);
-import { ERROR_CODES } from "react-docgen";
-import {
-  builtinHandlers as docgenHandlers,
-  builtinResolvers as docgenResolver,
-  makeFsImporter,
-  parse as parse3
-} from "react-docgen";
-
 // src/componentManifest/reactDocgen/actualNameHandler.ts
 import { utils } from "react-docgen";
 var { getNameOrValue, isReactForwardRefCall } = utils;
@@ -5018,65 +5060,154 @@ var exportNameHandler_default = exportNameHandler;
 var defaultHandlers = Object.values(docgenHandlers).map((handler) => handler);
 var defaultResolver = new docgenResolver.FindExportedDefinitionsResolver();
 var handlers = [...defaultHandlers, actualNameHandler_default, exportNameHandler_default];
-function getMatchingDocgen(docgens, csf) {
-  const componentName = csf._meta?.component;
+function getMatchingDocgen(docgens, component) {
   if (docgens.length === 1) {
     return docgens[0];
   }
-  const importSpecifier = csf._componentImportSpecifier;
-  let importName;
-  if (t2.isImportSpecifier(importSpecifier)) {
-    const imported = importSpecifier.imported;
-    importName = t2.isIdentifier(imported) ? imported.name : imported.value;
-  } else if (t2.isImportDefaultSpecifier(importSpecifier)) {
-    importName = "default";
-  }
-  const docgen = docgens.find((docgen2) => docgen2.exportName === importName);
-  if (docgen || !componentName) {
-    return docgen;
-  }
-  return docgens.find(
-    (docgen2) => docgen2.displayName === componentName || docgen2.actualName === componentName
+  const matchingDocgen = docgens.find(
+    (docgen) => [component.importName, component.localImportName].includes(docgen.exportName)
+  ) ?? docgens.find(
+    (docgen) => [component.importName, component.localImportName, component.componentName].includes(
+      docgen.displayName
+    ) || [component.importName, component.localImportName, component.componentName].includes(
+      docgen.actualName
+    )
   );
+  return matchingDocgen ?? docgens[0];
 }
 __name(getMatchingDocgen, "getMatchingDocgen");
-async function parseWithReactDocgen({ code, filename }) {
-  const tsconfigPath = up2("tsconfig.json", { cwd: process.cwd(), last: getProjectRoot() });
-  const tsconfig = TsconfigPaths.loadConfig(tsconfigPath);
-  let matchPath;
+function matchPath(id, basedir) {
+  basedir ??= process.cwd();
+  const tsconfig = getTsConfig(basedir);
   if (tsconfig.resultType === "success") {
-    matchPath = TsconfigPaths.createMatchPath(tsconfig.absoluteBaseUrl, tsconfig.paths, [
+    const match = TsconfigPaths.createMatchPath(tsconfig.absoluteBaseUrl, tsconfig.paths, [
       "browser",
       "module",
       "main"
     ]);
+    return match(id, void 0, void 0, supportedExtensions2) ?? id;
   }
-  try {
+  return id;
+}
+__name(matchPath, "matchPath");
+var getTsConfig = cached(
+  (cwd2) => {
+    const tsconfigPath = up2("tsconfig.json", { cwd: cwd2, last: getProjectRoot() });
+    return TsconfigPaths.loadConfig(tsconfigPath);
+  },
+  { name: "getTsConfig" }
+);
+var parseWithReactDocgen = cached(
+  (code, path2) => {
     return parse3(code, {
       resolver: defaultResolver,
       handlers,
-      importer: getReactDocgenImporter(matchPath),
-      filename
+      importer: getReactDocgenImporter(),
+      filename: path2
     });
-  } catch (e) {
-    if (!(e instanceof Error && "code" in e && e.code === ERROR_CODES.MISSING_DEFINITION)) {
-      console.error(e);
+  },
+  { key: /* @__PURE__ */ __name((code, path2) => path2, "key"), name: "parseWithReactDocgen" }
+);
+var getExportPaths = cached(
+  (code, filePath) => {
+    const ast = (() => {
+      try {
+        return babelParse(code);
+      } catch (_) {
+        return void 0;
+      }
+    })();
+    if (!ast) {
+      return [];
     }
-    return [];
-  }
-}
-__name(parseWithReactDocgen, "parseWithReactDocgen");
-function getReactDocgenImporter(matchPath) {
+    const basedir = dirname3(filePath);
+    const body = ast.program.body;
+    return body.flatMap(
+      (n) => t2.isExportAllDeclaration(n) ? [n.source.value] : t2.isExportNamedDeclaration(n) && !!n.source && !n.declaration ? [n.source.value] : []
+    ).map((s) => matchPath(s, basedir)).map((s) => {
+      try {
+        return cachedResolveImport(s, { basedir });
+      } catch {
+        return void 0;
+      }
+    }).filter((p) => !!p && !p.includes("node_modules"));
+  },
+  { name: "getExportPaths" }
+);
+var gatherDocgensForPath = cached(
+  (filePath, depth) => {
+    if (depth > 5 || filePath.includes("node_modules")) {
+      return { docgens: [], analyzed: [] };
+    }
+    let code;
+    try {
+      code = cachedReadFileSync(filePath, "utf-8");
+    } catch {
+    }
+    if (!code) {
+      return { docgens: [], analyzed: [{ path: filePath, code: "/* File not found */" }] };
+    }
+    const reexportResults = getExportPaths(code, filePath).map(
+      (p) => gatherDocgensForPath(p, depth + 1)
+    );
+    const fromReexports = reexportResults.flatMap((r) => r.docgens);
+    const analyzedChildren = reexportResults.flatMap((r) => r.analyzed);
+    let locals;
+    try {
+      locals = parseWithReactDocgen(code, filePath);
+    } catch {
+      locals = [];
+    }
+    return {
+      docgens: [...locals, ...fromReexports],
+      analyzed: [{ path: filePath, code }, ...analyzedChildren]
+    };
+  },
+  { name: "gatherDocgensWithTrace", key: /* @__PURE__ */ __name((filePath) => filePath, "key") }
+);
+var getReactDocgen = cached(
+  (path2, component) => {
+    if (path2.includes("node_modules")) {
+      return {
+        type: "error",
+        error: {
+          name: "Component file in node_modules",
+          message: `Component files in node_modules are not supported. Please import your component file directly.`
+        }
+      };
+    }
+    const docgenWithInfo = gatherDocgensForPath(path2, 0);
+    const docgens = docgenWithInfo.docgens;
+    const noCompDefError = {
+      type: "error",
+      error: {
+        name: "No component definition found",
+        message: `Could not find a component definition.
+Prefer relative imports if possible.
+Avoid pointing to transpiled files.
+You can debug your component file in this playground: https://react-docgen.dev/playground
+
+` + docgenWithInfo.analyzed.map(({ path: path3, code }) => `File: ${path3}
+${code}`).join("\n")
+      }
+    };
+    if (!docgens || docgens.length === 0) {
+      return noCompDefError;
+    }
+    const docgen = getMatchingDocgen(docgens, component);
+    if (!docgen) {
+      return noCompDefError;
+    }
+    return { type: "success", data: docgen };
+  },
+  { name: "getReactDocgen", key: /* @__PURE__ */ __name((path2, component) => path2 + JSON.stringify(component), "key") }
+);
+function getReactDocgenImporter() {
   return makeFsImporter((filename, basedir) => {
     const mappedFilenameByPaths = (() => {
-      if (matchPath) {
-        const match = matchPath(filename, void 0, void 0, supportedExtensions2);
-        return match || filename;
-      } else {
-        return filename;
-      }
+      return matchPath(filename, basedir);
     })();
-    const result = resolveImport(mappedFilenameByPaths, { basedir });
+    const result = cachedResolveImport(mappedFilenameByPaths, { basedir });
     if (result.includes(`${sep2}react-native${sep2}index.js`)) {
       const replaced = result.replace(
         `${sep2}react-native${sep2}index.js`,
@@ -5095,11 +5226,347 @@ function getReactDocgenImporter(matchPath) {
   });
 }
 __name(getReactDocgenImporter, "getReactDocgenImporter");
+function getImportTag(docgen) {
+  const jsdocComment = docgen?.description;
+  const tags = jsdocComment ? extractJSDocInfo(jsdocComment).tags : void 0;
+  return tags?.import?.[0];
+}
+__name(getImportTag, "getImportTag");
+
+// src/componentManifest/getComponentImports.ts
+var baseIdentifier = /* @__PURE__ */ __name((component) => component.split(".")[0] ?? component, "baseIdentifier");
+var isTypeSpecifier = /* @__PURE__ */ __name((s) => t3.isImportSpecifier(s) && s.importKind === "type", "isTypeSpecifier");
+var importedName = /* @__PURE__ */ __name((im) => t3.isIdentifier(im) ? im.name : im.value, "importedName");
+var addUniqueBy = /* @__PURE__ */ __name((arr, item, eq) => {
+  if (!arr.find(eq)) {
+    arr.push(item);
+  }
+}, "addUniqueBy");
+var getComponents = /* @__PURE__ */ __name(({
+  csf,
+  storyFilePath
+}) => {
+  const program = csf._file.path;
+  const componentSet = /* @__PURE__ */ new Set();
+  const localToImport = /* @__PURE__ */ new Map();
+  program.traverse({
+    JSXOpeningElement(p) {
+      const n = p.node.name;
+      if (t3.isJSXIdentifier(n)) {
+        const name = n.name;
+        if (name && /[A-Z]/.test(name.charAt(0))) {
+          componentSet.add(name);
+        }
+      } else if (t3.isJSXMemberExpression(n)) {
+        const jsxNameToString = /* @__PURE__ */ __name((name) => t3.isJSXIdentifier(name) ? name.name : `${jsxNameToString(name.object)}.${jsxNameToString(name.property)}`, "jsxNameToString");
+        const full = jsxNameToString(n);
+        componentSet.add(full);
+      }
+    }
+  });
+  const metaComp = csf._meta?.component;
+  if (metaComp) {
+    componentSet.add(metaComp);
+  }
+  const components = Array.from(componentSet).sort((a, b) => a.localeCompare(b));
+  const body = program.get("body");
+  for (const stmt of body) {
+    if (!stmt.isImportDeclaration()) {
+      continue;
+    }
+    const decl = stmt.node;
+    if (decl.importKind === "type") {
+      continue;
+    }
+    const specifiers = decl.specifiers ?? [];
+    if (specifiers.length === 0) {
+      continue;
+    }
+    for (const s of specifiers) {
+      if (!("local" in s) || !s.local) {
+        continue;
+      }
+      if (isTypeSpecifier(s)) {
+        continue;
+      }
+      const importId = decl.source.value;
+      if (t3.isImportDefaultSpecifier(s)) {
+        localToImport.set(s.local.name, { importId, importName: "default" });
+      } else if (t3.isImportNamespaceSpecifier(s)) {
+        localToImport.set(s.local.name, { importId, importName: "*" });
+      } else if (t3.isImportSpecifier(s)) {
+        const imported = importedName(s.imported);
+        localToImport.set(s.local.name, { importId, importName: imported });
+      }
+    }
+  }
+  const isLocallyDefinedWithoutImport = /* @__PURE__ */ __name((base) => {
+    const binding = program.scope.getBinding(base);
+    if (!binding) {
+      return false;
+    }
+    const isImportBinding = Boolean(
+      binding.path.isImportSpecifier?.() || binding.path.isImportDefaultSpecifier?.() || binding.path.isImportNamespaceSpecifier?.()
+    );
+    return !isImportBinding;
+  }, "isLocallyDefinedWithoutImport");
+  const filteredComponents = components.filter(
+    (c) => !isLocallyDefinedWithoutImport(baseIdentifier(c))
+  );
+  const componentObjs = filteredComponents.map((c) => {
+    const dot = c.indexOf(".");
+    if (dot !== -1) {
+      const ns = c.slice(0, dot);
+      const member = c.slice(dot + 1);
+      const direct2 = localToImport.get(ns);
+      return !direct2 ? { componentName: c } : direct2.importName === "*" ? {
+        componentName: c,
+        localImportName: ns,
+        importId: direct2.importId,
+        importName: member,
+        namespace: ns
+      } : {
+        componentName: c,
+        localImportName: ns,
+        importId: direct2.importId,
+        importName: direct2.importName
+      };
+    }
+    const direct = localToImport.get(c);
+    return direct ? {
+      componentName: c,
+      localImportName: c,
+      importId: direct.importId,
+      importName: direct.importName
+    } : { componentName: c };
+  }).map((component) => {
+    let path2;
+    try {
+      if (component.importId && storyFilePath) {
+        path2 = cachedResolveImport(matchPath(component.importId, dirname4(storyFilePath)), {
+          basedir: dirname4(storyFilePath)
+        });
+      }
+    } catch (e) {
+      logger2.error(e);
+    }
+    if (path2) {
+      const reactDocgen = getReactDocgen(path2, component);
+      return {
+        ...component,
+        path: path2,
+        reactDocgen,
+        importOverride: reactDocgen.type === "success" ? getImportTag(reactDocgen.data) : void 0
+      };
+    }
+    return component;
+  }).sort((a, b) => a.componentName.localeCompare(b.componentName));
+  return componentObjs;
+}, "getComponents");
+var getImports = /* @__PURE__ */ __name(({
+  components,
+  packageName
+}) => {
+  const isRelative = /* @__PURE__ */ __name((id) => id.startsWith(".") || id === ".", "isRelative");
+  const withSource = components.filter((c) => Boolean(c.importId)).map((c, idx) => {
+    const importId = c.importId;
+    const overrideSource = (() => {
+      if (!c.importOverride) {
+        return void 0;
+      }
+      try {
+        const parsed = babelParse2(c.importOverride);
+        const decl = parsed.program.body.find((n) => t3.isImportDeclaration(n));
+        const src = decl?.source?.value;
+        return typeof src === "string" ? src : void 0;
+      } catch {
+        return void 0;
+      }
+    })();
+    const rewritten = overrideSource !== void 0 ? overrideSource : packageName && isRelative(importId) ? packageName : importId;
+    return { c, src: t3.stringLiteral(rewritten), key: rewritten, ord: idx };
+  });
+  const orderOfSource = {};
+  for (const w of withSource) {
+    if (orderOfSource[w.key] === void 0) {
+      orderOfSource[w.key] = w.ord;
+    }
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  const ensureBucket = /* @__PURE__ */ __name((key, src) => {
+    const prev = buckets.get(key);
+    if (prev) {
+      return prev;
+    }
+    const b = {
+      source: src,
+      defaults: [],
+      namespaces: [],
+      named: [],
+      order: orderOfSource[key] ?? 0
+    };
+    buckets.set(key, b);
+    return b;
+  }, "ensureBucket");
+  for (const { c, src, key } of withSource) {
+    const b = ensureBucket(key, src);
+    const rewritten = src.value !== c.importId;
+    const overrideSpec = (() => {
+      if (!c.importOverride) {
+        return void 0;
+      }
+      try {
+        const parsed = babelParse2(c.importOverride);
+        const decl = parsed.program.body.find((n) => t3.isImportDeclaration(n));
+        if (!decl) {
+          return void 0;
+        }
+        const spec = (decl.specifiers ?? []).find((s) => !isTypeSpecifier(s));
+        if (!spec) {
+          return void 0;
+        }
+        if (t3.isImportNamespaceSpecifier(spec)) {
+          return { kind: "namespace", local: spec.local.name };
+        }
+        if (t3.isImportDefaultSpecifier(spec)) {
+          return { kind: "default" };
+        }
+        if (t3.isImportSpecifier(spec)) {
+          const imported = t3.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          return { kind: "named", imported };
+        }
+        return void 0;
+      } catch {
+        return void 0;
+      }
+    })();
+    if (overrideSpec) {
+      if (overrideSpec.kind === "namespace") {
+        const ns = t3.identifier(overrideSpec.local);
+        addUniqueBy(b.namespaces, ns, (n) => n.name === ns.name);
+        continue;
+      }
+      if (!c.localImportName) {
+        continue;
+      }
+      if (overrideSpec.kind === "default") {
+        const id = t3.identifier(c.localImportName);
+        addUniqueBy(b.defaults, id, (d) => d.name === id.name);
+        continue;
+      }
+      if (overrideSpec.kind === "named") {
+        const local = t3.identifier(c.localImportName);
+        const imported = t3.identifier(overrideSpec.imported);
+        addUniqueBy(
+          b.named,
+          t3.importSpecifier(local, imported),
+          (n) => n.local.name === local.name && importedName(n.imported) === imported.name
+        );
+        continue;
+      }
+    }
+    if (c.namespace) {
+      if (rewritten) {
+        if (!c.importName) {
+          continue;
+        }
+        const member = c.importName;
+        const id = t3.identifier(member);
+        addUniqueBy(
+          b.named,
+          t3.importSpecifier(id, id),
+          (n) => n.local.name === member && importedName(n.imported) === member
+        );
+      } else {
+        const ns = t3.identifier(c.namespace);
+        addUniqueBy(b.namespaces, ns, (n) => n.name === ns.name);
+      }
+      continue;
+    }
+    if (c.importName === "default") {
+      if (!c.localImportName) {
+        continue;
+      }
+      if (rewritten) {
+        const id = t3.identifier(c.localImportName);
+        addUniqueBy(
+          b.named,
+          t3.importSpecifier(id, id),
+          (n) => n.local.name === id.name && importedName(n.imported) === id.name
+        );
+      } else {
+        const id = t3.identifier(c.localImportName);
+        addUniqueBy(b.defaults, id, (d) => d.name === id.name);
+      }
+      continue;
+    }
+    if (c.importName) {
+      if (!c.localImportName) {
+        continue;
+      }
+      const local = t3.identifier(c.localImportName);
+      const imported = t3.identifier(c.importName);
+      addUniqueBy(
+        b.named,
+        t3.importSpecifier(local, imported),
+        (n) => n.local.name === local.name && importedName(n.imported) === imported.name
+      );
+      continue;
+    }
+  }
+  const merged = [];
+  const printDecl = /* @__PURE__ */ __name((specs, src) => {
+    const node = t3.importDeclaration(specs, src);
+    const code = recast.print(node, {}).code;
+    merged.push(code);
+  }, "printDecl");
+  const sortedBuckets = Array.from(buckets.values()).sort((a, b) => a.order - b.order);
+  for (const bucket of sortedBuckets) {
+    const { source, defaults, namespaces, named } = bucket;
+    if (defaults.length === 0 && namespaces.length === 0 && named.length === 0) {
+      continue;
+    }
+    if (namespaces.length > 0) {
+      const firstSpecs = [];
+      if (defaults[0]) {
+        firstSpecs.push(t3.importDefaultSpecifier(defaults[0]));
+      }
+      firstSpecs.push(t3.importNamespaceSpecifier(namespaces[0]));
+      printDecl(firstSpecs, source);
+      if (named.length > 0) {
+        printDecl(named, source);
+      }
+      for (const d of defaults.slice(1)) {
+        printDecl([t3.importDefaultSpecifier(d)], source);
+      }
+      for (const ns of namespaces.slice(1)) {
+        printDecl([t3.importNamespaceSpecifier(ns)], source);
+      }
+    } else {
+      if (defaults.length > 0 || named.length > 0) {
+        const specs = [];
+        if (defaults[0]) {
+          specs.push(t3.importDefaultSpecifier(defaults[0]));
+        }
+        specs.push(...named);
+        printDecl(specs, source);
+      }
+      for (const d of defaults.slice(1)) {
+        printDecl([t3.importDefaultSpecifier(d)], source);
+      }
+    }
+  }
+  return merged;
+}, "getImports");
 
 // src/componentManifest/generator.ts
 var componentManifestGenerator = /* @__PURE__ */ __name(async () => {
   return async (storyIndexGenerator) => {
+    invalidateCache();
+    const startIndex = performance.now();
     const index = await storyIndexGenerator.getIndex();
+    logger3.verbose(`Story index generation took ${performance.now() - startIndex}ms`);
+    const startPerformance = performance.now();
     const groupByComponentId = groupBy(
       Object.values(index.entries).filter((entry) => entry.type === "story").filter((entry) => entry.subtype === "story"),
       (it) => it.id.split("--")[0]
@@ -5107,102 +5574,101 @@ var componentManifestGenerator = /* @__PURE__ */ __name(async () => {
     const singleEntryPerComponent = Object.values(groupByComponentId).flatMap(
       (group) => group && group?.length > 0 ? [group[0]] : []
     );
-    const components = await Promise.all(
-      singleEntryPerComponent.flatMap(async (entry) => {
-        const storyFile = await readFile(path.join(process.cwd(), entry.importPath), "utf-8");
-        const csf = loadCsf(storyFile, { makeTitle: /* @__PURE__ */ __name((title) => title ?? "No title", "makeTitle") }).parse();
-        const name = csf._meta?.component ?? entry.title.split("/").at(-1);
-        const id = entry.id.split("--")[0];
-        const importPath = entry.importPath;
-        const examples = Object.keys(csf._stories).map((storyName) => {
-          try {
-            return {
-              name: storyName,
-              snippet: recast.print(getCodeSnippet(csf, storyName, name)).code
-            };
-          } catch (e) {
-            invariant(e instanceof Error);
-            return {
-              name: storyName,
-              error: {
-                name: e.name,
-                message: e.message
-              }
-            };
-          }
-        }).filter(Boolean);
-        const base = {
-          id,
-          name,
-          path: importPath,
-          examples,
-          jsDocTags: {}
-        };
-        if (!entry.componentPath) {
-          const componentName = csf._meta?.component;
-          const error2 = !componentName ? {
-            name: "No meta.component specified",
-            message: "Specify meta.component for the component to be included in the manifest."
-          } : {
-            name: "No component import found",
-            message: `No component file found for the "${componentName}" component.`
-          };
-          return {
-            ...base,
-            name,
-            examples,
-            error: {
-              name: error2.name,
-              message: csf._metaStatementPath?.buildCodeFrameError(error2.message).message ?? error2.message
-            }
-          };
+    const components = singleEntryPerComponent.map((entry) => {
+      const absoluteImportPath = path.join(process.cwd(), entry.importPath);
+      const storyFile = cachedReadFileSync(absoluteImportPath, "utf-8");
+      const csf = loadCsf(storyFile, { makeTitle: /* @__PURE__ */ __name((title2) => title2 ?? "No title", "makeTitle") }).parse();
+      const manifestEnabled = csf.stories.map((it) => combineTags("manifest", ...csf.meta.tags ?? [], ...it.tags ?? [])).some((it) => it.includes("manifest"));
+      if (!manifestEnabled) {
+        return;
+      }
+      const componentName = csf._meta?.component;
+      const id = entry.id.split("--")[0];
+      const importPath = entry.importPath;
+      const components2 = getComponents({ csf, storyFilePath: absoluteImportPath });
+      const trimmedTitle = entry.title.replace(/\s+/g, "");
+      const component = components2.find((it) => {
+        return componentName ? [it.componentName, it.localImportName, it.importName].includes(componentName) : trimmedTitle.includes(it.componentName) || it.localImportName && trimmedTitle.includes(it.localImportName) || it.importName && trimmedTitle.includes(it.importName);
+      });
+      const stories = Object.keys(csf._stories).map((storyName) => {
+        const story = csf._stories[storyName];
+        const manifestEnabled2 = combineTags(
+          "manifest",
+          ...csf.meta.tags ?? [],
+          ...story.tags ?? []
+        ).includes("manifest");
+        if (!manifestEnabled2) {
+          return;
         }
-        let componentFile;
         try {
-          componentFile = await readFile(path.join(process.cwd(), entry.componentPath), "utf-8");
+          const jsdocComment2 = extractDescription(csf._storyStatements[storyName]);
+          const { tags: tags2 = {}, description: description2 } = jsdocComment2 ? extractJSDocInfo(jsdocComment2) : {};
+          const finalDescription = (tags2?.describe?.[0] || tags2?.desc?.[0]) ?? description2;
+          return {
+            name: storyName,
+            snippet: recast2.print(getCodeSnippet(csf, storyName, component?.componentName)).code,
+            description: finalDescription?.trim(),
+            summary: tags2.summary?.[0]
+          };
         } catch (e) {
           invariant(e instanceof Error);
           return {
-            ...base,
-            name,
-            examples,
-            error: {
-              name: "Component file could not be read",
-              message: `Could not read the component file located at "${entry.componentPath}".
-Prefer relative imports.`
-            }
+            name: storyName,
+            error: { name: e.name, message: e.message }
           };
         }
-        const docgens = await parseWithReactDocgen({
-          code: componentFile,
-          filename: path.join(process.cwd(), entry.componentPath)
-        });
-        const docgen = getMatchingDocgen(docgens, csf);
-        const error = !docgen ? {
-          name: "Docgen evaluation failed",
-          message: `Could not parse props information for the component file located at "${entry.componentPath}"
-Avoid barrel files when importing your component file.
-Prefer relative imports if possible.
-Avoid pointing to transpiled files.
-You can debug your component file in this playground: https://react-docgen.dev/playground`
-        } : void 0;
-        const metaDescription = extractDescription(csf._metaStatement);
-        const jsdocComment = metaDescription || docgen?.description;
-        const { tags = {}, description } = jsdocComment ? extractJSDocInfo(jsdocComment) : {};
-        const manifestDescription = (tags?.describe?.[0] || tags?.desc?.[0]) ?? description;
+      }).filter((it) => it != null);
+      const nearestPkg = cachedFindUp("package.json", {
+        cwd: path.dirname(component?.path ?? absoluteImportPath)
+      });
+      let packageName;
+      try {
+        packageName = nearestPkg ? JSON.parse(cachedReadFileSync(nearestPkg, "utf-8")).name : void 0;
+      } catch {
+      }
+      const fallbackImport = packageName && componentName ? `import { ${componentName} } from "${packageName}";` : "";
+      const imports = getImports({ components: components2, packageName }).join("\n").trim() || fallbackImport;
+      const title = entry.title.split("/").at(-1).replace(/\s+/g, "");
+      const base = {
+        id,
+        name: componentName ?? title,
+        path: importPath,
+        stories,
+        import: imports,
+        jsDocTags: {}
+      };
+      if (!component?.reactDocgen) {
+        const error2 = !component ? {
+          name: "No meta.component specified",
+          message: "Specify meta.component for the component to be included in the manifest."
+        } : {
+          name: "No component import found",
+          message: `No component file found for the "${component.componentName}" component.`
+        };
         return {
           ...base,
-          name,
-          description: manifestDescription?.trim(),
-          summary: tags.summary?.[0],
-          import: tags.import?.[0],
-          reactDocgen: docgen,
-          jsDocTags: tags,
-          examples,
-          error
+          error: {
+            name: error2.name,
+            message: csf._metaStatementPath?.buildCodeFrameError(error2.message).message ?? error2.message
+          }
         };
-      })
-    );
+      }
+      const docgenResult = component.reactDocgen;
+      const docgen = docgenResult.type === "success" ? docgenResult.data : void 0;
+      const error = docgenResult.type === "error" ? docgenResult.error : void 0;
+      const jsdocComment = extractDescription(csf._metaStatement) || docgen?.description;
+      const { tags = {}, description } = jsdocComment ? extractJSDocInfo(jsdocComment) : {};
+      return {
+        ...base,
+        description: ((tags?.describe?.[0] || tags?.desc?.[0]) ?? description)?.trim(),
+        summary: tags.summary?.[0],
+        import: imports,
+        reactDocgen: docgen,
+        jsDocTags: tags,
+        error
+      };
+    });
+    logger3.verbose(`Component manifest generation took ${performance.now() - startPerformance}ms`);
     return {
       v: 0,
       components: Object.fromEntries(
@@ -5213,7 +5679,7 @@ You can debug your component file in this playground: https://react-docgen.dev/p
 }, "componentManifestGenerator");
 
 // src/enrichCsf.ts
-import { recast as recast2, types as t3 } from "storybook/internal/babel";
+import { recast as recast3, types as t4 } from "storybook/internal/babel";
 import { getPrettier } from "storybook/internal/common";
 var enrichCsf = /* @__PURE__ */ __name(async (input, options) => {
   const features = await options.presets.apply("features");
@@ -5238,7 +5704,7 @@ var enrichCsf = /* @__PURE__ */ __name(async (input, options) => {
       }
       try {
         if (!snippet && node) {
-          snippet = await format3(recast2.print(node).code, {
+          snippet = await format3(recast3.print(node).code, {
             filepath: join(process.cwd(), "component.tsx")
           });
         }
@@ -5251,35 +5717,35 @@ var enrichCsf = /* @__PURE__ */ __name(async (input, options) => {
       if (!snippet) {
         return;
       }
-      const originalParameters = t3.memberExpression(
-        csf._metaIsFactory ? t3.memberExpression(t3.identifier(key), t3.identifier("input")) : t3.identifier(key),
-        t3.identifier("parameters")
+      const originalParameters = t4.memberExpression(
+        csf._metaIsFactory ? t4.memberExpression(t4.identifier(key), t4.identifier("input")) : t4.identifier(key),
+        t4.identifier("parameters")
       );
-      const docsParameter = t3.optionalMemberExpression(
+      const docsParameter = t4.optionalMemberExpression(
         originalParameters,
-        t3.identifier("docs"),
+        t4.identifier("docs"),
         false,
         true
       );
       csf._ast.program.body.push(
-        t3.expressionStatement(
-          t3.assignmentExpression(
+        t4.expressionStatement(
+          t4.assignmentExpression(
             "=",
             originalParameters,
-            t3.objectExpression([
-              t3.spreadElement(originalParameters),
-              t3.objectProperty(
-                t3.identifier("docs"),
-                t3.objectExpression([
-                  t3.spreadElement(docsParameter),
-                  t3.objectProperty(
-                    t3.identifier("source"),
-                    t3.objectExpression([
-                      t3.objectProperty(t3.identifier("code"), t3.stringLiteral(snippet)),
-                      t3.spreadElement(
-                        t3.optionalMemberExpression(
+            t4.objectExpression([
+              t4.spreadElement(originalParameters),
+              t4.objectProperty(
+                t4.identifier("docs"),
+                t4.objectExpression([
+                  t4.spreadElement(docsParameter),
+                  t4.objectProperty(
+                    t4.identifier("source"),
+                    t4.objectExpression([
+                      t4.objectProperty(t4.identifier("code"), t4.stringLiteral(snippet)),
+                      t4.spreadElement(
+                        t4.optionalMemberExpression(
                           docsParameter,
-                          t3.identifier("source"),
+                          t4.identifier("source"),
                           false,
                           true
                         )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/react",
-  "version": "10.1.0-alpha.3",
+  "version": "10.1.0-alpha.5",
   "description": "Storybook React renderer",
   "keywords": [
     "storybook"
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@storybook/global": "^5.0.0",
-    "@storybook/react-dom-shim": "10.1.0-alpha.3",
+    "@storybook/react-dom-shim": "10.1.0-alpha.5",
     "react-docgen": "^8.0.2"
   },
   "devDependencies": {
@@ -67,6 +67,7 @@
     "acorn-walk": "^7.2.0",
     "babel-plugin-react-docgen": "^4.2.1",
     "comment-parser": "^1.4.1",
+    "empathic": "^2.0.0",
     "es-toolkit": "^1.36.0",
     "escodegen": "^2.1.0",
     "expect-type": "^0.15.0",
@@ -80,7 +81,7 @@
   "peerDependencies": {
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
     "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-    "storybook": "^10.1.0-alpha.3",
+    "storybook": "^10.1.0-alpha.5",
     "typescript": ">= 4.9.x"
   },
   "peerDependenciesMeta": {