storybook 10.1.0-alpha.11 → 10.1.0-alpha.13

package/dist/cli/index.js

@@ -1,85 +1,51 @@
-import CJS_COMPAT_NODE_URL_843v2rliy1 from 'node:url';
-import CJS_COMPAT_NODE_PATH_843v2rliy1 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_843v2rliy1 from "node:module";
+import CJS_COMPAT_NODE_URL_h0pwn2pcb57 from 'node:url';
+import CJS_COMPAT_NODE_PATH_h0pwn2pcb57 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_h0pwn2pcb57 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_843v2rliy1.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_843v2rliy1.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_843v2rliy1.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_h0pwn2pcb57.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_h0pwn2pcb57.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_h0pwn2pcb57.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
-  CommunityBuilder,
-  CoreBuilder,
-  CoreWebpackCompilers,
-  ProjectType,
-  SUPPORTED_RENDERERS,
-  SupportedLanguage,
-  addToDevDependenciesIfNotPresent,
-  adjustTemplate,
-  builderNameToCoreBuilder,
-  cliStoriesTargetPath,
-  coerceSemver,
-  compilerNameToCoreCompiler,
-  copyTemplate,
-  copyTemplateFiles,
-  detect,
-  detectBuilder,
-  detectFrameworkPreset,
-  detectLanguage,
-  detectPnp,
-  externalFrameworks,
-  frameworkToDefaultBuilder,
-  getBabelDependencies,
-  getRendererDir,
-  getVersionSafe,
-  hasStorybookDependencies,
-  installableProjectTypes,
-  isNxProject,
-  isStorybookInstantiated,
-  readFileAsJson,
-  supportedTemplates,
-  unsupportedTemplate,
-  writeFileAsJson
-} from "../_node-chunks/chunk-KK4AT5F3.js";
-import {
-  boxen
-} from "../_node-chunks/chunk-7I22Y76Z.js";
-import "../_node-chunks/chunk-MJ3WOS6F.js";
+  detectPnp
+} from "../_node-chunks/chunk-654SJIMS.js";
 import {
   Settings,
   _clearGlobalSettings,
   globalSettings
-} from "../_node-chunks/chunk-JCRM2YVK.js";
+} from "../_node-chunks/chunk-XKRVQL2G.js";
 import {
+  any,
   up2 as up
-} from "../_node-chunks/chunk-4GZCFQFG.js";
-import "../_node-chunks/chunk-R6HWGZWD.js";
-import "../_node-chunks/chunk-SPQXMU2Q.js";
-import "../_node-chunks/chunk-BBOP3XCK.js";
+} from "../_node-chunks/chunk-DPFYWXEA.js";
+import {
+  invariant
+} from "../_node-chunks/chunk-JQ7RQS5Q.js";
 import {
-  require_prompts
-} from "../_node-chunks/chunk-GQJOWVVR.js";
+  resolvePackageDir
+} from "../_node-chunks/chunk-MJM4TEMP.js";
+import "../_node-chunks/chunk-LPKSBF62.js";
 import {
   require_dist
-} from "../_node-chunks/chunk-PHOZWZZO.js";
+} from "../_node-chunks/chunk-CMYD2JNN.js";
 import {
   babelParse,
   recast,
   traverse,
   types
-} from "../_node-chunks/chunk-ZZSRFAC6.js";
-import "../_node-chunks/chunk-L7MYXJUM.js";
-import "../_node-chunks/chunk-LCZO45L7.js";
+} from "../_node-chunks/chunk-RUUNVQ6W.js";
+import "../_node-chunks/chunk-FCVNHU2F.js";
 import {
   require_picocolors
-} from "../_node-chunks/chunk-32NE3UE3.js";
+} from "../_node-chunks/chunk-OVVZIUHS.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "../_node-chunks/chunk-XGVLB4UJ.js";
+} from "../_node-chunks/chunk-WC2YEQHJ.js";
 
 // ../node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS({
@@ -412,8 +378,8 @@ var require_esprima = __commonJS({
                 }
                 return result;
               }, JSXParser2.prototype.lexJSX = function() {
-                var cp = this.scanner.source.charCodeAt(this.scanner.index);
-                if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
+                var cp2 = this.scanner.source.charCodeAt(this.scanner.index);
+                if (cp2 === 60 || cp2 === 62 || cp2 === 47 || cp2 === 58 || cp2 === 61 || cp2 === 123 || cp2 === 125) {
                   var value = this.scanner.source[this.scanner.index++];
                   return {
                     type: 7,
@@ -424,7 +390,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 34 || cp === 39) {
+                if (cp2 === 34 || cp2 === 39) {
                   for (var start = this.scanner.index, quote = this.scanner.source[this.scanner.index++], str = ""; !this.scanner.eof(); ) {
                     var ch = this.scanner.source[this.scanner.index++];
                     if (ch === quote)
@@ -440,7 +406,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 46) {
+                if (cp2 === 46) {
                   var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1), n2 = this.scanner.source.charCodeAt(this.scanner.index + 2), value = n1 === 46 && n2 === 46 ? "..." : ".", start = this.scanner.index;
                   return this.scanner.index += value.length, {
                     type: 7,
@@ -451,7 +417,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 96)
+                if (cp2 === 96)
                   return {
                     type: 10,
                     value: "",
@@ -460,7 +426,7 @@ var require_esprima = __commonJS({
                     start: this.scanner.index,
                     end: this.scanner.index
                   };
-                if (character_1.Character.isIdentifierStart(cp) && cp !== 92) {
+                if (character_1.Character.isIdentifierStart(cp2) && cp2 !== 92) {
                   var start = this.scanner.index;
                   for (++this.scanner.index; !this.scanner.eof(); ) {
                     var ch = this.scanner.source.charCodeAt(this.scanner.index);
@@ -659,33 +625,33 @@ var require_esprima = __commonJS({
             };
             exports2.Character = {
               /* tslint:disable:no-bitwise */
-              fromCodePoint: function(cp) {
-                return cp < 65536 ? String.fromCharCode(cp) : String.fromCharCode(55296 + (cp - 65536 >> 10)) + String.fromCharCode(56320 + (cp - 65536 & 1023));
+              fromCodePoint: function(cp2) {
+                return cp2 < 65536 ? String.fromCharCode(cp2) : String.fromCharCode(55296 + (cp2 - 65536 >> 10)) + String.fromCharCode(56320 + (cp2 - 65536 & 1023));
               },
               // https://tc39.github.io/ecma262/#sec-white-space
-              isWhiteSpace: function(cp) {
-                return cp === 32 || cp === 9 || cp === 11 || cp === 12 || cp === 160 || cp >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp) >= 0;
+              isWhiteSpace: function(cp2) {
+                return cp2 === 32 || cp2 === 9 || cp2 === 11 || cp2 === 12 || cp2 === 160 || cp2 >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp2) >= 0;
               },
               // https://tc39.github.io/ecma262/#sec-line-terminators
-              isLineTerminator: function(cp) {
-                return cp === 10 || cp === 13 || cp === 8232 || cp === 8233;
+              isLineTerminator: function(cp2) {
+                return cp2 === 10 || cp2 === 13 || cp2 === 8232 || cp2 === 8233;
               },
               // https://tc39.github.io/ecma262/#sec-names-and-keywords
-              isIdentifierStart: function(cp) {
-                return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp));
+              isIdentifierStart: function(cp2) {
+                return cp2 === 36 || cp2 === 95 || cp2 >= 65 && cp2 <= 90 || cp2 >= 97 && cp2 <= 122 || cp2 === 92 || cp2 >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp2));
               },
-              isIdentifierPart: function(cp) {
-                return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp >= 48 && cp <= 57 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp));
+              isIdentifierPart: function(cp2) {
+                return cp2 === 36 || cp2 === 95 || cp2 >= 65 && cp2 <= 90 || cp2 >= 97 && cp2 <= 122 || cp2 >= 48 && cp2 <= 57 || cp2 === 92 || cp2 >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp2));
               },
               // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
-              isDecimalDigit: function(cp) {
-                return cp >= 48 && cp <= 57;
+              isDecimalDigit: function(cp2) {
+                return cp2 >= 48 && cp2 <= 57;
               },
-              isHexDigit: function(cp) {
-                return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+              isHexDigit: function(cp2) {
+                return cp2 >= 48 && cp2 <= 57 || cp2 >= 65 && cp2 <= 70 || cp2 >= 97 && cp2 <= 102;
               },
-              isOctalDigit: function(cp) {
-                return cp >= 48 && cp <= 55;
+              isOctalDigit: function(cp2) {
+                return cp2 >= 48 && cp2 <= 55;
               }
             };
           },
@@ -3049,15 +3015,15 @@ var require_esprima = __commonJS({
                     return !1;
                 }
               }, Scanner2.prototype.codePointAt = function(i) {
-                var cp = this.source.charCodeAt(i);
-                if (cp >= 55296 && cp <= 56319) {
+                var cp2 = this.source.charCodeAt(i);
+                if (cp2 >= 55296 && cp2 <= 56319) {
                   var second = this.source.charCodeAt(i + 1);
                   if (second >= 56320 && second <= 57343) {
-                    var first = cp;
-                    cp = (first - 55296) * 1024 + second - 56320 + 65536;
+                    var first = cp2;
+                    cp2 = (first - 55296) * 1024 + second - 56320 + 65536;
                   }
                 }
-                return cp;
+                return cp2;
               }, Scanner2.prototype.scanHexEscape = function(prefix) {
                 for (var len = prefix === "u" ? 4 : 2, code = 0, i = 0; i < len; ++i)
                   if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index)))
@@ -3084,11 +3050,11 @@ var require_esprima = __commonJS({
                 }
                 return this.source.slice(start, this.index);
               }, Scanner2.prototype.getComplexIdentifier = function() {
-                var cp = this.codePointAt(this.index), id = character_1.Character.fromCodePoint(cp);
+                var cp2 = this.codePointAt(this.index), id = character_1.Character.fromCodePoint(cp2);
                 this.index += id.length;
                 var ch;
-                for (cp === 92 && (this.source.charCodeAt(this.index) !== 117 && this.throwUnexpectedToken(), ++this.index, this.source[this.index] === "{" ? (++this.index, ch = this.scanUnicodeCodePointEscape()) : (ch = this.scanHexEscape("u"), (ch === null || ch === "\\" || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) && this.throwUnexpectedToken()), id = ch); !this.eof() && (cp = this.codePointAt(this.index), !!character_1.Character.isIdentifierPart(cp)); )
-                  ch = character_1.Character.fromCodePoint(cp), id += ch, this.index += ch.length, cp === 92 && (id = id.substr(0, id.length - 1), this.source.charCodeAt(this.index) !== 117 && this.throwUnexpectedToken(), ++this.index, this.source[this.index] === "{" ? (++this.index, ch = this.scanUnicodeCodePointEscape()) : (ch = this.scanHexEscape("u"), (ch === null || ch === "\\" || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) && this.throwUnexpectedToken()), id += ch);
+                for (cp2 === 92 && (this.source.charCodeAt(this.index) !== 117 && this.throwUnexpectedToken(), ++this.index, this.source[this.index] === "{" ? (++this.index, ch = this.scanUnicodeCodePointEscape()) : (ch = this.scanHexEscape("u"), (ch === null || ch === "\\" || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) && this.throwUnexpectedToken()), id = ch); !this.eof() && (cp2 = this.codePointAt(this.index), !!character_1.Character.isIdentifierPart(cp2)); )
+                  ch = character_1.Character.fromCodePoint(cp2), id += ch, this.index += ch.length, cp2 === 92 && (id = id.substr(0, id.length - 1), this.source.charCodeAt(this.index) !== 117 && this.throwUnexpectedToken(), ++this.index, this.source[this.index] === "{" ? (++this.index, ch = this.scanUnicodeCodePointEscape()) : (ch = this.scanHexEscape("u"), (ch === null || ch === "\\" || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) && this.throwUnexpectedToken()), id += ch);
                 return id;
               }, Scanner2.prototype.octalToDecimal = function(ch) {
                 var octal = ch !== "0", code = octalValue(ch);
@@ -3442,8 +3408,8 @@ var require_esprima = __commonJS({
                     start: this.index,
                     end: this.index
                   };
-                var cp = this.source.charCodeAt(this.index);
-                return character_1.Character.isIdentifierStart(cp) ? this.scanIdentifier() : cp === 40 || cp === 41 || cp === 59 ? this.scanPunctuator() : cp === 39 || cp === 34 ? this.scanStringLiteral() : cp === 46 ? character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1)) ? this.scanNumericLiteral() : this.scanPunctuator() : character_1.Character.isDecimalDigit(cp) ? this.scanNumericLiteral() : cp === 96 || cp === 125 && this.curlyStack[this.curlyStack.length - 1] === "${" ? this.scanTemplate() : cp >= 55296 && cp < 57343 && character_1.Character.isIdentifierStart(this.codePointAt(this.index)) ? this.scanIdentifier() : this.scanPunctuator();
+                var cp2 = this.source.charCodeAt(this.index);
+                return character_1.Character.isIdentifierStart(cp2) ? this.scanIdentifier() : cp2 === 40 || cp2 === 41 || cp2 === 59 ? this.scanPunctuator() : cp2 === 39 || cp2 === 34 ? this.scanStringLiteral() : cp2 === 46 ? character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1)) ? this.scanNumericLiteral() : this.scanPunctuator() : character_1.Character.isDecimalDigit(cp2) ? this.scanNumericLiteral() : cp2 === 96 || cp2 === 125 && this.curlyStack[this.curlyStack.length - 1] === "${" ? this.scanTemplate() : cp2 >= 55296 && cp2 < 57343 && character_1.Character.isIdentifierStart(this.codePointAt(this.index)) ? this.scanIdentifier() : this.scanPunctuator();
               }, Scanner2;
             })();
             exports2.Scanner = Scanner;
@@ -4742,21 +4708,21 @@ var require_stringify = __commonJS({
       return display_block || is_line_comment ? str + LF + deeper_gap : str;
     }, replacer = null, indent = EMPTY, clean = () => {
       replacer = null, indent = EMPTY;
-    }, join2 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY, join_content = (inside, value, gap) => {
+    }, join5 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY, join_content = (inside, value, gap) => {
       let comment = process_comments(value, PREFIX_BEFORE, gap + indent, !0);
-      return join2(comment, inside, gap);
+      return join5(comment, inside, gap);
     }, array_stringify = (value, gap) => {
       let deeper_gap = gap + indent, { length } = value, inside = EMPTY, after_comma = EMPTY;
       for (let i = 0; i < length; i++) {
         i !== 0 && (inside += COMMA);
-        let before = join2(
+        let before = join5(
           after_comma,
           process_comments(value, BEFORE(i), deeper_gap),
           deeper_gap
         );
         inside += before || LF + deeper_gap, inside += stringify(i, value, deeper_gap) || STR_NULL, inside += process_comments(value, AFTER_VALUE(i), deeper_gap), after_comma = process_comments(value, AFTER(i), deeper_gap);
       }
-      return inside += join2(
+      return inside += join5(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -4769,14 +4735,14 @@ var require_stringify = __commonJS({
         if (sv === UNDEFINED)
           return;
         first || (inside += COMMA), first = !1;
-        let before = join2(
+        let before = join5(
           after_comma,
           process_comments(value, BEFORE(key), deeper_gap),
           deeper_gap
         );
         inside += before || LF + deeper_gap, inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap), after_comma = process_comments(value, AFTER(key), deeper_gap);
       };
-      return keys.forEach(iteratee), inside += join2(
+      return keys.forEach(iteratee), inside += join5(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -4851,39 +4817,727 @@ var require_src2 = __commonJS({
   }
 });
 
-// src/cli/angular/helpers.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+// src/cli/helpers.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { cpSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { cp, readFile as readFile2, writeFile } from "node:fs/promises";
+import { join as join3, resolve as resolve2 } from "node:path";
+import {
+  frameworkToRenderer
+} from "storybook/internal/common";
 import { logger } from "storybook/internal/node-logger";
-import { MissingAngularJsonError } from "storybook/internal/server-errors";
-var import_prompts = __toESM(require_prompts(), 1), import_ts_dedent = __toESM(require_dist(), 1), ANGULAR_JSON_PATH = "angular.json", compoDocPreviewPrefix = import_ts_dedent.dedent`
-  import { setCompodocJson } from "@storybook/addon-docs/angular";
-  import docJson from "../documentation.json";
-  setCompodocJson(docJson);
-`.trimStart(), promptForCompoDocs = async () => {
-  logger.plain(
-    // Create a text which explains the user why compodoc is necessary
-    boxen(
-      import_ts_dedent.dedent`
-      Compodoc is a great tool to generate documentation for your Angular projects.
-      Storybook can use the documentation generated by Compodoc to extract argument definitions
-      and JSDOC comments to display them in the Storybook UI. We highly recommend using Compodoc for
-      your Angular projects to get the best experience out of Storybook.
-    `,
-      { title: "Compodoc", borderStyle: "round", padding: 1, borderColor: "#F1618C" }
-    )
-  );
-  let { useCompoDoc } = await (0, import_prompts.default)({
-    type: "confirm",
-    name: "useCompoDoc",
-    message: "Do you want to use Compodoc for documentation?"
+import {
+  SupportedLanguage
+} from "storybook/internal/types";
+import { Feature } from "storybook/internal/types";
+import { coerce, satisfies } from "semver";
+
+// ../node_modules/strip-json-comments/index.js
+var singleComment = Symbol("singleComment"), multiComment = Symbol("multiComment"), stripWithoutWhitespace = () => "", stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/[^ \t\r\n]/g, " "), isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1, backslashCount = 0;
+  for (; jsonString[index] === "\\"; )
+    index -= 1, backslashCount += 1;
+  return !!(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = !0, trailingCommas = !1 } = {}) {
+  if (typeof jsonString != "string")
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  let strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace, isInsideString = !1, isInsideComment = !1, offset = 0, buffer = "", result = "", commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    let currentCharacter = jsonString[index], nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"' && (isEscaped(jsonString, index) || (isInsideString = !isInsideString)), !isInsideString)
+      if (!isInsideComment && currentCharacter + nextCharacter === "//")
+        buffer += jsonString.slice(offset, index), offset = index, isInsideComment = singleComment, index++;
+      else if (isInsideComment === singleComment && currentCharacter + nextCharacter === `\r
+`) {
+        index++, isInsideComment = !1, buffer += strip(jsonString, offset, index), offset = index;
+        continue;
+      } else if (isInsideComment === singleComment && currentCharacter === `
+`)
+        isInsideComment = !1, buffer += strip(jsonString, offset, index), offset = index;
+      else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+        buffer += jsonString.slice(offset, index), offset = index, isInsideComment = multiComment, index++;
+        continue;
+      } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+        index++, isInsideComment = !1, buffer += strip(jsonString, offset, index + 1), offset = index + 1;
+        continue;
+      } else trailingCommas && !isInsideComment && (commaIndex !== -1 ? currentCharacter === "}" || currentCharacter === "]" ? (buffer += jsonString.slice(offset, index), result += strip(buffer, 0, 1) + buffer.slice(1), buffer = "", offset = index, commaIndex = -1) : currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== `
+` && (buffer += jsonString.slice(offset, index), offset = index, commaIndex = -1) : currentCharacter === "," && (result += buffer + jsonString.slice(offset, index), buffer = "", offset = index, commaIndex = index));
+  }
+  let remaining = isInsideComment === singleComment ? strip(jsonString, offset) : jsonString.slice(offset);
+  return result + buffer + remaining;
+}
+
+// src/cli/dirs.ts
+import { join as join2 } from "node:path";
+import { Readable as Readable2 } from "node:stream";
+import { pipeline as pipeline2 } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { temporaryDirectory, versions } from "storybook/internal/common";
+import { SupportedFramework } from "storybook/internal/types";
+
+// ../node_modules/get-npm-tarball-url/lib/index.mjs
+function src_default(pkgName, pkgVersion, opts) {
+  let registry;
+  opts?.registry ? registry = opts.registry.endsWith("/") ? opts.registry : `${opts.registry}/` : registry = "https://registry.npmjs.org/";
+  let scopelessName = getScopelessName(pkgName);
+  return `${registry}${pkgName}/-/${scopelessName}-${removeBuildMetadataFromVersion(pkgVersion)}.tgz`;
+}
+function removeBuildMetadataFromVersion(version) {
+  let plusPos = version.indexOf("+");
+  return plusPos === -1 ? version : version.substring(0, plusPos);
+}
+function getScopelessName(name) {
+  return name[0] !== "@" ? name : name.split("/")[1];
+}
+
+// ../node_modules/modern-tar/dist/unpacker-BKKRRs7i.js
+var FLAGTYPE = {
+  0: "file",
+  1: "link",
+  2: "symlink",
+  3: "character-device",
+  4: "block-device",
+  5: "directory",
+  6: "fifo",
+  x: "pax-header",
+  g: "pax-global-header",
+  L: "gnu-long-name",
+  K: "gnu-long-link-name"
+}, ZERO_BLOCK = new Uint8Array(512), encoder = new TextEncoder(), decoder = new TextDecoder();
+function readString(view, offset, size) {
+  let end = view.indexOf(0, offset), sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+  return decoder.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal(view, offset, size) {
+  let value = 0, end = offset + size;
+  for (let i = offset; i < end; i++) {
+    let charCode = view[i];
+    if (charCode === 0) break;
+    charCode !== 32 && (value = (value << 3) + (charCode - 48));
+  }
+  return value;
+}
+function readNumeric(view, offset, size) {
+  if (view[offset] & 128) {
+    let result = 0;
+    result = view[offset] & 127;
+    for (let i = 1; i < size; i++) result = result * 256 + view[offset + i];
+    if (!Number.isSafeInteger(result)) throw new Error("TAR number too large");
+    return result;
+  }
+  return readOctal(view, offset, size);
+}
+var CHECKSUM_SPACE = 32;
+function validateChecksum(block) {
+  let stored = readOctal(block, 148, 8), sum = 0;
+  for (let i = 0; i < block.length; i++) i >= 148 && i < 156 ? sum += CHECKSUM_SPACE : sum += block[i];
+  return stored === sum;
+}
+function parseUstarHeader(block, strict) {
+  if (strict && !validateChecksum(block)) throw new Error("Invalid tar header checksum.");
+  let typeflag = readString(block, 156, 1), header = {
+    name: readString(block, 0, 100),
+    mode: readOctal(block, 100, 8),
+    uid: readNumeric(block, 108, 8),
+    gid: readNumeric(block, 116, 8),
+    size: readNumeric(block, 124, 12),
+    mtime: new Date(readNumeric(block, 136, 12) * 1e3),
+    type: FLAGTYPE[typeflag] || "file",
+    linkname: readString(block, 157, 100)
+  }, magic = readString(block, 257, 6);
+  return magic.trim() === "ustar" && (header.uname = readString(block, 265, 32), header.gname = readString(block, 297, 32)), magic === "ustar" && (header.prefix = readString(block, 345, 155)), header;
+}
+var PAX_MAPPING = {
+  path: ["name", (v) => v],
+  linkpath: ["linkname", (v) => v],
+  size: ["size", (v) => parseInt(v, 10)],
+  mtime: ["mtime", parseFloat],
+  uid: ["uid", (v) => parseInt(v, 10)],
+  gid: ["gid", (v) => parseInt(v, 10)],
+  uname: ["uname", (v) => v],
+  gname: ["gname", (v) => v]
+};
+function parsePax(buffer) {
+  let decoder$1 = new TextDecoder("utf-8"), overrides = {}, pax = {}, offset = 0;
+  for (; offset < buffer.length; ) {
+    let spaceIndex = buffer.indexOf(32, offset);
+    if (spaceIndex === -1) break;
+    let length = parseInt(decoder$1.decode(buffer.subarray(offset, spaceIndex)), 10);
+    if (Number.isNaN(length) || length === 0) break;
+    let recordEnd = offset + length, [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+    if (key && value !== void 0) {
+      pax[key] = value;
+      let mapping = PAX_MAPPING[key];
+      if (mapping) {
+        let [targetKey, parser] = mapping, parsedValue = parser(value);
+        (typeof parsedValue == "string" || !Number.isNaN(parsedValue)) && (overrides[targetKey] = parsedValue);
+      }
+    }
+    offset = recordEnd;
+  }
+  return Object.keys(pax).length > 0 && (overrides.pax = pax), overrides;
+}
+function applyOverrides(header, overrides) {
+  overrides.name !== void 0 && (header.name = overrides.name), overrides.linkname !== void 0 && (header.linkname = overrides.linkname), overrides.size !== void 0 && (header.size = overrides.size), overrides.mtime !== void 0 && (header.mtime = new Date(overrides.mtime * 1e3)), overrides.uid !== void 0 && (header.uid = overrides.uid), overrides.gid !== void 0 && (header.gid = overrides.gid), overrides.uname !== void 0 && (header.uname = overrides.uname), overrides.gname !== void 0 && (header.gname = overrides.gname), overrides.pax && (header.pax = Object.assign({}, header.pax ?? {}, overrides.pax));
+}
+function getMetaParser(type) {
+  switch (type) {
+    case "pax-global-header":
+    case "pax-header":
+      return parsePax;
+    case "gnu-long-name":
+      return (data) => ({ name: readString(data, 0, data.length) });
+    case "gnu-long-link-name":
+      return (data) => ({ linkname: readString(data, 0, data.length) });
+    default:
+      return;
+  }
+}
+var EOF_BUFFER = new Uint8Array(512 * 2);
+function transformHeader(header, options) {
+  let { strip, filter, map } = options;
+  if (!strip && !filter && !map) return header;
+  let h = { ...header };
+  if (strip && strip > 0) {
+    let components = h.name.split("/").filter(Boolean);
+    if (strip >= components.length) return null;
+    let newName = components.slice(strip).join("/");
+    if (h.name = h.type === "directory" && !newName.endsWith("/") ? `${newName}/` : newName, h.linkname?.startsWith("/")) {
+      let linkComponents = h.linkname.split("/").filter(Boolean);
+      h.linkname = strip >= linkComponents.length ? "/" : `/${linkComponents.slice(strip).join("/")}`;
+    }
+  }
+  if (filter?.(h) === !1) return null;
+  let result = map ? map(h) : h;
+  return result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/") ? null : result;
+}
+var STATE_HEADER = 0, STATE_BODY = 1, STATE_PADDING = 2, STATE_AWAIT_EOF = 3;
+function createTarUnpacker(handler, options = {}) {
+  let strict = options.strict ?? !1, chunkQueue = [], totalAvailable = 0, state = STATE_HEADER, waitingForData = !1, currentEntry = null, paxGlobals = {}, nextEntryOverrides = {};
+  function consume(size, callback) {
+    let remaining = Math.min(size, totalAvailable), initialRemaining = remaining;
+    for (; remaining > 0 && chunkQueue.length > 0; ) {
+      let chunkNode = chunkQueue[0], available = chunkNode.data.length - chunkNode.consumed, toProcess = Math.min(remaining, available);
+      callback && callback(chunkNode.data.subarray(chunkNode.consumed, chunkNode.consumed + toProcess)), chunkNode.consumed += toProcess, remaining -= toProcess, chunkNode.consumed >= chunkNode.data.length && chunkQueue.shift();
+    }
+    return totalAvailable -= initialRemaining - remaining, initialRemaining - remaining;
+  }
+  function read(size) {
+    let toRead = Math.min(size, totalAvailable);
+    if (toRead === 0) return null;
+    let chunk = chunkQueue[0];
+    if (chunk && chunk.data.length - chunk.consumed >= toRead) {
+      let result$1 = chunk.data.subarray(chunk.consumed, chunk.consumed + toRead);
+      return chunk.consumed += toRead, totalAvailable -= toRead, chunk.consumed >= chunk.data.length && chunkQueue.shift(), result$1;
+    }
+    let result = new Uint8Array(toRead), offset = 0;
+    return consume(toRead, (data) => {
+      result.set(data, offset), offset += data.length;
+    }), result;
+  }
+  function process2() {
+    for (; ; ) switch (state) {
+      case STATE_HEADER: {
+        if (totalAvailable < 512) {
+          waitingForData = !0;
+          return;
+        }
+        let headerBlock = read(512);
+        if (!headerBlock) {
+          waitingForData = !0;
+          return;
+        }
+        if (isZeroBlock(headerBlock)) {
+          state = STATE_AWAIT_EOF;
+          continue;
+        }
+        waitingForData = !1;
+        try {
+          let internalHeader = parseUstarHeader(headerBlock, strict), header = {
+            ...internalHeader,
+            name: internalHeader.name
+          }, metaParser = getMetaParser(header.type);
+          if (metaParser) {
+            let paddedSize = header.size + 511 & -512;
+            if (totalAvailable < paddedSize) {
+              waitingForData = !0, chunkQueue.unshift({
+                data: headerBlock,
+                consumed: 0
+              }), totalAvailable += 512;
+              return;
+            }
+            let metaBlock = read(paddedSize);
+            if (!metaBlock) {
+              waitingForData = !0;
+              return;
+            }
+            let overrides = metaParser(metaBlock.subarray(0, header.size));
+            header.type === "pax-global-header" ? Object.assign(paxGlobals, overrides) : Object.assign(nextEntryOverrides, overrides);
+            continue;
+          }
+          internalHeader.prefix && (header.name = `${internalHeader.prefix}/${header.name}`), applyOverrides(header, paxGlobals), applyOverrides(header, nextEntryOverrides), nextEntryOverrides = {}, handler.onHeader(header), header.size > 0 ? (currentEntry = {
+            remaining: header.size,
+            padding: -header.size & 511
+          }, state = STATE_BODY) : handler.onEndEntry();
+        } catch (error) {
+          handler.onError(error);
+          return;
+        }
+        continue;
+      }
+      case STATE_BODY: {
+        if (!currentEntry) throw new Error("No current entry for body");
+        let toForward = Math.min(currentEntry.remaining, totalAvailable);
+        if (toForward > 0) {
+          let consumed = consume(toForward, handler.onData);
+          currentEntry.remaining -= consumed;
+        }
+        if (currentEntry.remaining === 0)
+          state = currentEntry.padding > 0 ? STATE_PADDING : STATE_HEADER, state === STATE_HEADER && (handler.onEndEntry(), currentEntry = null);
+        else if (totalAvailable === 0) {
+          waitingForData = !0;
+          return;
+        }
+        continue;
+      }
+      case STATE_PADDING:
+        if (!currentEntry) throw new Error("No current entry for padding");
+        if (totalAvailable < currentEntry.padding) {
+          waitingForData = !0;
+          return;
+        }
+        currentEntry.padding > 0 && consume(currentEntry.padding), handler.onEndEntry(), currentEntry = null, state = STATE_HEADER;
+        continue;
+      case STATE_AWAIT_EOF: {
+        if (totalAvailable < 512) {
+          waitingForData = !0;
+          return;
+        }
+        let secondBlock = read(512);
+        if (!secondBlock) {
+          waitingForData = !0;
+          return;
+        }
+        if (isZeroBlock(secondBlock)) return;
+        if (strict) {
+          handler.onError(new Error("Invalid EOF"));
+          return;
+        }
+        chunkQueue.unshift({
+          data: secondBlock,
+          consumed: 0
+        }), totalAvailable += 512, state = STATE_HEADER;
+        continue;
+      }
+      default:
+        throw new Error("Invalid state in tar unpacker.");
+    }
+  }
+  return {
+    write(chunk) {
+      if (chunk.length !== 0 && (chunkQueue.push({
+        data: chunk,
+        consumed: 0
+      }), totalAvailable += chunk.length, waitingForData)) {
+        waitingForData = !1;
+        try {
+          process2();
+        } catch (error) {
+          handler.onError(error);
+        }
+      }
+    },
+    end() {
+      try {
+        if (waitingForData || process2(), strict) {
+          if (currentEntry && currentEntry.remaining > 0) {
+            let error = new Error("Tar archive is truncated.");
+            throw handler.onError(error), error;
+          }
+          if (totalAvailable > 0 && read(totalAvailable)?.some((b) => b !== 0)) {
+            let error = new Error("Invalid EOF.");
+            throw handler.onError(error), error;
+          }
+          if (waitingForData) {
+            let error = new Error("Tar archive is truncated.");
+            throw handler.onError(error), error;
+          }
+        } else currentEntry && (handler.onEndEntry(), currentEntry = null);
+      } catch (error) {
+        handler.onError(error);
+      }
+    }
+  };
+}
+function isZeroBlock(block) {
+  if (block.byteOffset % 8 === 0) {
+    let view = new BigUint64Array(block.buffer, block.byteOffset, block.length / 8);
+    for (let i = 0; i < view.length; i++) if (view[i] !== 0n) return !1;
+    return !0;
+  }
+  for (let i = 0; i < block.length; i++) if (block[i] !== 0) return !1;
+  return !0;
+}
+
+// ../node_modules/modern-tar/dist/fs/index.js
+import * as fs from "node:fs/promises";
+import { cpus } from "node:os";
+import * as path from "node:path";
+import { PassThrough, Readable, Writable } from "node:stream";
+import { createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+var unicodeCache = /* @__PURE__ */ new Map(), normalizeUnicode = (s) => {
+  let result = unicodeCache.get(s);
+  return result !== void 0 && unicodeCache.delete(s), result = result ?? s.normalize("NFD"), unicodeCache.set(s, result), unicodeCache.size > 1e4 && unicodeCache.delete(unicodeCache.keys().next().value), result;
+};
+function validateBounds(targetPath, destDir, errorMessage) {
+  let target = normalizeUnicode(path.resolve(targetPath)), dest = path.resolve(destDir);
+  if (target !== dest && !target.startsWith(dest + path.sep)) throw new Error(errorMessage);
+}
+var win32Reserved = {
+  ":": "\uF03A",
+  "<": "\uF03C",
+  ">": "\uF03E",
+  "|": "\uF07C",
+  "?": "\uF03F",
+  "*": "\uF02A",
+  '"': "\uF022"
+};
+function normalizeName(name) {
+  let path$1 = name.replace(/\\/g, "/");
+  if (path$1.split("/").includes("..") || /^[a-zA-Z]:\.\./.test(path$1)) throw new Error(`${name} points outside extraction directory`);
+  let relative = path$1;
+  return /^[a-zA-Z]:/.test(relative) ? relative = relative.replace(/^[a-zA-Z]:[/\\]?/, "") : relative.startsWith("/") && (relative = relative.replace(/^\/+/, "")), process.platform === "win32" ? relative.replace(/[<>:"|?*]/g, (char) => win32Reserved[char]) : relative;
+}
+var normalizeHeaderName = (s) => normalizeUnicode(normalizeName(s.replace(/\/+$/, "")));
+function unpackTar(directoryPath, options = {}) {
+  let { streamTimeout = 5e3, ...fsOptions } = options, timeoutId = null, { handler, signal } = createFSHandler(directoryPath, fsOptions), unpacker = createTarUnpacker(handler, fsOptions), stream;
+  function resetTimeout() {
+    timeoutId && clearTimeout(timeoutId), streamTimeout !== 1 / 0 && streamTimeout > 0 && (timeoutId = setTimeout(() => {
+      let err = new Error(`Stream timed out after ${streamTimeout}ms of inactivity.`);
+      stream.destroy(err);
+    }, streamTimeout));
+  }
+  return stream = new Writable({
+    write(chunk, _, callback) {
+      if (resetTimeout(), signal.aborted) return callback(signal.reason);
+      try {
+        unpacker.write(chunk), callback();
+      } catch (writeErr) {
+        callback(writeErr);
+      }
+    },
+    async final(callback) {
+      timeoutId && clearTimeout(timeoutId);
+      try {
+        if (signal.aborted) return callback(signal.reason);
+        unpacker.end(), await handler.process(), callback();
+      } catch (finalErr) {
+        callback(finalErr);
+      }
+    }
+  }), stream.on("close", () => {
+    timeoutId && clearTimeout(timeoutId);
+  }), resetTimeout(), stream;
+}
+function createFSHandler(directoryPath, options) {
+  let { maxDepth = 1024, dmode, fmode, concurrency = cpus().length || 8 } = options, abortController = new AbortController(), { signal } = abortController, opQueue = [], activeOps = 0, pathPromises = /* @__PURE__ */ new Map(), activeEntryStream = null, processingEnded = !1, resolveDrain, drainPromise = new Promise((resolve3) => {
+    resolveDrain = resolve3;
+  }), processQueue = () => {
+    for (signal.aborted && (opQueue.length = 0); activeOps < concurrency && opQueue.length > 0; ) {
+      activeOps++;
+      let op = opQueue.shift();
+      if (!op) break;
+      op();
+    }
+    processingEnded && activeOps === 0 && opQueue.length === 0 && resolveDrain();
+  }, destDirPromise = (async () => {
+    let symbolic = normalizeUnicode(path.resolve(directoryPath));
+    await fs.mkdir(symbolic, { recursive: !0 });
+    try {
+      let real = await fs.realpath(symbolic);
+      return {
+        symbolic,
+        real
+      };
+    } catch (err) {
+      throw signal.aborted ? signal.reason : err;
+    }
+  })();
+  destDirPromise.catch((err) => {
+    signal.aborted || abortController.abort(err);
+  });
+  let ensureDirectoryExists = (dirPath) => {
+    let promise = pathPromises.get(dirPath);
+    return promise || (promise = (async () => {
+      if (signal.aborted) throw signal.reason;
+      let destDir = await destDirPromise;
+      if (dirPath === destDir.symbolic) return "directory";
+      if (await ensureDirectoryExists(path.dirname(dirPath)), signal.aborted) throw signal.reason;
+      try {
+        let stat2 = await fs.lstat(dirPath);
+        if (stat2.isDirectory()) return "directory";
+        if (stat2.isSymbolicLink()) {
+          let realPath = await fs.realpath(dirPath);
+          if (validateBounds(realPath, destDir.real, `Symlink "${dirPath}" points outside the extraction directory.`), (await fs.stat(realPath)).isDirectory()) return "directory";
+        }
+        throw new Error(`"${dirPath}" is not a valid directory component.`);
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return await fs.mkdir(dirPath, { mode: dmode }), "directory";
+        throw err;
+      }
+    })(), pathPromises.set(dirPath, promise), promise);
+  };
+  return {
+    handler: {
+      onHeader(header) {
+        if (signal.aborted) return;
+        activeEntryStream = new PassThrough({ highWaterMark: header.size > 1048576 ? 524288 : void 0 });
+        let entryStream = activeEntryStream, startOperation = () => {
+          let opPromise;
+          try {
+            let transformed = transformHeader(header, options);
+            if (!transformed) {
+              entryStream.resume(), activeOps--, processQueue();
+              return;
+            }
+            let name = normalizeHeaderName(transformed.name), target = path.join(path.resolve(directoryPath), name);
+            opPromise = (pathPromises.get(target) || Promise.resolve(void 0)).then(async (priorOp) => {
+              if (signal.aborted) throw signal.reason;
+              if (priorOp && (priorOp === "directory" && transformed.type !== "directory" || priorOp !== "directory" && transformed.type === "directory"))
+                throw new Error(`Path conflict ${transformed.type} over existing ${priorOp} at "${transformed.name}"`);
+              try {
+                let destDir = await destDirPromise;
+                if (maxDepth !== 1 / 0 && name.split("/").length > maxDepth) throw new Error("Tar exceeds max specified depth.");
+                let outPath = path.join(destDir.symbolic, name);
+                validateBounds(outPath, destDir.symbolic, `Entry "${transformed.name}" points outside the extraction directory.`);
+                let parentDir = path.dirname(outPath);
+                switch (await ensureDirectoryExists(parentDir), transformed.type) {
+                  case "directory":
+                    await fs.mkdir(outPath, {
+                      recursive: !0,
+                      mode: dmode ?? transformed.mode
+                    });
+                    break;
+                  case "file": {
+                    let fileStream = createWriteStream(outPath, {
+                      mode: fmode ?? transformed.mode,
+                      highWaterMark: transformed.size > 1048576 ? 524288 : void 0
+                    });
+                    await pipeline(entryStream, fileStream);
+                    break;
+                  }
+                  case "symlink": {
+                    let { linkname } = transformed;
+                    if (!linkname) return transformed.type;
+                    let target$1 = path.resolve(parentDir, linkname);
+                    validateBounds(target$1, destDir.symbolic, `Symlink "${linkname}" points outside the extraction directory.`), await fs.symlink(linkname, outPath);
+                    break;
+                  }
+                  case "link": {
+                    let { linkname } = transformed;
+                    if (!linkname) return transformed.type;
+                    let normalizedLink = normalizeUnicode(linkname);
+                    if (path.isAbsolute(normalizedLink)) throw new Error(`Hardlink "${linkname}" points outside the extraction directory.`);
+                    let linkTarget = path.join(destDir.symbolic, normalizedLink);
+                    validateBounds(linkTarget, destDir.symbolic, `Hardlink "${linkname}" points outside the extraction directory.`), await ensureDirectoryExists(path.dirname(linkTarget));
+                    let realTargetParent = await fs.realpath(path.dirname(linkTarget)), realLinkTarget = path.join(realTargetParent, path.basename(linkTarget));
+                    if (validateBounds(realLinkTarget, destDir.real, `Hardlink "${linkname}" points outside the extraction directory.`), linkTarget === outPath) return transformed.type;
+                    let targetPromise = pathPromises.get(linkTarget);
+                    targetPromise && await targetPromise, await fs.link(linkTarget, outPath);
+                    break;
+                  }
+                  default:
+                    return transformed.type;
+                }
+                return transformed.mtime && await (transformed.type === "symlink" ? fs.lutimes : fs.utimes)(outPath, transformed.mtime, transformed.mtime).catch(() => {
+                }), transformed.type;
+              } finally {
+                entryStream.readableEnded || entryStream.resume();
+              }
+            }), pathPromises.set(target, opPromise);
+          } catch (err) {
+            opPromise = Promise.reject(err), abortController.abort(err);
+          }
+          opPromise.catch((err) => abortController.abort(err)).finally(() => {
+            activeOps--, processQueue();
+          });
+        };
+        opQueue.push(startOperation), processQueue();
+      },
+      onData(chunk) {
+        signal.aborted || activeEntryStream?.write(chunk);
+      },
+      onEndEntry() {
+        activeEntryStream?.end(), activeEntryStream = null;
+      },
+      onError(error) {
+        abortController.abort(error);
+      },
+      async process() {
+        if (processingEnded = !0, processQueue(), await drainPromise, signal.aborted) throw signal.reason;
+      }
+    },
+    signal
+  };
+}
+
+// src/cli/dirs.ts
+var externalFrameworks = [
+  { name: SupportedFramework.QWIK, packageName: "storybook-framework-qwik" },
+  {
+    name: SupportedFramework.SOLID,
+    packageName: "storybook-solidjs-vite",
+    frameworks: ["storybook-solidjs-vite"],
+    renderer: "storybook-solidjs-vite"
+  },
+  {
+    name: SupportedFramework.NUXT,
+    packageName: "@storybook-vue/nuxt",
+    frameworks: ["@storybook-vue/nuxt"],
+    renderer: "@storybook/vue3"
+  }
+], resolveUsingBranchInstall = async (packageManager, request) => {
+  let tempDirectory = await temporaryDirectory(), version = versions[request] || await packageManager.latestVersion(request), url = (src_default.default || src_default)(request, version, {
+    registry: await packageManager.getRegistryURL()
+  }), response = await fetch(url);
+  if (!response.ok || !response.body)
+    throw new Error(`Failed to download tarball from ${url}`);
+  return await pipeline2(
+    Readable2.fromWeb(response.body),
+    createGunzip(),
+    unpackTar(tempDirectory)
+  ), join2(tempDirectory, "package");
+};
+async function getRendererDir(packageManager, renderer) {
+  let externalFramework = externalFrameworks.find((framework) => framework.name === renderer), frameworkPackageName = externalFramework?.packageName || externalFramework?.renderer || `@storybook/${renderer}`, packageJsonPath = join2(frameworkPackageName, "package.json"), errors = [];
+  try {
+    return resolvePackageDir(frameworkPackageName, process.cwd());
+  } catch (e) {
+    invariant(e instanceof Error), errors.push(e);
+  }
+  try {
+    return await resolveUsingBranchInstall(packageManager, frameworkPackageName);
+  } catch (e) {
+    invariant(e instanceof Error), errors.push(e);
+  }
+  throw new Error(`Cannot find ${packageJsonPath}, ${errors.map((e) => e.stack).join(`
+
+`)}`);
+}
+
+// src/cli/helpers.ts
+function readFileAsJson(jsonPath, allowComments) {
+  let filePath = resolve2(jsonPath);
+  if (!existsSync(filePath))
+    return !1;
+  let fileContent = readFileSync(filePath, "utf8"), jsonContent = allowComments ? stripJsonComments(fileContent) : fileContent;
+  try {
+    return JSON.parse(jsonContent);
+  } catch (e) {
+    throw logger.error(import_picocolors.default.red(`Invalid json in file: ${filePath}`)), e;
+  }
+}
+var writeFileAsJson = (jsonPath, content) => {
+  let filePath = resolve2(jsonPath);
+  return existsSync(filePath) ? (writeFileSync(filePath, `${JSON.stringify(content, null, 2)}
+`), !0) : !1;
+};
+async function getBabelDependencies(packageManager) {
+  let dependenciesToAdd = [], babelLoaderVersion = "^8.0.0-0", babelCoreVersion = packageManager.getDependencyVersion("babel-core");
+  if (babelCoreVersion) {
+    let latestCompatibleBabelVersion = await packageManager.latestVersion(
+      "babel-core",
+      babelCoreVersion
+    );
+    latestCompatibleBabelVersion && satisfies(latestCompatibleBabelVersion, "^6.0.0") && (babelLoaderVersion = "^7.0.0");
+  } else if (!packageManager.getDependencyVersion("@babel/core")) {
+    let babelCoreInstallVersion = await packageManager.getVersion("@babel/core");
+    dependenciesToAdd.push(`@babel/core@${babelCoreInstallVersion}`);
+  }
+  if (!packageManager.getDependencyVersion("babel-loader")) {
+    let babelLoaderInstallVersion = await packageManager.getVersion(
+      "babel-loader",
+      babelLoaderVersion
+    );
+    dependenciesToAdd.push(`babel-loader@${babelLoaderInstallVersion}`);
+  }
+  return dependenciesToAdd;
+}
+function addToDevDependenciesIfNotPresent(packageJson, name, packageVersion) {
+  !packageJson.dependencies?.[name] && !packageJson.devDependencies?.[name] && (packageJson.devDependencies ? packageJson.devDependencies[name] = packageVersion : packageJson.devDependencies = {
+    [name]: packageVersion
   });
-  return useCompoDoc;
-}, AngularJSON = class {
+}
+function copyTemplate(templateRoot, destination = ".") {
+  let templateDir = resolve2(templateRoot, "template-csf/");
+  if (!existsSync(templateDir))
+    throw new Error("Couldn't find template dir");
+  cpSync(templateDir, destination, { recursive: !0 });
+}
+async function getVersionSafe(packageManager, packageName) {
+  try {
+    let version = await packageManager.getInstalledVersion(packageName);
+    return version || (version = packageManager.getAllDependencies()[packageName] ?? ""), coerce(version, { includePrerelease: !0 })?.toString();
+  } catch {
+  }
+}
+var cliStoriesTargetPath = async () => existsSync("./src") ? "./src/stories" : "./stories";
+async function copyTemplateFiles({
+  packageManager,
+  templateLocation,
+  language,
+  destination,
+  commonAssetsDir,
+  features
+}) {
+  let languageFolderMapping = {
+    [SupportedLanguage.JAVASCRIPT]: "js",
+    [SupportedLanguage.TYPESCRIPT]: "ts"
+  }, templatePath = async () => {
+    let baseDir = await getRendererDir(packageManager, templateLocation), assetsDir = join3(baseDir, "template", "cli"), assetsLanguage = join3(assetsDir, languageFolderMapping[language]), assetsJS = join3(assetsDir, languageFolderMapping[SupportedLanguage.JAVASCRIPT]), assetsTS = join3(assetsDir, languageFolderMapping.typescript);
+    if (existsSync(assetsLanguage))
+      return assetsLanguage;
+    if (existsSync(assetsTS))
+      return assetsTS;
+    if (existsSync(assetsJS))
+      return assetsJS;
+    if (existsSync(assetsDir))
+      return assetsDir;
+    throw new Error(`Unsupported renderer: ${templateLocation} (${baseDir})`);
+  }, destinationPath = destination ?? await cliStoriesTargetPath(), filter = (file) => features.has(Feature.DOCS) || !file.endsWith(".mdx");
+  if (commonAssetsDir && await cp(commonAssetsDir, destinationPath, { recursive: !0, filter }), await cp(await templatePath(), destinationPath, { recursive: !0, filter }), commonAssetsDir && features.has(Feature.DOCS)) {
+    let rendererType = frameworkToRenderer[templateLocation] || "react";
+    await adjustTemplate(join3(destinationPath, "Configure.mdx"), { renderer: rendererType });
+  }
+}
+async function adjustTemplate(templatePath, templateData) {
+  let template = await readFile2(templatePath, { encoding: "utf8" });
+  Object.keys(templateData).forEach((key) => {
+    template = template.replaceAll(`{{${key}}}`, `${templateData[key]}`);
+  }), await writeFile(templatePath, template);
+}
+function coerceSemver(version) {
+  let coercedSemver = coerce(version);
+  return invariant(coercedSemver != null, `Could not coerce ${version} into a semver.`), coercedSemver;
+}
+function hasStorybookDependencies(packageManager) {
+  let currentPackageDeps = packageManager.getAllDependencies();
+  return Object.keys(currentPackageDeps).some((dep) => dep.includes("storybook"));
+}
+
+// src/cli/angular/helpers.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { prompt } from "storybook/internal/node-logger";
+import { MissingAngularJsonError } from "storybook/internal/server-errors";
+var ANGULAR_JSON_PATH = "angular.json", AngularJSON = class {
   constructor() {
-    if (!existsSync(ANGULAR_JSON_PATH))
-      throw new MissingAngularJsonError({ path: join(process.cwd(), ANGULAR_JSON_PATH) });
-    let jsonContent = readFileSync(ANGULAR_JSON_PATH, "utf8");
+    if (!existsSync2(ANGULAR_JSON_PATH))
+      throw new MissingAngularJsonError({ path: join4(process.cwd(), ANGULAR_JSON_PATH) });
+    let jsonContent = readFileSync2(ANGULAR_JSON_PATH, "utf8");
     this.json = JSON.parse(jsonContent);
   }
   get projects() {
@@ -4912,19 +5566,13 @@ var import_prompts = __toESM(require_prompts(), 1), import_ts_dedent = __toESM(r
     return this.projects[projectName];
   }
   async getProjectName() {
-    if (this.projectsWithoutStorybook.length > 1) {
-      let { projectName } = await (0, import_prompts.default)({
-        type: "select",
-        name: "projectName",
-        message: "For which project do you want to generate Storybook configuration?",
-        choices: this.projectsWithoutStorybook.map((name) => ({
-          title: name,
-          value: name
-        }))
-      });
-      return projectName;
-    }
-    return this.projectsWithoutStorybook[0];
+    return this.projectsWithoutStorybook.length > 1 ? prompt.select({
+      message: "For which project do you want to generate Storybook configuration?",
+      options: this.projectsWithoutStorybook.map((name) => ({
+        label: name,
+        value: name
+      }))
+    }) : this.projectsWithoutStorybook[0];
   }
   addStorybookEntries({
     angularProjectName,
@@ -4953,16 +5601,19 @@ var import_prompts = __toESM(require_prompts(), 1), import_ts_dedent = __toESM(r
     });
   }
   write() {
-    writeFileSync(ANGULAR_JSON_PATH, JSON.stringify(this.json, null, 2));
+    writeFileSync2(ANGULAR_JSON_PATH, JSON.stringify(this.json, null, 2));
   }
 };
 
+// src/cli/projectTypes.ts
+var ProjectType = /* @__PURE__ */ ((ProjectType2) => (ProjectType2.ANGULAR = "angular", ProjectType2.EMBER = "ember", ProjectType2.HTML = "html", ProjectType2.NEXTJS = "nextjs", ProjectType2.NUXT = "nuxt", ProjectType2.NX = "nx", ProjectType2.PREACT = "preact", ProjectType2.QWIK = "qwik", ProjectType2.REACT = "react", ProjectType2.REACT_NATIVE = "react_native", ProjectType2.REACT_NATIVE_AND_RNW = "react_native_and_rnw", ProjectType2.REACT_NATIVE_WEB = "react_native_web", ProjectType2.REACT_PROJECT = "react_project", ProjectType2.REACT_SCRIPTS = "react_scripts", ProjectType2.SERVER = "server", ProjectType2.SOLID = "solid", ProjectType2.SVELTE = "svelte", ProjectType2.SVELTEKIT = "sveltekit", ProjectType2.UNDETECTED = "undetected", ProjectType2.UNSUPPORTED = "unsupported", ProjectType2.VUE3 = "vue3", ProjectType2.WEB_COMPONENTS = "web_components", ProjectType2))(ProjectType || {});
+
 // src/cli/eslintPlugin.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { getProjectRoot } from "storybook/internal/common";
 import { readConfig, writeConfig } from "storybook/internal/csf-tools";
-import { logger as logger2, prompt } from "storybook/internal/node-logger";
+import { logger as logger2, prompt as prompt2 } from "storybook/internal/node-logger";
 
 // ../node_modules/detect-indent/index.js
 var INDENT_REGEX = /^(?:( )+|\t+)/, INDENT_TYPE_SPACE = "space";
@@ -5027,7 +5678,7 @@ function detectIndent(string) {
 }
 
 // src/cli/eslintPlugin.ts
-var import_picocolors = __toESM(require_picocolors(), 1), import_ts_dedent2 = __toESM(require_dist(), 1);
+var import_picocolors2 = __toESM(require_picocolors(), 1), import_ts_dedent = __toESM(require_dist(), 1);
 var SUPPORTED_ESLINT_EXTENSIONS = ["ts", "mts", "cts", "mjs", "js", "cjs", "json"], UNSUPPORTED_ESLINT_EXTENSIONS = ["yaml", "yml"], findEslintFile = (instanceDir) => {
   let filePrefixes = ["eslint.config", ".eslintrc"];
   for (let prefix of filePrefixes)
@@ -5047,14 +5698,14 @@ function unwrapTSExpression(expr) {
 var configureFlatConfig = async (code) => {
   let ast = babelParse(code), tsEslintLocalName = "", eslintConfigExpression = null;
   return traverse(ast, {
-    ImportDeclaration(path) {
-      if (path.node.source.value === "typescript-eslint") {
-        let defaultSpecifier = path.node.specifiers.find((s) => types.isImportDefaultSpecifier(s));
+    ImportDeclaration(path2) {
+      if (path2.node.source.value === "typescript-eslint") {
+        let defaultSpecifier = path2.node.specifiers.find((s) => types.isImportDefaultSpecifier(s));
         defaultSpecifier && (tsEslintLocalName = defaultSpecifier.local.name);
       }
     },
-    ExportDefaultDeclaration(path) {
-      let node = path.node;
+    ExportDefaultDeclaration(path2) {
+      let node = path2.node;
       eslintConfigExpression = unwrapTSExpression(node.declaration);
       let storybookConfig = types.memberExpression(
         types.memberExpression(types.identifier("storybook"), types.identifier("configs")),
@@ -5062,15 +5713,15 @@ var configureFlatConfig = async (code) => {
         !0
       );
       if (types.isArrayExpression(eslintConfigExpression) && eslintConfigExpression.elements.push(types.spreadElement(storybookConfig)), types.isCallExpression(eslintConfigExpression) && types.isMemberExpression(eslintConfigExpression.callee) && tsEslintLocalName && types.isIdentifier(eslintConfigExpression.callee.object, { name: tsEslintLocalName }) && types.isIdentifier(eslintConfigExpression.callee.property, { name: "config" }) && eslintConfigExpression.arguments.push(storybookConfig), types.isIdentifier(eslintConfigExpression)) {
-        let binding = path.scope.getBinding(eslintConfigExpression.name);
+        let binding = path2.scope.getBinding(eslintConfigExpression.name);
         if (binding && types.isVariableDeclarator(binding.path.node)) {
           let init = unwrapTSExpression(binding.path.node.init);
           types.isArrayExpression(init) && init.elements.push(types.spreadElement(storybookConfig));
         }
       }
     },
-    Program(path) {
-      if (!path.node.body.some(
+    Program(path2) {
+      if (!path2.node.body.some(
         (node) => types.isImportDeclaration(node) && node.source.value === "eslint-plugin-storybook"
       )) {
         let importDecl = types.importDeclaration(
@@ -5082,7 +5733,7 @@ var configureFlatConfig = async (code) => {
             type: "CommentLine",
             value: " For more info, see https://github.com/storybookjs/eslint-plugin-storybook#configuration-flat-config-format"
           }
-        ], path.node.body.unshift(importDecl);
+        ], path2.node.body.unshift(importDecl);
       }
     }
   }), recast.print(ast).code;
@@ -5123,16 +5774,16 @@ async function configureEslintPlugin({
   if (eslintConfigFile)
     if (eslintConfigFile.endsWith("json")) {
       logger2.debug(`Detected JSON config at ${eslintConfigFile}`);
-      let eslintFileContents = await readFile(eslintConfigFile, { encoding: "utf8" }), eslintConfig = import_comment_json.default.parse(eslintFileContents);
+      let eslintFileContents = await readFile3(eslintConfigFile, { encoding: "utf8" }), eslintConfig = import_comment_json.default.parse(eslintFileContents);
       if (normalizeExtends(eslintConfig.extends).filter(Boolean).includes("plugin:storybook/recommended"))
         return;
       Array.isArray(eslintConfig.extends) || (eslintConfig.extends = eslintConfig.extends ? [eslintConfig.extends] : []), eslintConfig.extends.push("plugin:storybook/recommended");
       let spaces = detectIndent(eslintFileContents).amount || 2;
-      await writeFile(eslintConfigFile, import_comment_json.default.stringify(eslintConfig, null, spaces));
+      await writeFile2(eslintConfigFile, import_comment_json.default.stringify(eslintConfig, null, spaces));
     } else if (isFlatConfig) {
       logger2.debug(`Detected flat config at ${eslintConfigFile}`);
-      let code = await readFile(eslintConfigFile, { encoding: "utf8" }), output = await configureFlatConfig(code);
-      await writeFile(eslintConfigFile, output);
+      let code = await readFile3(eslintConfigFile, { encoding: "utf8" }), output = await configureFlatConfig(code);
+      await writeFile2(eslintConfigFile, output);
     } else {
       let eslint = await readConfig(eslintConfigFile), existingExtends = normalizeExtends(eslint.getFieldValue(["extends"])).filter(Boolean);
       if (existingExtends.includes("plugin:storybook/recommended"))
@@ -5151,9 +5802,9 @@ async function configureEslintPlugin({
     });
   }
 }
-var suggestESLintPlugin = async () => await prompt.confirm({
-  message: import_ts_dedent2.dedent`
-        We have detected that you're using ESLint. Storybook provides a plugin that gives the best experience with Storybook and helps follow best practices: ${import_picocolors.default.yellow(
+var suggestESLintPlugin = async () => await prompt2.confirm({
+  message: import_ts_dedent.dedent`
+        We have detected that you're using ESLint. Storybook provides a plugin that gives the best experience with Storybook and helps follow best practices: ${import_picocolors2.default.yellow(
     "https://storybook.js.org/docs/9/configure/integration/eslint-plugin"
   )}
 
@@ -5161,51 +5812,228 @@ var suggestESLintPlugin = async () => await prompt.confirm({
       `,
   initialValue: !0
 });
+
+// src/cli/AddonVitestService.ts
+import fs2 from "node:fs/promises";
+import * as babel from "storybook/internal/babel";
+import { getProjectRoot as getProjectRoot2 } from "storybook/internal/common";
+import { CLI_COLORS } from "storybook/internal/node-logger";
+import { logger as logger3, prompt as prompt3 } from "storybook/internal/node-logger";
+import { ErrorCollector } from "storybook/internal/telemetry";
+var import_ts_dedent2 = __toESM(require_dist(), 1);
+import { coerce as coerce2, satisfies as satisfies2 } from "semver";
+var AddonVitestService = class {
+  constructor() {
+    this.supportedFrameworks = [
+      "html-vite" /* HTML_VITE */,
+      "nextjs-vite" /* NEXTJS_VITE */,
+      "preact-vite" /* PREACT_VITE */,
+      "react-native-web-vite" /* REACT_NATIVE_WEB_VITE */,
+      "react-vite" /* REACT_VITE */,
+      "svelte-vite" /* SVELTE_VITE */,
+      "sveltekit" /* SVELTEKIT */,
+      "vue3-vite" /* VUE3_VITE */,
+      "web-components-vite" /* WEB_COMPONENTS_VITE */
+    ];
+  }
+  /**
+   * Collect all dependencies needed for @storybook/addon-vitest
+   *
+   * Returns versioned package strings ready for installation:
+   *
+   * - Base packages: vitest, @vitest/browser, playwright
+   * - Next.js specific: @storybook/nextjs-vite
+   * - Coverage reporter: @vitest/coverage-v8
+   */
+  async collectDependencies(packageManager) {
+    let allDeps = packageManager.getAllDependencies(), dependencies = [], vitestVersionSpecifier = await packageManager.getInstalledVersion("vitest"), basePackages = [
+      "vitest",
+      "playwright",
+      (vitestVersionSpecifier ? satisfies2(vitestVersionSpecifier, ">=4.0.0") : !0) ? "@vitest/browser-playwright" : "@vitest/browser"
+    ];
+    for (let pkg of basePackages)
+      allDeps[pkg] || dependencies.push(pkg);
+    let v8Version = await packageManager.getInstalledVersion("@vitest/coverage-v8"), istanbulVersion = await packageManager.getInstalledVersion("@vitest/coverage-istanbul");
+    return !v8Version && !istanbulVersion && dependencies.push("@vitest/coverage-v8"), dependencies.map((pkg) => pkg.includes("vitest") && vitestVersionSpecifier ? `${pkg}@${vitestVersionSpecifier}` : pkg);
+  }
+  /**
+   * Install Playwright browser binaries for @storybook/addon-vitest
+   *
+   * Installs Chromium with dependencies via `npx playwright install chromium --with-deps`
+   *
+   * @param packageManager - The package manager to use for installation
+   * @param prompt - The prompt instance for displaying progress
+   * @param logger - The logger instance for displaying messages
+   * @param options - Installation options
+   * @returns Array of error messages if installation fails
+   */
+  async installPlaywright(packageManager, options = {}) {
+    let errors = [], playwrightCommand = ["playwright", "install", "chromium", "--with-deps"];
+    try {
+      (options.yes ? !0 : await (async () => (logger3.log(import_ts_dedent2.dedent`
+            Playwright browser binaries are necessary for @storybook/addon-vitest. The download can take some time. If you don't want to wait, you can skip the installation and run the following command manually later:
+            ${CLI_COLORS.cta(`npx ${playwrightCommand.join(" ")}`)}
+            `), prompt3.confirm({
+        message: "Do you want to install Playwright with Chromium now?",
+        initialValue: !0
+      })))()) ? await prompt3.executeTaskWithSpinner(
+        (signal) => packageManager.runPackageCommand({
+          args: playwrightCommand,
+          stdio: ["inherit", "pipe", "pipe"],
+          signal
+        }),
+        {
+          id: "playwright-installation",
+          intro: 'Installing Playwright browser binaries (Press "c" to abort)',
+          error: `An error occurred while installing Playwright browser binaries. Please run the following command later: npx ${playwrightCommand.join(" ")}`,
+          success: "Playwright browser binaries installed successfully",
+          abortable: !0
+        }
+      ) : logger3.warn("Playwright installation skipped");
+    } catch (e) {
+      ErrorCollector.addError(e), e instanceof Error ? errors.push(e.stack ?? e.message) : errors.push(String(e));
+    }
+    return { errors };
+  }
+  /**
+   * Validate full compatibility for @storybook/addon-vitest
+   *
+   * Checks:
+   *
+   * - Webpack configuration compatibility
+   * - Builder compatibility (Vite or Next.js)
+   * - Renderer/framework support
+   * - Vitest version (>=3.0.0)
+   * - MSW version (>=2.0.0 if installed)
+   * - Next.js installation (if using @storybook/nextjs)
+   * - Vitest config files (if configDir provided)
+   */
+  async validateCompatibility(options) {
+    let reasons = [];
+    options.builder !== "vite" /* VITE */ && reasons.push("Non-Vite builder is not supported"), this.supportedFrameworks.some(
+      (framework) => options.framework === framework
+    ) || reasons.push(`Test feature cannot yet be used with ${options.framework}`);
+    let packageVersionResult = await this.validatePackageVersions(options.packageManager);
+    if (!packageVersionResult.compatible && packageVersionResult.reasons && reasons.push(...packageVersionResult.reasons), options.projectRoot) {
+      let configResult = await this.validateConfigFiles(options.projectRoot);
+      !configResult.compatible && configResult.reasons && reasons.push(...configResult.reasons);
+    }
+    return reasons.length > 0 ? { compatible: !1, reasons } : { compatible: !0 };
+  }
+  /**
+   * Validate package versions for addon-vitest compatibility Public method to allow early
+   * validation before framework detection
+   */
+  async validatePackageVersions(packageManager) {
+    let reasons = [], vitestVersionSpecifier = await packageManager.getInstalledVersion("vitest"), coercedVitestVersion = vitestVersionSpecifier ? coerce2(vitestVersionSpecifier) : null;
+    coercedVitestVersion && !satisfies2(coercedVitestVersion, ">=3.0.0") && reasons.push(
+      `The addon requires Vitest 3.0.0 or higher. You are currently using ${vitestVersionSpecifier}.`
+    );
+    let mswVersionSpecifier = await packageManager.getInstalledVersion("msw"), coercedMswVersion = mswVersionSpecifier ? coerce2(mswVersionSpecifier) : null;
+    return coercedMswVersion && !satisfies2(coercedMswVersion, ">=2.0.0") && reasons.push(
+      `The addon uses Vitest behind the scenes, which supports only version 2 and above of MSW. However, we have detected version ${coercedMswVersion.version} in this project.`
+    ), reasons.length > 0 ? { compatible: !1, reasons } : { compatible: !0 };
+  }
+  /**
+   * Validate vitest config files for addon compatibility
+   *
+   * Public method that can be used by both postinstall and create-storybook flows
+   */
+  async validateConfigFiles(directory) {
+    let reasons = [], projectRoot = getProjectRoot2(), vitestWorkspaceFile = any(
+      ["ts", "js", "json"].flatMap((ex) => [`vitest.workspace.${ex}`, `vitest.projects.${ex}`]),
+      { cwd: directory, last: projectRoot }
+    );
+    if (vitestWorkspaceFile?.endsWith(".json"))
+      reasons.push(`Cannot auto-update JSON workspace file: ${vitestWorkspaceFile}`);
+    else if (vitestWorkspaceFile) {
+      let fileContents = await fs2.readFile(vitestWorkspaceFile, "utf8");
+      this.isValidWorkspaceConfigFile(fileContents) || reasons.push(`Found an invalid workspace config file: ${vitestWorkspaceFile}`);
+    }
+    let vitestConfigFile = any(
+      ["ts", "js", "tsx", "jsx", "cts", "cjs", "mts", "mjs"].map((ex) => `vitest.config.${ex}`),
+      { cwd: directory, last: projectRoot }
+    );
+    if (vitestConfigFile?.endsWith(".cts") || vitestConfigFile?.endsWith(".cjs"))
+      reasons.push(`Cannot auto-update CommonJS config file: ${vitestConfigFile}`);
+    else if (vitestConfigFile) {
+      let configContent = await fs2.readFile(vitestConfigFile, "utf8");
+      this.isValidVitestConfig(configContent) || reasons.push(`Found an invalid Vitest config file: ${vitestConfigFile}`);
+    }
+    return reasons.length > 0 ? { compatible: !1, reasons } : { compatible: !0 };
+  }
+  // Private helper methods for Vitest config validation
+  /** Validate workspace config file structure */
+  isValidWorkspaceConfigFile(fileContents) {
+    let isValid = !1, parsedFile = babel.babelParse(fileContents);
+    return babel.traverse(parsedFile, {
+      ExportDefaultDeclaration: (path2) => {
+        let declaration = path2.node.declaration;
+        isValid = this.isWorkspaceConfigArray(declaration) || this.isDefineWorkspaceExpression(declaration);
+      }
+    }), isValid;
+  }
+  /** Validate Vitest config file structure */
+  isValidVitestConfig(configContent) {
+    let parsedConfig = babel.babelParse(configContent), isValidVitestConfig = !1;
+    return babel.traverse(parsedConfig, {
+      ExportDefaultDeclaration: (path2) => {
+        this.isDefineConfigExpression(path2.node.declaration) ? isValidVitestConfig = this.isSafeToExtendWorkspace(
+          path2.node.declaration
+        ) : this.isMergeConfigExpression(path2.node.declaration) && (isValidVitestConfig = path2.node.declaration.arguments.some(
+          (arg) => this.isSafeToExtendWorkspace(arg)
+        ));
+      }
+    }), isValidVitestConfig;
+  }
+  isWorkspaceConfigArray(node) {
+    return babel.types.isArrayExpression(node) && node?.elements.every(
+      (el) => babel.types.isStringLiteral(el) || babel.types.isObjectExpression(el)
+    );
+  }
+  isDefineWorkspaceExpression(node) {
+    return babel.types.isCallExpression(node) && node.callee && node.callee?.name === "defineWorkspace" && this.isWorkspaceConfigArray(node.arguments?.[0]);
+  }
+  isDefineConfigExpression(node) {
+    return babel.types.isCallExpression(node) && node.callee?.name === "defineConfig" && babel.types.isObjectExpression(node.arguments?.[0]);
+  }
+  isMergeConfigExpression(path2) {
+    return babel.types.isCallExpression(path2) && path2.callee?.name === "mergeConfig";
+  }
+  isSafeToExtendWorkspace(node) {
+    return babel.types.isCallExpression(node) && node.arguments.length > 0 && babel.types.isObjectExpression(node.arguments?.[0]) && node.arguments[0]?.properties.every(
+      (p) => p.key?.name !== "test" || babel.types.isObjectExpression(p.value) && p.value.properties.every(
+        ({ key, value }) => key?.name !== "workspace" || babel.types.isArrayExpression(value)
+      )
+    );
+  }
+};
 export {
   ANGULAR_JSON_PATH,
+  AddonVitestService,
   AngularJSON,
-  CommunityBuilder,
-  CoreBuilder,
-  CoreWebpackCompilers,
   ProjectType,
   SUPPORTED_ESLINT_EXTENSIONS,
-  SUPPORTED_RENDERERS,
   Settings,
-  SupportedLanguage,
   _clearGlobalSettings,
   addToDevDependenciesIfNotPresent,
   adjustTemplate,
-  builderNameToCoreBuilder,
   cliStoriesTargetPath,
   coerceSemver,
-  compilerNameToCoreCompiler,
-  compoDocPreviewPrefix,
   configureEslintPlugin,
   configureFlatConfig,
   copyTemplate,
   copyTemplateFiles,
-  detect,
-  detectBuilder,
-  detectFrameworkPreset,
-  detectLanguage,
   detectPnp,
-  externalFrameworks,
   extractEslintInfo,
   findEslintFile,
-  frameworkToDefaultBuilder,
   getBabelDependencies,
   getRendererDir,
   getVersionSafe,
   globalSettings,
   hasStorybookDependencies,
-  installableProjectTypes,
-  isNxProject,
-  isStorybookInstantiated,
   normalizeExtends,
-  promptForCompoDocs,
   readFileAsJson,
   suggestESLintPlugin,
-  supportedTemplates,
-  unsupportedTemplate,
   writeFileAsJson
 };