@storybook/cli 10.4.0-alpha.11 → 10.4.0-alpha.13

package/dist/_node-chunks/{run-DB2FPOMF.js → run-OIEKD62P.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_ss6g9koxy4s from 'node:url';
-import CJS_COMPAT_NODE_PATH_ss6g9koxy4s from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ss6g9koxy4s from "node:module";
+import CJS_COMPAT_NODE_URL_k1889y8tin from 'node:url';
+import CJS_COMPAT_NODE_PATH_k1889y8tin from 'node:path';
+import CJS_COMPAT_NODE_MODULE_k1889y8tin from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ss6g9koxy4s.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ss6g9koxy4s.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ss6g9koxy4s.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_k1889y8tin.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_k1889y8tin.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_k1889y8tin.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -23,20 +23,21 @@ import {
   processAutoblockerResults,
   require_picocolors,
   shortenPath,
+  up,
   updateMainConfig,
   upgradeStorybookDependencies
-} from "./chunk-6BWYOUU7.js";
+} from "./chunk-X5LJ3DDJ.js";
 import {
   slash
-} from "./chunk-WCEKSVGD.js";
+} from "./chunk-6KUBKUXA.js";
 import {
   require_semver
-} from "./chunk-F3OYUBSA.js";
+} from "./chunk-M4GFZIKM.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-KSVLT5Q6.js";
+} from "./chunk-47LRJSKF.js";
 
 // ../../../node_modules/envinfo/dist/envinfo.js
 var require_envinfo = __commonJS({
@@ -4417,9 +4418,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(resolve4, reject) {
           isexe(path4, options || {}, function(er, is) {
-            er ? reject(er) : resolve2(is);
+            er ? reject(er) : resolve4(is);
           });
         });
       }
@@ -4456,22 +4457,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((resolve4, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve4(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) => {
+        resolve4(subStep(p, i, 0));
+      }), subStep = (p, i, ii) => new Promise((resolve4, reject) => {
         if (ii === pathExt.length)
-          return resolve2(step(i + 1));
+          return resolve4(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 resolve4(p + ext);
+          return resolve4(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -4710,17 +4711,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 logger24 } from "storybook/internal/node-logger";
+import { addToGlobalContext, telemetry as telemetry3 } from "storybook/internal/telemetry";
 import { Option, program } from "commander";
 
 // ../../../node_modules/leven/index.js
@@ -4761,7 +4761,7 @@ function leven(first, second, options) {
 var import_picocolors17 = __toESM(require_picocolors(), 1);
 
 // package.json
-var version = "10.4.0-alpha.11";
+var version = "10.4.0-alpha.13";
 
 // src/add.ts
 var import_semver = __toESM(require_semver(), 1);
@@ -5001,9 +5001,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, logger25 = options.logger;
   if (!postinstall || typeof postinstall != "function") {
-    logger23.error(`Error finding postinstall function for ${addonName}`);
+    logger25.error(`Error finding postinstall function for ${addonName}`);
     return;
   }
   try {
@@ -5024,7 +5024,7 @@ async function add(addon, {
   configDir: userSpecifiedConfigDir,
   yes,
   skipInstall
-}, logger23 = nodeLogger) {
+}, logger25 = nodeLogger) {
   let [addonName, inputVersion] = getVersionSpecifier(addon), { mainConfig, mainConfigPath, configDir, previewConfigPath, packageManager } = await getStorybookData({
     configDir: userSpecifiedConfigDir,
     packageManagerName: pkgMgr
@@ -5034,16 +5034,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");
+    logger25.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 && (logger25.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}`);
+  logger25.log(`Verifying ${addonName}`);
   let version2 = inputVersion;
   if (!version2 && isCoreAddon(addonName) && (version2 = versions.storybook), !version2) {
     let latestVersion = await packageManager.latestVersion(addonName);
@@ -5052,14 +5052,14 @@ async function add(addon, {
     version2 = latestVersion;
   }
   let storybookVersion = versions.storybook, versionIsStorybook = version2 === versions.storybook;
-  isCoreAddon(addonName) && !versionIsStorybook && logger23.warn(
+  isCoreAddon(addonName) && !versionIsStorybook && logger25.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(
+  logger25.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 && (logger25.log(`Adding '${addon}' to the "addons" field in ${mainConfigPath}`), await setupAddonInConfig({
     addonName,
     mainConfigCSFFile: main,
     previewConfigPath,
@@ -5068,7 +5068,7 @@ async function add(addon, {
     packageManager: packageManager.type,
     configDir,
     yes,
-    logger: logger23,
+    logger: logger25,
     prompt,
     skipInstall
   });
@@ -5625,7 +5625,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-XYA3TN25.js"), files = await globby(slash(globPattern), {
+  let modifiedCount = 0, unmodifiedCount = 0, errorCount = 0, { globby } = await import("./globby-KNFCECZ3.js"), files = await globby(slash(globPattern), {
     followSymbolicLinks: !0,
     ignore: ["**/node_modules/**", "**/dist/**", "**/storybook-static/**", "**/build/**"]
   });
@@ -5636,7 +5636,7 @@ Please try a different pattern.
 `
     ), new Error("No files matched");
   try {
-    let pLimit = (await import("./p-limit-U3C7RBHQ.js")).default, limit = pLimit(maxConcurrentTasks);
+    let pLimit = (await import("./p-limit-MF6JQ6VU.js")).default, limit = pLimit(maxConcurrentTasks);
     await Promise.all(
       files.map(
         (file) => limit(async () => {
@@ -6479,7 +6479,7 @@ var addonA11yParameters = {
             errors.push({ file: previewFileToUpdate, error });
           }
     }
-    let { default: pLimit } = await import("./p-limit-U3C7RBHQ.js"), limit = pLimit(10);
+    let { default: pLimit } = await import("./p-limit-MF6JQ6VU.js"), limit = pLimit(10);
     if (await Promise.all(
       storyFilesToUpdate.map(
         (file) => limit(async () => {
@@ -6633,7 +6633,7 @@ var addonGlobalsApi = {
   }
 };
 async function transformStoryFiles(files, options, dryRun) {
-  let errors = [], { default: pLimit } = await import("./p-limit-U3C7RBHQ.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-MF6JQ6VU.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
@@ -6825,7 +6825,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-U3C7RBHQ.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-MF6JQ6VU.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
@@ -6864,7 +6864,7 @@ var transformPackageJsonFiles = async (files, dryRun) => {
       dryRun
     );
     errors.push(...packageJsonErrors);
-    let { globby } = await import("./globby-XYA3TN25.js"), configFiles = await globby([`${configDir}/**/*`]), importErrors = await transformImportFiles(
+    let { globby } = await import("./globby-KNFCECZ3.js"), configFiles = await globby([`${configDir}/**/*`]), importErrors = await transformImportFiles(
       [...storiesPaths, ...configFiles].filter(Boolean),
       {
         ...consolidatedPackages,
@@ -7220,7 +7220,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-XYA3TN25.js"), configFiles = await globby([`${configDir}/**/*`]), allFiles = [...storiesPaths, ...configFiles].filter(Boolean), transformErrors = await transformImportFiles2(
+    let { globby } = await import("./globby-KNFCECZ3.js"), configFiles = await globby([`${configDir}/**/*`]), allFiles = [...storiesPaths, ...configFiles].filter(Boolean), transformErrors = await transformImportFiles2(
       allFiles,
       {
         "@storybook/nextjs": "@storybook/nextjs-vite"
@@ -7430,7 +7430,7 @@ 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-U3C7RBHQ.js"), limit = pLimit(10);
+  let errors = [], { default: pLimit } = await import("./p-limit-MF6JQ6VU.js"), limit = pLimit(10);
   return await Promise.all(
     files.map(
       (file) => limit(async () => {
@@ -7497,7 +7497,7 @@ var getAllDependencies = (packageJson) => Object.keys({
         continue;
       logger13.debug(`
 Migrating ${rendererPackage} to ${selectedFramework}`);
-      let { globby } = await import("./globby-XYA3TN25.js"), configFiles = await globby([`${configDir}/**/*`]);
+      let { globby } = await import("./globby-KNFCECZ3.js"), configFiles = await globby([`${configDir}/**/*`]);
       await transformSourceFiles(
         [...storiesPaths, ...configFiles].filter(Boolean),
         rendererPackage,
@@ -7517,6 +7517,11 @@ 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";
+
+// ../../core/src/shared/constants/config-folder.ts
+var RN_STORYBOOK_DIR = ".rnstorybook";
+
+// src/automigrate/fixes/rnstorybook-config.ts
 async function renameInFile(filePath, oldText, newText) {
   try {
     let updatedContent = (await readFile8(filePath, "utf8")).replaceAll(oldText, newText);
@@ -7527,7 +7532,7 @@ async function renameInFile(filePath, oldText, newText) {
 }
 var getDotStorybookReferences = async (searchDir) => {
   try {
-    let { globby } = await import("./globby-XYA3TN25.js"), { readFile: readFile10 } = await import("node:fs/promises"), files = await globby(`${searchDir}/**/*`, {
+    let { globby } = await import("./globby-KNFCECZ3.js"), { readFile: readFile10 } = await import("node:fs/promises"), files = await globby(`${searchDir}/**/*`, {
       onlyFiles: !0,
       gitignore: !0
     }), referencedFiles = [];
@@ -7548,7 +7553,7 @@ 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-XYA3TN25.js"), requiresFiles = await globby(join2(storybookDir, "storybook.requires.*"));
+    let projectDir = mainConfigPath ? join2(mainConfigPath, "..", "..") : process.cwd(), storybookDir = join2(projectDir, ".storybook"), rnStorybookDir = join2(projectDir, RN_STORYBOOK_DIR), { globby } = await import("./globby-KNFCECZ3.js"), requiresFiles = await globby(join2(storybookDir, "storybook.requires.*"));
     return existsSync2(storybookDir) && requiresFiles.length > 0 && !existsSync2(rnStorybookDir) ? { storybookDir, rnStorybookDir } : null;
   },
   prompt() {
@@ -7558,7 +7563,7 @@ var getDotStorybookReferences = async (searchDir) => {
     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));
   }
@@ -9128,30 +9133,1192 @@ async function promptSelectedTemplate(choices) {
   });
 }
 
+// src/ai/index.ts
+import { writeFile as writeFile9 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+import { cache } from "storybook/internal/common";
+import { logger as logger21 } from "storybook/internal/node-logger";
+import {
+  getSessionId,
+  isTelemetryModuleEnabled,
+  snapshotPreviewFile,
+  telemetry
+} from "storybook/internal/telemetry";
+import { SupportedLanguage as SupportedLanguage2 } from "storybook/internal/types";
+
+// ../create-storybook/src/services/ProjectTypeService.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { ProjectType as ProjectType2 } from "storybook/internal/cli";
+import { HandledError, getProjectRoot } from "storybook/internal/common";
+import { logger as logger20 } 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 join4 } from "node:path";
+import { existsSync as existsSync4, statSync } from "node:fs";
+function up2(name, options) {
+  let dir, tmp, start = options && options.cwd || "";
+  for (dir of up(start, options))
+    if (tmp = join4(dir, name), existsSync4(tmp)) return tmp;
+}
+
+// ../create-storybook/src/services/ProjectTypeService.ts
+var import_semver7 = __toESM(require_semver(), 1);
+import { dedent as dedent16 } 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.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"],
+        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 = resolve2(process.cwd(), ".storybook")) {
+    return existsSync5(configDir);
+  }
+  async validateProvidedType(projectTypeProvided) {
+    if (Object.values(ProjectType2).filter(
+      (t10) => !["undetected", "unsupported", "nx"].includes(String(t10))
+    ).includes(projectTypeProvided))
+      return projectTypeProvided;
+    throw logger20.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 logger20.error(dedent16`
+          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 : (logger20.error(String(err)), new HandledError(err instanceof Error ? err.message : String(err)));
+    }
+  }
+  async detectLanguage() {
+    let language = SupportedLanguage.JAVASCRIPT;
+    if (existsSync5("jsconfig.json"))
+      return language;
+    let isTypescriptDirectDependency = !!this.jsPackageManager.getAllDependencies().typescript, 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;
+    return isTypescriptDirectDependency && typescriptVersion ? satisfies(typescriptVersion, ">=4.9.0") && (!prettierVersion || import_semver7.default.gte(prettierVersion, "2.8.0")) && (!babelPluginTransformTypescriptVersion || satisfies(babelPluginTransformTypescriptVersion, ">=7.20.0")) && (!typescriptEslintParserVersion || satisfies(typescriptEslintParserVersion, ">=5.44.0")) && (!eslintPluginStorybookVersion || satisfies(eslintPluginStorybookVersion, ">=0.6.8")) ? language = SupportedLanguage.TYPESCRIPT : logger20.warn(
+      "Detected TypeScript < 4.9 or incompatible tooling, populating with JavaScript examples"
+    ) : existsSync5("tsconfig.json") && (language = SupportedLanguage.TYPESCRIPT), language;
+  }
+  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) => existsSync5(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/prompt.ts
+import { dedent as dedent18 } from "ts-dedent";
+
+// src/ai/setup-prompts/pattern-copy-play.ts
+import { dedent as dedent17 } from "ts-dedent";
+function getDocsMarkdownUrl(path4, projectInfo) {
+  let { majorVersion, renderer = "react", language = "ts" } = projectInfo ?? {}, versionSegment = majorVersion ? `/${majorVersion}` : "", params = new URLSearchParams();
+  renderer && params.set("renderer", renderer), params.set("language", language);
+  let query = params.toString();
+  return `https://storybook.js.org/docs${versionSegment}/${path4}.md${query ? `?${query}` : ""}`;
+}
+function getTypeImportSource(projectInfo) {
+  return projectInfo.framework || projectInfo.rendererPackage || "@storybook/react";
+}
+function getDocsReferenceSection(projectInfo) {
+  let docsUrl = (path4) => getDocsMarkdownUrl(path4, projectInfo);
+  return dedent17`
+    ### Storybook Documentation Reference
+
+    Use the following references to look up Storybook APIs, concepts, or examples:
+
+    - Full docs index: https://storybook.js.org/llms.txt
+    - See code snippets only with codeOnly=true param e.g. ${docsUrl("writing-stories")}&codeOnly=true
+
+    Key documentation pages for this task:
+    - Writing stories: ${docsUrl("writing-stories")}
+    - Decorators: ${docsUrl("writing-stories/decorators")}
+    - Args: ${docsUrl("writing-stories/args")}
+    - Play functions: ${docsUrl("writing-stories/play-function")}
+    - Vitest integration: ${docsUrl("writing-tests/vitest-plugin")}
+
+    Fetch these URLs directly when you need guidance on Storybook APIs or patterns.
+  `;
+}
+function getPreviewConfigExample(projectInfo) {
+  let configDir = projectInfo.configDir, typeImport = getTypeImportSource(projectInfo);
+  return projectInfo.hasCsfFactoryPreview ? dedent17`
+      \`\`\`tsx
+      // ${configDir}/preview.tsx
+      import '../src/index.css'; // import global styles
+      import MockDate from 'mockdate';
+
+      import { definePreview } from 'storybook/preview';
+      import { SessionProvider } from '../src/contexts/SessionContext';
+
+      export default definePreview({
+        decorators: [
+          (Story) => (
+            <SessionProvider>
+              <Story />
+            </SessionProvider>
+          ),
+        ],
+        async beforeEach() {
+          localStorage.setItem('theme', 'dark');
+          localStorage.setItem('sidebar:open', 'true');
+          MockDate.set('2024-04-01T12:00:00Z');
+        },
+      });
+      \`\`\`
+    ` : dedent17`
+    \`\`\`tsx
+    // ${configDir}/preview.tsx
+    import type { Preview } from '${typeImport}';
+    import MockDate from 'mockdate';
+    import '../src/index.css'; // import global styles
+    import { SessionProvider } from '../src/contexts/SessionContext';
+
+    const preview: Preview = {
+      decorators: [
+        (Story) => (
+          <SessionProvider>
+            <Story />
+          </SessionProvider>
+        ),
+      ],
+      async beforeEach() {
+        localStorage.setItem('theme', 'dark');
+        localStorage.setItem('sidebar:open', 'true');
+        MockDate.set('2024-04-01T12:00:00Z');
+      },
+    };
+
+    export default preview;
+    \`\`\`
+  `;
+}
+function getMockDateExample(projectInfo) {
+  let typeImport = getTypeImportSource(projectInfo);
+  return projectInfo.hasCsfFactoryPreview ? dedent17`
+      \`\`\`tsx
+      import MockDate from 'mockdate';
+      import { definePreview } from 'storybook/preview';
+
+      export default definePreview({
+        async beforeEach() {
+          MockDate.set('2024-04-01T12:00:00Z');
+        },
+      });
+      \`\`\`
+    ` : dedent17`
+    \`\`\`tsx
+    import type { Preview } from '${typeImport}';
+    import MockDate from 'mockdate';
+
+    const preview: Preview = {
+      async beforeEach() {
+        MockDate.set('2024-04-01T12:00:00Z');
+      },
+    };
+
+    export default preview;
+    \`\`\`
+  `;
+}
+function getMswPreviewExample(projectInfo) {
+  let configDir = projectInfo.configDir, typeImport = getTypeImportSource(projectInfo);
+  return projectInfo.hasCsfFactoryPreview ? dedent17`
+      \`\`\`tsx
+      // ${configDir}/preview.tsx
+      import { definePreview } from 'storybook/preview';
+      import { initialize, mswLoader } from 'msw-storybook-addon';
+      import { mswHandlers } from './msw-handlers';
+
+      initialize({
+        onUnhandledRequest: 'bypass',
+      });
+
+      export default definePreview({
+        loaders: [mswLoader],
+        parameters: {
+          msw: {
+            handlers: mswHandlers,
+          },
+        },
+      });
+      \`\`\`
+    ` : dedent17`
+    \`\`\`tsx
+    // ${configDir}/preview.tsx
+    import type { Preview } from '${typeImport}';
+    import { initialize, mswLoader } from 'msw-storybook-addon';
+    import { mswHandlers } from './msw-handlers';
+
+    initialize({
+      onUnhandledRequest: 'bypass',
+    });
+
+    const preview: Preview = {
+      loaders: [mswLoader],
+      parameters: {
+        msw: {
+          handlers: mswHandlers,
+        },
+      },
+    };
+
+    export default preview;
+    \`\`\`
+  `;
+}
+function getStoryExample(projectInfo) {
+  if (projectInfo.hasCsfFactoryPreview)
+    return dedent17`
+      \`\`\`tsx
+      import preview from '#.storybook/preview';
+      import { expect } from 'storybook/test';
+      import { SomeComponent } from './SomeComponent';
+
+      const meta = preview.meta({
+        component: SomeComponent,
+        tags: ['ai-generated'],
+      });
+
+      export const Default = meta.story({
+        render: () => <SomeComponent variant="primary" disabled={false} />,
+        play: async ({ canvas }) => {
+          await expect(canvas.getByRole('button')).toBeVisible();
+        },
+      });
+      \`\`\`
+    `;
+  let typeImport = getTypeImportSource(projectInfo);
+  return dedent17`
+    \`\`\`tsx
+    import type { Meta, StoryObj } from '${typeImport}';
+    import { expect } from 'storybook/test';
+    import { SomeComponent } from './SomeComponent';
+
+    const meta = {
+      component: SomeComponent,
+      tags: ['ai-generated'],
+    } satisfies Meta<typeof SomeComponent>;
+
+    export default meta;
+    type Story = StoryObj<typeof meta>;
+
+    export const Default: Story = {
+      render: () => <SomeComponent variant="primary" disabled={false} />,
+      play: async ({ canvas }) => {
+        await expect(canvas.getByRole('button')).toBeVisible();
+      },
+    };
+    \`\`\`
+  `;
+}
+function getNeedsWorkTagExample(projectInfo) {
+  return projectInfo.hasCsfFactoryPreview ? dedent17`
+      \`\`\`ts
+      const meta = preview.meta({
+        component: SomeComponent,
+        tags: ['ai-generated', 'needs-work'],
+      });
+      \`\`\`
+    ` : dedent17`
+    \`\`\`ts
+    const meta = {
+      component: SomeComponent,
+      tags: ['ai-generated', 'needs-work'],
+    } satisfies Meta<typeof SomeComponent>;
+    \`\`\`
+  `;
+}
+function getArgsStoryExample(projectInfo) {
+  if (projectInfo.hasCsfFactoryPreview)
+    return dedent17`
+      \`\`\`tsx
+      import preview from '#.storybook/preview';
+      import { expect } from 'storybook/test';
+      import { Button } from './Button';
+
+      const meta = preview.meta({
+        component: Button,
+        tags: ['ai-generated'],
+      });
+
+      export const Primary = meta.story({
+        args: {
+          variant: 'primary',
+          children: 'Save',
+        },
+        play: async ({ canvas }) => {
+          await expect(canvas.getByRole('button', { name: /save/i })).toBeVisible();
+        },
+      });
+
+      export const Disabled = meta.story({
+        args: {
+          variant: 'primary',
+          disabled: true,
+          children: 'Save',
+        },
+        play: async ({ canvas }) => {
+          await expect(canvas.getByRole('button')).toBeDisabled();
+        },
+      });
+      \`\`\`
+    `;
+  let typeImport = getTypeImportSource(projectInfo);
+  return dedent17`
+    \`\`\`tsx
+    import type { Meta, StoryObj } from '${typeImport}';
+    import { expect } from 'storybook/test';
+    import { Button } from './Button';
+
+    const meta = {
+      component: Button,
+      tags: ['ai-generated'],
+    } satisfies Meta<typeof Button>;
+
+    export default meta;
+    type Story = StoryObj<typeof meta>;
+
+    export const Primary: Story = {
+      args: {
+        variant: 'primary',
+        children: 'Save',
+      },
+      play: async ({ canvas }) => {
+        await expect(canvas.getByRole('button', { name: /save/i })).toBeVisible();
+      },
+    };
+
+    export const Disabled: Story = {
+      args: {
+        variant: 'primary',
+        disabled: true,
+        children: 'Save',
+      },
+      play: async ({ canvas }) => {
+        await expect(canvas.getByRole('button')).toBeDisabled();
+      },
+    };
+    \`\`\`
+  `;
+}
+function getRenderCompositionExample(projectInfo) {
+  if (projectInfo.hasCsfFactoryPreview)
+    return dedent17`
+      \`\`\`tsx
+      import preview from '#.storybook/preview';
+      import { expect } from 'storybook/test';
+      import { Button } from './Button';
+      import { Card } from './Card';
+
+      const meta = preview.meta({
+        component: Button,
+        tags: ['ai-generated'],
+      });
+
+      export const InsideCard = meta.story({
+        render: () => (
+          <Card>
+            <Button disabled={false}>Save</Button>
+          </Card>
+        ),
+        play: async ({ canvas, userEvent }) => {
+          await expect(canvas.getByRole('button', { name: /save/i })).toBeVisible();
+          await userEvent.click(canvas.getByRole('button', { name: /save/i }));
+        },
+      });
+      \`\`\`
+    `;
+  let typeImport = getTypeImportSource(projectInfo);
+  return dedent17`
+    \`\`\`tsx
+    import type { Meta, StoryObj } from '${typeImport}';
+    import { expect } from 'storybook/test';
+    import { Button } from './Button';
+    import { Card } from './Card';
+
+    const meta = {
+      component: Button,
+      tags: ['ai-generated'],
+    } satisfies Meta<typeof Button>;
+
+    export default meta;
+    type Story = StoryObj<typeof meta>;
+
+    export const InsideCard: Story = {
+      render: () => (
+        <Card>
+          <Button disabled={false}>Save</Button>
+        </Card>
+      ),
+      play: async ({ canvas, userEvent }) => {
+        await expect(canvas.getByRole('button', { name: /save/i })).toBeVisible();
+        await userEvent.click(canvas.getByRole('button', { name: /save/i }));
+      },
+    };
+    \`\`\`
+  `;
+}
+function getPageStoryExample(projectInfo) {
+  if (projectInfo.hasCsfFactoryPreview)
+    return dedent17`
+      \`\`\`tsx
+      import preview from '#.storybook/preview';
+      import { expect } from 'storybook/test';
+      import { ProductPage } from './ProductPage';
+
+      const meta = preview.meta({
+        component: ProductPage,
+        tags: ['ai-generated'],
+      });
+
+      export const Default = meta.story({
+        render: () => <ProductPage />,
+        play: async ({ canvas }) => {
+          await expect(
+            canvas.getByRole('heading', { name: /products/i }),
+          ).toBeVisible();
+        },
+      });
+      \`\`\`
+    `;
+  let typeImport = getTypeImportSource(projectInfo);
+  return dedent17`
+    \`\`\`tsx
+    import type { Meta, StoryObj } from '${typeImport}';
+    import { expect } from 'storybook/test';
+    import { ProductPage } from './ProductPage';
+
+    const meta = {
+      component: ProductPage,
+      tags: ['ai-generated'],
+    } satisfies Meta<typeof ProductPage>;
+
+    export default meta;
+    type Story = StoryObj<typeof meta>;
+
+    export const Default: Story = {
+      render: () => <ProductPage />,
+      play: async ({ canvas }) => {
+        await expect(
+          canvas.getByRole('heading', { name: /products/i }),
+        ).toBeVisible();
+      },
+    };
+    \`\`\`
+  `;
+}
+function instructions(projectInfo) {
+  let configDir = projectInfo.configDir, typeImport = getTypeImportSource(projectInfo);
+  return dedent17`
+    Attention: The following instructions must be followed in order to successfully set up Storybook in this project. Do not skip steps or attempt to do them out of order.
+
+    Your goal is to make Storybook fully functional in this project by analyzing the codebase,
+    configuring the preview with the right decorators, and writing stories for some components.
+
+    The end state should be a Storybook where any component — from a small button to a full page — can be added without story-specific workarounds. All necessary providers, CSS, browser state, and network mocks should live in the shared preview so that just rendering the component in the story is enough.
+
+    After each created story, run Vitest to verify it renders.
+    If the test fails, read the error, fix the issue, and re-run until it passes before moving on.
+
+    - Copy real patterns from the codebase
+    - Keep the app code unchanged
+    - Put the default setup in \`${configDir}/preview.tsx\`
+    - Keep app mocking and runtime setup in \`${configDir}/preview.tsx\`, not in the stories
+
+    ${getDocsReferenceSection(projectInfo)}
+
+    ### Step 1: Analyze the codebase
+
+    Read enough of the app to understand the full runtime environment before writing any stories.
+
+    Do not stop at \`main.tsx\` or \`App.tsx\`.
+    Follow imports into providers, pages, hooks, and shared components until you know:
+
+    - which providers exist
+    - which CSS files are injected
+    - which queries fetch data
+    - which browser-state reads happen
+    - which portals and portal roots exist
+    - which pages and components show the real usage patterns
+
+    Example of what to copy:
+
+    \`\`\`tsx
+    // src/main.tsx
+    import "./index.css";
+    import App from "./App";
+    import { SessionProvider } from "./contexts/SessionContext";
+
+    createRoot(document.getElementById("root")!).render(
+      <SessionProvider>
+        <App />
+      </SessionProvider>,
+    );
+    \`\`\`
+
+    That means Storybook should copy:
+
+    - the \`index.css\` import
+    - the \`SessionProvider\`
+    - the same provider order
+
+    Example of tracing the app deeper:
+
+    \`\`\`tsx
+    // src/App.tsx
+    function App() {
+      const { products, loadMoreProducts } = useProducts();
+      const { currentUser, signOut } = useSession();
+      // ...
+    }
+    \`\`\`
+
+    \`\`\`ts
+    // src/hooks/useProducts.ts
+    const response = await fetch(apiBaseUrl + "/products?page=1");
+    \`\`\`
+
+    \`\`\`ts
+    // src/hooks/useTheme.ts
+    const savedTheme = localStorage.getItem("theme");
+    \`\`\`
+
+    That means the default Storybook setup should discover and prepare:
+
+    - provider state
+    - MSW handlers for queries
+    - browser-state values that are actually read during render
+
+    ### Step 2: Build one default app environment in preview
+
+    Set up Storybook once so most stories work without story-specific setup.
+
+    Start with the smallest faithful environment:
+
+    - the real provider tree
+    - the real root CSS
+    - seeded browser state if the app reads it during render
+    - MSW for network/data queries
+
+    It is fine to seed browser state such as \`localStorage\`, \`sessionStorage\`, and cookies when the app reads them during render.
+    Seed only the specific app-owned keys and values you need.
+    Do not clear all \`localStorage\`, \`sessionStorage\`, or cookies, and do not reset Storybook's own state.
+    Do not mock or redefine the browser runtime itself.
+    The stories run in Vitest browser mode, so the real browser environment should already exist.
+
+    ${getPreviewConfigExample(projectInfo)}
+
+    Use this same idea for:
+
+    - providers
+    - root CSS
+    - browser state
+    - dates, and if the app logic depends on them during render then always use \`mockdate\`
+
+    Example with the \`mockdate\` package:
+
+    ${getMockDateExample(projectInfo)}
+
+    ### Step 3: Support portals with preview-body.html
+
+    If the app uses portals, copy that setup into Storybook too.
+
+    Look for patterns like:
+
+    - \`createPortal(...)\`
+    - modal, dialog, drawer, popover, tooltip, toast, or dropdown portal components
+    - hard-coded roots such as \`#portal-root\`, \`#modal-root\`, \`#drawer-root\`, or \`#toast-root\`
+
+    Example of what to copy:
+
+    \`\`\`tsx
+    // real component
+    return createPortal(<ModalContent />, document.getElementById("portal-root")!);
+    \`\`\`
+
+    That means Storybook should create the same portal root in \`${configDir}/preview-body.html\`:
+
+    \`\`\`html
+    <!-- ${configDir}/preview-body.html -->
+    <div id="portal-root"></div>
+    \`\`\`
+
+    If the app uses multiple portal roots, create all of them there:
+
+    \`\`\`html
+    <!-- ${configDir}/preview-body.html -->
+    <div id="modal-root"></div>
+    <div id="drawer-root"></div>
+    <div id="toast-root"></div>
+    \`\`\`
+
+    If a library portals directly to \`document.body\`, do not add extra roots for it.
+    Make sure the copied page shell, CSS, and layout still allow overlays, fixed positioning, and z-index stacking to render correctly.
+
+    ### Step 4: Mock side effects globally
+
+    All network/data queries should be handled by the default Storybook environment.
+
+    - Always use \`msw-storybook-addon\` for query mocking.
+    - If you introduce MSW, run \`npx msw init ./public --save\` to create the worker file.
+    - Make sure Storybook serves \`./public\` as a static dir so \`mockServiceWorker.js\` is available.
+    - Do not mock \`fetch\` directly.
+    - Network/data queries should return deterministic mock data.
+    - If you need to change dependencies, first check the lockfile and use that package manager for the change.
+
+    Example of copying a real fetch pattern into shared handlers:
+
+    \`\`\`ts
+    // real app hook
+    const response = await fetch(
+      apiBaseUrl +
+        "/products?" +
+        new URLSearchParams({
+          page: "1",
+          sort: "featured",
+        }),
+    );
+    \`\`\`
+
+    \`\`\`ts
+    // ${configDir}/msw-handlers.ts
+    import { http, HttpResponse } from "msw";
+
+    export const mswHandlers = {
+      products: [
+        http.get("https://api.example.com/products", () =>
+          HttpResponse.json({
+            items: [
+              {
+                id: "product-1",
+                name: "Example product",
+                description: "Mock product description",
+                imageUrl: "https://images.example.com/product.jpg",
+                price: 42,
+              },
+            ],
+          }),
+        ),
+      ],
+    };
+    \`\`\`
+
+    ${getMswPreviewExample(projectInfo)}
+
+    \`\`\`ts
+    // ${configDir}/main.ts
+    import type { StorybookConfig } from "${typeImport}";
+
+    const config: StorybookConfig = {
+      staticDirs: ["../public"],
+    };
+
+    export default config;
+    \`\`\`
+
+    Keep these mocks global.
+    Do not put fetch mocks in individual stories.
+    Only add handlers for requests that the shared preview setup or the stories actually use.
+    Do not add catch-all handlers that can hide unrelated failures.
+    If the defaults are not enough, improve the shared default setup instead.
+    Seed browser state when needed, but do not mock \`window\`, \`document\`, \`navigator\`, observers, or similar runtime APIs.
+    The only exception is \`mockdate\` when date-based rendering exists.
+
+    ### Step 5: Write stories
+
+    Try to find around 10 good candidate components for story files.
+    Write colocated stories for top-level components, from low-level reusable components up to page components.
+    Write up to 10 story files, or fewer only if the codebase clearly has fewer meaningful targets.
+
+    The stories should use JSX copied from real usage patterns in:
+
+    - pages
+    - app shells
+    - routes
+    - tests
+    - existing feature code
+
+    As a rule of thumb, each story file should have around 3 story exports when the component or page has enough meaningful states.
+    It can have more when the real usage supports it, up to 10 story exports in one file.
+
+    Always show all imports explicitly in story and preview files.
+    Do not rely on omitted or implied imports in examples or generated code.
+
+    #### Story tags
+
+    Every story meta must include the \`ai-generated\` tag to identify AI-created stories:
+
+    ${getStoryExample(projectInfo)}
+
+    If a story could not be fully fixed after the self-healing loop (the test still fails
+    or the rendering is incomplete), add the \`needs-work\` tag alongside \`ai-generated\`:
+
+    ${getNeedsWorkTagExample(projectInfo)}
+
+    #### Args vs render
+
+    For simple components where props drive the state, prefer \`args\` stories — no \`render\` function needed:
+
+    ${getArgsStoryExample(projectInfo)}
+
+    Use \`render\` when the story needs composition — wrapping the component in layout, combining multiple components, or passing children as JSX:
+
+    ${getRenderCompositionExample(projectInfo)}
+
+    Keep app mocking and runtime setup in preview, not in the stories.
+    Do not build large story-specific harnesses.
+    Do not write story files for subcomponents, hooks, contexts, or helpers.
+    Do not create new application components.
+    Do not add a custom \`title\`.
+    Do not stop after only a few easy targets if the codebase has more meaningful components or pages available.
+
+    ### Step 6: Write a play function for every story
+
+    Every named story export must have a \`play\` function.
+    The \`play\` function is not optional, even for simple stories.
+
+    The purpose of the \`play\` function is to prove that the story actually works in the copied Storybook environment:
+
+    - the story renders something real and non-empty
+    - the decorators provide the needed context
+    - the CSS is applied well enough for the intended state to be visible
+    - the MSW mocks or seeded browser state are actually being used
+    - important interactions, async loading states, and portals behave correctly
+
+    Use \`play\` functions to verify behavior, not just to click around.
+    A story without assertions is incomplete.
+
+    Use tools from \`storybook/test\` such as:
+
+    - \`expect\`
+    - \`waitFor\`
+
+    Prefer \`canvas\` and \`userEvent\` from the \`play\` context.
+    Do not destructure \`canvasElement\` just to create \`const canvas = within(canvasElement)\`.
+    Do not import \`userEvent\` from \`storybook/test\`; use \`userEvent\` from the \`play\` context instead.
+    Only use \`canvasElement.ownerDocument\` when you need to query outside the canvas, such as for portals.
+
+    Example:
+
+    \`\`\`tsx
+    import type { StoryObj } from "${typeImport}";
+
+    export const FilledForm: Story = {
+      play: async ({ canvas, userEvent }) => {
+        const emailInput = canvas.getByLabelText("email", {
+          selector: "input",
+        });
+
+        await userEvent.type(emailInput, "example-email@email.com", {
+          delay: 100,
+        });
+
+        const passwordInput = canvas.getByLabelText("password", {
+          selector: "input",
+        });
+
+        await userEvent.type(passwordInput, "ExamplePassword", {
+          delay: 100,
+        });
+
+        const submitButton = canvas.getByRole("button");
+        await userEvent.click(submitButton);
+      },
+    };
+    \`\`\`
+
+    The assertions should match the real pattern you copied:
+
+    - for provider-backed stories, assert the provider-dependent UI appears correctly
+    - for mocked-data stories, wait for the mocked data to appear and assert on it
+    - for CSS-sensitive states, assert on visibility, text layout, class-driven states, or meaningful computed styles
+    - for routing or navigation stories, assert the routed state or navigation outcome
+    - for portal stories, query from \`canvasElement.ownerDocument\` when the UI renders outside the canvas
+
+    Examples of useful checks:
+
+    - a themed button has the expected label and is visibly enabled or disabled
+    - a modal opened through a decorator or provider is visible in the portal root
+    - mocked API data appears in the page instead of a loading spinner forever
+    - a selected tab actually shows the selected panel
+    - a toast, alert, or badge has the expected accessible text and visual state
+    - a CSS class or computed style confirms the real state that matters
+
+    ### Step 7: Prove CSS is loaded in exactly one story named \`CssCheck\`
+
+    In exactly one story, named \`CssCheck\`, assert a component-specific computed style. \`toBeVisible\` passes on an unstyled component; a concrete style value proves the shared preview loaded the app's CSS.
+
+    Pick a visually distinctive component, read a styling value from its source, and assert it with \`getComputedStyle\`:
+
+    \`\`\`tsx
+    export const CssCheck: Story = {
+      args: { children: "Submit" },
+      play: async ({ canvas }) => {
+        const button = canvas.getByRole("button", { name: /submit/i });
+        // PrimaryButton uses bg-blue-600 — fails if Tailwind / global CSS did not load.
+        await expect(getComputedStyle(button).backgroundColor).toBe("rgb(37, 99, 235)");
+      },
+    };
+    \`\`\`
+
+    ### Step 8: Cover the patterns you found
+
+    Write stories for the real patterns in the codebase, for example:
+
+    - a low-level reusable component in real JSX usage
+    - a provider-backed component
+    - a browser-state-backed component
+    - a fetched-data component
+    - a real page component
+
+    Use \`App.tsx\` to inspect the real provider tree and usage patterns, but do not make a story for \`App\` when the codebase has actual page components.
+
+    Example page story:
+
+    ${getPageStoryExample(projectInfo)}
+
+    ### Step 9: Verify both rendering and types
+
+    As you work, verify the stories with Vitest:
+
+    \`\`\`bash
+    npx vitest --project storybook <path-to-story-file>
+    \`\`\`
+
+    Also verify types so you catch missing required props, broken imports, and preview typing issues. Run the same TypeScript command the project itself uses.
+
+    \`\`\`bash
+    <project-specific-typescript-command>
+    \`\`\`
+
+    After verification passes, review every changed file and remove anything that is not needed for the final solution, especially debug fixes, overly broad mocks, unnecessary dependencies, and eval artifacts.
+
+    Keep iterating until:
+
+    - every story you wrote passes
+    - every story you wrote has a meaningful passing \`play\` function
+    - the changed stories and preview setup pass the project's real TypeScript check
+    - the rendered output looks sensible
+    - the default global mocked environment is strong enough that stories do not need manual fetch overrides
+    - stories no longer fail because the shared preview setup and story JSX are fixed
+    - all passing stories have \`tags: ['ai-generated']\` in their meta
+    - any stories that still need work have \`tags: ['ai-generated', 'needs-work']\` in their meta
+  `;
+}
+
+// src/ai/setup-prompts/index.ts
+var CURRENTLY_USED_PROMPT = {
+  "pattern-copy-play": instructions
+}, FORMERLY_USED_PROMPTS = {
+  setup: async () => (await import("./setup-BYVI7PM2.js")).instructions
+}, PROMPT_NAMES = [
+  ...Object.keys(CURRENTLY_USED_PROMPT),
+  ...Object.keys(FORMERLY_USED_PROMPTS)
+], DEFAULT_PROMPT_NAME = "pattern-copy-play", 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 getPrompts(projectInfo) {
+  let name = resolvePromptName(), builder = CURRENTLY_USED_PROMPT[name] ?? await FORMERLY_USED_PROMPTS[name]();
+  return {
+    prompts: [
+      {
+        name,
+        description: "Set up Storybook for success",
+        instructions: builder(projectInfo)
+      }
+    ]
+  };
+}
+
+// src/ai/prompt.ts
+function getProjectOverview(projectInfo) {
+  return dedent18`
+    ## Project Info
+
+    | Property | Value |
+    |----------|-------|
+    | Version | ${projectInfo.storybookVersion || "unknown"} |
+    | Renderer | ${projectInfo.rendererPackage || "unknown"} |
+    | Framework | ${projectInfo.framework || "unknown"} |
+    | Builder | ${projectInfo.builderPackage || "unknown"} |
+    | Config Dir | \`${projectInfo.configDir}\` |
+    | CSF Format | ${projectInfo.hasCsfFactoryPreview ? "CSF Factory" : "CSF3"} |
+    | Addons | ${projectInfo.addons.length > 0 ? projectInfo.addons.join(", ") : "none"} |
+  `;
+}
+async function generateMarkdownOutput(projectInfo) {
+  let { prompts: aiPrompts } = await getPrompts(projectInfo), sections = [];
+  sections.push(dedent18`
+    # Storybook Setup
+  `), sections.push(getProjectOverview(projectInfo));
+  for (let aiPrompt of aiPrompts)
+    sections.push(aiPrompt.instructions);
+  return { markdown: sections.join(`
+
+`) };
+}
+
+// src/ai/index.ts
+async function aiSetup(options) {
+  let { configDir: userConfigDir, packageManager: packageManagerName, output } = options, projectInfo;
+  try {
+    let data = await getStorybookData({
+      configDir: userConfigDir,
+      packageManagerName
+    }), majorVersion = data.versionInstalled ? parseMajorVersion(data.versionInstalled) : void 0;
+    if (!data.frameworkPackage || !data.rendererPackage || !data.builderPackage) {
+      logger21.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 language = await new ProjectTypeService(data.packageManager).detectLanguage() === SupportedLanguage2.TYPESCRIPT ? "ts" : "js";
+    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,
+      hasCsfFactoryPreview: data.hasCsfFactoryPreview,
+      language
+    };
+  } catch (err) {
+    logger21.error(
+      `Failed to read Storybook configuration: ${err instanceof Error ? err.message : String(err)}`
+    ), logger21.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") {
+    logger21.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 markdownOutput = (await generateMarkdownOutput(projectInfo)).markdown;
+  if (await telemetry("ai-setup", {
+    cliOptions: {
+      output: output ? "file" : void 0,
+      configDir: projectInfo.configDir,
+      packageManager: packageManagerName
+    },
+    project: {
+      framework: projectInfo.framework,
+      renderer: projectInfo.rendererPackage,
+      builder: projectInfo.builderPackage,
+      language: projectInfo.language,
+      hasCsfFactoryPreview: projectInfo.hasCsfFactoryPreview
+    }
+  }), isTelemetryModuleEnabled()) {
+    let resolvedConfigDir = resolve3(projectInfo.configDir), previewSnapshot = await snapshotPreviewFile(resolvedConfigDir), sessionId = await getSessionId(), pendingRecord = {
+      timestamp: Date.now(),
+      sessionId,
+      configDir: resolvedConfigDir,
+      ...previewSnapshot
+    };
+    await cache.set("ai-setup-pending", pendingRecord);
+  }
+  if (output) {
+    let outputPath = resolve3(output);
+    await writeFile9(outputPath, markdownOutput, "utf-8"), logger21.log(`Prompt written to ${outputPath}`);
+  } else
+    logger21.log(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_picocolors16 = __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, isCorePackage as isCorePackage2 } from "storybook/internal/common";
 import {
   CLI_COLORS as CLI_COLORS4,
   createHyperlink,
   logTracker as logTracker3,
-  logger as logger21,
+  logger as logger23,
   prompt as prompt6
 } from "storybook/internal/node-logger";
 import {
   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 logger22, prompt as prompt5 } 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(
+  logger22.debug(
     `Starting automigration collection across ${projects.length} projects and ${fixes.length} fixes...`
   );
   function collectResult(fix, project, status, result) {
@@ -9173,10 +10340,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}...`), logger22.debug(`Processing project: ${projectName}`);
     for (let fix of fixes)
       try {
-        logger20.debug(`Checking fix ${fix.id} for project ${projectName}...`);
+        logger22.debug(`Checking fix ${fix.id} for project ${projectName}...`);
         let checkOptions = {
           packageManager: project.packageManager,
           configDir: project.configDir,
@@ -9189,9 +10356,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"), logger22.debug(
           `Failed to check fix ${fix.id} for project ${shortenPath(project.configDir)}.`
-        ), logger20.debug(`${error instanceof Error ? error.stack : String(error)}`), ErrorCollector.addError(error);
+        ), logger22.debug(`${error instanceof Error ? error.stack : String(error)}`), ErrorCollector.addError(error);
       }
   }
   let allAutomigrations = Array.from(automigrationMap.values()), applicableAutomigrations = allAutomigrations.filter(
@@ -9205,9 +10372,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(`${logger22.SYMBOLS.success} ${fixId}`)}`);
   }), failedAutomigrations.forEach((fixId) => {
-    taskLog.message(`${CLI_COLORS3.error(`${logger20.SYMBOLS.error} ${fixId}`)}`);
+    taskLog.message(`${CLI_COLORS3.error(`${logger22.SYMBOLS.error} ${fixId}`)}`);
   }), failedAutomigrations.length > 0 ? taskLog.error(
     `${failedAutomigrations.length} automigration ${failedAutomigrations.length > 1 ? "checks" : "check"} failed`
   ) : taskLog.success(
@@ -9225,12 +10392,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 logger22.log("Detected automigrations (dry run - no changes will be made):"), automigrations.forEach(({ fix, reports: list }) => {
+      logger22.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 logger22.log("Running all detected automigrations:"), automigrations.forEach(({ fix, reports: list }) => {
+      logger22.log(`  - ${fix.id} (${formatProjectDirs(list)})`);
     }), automigrations;
   let choices = automigrations.map((am) => {
     let hint = [];
@@ -9279,13 +10446,13 @@ async function runAutomigrationsForProjects(selectedAutomigrations, options) {
       title: `${countPrefix}Running automigrations for ${projectName}`
     }) : {
       message: (message) => {
-        logger20.debug(`${message}`);
+        logger22.debug(`${message}`);
       },
       error: (message) => {
-        logger20.debug(`${message}`);
+        logger22.debug(`${message}`);
       },
       success: (message) => {
-        logger20.debug(`${message}`);
+        logger22.debug(`${message}`);
       }
     }, fixResults = {}, fixFailures = {};
     for (let automigration of projectAutomigration) {
@@ -9319,11 +10486,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(`${logger22.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(`${logger22.SYMBOLS.error} ${automigration.fix.id}`)), logger22.debug(errorMessage), ErrorCollector.addError(error);
       }
     }
     let automigrationsWithErrors = Object.values(fixResults).filter(
@@ -9378,7 +10545,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,28 +10600,28 @@ function logUpgradeResults(projectResults, detectedAutomigrations, doctorResults
     doctorResults
   );
   if (failedProjects.length > 0) {
-    if (logTracker3.enableLogWriting(), logger21.step(
+    if (logTracker3.enableLogWriting(), logger23.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:")}
+      logger23.log(`${CLI_COLORS4.success("Successfully upgraded:")}
 ${successfulProjectsList}`);
     }
     let failedProjectsList = failedProjects.map((dir) => `  \u2022 ${shortenPath(dir)}`).join(`
 `);
-    if (logger21.log(
+    if (logger23.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:")}
+      logger23.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(
+    Object.values(doctorResults).every((result) => result.status === "healthy") ? logger23.step(`${CLI_COLORS4.success("Your project(s) have been upgraded successfully! \u{1F389}")}`) : logger23.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.")}`
     );
   let automigrationLinks = detectedAutomigrations.filter(
@@ -9468,9 +10635,9 @@ ${projectList}`);
       ...automigrationLinks
     ].join(`
 `);
-    logger21.log(automigrationLinksMessage);
+    logger23.log(automigrationLinksMessage);
   }
-  logger21.log(
+  logger23.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 +10658,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 +10669,7 @@ async function sendMultiUpgradeTelemetry(options) {
       hasUserInterrupted
     });
   } catch (error) {
-    logger21.debug(`Failed to send multi-upgrade telemetry: ${String(error)}`);
+    logger23.debug(`Failed to send multi-upgrade telemetry: ${String(error)}`);
   }
 }
 async function upgrade(options) {
@@ -9510,13 +10677,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.length > 1 ? logger23.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(
+`)}`) : logger23.info(
     `Upgrading from ${import_picocolors16.default.bold(storybookProjects[0].beforeVersion)} to ${import_picocolors16.default.bold(storybookProjects[0].currentCLIVersion)}`
   );
   let automigrationResults = {}, doctorResults = {}, handleInterruption = async () => {
-    throw logger21.log(`
+    throw logger23.log(`
 
 Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgradeTelemetry({
       allProjects,
@@ -9524,16 +10691,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}`);
+      logger23.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
@@ -9548,7 +10715,7 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
       try {
         let loggedPaths = [];
         for (let project of storybookProjects) {
-          logger21.debug(`Updating dependencies in ${shortenPath(project.configDir)}...`);
+          logger23.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 +10732,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 ? logger23.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() && (logger23.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({
       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() : logger23.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,7 +10752,7 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
       storybookVersion: project.currentCLIVersion,
       mainConfig: project.mainConfig
     }));
-    logger21.step("Checking the health of your project(s).."), doctorResults = await runMultiProjectDoctor(doctorProjects), displayDoctorResults(doctorResults) && logTracker3.enableLogWriting(), logUpgradeResults(automigrationResults2, detectedAutomigrations, doctorResults);
+    logger23.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: {},
@@ -9593,7 +10762,7 @@ Upgrade interrupted by user.`), allProjects.length > 1 && await sendMultiUpgrade
         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", {
+      await telemetry2("upgrade", {
         beforeVersion: project.beforeVersion,
         afterVersion: project.currentCLIVersion,
         automigrationResults: resultData.automigrationStatuses,
@@ -9619,13 +10788,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 || logger24.error(String(error));
   try {
     let logFile = await logTracker4.writeToFile(logFilePath);
-    logger22.log(`Debug logs are written to: ${logFile}`);
+    logger24.log(`Debug logs are written to: ${logFile}`);
   } catch {
   }
-  logger22.outro(""), process.exit(1);
+  logger24.outro(""), process.exit(1);
 }, command = (name) => program.command(name).option(
   "--disable-telemetry",
   "Disable sending telemetry data",
@@ -9635,34 +10804,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 && logger24.setLogLevel("debug"), options.loglevel && logger24.setLogLevel(options.loglevel), options.logfile && logTracker4.enableLogWriting();
   try {
     await globalSettings();
   } catch (e) {
-    logger22.error(`Error loading global settings:
+    logger24.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}`);
+      logger24.log(`Debug logs are written to: ${logFile}`);
     } catch {
     }
-    logger22.outro(CLI_COLORS5.success("Done!"));
+    logger24.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(
@@ -9670,7 +10835,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), await telemetry2("add", { addon: addonName, source: "cli" }), logger22.outro("Done!");
+    logger24.intro(`Setting up your project for ${addonName}`), await add(addonName, options), await telemetry3("add", { addon: addonName, source: "cli" }), logger24.outro("Done!");
   }).catch(handleCommandFailure);
 });
 command("remove <addon>").description("Remove an addon from your Storybook").addOption(
@@ -9679,7 +10844,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`);
+    logger24.intro(`Removing ${addonName} from your Storybook`);
     let packageManager = JsPackageManagerFactory3.getPackageManager({
       configDir: options.configDir,
       force: options.packageManager
@@ -9688,7 +10853,7 @@ command("remove <addon>").description("Remove an addon from your Storybook").add
       configDir: options.configDir,
       packageManager,
       skipInstall: options.skipInstall
-    }), await telemetry2("remove", { addon: addonName, source: "cli" }), logger22.outro("Done!");
+    }), await telemetry3("remove", { addon: addonName, source: "cli" }), logger24.outro("Done!");
   }).catch(handleCommandFailure(options.logfile))
 );
 command("upgrade").description(`Upgrade your Storybook packages to v${versions5.storybook}`).addOption(
@@ -9696,6 +10861,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) => {
@@ -9703,12 +10871,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!");
+      logger24.intro(`Storybook upgrade - v${versions5.storybook}`), await upgrade(options), logger24.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(`
+  logger24.log(import_picocolors17.default.bold(`
 Storybook Environment Info:`));
   let activePackageManager = JsPackageManagerFactory3.getPackageManager().type.replace(/\d/, ""), output = await import_envinfo.default.run({
     System: ["OS", "CPU", "Shell"],
@@ -9717,7 +10885,7 @@ Storybook Environment Info:`));
     npmPackages: "{@storybook/*,*storybook*,sb,chromatic}",
     npmGlobalPackages: "{@storybook/*,*storybook*,sb,chromatic}"
   }), activePackageManagerLine = output.match(new RegExp(`${activePackageManager}:.*`, "i"));
-  logger22.log(
+  logger24.log(
     output.replace(
       activePackageManagerLine,
       import_picocolors17.default.bold(`${activePackageManagerLine} <----- active`)
@@ -9732,12 +10900,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");
+    logger24.intro(`Running ${migration} migration`), await migrate(migration, options), logger24.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!");
+  logger24.intro("Creating a Storybook sandbox..."), sandbox({ filterValue, ...options }).catch(handleCommandFailure).finally(() => {
+    logger24.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(
@@ -9752,7 +10920,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");
+    logger24.intro(fixId ? `Running ${fixId} automigration` : "Running automigrations"), await doAutomigrate({ fixId, ...options }), logger24.outro("Done");
   }).catch(handleCommandFailure(options.logfile));
 });
 command("doctor").description("Check Storybook for known problems and provide suggestions or fixes").addOption(
@@ -9761,13 +10929,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");
+    logger24.intro("Doctoring Storybook"), await doctor(options), logger24.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 mergedOptions = { ...cmd.parent?.opts() ?? {}, ...options };
+  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)}.
  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_picocolors17.default.yellow(suggestion)}?`), logger24.error(errorMessage), process.exit(1);
 });
 program.usage("<command> [options]").version(String(version)).parse(process.argv);