@storybook/cli 10.4.0-alpha.9 → 10.4.0

package/dist/_node-chunks/{run-2DIHBNRR.js → run-CMSUW4EI.js}

@@ -1,14 +1,19 @@
-import CJS_COMPAT_NODE_URL_r0u17tnf7k from 'node:url';
-import CJS_COMPAT_NODE_PATH_r0u17tnf7k from 'node:path';
-import CJS_COMPAT_NODE_MODULE_r0u17tnf7k from "node:module";
+import CJS_COMPAT_NODE_URL_qwqib56gpq from 'node:url';
+import CJS_COMPAT_NODE_PATH_qwqib56gpq from 'node:path';
+import CJS_COMPAT_NODE_MODULE_qwqib56gpq from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_r0u17tnf7k.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_r0u17tnf7k.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_r0u17tnf7k.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_qwqib56gpq.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_qwqib56gpq.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_qwqib56gpq.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
+import {
+  instructions
+} from "./chunk-OCLBRGHS.js";
+import "./chunk-L5XJ6BK3.js";
+import "./chunk-DYSRKIJT.js";
 import {
   bannerComment,
   containsDirnameUsage,
@@ -23,20 +28,21 @@ import {
   processAutoblockerResults,
   require_picocolors,
   shortenPath,
+  up,
   updateMainConfig,
   upgradeStorybookDependencies
-} from "./chunk-TOPUV6KI.js";
+} from "./chunk-UI4WZ34X.js";
 import {
   slash
-} from "./chunk-CM5XGY6F.js";
+} from "./chunk-BRMCKSDM.js";
 import {
   require_semver
-} from "./chunk-HNY2PNPG.js";
+} from "./chunk-UCOB2TZD.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-KMOZMHXY.js";
+} from "./chunk-5CZRH4L2.js";
 
 // ../../../node_modules/envinfo/dist/envinfo.js
 var require_envinfo = __commonJS({
@@ -4417,9 +4423,9 @@ var require_isexe = __commonJS({
       if (typeof options == "function" && (cb = options, options = {}), !cb) {
         if (typeof Promise != "function")
           throw new TypeError("callback not provided");
-        return new Promise(function(resolve2, reject) {
+        return new Promise(function(resolve5, reject) {
           isexe(path4, options || {}, function(er, is) {
-            er ? reject(er) : resolve2(is);
+            er ? reject(er) : resolve5(is);
           });
         });
       }
@@ -4456,22 +4462,22 @@ var require_which = __commonJS({
       };
     }, which = (cmd, opt, cb) => {
       typeof opt == "function" && (cb = opt, opt = {}), opt || (opt = {});
-      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [], step = (i) => new Promise((resolve2, reject) => {
+      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [], step = (i) => new Promise((resolve5, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve5(found) : reject(getNotFoundError(cmd));
         let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path4.join(pathPart, cmd), p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve2(subStep(p, i, 0));
-      }), subStep = (p, i, ii) => new Promise((resolve2, reject) => {
+        resolve5(subStep(p, i, 0));
+      }), subStep = (p, i, ii) => new Promise((resolve5, reject) => {
         if (ii === pathExt.length)
-          return resolve2(step(i + 1));
+          return resolve5(step(i + 1));
         let ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is)
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve2(p + ext);
-          return resolve2(subStep(p, i, ii + 1));
+              return resolve5(p + ext);
+          return resolve5(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -4690,7 +4696,7 @@ var require_cross_spawn = __commonJS({
   "../../../node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
     var cp = __require("child_process"), parse2 = require_parse(), enoent = require_enoent();
-    function spawn(command2, args, options) {
+    function spawn2(command2, args, options) {
       let parsed = parse2(command2, args, options), spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       return enoent.hookChildProcess(spawned, parsed), spawned;
     }
@@ -4698,8 +4704,8 @@ var require_cross_spawn = __commonJS({
       let parsed = parse2(command2, args, options), result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       return result.error = result.error || enoent.verifyENOENTSync(result.status, parsed), result;
     }
-    module.exports = spawn;
-    module.exports.spawn = spawn;
+    module.exports = spawn2;
+    module.exports.spawn = spawn2;
     module.exports.sync = spawnSync4;
     module.exports._parse = parse2;
     module.exports._enoent = enoent;
@@ -4710,17 +4716,16 @@ var require_cross_spawn = __commonJS({
 var import_envinfo = __toESM(require_envinfo(), 1);
 import { globalSettings } from "storybook/internal/cli";
 import {
-  HandledError as HandledError2,
+  HandledError as HandledError3,
   JsPackageManagerFactory as JsPackageManagerFactory3,
   PackageManagerName as PackageManagerName3,
-  isCI as isCI2,
   optionalEnvToBoolean as optionalEnvToBoolean3,
   removeAddon as remove,
   versions as versions5
 } from "storybook/internal/common";
 import { withTelemetry } from "storybook/internal/core-server";
-import { CLI_COLORS as CLI_COLORS5, logTracker as logTracker4, logger as logger22 } from "storybook/internal/node-logger";
-import { addToGlobalContext, telemetry as telemetry2 } from "storybook/internal/telemetry";
+import { CLI_COLORS as CLI_COLORS5, logTracker as logTracker4, logger as logger26 } from "storybook/internal/node-logger";
+import { addToGlobalContext, telemetry as telemetry3 } from "storybook/internal/telemetry";
 import { Option, program } from "commander";
 
 // ../../../node_modules/leven/index.js
@@ -4758,10 +4763,10 @@ function leven(first, second, options) {
 }
 
 // src/bin/run.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
+var import_picocolors18 = __toESM(require_picocolors(), 1);
 
 // package.json
-var version = "10.4.0-alpha.9";
+var version = "10.4.0";
 
 // src/add.ts
 var import_semver = __toESM(require_semver(), 1);
@@ -5001,9 +5006,9 @@ var DIR_CWD = process.cwd(), require2 = createRequire2(DIR_CWD), postinstallAddo
   } catch {
     return;
   }
-  let postinstall = moduledLoaded?.default || moduledLoaded?.postinstall || moduledLoaded, logger23 = options.logger;
+  let postinstall = moduledLoaded?.default || moduledLoaded?.postinstall || moduledLoaded, logger27 = options.logger;
   if (!postinstall || typeof postinstall != "function") {
-    logger23.error(`Error finding postinstall function for ${addonName}`);
+    logger27.error(`Error finding postinstall function for ${addonName}`);
     return;
   }
   try {
@@ -5024,7 +5029,7 @@ async function add(addon, {
   configDir: userSpecifiedConfigDir,
   yes,
   skipInstall
-}, logger23 = nodeLogger) {
+}, logger27 = nodeLogger) {
   let [addonName, inputVersion] = getVersionSpecifier(addon), { mainConfig, mainConfigPath, configDir, previewConfigPath, packageManager } = await getStorybookData({
     configDir: userSpecifiedConfigDir,
     packageManagerName: pkgMgr
@@ -5034,16 +5039,16 @@ async function add(addon, {
       Unable to find storybook config directory. Please specify your Storybook config directory with the --config-dir flag.
     `);
   if (!mainConfigPath) {
-    logger23.error("Unable to find Storybook main.js config");
+    logger27.error("Unable to find Storybook main.js config");
     return;
   }
   let shouldAddToMain = !0;
-  if (checkInstalled(addonName, mainConfig) && (shouldAddToMain = !1, !yes && (logger23.log(`The Storybook addon "${addonName}" is already present in ${mainConfigPath}.`), !await prompt.confirm({
+  if (checkInstalled(addonName, mainConfig) && (shouldAddToMain = !1, !yes && (logger27.log(`The Storybook addon "${addonName}" is already present in ${mainConfigPath}.`), !await prompt.confirm({
     message: "Do you wish to install it again?"
   }))))
     return;
   let main = await readConfig(mainConfigPath);
-  logger23.log(`Verifying ${addonName}`);
+  logger27.log(`Verifying ${addonName}`);
   let version2 = inputVersion;
   if (!version2 && isCoreAddon(addonName) && (version2 = versions.storybook), !version2) {
     let latestVersion = await packageManager.latestVersion(addonName);
@@ -5052,14 +5057,14 @@ async function add(addon, {
     version2 = latestVersion;
   }
   let storybookVersion = versions.storybook, versionIsStorybook = version2 === versions.storybook;
-  isCoreAddon(addonName) && !versionIsStorybook && logger23.warn(
+  isCoreAddon(addonName) && !versionIsStorybook && logger27.warn(
     `The version of ${addonName} (${version2}) you are installing is not the same as the version of Storybook you are using (${storybookVersion}). This may lead to unexpected behavior.`
   );
   let versionRange = packageManager.getDependencyVersion("storybook")?.match(/^[~^]/)?.[0] ?? "", addonWithVersion = versionIsStorybook ? `${addonName}@${versionRange}${storybookVersion}` : isValidVersion(version2) && !version2.includes("-pr-") ? `${addonName}@^${version2}` : `${addonName}@${version2}`;
-  logger23.log(`Installing ${addonWithVersion}`), await packageManager.addDependencies(
+  logger27.log(`Installing ${addonWithVersion}`), await packageManager.addDependencies(
     { type: "devDependencies", writeOutputToFile: !1, skipInstall },
     [addonWithVersion]
-  ), shouldAddToMain && (logger23.log(`Adding '${addon}' to the "addons" field in ${mainConfigPath}`), await setupAddonInConfig({
+  ), shouldAddToMain && (logger27.log(`Adding '${addon}' to the "addons" field in ${mainConfigPath}`), await setupAddonInConfig({
     addonName,
     mainConfigCSFFile: main,
     previewConfigPath,
@@ -5068,7 +5073,7 @@ async function add(addon, {
     packageManager: packageManager.type,
     configDir,
     yes,
-    logger: logger23,
+    logger: logger27,
     prompt,
     skipInstall
   });
@@ -5078,9 +5083,9 @@ function isValidVersion(version2) {
 }
 
 // src/automigrate/index.ts
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 import { versions as versions3 } from "storybook/internal/common";
-import { logTracker as logTracker2, logger as logger16, prompt as prompt3 } from "storybook/internal/node-logger";
+import { logTracker as logTracker2, logger as logger18, prompt as prompt4 } from "storybook/internal/node-logger";
 import { AutomigrateError } from "storybook/internal/server-errors";
 
 // ../../../node_modules/tiny-invariant/dist/esm/tiny-invariant.js
@@ -5095,7 +5100,7 @@ function invariant(condition, message) {
 }
 
 // src/automigrate/index.ts
-import { dedent as dedent14 } from "ts-dedent";
+import { dedent as dedent15 } from "ts-dedent";
 
 // src/doctor/index.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
@@ -5625,7 +5630,7 @@ import { logger as logger3 } from "storybook/internal/node-logger";
 import { promises as fs } from "fs";
 var maxConcurrentTasks = Math.max(1, os.cpus().length - 1);
 async function runCodemod(globPattern = "**/*.{stories,story}.{js,jsx,ts,tsx,mjs,mjsx,mts,mtsx}", transform, { dryRun = !1, skipFormatting = !1 } = {}) {
-  let modifiedCount = 0, unmodifiedCount = 0, errorCount = 0, { globby } = await import("./globby-GGFRIMJG.js"), files = await globby(slash(globPattern), {
+  let modifiedCount = 0, unmodifiedCount = 0, errorCount = 0, { globby } = await import("./globby-4NOR2DQO.js"), files = await globby(slash(globPattern), {
     followSymbolicLinks: !0,
     ignore: ["**/node_modules/**", "**/dist/**", "**/storybook-static/**", "**/build/**"]
   });
@@ -5636,7 +5641,7 @@ Please try a different pattern.
 `
     ), new Error("No files matched");
   try {
-    let pLimit = (await import("./p-limit-SUJZ4KSM.js")).default, limit = pLimit(maxConcurrentTasks);
+    let pLimit = (await import("./p-limit-BPN7VYEH.js")).default, limit = pLimit(maxConcurrentTasks);
     await Promise.all(
       files.map(
         (file) => limit(async () => {
@@ -6479,7 +6484,7 @@ var addonA11yParameters = {
             errors.push({ file: previewFileToUpdate, error });
           }
     }
-    let { default: pLimit } = await import("./p-limit-SUJZ4KSM.js"), limit = pLimit(10);
+    let { default: pLimit } = await import("./p-limit-BPN7VYEH.js"), limit = pLimit(10);
     if (await Promise.all(
       storyFilesToUpdate.map(
         (file) => limit(async () => {
@@ -6633,7 +6638,7 @@ var addonGlobalsApi = {
   }
 };
 async function transformStoryFiles(files, options, dryRun) {
-  let errors = [], { default: pLimit } = await import("./p-limit-SUJZ4KSM.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-BPN7VYEH.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
@@ -6825,7 +6830,7 @@ function transformPackageJson(content) {
   return hasChanges ? JSON.stringify(packageJson, null, 2) : null;
 }
 var transformPackageJsonFiles = async (files, dryRun) => {
-  let errors = [], { default: pLimit } = await import("./p-limit-SUJZ4KSM.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-BPN7VYEH.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
@@ -6864,7 +6869,7 @@ var transformPackageJsonFiles = async (files, dryRun) => {
       dryRun
     );
     errors.push(...packageJsonErrors);
-    let { globby } = await import("./globby-GGFRIMJG.js"), configFiles = await globby([`${configDir}/**/*`]), importErrors = await transformImportFiles(
+    let { globby } = await import("./globby-4NOR2DQO.js"), configFiles = await globby([`${configDir}/**/*`]), importErrors = await transformImportFiles(
       [...storiesPaths, ...configFiles].filter(Boolean),
       {
         ...consolidatedPackages,
@@ -7220,7 +7225,7 @@ var VITE_DEFAULT_VERSION = "^7.0.0", transformMainConfig = async (mainConfigPath
       ]);
     }
     mainConfigPath && (logger11.debug("Updating main config file..."), await transformMainConfig(mainConfigPath, dryRun)), logger11.debug("Scanning and updating import statements...");
-    let { globby } = await import("./globby-GGFRIMJG.js"), configFiles = await globby([`${configDir}/**/*`]), allFiles = [...storiesPaths, ...configFiles].filter(Boolean), transformErrors = await transformImportFiles2(
+    let { globby } = await import("./globby-4NOR2DQO.js"), configFiles = await globby([`${configDir}/**/*`]), allFiles = [...storiesPaths, ...configFiles].filter(Boolean), transformErrors = await transformImportFiles2(
       allFiles,
       {
         "@storybook/nextjs": "@storybook/nextjs-vite"
@@ -7235,6 +7240,334 @@ var VITE_DEFAULT_VERSION = "^7.0.0", transformMainConfig = async (mainConfigPath
   }
 };
 
+// src/automigrate/fixes/react-vite-to-tanstack-react.ts
+import { readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { transformImportFiles as transformImportFiles3 } from "storybook/internal/common";
+import { logger as logger12, prompt as prompt3 } from "storybook/internal/node-logger";
+
+// ../../../node_modules/tinyclip/dist/index.js
+import { spawn } from "node:child_process";
+var TIMEOUT = 2e3;
+function checkUnixCommandExists(command2) {
+  return new Promise((resolve5) => {
+    let proc = spawn("which", [command2]);
+    proc.on("error", () => resolve5(!1)), proc.on("close", (code) => resolve5(code === 0));
+  });
+}
+async function getWriteCommand() {
+  switch (process.platform) {
+    case "darwin":
+      return ["pbcopy", []];
+    case "win32":
+      return ["clip", []];
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+      return process.env.WSL_DISTRO_NAME ? ["clip.exe", []] : process.env.WAYLAND_DISPLAY ? ["wl-copy", []] : await checkUnixCommandExists("xsel") ? ["xsel", ["--clipboard", "--input"]] : ["xclip", ["-selection", "clipboard", "-i"]];
+    case "android":
+      return ["termux-clipboard-set", []];
+    default:
+      return;
+  }
+}
+function writeText(text) {
+  return new Promise(async (resolve5, reject) => {
+    let command2 = await getWriteCommand();
+    if (!command2)
+      return reject(new Error("No clipboard tool found"));
+    let proc = spawn(...command2, {
+      stdio: ["pipe", "ignore", "ignore"],
+      signal: AbortSignal.timeout(TIMEOUT)
+    });
+    proc.on("error", (cause) => reject(new Error("An error occurred while copying", { cause }))), proc.on("close", (code) => code === 0 ? resolve5() : reject(new Error("An unknown error occurred while copying"))), proc.stdin.write(text), proc.stdin.end();
+  });
+}
+
+// src/automigrate/fixes/react-vite-to-tanstack-react.ts
+var import_picocolors11 = __toESM(require_picocolors(), 1);
+import { dedent as dedent9 } from "ts-dedent";
+var REACT_VITE_PACKAGE = "@storybook/react-vite", TANSTACK_REACT_PACKAGE = "@storybook/tanstack-react", TANSTACK_ROUTER_DECORATOR_MARKERS = [
+  "createMemoryHistory",
+  "createRootRoute",
+  "createRouter",
+  "RouterProvider"
+], TANSTACK_ROUTER_PACKAGES = [
+  "@tanstack/react-router",
+  "@tanstack/router-core",
+  "@tanstack/start",
+  "@tanstack/react-start"
+], fileLooksLikeTanstackRouterDecorator = (content) => TANSTACK_ROUTER_PACKAGES.some(
+  (pkg) => new RegExp(`from\\s+['"]${pkg.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}['"]`).test(content)
+) ? TANSTACK_ROUTER_DECORATOR_MARKERS.some((marker) => content.includes(marker)) : !1, detectTanstackRouterDecorator = async ({
+  previewConfigPath,
+  configDir,
+  storiesPaths
+}) => {
+  let { globby } = await import("./globby-4NOR2DQO.js"), configFiles = configDir ? await globby([`${configDir}/**/*.{ts,tsx,js,jsx,mjs,cjs}`], {
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  }) : [], candidateFiles = Array.from(
+    /* @__PURE__ */ new Set([...previewConfigPath ? [previewConfigPath] : [], ...configFiles, ...storiesPaths])
+  );
+  for (let file of candidateFiles)
+    try {
+      let content = await readFile7(file, "utf-8");
+      if (fileLooksLikeTanstackRouterDecorator(content))
+        return !0;
+    } catch {
+      continue;
+    }
+  return !1;
+}, transformMainConfig2 = async (mainConfigPath, dryRun) => {
+  try {
+    let content = await readFile7(mainConfigPath, "utf-8");
+    if (!content.includes(REACT_VITE_PACKAGE))
+      return !1;
+    let transformedContent = content.replaceAll(REACT_VITE_PACKAGE, TANSTACK_REACT_PACKAGE);
+    return transformedContent !== content && !dryRun && await writeFile6(mainConfigPath, transformedContent), transformedContent !== content;
+  } catch (error) {
+    return logger12.error(`Failed to update main config at ${mainConfigPath}: ${error}`), !1;
+  }
+}, buildAiMigrationPrompt = (previewConfigPath) => dedent9`
+    You are migrating a Storybook project from the "${REACT_VITE_PACKAGE}" framework to the
+    "${TANSTACK_REACT_PACKAGE}" framework. The framework swap in .storybook/main.* and the
+    package.json dependency change have already been performed by the Storybook automigration
+    CLI — do not redo those. Your job is to clean up the user-land code that the CLI cannot
+    safely transform.
+
+    Reference documentation:
+    https://storybook.js.org/docs/get-started/frameworks/tanstack-react
+
+    # Background
+
+    "${TANSTACK_REACT_PACKAGE}" is a TanStack Router-aware Storybook framework built on top
+    of @storybook/react-vite. It mounts every story inside a TanStack Router (in-memory
+    history) automatically. Manual router setup that users previously wired into a
+    decorator is now redundant and must be removed — leaving it in place creates a nested
+    router and breaks stories.
+
+    Telltale signs of a manual decorator that must be removed (any of these in
+    preview / decorator / story files):
+      - imports from "@tanstack/react-router", "@tanstack/router-core",
+        "@tanstack/start", or "@tanstack/react-start" used to construct a router
+      - calls to createMemoryHistory(...), createRootRoute(...), createRouter(...)
+      - JSX usage of <RouterProvider router={...} />
+      - a decorator function (e.g. const withRouter = (Story) => <RouterProvider .../>)
+        wired into "decorators: [...]" of a meta or preview
+
+    # The replacement APIs from "${TANSTACK_REACT_PACKAGE}"
+
+    All of the following are exported from "${TANSTACK_REACT_PACKAGE}" — re-exporting the
+    @storybook/react primitives plus the TanStack-specific additions. Use these instead of
+    a hand-rolled router decorator. Only opt in when a story actually needs a specific
+    route — by default the framework's auto-router is enough.
+
+    1) Preview-level default route (CSF factories — recommended).
+
+       In ${previewConfigPath ?? ".storybook/preview.*"}:
+
+         import { definePreview } from '@storybook/tanstack-react';
+         import { routeTree } from '../src/routeTree.gen'; // or a custom Route
+
+         export default definePreview({
+           // optional — registers a default route for every story in the project
+           route: routeTree,
+           parameters: { /* ... */ },
+         });
+
+    2) Per-meta route via "parameters.tanstack.router" (works with both CSF factories
+       and CSF3). Most TanStack-Router-decorator removals translate to this:
+
+         // CSF factories style (preferred when the project already uses preview.meta):
+         import preview from '#.storybook/preview';
+         import { Route } from './Page';
+
+         const meta = preview.meta({
+           title: 'Example/Page',
+           parameters: {
+             tanstack: {
+               router: {
+                 route: Route,
+               },
+             },
+           },
+         });
+
+         export const Default = meta.story();
+
+         // CSF3 style:
+         import type { Meta, StoryObj } from '@storybook/tanstack-react';
+         import { Route } from './Page';
+
+         const meta = {
+           title: 'Example/Page',
+           parameters: {
+             tanstack: { router: { route: Route } },
+           },
+         } satisfies Meta<typeof Route>;
+
+         export default meta;
+         export const Default: StoryObj<typeof meta> = {};
+
+    3) Per-story override — same shape, but on a single story's "parameters" instead of
+       the meta. Useful when one story needs a different route than the others.
+
+    4) Additional "parameters.tanstack.router" fields you can use when needed:
+         - "path"           initial pathname (e.g. '/users/$id')
+         - "params"         URL params object (typed against the route)
+         - "query"          search params object (typed against the route)
+         - "routeOverrides" map of route id -> { loader / beforeLoad / validateSearch / ... }
+                            for mocking specific routes in the registered tree
+         - "useRouterContext" function that returns a custom router context per story
+
+       Do NOT introduce any of these unless the original decorator was clearly setting up
+       that exact behavior. Remove the decorator first; only port over the bits that were
+       actually doing work.
+
+    5) Type imports. If the project uses CSF3 types, switch them from "@storybook/react"
+       (or "@storybook/react-vite") to "@storybook/tanstack-react":
+
+         - import type { Meta, StoryObj } from '@storybook/react';
+         + import type { Meta, StoryObj } from '@storybook/tanstack-react';
+
+       The TanStack-aware "Meta" infers TanStack parameter types from the route in
+       "component" / parameters, giving type-safe params/query.
+
+    # Tasks (perform in order, in the user's repository)
+
+    1. Open ${previewConfigPath ?? ".storybook/preview.*"} and remove any TanStack Router
+       decorator from the "decorators" array. The decorator may be:
+         - defined inline in this file, or
+         - imported from another module (commonly .storybook/decorators.ts,
+           .storybook/withRouter.tsx, or similar) — in that case remove BOTH the
+           import + usage here AND delete the decorator definition at its source.
+       If the source decorator file becomes empty after removal, delete the file.
+
+       Confirm "definePreview" is imported from "@storybook/tanstack-react" (not
+       "@storybook/react" or "@storybook/react-vite"). If the project has a single
+       project-wide route to register, pass it via "definePreview({ route })".
+
+    2. Search the whole repository (not just .storybook/) for any *.stories.* file that
+       declares a per-story or per-meta TanStack Router decorator and remove it. If the
+       removed decorator was setting up a specific route, port that to
+       "parameters.tanstack.router" using the APIs above (route / path / params / query /
+       routeOverrides — whichever applies).
+
+    3. Drop now-unused imports of: RouterProvider, createRouter, createMemoryHistory,
+       createRootRoute, Outlet (from "@tanstack/react-router" / "@tanstack/router-core" /
+       "@tanstack/start" / "@tanstack/react-start"). Keep imports that are still
+       legitimately used elsewhere in the file (Link, useNavigate, createRoute when used
+       to build a Route passed to "parameters.tanstack.router.route", etc.).
+
+    4. Update story-type imports from "@storybook/react" / "@storybook/react-vite" to
+       "@storybook/tanstack-react" wherever the story uses TanStack router parameters,
+       so the types pick up the TanStack additions.
+
+    5. Preserve CSF factories syntax. If the file uses
+       "definePreview({...})" / "preview.meta({...})" / "meta.story(...)", keep that shape;
+       only mutate the affected fields. Do not rewrite CSF1/CSF2/CSF3 -> CSF factories or
+       vice versa.
+
+    6. Preserve all other decorators, parameters, args, argTypes, loaders, beforeEach,
+       tags, and globals exactly as they were. Only the TanStack Router decorator is
+       being removed.
+
+    7. Do not edit .storybook/main.*, package.json, or any lockfile — those are already
+       handled by the automigration CLI.
+
+    # Verification checklist before finishing
+
+      - No remaining manual "RouterProvider", "createRouter", "createMemoryHistory",
+        "createRootRoute" usage in preview, .storybook/**, or *.stories.*.
+      - "decorators" arrays no longer contain the removed TanStack Router decorator.
+      - All previously imported router symbols that are no longer referenced are gone.
+      - Story files importing TanStack-aware types use "@storybook/tanstack-react".
+      - TypeScript still compiles. Storybook still loads. Stories that don't need a
+        specific route now rely on the framework's default in-memory router; stories
+        that do specify a route do so via "parameters.tanstack.router".
+  `, reactViteToTanstackReact = {
+  id: "react-vite-to-tanstack-react",
+  link: "https://storybook.js.org/docs/get-started/frameworks/tanstack-react",
+  defaultSelected: !1,
+  async check({
+    packageManager,
+    previewConfigPath,
+    configDir,
+    storiesPaths
+  }) {
+    let allDeps = packageManager.getAllDependencies(), hasReactVitePackage = !!allDeps[REACT_VITE_PACKAGE], hasTanstackRouter = TANSTACK_ROUTER_PACKAGES.some((pkg) => !!allDeps[pkg]);
+    return !hasReactVitePackage || !hasTanstackRouter ? null : {
+      hasTanstackRouterDecorator: await detectTanstackRouterDecorator({
+        previewConfigPath,
+        configDir,
+        storiesPaths: storiesPaths ?? []
+      })
+    };
+  },
+  prompt() {
+    return `Migrate from ${REACT_VITE_PACKAGE} to ${TANSTACK_REACT_PACKAGE} (TanStack Router-aware framework)`;
+  },
+  async run({
+    result,
+    dryRun = !1,
+    mainConfigPath,
+    previewConfigPath,
+    storiesPaths,
+    configDir,
+    packageManager,
+    storybookVersion,
+    yes
+  }) {
+    if (!result)
+      return;
+    logger12.step(`Migrating from ${REACT_VITE_PACKAGE} to ${TANSTACK_REACT_PACKAGE}...`), dryRun ? logger12.debug("Dry run: Skipping package.json updates.") : (logger12.debug("Updating package.json files..."), await packageManager.removeDependencies([REACT_VITE_PACKAGE]), await packageManager.addDependencies({ type: "devDependencies", skipInstall: !0 }, [
+      `${TANSTACK_REACT_PACKAGE}@${storybookVersion}`
+    ])), mainConfigPath && (logger12.debug("Updating main config file..."), await transformMainConfig2(mainConfigPath, dryRun)), logger12.debug("Scanning and updating import statements...");
+    let { globby } = await import("./globby-4NOR2DQO.js"), configFiles = configDir ? await globby([`${configDir}/**/*.{ts,tsx,js,jsx,mjs,cjs}`], {
+      ignore: ["**/node_modules/**", "**/dist/**"]
+    }) : [], allFiles = [...storiesPaths, ...configFiles, previewConfigPath].filter(
+      Boolean
+    ), transformErrors = await transformImportFiles3(
+      allFiles,
+      {
+        [REACT_VITE_PACKAGE]: TANSTACK_REACT_PACKAGE
+      },
+      !!dryRun
+    );
+    if (transformErrors.length > 0 && (logger12.warn(`Encountered ${transformErrors.length} errors during file transformation:`), transformErrors.forEach(({ file, error }) => {
+      logger12.warn(`  - ${file}: ${error.message}`);
+    })), result.hasTanstackRouterDecorator && (logger12.logBox(
+      dedent9`
+          We detected what looks like a manual TanStack Router decorator in
+          ${import_picocolors11.default.cyan(previewConfigPath ?? ".storybook/preview")}.
+
+          ${import_picocolors11.default.bold(TANSTACK_REACT_PACKAGE)} wraps every story in a TanStack Router
+          automatically (see ${import_picocolors11.default.yellow(
+        "https://storybook.js.org/docs/get-started/frameworks/tanstack-react"
+      )}), so that decorator is no longer needed and should be removed.
+        `
+    ), yes ? !0 : await prompt3.confirm({
+      message: "Would you like a ready-to-paste AI prompt to help remove the now-unused TanStack Router decorator?",
+      initialValue: !0
+    }))) {
+      let aiPrompt = buildAiMigrationPrompt(previewConfigPath), separator = import_picocolors11.default.dim("\u2500".repeat(60)), clipboardOk = !1;
+      try {
+        await writeText(aiPrompt), clipboardOk = !0;
+      } catch {
+      }
+      logger12.logBox(
+        dedent9`${clipboardOk ? "AI migration prompt copied to clipboard. Full prompt below:" : "Clipboard not available in this environment. Copy the AI migration prompt below manually:"}
+
+            ${separator}
+            ${aiPrompt}
+            ${separator}`
+      );
+    }
+    logger12.step("Migration completed successfully!"), logger12.log(
+      "For more information, see: https://storybook.js.org/docs/get-started/frameworks/tanstack-react"
+    );
+  }
+};
+
 // src/automigrate/fixes/remove-addon-interactions.ts
 import { getAddonNames as getAddonNames5, removeAddon as removeAddon4 } from "storybook/internal/common";
 var removeAddonInteractions = {
@@ -7257,10 +7590,10 @@ var removeAddonInteractions = {
 };
 
 // src/automigrate/fixes/remove-docs-autodocs.ts
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 import { Tag } from "storybook/internal/core-server";
 import { readConfig as readConfig2 } from "storybook/internal/csf-tools";
-var logger12 = {
+var logger13 = {
   log: (message) => {
     process.env.NODE_ENV !== "test" && console.log(message);
   }
@@ -7279,13 +7612,13 @@ var logger12 = {
       return null;
     }
   },
-  prompt: () => `${import_picocolors11.default.cyan("docs.autodocs")} has been removed in Storybook 9 and will be removed from your configuration.`,
+  prompt: () => `${import_picocolors12.default.cyan("docs.autodocs")} has been removed in Storybook 9 and will be removed from your configuration.`,
   async run({ result, dryRun, mainConfigPath, previewConfigPath }) {
     let { autodocs } = result;
-    logger12.log(`\u{1F504} Updating ${import_picocolors11.default.cyan("docs")} parameter in main config file...`), await updateMainConfig({ mainConfigPath, dryRun: !!dryRun }, async (main) => {
+    logger13.log(`\u{1F504} Updating ${import_picocolors12.default.cyan("docs")} parameter in main config file...`), await updateMainConfig({ mainConfigPath, dryRun: !!dryRun }, async (main) => {
       let docs = main.getFieldValue(["docs"]) || {};
       dryRun || (delete docs.autodocs, Object.keys(docs).length === 0 ? main.removeField(["docs"]) : main.setFieldValue(["docs"], docs));
-    }), autodocs === !0 && previewConfigPath && (logger12.log(`\u{1F504} Updating ${import_picocolors11.default.cyan("tags")} parameter in preview config file...`), await updateMainConfig(
+    }), autodocs === !0 && previewConfigPath && (logger13.log(`\u{1F504} Updating ${import_picocolors12.default.cyan("tags")} parameter in preview config file...`), await updateMainConfig(
       { mainConfigPath: previewConfigPath, dryRun: !!dryRun },
       async (preview) => {
         let tags = preview.getFieldValue(["tags"]) || [];
@@ -7296,7 +7629,7 @@ var logger12 = {
 };
 
 // src/automigrate/fixes/remove-essentials.ts
-import { getAddonNames as getAddonNames6, removeAddon as removeAddon5, transformImportFiles as transformImportFiles3 } from "storybook/internal/common";
+import { getAddonNames as getAddonNames6, removeAddon as removeAddon5, transformImportFiles as transformImportFiles4 } from "storybook/internal/common";
 
 // src/automigrate/fixes/remove-essentials.utils.ts
 function moveEssentialOptions(dryRun, essentialsOptions) {
@@ -7390,7 +7723,7 @@ var consolidatedAddons = {
           packageManager,
           skipInstall: !0
         });
-      let errors = await transformImportFiles3(
+      let errors = await transformImportFiles4(
         [...storiesPaths, mainConfigPath, previewConfigPath].filter(Boolean),
         consolidatedAddons,
         dryRun
@@ -7416,13 +7749,13 @@ ${errors.map(({ file, error }) => `- ${file}: ${error.message}`).join(`
 };
 
 // src/automigrate/fixes/renderer-to-framework.ts
-import { readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
 import {
   frameworkPackages as frameworkPackages4,
   frameworkToRenderer,
   rendererPackages as rendererPackages2
 } from "storybook/internal/common";
-import { logger as logger13 } from "storybook/internal/node-logger";
+import { logger as logger14 } from "storybook/internal/node-logger";
 var getAllDependencies = (packageJson) => Object.keys({
   ...packageJson.dependencies || {},
   ...packageJson.devDependencies || {}
@@ -7430,13 +7763,13 @@ var getAllDependencies = (packageJson) => Object.keys({
   let regex = new RegExp(`(['"])${renderer}(['"])`, "g");
   return regex.test(source) ? source.replace(regex, `$1${framework}$2`) : null;
 }, transformSourceFiles = async (files, renderer, framework, dryRun) => {
-  let errors = [], { default: pLimit } = await import("./p-limit-SUJZ4KSM.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-BPN7VYEH.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
         try {
-          let contents = await readFile7(file, "utf-8"), transformed = replaceImports(contents, renderer, framework);
-          !dryRun && transformed && await writeFile6(file, transformed);
+          let contents = await readFile8(file, "utf-8"), transformed = replaceImports(contents, renderer, framework);
+          !dryRun && transformed && await writeFile7(file, transformed);
         } catch (error) {
           errors.push({ file, error });
         }
@@ -7445,13 +7778,13 @@ var getAllDependencies = (packageJson) => Object.keys({
   ), errors;
 }, removeRendererInPackageJson = async (packageJsonPath, renderer, dryRun) => {
   try {
-    let content = await readFile7(packageJsonPath, "utf-8"), packageJson = JSON.parse(content), hasChanges = !1;
-    return packageJson.dependencies?.[renderer] && (delete packageJson.dependencies[renderer], hasChanges = !0), packageJson.devDependencies?.[renderer] && (delete packageJson.devDependencies[renderer], hasChanges = !0), !dryRun && hasChanges && await writeFile6(packageJsonPath, JSON.stringify(packageJson, null, 2)), hasChanges;
+    let content = await readFile8(packageJsonPath, "utf-8"), packageJson = JSON.parse(content), hasChanges = !1;
+    return packageJson.dependencies?.[renderer] && (delete packageJson.dependencies[renderer], hasChanges = !0), packageJson.devDependencies?.[renderer] && (delete packageJson.devDependencies[renderer], hasChanges = !0), !dryRun && hasChanges && await writeFile7(packageJsonPath, JSON.stringify(packageJson, null, 2)), hasChanges;
   } catch (error) {
     throw new Error(`Failed to update package.json: ${error}`);
   }
 }, checkPackageJson = async (packageJsonPath) => {
-  let content = await readFile7(packageJsonPath, "utf-8"), packageJson = JSON.parse(content), dependencies = getAllDependencies(packageJson), frameworks = detectFrameworks(dependencies);
+  let content = await readFile8(packageJsonPath, "utf-8"), packageJson = JSON.parse(content), dependencies = getAllDependencies(packageJson), frameworks = detectFrameworks(dependencies);
   if (frameworks.length === 0)
     return null;
   let renderers = detectRenderers(dependencies);
@@ -7485,25 +7818,25 @@ var getAllDependencies = (packageJson) => Object.keys({
     let { result, dryRun = !1, storiesPaths, configDir } = options;
     for (let selectedFramework of result.frameworks) {
       if (!frameworkPackages4[selectedFramework]) {
-        logger13.warn(`Framework name not found for ${selectedFramework}, skipping.`);
+        logger14.warn(`Framework name not found for ${selectedFramework}, skipping.`);
         continue;
       }
       let rendererName = frameworkToRenderer[frameworkPackages4[selectedFramework]], [rendererPackage] = Object.entries(rendererPackages2).find(([, renderer]) => renderer === rendererName) ?? [];
       if (!rendererPackage) {
-        logger13.warn(`Renderer package not found for ${selectedFramework}, skipping.`);
+        logger14.warn(`Renderer package not found for ${selectedFramework}, skipping.`);
         continue;
       }
       if (rendererPackage === selectedFramework)
         continue;
-      logger13.debug(`
+      logger14.debug(`
 Migrating ${rendererPackage} to ${selectedFramework}`);
-      let { globby } = await import("./globby-GGFRIMJG.js"), configFiles = await globby([`${configDir}/**/*`]);
+      let { globby } = await import("./globby-4NOR2DQO.js"), configFiles = await globby([`${configDir}/**/*`]);
       await transformSourceFiles(
         [...storiesPaths, ...configFiles].filter(Boolean),
         rendererPackage,
         selectedFramework,
         dryRun
-      ), logger13.debug("Updating package.json files..."), await Promise.all(
+      ), logger14.debug("Updating package.json files..."), await Promise.all(
         result.packageJsonFiles.map(
           (file) => removeRendererInPackageJson(file, rendererPackage, dryRun)
         )
@@ -7512,29 +7845,105 @@ Migrating ${rendererPackage} to ${selectedFramework}`);
   }
 };
 
-// src/automigrate/fixes/rnstorybook-config.ts
+// src/automigrate/fixes/rn-ondevice-addons-to-device-addons.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile8, rename, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { dedent as dedent9 } from "ts-dedent";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+import { findConfigFile, loadMainConfig } from "storybook/internal/common";
+import { logger as logger15 } from "storybook/internal/node-logger";
+
+// ../../core/src/shared/constants/config-folder.ts
+var RN_STORYBOOK_DIR = ".rnstorybook";
+
+// src/automigrate/fixes/rn-ondevice-addons-to-device-addons.ts
+var resolveAbsoluteConfigDir = (configDir) => isAbsolute2(configDir) ? configDir : join2(process.cwd(), configDir), getSiblingStorybookConfigDir = (configDirAbs) => {
+  let base = basename2(configDirAbs), parent = dirname2(configDirAbs);
+  if (base === ".storybook") {
+    let rn = join2(parent, RN_STORYBOOK_DIR);
+    return existsSync2(rn) ? rn : null;
+  }
+  if (base === RN_STORYBOOK_DIR) {
+    let web = join2(parent, ".storybook");
+    return existsSync2(web) ? web : null;
+  }
+  return null;
+}, isReactNativeMain = (mainConfigPath, mainConfig) => basename2(dirname2(mainConfigPath)) === RN_STORYBOOK_DIR ? !0 : getFrameworkPackageName(mainConfig) === "@storybook/react-native", hasAddonsToRename = (cfg) => {
+  let addons = cfg.addons;
+  return !(!Array.isArray(addons) || addons.length === 0 || cfg.deviceAddons !== void 0);
+}, rnOndeviceAddonsToDeviceAddons = {
+  id: "rn-ondevice-addons-to-device-addons",
+  link: "https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#react-native-on-device-addons-moved-to-deviceaddons",
+  async check({ mainConfig, packageManager, configDir, mainConfigPath }) {
+    if (!packageManager.getAllDependencies()["@storybook/react-native"])
+      return null;
+    let candidateDirs = [];
+    if (configDir) {
+      let absConfigDir = resolveAbsoluteConfigDir(configDir);
+      candidateDirs.push(absConfigDir);
+      let siblingConfigDir = getSiblingStorybookConfigDir(absConfigDir);
+      siblingConfigDir && candidateDirs.push(siblingConfigDir);
+    }
+    let targets = [], seenResolvedMainPaths = /* @__PURE__ */ new Set();
+    if (candidateDirs.length > 0)
+      for (let dir of candidateDirs) {
+        let mainPath = findConfigFile("main", dir);
+        if (!mainPath)
+          continue;
+        let resolvedMain = resolve2(mainPath);
+        if (seenResolvedMainPaths.has(resolvedMain))
+          continue;
+        seenResolvedMainPaths.add(resolvedMain);
+        let cfg;
+        if (mainConfigPath && resolve2(mainConfigPath) === resolvedMain)
+          cfg = mainConfig;
+        else
+          try {
+            cfg = await loadMainConfig({ configDir: dir });
+          } catch (e) {
+            logger15.debug(
+              `Failed to load Storybook main config at ${dir}: ${e instanceof Error ? e.message : String(e)}`
+            );
+            continue;
+          }
+        isReactNativeMain(mainPath, cfg) && hasAddonsToRename(cfg) && targets.push({ mainConfigPath: mainPath });
+      }
+    else mainConfigPath && isReactNativeMain(mainConfigPath, mainConfig) && hasAddonsToRename(mainConfig) && targets.push({ mainConfigPath });
+    return targets.length === 0 ? null : { targets };
+  },
+  prompt() {
+    return "Renaming `addons` to `deviceAddons` in your React Native Storybook config (on-device addons must not be evaluated as Node.js presets).";
+  },
+  async run({ result, dryRun }) {
+    for (let { mainConfigPath } of result.targets)
+      await updateMainConfig({ mainConfigPath, dryRun: !!dryRun }, (main) => {
+        let node = main.getFieldNode(["addons"]);
+        node && (main.setFieldNode(["deviceAddons"], node), main.removeField(["addons"]));
+      });
+  }
+};
+
+// src/automigrate/fixes/rnstorybook-config.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile9, rename, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { dedent as dedent10 } from "ts-dedent";
 async function renameInFile(filePath, oldText, newText) {
   try {
-    let updatedContent = (await readFile8(filePath, "utf8")).replaceAll(oldText, newText);
-    await writeFile7(filePath, updatedContent, "utf8");
+    let updatedContent = (await readFile9(filePath, "utf8")).replaceAll(oldText, newText);
+    await writeFile8(filePath, updatedContent, "utf8");
   } catch (error) {
     console.error(`Error updating references in ${filePath}:`, error);
   }
 }
 var getDotStorybookReferences = async (searchDir) => {
   try {
-    let { globby } = await import("./globby-GGFRIMJG.js"), { readFile: readFile10 } = await import("node:fs/promises"), files = await globby(`${searchDir}/**/*`, {
+    let { globby } = await import("./globby-4NOR2DQO.js"), { readFile: readFile11 } = await import("node:fs/promises"), files = await globby(`${searchDir}/**/*`, {
       onlyFiles: !0,
       gitignore: !0
     }), referencedFiles = [];
     return await Promise.all(
       files.map(async (file) => {
         try {
-          (await readFile10(file, "utf8")).includes(".storybook") && referencedFiles.push(file);
+          (await readFile11(file, "utf8")).includes(".storybook") && referencedFiles.push(file);
         } catch {
         }
       })
@@ -7548,25 +7957,25 @@ var getDotStorybookReferences = async (searchDir) => {
   async check({ packageManager, mainConfigPath }) {
     if (!packageManager.getAllDependencies()["@storybook/react-native"])
       return null;
-    let projectDir = mainConfigPath ? join2(mainConfigPath, "..", "..") : process.cwd(), storybookDir = join2(projectDir, ".storybook"), rnStorybookDir = join2(projectDir, ".rnstorybook"), { globby } = await import("./globby-GGFRIMJG.js"), requiresFiles = await globby(join2(storybookDir, "storybook.requires.*"));
-    return existsSync2(storybookDir) && requiresFiles.length > 0 && !existsSync2(rnStorybookDir) ? { storybookDir, rnStorybookDir } : null;
+    let projectDir = mainConfigPath ? join3(mainConfigPath, "..", "..") : process.cwd(), storybookDir = join3(projectDir, ".storybook"), rnStorybookDir = join3(projectDir, RN_STORYBOOK_DIR), { globby } = await import("./globby-4NOR2DQO.js"), requiresFiles = await globby(join3(storybookDir, "storybook.requires.*"));
+    return existsSync3(storybookDir) && requiresFiles.length > 0 && !existsSync3(rnStorybookDir) ? { storybookDir, rnStorybookDir } : null;
   },
   prompt() {
-    return dedent9`We'll rename your .storybook directory to .rnstorybook and update all references to it.`;
+    return dedent10`We'll rename your .storybook directory to .rnstorybook and update all references to it.`;
   },
   async run({ result: { storybookDir, rnStorybookDir }, dryRun, packageManager }) {
     let instanceDir = packageManager.instanceDir, dotStorybookReferences = await getDotStorybookReferences(instanceDir);
     dryRun || (await Promise.all(
       dotStorybookReferences.map(async (ref) => {
-        await renameInFile(ref, ".storybook", ".rnstorybook");
+        await renameInFile(ref, ".storybook", RN_STORYBOOK_DIR);
       })
     ), await rename(storybookDir, rnStorybookDir));
   }
 };
 
 // src/automigrate/fixes/storybook-package-name-conflict.ts
-var import_picocolors12 = __toESM(require_picocolors(), 1);
-import { dedent as dedent10 } from "ts-dedent";
+var import_picocolors13 = __toESM(require_picocolors(), 1);
+import { dedent as dedent11 } from "ts-dedent";
 var storybookPackageNameConflict = {
   id: "storybookPackageNameConflict",
   promptType: "notification",
@@ -7576,15 +7985,15 @@ var storybookPackageNameConflict = {
     return packageName === "storybook" ? { packageName } : null;
   },
   prompt() {
-    return dedent10`
-      Your package.json ${import_picocolors12.default.cyan('"name"')} field is set to ${import_picocolors12.default.cyan('"storybook"')}.
+    return dedent11`
+      Your package.json ${import_picocolors13.default.cyan('"name"')} field is set to ${import_picocolors13.default.cyan('"storybook"')}.
 
       In npm, pnpm, or yarn workspaces this creates a symlink at
-      ${import_picocolors12.default.yellow("node_modules/storybook")} that shadows the real Storybook
-      package, causing ${import_picocolors12.default.red('"Cannot find module storybook/internal/..."')} errors.
+      ${import_picocolors13.default.yellow("node_modules/storybook")} that shadows the real Storybook
+      package, causing ${import_picocolors13.default.red('"Cannot find module storybook/internal/..."')} errors.
 
-      To fix this, rename the ${import_picocolors12.default.cyan('"name"')} field in your package.json
-      to something other than ${import_picocolors12.default.cyan('"storybook"')} (e.g. "my-storybook", "docs", "@myorg/storybook").
+      To fix this, rename the ${import_picocolors13.default.cyan('"name"')} field in your package.json
+      to something other than ${import_picocolors13.default.cyan('"storybook"')} (e.g. "my-storybook", "docs", "@myorg/storybook").
     `;
   }
 };
@@ -7592,10 +8001,10 @@ var storybookPackageNameConflict = {
 // src/automigrate/fixes/upgrade-storybook-related-dependencies.ts
 var import_semver5 = __toESM(require_semver(), 1);
 import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 import { isCorePackage, isSatelliteAddon } from "storybook/internal/common";
-import { logger as logger14 } from "storybook/internal/node-logger";
-import { dedent as dedent11 } from "ts-dedent";
+import { logger as logger16 } from "storybook/internal/node-logger";
+import { dedent as dedent12 } from "ts-dedent";
 async function getLatestVersions(packageManager, packages) {
   return Promise.all(
     packages.map(async ([packageName]) => ({
@@ -7606,14 +8015,14 @@ async function getLatestVersions(packageManager, packages) {
   );
 }
 function isValidVersionType(packageName, specifier) {
-  return specifier.startsWith("patch:") || specifier.startsWith("file:") || specifier.startsWith("link:") || specifier.startsWith("portal:") || specifier.startsWith("git:") || specifier.startsWith("git+") || specifier.startsWith("http:") || specifier.startsWith("https:") || specifier.startsWith("workspace:") ? (logger14.debug(`Skipping ${packageName} as it does not have a valid version type: ${specifier}`), !1) : !0;
+  return specifier.startsWith("patch:") || specifier.startsWith("file:") || specifier.startsWith("link:") || specifier.startsWith("portal:") || specifier.startsWith("git:") || specifier.startsWith("git+") || specifier.startsWith("http:") || specifier.startsWith("https:") || specifier.startsWith("workspace:") ? (logger16.debug(`Skipping ${packageName} as it does not have a valid version type: ${specifier}`), !1) : !0;
 }
 var upgradeStorybookRelatedDependencies = {
   id: "upgrade-storybook-related-dependencies",
   promptType: "auto",
   defaultSelected: !1,
   async check({ packageManager, storybookVersion }) {
-    logger14.debug("Checking for incompatible storybook packages...");
+    logger16.debug("Checking for incompatible storybook packages...");
     let analyzedPackages = await getIncompatibleStorybookPackages({
       currentStorybookVersion: storybookVersion,
       packageManager,
@@ -7634,7 +8043,7 @@ var upgradeStorybookRelatedDependencies = {
   },
   async run({ result: { upgradable }, packageManager, dryRun }) {
     if (dryRun) {
-      logger14.log(dedent11`
+      logger16.log(dedent12`
         The following would have been upgraded:
         ${upgradable.map(
         ({ packageName, afterVersion, beforeVersion }) => `${packageName}: ${beforeVersion} => ${afterVersion}`
@@ -7650,7 +8059,7 @@ var upgradeStorybookRelatedDependencies = {
           return;
         let { packageName, afterVersion: version2 } = item, prefixed = `^${version2}`;
         packageJson.dependencies?.[packageName] && (packageJson.dependencies[packageName] = prefixed), packageJson.devDependencies?.[packageName] && (packageJson.devDependencies[packageName] = prefixed), packageJson.peerDependencies?.[packageName] && (packageJson.peerDependencies[packageName] = prefixed);
-      }), packageManager.writePackageJson(packageJson, dirname2(packageJsonPath));
+      }), packageManager.writePackageJson(packageJson, dirname3(packageJsonPath));
     });
   }
 };
@@ -7666,7 +8075,7 @@ import {
 } from "storybook/internal/common";
 import { readConfig as readConfig3 } from "storybook/internal/csf-tools";
 import { CommonJsConfigNotSupportedError } from "storybook/internal/server-errors";
-import { dedent as dedent12 } from "ts-dedent";
+import { dedent as dedent13 } from "ts-dedent";
 var wrapGetAbsolutePath = {
   id: "wrap-getAbsolutePath",
   link: "https://storybook.js.org/docs/faq#how-do-i-fix-module-resolution-in-special-environments",
@@ -7683,7 +8092,7 @@ var wrapGetAbsolutePath = {
     return { storybookVersion, isStorybookInMonorepo, isPnp, isConfigTypescript };
   },
   prompt() {
-    return dedent12`We have detected that you're using Storybook in a monorepo or PnP project. Some fields in your main config must be updated.`;
+    return dedent13`We have detected that you're using Storybook in a monorepo or PnP project. Some fields in your main config must be updated.`;
   },
   async run({ dryRun, mainConfigPath, result }) {
     await updateMainConfig({ dryRun: !!dryRun, mainConfigPath }, (mainConfig) => {
@@ -7712,8 +8121,10 @@ var allFixes = [
   consolidatedImports,
   addonExperimentalTest,
   rnstorybookConfig,
+  rnOndeviceAddonsToDeviceAddons,
   migrateAddonConsole,
   nextjsToNextjsVite,
+  reactViteToTanstackReact,
   removeAddonInteractions,
   rendererToFramework,
   removeEssentials,
@@ -7726,9 +8137,9 @@ var allFixes = [
 var commandFixes = [csfFactories];
 
 // src/automigrate/helpers/logMigrationSummary.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
-import { CLI_COLORS as CLI_COLORS2, logger as logger15 } from "storybook/internal/node-logger";
-import { dedent as dedent13 } from "ts-dedent";
+var import_picocolors14 = __toESM(require_picocolors(), 1);
+import { CLI_COLORS as CLI_COLORS2, logger as logger17 } from "storybook/internal/node-logger";
+import { dedent as dedent14 } from "ts-dedent";
 var messageDivider2 = `
 
 `, segmentDivider = `
@@ -7738,23 +8149,23 @@ var messageDivider2 = `
 `;
 function getGlossaryMessages(fixSummary, fixResults) {
   let messages2 = [];
-  return fixSummary.succeeded.length > 0 && (messages2.push(import_picocolors13.default.bold("Successful migrations:")), messages2.push(fixSummary.succeeded.map((m) => import_picocolors13.default.green(m)).join(", "))), Object.keys(fixSummary.failed).length > 0 && (messages2.push(import_picocolors13.default.bold("Failed migrations:")), messages2.push(
-    Object.entries(fixSummary.failed).map(([id, error]) => `${import_picocolors13.default.bold(import_picocolors13.default.red(id))}:
+  return fixSummary.succeeded.length > 0 && (messages2.push(import_picocolors14.default.bold("Successful migrations:")), messages2.push(fixSummary.succeeded.map((m) => import_picocolors14.default.green(m)).join(", "))), Object.keys(fixSummary.failed).length > 0 && (messages2.push(import_picocolors14.default.bold("Failed migrations:")), messages2.push(
+    Object.entries(fixSummary.failed).map(([id, error]) => `${import_picocolors14.default.bold(import_picocolors14.default.red(id))}:
 ${error}`).join(`
 `)
-  )), fixSummary.manual.length > 0 && (messages2.push(import_picocolors13.default.bold("Manual migrations:")), messages2.push(
+  )), fixSummary.manual.length > 0 && (messages2.push(import_picocolors14.default.bold("Manual migrations:")), messages2.push(
     fixSummary.manual.map(
-      (m) => fixResults[m] === "manual_succeeded" /* MANUAL_SUCCEEDED */ ? import_picocolors13.default.green(m) : import_picocolors13.default.blue(m)
+      (m) => fixResults[m] === "manual_succeeded" /* MANUAL_SUCCEEDED */ ? import_picocolors14.default.green(m) : import_picocolors14.default.blue(m)
     ).join(", ")
-  )), fixSummary.skipped.length > 0 && (messages2.push(import_picocolors13.default.bold("Skipped migrations:")), messages2.push(fixSummary.skipped.map((m) => import_picocolors13.default.cyan(m)).join(", "))), messages2;
+  )), fixSummary.skipped.length > 0 && (messages2.push(import_picocolors14.default.bold("Skipped migrations:")), messages2.push(fixSummary.skipped.map((m) => import_picocolors14.default.cyan(m)).join(", "))), messages2;
 }
 function logMigrationSummary({
   fixResults,
   fixSummary
 }) {
   let messages2 = [];
-  messages2.push(getGlossaryMessages(fixSummary, fixResults).join(messageDivider2)), messages2.push(dedent13`If you'd like to run the migrations again, you can do so by running 
-    ${import_picocolors13.default.cyan("npx storybook automigrate")}
+  messages2.push(getGlossaryMessages(fixSummary, fixResults).join(messageDivider2)), messages2.push(dedent14`If you'd like to run the migrations again, you can do so by running 
+    ${import_picocolors14.default.cyan("npx storybook automigrate")}
     
     The automigrations try to migrate common patterns in your project, but might not contain everything needed to migrate to the latest version of Storybook.
     
@@ -7765,21 +8176,21 @@ function logMigrationSummary({
   let hasNoFixes = Object.values(fixResults).every((r) => r === "unnecessary" /* UNNECESSARY */), hasFailures2 = Object.values(fixResults).some(
     (r) => r === "failed" /* FAILED */ || r === "check_failed" /* CHECK_FAILED */
   );
-  hasNoFixes ? logger15.warn("No migrations were applicable to your project") : hasFailures2 ? logger15.error("Migration check ran with failures") : logger15.step(CLI_COLORS2.success("Migration check ran successfully")), logger15.log(messages2.filter(Boolean).join(segmentDivider));
+  hasNoFixes ? logger17.warn("No migrations were applicable to your project") : hasFailures2 ? logger17.error("Migration check ran with failures") : logger17.step(CLI_COLORS2.success("Migration check ran successfully")), logger17.log(messages2.filter(Boolean).join(segmentDivider));
 }
 
 // src/automigrate/index.ts
 var logAvailableMigrations = () => {
-  let availableFixes = [...allFixes, ...commandFixes].map((f) => import_picocolors14.default.yellow(f.id)).map((x) => `- ${x}`).join(`
+  let availableFixes = [...allFixes, ...commandFixes].map((f) => import_picocolors15.default.yellow(f.id)).map((x) => `- ${x}`).join(`
 `);
-  logger16.log(dedent14`
+  logger18.log(dedent15`
     The following migrations are available:
     ${availableFixes}
   `);
 }, hasFailures = (fixResults) => Object.values(fixResults || {}).some(
   (r) => r === "failed" /* FAILED */ || r === "check_failed" /* CHECK_FAILED */
 ), doAutomigrate = async (options) => {
-  logger16.debug("Extracting storybook data...");
+  logger18.debug("Extracting storybook data...");
   let {
     mainConfig,
     mainConfigPath,
@@ -7813,7 +8224,7 @@ var logAvailableMigrations = () => {
   ) && !options.skipInstall && await packageManager.installDependencies(), outcome && !options.skipDoctor && await doctor({ configDir, packageManager: options.packageManager }), hasFailures(outcome?.fixResults)) {
     let failedMigrations = Object.entries(outcome?.fixResults ?? {}).filter(([, status]) => status === "failed" /* FAILED */ || status === "check_failed" /* CHECK_FAILED */).map(([id, status]) => {
       let statusLabel = status === "check_failed" /* CHECK_FAILED */ ? "check failed" : "failed";
-      return `${import_picocolors14.default.cyan(id)} (${statusLabel})`;
+      return `${import_picocolors15.default.cyan(id)} (${statusLabel})`;
     });
     throw new AutomigrateError({ errors: failedMigrations });
   }
@@ -7842,7 +8253,7 @@ var logAvailableMigrations = () => {
     return logAvailableMigrations(), null;
   let commandFix = commandFixes.find((f) => f.id === fixId);
   if (commandFix)
-    return logger16.step(`Running migration ${import_picocolors14.default.magenta(fixId)}..`), await commandFix.run({
+    return logger18.step(`Running migration ${import_picocolors15.default.magenta(fixId)}..`), await commandFix.run({
       mainConfigPath,
       previewConfigPath,
       packageManager,
@@ -7857,8 +8268,8 @@ var logAvailableMigrations = () => {
     }), null;
   let selectedFixes = inputFixes || allFixes.filter((fix) => !(fix.id === upgradeStorybookRelatedDependencies.id && isLatest === !1 && fixId !== upgradeStorybookRelatedDependencies.id)), fixes = fixId ? selectedFixes.filter((f) => f.id === fixId) : selectedFixes;
   if (fixId && fixes.length === 0)
-    return logger16.log(`\u{1F4ED} No migrations found for ${import_picocolors14.default.magenta(fixId)}.`), logAvailableMigrations(), null;
-  logger16.step("Checking possible migrations..");
+    return logger18.log(`\u{1F4ED} No migrations found for ${import_picocolors15.default.magenta(fixId)}.`), logAvailableMigrations(), null;
+  logger18.step("Checking possible migrations..");
   let { fixResults, fixSummary, preCheckFailure } = await runFixes({
     fixes,
     packageManager,
@@ -7899,7 +8310,7 @@ async function runFixes({
   for (let i = 0; i < fixes.length; i += 1) {
     let f = fixes[i], result;
     try {
-      logger16.debug(`Running ${import_picocolors14.default.cyan(f.id)} migration checks`), result = await f.check({
+      logger18.debug(`Running ${import_picocolors15.default.cyan(f.id)} migration checks`), result = await f.check({
         packageManager,
         configDir,
         rendererPackage,
@@ -7909,14 +8320,14 @@ async function runFixes({
         mainConfigPath,
         storiesPaths,
         hasCsfFactoryPreview
-      }), logger16.debug(`End of ${import_picocolors14.default.cyan(f.id)} migration checks`);
+      }), logger18.debug(`End of ${import_picocolors15.default.cyan(f.id)} migration checks`);
     } catch (error) {
-      logger16.warn(`\u26A0\uFE0F  failed to check fix ${import_picocolors14.default.bold(f.id)}`), error instanceof Error && (logger16.error(`
+      logger18.warn(`\u26A0\uFE0F  failed to check fix ${import_picocolors15.default.bold(f.id)}`), error instanceof Error && (logger18.error(`
 ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "check_failed" /* CHECK_FAILED */;
     }
     if (result) {
       let promptType = typeof f.promptType == "function" ? await f.promptType(result) : f.promptType ?? "auto";
-      logger16.log(`\u{1F50E} found a '${import_picocolors14.default.cyan(f.id)}' migration:`);
+      logger18.log(`\u{1F50E} found a '${import_picocolors15.default.cyan(f.id)}' migration:`);
       let getTitle = () => {
         switch (promptType) {
           case "auto":
@@ -7926,11 +8337,11 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
           case "notification":
             return "Migration notification";
         }
-      }, currentTaskLogger = prompt3.taskLog({
+      }, currentTaskLogger = prompt4.taskLog({
         id: `automigrate-task-${f.id}`,
-        title: `${getTitle()}: ${import_picocolors14.default.cyan(f.id)}`
+        title: `${getTitle()}: ${import_picocolors15.default.cyan(f.id)}`
       });
-      logger16.logBox(f.prompt());
+      logger18.logBox(f.prompt());
       let runAnswer;
       try {
         if (dryRun)
@@ -7938,7 +8349,7 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
         else if (yes)
           runAnswer = { fix: !0 }, promptType === "manual" && (fixResults[f.id] = "manual_succeeded" /* MANUAL_SUCCEEDED */, fixSummary.manual.push(f.id));
         else if (promptType === "manual") {
-          if (fixResults[f.id] = "manual_succeeded" /* MANUAL_SUCCEEDED */, fixSummary.manual.push(f.id), !await prompt3.confirm(
+          if (fixResults[f.id] = "manual_succeeded" /* MANUAL_SUCCEEDED */, fixSummary.manual.push(f.id), !await prompt4.confirm(
             {
               message: "Select continue once you have made the required changes, or quit to exit the migration process",
               initialValue: !0,
@@ -7954,9 +8365,9 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
             fixResults[f.id] = "manual_skipped" /* MANUAL_SKIPPED */;
             break;
           }
-        } else promptType === "auto" ? runAnswer = { fix: yes ? !0 : await prompt3.confirm(
+        } else promptType === "auto" ? runAnswer = { fix: yes ? !0 : await prompt4.confirm(
           {
-            message: `Do you want to run the '${import_picocolors14.default.cyan(f.id)}' migration on your project?`,
+            message: `Do you want to run the '${import_picocolors15.default.cyan(f.id)}' migration on your project?`,
             initialValue: f.defaultSelected ?? !0
           },
           {
@@ -7964,7 +8375,7 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
               throw new Error();
             }
           }
-        ) } : promptType === "notification" && (runAnswer = { fix: await prompt3.confirm(
+        ) } : promptType === "notification" && (runAnswer = { fix: await prompt4.confirm(
           {
             message: "Do you want to continue?"
           },
@@ -7992,14 +8403,14 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
               storybookVersion,
               storiesPaths,
               yes
-            }), logger16.log(`\u2705 ran ${import_picocolors14.default.cyan(f.id)} migration`), fixResults[f.id] = "succeeded" /* SUCCEEDED */, fixSummary.succeeded.push(f.id), currentTaskLogger.success(`Ran ${import_picocolors14.default.cyan(f.id)} migration`);
+            }), logger18.log(`\u2705 ran ${import_picocolors15.default.cyan(f.id)} migration`), fixResults[f.id] = "succeeded" /* SUCCEEDED */, fixSummary.succeeded.push(f.id), currentTaskLogger.success(`Ran ${import_picocolors15.default.cyan(f.id)} migration`);
           } catch (error) {
             fixResults[f.id] = "failed" /* FAILED */;
             let errorMessage = error instanceof Error ? error.message : "Failed to run migration";
-            fixSummary.failed[f.id] = errorMessage, currentTaskLogger.error(`Error when running ${import_picocolors14.default.cyan(f.id)} migration`);
+            fixSummary.failed[f.id] = errorMessage, currentTaskLogger.error(`Error when running ${import_picocolors15.default.cyan(f.id)} migration`);
           }
         else
-          fixResults[f.id] = "skipped" /* SKIPPED */, fixSummary.skipped.push(f.id), currentTaskLogger.success(`Skipped ${import_picocolors14.default.cyan(f.id)} migration`);
+          fixResults[f.id] = "skipped" /* SKIPPED */, fixSummary.skipped.push(f.id), currentTaskLogger.success(`Skipped ${import_picocolors15.default.cyan(f.id)} migration`);
     } else
       fixResults[f.id] = fixResults[f.id] || "unnecessary" /* UNNECESSARY */;
   }
@@ -8008,26 +8419,26 @@ ${error.stack}`), fixSummary.failed[f.id] = error.message), fixResults[f.id] = "
 
 // src/link.ts
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import { mkdir, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
-import { basename as basename2, extname as extname2, join as join3 } from "node:path";
+import { mkdir, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
+import { basename as basename3, extname as extname2, join as join4 } from "node:path";
 import { executeCommand } from "storybook/internal/common";
-import { logger as logger17 } from "storybook/internal/node-logger";
+import { logger as logger19 } from "storybook/internal/node-logger";
 var link = async ({ target, local, start }) => {
   let storybookDir = process.cwd();
   try {
-    if (JSON.parse(await readFile9("package.json", { encoding: "utf8" })).name !== "@storybook/code")
+    if (JSON.parse(await readFile10("package.json", { encoding: "utf8" })).name !== "@storybook/code")
       throw new Error();
   } catch {
     throw new Error("Expected to run link from the root of the storybook monorepo");
   }
-  let reproDir = target, reproName = basename2(target);
+  let reproDir = target, reproName = basename3(target);
   if (!local) {
-    let reprosDir = join3(storybookDir, "../storybook-repros");
-    logger17.info(`Ensuring directory ${reprosDir}`), await mkdir(reprosDir, { recursive: !0 }), logger17.info(`Cloning ${target}`), await executeCommand({
+    let reprosDir = join4(storybookDir, "../storybook-repros");
+    logger19.info(`Ensuring directory ${reprosDir}`), await mkdir(reprosDir, { recursive: !0 }), logger19.info(`Cloning ${target}`), await executeCommand({
       command: "git",
       args: ["clone", target],
       cwd: reprosDir
-    }), reproName = basename2(target, extname2(target)), reproDir = join3(reprosDir, reproName);
+    }), reproName = basename3(target, extname2(target)), reproDir = join4(reprosDir, reproName);
   }
   let version2 = (0, import_cross_spawn.sync)("yarn", ["--version"], {
     cwd: reproDir,
@@ -8035,16 +8446,16 @@ var link = async ({ target, local, start }) => {
     shell: !0
   }).stdout.toString();
   if (!/^[2-4]\./.test(version2)) {
-    logger17.warn(`\u{1F6A8} Expected yarn 2 or higher in ${reproDir}!`), logger17.warn(""), logger17.warn("Please set it up with `yarn set version berry`,"), logger17.warn(`then link '${reproDir}' with the '--local' flag.`);
+    logger19.warn(`\u{1F6A8} Expected yarn 2 or higher in ${reproDir}!`), logger19.warn(""), logger19.warn("Please set it up with `yarn set version berry`,"), logger19.warn(`then link '${reproDir}' with the '--local' flag.`);
     return;
   }
-  logger17.info(`Linking ${reproDir}`), await executeCommand({
+  logger19.info(`Linking ${reproDir}`), await executeCommand({
     command: "yarn",
     args: ["link", "--all", "--relative", storybookDir],
     cwd: reproDir
-  }), logger17.info(`Installing ${reproName}`);
+  }), logger19.info(`Installing ${reproName}`);
   let reproPackageJson = JSON.parse(
-    await readFile9(join3(reproDir, "package.json"), { encoding: "utf8" })
+    await readFile10(join4(reproDir, "package.json"), { encoding: "utf8" })
   );
   reproPackageJson.devDependencies?.vite || (reproPackageJson.devDependencies = {
     ...reproPackageJson.devDependencies,
@@ -8052,11 +8463,11 @@ var link = async ({ target, local, start }) => {
   }), reproPackageJson.devDependencies = {
     ...reproPackageJson.devDependencies,
     "@types/node": "^22"
-  }, await writeFile8(join3(reproDir, "package.json"), JSON.stringify(reproPackageJson, null, 2)), await executeCommand({
+  }, await writeFile9(join4(reproDir, "package.json"), JSON.stringify(reproPackageJson, null, 2)), await executeCommand({
     command: "yarn",
     args: ["install"],
     cwd: reproDir
-  }), start && (logger17.info(`Running ${reproName} storybook`), await executeCommand({
+  }), start && (logger19.info(`Running ${reproName} storybook`), await executeCommand({
     command: "yarn",
     args: ["run", "storybook"],
     cwd: reproDir
@@ -8064,22 +8475,22 @@ var link = async ({ target, local, start }) => {
 };
 
 // src/migrate.ts
-import { logger as logger18 } from "storybook/internal/node-logger";
+import { logger as logger20 } from "storybook/internal/node-logger";
 import { listCodemods, runCodemod as runCodemod2 } from "@storybook/codemod";
 async function migrate(migration, { glob, dryRun, list, rename: rename2, parser }) {
   if (list)
-    listCodemods().forEach((key) => logger18.log(key));
+    listCodemods().forEach((key) => logger20.log(key));
   else if (migration)
-    await runCodemod2(migration, { glob, dryRun, logger: logger18, rename: rename2, parser });
+    await runCodemod2(migration, { glob, dryRun, logger: logger20, rename: rename2, parser });
   else
     throw new Error("Migrate: please specify a migration name or --list");
 }
 
 // src/sandbox.ts
 var import_cross_spawn2 = __toESM(require_cross_spawn(), 1);
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir2, readdir, rm } from "node:fs/promises";
-import { isAbsolute as isAbsolute2 } from "node:path";
+import { isAbsolute as isAbsolute3 } from "node:path";
 import { PackageManagerName } from "storybook/internal/common";
 import {
   JsPackageManagerFactory,
@@ -8087,9 +8498,9 @@ import {
   optionalEnvToBoolean as optionalEnvToBoolean2,
   versions as versions4
 } from "storybook/internal/common";
-import { logger as logger19, prompt as prompt4 } from "storybook/internal/node-logger";
-var import_picocolors15 = __toESM(require_picocolors(), 1), import_semver6 = __toESM(require_semver(), 1);
-import { dedent as dedent15 } from "ts-dedent";
+import { logger as logger21, prompt as prompt5 } from "storybook/internal/node-logger";
+var import_picocolors16 = __toESM(require_picocolors(), 1), import_semver6 = __toESM(require_semver(), 1);
+import { dedent as dedent16 } from "ts-dedent";
 
 // src/sandbox-templates.ts
 var baseTemplates = {
@@ -8204,7 +8615,8 @@ var baseTemplates = {
         features: {
           experimentalRSC: !0,
           developmentModeForBuild: !0,
-          experimentalTestSyntax: !0
+          experimentalTestSyntax: !0,
+          changeDetection: !0
         }
       },
       extraDependencies: ["server-only", "prop-types"]
@@ -8297,7 +8709,8 @@ var baseTemplates = {
         features: {
           experimentalRSC: !0,
           developmentModeForBuild: !0,
-          experimentalTestSyntax: !0
+          experimentalTestSyntax: !0,
+          changeDetection: !0
         }
       },
       extraDependencies: ["server-only", "vite", "prop-types"]
@@ -8339,7 +8752,8 @@ var baseTemplates = {
       mainConfig: {
         features: {
           developmentModeForBuild: !0,
-          experimentalTestSyntax: !0
+          experimentalTestSyntax: !0,
+          changeDetection: !0
         }
       }
     },
@@ -8470,6 +8884,46 @@ var baseTemplates = {
     },
     skipTasks: ["e2e-tests", "e2e-tests-dev", "bench", "vitest-integration"]
   },
+  "tanstack-react-router/default-ts": {
+    name: "TanStack React Router Latest (Vite | TypeScript)",
+    script: "npx @tanstack/cli@latest create {{beforeDir}} --tailwind --router-only",
+    expected: {
+      framework: "@storybook/tanstack-react",
+      renderer: "@storybook/react",
+      builder: "@storybook/builder-vite"
+    },
+    modifications: {
+      useCsfFactory: !0,
+      extraDependencies: ["prop-types"],
+      mainConfig: {
+        framework: "@storybook/tanstack-react",
+        features: {
+          experimentalTestSyntax: !0
+        }
+      }
+    },
+    skipTasks: ["bench"]
+  },
+  "tanstack-react-start/default-ts": {
+    name: "TanStack React Start Latest (Vite | TypeScript)",
+    script: "npx @tanstack/cli@latest create {{beforeDir}} --tailwind",
+    expected: {
+      framework: "@storybook/tanstack-react",
+      renderer: "@storybook/react",
+      builder: "@storybook/builder-vite"
+    },
+    modifications: {
+      useCsfFactory: !0,
+      extraDependencies: ["prop-types"],
+      mainConfig: {
+        framework: "@storybook/tanstack-react",
+        features: {
+          experimentalTestSyntax: !0
+        }
+      }
+    },
+    skipTasks: ["bench"]
+  },
   "vue3-vite/default-js": {
     name: "Vue v3 (Vite | JavaScript)",
     script: "npm create vite --yes {{beforeDir}} -- --template vue",
@@ -8953,7 +9407,9 @@ var baseTemplates = {
   "bench/react-vite-default-ts-test-build",
   "bench/react-webpack-18-ts-test-build",
   // 'ember/default-js',
-  "react-rsbuild/default-ts"
+  "react-rsbuild/default-ts",
+  "tanstack-react-router/default-ts",
+  "tanstack-react-start/default-ts"
 ], merged = [
   ...normal,
   "react-webpack/18-ts",
@@ -8999,20 +9455,20 @@ var toChoices = (c) => ({ label: allTemplates[c].name, value: c }), sandbox = as
   let selectedConfig = allTemplates[filterValue], templateId = selectedConfig ? filterValue : null, packageManager = JsPackageManagerFactory.getPackageManager({
     force: PackageManagerName.NPM
   }), latestVersion = await packageManager.latestVersion("storybook"), nextVersion = await packageManager.latestVersion("storybook@next") ?? "0.0.0", currentVersion = versions4.storybook, isPrerelease = (0, import_semver6.prerelease)(currentVersion), isOutdated = (0, import_semver6.lt)(currentVersion, isPrerelease ? nextVersion : latestVersion), downloadType = !isOutdated && init ? "after-storybook" : "before-storybook", branch = isPrerelease ? "next" : "main", messages2 = {
-    welcome: `Creating a Storybook ${import_picocolors15.default.bold(currentVersion)} sandbox..`,
-    notLatest: import_picocolors15.default.red(dedent15`
-      This version is behind the latest release, which is: ${import_picocolors15.default.bold(latestVersion)}!
+    welcome: `Creating a Storybook ${import_picocolors16.default.bold(currentVersion)} sandbox..`,
+    notLatest: import_picocolors16.default.red(dedent16`
+      This version is behind the latest release, which is: ${import_picocolors16.default.bold(latestVersion)}!
       You likely ran the init command through npx, which can use a locally cached version, to get the latest please run:
-      ${import_picocolors15.default.bold("npx storybook@latest sandbox")}
+      ${import_picocolors16.default.bold("npx storybook@latest sandbox")}
       
       You may want to CTRL+C to stop, and run with the latest version instead.
     `),
-    longInitTime: import_picocolors15.default.yellow(
+    longInitTime: import_picocolors16.default.yellow(
       "The creation of the sandbox will take longer, because we will need to run init."
     ),
-    prerelease: import_picocolors15.default.yellow("This is a pre-release version.")
+    prerelease: import_picocolors16.default.yellow("This is a pre-release version.")
   };
-  if (logger19.logBox(
+  if (logger21.logBox(
     [messages2.welcome].concat(isOutdated && !isPrerelease ? [messages2.notLatest] : []).concat(init && (isOutdated || isPrerelease) ? [messages2.longInitTime] : []).concat(isPrerelease ? [messages2.prerelease] : []).join(`
 `),
     {
@@ -9023,24 +9479,24 @@ var toChoices = (c) => ({ label: allTemplates[c].name, value: c }), sandbox = as
       let current = allTemplates[group];
       return (!filterValue || current.name.match(filterRegex) || group.match(filterRegex) || current.expected.builder.match(filterRegex) || current.expected.framework.match(filterRegex) || current.expected.renderer.match(filterRegex)) && acc.push(group), acc;
     }, []);
-    if (choices.length === 0 && (logger19.logBox(
-      dedent15`
+    if (choices.length === 0 && (logger21.logBox(
+      dedent16`
             🔎 You filtered out all templates. 🔍
 
-            After filtering all the templates with "${import_picocolors15.default.yellow(
+            After filtering all the templates with "${import_picocolors16.default.yellow(
         filterValue
       )}", we found no results. Please try again with a different filter.
 
             Available templates:
-            ${keys.map((key) => import_picocolors15.default.blue(`- ${key}`)).join(`
+            ${keys.map((key) => import_picocolors16.default.blue(`- ${key}`)).join(`
 `)}
             `.trim(),
       { borderStyle: "round", padding: 1, borderColor: "#F1618C" }
-    ), process.exit(1)), choices.length === 1 ? [templateId] = choices : (logger19.logBox(
-      dedent15`
-            🤗 Welcome to ${import_picocolors15.default.yellow("sb sandbox")}! 🤗
+    ), process.exit(1)), choices.length === 1 ? [templateId] = choices : (logger21.logBox(
+      dedent16`
+            🤗 Welcome to ${import_picocolors16.default.yellow("sb sandbox")}! 🤗
 
-            Create a ${import_picocolors15.default.green("new project")} to minimally reproduce Storybook issues.
+            Create a ${import_picocolors16.default.green("new project")} to minimally reproduce Storybook issues.
 
             1. select an environment that most closely matches your project setup.
             2. select a location for the reproduction, outside of your project.
@@ -9049,36 +9505,36 @@ var toChoices = (c) => ({ label: allTemplates[c].name, value: c }), sandbox = as
             `.trim(),
       { borderStyle: "round", padding: 1, borderColor: "#F1618C" }
     ), templateId = await promptSelectedTemplate(choices)), !!!(templateId ?? null)) {
-      logger19.error("Somehow we got no templates. Please rerun this command!");
+      logger21.error("Somehow we got no templates. Please rerun this command!");
       return;
     }
     if (selectedConfig = templateId ? allTemplates[templateId] : void 0, !selectedConfig)
       throw new Error("\u{1F6A8} Sandbox: please specify a valid template type");
   }
   let selectedDirectory = outputDirectory, outputDirectoryName = outputDirectory || templateId;
-  selectedDirectory && existsSync3(`${selectedDirectory}`) && (logger19.log(`\u26A0\uFE0F  ${selectedDirectory} already exists! Overwriting...`), await rm(selectedDirectory, { recursive: !0, force: !0 })), selectedDirectory || (selectedDirectory = await prompt4.text(
+  selectedDirectory && existsSync4(`${selectedDirectory}`) && (logger21.log(`\u26A0\uFE0F  ${selectedDirectory} already exists! Overwriting...`), await rm(selectedDirectory, { recursive: !0, force: !0 })), selectedDirectory || (selectedDirectory = await prompt5.text(
     {
       message: "Enter the output directory",
       initialValue: outputDirectoryName ?? void 0,
-      validate: (directoryName) => directoryName && existsSync3(directoryName) ? `${directoryName} already exists. Please choose another name.` : void 0
+      validate: (directoryName) => directoryName && existsSync4(directoryName) ? `${directoryName} already exists. Please choose another name.` : void 0
     },
     {
       onCancel: () => {
-        logger19.log("Command cancelled by the user. Exiting..."), process.exit(1);
+        logger21.log("Command cancelled by the user. Exiting..."), process.exit(1);
       }
     }
   )), invariant(selectedDirectory);
   try {
-    let templateDestination = isAbsolute2(selectedDirectory) ? selectedDirectory : join(process.cwd(), selectedDirectory);
-    logger19.log(`\u{1F3C3} Adding ${selectedConfig.name} into ${templateDestination}`), logger19.log(`\u{1F4E6} Downloading sandbox template (${import_picocolors15.default.bold(downloadType)})...`);
+    let templateDestination = isAbsolute3(selectedDirectory) ? selectedDirectory : join(process.cwd(), selectedDirectory);
+    logger21.log(`\u{1F3C3} Adding ${selectedConfig.name} into ${templateDestination}`), logger21.log(`\u{1F4E6} Downloading sandbox template (${import_picocolors16.default.bold(downloadType)})...`);
     try {
       let gitPath = `storybookjs/sandboxes/tree/${branch}/${templateId}/${downloadType}`;
       if (await mkdir2(templateDestination, { recursive: !0 }), (0, import_cross_spawn2.sync)("npx", ["gitpick@4.12.4", gitPath, templateDestination, "-o"], {
         stdio: "inherit"
       }), (await readdir(templateDestination)).length === 0) {
-        let selected = import_picocolors15.default.yellow(templateId);
-        throw new Error(dedent15`
-          Template downloaded from ${import_picocolors15.default.blue(gitPath)} is empty.
+        let selected = import_picocolors16.default.yellow(templateId);
+        throw new Error(dedent16`
+          Template downloaded from ${import_picocolors16.default.blue(gitPath)} is empty.
           Are you use it exists? Or did you want to set ${selected} to inDevelopment first?
         `);
       }
@@ -9094,22 +9550,22 @@ var toChoices = (c) => ({ label: allTemplates[c].name, value: c }), sandbox = as
         }), process.chdir(before);
       }
     } catch (err) {
-      throw logger19.error(`\u{1F6A8} Failed to download sandbox template: ${String(err)}`), err;
+      throw logger21.error(`\u{1F6A8} Failed to download sandbox template: ${String(err)}`), err;
     }
-    let initMessage = init ? import_picocolors15.default.yellow(dedent15`
+    let initMessage = init ? import_picocolors16.default.yellow(dedent16`
           yarn install
           yarn storybook
-        `) : `Recreate your setup, then ${import_picocolors15.default.yellow("npx storybook@latest init")}`;
-    logger19.logBox(
-      dedent15`
+        `) : `Recreate your setup, then ${import_picocolors16.default.yellow("npx storybook@latest init")}`;
+    logger21.logBox(
+      dedent16`
         🎉 Your Storybook reproduction project is ready to use! 🎉
 
-        ${import_picocolors15.default.yellow(`cd ${selectedDirectory}`)}
+        ${import_picocolors16.default.yellow(`cd ${selectedDirectory}`)}
         ${initMessage}
 
         Once you've recreated the problem you're experiencing, please:
 
-        1. Document any additional steps in ${import_picocolors15.default.cyan("README.md")}
+        1. Document any additional steps in ${import_picocolors16.default.cyan("README.md")}
         2. Publish the repository to github
         3. Link to the repro repository in your issue
 
@@ -9118,40 +9574,416 @@ var toChoices = (c) => ({ label: allTemplates[c].name, value: c }), sandbox = as
       { rounded: !0 }
     );
   } catch (error) {
-    throw logger19.error("\u{1F6A8} Failed to create sandbox"), error;
+    throw logger21.error("\u{1F6A8} Failed to create sandbox"), error;
   }
 };
 async function promptSelectedTemplate(choices) {
-  return await prompt4.select({
+  return await prompt5.select({
     message: "Select a template",
     options: choices.map(toChoices)
   });
 }
 
+// src/ai/index.ts
+import { writeFile as writeFile10 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+import { cache, getPrettyPackageManagerName } from "storybook/internal/common";
+import { logger as logger23 } from "storybook/internal/node-logger";
+import { telemetry } from "storybook/internal/telemetry";
+import { SupportedLanguage as SupportedLanguage2 } from "storybook/internal/types";
+
+// ../create-storybook/src/services/ProjectTypeService.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+import { ProjectType as ProjectType2 } from "storybook/internal/cli";
+import { HandledError, getProjectRoot } from "storybook/internal/common";
+import { logger as logger22 } from "storybook/internal/node-logger";
+import { NxProjectDetectedError } from "storybook/internal/server-errors";
+import { SupportedLanguage } from "storybook/internal/types";
+
+// ../../../node_modules/empathic/find.mjs
+import { join as join5 } from "node:path";
+import { existsSync as existsSync5, statSync } from "node:fs";
+function up2(name, options) {
+  let dir, tmp, start = options && options.cwd || "";
+  for (dir of up(start, options))
+    if (tmp = join5(dir, name), existsSync5(tmp)) return tmp;
+}
+
+// ../create-storybook/src/services/ProjectTypeService.ts
+var import_semver7 = __toESM(require_semver(), 1);
+import { dedent as dedent17 } from "ts-dedent";
+var ProjectTypeService = class {
+  constructor(jsPackageManager) {
+    this.jsPackageManager = jsPackageManager;
+  }
+  /** Sorted configuration to match a Storybook preset template */
+  getSupportedTemplates() {
+    return [
+      {
+        preset: ProjectType2.NUXT,
+        dependencies: ["nuxt"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.TANSTACK_REACT,
+        dependencies: ["@tanstack/start", "@tanstack/react-start", "@tanstack/react-router"],
+        matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+      },
+      {
+        preset: ProjectType2.VUE3,
+        dependencies: {
+          // This Vue template works with Vue 3
+          vue: (versionRange) => versionRange === "next" || this.eqMajor(versionRange, 3)
+        },
+        matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+      },
+      {
+        preset: ProjectType2.EMBER,
+        dependencies: ["ember-cli"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.NEXTJS,
+        dependencies: ["next"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.QWIK,
+        dependencies: ["@builder.io/qwik"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.REACT_NATIVE,
+        dependencies: ["react-native", "react-native-scripts", "expo"],
+        matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+      },
+      {
+        preset: ProjectType2.REACT_SCRIPTS,
+        // For projects using a custom/forked `react-scripts` package.
+        files: ["/node_modules/.bin/react-scripts"],
+        // For standard CRA projects
+        dependencies: ["react-scripts"],
+        matcherFunction: ({ dependencies, files }) => (dependencies?.every(Boolean) || files?.every(Boolean)) ?? !1
+      },
+      {
+        preset: ProjectType2.ANGULAR,
+        dependencies: ["@angular/core"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.WEB_COMPONENTS,
+        dependencies: ["lit-element", "lit-html", "lit"],
+        matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+      },
+      {
+        preset: ProjectType2.PREACT,
+        dependencies: ["preact"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        // TODO: This only works because it is before the SVELTE template. could be more explicit
+        preset: ProjectType2.SVELTEKIT,
+        dependencies: ["@sveltejs/kit"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.SVELTE,
+        dependencies: ["svelte"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType2.SOLID,
+        dependencies: ["solid-js"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      // DO NOT MOVE ANY TEMPLATES BELOW THIS LINE
+      // React is part of every Template, after Storybook is initialized once
+      {
+        preset: ProjectType2.REACT,
+        dependencies: ["react"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      }
+    ];
+  }
+  isStorybookInstantiated(configDir = resolve3(process.cwd(), ".storybook")) {
+    return existsSync6(configDir);
+  }
+  async validateProvidedType(projectTypeProvided) {
+    if (Object.values(ProjectType2).filter(
+      (t10) => !["undetected", "unsupported", "nx"].includes(String(t10))
+    ).includes(projectTypeProvided))
+      return projectTypeProvided;
+    throw logger22.error(
+      `The provided project type ${projectTypeProvided} was not recognized by Storybook`
+    ), new HandledError(`Unknown project type supplied: ${projectTypeProvided}`);
+  }
+  async autoDetectProjectType(options) {
+    try {
+      let detectedType = await this.detectProjectType(options);
+      if (detectedType === ProjectType2.UNDETECTED || detectedType === null)
+        throw logger22.error(dedent17`
+          Unable to initialize Storybook in this directory.
+
+          Storybook couldn't detect a supported framework or configuration for your project. Make sure you're inside a framework project (e.g., React, Vue, Svelte, Angular, Next.js) and that its dependencies are installed.
+
+          Tips:
+          - Run init in an empty directory or create a new framework app first.
+          - If this directory contains unrelated files, try a new directory for Storybook.
+        `), new HandledError("Storybook failed to detect your project type");
+      if (detectedType === ProjectType2.NX)
+        throw new NxProjectDetectedError();
+      return detectedType;
+    } catch (err) {
+      throw err instanceof HandledError || err instanceof NxProjectDetectedError ? err : (logger22.error(String(err)), new HandledError(err instanceof Error ? err.message : String(err)));
+    }
+  }
+  async detectLanguage() {
+    let language = SupportedLanguage.JAVASCRIPT;
+    return existsSync6("jsconfig.json") || (!!this.jsPackageManager.getAllDependencies().typescript ? (await this.detectIncompatiblePackageVersions()).length === 0 && (language = SupportedLanguage.TYPESCRIPT) : existsSync6("tsconfig.json") && (language = SupportedLanguage.TYPESCRIPT)), language;
+  }
+  /** Check installed tooling versions for TypeScript compatibility constraints */
+  async detectIncompatiblePackageVersions() {
+    let getModulePackageJSONVersion = async (pkg) => (await this.jsPackageManager.getModulePackageJSON(pkg))?.version ?? null, [
+      typescriptVersion,
+      prettierVersion,
+      babelPluginTransformTypescriptVersion,
+      typescriptEslintParserVersion,
+      eslintPluginStorybookVersion
+    ] = await Promise.all([
+      getModulePackageJSONVersion("typescript"),
+      getModulePackageJSONVersion("prettier"),
+      getModulePackageJSONVersion("@babel/plugin-transform-typescript"),
+      getModulePackageJSONVersion("@typescript-eslint/parser"),
+      getModulePackageJSONVersion("eslint-plugin-storybook")
+    ]), satisfies = (version2, range) => version2 ? import_semver7.default.satisfies(version2, range, { includePrerelease: !0 }) : !1, incompatibleReasons = [];
+    return typescriptVersion && !satisfies(typescriptVersion, ">=4.9.0") && incompatibleReasons.push(`typescript ${typescriptVersion} is below 4.9.0`), prettierVersion && !import_semver7.default.gte(prettierVersion, "2.8.0") && incompatibleReasons.push(`prettier ${prettierVersion} is below 2.8.0`), babelPluginTransformTypescriptVersion && !satisfies(babelPluginTransformTypescriptVersion, ">=7.20.0") && incompatibleReasons.push(
+      `@babel/plugin-transform-typescript ${babelPluginTransformTypescriptVersion} is below 7.20.0`
+    ), typescriptEslintParserVersion && !satisfies(typescriptEslintParserVersion, ">=5.44.0") && incompatibleReasons.push(
+      `@typescript-eslint/parser ${typescriptEslintParserVersion} is below 5.44.0`
+    ), eslintPluginStorybookVersion && !eslintPluginStorybookVersion.startsWith("0.0.0-") && !satisfies(eslintPluginStorybookVersion, ">=0.6.8") && incompatibleReasons.push(
+      `eslint-plugin-storybook ${eslintPluginStorybookVersion} is below 0.6.8`
+    ), incompatibleReasons;
+  }
+  eqMajor(versionRange, major) {
+    return import_semver7.default.validRange(versionRange) ? import_semver7.default.minVersion(versionRange)?.major === major : !1;
+  }
+  async detectProjectType(options) {
+    try {
+      if (this.isNxProject())
+        return ProjectType2.NX;
+      if (options.html)
+        return ProjectType2.HTML;
+      let { packageJson } = this.jsPackageManager.primaryPackageJson;
+      return this.detectFrameworkPreset(packageJson);
+    } catch {
+      return ProjectType2.UNDETECTED;
+    }
+  }
+  detectFrameworkPreset(packageJson) {
+    let result = [...this.getSupportedTemplates(), this.getUnsupportedTemplate()].find(
+      (framework) => this.getProjectType(packageJson, framework) !== null
+    );
+    return result ? result.preset : ProjectType2.UNDETECTED;
+  }
+  /** Template that matches unsupported frameworks */
+  getUnsupportedTemplate() {
+    return {
+      preset: ProjectType2.UNSUPPORTED,
+      dependencies: {},
+      matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+    };
+  }
+  getProjectType(packageJson, framework) {
+    let matcher = {
+      dependencies: [!1],
+      peerDependencies: [!1],
+      files: [!1]
+    }, { preset, files, dependencies, peerDependencies, matcherFunction } = framework, dependencySearches = [];
+    Array.isArray(dependencies) ? dependencySearches = dependencies.map((name) => [name, void 0]) : typeof dependencies == "object" && (dependencySearches = Object.entries(dependencies)), dependencySearches.length > 0 && (matcher.dependencies = dependencySearches.map(
+      ([name, matchFn]) => this.hasDependency(packageJson, name, matchFn)
+    ));
+    let peerDependencySearches = [];
+    return Array.isArray(peerDependencies) ? peerDependencySearches = peerDependencies.map((name) => [name, void 0]) : typeof peerDependencies == "object" && (peerDependencySearches = Object.entries(peerDependencies)), peerDependencySearches.length > 0 && (matcher.peerDependencies = peerDependencySearches.map(
+      ([name, matchFn]) => this.hasPeerDependency(packageJson, name, matchFn)
+    )), Array.isArray(files) && files.length > 0 && (matcher.files = files.map((name) => existsSync6(name))), matcherFunction(matcher) ? preset : null;
+  }
+  hasDependency(packageJson, name, matcher) {
+    let version2 = packageJson.dependencies?.[name] || packageJson.devDependencies?.[name];
+    return version2 && typeof matcher == "function" ? matcher(version2) : !!version2;
+  }
+  hasPeerDependency(packageJson, name, matcher) {
+    let version2 = packageJson.peerDependencies?.[name];
+    return version2 && typeof matcher == "function" ? matcher(version2) : !!version2;
+  }
+  isNxProject() {
+    return up2("nx.json", { last: getProjectRoot() });
+  }
+};
+
+// src/ai/setup-prompts/index.ts
+import { dedent as dedent18 } from "ts-dedent";
+
+// src/ai/utils/project-overview.ts
+function getProjectOverview(projectInfo) {
+  let rows = [
+    ["Version", projectInfo.storybookVersion || "unknown"],
+    ["Renderer", projectInfo.rendererPackage || "unknown"],
+    ["Framework", projectInfo.framework || "unknown"],
+    ["Builder", projectInfo.builderPackage || "unknown"],
+    ["Config Dir", `\`${projectInfo.configDir}\``],
+    ["Language", projectInfo.language === "ts" ? "TypeScript" : "JavaScript"]
+  ];
+  return projectInfo.packageManager && rows.push(["Package Manager", projectInfo.packageManagerName || "unknown"]), rows.push(["Addons", projectInfo.addons.length > 0 ? projectInfo.addons.join(", ") : "none"]), ["## Project Info", "", "| Property | Value |", "|----------|-------|", rows.map(([key, value]) => `| ${key} | ${value} |`).join(`
+`)].join(
+    `
+`
+  );
+}
+
+// src/ai/setup-prompts/index.ts
+var DEFAULT_PROMPT_NAME = "optimized-tests", CURRENTLY_USED_PROMPT = {
+  [DEFAULT_PROMPT_NAME]: instructions
+}, FORMERLY_USED_PROMPTS = {
+  monorepo: async () => (await import("./monorepo-UN2SFOKP.js")).instructions,
+  "optimized-tests": async () => (await import("./optimized-tests-JK7ONDR4.js")).instructions,
+  "relaxed-limits": async () => (await import("./relaxed-limits-JZ6RZ46W.js")).instructions,
+  setup: async () => (await import("./setup-WU7VMOU5.js")).instructions,
+  "pattern-copy-play": async () => (await import("./pattern-copy-play-7YSOSVSA.js")).instructions,
+  "monorepo-optimized-tests-relaxed-limits-no-story-deletion": async () => (await import("./monorepo-optimized-tests-relaxed-limits-no-story-deletion-5YVGNWCV.js")).instructions
+}, PROMPT_NAMES = [
+  ...Object.keys(CURRENTLY_USED_PROMPT),
+  ...Object.keys(FORMERLY_USED_PROMPTS)
+], EVAL_SETUP_PROMPT_ENV = "EVAL_SETUP_PROMPT";
+function resolvePromptName() {
+  let requested = process.env[EVAL_SETUP_PROMPT_ENV]?.trim();
+  return requested && (Object.hasOwn(CURRENTLY_USED_PROMPT, requested) || Object.hasOwn(FORMERLY_USED_PROMPTS, requested)) ? requested : DEFAULT_PROMPT_NAME;
+}
+async function getAiSetupPrompt(projectInfo) {
+  let name = resolvePromptName();
+  return { content: (CURRENTLY_USED_PROMPT[name] ?? await FORMERLY_USED_PROMPTS[name]())(projectInfo), name };
+}
+async function getAiSetupMarkdownOutput(projectInfo) {
+  let { content, name } = await getAiSetupPrompt(projectInfo);
+  return {
+    markdown: dedent18`
+    # Storybook Setup
+
+    ${getProjectOverview(projectInfo)}
+
+    ${content}
+  `,
+    prompt: name
+  };
+}
+
+// src/ai/index.ts
+async function aiSetup(options) {
+  let { configDir: userConfigDir, packageManager, output } = options, projectInfo;
+  try {
+    let data = await getStorybookData({
+      configDir: userConfigDir,
+      packageManagerName: packageManager
+    });
+    if (!data.frameworkPackage || !data.rendererPackage || !data.builderPackage) {
+      logger23.error(
+        "Could not detect framework, renderer, or builder from your Storybook config. Make sure you are running this command from your project root, or specify --config-dir."
+      );
+      return;
+    }
+    let majorVersion = data.versionInstalled ? parseMajorVersion(data.versionInstalled) : void 0, language = await new ProjectTypeService(data.packageManager).detectLanguage() === SupportedLanguage2.TYPESCRIPT ? "ts" : "js", needsUserOnboarding = await cache.get("onboarding-pending", !1);
+    projectInfo = {
+      storybookVersion: data.versionInstalled,
+      majorVersion,
+      framework: data.frameworkPackage,
+      rendererPackage: data.rendererPackage,
+      renderer: data.renderer,
+      builderPackage: data.builderPackage,
+      addons: data.addons ?? [],
+      configDir: data.configDir,
+      storiesPaths: data.storiesPaths,
+      packageManager: data.packageManager,
+      packageManagerName: getPrettyPackageManagerName(data.packageManager.type),
+      language,
+      hasCsfFactoryPreview: data.hasCsfFactoryPreview,
+      needsUserOnboarding
+    };
+  } catch (err) {
+    logger23.error(
+      `Failed to read Storybook configuration: ${err instanceof Error ? err.message : String(err)}`
+    ), logger23.log(
+      "Make sure you are running this command from your project root, or specify --config-dir."
+    );
+    return;
+  }
+  if (projectInfo.rendererPackage !== "@storybook/react" || projectInfo.builderPackage !== "@storybook/builder-vite") {
+    logger23.log(
+      "AI-assisted setup is currently only available for projects using the React renderer with Vite builder. Detected renderer: " + projectInfo.rendererPackage + ", builder: " + projectInfo.builderPackage
+    );
+    return;
+  }
+  let result = await getAiSetupMarkdownOutput(projectInfo), markdownOutput = result.markdown;
+  if (await cache.set("ai-setup-ran", {
+    timestamp: Date.now(),
+    runId: options.runId,
+    configDir: resolve4(projectInfo.configDir)
+  }).catch(() => {
+  }), await telemetry("ai-setup", {
+    cliOptions: {
+      output: output ? "file" : void 0,
+      configDir: projectInfo.configDir,
+      packageManager: projectInfo.packageManager.type,
+      prompt: result.prompt
+    },
+    project: {
+      framework: projectInfo.framework,
+      renderer: projectInfo.rendererPackage,
+      builder: projectInfo.builderPackage,
+      language: projectInfo.language
+    },
+    runId: options.runId
+  }), output) {
+    let outputPath = resolve4(output);
+    await writeFile10(outputPath, markdownOutput, "utf-8"), logger23.log(`Prompt written to ${outputPath}`);
+  } else
+    process.stdout.write(`${markdownOutput}
+`);
+}
+function parseMajorVersion(version2) {
+  let match = version2.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : void 0;
+}
+
 // src/upgrade.ts
-var import_cross_spawn3 = __toESM(require_cross_spawn(), 1), import_picocolors16 = __toESM(require_picocolors(), 1), import_semver7 = __toESM(require_semver(), 1);
+var import_cross_spawn3 = __toESM(require_cross_spawn(), 1), import_picocolors17 = __toESM(require_picocolors(), 1), import_semver8 = __toESM(require_semver(), 1);
 import { PackageManagerName as PackageManagerName2 } from "storybook/internal/common";
-import { HandledError, JsPackageManagerFactory as JsPackageManagerFactory2, isCorePackage as isCorePackage2 } from "storybook/internal/common";
+import {
+  HandledError as HandledError2,
+  JsPackageManagerFactory as JsPackageManagerFactory2,
+  isCI as isCI2,
+  isCorePackage as isCorePackage2
+} from "storybook/internal/common";
 import {
   CLI_COLORS as CLI_COLORS4,
   createHyperlink,
   logTracker as logTracker3,
-  logger as logger21,
-  prompt as prompt6
+  logger as logger25,
+  prompt as prompt7
 } from "storybook/internal/node-logger";
 import {
+  MinimumReleaseAgeHandledError,
   UpgradeStorybookToLowerVersionError,
   UpgradeStorybookUnknownCurrentVersionError
 } from "storybook/internal/server-errors";
-import { telemetry } from "storybook/internal/telemetry";
-import { dedent as dedent16 } from "ts-dedent";
+import { telemetry as telemetry2 } from "storybook/internal/telemetry";
+import { dedent as dedent19 } from "ts-dedent";
 
 // src/automigrate/multi-project.ts
-import { CLI_COLORS as CLI_COLORS3, logger as logger20, prompt as prompt5 } from "storybook/internal/node-logger";
+import { CLI_COLORS as CLI_COLORS3, logger as logger24, prompt as prompt6 } from "storybook/internal/node-logger";
 import { ErrorCollector, sanitizeError } from "storybook/internal/telemetry";
 async function collectAutomigrationsAcrossProjects(options) {
   let { fixes, projects, taskLog } = options, automigrationMap = /* @__PURE__ */ new Map();
-  logger20.debug(
+  logger24.debug(
     `Starting automigration collection across ${projects.length} projects and ${fixes.length} fixes...`
   );
   function collectResult(fix, project, status, result) {
@@ -9173,10 +10005,10 @@ async function collectAutomigrationsAcrossProjects(options) {
   }
   for (let project of projects) {
     let projectName = shortenPath(project.configDir);
-    taskLog.message(`Checking automigrations for ${projectName}...`), logger20.debug(`Processing project: ${projectName}`);
+    taskLog.message(`Checking automigrations for ${projectName}...`), logger24.debug(`Processing project: ${projectName}`);
     for (let fix of fixes)
       try {
-        logger20.debug(`Checking fix ${fix.id} for project ${projectName}...`);
+        logger24.debug(`Checking fix ${fix.id} for project ${projectName}...`);
         let checkOptions = {
           packageManager: project.packageManager,
           configDir: project.configDir,
@@ -9189,9 +10021,9 @@ async function collectAutomigrationsAcrossProjects(options) {
         }, result = await fix.check(checkOptions);
         result !== null ? collectResult(fix, project, "check_succeeded", result) : collectResult(fix, project, "not_applicable");
       } catch (error) {
-        collectResult(fix, project, "check_failed"), logger20.debug(
+        collectResult(fix, project, "check_failed"), logger24.debug(
           `Failed to check fix ${fix.id} for project ${shortenPath(project.configDir)}.`
-        ), logger20.debug(`${error instanceof Error ? error.stack : String(error)}`), ErrorCollector.addError(error);
+        ), logger24.debug(`${error instanceof Error ? error.stack : String(error)}`), ErrorCollector.addError(error);
       }
   }
   let allAutomigrations = Array.from(automigrationMap.values()), applicableAutomigrations = allAutomigrations.filter(
@@ -9205,9 +10037,9 @@ async function collectAutomigrationsAcrossProjects(options) {
   );
   return taskLog.message(`
 Automigrations detected:`), successAutomigrations.forEach((fixId) => {
-    taskLog.message(`${CLI_COLORS3.success(`${logger20.SYMBOLS.success} ${fixId}`)}`);
+    taskLog.message(`${CLI_COLORS3.success(`${logger24.SYMBOLS.success} ${fixId}`)}`);
   }), failedAutomigrations.forEach((fixId) => {
-    taskLog.message(`${CLI_COLORS3.error(`${logger20.SYMBOLS.error} ${fixId}`)}`);
+    taskLog.message(`${CLI_COLORS3.error(`${logger24.SYMBOLS.error} ${fixId}`)}`);
   }), failedAutomigrations.length > 0 ? taskLog.error(
     `${failedAutomigrations.length} automigration ${failedAutomigrations.length > 1 ? "checks" : "check"} failed`
   ) : taskLog.success(
@@ -9225,12 +10057,12 @@ async function promptForAutomigrations(automigrations, options) {
   if (automigrations.length === 0)
     return [];
   if (options.dryRun)
-    return logger20.log("Detected automigrations (dry run - no changes will be made):"), automigrations.forEach(({ fix, reports: list }) => {
-      logger20.log(`  - ${fix.id} (${formatProjectDirs(list)})`);
+    return logger24.log("Detected automigrations (dry run - no changes will be made):"), automigrations.forEach(({ fix, reports: list }) => {
+      logger24.log(`  - ${fix.id} (${formatProjectDirs(list)})`);
     }), [];
   if (options.yes)
-    return logger20.log("Running all detected automigrations:"), automigrations.forEach(({ fix, reports: list }) => {
-      logger20.log(`  - ${fix.id} (${formatProjectDirs(list)})`);
+    return logger24.log("Running all detected automigrations:"), automigrations.forEach(({ fix, reports: list }) => {
+      logger24.log(`  - ${fix.id} (${formatProjectDirs(list)})`);
     }), automigrations;
   let choices = automigrations.map((am) => {
     let hint = [];
@@ -9243,7 +10075,7 @@ async function promptForAutomigrations(automigrations, options) {
 `),
       defaultSelected: am.fix.defaultSelected ?? !0
     };
-  }), selectedIds = await prompt5.multiselect({
+  }), selectedIds = await prompt6.multiselect({
     message: "Select automigrations to run",
     options: choices,
     initialValues: choices.filter((c) => c.defaultSelected).map((c) => c.value),
@@ -9274,18 +10106,18 @@ async function runAutomigrationsForProjects(selectedAutomigrations, options) {
     }
   let projectIndex = 0;
   for (let [configDir, projectAutomigration] of projectAutomigrationResults) {
-    let countPrefix = projectAutomigrationResults.size > 1 ? `(${++projectIndex}/${projectAutomigrationResults.size}) ` : "", { project } = projectAutomigration[0], projectName = shortenPath(project.configDir), taskLog = applicableAutomigrations.length > 0 ? prompt5.taskLog({
+    let countPrefix = projectAutomigrationResults.size > 1 ? `(${++projectIndex}/${projectAutomigrationResults.size}) ` : "", { project } = projectAutomigration[0], projectName = shortenPath(project.configDir), taskLog = applicableAutomigrations.length > 0 ? prompt6.taskLog({
       id: `automigrate-${projectName}`,
       title: `${countPrefix}Running automigrations for ${projectName}`
     }) : {
       message: (message) => {
-        logger20.debug(`${message}`);
+        logger24.debug(`${message}`);
       },
       error: (message) => {
-        logger20.debug(`${message}`);
+        logger24.debug(`${message}`);
       },
       success: (message) => {
-        logger20.debug(`${message}`);
+        logger24.debug(`${message}`);
       }
     }, fixResults = {}, fixFailures = {};
     for (let automigration of projectAutomigration) {
@@ -9319,11 +10151,11 @@ async function runAutomigrationsForProjects(selectedAutomigrations, options) {
             storiesPaths: project2.storiesPaths,
             yes
           };
-          await fix.run(runOptions), fixResults[fix.id] = "succeeded" /* SUCCEEDED */, taskLog.message(CLI_COLORS3.success(`${logger20.SYMBOLS.success} ${fix.id}`));
+          await fix.run(runOptions), fixResults[fix.id] = "succeeded" /* SUCCEEDED */, taskLog.message(CLI_COLORS3.success(`${logger24.SYMBOLS.success} ${fix.id}`));
         }
       } catch (error) {
         let errorMessage = (error instanceof Error ? error.stack : String(error)) ?? "Unknown error";
-        fixResults[fix.id] = "failed" /* FAILED */, fixFailures[fix.id] = sanitizeError(error), taskLog.message(CLI_COLORS3.error(`${logger20.SYMBOLS.error} ${automigration.fix.id}`)), logger20.debug(errorMessage), ErrorCollector.addError(error);
+        fixResults[fix.id] = "failed" /* FAILED */, fixFailures[fix.id] = sanitizeError(error), taskLog.message(CLI_COLORS3.error(`${logger24.SYMBOLS.error} ${automigration.fix.id}`)), logger24.debug(errorMessage), ErrorCollector.addError(error);
       }
     }
     let automigrationsWithErrors = Object.values(fixResults).filter(
@@ -9352,7 +10184,7 @@ async function runAutomigrations(projects, options) {
     beforeVersion: project.beforeVersion,
     storiesPaths: project.storiesPaths,
     hasCsfFactoryPreview: project.hasCsfFactoryPreview
-  })), detectingAutomigrationTask = prompt5.taskLog({
+  })), detectingAutomigrationTask = prompt6.taskLog({
     id: "detect-automigrations",
     title: projectAutomigrationData.length > 1 ? `Detecting automigrations for ${projectAutomigrationData.length} projects...` : "Detecting automigrations..."
   }), detectedAutomigrations = await collectAutomigrationsAcrossProjects({
@@ -9378,7 +10210,7 @@ async function runAutomigrations(projects, options) {
       let project = projects.find((p) => p.configDir === configDir);
       if (project) {
         let oldConfigDir = project.configDir;
-        project.configDir = project.configDir.replace(".storybook", ".rnstorybook"), automigrationResults[project.configDir] = resultData, delete automigrationResults[oldConfigDir];
+        project.configDir = project.configDir.replace(".storybook", RN_STORYBOOK_DIR), automigrationResults[project.configDir] = resultData, delete automigrationResults[oldConfigDir];
       }
     }
   }), {
@@ -9433,29 +10265,29 @@ function logUpgradeResults(projectResults, detectedAutomigrations, doctorResults
     doctorResults
   );
   if (failedProjects.length > 0) {
-    if (logTracker3.enableLogWriting(), logger21.step(
+    if (logTracker3.enableLogWriting(), logger25.step(
       "The upgrade is complete, but some projects failed to upgrade or migrate completely. Please see the debug logs for more details."
     ), successfulProjects.length > 0) {
       let successfulProjectsList = successfulProjects.map((dir) => `  \u2022 ${shortenPath(dir)}`).join(`
 `);
-      logger21.log(`${CLI_COLORS4.success("Successfully upgraded:")}
+      logger25.log(`${CLI_COLORS4.success("Successfully upgraded:")}
 ${successfulProjectsList}`);
     }
     let failedProjectsList = failedProjects.map((dir) => `  \u2022 ${shortenPath(dir)}`).join(`
 `);
-    if (logger21.log(
+    if (logger25.log(
       `${CLI_COLORS4.error("Failed to upgrade:")}
 Some automigrations failed, please check the logs in the log file for more details.
 ${failedProjectsList}`
     ), projectsWithNoFixes.length > 0) {
       let projectList = projectsWithNoFixes.map((dir) => `  \u2022 ${shortenPath(dir)}`).join(`
 `);
-      logger21.log(`${CLI_COLORS4.info("No applicable migrations:")}
+      logger25.log(`${CLI_COLORS4.info("No applicable migrations:")}
 ${projectList}`);
     }
   } else
-    Object.values(doctorResults).every((result) => result.status === "healthy") ? logger21.step(`${CLI_COLORS4.success("Your project(s) have been upgraded successfully! \u{1F389}")}`) : logger21.step(
-      `${import_picocolors16.default.yellow("Your project(s) have been upgraded successfully, but some issues were found which need your attention, please check Storybook doctor logs above.")}`
+    Object.values(doctorResults).every((result) => result.status === "healthy") ? logger25.step(`${CLI_COLORS4.success("Your project(s) have been upgraded successfully! \u{1F389}")}`) : logger25.step(
+      `${import_picocolors17.default.yellow("Your project(s) have been upgraded successfully, but some issues were found which need your attention, please check Storybook doctor logs above.")}`
     );
   let automigrationLinks = detectedAutomigrations.filter(
     (am) => Object.entries(projectResults).some(
@@ -9468,9 +10300,9 @@ ${projectList}`);
       ...automigrationLinks
     ].join(`
 `);
-    logger21.log(automigrationLinksMessage);
+    logger25.log(automigrationLinksMessage);
   }
-  logger21.log(
+  logger25.log(
     `For a full list of changes, please check our migration guide: ${CLI_COLORS4.cta("https://storybook.js.org/docs/releases/migration-guide?ref=upgrade")}`
   );
 }
@@ -9491,7 +10323,7 @@ async function sendMultiUpgradeTelemetry(options) {
     (result) => result.status !== "healthy"
   ).length;
   try {
-    await telemetry("multi-upgrade", {
+    await telemetry2("multi-upgrade", {
       totalDetectedProjects: allProjects.length,
       totalSelectedProjects: selectedProjects.length,
       projectsWithSuccessfulAutomigrations: successfulProjects.length,
@@ -9502,7 +10334,7 @@ async function sendMultiUpgradeTelemetry(options) {
       hasUserInterrupted
     });
   } catch (error) {
-    logger21.debug(`Failed to send multi-upgrade telemetry: ${String(error)}`);
+    logger25.debug(`Failed to send multi-upgrade telemetry: ${String(error)}`);
   }
 }
 async function upgrade(options) {
@@ -9510,13 +10342,13 @@ async function upgrade(options) {
   if (projectsResult === void 0 || projectsResult.selectedProjects.length === 0)
     return;
   let { allProjects, selectedProjects: storybookProjects } = projectsResult;
-  storybookProjects.length > 1 ? logger21.info(`Upgrading the following projects:
-          ${storybookProjects.map((p) => `${import_picocolors16.default.cyan(shortenPath(p.configDir))}: ${import_picocolors16.default.bold(p.beforeVersion)} -> ${import_picocolors16.default.bold(p.currentCLIVersion)}`).join(`
-`)}`) : logger21.info(
-    `Upgrading from ${import_picocolors16.default.bold(storybookProjects[0].beforeVersion)} to ${import_picocolors16.default.bold(storybookProjects[0].currentCLIVersion)}`
+  storybookProjects.length > 1 ? logger25.info(`Upgrading the following projects:
+          ${storybookProjects.map((p) => `${import_picocolors17.default.cyan(shortenPath(p.configDir))}: ${import_picocolors17.default.bold(p.beforeVersion)} -> ${import_picocolors17.default.bold(p.currentCLIVersion)}`).join(`
+`)}`) : logger25.info(
+    `Upgrading from ${import_picocolors17.default.bold(storybookProjects[0].beforeVersion)} to ${import_picocolors17.default.bold(storybookProjects[0].currentCLIVersion)}`
   );
   let automigrationResults = {}, doctorResults = {}, handleInterruption = async () => {
-    throw logger21.log(`
+    throw logger25.log(`
 
 Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgradeTelemetry({
       allProjects,
@@ -9524,16 +10356,16 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
       projectResults: automigrationResults,
       doctorResults,
       hasUserInterrupted: !0
-    }), new HandledError("Upgrade cancelled by user");
+    }), new HandledError2("Upgrade cancelled by user");
   };
   process.on("SIGINT", handleInterruption), process.on("SIGTERM", handleInterruption);
   try {
     if (processAutoblockerResults(storybookProjects, (message) => {
-      logger21.error(dedent16`Blockers detected\n\n${message}`);
+      logger25.error(dedent19`Blockers detected\n\n${message}`);
     }))
-      throw new HandledError("Blockers detected");
+      throw new HandledError2("Blockers detected");
     if (storybookProjects.some((project) => {
-      if (!project.isCanary && (0, import_semver7.lt)(project.currentCLIVersion, project.beforeVersion))
+      if (!project.isCanary && (0, import_semver8.lt)(project.currentCLIVersion, project.beforeVersion))
         throw new UpgradeStorybookToLowerVersionError({
           beforeVersion: project.beforeVersion,
           currentVersion: project.currentCLIVersion
@@ -9541,14 +10373,28 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
       if (!project.beforeVersion)
         throw new UpgradeStorybookUnknownCurrentVersionError();
     }), !options.dryRun) {
-      let task = prompt6.taskLog({
+      for (let project of storybookProjects)
+        try {
+          await project.packageManager.precheckStorybookPackageInstall({
+            storybookVersion: project.currentCLIVersion,
+            nonInteractive: !!options.yes || !process.stdout.isTTY || !!isCI2(),
+            installContext: "upgrade"
+          });
+        } catch (error) {
+          if (error instanceof MinimumReleaseAgeHandledError)
+            throw error;
+          logger25.debug(
+            `Skipping minimum-release-age precheck for ${project.configDir} after an unexpected failure: ${error}`
+          );
+        }
+      let task = prompt7.taskLog({
         id: "upgrade-dependencies",
         title: "Fetching versions to update package.json files.."
       });
       try {
         let loggedPaths = [];
         for (let project of storybookProjects) {
-          logger21.debug(`Updating dependencies in ${shortenPath(project.configDir)}...`);
+          logger25.debug(`Updating dependencies in ${shortenPath(project.configDir)}...`);
           let newPaths = project.packageManager.packageJsonPaths.map(shortenPath).filter((path4) => !loggedPaths.includes(path4));
           newPaths.length > 0 && (task.message(newPaths.join(`
 `)), loggedPaths.push(...newPaths)), await upgradeStorybookDependencies({
@@ -9565,16 +10411,18 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
         task.error(`Failed to upgrade dependencies: ${String(err)}`);
       }
     }
-    let { automigrationResults: automigrationResults2, detectedAutomigrations } = await runAutomigrations(
+    let automigrationResults2 = {}, detectedAutomigrations = [];
+    options.skipAutomigrations ? logger25.log("Skipping automigrations (--skip-automigrations).") : { automigrationResults: automigrationResults2, detectedAutomigrations } = await runAutomigrations(
       storybookProjects,
       options
-    ), rootPackageManager = storybookProjects.length > 1 ? JsPackageManagerFactory2.getPackageManager({ force: options.packageManager }) : storybookProjects[0].packageManager;
-    rootPackageManager.type === "npm" ? await rootPackageManager.installDependencies({ force: !0 }) : await rootPackageManager.installDependencies(), rootPackageManager.type !== PackageManagerName2.YARN1 && rootPackageManager.isStorybookInMonorepo() && (logger21.warn(
+    );
+    let rootPackageManager = storybookProjects.length > 1 ? JsPackageManagerFactory2.getPackageManager({ force: options.packageManager }) : storybookProjects[0].packageManager;
+    rootPackageManager.type === "npm" ? await rootPackageManager.installDependencies({ force: !0 }) : await rootPackageManager.installDependencies(), rootPackageManager.type !== PackageManagerName2.YARN1 && rootPackageManager.isStorybookInMonorepo() && (logger25.warn(
       "Since you are in a monorepo, we advise you to deduplicate your dependencies. We can do this for you but it might take some time."
-    ), options.yes || await prompt6.confirm({
+    ), options.yes || await prompt7.confirm({
       message: `Execute ${rootPackageManager.getRunCommand("dedupe")}?`,
       initialValue: !0
-    }) ? rootPackageManager.type === "npm" ? await rootPackageManager.dedupeDependencies({ force: !0 }) : await rootPackageManager.dedupeDependencies() : logger21.log(
+    }) ? rootPackageManager.type === "npm" ? await rootPackageManager.dedupeDependencies({ force: !0 }) : await rootPackageManager.dedupeDependencies() : logger25.log(
       `If you find any issues running Storybook, you can run ${rootPackageManager.getRunCommand("dedupe")} manually to deduplicate your dependencies and try again.`
     ));
     let doctorProjects = storybookProjects.map((project) => ({
@@ -9583,35 +10431,34 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
       storybookVersion: project.currentCLIVersion,
       mainConfig: project.mainConfig
     }));
-    if (logger21.step("Checking the health of your project(s).."), doctorResults = await runMultiProjectDoctor(doctorProjects), displayDoctorResults(doctorResults) && logTracker3.enableLogWriting(), logUpgradeResults(automigrationResults2, detectedAutomigrations, doctorResults), !options.disableTelemetry) {
-      for (let project of storybookProjects) {
-        let resultData = automigrationResults2[project.configDir] || {
-          automigrationStatuses: {},
-          automigrationErrors: {}
-        }, doctorFailureCount = 0, doctorErrorCount = 0;
-        Object.values(doctorResults[project.configDir]?.diagnostics || {}).forEach((status) => {
-          status === "has_issues" && doctorFailureCount++, status === "check_error" && doctorErrorCount++;
-        });
-        let automigrationFailureCount = Object.keys(resultData.automigrationErrors).length, automigrationPreCheckFailure = project.autoblockerCheckResults && project.autoblockerCheckResults.length > 0 ? project.autoblockerCheckResults?.map((result) => result.result !== null ? result.blocker.id : null).filter(Boolean) : null;
-        await telemetry("upgrade", {
-          beforeVersion: project.beforeVersion,
-          afterVersion: project.currentCLIVersion,
-          automigrationResults: resultData.automigrationStatuses,
-          automigrationErrors: resultData.automigrationErrors,
-          automigrationFailureCount,
-          automigrationPreCheckFailure,
-          doctorResults: doctorResults[project.configDir]?.diagnostics || {},
-          doctorFailureCount,
-          doctorErrorCount
-        });
-      }
-      await sendMultiUpgradeTelemetry({
-        allProjects,
-        selectedProjects: storybookProjects,
-        projectResults: automigrationResults2,
-        doctorResults
+    logger25.step("Checking the health of your project(s).."), doctorResults = await runMultiProjectDoctor(doctorProjects), displayDoctorResults(doctorResults) && logTracker3.enableLogWriting(), logUpgradeResults(automigrationResults2, detectedAutomigrations, doctorResults);
+    for (let project of storybookProjects) {
+      let resultData = automigrationResults2[project.configDir] || {
+        automigrationStatuses: {},
+        automigrationErrors: {}
+      }, doctorFailureCount = 0, doctorErrorCount = 0;
+      Object.values(doctorResults[project.configDir]?.diagnostics || {}).forEach((status) => {
+        status === "has_issues" && doctorFailureCount++, status === "check_error" && doctorErrorCount++;
+      });
+      let automigrationFailureCount = Object.keys(resultData.automigrationErrors).length, automigrationPreCheckFailure = project.autoblockerCheckResults && project.autoblockerCheckResults.length > 0 ? project.autoblockerCheckResults?.map((result) => result.result !== null ? result.blocker.id : null).filter(Boolean) : null;
+      await telemetry2("upgrade", {
+        beforeVersion: project.beforeVersion,
+        afterVersion: project.currentCLIVersion,
+        automigrationResults: resultData.automigrationStatuses,
+        automigrationErrors: resultData.automigrationErrors,
+        automigrationFailureCount,
+        automigrationPreCheckFailure,
+        doctorResults: doctorResults[project.configDir]?.diagnostics || {},
+        doctorFailureCount,
+        doctorErrorCount
       });
     }
+    await sendMultiUpgradeTelemetry({
+      allProjects,
+      selectedProjects: storybookProjects,
+      projectResults: automigrationResults2,
+      doctorResults
+    });
   } finally {
     process.removeListener("SIGINT", handleInterruption), process.removeListener("SIGTERM", handleInterruption);
   }
@@ -9620,13 +10467,13 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
 // src/bin/run.ts
 addToGlobalContext("cliVersion", versions5.storybook);
 var handleCommandFailure = (logFilePath) => async (error) => {
-  error instanceof HandledError2 || logger22.error(String(error));
+  error instanceof HandledError3 || logger26.error(String(error));
   try {
     let logFile = await logTracker4.writeToFile(logFilePath);
-    logger22.log(`Debug logs are written to: ${logFile}`);
+    logger26.log(`Debug logs are written to: ${logFile}`);
   } catch {
   }
-  logger22.outro(""), process.exit(1);
+  logger26.outro(""), process.exit(1);
 }, command = (name) => program.command(name).option(
   "--disable-telemetry",
   "Disable sending telemetry data",
@@ -9636,34 +10483,30 @@ var handleCommandFailure = (logFilePath) => async (error) => {
   "Write all debug logs to the specified file at the end of the run. Defaults to debug-storybook.log when [path] is not provided"
 ).option("--loglevel <trace | debug | info | warn | error | silent>", "Define log level", "info").hook("preAction", async (self2) => {
   let options = self2.opts();
-  options.debug && logger22.setLogLevel("debug"), options.loglevel && logger22.setLogLevel(options.loglevel), options.logfile && logTracker4.enableLogWriting();
+  options.debug && logger26.setLogLevel("debug"), options.loglevel && logger26.setLogLevel(options.loglevel), options.logfile && logTracker4.enableLogWriting();
   try {
     await globalSettings();
   } catch (e) {
-    logger22.error(`Error loading global settings:
+    logger26.error(`Error loading global settings:
 ` + String(e));
   }
 }).hook("postAction", async (command2) => {
   if (logTracker4.shouldWriteLogsToFile) {
     try {
       let logFile = await logTracker4.writeToFile(command2.getOptionValue("logfile"));
-      logger22.log(`Debug logs are written to: ${logFile}`);
+      logger26.log(`Debug logs are written to: ${logFile}`);
     } catch {
     }
-    logger22.outro(CLI_COLORS5.success("Done!"));
+    logger26.outro(CLI_COLORS5.success("Done!"));
   }
 });
 command("init").description("Initialize Storybook into your project").option("-f --force", "Force add Storybook").option("-s --skip-install", "Skip installing deps").addOption(
   new Option("--package-manager <type>", "Force package manager for installing deps").choices(
     Object.values(PackageManagerName3)
   )
-).option("--use-pnp", "Enable PnP mode for Yarn 2+").option("-p --parser <babel | babylon | flow | ts | tsx>", "jscodeshift parser").option("-t --type <type>", "Add Storybook for a specific project type").option("-y --yes", "Answer yes to all prompts").option("-b --builder <webpack5 | vite>", "Builder library").option("-l --linkable", "Prepare installation for link (contributor helper)").option(
-  "--dev",
-  "Launch the development server after completing initialization. Enabled by default (default: true)",
-  !isCI2() && !optionalEnvToBoolean3(process.env.IN_STORYBOOK_SANDBOX)
-).option(
+).option("--use-pnp", "Enable PnP mode for Yarn 2+").option("-p --parser <babel | babylon | flow | ts | tsx>", "jscodeshift parser").option("-t --type <type>", "Add Storybook for a specific project type").option("-y --yes", "Answer yes to all prompts").option("-b --builder <webpack5 | vite>", "Builder library").option("-l --linkable", "Prepare installation for link (contributor helper)").option("--dev", "Launch the development server after completing initialization").option(
   "--no-dev",
-  "Complete the initialization of Storybook without launching the Storybook development server"
+  "Do not launch the Storybook development server after completing initialization (default)"
 );
 command("add <addon>").description("Add an addon to your Storybook").addOption(
   new Option("--package-manager <type>", "Force package manager for installing deps").choices(
@@ -9671,7 +10514,7 @@ command("add <addon>").description("Add an addon to your Storybook").addOption(
   )
 ).option("-c, --config-dir <dir-name>", "Directory where to load Storybook configurations from").option("--skip-install", "Skip installing deps").option("-s --skip-postinstall", "Skip package specific postinstall config modifications").option("-y --yes", "Skip prompting the user").option("--skip-doctor", "Skip doctor check").action((addonName, options) => {
   withTelemetry("add", { cliOptions: options }, async () => {
-    logger22.intro(`Setting up your project for ${addonName}`), await add(addonName, options), options.disableTelemetry || await telemetry2("add", { addon: addonName, source: "cli" }), logger22.outro("Done!");
+    logger26.intro(`Setting up your project for ${addonName}`), await add(addonName, options), await telemetry3("add", { addon: addonName, source: "cli" }), logger26.outro("Done!");
   }).catch(handleCommandFailure);
 });
 command("remove <addon>").description("Remove an addon from your Storybook").addOption(
@@ -9680,7 +10523,7 @@ command("remove <addon>").description("Remove an addon from your Storybook").add
   )
 ).option("-c, --config-dir <dir-name>", "Directory where to load Storybook configurations from").option("-s --skip-install", "Skip installing deps").action(
   (addonName, options) => withTelemetry("remove", { cliOptions: options }, async () => {
-    logger22.intro(`Removing ${addonName} from your Storybook`);
+    logger26.intro(`Removing ${addonName} from your Storybook`);
     let packageManager = JsPackageManagerFactory3.getPackageManager({
       configDir: options.configDir,
       force: options.packageManager
@@ -9689,7 +10532,7 @@ command("remove <addon>").description("Remove an addon from your Storybook").add
       configDir: options.configDir,
       packageManager,
       skipInstall: options.skipInstall
-    }), options.disableTelemetry || await telemetry2("remove", { addon: addonName, source: "cli" }), logger22.outro("Done!");
+    }), await telemetry3("remove", { addon: addonName, source: "cli" }), logger26.outro("Done!");
   }).catch(handleCommandFailure(options.logfile))
 );
 command("upgrade").description(`Upgrade your Storybook packages to v${versions5.storybook}`).addOption(
@@ -9697,6 +10540,9 @@ command("upgrade").description(`Upgrade your Storybook packages to v${versions5.
     Object.values(PackageManagerName3)
   )
 ).option("-y --yes", "Skip prompting the user").option("-f --force", "force the upgrade, skipping autoblockers").option("-n --dry-run", "Only check for upgrades, do not install").option("-s --skip-check", "Skip postinstall version and automigration checks").option(
+  "--skip-automigrations",
+  "Skip running automigrations entirely (only update package versions and install)"
+).option(
   "-c, --config-dir <dir-name...>",
   "Directory(ies) where to load Storybook configurations from"
 ).action(async (options) => {
@@ -9704,12 +10550,12 @@ command("upgrade").description(`Upgrade your Storybook packages to v${versions5.
     "upgrade",
     { cliOptions: { ...options, configDir: options.configDir?.[0] } },
     async () => {
-      logger22.intro(`Storybook upgrade - v${versions5.storybook}`), await upgrade(options), logger22.outro("Storybook upgrade completed!");
+      logger26.intro(`Storybook upgrade - v${versions5.storybook}`), await upgrade(options), logger26.outro("Storybook upgrade completed!");
     }
   ).catch(handleCommandFailure(options.logfile));
 });
 command("info").description("Prints debugging information about the local environment").action(async () => {
-  logger22.log(import_picocolors17.default.bold(`
+  logger26.log(import_picocolors18.default.bold(`
 Storybook Environment Info:`));
   let activePackageManager = JsPackageManagerFactory3.getPackageManager().type.replace(/\d/, ""), output = await import_envinfo.default.run({
     System: ["OS", "CPU", "Shell"],
@@ -9718,10 +10564,10 @@ Storybook Environment Info:`));
     npmPackages: "{@storybook/*,*storybook*,sb,chromatic}",
     npmGlobalPackages: "{@storybook/*,*storybook*,sb,chromatic}"
   }), activePackageManagerLine = output.match(new RegExp(`${activePackageManager}:.*`, "i"));
-  logger22.log(
+  logger26.log(
     output.replace(
       activePackageManagerLine,
-      import_picocolors17.default.bold(`${activePackageManagerLine} <----- active`)
+      import_picocolors18.default.bold(`${activePackageManagerLine} <----- active`)
     )
   );
 });
@@ -9733,12 +10579,12 @@ command("migrate [migration]").description("Run a Storybook codemod migration on
   'Rename suffix of matching files after codemod has been applied, e.g. ".js:.ts"'
 ).action((migration, options) => {
   withTelemetry("migrate", { cliOptions: options }, async () => {
-    logger22.intro(`Running ${migration} migration`), await migrate(migration, options), logger22.outro("Migration completed");
+    logger26.intro(`Running ${migration} migration`), await migrate(migration, options), logger26.outro("Migration completed");
   }).catch(handleCommandFailure(options.logfile));
 });
 command("sandbox [filterValue]").alias("repro").description("Create a sandbox from a set of possible templates").option("-o --output <outDir>", "Define an output directory").option("--no-init", "Whether to download a template without an initialized Storybook", !1).action((filterValue, options) => {
-  logger22.intro("Creating a Storybook sandbox..."), sandbox({ filterValue, ...options }).catch(handleCommandFailure).finally(() => {
-    logger22.outro("Done!");
+  logger26.intro("Creating a Storybook sandbox..."), sandbox({ filterValue, ...options }).catch(handleCommandFailure).finally(() => {
+    logger26.outro("Done!");
   });
 });
 command("link <repo-url-or-directory>").description("Pull down a repro from a URL (or a local directory), link it, and run storybook").option("--local", "Link a local directory already in your file system").option("--no-start", "Start the storybook", !0).action(
@@ -9753,7 +10599,7 @@ command("automigrate [fixId]").description("Check storybook for incompatibilitie
   "The renderer package for the framework Storybook is using."
 ).option("--skip-doctor", "Skip doctor check").option("--glob <pattern>", "Glob pattern for story files (for csf-factories codemod)").action(async (fixId, options) => {
   withTelemetry("automigrate", { cliOptions: options }, async () => {
-    logger22.intro(fixId ? `Running ${fixId} automigration` : "Running automigrations"), await doAutomigrate({ fixId, ...options }), logger22.outro("Done");
+    logger26.intro(fixId ? `Running ${fixId} automigration` : "Running automigrations"), await doAutomigrate({ fixId, ...options }), logger26.outro("Done");
   }).catch(handleCommandFailure(options.logfile));
 });
 command("doctor").description("Check Storybook for known problems and provide suggestions or fixes").addOption(
@@ -9762,13 +10608,30 @@ command("doctor").description("Check Storybook for known problems and provide su
   )
 ).option("-c, --config-dir <dir-name>", "Directory of Storybook configuration").action(async (options) => {
   withTelemetry("doctor", { cliOptions: options }, async () => {
-    logger22.intro("Doctoring Storybook"), await doctor(options), logger22.outro("Done");
+    logger26.intro("Doctoring Storybook"), await doctor(options), logger26.outro("Done");
   }).catch(handleCommandFailure(options.logfile));
 });
+var aiCommand = command("ai").description("AI agent helpers for Storybook").option(
+  "-o, --output <path>",
+  "Write the prompt output to a file instead of printing it to stdout"
+);
+aiCommand.command("setup").description("Generate setup instructions to write stories for real components").addOption(
+  new Option("--package-manager <type>", "Force package manager for installing deps").choices(
+    Object.values(PackageManagerName3)
+  )
+).option("-c, --config-dir <dir-name>", "Directory of Storybook configuration").action(async (options, cmd) => {
+  let parentOptions = cmd.parent?.opts() ?? {}, runId = Math.random().toString(36), mergedOptions = { ...parentOptions, ...options, runId };
+  await withTelemetry("ai-setup", { cliOptions: mergedOptions }, async () => {
+    await aiSetup(mergedOptions);
+  }).catch(handleCommandFailure(mergedOptions.logfile));
+});
+aiCommand.action(() => {
+  aiCommand.outputHelp();
+});
 program.on("command:*", ([invalidCmd]) => {
-  let errorMessage = ` Invalid command: ${import_picocolors17.default.bold(invalidCmd)}.
+  let errorMessage = ` Invalid command: ${import_picocolors18.default.bold(invalidCmd)}.
  See --help for a list of available commands.`, suggestion = program.commands.map((cmd) => cmd.name()).find((cmd) => leven(cmd, invalidCmd) < 3);
   suggestion && (errorMessage += `
- Did you mean ${import_picocolors17.default.yellow(suggestion)}?`), logger22.error(errorMessage), process.exit(1);
+ Did you mean ${import_picocolors18.default.yellow(suggestion)}?`), logger26.error(errorMessage), process.exit(1);
 });
 program.usage("<command> [options]").version(String(version)).parse(process.argv);