@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,2187 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  getAiSetupRunId
+} from "../../_node-chunks/chunk-NPO45IMH.js";
+import {
+  REVIEW_EVENTS
+} from "../../_node-chunks/chunk-TINO74G5.js";
+import {
+  GitDiffProvider,
+  applyServicesPresetOnce,
+  createCompositionDocsSources,
+  createDocsToolset,
+  createLocalDocsAccess,
+  createStoriesToolset,
+  defineService,
+  docgenQueryStaticPath,
+  fullTestProviderStore,
+  getChangeDetectionReadiness,
+  getComponentCandidates,
+  getPreviewBuilder,
+  getRefsFromConfig,
+  getSyncedStatuses,
+  getWsToken,
+  loadManifests,
+  mapStaticDir,
+  parseStaticDir,
+  prependImportToSnippet,
+  registerModuleGraphService,
+  reviewToolset,
+  runStoryTests,
+  sendTelemetryError,
+  sourceUrlManifestProvider,
+  storyDocsQueryStaticPath
+} from "../../_node-chunks/chunk-E6YESGLX.js";
+import "../../_node-chunks/chunk-OISX4AGQ.js";
+import "../../_node-chunks/chunk-XGIUVY52.js";
+import "../../_node-chunks/chunk-TFCEV2XX.js";
+import "../../_node-chunks/chunk-Q7QNUM5H.js";
+import {
+  registerToolset
+} from "../../_node-chunks/chunk-3Y6AAY5H.js";
+import "../../_node-chunks/chunk-BSKFCWQD.js";
+import "../../_node-chunks/chunk-ICPBH3E7.js";
+import "../../_node-chunks/chunk-EWOX7HPJ.js";
+import {
+  getComponentIdFromEntry,
+  getStoryImportPathFromEntry,
+  isEligibleStoryEntry,
+  selectComponentEntriesByComponentId
+} from "../../_node-chunks/chunk-MK2KYAI6.js";
+import "../../_node-chunks/chunk-IDEL2J23.js";
+import "../../_node-chunks/chunk-BXVYT7SB.js";
+import {
+  getService,
+  registerService
+} from "../../_node-chunks/chunk-SLWQNBGO.js";
+import "../../_node-chunks/chunk-4FEANXWU.js";
+import "../../_node-chunks/chunk-TEQGGSP7.js";
+import "../../_node-chunks/chunk-OWNFOGTA.js";
+import "../../_node-chunks/chunk-HMP2G23X.js";
+import "../../_node-chunks/chunk-3W7F2B7P.js";
+import "../../_node-chunks/chunk-OUW6R7C3.js";
+import "../../_node-chunks/chunk-SVTBJ7Q3.js";
+import "../../_node-chunks/chunk-WNZ2UMFM.js";
+import "../../_node-chunks/chunk-RRN2V55B.js";
+import "../../_node-chunks/chunk-JDXXX6LB.js";
+import {
+  invariant
+} from "../../_node-chunks/chunk-34EO2PUT.js";
+import {
+  importMetaResolve,
+  resolvePackageDir
+} from "../../_node-chunks/chunk-F3ZFKBHY.js";
+import "../../_node-chunks/chunk-TNJIXE37.js";
+import {
+  OpenServiceDocgenMissingComponentError,
+  OpenServiceServicesAppliedTwiceError,
+  OpenServiceUnknownStoryIdsError
+} from "../../_node-chunks/chunk-U5W53R2J.js";
+import {
+  require_picocolors
+} from "../../_node-chunks/chunk-2BUPBPFB.js";
+import {
+  toStoryIndexPath
+} from "../../_node-chunks/chunk-XLP2ZKXV.js";
+import "../../_node-chunks/chunk-FW2HQUBQ.js";
+import "../../_node-chunks/chunk-ZMAMXQKP.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "../../_node-chunks/chunk-CXRU72ET.js";
+
+// ../../node_modules/shell-quote/quote.js
+var require_quote = __commonJS({
+  "../../node_modules/shell-quote/quote.js"(exports, module) {
+    "use strict";
+    var OPS = (
+      /** @type {const} */
+      [
+        "||",
+        "&&",
+        ";;&",
+        ";;",
+        ";&",
+        "|&",
+        "<(",
+        ">(",
+        "<<<",
+        "<<-",
+        "<<",
+        ">>",
+        ">&",
+        ">|",
+        "&>>",
+        "&>",
+        "<&",
+        "<>",
+        "&",
+        ";",
+        "(",
+        ")",
+        "|",
+        "<",
+        ">"
+      ]
+    ), LINE_TERMINATORS = /[\n\r\u2028\u2029]/, GLOB_SHELL_SPECIAL = /[\s#!"$&'():;<=>@\\^`|~]/g;
+    module.exports = function(xs) {
+      var sawComment = !1;
+      return xs.map(function(s) {
+        if (sawComment && typeof s == "string" && LINE_TERMINATORS.test(s))
+          throw new TypeError("a token after a `comment` must not contain line terminators");
+        if (s === "")
+          return (
+            /** @type {const} */
+            "''"
+          );
+        if (s && typeof s == "object") {
+          if ("op" in s && s.op === "glob") {
+            if (typeof s.pattern != "string")
+              throw new TypeError("glob token requires a string `pattern`");
+            if (LINE_TERMINATORS.test(s.pattern))
+              throw new TypeError("glob `pattern` must not contain line terminators");
+            return s.pattern === "" ? (
+              /** @type {const} */
+              "''"
+            ) : s.pattern.replace(GLOB_SHELL_SPECIAL, "\\$&");
+          }
+          if ("op" in s && typeof s.op == "string") {
+            if (OPS.indexOf(s.op) < 0)
+              throw new TypeError("invalid `op` value: " + JSON.stringify(s.op));
+            return s.op.replace(/[\s\S]/g, "\\$&");
+          }
+          if ("comment" in s && typeof s.comment == "string") {
+            if (LINE_TERMINATORS.test(s.comment))
+              throw new TypeError("`comment` must not contain line terminators");
+            return sawComment = !0, "#" + s.comment;
+          }
+          throw new TypeError("unrecognized object token shape");
+        }
+        return /'/.test(s) && /!/.test(s) ? "'" + s.replace(/'/g, `'"'"'`) + "'" : /["\s\\]/.test(s) && !/'/.test(s) ? "'" + s + "'" : /["'\s]/.test(s) ? '"' + s.replace(/(["\\$`])/g, "\\$1") + '"' : String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}~])/g, "$1\\$2");
+      }).join(" ");
+    };
+  }
+});
+
+// ../../node_modules/shell-quote/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/shell-quote/parse.js"(exports, module) {
+    "use strict";
+    var CONTROL = (
+      /** @type {const} */
+      "(?:" + /** @type {const} */
+      [
+        "\\|\\|",
+        "\\&(?:\\&|>>?)",
+        // `&&`, `&>`, and `&>>`
+        ";;\\&?",
+        // `;;` and `;;&`
+        "[;|]\\&",
+        // `;&` and `|&`
+        "\\<\\(",
+        "\\<\\<\\<",
+        "\\<\\<-",
+        "\\<\\<(?!\\()",
+        // `<<(` stays `<` and `<(`, as zsh reads it; other shells reject it
+        ">>",
+        ">[&|(]",
+        // `>&`, `>|`, and `>(`
+        "<[&>]",
+        // `<&` and `<>`
+        "[&;()|<>]"
+      ].join(
+        /** @type {const} */
+        "|"
+      ) + /** @type {const} */
+      ")"
+    ), controlRE = new RegExp("^" + CONTROL + "$"), META = (
+      /** @type {const} */
+      "|&;()<> \\t"
+    ), SINGLE_QUOTE = (
+      /** @type {const} */
+      "'([^']*?)'"
+    ), ANSI_C_BODY = "(?:\\\\[\\s\\S]|[^\\\\'])*?", ANSI_C_QUOTE = "\\$'" + ANSI_C_BODY + "'", ansiCAt = new RegExp("\\$'" + ANSI_C_BODY + "(?:(')|\\\\?$)", "g"), ANSI_C_LETTERS = "abeEfnrtv", ANSI_C_CHARS = `\x07\b\x1B\x1B\f
+\r	\v`, hash = /^#$/, SQ = (
+      /** @type {const} */
+      "'"
+    ), DQ = (
+      /** @type {const} */
+      '"'
+    ), DS = (
+      /** @type {const} */
+      "$"
+    ), TOKEN = "", mult = (
+      /** @type {const} */
+      4294967296
+    );
+    for (i = 0; i < 4; i++)
+      TOKEN += (mult * Math.random()).toString(16);
+    var i, startsWithToken = new RegExp("^" + TOKEN);
+    function matchAll(s, r) {
+      for (var origIndex = r.lastIndex, matches = [], matchObj; matchObj = r.exec(s); )
+        matches[matches.length] = matchObj, r.lastIndex === matchObj.index && (r.lastIndex += 1);
+      return r.lastIndex = origIndex, matches;
+    }
+    function getVar(env2, pre, key) {
+      var r = typeof env2 == "function" ? env2(key) : env2[key];
+      return typeof r > "u" && key != "" ? r = "" : typeof r > "u" && (r = "$"), typeof r == "object" ? pre + TOKEN + JSON.stringify(r) + TOKEN : pre + r;
+    }
+    var ansiCEscape = /\\([0-7]{1,3}|x[\dA-Fa-f]{1,2}|u[\dA-Fa-f]{1,4}|U[\dA-Fa-f]{1,8}|c(?:\\\\|[\s\S])|[abeEfnrtv\\'"?])/g;
+    function expandAnsiCEscape(m, escape) {
+      var kind = escape.charAt(0);
+      if (kind === "c") {
+        var ctrl = escape.charAt(1);
+        return ctrl === "?" ? "\x7F" : String.fromCharCode(ctrl.charCodeAt(0) & 31);
+      }
+      if (kind === "x" || kind === "u" || kind === "U") {
+        var cp = parseInt(escape.slice(1), 16);
+        return cp > 1114111 ? m : String.fromCharCode.apply(null, cp > 65535 ? [55232 + (cp >> 10), 56320 + (cp & 1023)] : [cp]);
+      }
+      if (kind >= "0" && kind <= "7")
+        return String.fromCharCode(parseInt(escape, 8) & 255);
+      var letter = ANSI_C_LETTERS.indexOf(escape);
+      return letter < 0 ? escape : ANSI_C_CHARS.charAt(letter);
+    }
+    function expandAnsiC(body) {
+      return body.replace(ansiCEscape, expandAnsiCEscape).split("\0")[0];
+    }
+    function closesAnsiC(s, i2) {
+      return ansiCAt.lastIndex = i2, !!/** @type {RegExpExecArray} */
+      ansiCAt.exec(s)[1];
+    }
+    function parseInternal(string4, env2, opts) {
+      opts || (opts = {});
+      var BS = opts.escape || "\\", ifs = opts.splitUnquoted === !0 ? ` 	
+` : typeof opts.splitUnquoted == "string" ? opts.splitUnquoted : "", BAREWORD = "(\\" + BS + `['"$\\` + BS + META + "]|\\$\\$|\\$(?!" + ANSI_C_QUOTE.slice(2) + `)|[^\\s'"$` + META + "])+", DOUBLE_QUOTE = '"(?:\\' + BS + '[\\s\\S]|[^"\\' + BS + '])*"', chunker = new RegExp([
+        "(" + CONTROL + ")",
+        // control chars
+        "(" + ANSI_C_QUOTE + "|" + BAREWORD + "|" + DOUBLE_QUOTE + "|" + SINGLE_QUOTE + ")+"
+      ].join("|"), "g"), matches = matchAll(string4, chunker);
+      if (matches.length === 0)
+        return [];
+      env2 || (env2 = {});
+      var commented = !1;
+      return matches.map(function(match) {
+        var s = match[0];
+        if (!s || commented)
+          return;
+        if (controlRE.test(s))
+          return (
+            /** @type {ControlOperator} */
+            { op: s }
+          );
+        var quote = !1, esc = !1, out = "", words = [], sawQuote = !1, pendingNw = null, isGlob = !1, i2;
+        function parseEnvVar() {
+          i2 += 1;
+          var varend, varname, char = s.charAt(i2);
+          if (char === "{") {
+            if (i2 += 1, s.charAt(i2) === "}")
+              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
+            var depth = 1;
+            for (varend = i2; depth > 0 && varend < s.length; )
+              s.charAt(varend) === "{" && s.charAt(varend - 1) === "$" ? depth += 1 : s.charAt(varend) === "}" && (depth -= 1), varend += 1;
+            if (depth !== 0)
+              throw new Error("Bad substitution: " + s.slice(i2));
+            varend -= 1, varname = s.slice(i2, varend), i2 = varend;
+          } else if (/[*@#?$!-]/.test(char))
+            varname = char;
+          else {
+            var slicedFromI = s.slice(i2);
+            varend = slicedFromI.match(/[^\w\d_]/), varend ? (varname = slicedFromI.slice(0, varend.index), i2 += /** @type {number} */
+            varend.index - 1) : (varname = slicedFromI, i2 = s.length);
+          }
+          return getVar(
+            /** @type {NonNullable<typeof env>} */
+            env2,
+            "",
+            varname
+          );
+        }
+        function flushRun() {
+          if (pendingNw !== null) {
+            if (pendingNw === 0)
+              out !== "" && (words[words.length] = out, out = "");
+            else {
+              words[words.length] = out, out = "";
+              for (var fe = 1; fe < pendingNw; fe += 1)
+                words[words.length] = "";
+            }
+            pendingNw = null;
+          }
+        }
+        for (i2 = 0; i2 < s.length; i2++) {
+          var c = s.charAt(i2);
+          if (ifs && c !== DS && flushRun(), isGlob = isGlob || !quote && (c === "*" || c === "?"), esc)
+            out += c, esc = !1;
+          else if (quote)
+            c === quote ? quote = !1 : quote == SQ ? out += c : c === BS ? (i2 += 1, c = s.charAt(i2), c === DQ || c === BS || c === DS ? out += c : out += BS + c) : c === DS ? out += parseEnvVar() : out += c;
+          else if (c === DQ || c === SQ)
+            quote = c, sawQuote = !0;
+          else {
+            if (controlRE.test(c))
+              return (
+                /** @type {ControlOperator} */
+                { op: s }
+              );
+            if (hash.test(c)) {
+              commented = !0;
+              var commentObj = { comment: string4.slice(match.index + i2 + 1) };
+              return out.length ? (
+                /** @type {const} */
+                [out, commentObj]
+              ) : (
+                /** @type {const} */
+                [commentObj]
+              );
+            } else if (c === BS)
+              esc = !0;
+            else if (c === DS && s.charAt(i2 + 1) === SQ && closesAnsiC(s, i2))
+              flushRun(), sawQuote = !0, out += expandAnsiC(s.slice(i2 + 2, ansiCAt.lastIndex - 1)), i2 = ansiCAt.lastIndex - 1;
+            else if (c === DS) {
+              var value = parseEnvVar();
+              if (!ifs)
+                out += value;
+              else
+                for (var vi = 0; vi < value.length; vi += 1) {
+                  var vc = value.charAt(vi);
+                  ifs.indexOf(vc) < 0 ? (flushRun(), out += vc) : pendingNw === null ? pendingNw = vc === " " || vc === "	" || vc === `
+` ? 0 : 1 : vc !== " " && vc !== "	" && vc !== `
+` && (pendingNw += 1);
+                }
+            } else
+              out += c;
+          }
+        }
+        if (isGlob)
+          return (
+            /** @type {GlobPattern} */
+            { op: "glob", pattern: out }
+          );
+        if (ifs) {
+          if (pendingNw !== null && pendingNw > 0) {
+            words[words.length] = out, out = "";
+            for (var te = 1; te < pendingNw; te += 1)
+              words[words.length] = "";
+          }
+          return (out !== "" || sawQuote && words.length === 0) && (words[words.length] = out), words;
+        }
+        return out;
+      }).reduce(
+        function(prev, arg) {
+          return typeof arg > "u" || [].concat(arg).forEach(function(entry) {
+            prev[prev.length] = entry;
+          }), prev;
+        },
+        /** @type {ParseEntry[]} */
+        []
+      );
+    }
+    module.exports = function(s, env2, opts) {
+      var mapped = parseInternal(s, env2, opts);
+      return typeof env2 != "function" ? mapped : mapped.reduce(
+        function(acc, s2) {
+          if (typeof s2 == "object")
+            return acc[acc.length] = s2, acc;
+          var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+          return xs.length === 1 ? (acc[acc.length] = xs[0], acc) : (xs.filter(Boolean).forEach(function(x) {
+            acc[acc.length] = startsWithToken.test(x) ? JSON.parse(x.split(TOKEN)[1]) : x;
+          }), acc);
+        },
+        /** @type {ParseEntry[]} */
+        []
+      );
+    };
+  }
+});
+
+// ../../node_modules/shell-quote/index.js
+var require_shell_quote = __commonJS({
+  "../../node_modules/shell-quote/index.js"(exports) {
+    "use strict";
+    exports.quote = require_quote();
+    exports.parse = require_parse();
+  }
+});
+
+// ../../node_modules/launch-editor/editor-info/macos.js
+var require_macos = __commonJS({
+  "../../node_modules/launch-editor/editor-info/macos.js"(exports, module) {
+    module.exports = {
+      "/Applications/Atom.app/Contents/MacOS/Atom": "atom",
+      "/Applications/Atom Beta.app/Contents/MacOS/Atom Beta": "/Applications/Atom Beta.app/Contents/MacOS/Atom Beta",
+      "/Applications/Brackets.app/Contents/MacOS/Brackets": "brackets",
+      "/Applications/Sublime Text.app/Contents/MacOS/Sublime Text": "/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl",
+      "/Applications/Sublime Text.app/Contents/MacOS/sublime_text": "/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl",
+      "/Applications/Sublime Text 2.app/Contents/MacOS/Sublime Text 2": "/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl",
+      "/Applications/Sublime Text Dev.app/Contents/MacOS/Sublime Text": "/Applications/Sublime Text Dev.app/Contents/SharedSupport/bin/subl",
+      "/Applications/Visual Studio Code.app/Contents/MacOS/Code": "code",
+      "/Applications/Visual Studio Code.app/Contents/MacOS/Electron": "code",
+      "/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Code - Insiders": "code-insiders",
+      "/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron": "code-insiders",
+      "/Applications/VSCodium.app/Contents/MacOS/Electron": "codium",
+      "/Applications/Cursor.app/Contents/MacOS/Cursor": "cursor",
+      "/Applications/Trae.app/Contents/MacOS/Electron": "trae",
+      "/Applications/Antigravity.app/Contents/MacOS/Electron": "antigravity",
+      "/Applications/AppCode.app/Contents/MacOS/appcode": "/Applications/AppCode.app/Contents/MacOS/appcode",
+      "/Applications/CLion.app/Contents/MacOS/clion": "/Applications/CLion.app/Contents/MacOS/clion",
+      "/Applications/IntelliJ IDEA.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA.app/Contents/MacOS/idea",
+      "/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea",
+      "/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea",
+      "/Applications/PhpStorm.app/Contents/MacOS/phpstorm": "/Applications/PhpStorm.app/Contents/MacOS/phpstorm",
+      "/Applications/PyCharm.app/Contents/MacOS/pycharm": "/Applications/PyCharm.app/Contents/MacOS/pycharm",
+      "/Applications/PyCharm CE.app/Contents/MacOS/pycharm": "/Applications/PyCharm CE.app/Contents/MacOS/pycharm",
+      "/Applications/RubyMine.app/Contents/MacOS/rubymine": "/Applications/RubyMine.app/Contents/MacOS/rubymine",
+      "/Applications/WebStorm.app/Contents/MacOS/webstorm": "/Applications/WebStorm.app/Contents/MacOS/webstorm",
+      "/Applications/MacVim.app/Contents/MacOS/MacVim": "mvim",
+      "/Applications/GoLand.app/Contents/MacOS/goland": "/Applications/GoLand.app/Contents/MacOS/goland",
+      "/Applications/Rider.app/Contents/MacOS/rider": "/Applications/Rider.app/Contents/MacOS/rider",
+      "/Applications/Zed.app/Contents/MacOS/zed": "zed"
+    };
+  }
+});
+
+// ../../node_modules/launch-editor/editor-info/linux.js
+var require_linux = __commonJS({
+  "../../node_modules/launch-editor/editor-info/linux.js"(exports, module) {
+    module.exports = {
+      atom: "atom",
+      Brackets: "brackets",
+      "code-insiders": "code-insiders",
+      code: "code",
+      vscodium: "vscodium",
+      codium: "codium",
+      cursor: "cursor",
+      trae: "trae",
+      antigravity: "antigravity",
+      emacs: "emacs",
+      gvim: "gvim",
+      idea: "idea",
+      "idea.sh": "idea",
+      phpstorm: "phpstorm",
+      "phpstorm.sh": "phpstorm",
+      pycharm: "pycharm",
+      "pycharm.sh": "pycharm",
+      rubymine: "rubymine",
+      "rubymine.sh": "rubymine",
+      sublime_text: "subl",
+      vim: "vim",
+      webstorm: "webstorm",
+      "webstorm.sh": "webstorm",
+      goland: "goland",
+      "goland.sh": "goland",
+      rider: "rider",
+      "rider.sh": "rider",
+      zed: "zed"
+    };
+  }
+});
+
+// ../../node_modules/launch-editor/editor-info/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/launch-editor/editor-info/windows.js"(exports, module) {
+    module.exports = [
+      "Brackets.exe",
+      "Code.exe",
+      "Code - Insiders.exe",
+      "VSCodium.exe",
+      "Cursor.exe",
+      "atom.exe",
+      "sublime_text.exe",
+      "notepad++.exe",
+      "clion.exe",
+      "clion64.exe",
+      "idea.exe",
+      "idea64.exe",
+      "phpstorm.exe",
+      "phpstorm64.exe",
+      "pycharm.exe",
+      "pycharm64.exe",
+      "rubymine.exe",
+      "rubymine64.exe",
+      "webstorm.exe",
+      "webstorm64.exe",
+      "goland.exe",
+      "goland64.exe",
+      "rider.exe",
+      "rider64.exe",
+      "Trae.exe",
+      "zed.exe",
+      "Antigravity.exe"
+    ];
+  }
+});
+
+// ../../node_modules/launch-editor/guess.js
+var require_guess = __commonJS({
+  "../../node_modules/launch-editor/guess.js"(exports, module) {
+    var path = __require("path"), shellQuote = require_shell_quote(), childProcess = __require("child_process"), COMMON_EDITORS_MACOS = require_macos(), COMMON_EDITORS_LINUX = require_linux(), COMMON_EDITORS_WIN = require_windows();
+    function getEditorFromMacProcesses(output) {
+      let processNames = Object.keys(COMMON_EDITORS_MACOS), processList = output.split(`
+`);
+      for (let i = 0; i < processNames.length; i++) {
+        let processName = processNames[i];
+        if (processList.includes(processName))
+          return COMMON_EDITORS_MACOS[processName];
+        let processNameWithoutApplications = processName.replace("/Applications", "");
+        if (output.indexOf(processNameWithoutApplications) !== -1) {
+          if (processName !== COMMON_EDITORS_MACOS[processName])
+            return COMMON_EDITORS_MACOS[processName];
+          let runningProcess = processList.find(
+            (procName) => procName.endsWith(processNameWithoutApplications)
+          );
+          if (runningProcess !== void 0)
+            return runningProcess;
+        }
+      }
+    }
+    function getEditorFromWindowsProcesses(output) {
+      let runningProcesses = output.split(`\r
+`);
+      for (let i = 0; i < runningProcesses.length; i++) {
+        let fullProcessPath = runningProcesses[i].trim(), shortProcessName = path.win32.basename(fullProcessPath);
+        if (COMMON_EDITORS_WIN.indexOf(shortProcessName) !== -1)
+          return fullProcessPath;
+      }
+    }
+    function getEditorFromLinuxProcesses(output) {
+      let processNames = Object.keys(COMMON_EDITORS_LINUX);
+      for (let i = 0; i < processNames.length; i++) {
+        let processName = processNames[i];
+        if (output.indexOf(processName) !== -1)
+          return COMMON_EDITORS_LINUX[processName];
+      }
+    }
+    function guessEditor(specifiedEditor) {
+      if (specifiedEditor)
+        return shellQuote.parse(specifiedEditor);
+      if (process.env.LAUNCH_EDITOR)
+        return [process.env.LAUNCH_EDITOR];
+      if (process.versions.webcontainer)
+        return [process.env.EDITOR || "code"];
+      try {
+        if (process.platform === "darwin") {
+          let output = childProcess.execSync("ps x -o comm=", {
+            stdio: ["pipe", "pipe", "ignore"]
+          }).toString(), editor = getEditorFromMacProcesses(output);
+          if (editor !== void 0)
+            return [editor];
+        } else if (process.platform === "win32") {
+          let output = childProcess.execSync(
+            'powershell -NoProfile -Command "[Console]::OutputEncoding=[Text.Encoding]::UTF8;Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }"',
+            {
+              stdio: ["pipe", "pipe", "ignore"]
+            }
+          ).toString(), editor = getEditorFromWindowsProcesses(output);
+          if (editor !== void 0)
+            return [editor];
+        } else if (process.platform === "linux") {
+          let output = childProcess.execSync("ps x --no-heading -o comm --sort=comm", {
+            stdio: ["pipe", "pipe", "ignore"]
+          }).toString(), editor = getEditorFromLinuxProcesses(output);
+          if (editor !== void 0)
+            return [editor];
+        }
+      } catch {
+      }
+      return process.env.VISUAL ? [process.env.VISUAL] : process.env.EDITOR ? [process.env.EDITOR] : [null];
+    }
+    module.exports = guessEditor;
+    module.exports.getEditorFromMacProcesses = getEditorFromMacProcesses;
+    module.exports.getEditorFromWindowsProcesses = getEditorFromWindowsProcesses;
+    module.exports.getEditorFromLinuxProcesses = getEditorFromLinuxProcesses;
+  }
+});
+
+// ../../node_modules/launch-editor/get-args.js
+var require_get_args = __commonJS({
+  "../../node_modules/launch-editor/get-args.js"(exports, module) {
+    var os = __require("os"), path = __require("path");
+    module.exports = function(editor, fileName, lineNumber, columnNumber = 1) {
+      if (fileName = path.resolve(fileName), process.platform === "linux" && fileName.startsWith("/mnt/") && /Microsoft/i.test(os.release()) && (fileName = `./${path.relative("", fileName)}`), !lineNumber)
+        return [fileName];
+      switch (path.basename(editor).replace(/\.(exe|cmd|bat)$/i, "")) {
+        case "atom":
+        case "Atom":
+        case "Atom Beta":
+        case "subl":
+        case "sublime":
+        case "sublime_text":
+        case "wstorm":
+        case "charm":
+        case "zed":
+          return [`${fileName}:${lineNumber}:${columnNumber}`];
+        case "notepad++":
+          return ["-n" + lineNumber, "-c" + columnNumber, fileName];
+        case "vim":
+        case "mvim":
+          return [`+call cursor(${lineNumber}, ${columnNumber})`, fileName];
+        case "joe":
+        case "gvim":
+          return [`+${lineNumber}`, fileName];
+        case "emacs":
+        case "emacsclient":
+          return [`+${lineNumber}:${columnNumber}`, fileName];
+        case "rmate":
+        case "mate":
+        case "mine":
+          return ["--line", lineNumber, fileName];
+        case "code":
+        case "Code":
+        case "code-insiders":
+        case "Code - Insiders":
+        case "codium":
+        case "trae":
+        case "antigravity":
+        case "cursor":
+        case "vscodium":
+        case "VSCodium":
+          return ["-r", "-g", `${fileName}:${lineNumber}:${columnNumber}`];
+        case "appcode":
+        case "clion":
+        case "clion64":
+        case "idea":
+        case "idea64":
+        case "phpstorm":
+        case "phpstorm64":
+        case "pycharm":
+        case "pycharm64":
+        case "rubymine":
+        case "rubymine64":
+        case "webstorm":
+        case "webstorm64":
+        case "goland":
+        case "goland64":
+        case "rider":
+        case "rider64":
+          return ["--line", lineNumber, "--column", columnNumber, fileName];
+      }
+      return process.env.LAUNCH_EDITOR ? [fileName, lineNumber, columnNumber] : [fileName];
+    };
+  }
+});
+
+// ../../node_modules/launch-editor/construct-windows-launch-command.js
+var require_construct_windows_launch_command = __commonJS({
+  "../../node_modules/launch-editor/construct-windows-launch-command.js"(exports, module) {
+    function escapeCmdArgs(cmdArgs) {
+      return cmdArgs.replace(/([&|<>,;=^])/g, "^$1");
+    }
+    function doubleQuoteIfNeeded(str) {
+      return str.includes("^") ? `^"${str}^"` : str.includes(" ") ? `"${str}"` : str;
+    }
+    function constructWindowsLaunchCommand(editor, args) {
+      if (args.some((arg) => /[\r\n]/.test(arg)))
+        throw new Error("Cannot launch an editor with an argument containing a line break");
+      if (args.some((arg) => arg.includes("%")))
+        throw new Error('Cannot launch an editor with an argument containing "%"');
+      return [editor, ...args.map(escapeCmdArgs)].map(doubleQuoteIfNeeded).join(" ");
+    }
+    module.exports = constructWindowsLaunchCommand;
+  }
+});
+
+// ../../node_modules/launch-editor/parse-file.js
+var require_parse_file = __commonJS({
+  "../../node_modules/launch-editor/parse-file.js"(exports, module) {
+    var path = __require("path"), positionRE = /:(\d+)(:(\d+))?$/;
+    module.exports = function(file) {
+      file.startsWith("file://") && (file = __require("url").fileURLToPath(file));
+      let unresolvedFileName = file.replace(positionRE, ""), fileName = unresolvedFileName ? path.resolve(unresolvedFileName) : "", match = file.match(positionRE), lineNumber = match && match[1], columnNumber = match && match[3];
+      return {
+        fileName,
+        lineNumber,
+        columnNumber
+      };
+    };
+  }
+});
+
+// ../../node_modules/launch-editor/index.js
+var require_launch_editor = __commonJS({
+  "../../node_modules/launch-editor/index.js"(exports, module) {
+    var fs = __require("fs"), path = __require("path"), colors = require_picocolors(), childProcess = __require("child_process"), guessEditor = require_guess(), getArgumentsForFile = require_get_args(), constructWindowsLaunchCommand = require_construct_windows_launch_command(), parseFile = require_parse_file();
+    function wrapErrorCallback(cb) {
+      return (fileName, errorMessage) => {
+        console.log(), console.log(colors.red("Could not open " + path.basename(fileName) + " in the editor.")), errorMessage && (errorMessage[errorMessage.length - 1] !== "." && (errorMessage += "."), console.log(colors.red("The editor process exited with an error: " + errorMessage))), console.log(), cb && cb(fileName, errorMessage);
+      };
+    }
+    function isTerminalEditor(editor) {
+      switch (editor) {
+        case "vim":
+        case "emacs":
+        case "nano":
+          return !0;
+      }
+      return !1;
+    }
+    var currentChildProcess = null;
+    function launchEditor(file, specifiedEditor, onErrorCallback) {
+      let { fileName, lineNumber, columnNumber } = parseFile(file);
+      if (typeof specifiedEditor == "function" && (onErrorCallback = specifiedEditor, specifiedEditor = void 0), onErrorCallback = wrapErrorCallback(onErrorCallback), process.platform === "win32" && fileName.startsWith("\\\\"))
+        return onErrorCallback(
+          fileName,
+          "UNC paths are not supported on Windows to avoid security issues. See https://github.com/vitejs/launch-editor/tree/main/packages/launch-editor#unc-paths-on-windows for details."
+        );
+      if (!fs.existsSync(fileName))
+        return;
+      let [editor, ...args] = guessEditor(specifiedEditor);
+      if (!editor) {
+        onErrorCallback(fileName, null);
+        return;
+      }
+      let extraArgs = getArgumentsForFile(editor, fileName, lineNumber, columnNumber);
+      args.push.apply(args, extraArgs);
+      let launchCommand;
+      if (process.platform === "win32")
+        try {
+          launchCommand = constructWindowsLaunchCommand(editor, args);
+        } catch (error) {
+          onErrorCallback(fileName, error.message);
+          return;
+        }
+      currentChildProcess && isTerminalEditor(editor) && currentChildProcess.kill("SIGKILL"), process.platform === "win32" ? currentChildProcess = childProcess.exec(launchCommand, {
+        stdio: "inherit",
+        shell: !0
+      }) : currentChildProcess = childProcess.spawn(editor, args, { stdio: "inherit" }), currentChildProcess.on("exit", function(errorCode) {
+        currentChildProcess = null, errorCode && onErrorCallback(fileName, "(code " + errorCode + ")");
+      }), currentChildProcess.on("error", function(error) {
+        let { code, message } = error;
+        code === "ENOENT" && (message = `${message} ('${editor}' command does not exist in 'PATH')`), onErrorCallback(fileName, message);
+      });
+    }
+    module.exports = launchEditor;
+  }
+});
+
+// src/core-server/presets/common-preset.ts
+import { existsSync as existsSync2, realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import {
+  JsPackageManagerFactory,
+  STORY_FILE_TEST_REGEXP,
+  getBabelPresetEnvMajor,
+  getDirectoryFromWorkingDir,
+  getPreviewBodyTemplate,
+  getPreviewHeadTemplate,
+  loadEnvs,
+  normalizeStories,
+  optionalEnvToBoolean,
+  removeAddon as removeAddonBase
+} from "@aussieljk/forkbook/internal/common";
+import { StoryIndexGenerator } from "@aussieljk/forkbook/internal/core-server";
+import { loadCsf } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger5 } from "@aussieljk/forkbook/internal/node-logger";
+import { telemetry as telemetry7 } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/shared/open-service/services/extraction-service.server.ts
+var toExtractionError = (error) => error instanceof Error ? { name: error.name, message: error.message } : { name: "Error", message: String(error) };
+function subscribeExtractionServiceToModuleGraphChanges(definition, options) {
+  let runtime = getService(definition.id, {
+    internal: !0
+  }), moduleGraph = getService("core/module-graph", { internal: !0 }), query = runtime.queries[options.queryName], refreshComponent = (id) => runtime.commands[options.extractCommand]({ id }), refreshExtracted = async (componentIds) => {
+    let idsToRefresh = Array.from(componentIds).filter((id) => query.get({ id }) !== void 0);
+    idsToRefresh.length !== 0 && await Promise.all(idsToRefresh.map((id) => refreshComponent(id).catch(() => {
+    })));
+  };
+  moduleGraph.queries.latestStoryChanges.subscribe(void 0, async ({ data }) => {
+    if (!data || data.revision === 0)
+      return;
+    let changedStoryFiles = new Set(data.storyFiles), entries = Object.values((await options.getIndex()).entries), affectedEntries = changedStoryFiles.size === 0 ? entries : entries.filter((entry) => {
+      let storyFilePath = getStoryImportPathFromEntry(entry);
+      return storyFilePath && changedStoryFiles.has(toStoryIndexPath(storyFilePath, options.workingDir));
+    });
+    await refreshExtracted(new Set(affectedEntries.map(getComponentIdFromEntry)));
+  });
+}
+function registerExtractionService(definition, options) {
+  let { getIndex, provider, buildErrorPayload, queryName, extractCommand, extractAllCommand } = options;
+  invariant(
+    queryName in definition.queries,
+    `Extraction service "${definition.id}" has no query named "${queryName}".`
+  ), invariant(
+    extractCommand in definition.commands && extractAllCommand in definition.commands,
+    `Extraction service "${definition.id}" is missing command "${extractCommand}" or "${extractAllCommand}".`
+  );
+  let resolveInputs = async () => {
+    let entries = Object.values((await getIndex()).entries), storyEntries = Map.groupBy(entries.filter(isEligibleStoryEntry), getComponentIdFromEntry);
+    return new Map(
+      Array.from(selectComponentEntriesByComponentId(entries), ([id, entry]) => [
+        id,
+        { entry, storyEntries: storyEntries.get(id) ?? [] }
+      ])
+    );
+  }, resolveInput = async (id) => {
+    let input = (await resolveInputs()).get(id);
+    if (!input)
+      throw new OpenServiceDocgenMissingComponentError({ id });
+    return input;
+  }, writePayload = (state, id, payload) => {
+    payload ? state.components[id] = payload : delete state.components[id];
+  };
+  return registerService(definition, {
+    queries: {
+      [queryName]: {
+        staticInputs: async () => {
+          let inputs = await resolveInputs();
+          return Array.from(inputs.keys(), (id) => ({ id }));
+        }
+      }
+    },
+    commands: {
+      [extractCommand]: {
+        handler: async (input, ctx) => {
+          let payload = await provider(await resolveInput(input.id));
+          return ctx.self.setState((state) => writePayload(state, input.id, payload)), payload;
+        }
+      },
+      [extractAllCommand]: {
+        // Every component is resolved first and the state written once: one sync entry for the
+        // whole extraction instead of one per component.
+        handler: async (_input, ctx) => {
+          let inputs = await resolveInputs(), results = await Promise.all(
+            Array.from(inputs, async ([id, input]) => {
+              try {
+                return [id, await provider(input)];
+              } catch (error) {
+                return [
+                  id,
+                  buildErrorPayload({ id, entry: input.entry, error: toExtractionError(error) })
+                ];
+              }
+            })
+          );
+          ctx.self.setState((state) => {
+            for (let [id, payload] of results)
+              writePayload(state, id, payload);
+          });
+        }
+      }
+    }
+  });
+}
+
+// src/shared/open-service/services/docgen/definition.ts
+import * as v from "valibot";
+import { defineService as defineService2 } from "@aussieljk/forkbook/open-service";
+var docgenInputSchema = v.object({ id: v.string() }), argTypesSchema = v.custom(
+  (value) => typeof value == "object" && value !== null && !Array.isArray(value)
+), docgenErrorSchema = v.object({
+  name: v.string(),
+  message: v.string()
+}), docgenJsDocTagsSchema = v.record(v.string(), v.array(v.string())), docgenComponentFields = {
+  name: v.string(),
+  path: v.string(),
+  description: v.optional(v.string()),
+  summary: v.optional(v.string()),
+  jsDocTags: docgenJsDocTagsSchema,
+  argTypes: v.optional(argTypesSchema),
+  error: v.optional(docgenErrorSchema)
+}, docgenSubcomponentFields = {
+  ...docgenComponentFields,
+  import: v.optional(v.string())
+}, docgenSubcomponentSchema = v.looseObject(docgenSubcomponentFields), docgenPayloadSchema = v.looseObject({
+  id: v.string(),
+  ...docgenComponentFields,
+  subcomponents: v.optional(v.record(v.string(), docgenSubcomponentSchema))
+}), docgenOutputSchema = v.optional(docgenPayloadSchema), docgenServiceDef = defineService2({
+  id: "core/docgen",
+  internal: !0,
+  description: "Component documentation (name, description, props, JSDoc tags) keyed by component id.",
+  initialState: { components: {} },
+  queries: {
+    docgen: {
+      description: "Returns the docgen payload for one component id, or undefined when not loaded.",
+      input: docgenInputSchema,
+      output: docgenOutputSchema,
+      handler: (input, ctx) => ctx.self.state.components[input.id],
+      load: async (input, ctx) => {
+        await ctx.self.commands.extractDocgen(input);
+      },
+      staticPath: (input) => docgenQueryStaticPath(input.id)
+    },
+    docgenForAllComponents: {
+      description: "Returns docgen payloads for every component in the story index.",
+      input: v.void(),
+      output: v.record(v.string(), docgenPayloadSchema),
+      handler: (_input, ctx) => ctx.self.state.components,
+      load: async (_input, ctx) => {
+        await ctx.self.commands.extractAllDocgen(void 0);
+      }
+    }
+  },
+  commands: {
+    extractDocgen: {
+      description: "Resolves the story entry for a component id, runs the registered provider chain, writes the result into state, and returns it (or undefined when no provider produced docgen).",
+      input: docgenInputSchema,
+      output: docgenOutputSchema
+      // Handler is supplied at registration time so it can close over the story index and the
+      // composed experimental_docgenProvider chain.
+    },
+    extractAllDocgen: {
+      description: "Extracts docgen for every component id in the story index by invoking `extractDocgen` for each.",
+      input: v.undefined(),
+      output: v.void()
+      // Handler is supplied at registration time so it can close over the story index.
+    }
+  }
+});
+
+// src/shared/open-service/services/docgen/server.ts
+function registerDocgenService(options) {
+  return registerExtractionService(docgenServiceDef, {
+    getIndex: options.getIndex,
+    provider: ({ entry }) => options.docgenProvider({ entry }),
+    buildErrorPayload: ({ id, entry, error }) => ({
+      id,
+      name: entry.title,
+      path: getStoryImportPathFromEntry(entry) ?? entry.importPath,
+      jsDocTags: {},
+      error
+    }),
+    queryName: "docgen",
+    extractCommand: "extractDocgen",
+    extractAllCommand: "extractAllDocgen"
+  });
+}
+function subscribeDocgenToModuleGraphChanges(options) {
+  subscribeExtractionServiceToModuleGraphChanges(docgenServiceDef, {
+    ...options,
+    queryName: "docgen",
+    extractCommand: "extractDocgen"
+  });
+}
+
+// src/shared/open-service/services/docgen/worker/docgen-worker-client.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+var WORKER_SPECIFIER = "@aussieljk/forkbook/internal/docgen-worker", DEFAULT_TASK_TIMEOUT_MS = 12e4;
+function errorLikeToError(errorLike) {
+  let error = new Error(errorLike.message);
+  return errorLike.name && (error.name = errorLike.name), errorLike.stack && (error.stack = errorLike.stack), error;
+}
+var DocgenWorker = class {
+  constructor(scriptPath, descriptors, taskTimeoutMs = DEFAULT_TASK_TIMEOUT_MS) {
+    this.taskTimeoutMs = taskTimeoutMs;
+    this.pending = /* @__PURE__ */ new Map();
+    this.rejectReady = () => {
+    };
+    this.nextId = 0;
+    this.served = !1;
+    this.worker = new Worker(scriptPath), this.worker.on("message", (msg) => this.handleMessage(msg)), this.worker.on("error", (error) => this.fail(error)), this.worker.on("exit", (code) => {
+      this.death || this.fail(new Error(`docgen worker exited unexpectedly with code ${code}`));
+    }), this.ready = new Promise((resolve2, reject) => {
+      this.rejectReady = reject;
+      let onMessage = (msg) => {
+        msg.type === "init" && (this.worker.off("message", onMessage), msg.error ? reject(errorLikeToError(msg.error)) : resolve2());
+      };
+      this.worker.on("message", onMessage);
+    }), this.ready.catch(() => {
+    }), this.ready.finally(() => this.keepProcessAliveWhileBusy()).catch(() => {
+    }), this.post({ type: "init", descriptors, logLevel: logger.getLogLevel() });
+  }
+  /**
+   * Whether a fresh worker would be worth spawning in this one's place.
+   *
+   * Only once it has served an extract: a worker that died without ever answering died of something
+   * a replacement would hit again, and respawning would rebuild a multi-second TypeScript program
+   * per request to fail the same way.
+   */
+  get replaceable() {
+    return this.death !== void 0 && this.served;
+  }
+  async extract(entry) {
+    if (this.death)
+      throw new Error(`docgen worker is no longer running: ${this.death.message}`, {
+        cause: this.death
+      });
+    return await this.ready, new Promise((resolve2, reject) => {
+      let id = this.nextId++, pending = { resolve: resolve2, reject };
+      this.taskTimeoutMs > 0 && (pending.timer = setTimeout(() => {
+        this.pending.delete(id), this.keepProcessAliveWhileBusy(), reject(new Error(`docgen worker extract ${id} timed out after ${this.taskTimeoutMs}ms`));
+      }, this.taskTimeoutMs), pending.timer.unref?.()), this.pending.set(id, pending), this.keepProcessAliveWhileBusy(), this.post({ type: "extract", id, entry });
+    });
+  }
+  keepProcessAliveWhileBusy() {
+    this.pending.size > 0 ? this.worker.ref() : this.worker.unref();
+  }
+  post(msg) {
+    this.worker.postMessage(msg);
+  }
+  handleMessage(msg) {
+    if (msg.type !== "extract")
+      return;
+    let pending = this.pending.get(msg.id);
+    pending && (pending.timer && clearTimeout(pending.timer), this.pending.delete(msg.id), this.served = !0, this.keepProcessAliveWhileBusy(), msg.error ? pending.reject(errorLikeToError(msg.error)) : pending.resolve(msg.payload));
+  }
+  fail(error) {
+    this.death || (logger.warn(`docgen worker died, so component docs are unavailable: ${error.message}`), this.death = error, this.rejectReady(error), this.rejectAllPending(error), this.worker.terminate().catch(() => 0));
+  }
+  rejectAllPending(error) {
+    for (let [, pending] of this.pending)
+      pending.timer && clearTimeout(pending.timer), pending.reject(error);
+    this.pending.clear(), this.worker.unref();
+  }
+};
+function resolveWorkerScriptPath() {
+  try {
+    let scriptPath = fileURLToPath(importMetaResolve(WORKER_SPECIFIER));
+    return existsSync(scriptPath) ? scriptPath : void 0;
+  } catch {
+    return;
+  }
+}
+function createDocgenWorkerClient(descriptors) {
+  let scriptPath = resolveWorkerScriptPath();
+  if (!scriptPath) {
+    logger.debug(
+      "docgen worker disabled: compiled worker script not found (running from source without a build?)"
+    );
+    return;
+  }
+  let worker;
+  return {
+    async extract(entry) {
+      return worker?.replaceable && (logger.debug("docgen worker died after serving requests; spawning a replacement"), worker = void 0), worker ??= new DocgenWorker(scriptPath, descriptors), worker.extract(entry);
+    }
+  };
+}
+
+// src/shared/open-service/services/review/definition.ts
+import * as v2 from "valibot";
+var reviewCollectionSchema = v2.object({
+  title: v2.pipe(v2.string(), v2.description("Collection title shown on the review page.")),
+  rationale: v2.pipe(
+    v2.string(),
+    v2.description("Why this collection is relevant. Plain text, one or two sentences.")
+  ),
+  storyIds: v2.pipe(v2.array(v2.string()), v2.description("Story ids included in this collection."))
+}), reviewStateSchema = v2.object({
+  title: v2.pipe(v2.string(), v2.description("Terse review title. Plain text.")),
+  description: v2.pipe(
+    v2.string(),
+    v2.description(
+      "Review scope and what to look for. Limited markdown: bold, italic, and inline code."
+    )
+  ),
+  collections: v2.array(reviewCollectionSchema),
+  changedFiles: v2.optional(
+    v2.pipe(
+      v2.array(v2.string()),
+      v2.description(
+        "Changed file paths, most central first. Pass an empty array when nothing changed."
+      )
+    )
+  ),
+  createdAt: v2.optional(v2.number()),
+  stale: v2.optional(v2.boolean())
+}), reviewNavEntrySchema = v2.object({
+  storyId: v2.pipe(v2.string(), v2.description("Story id of this navigation slot.")),
+  collectionIndex: v2.pipe(
+    v2.number(),
+    v2.description("Index of the collection this slot belongs to.")
+  )
+}), reviewServiceDef = defineService({
+  id: "core/review",
+  internal: !0,
+  description: "Owns the current curated Forkbook review, its deferred update, and its staleness.",
+  initialState: { current: null, pending: null },
+  queries: {
+    current: {
+      description: "Returns the current review, or null when no review is active.",
+      input: v2.undefined(),
+      output: v2.nullable(reviewStateSchema),
+      handler: (_input, ctx) => ctx.self.state.current
+    },
+    pending: {
+      description: "Returns the deferred review update, or null when none is held.",
+      input: v2.undefined(),
+      output: v2.nullable(reviewStateSchema),
+      handler: (_input, ctx) => ctx.self.state.pending
+    },
+    flattenedEntries: {
+      description: "Returns the current review flattened into navigable story slots, walking collections in order (a story repeats when curated into several collections). Empty when no review is active.",
+      input: v2.undefined(),
+      output: v2.array(reviewNavEntrySchema),
+      handler: (_input, ctx) => (ctx.self.state.current?.collections ?? []).flatMap(
+        (collection, collectionIndex) => collection.storyIds.map((storyId) => ({ storyId, collectionIndex }))
+      )
+    },
+    bannerKind: {
+      description: "Returns which attention banner review surfaces should show: pending-update outranks stale, and once accepted the banner reflects the staleness of the accepted review; null when neither applies.",
+      input: v2.undefined(),
+      output: v2.nullable(v2.picklist(["pending-update", "stale"])),
+      handler: (_input, ctx) => ctx.self.state.pending !== null ? "pending-update" : ctx.self.state.current?.stale ? "stale" : null
+    }
+  },
+  commands: {
+    setReview: {
+      description: "Publishes a review and assigns its server creation time. Defers to pending while any review is current. Implemented by the server.",
+      input: reviewStateSchema,
+      output: v2.void()
+    },
+    acceptPending: {
+      description: "Promotes the deferred review update to current. Implemented by the server.",
+      input: v2.undefined(),
+      output: v2.void()
+    },
+    markStale: {
+      description: "Marks the current and pending reviews stale when the module graph changed after they were published. Implemented by the server.",
+      input: v2.object({
+        changedAt: v2.pipe(
+          v2.number(),
+          v2.description("When (unix ms) the newest module-graph change was made.")
+        )
+      }),
+      output: v2.void()
+    },
+    dismissReview: {
+      description: "Clears the current review and any deferred update. Implemented by the server.",
+      input: v2.undefined(),
+      output: v2.void()
+    }
+  }
+});
+
+// src/shared/open-service/services/review/state-transitions.ts
+function toPlainReview(review) {
+  return {
+    ...review,
+    collections: review.collections.map((collection) => ({
+      ...collection,
+      storyIds: [...collection.storyIds]
+    })),
+    ...review.changedFiles ? { changedFiles: [...review.changedFiles] } : {}
+  };
+}
+function applyPublishedReview(state, review) {
+  state.current === null ? (state.current = review, state.pending = null) : state.pending = review;
+}
+function applyAcceptPending(state) {
+  state.pending !== null && (state.current = toPlainReview(state.pending), state.pending = null);
+}
+function applyMarkStale(state, { changedAt }) {
+  let isOutdated = (review) => review?.createdAt !== void 0 && !review.stale && changedAt > review.createdAt;
+  isOutdated(state.current) && (state.current = { ...toPlainReview(state.current), stale: !0 }), isOutdated(state.pending) && (state.pending = { ...toPlainReview(state.pending), stale: !0 });
+}
+function applyDismiss(state) {
+  state.current = null, state.pending = null;
+}
+
+// src/shared/open-service/services/review/server.ts
+function registerReviewService({ getIndex }) {
+  return registerService(reviewServiceDef, {
+    commands: {
+      setReview: {
+        handler: async (input, ctx) => {
+          let { stale: _stale, createdAt: _createdAt, ...review } = input, storyIds = [
+            ...new Set(review.collections.flatMap((collection) => collection.storyIds))
+          ], index = await getIndex(), unknownIds = storyIds.filter((storyId) => index.entries[storyId]?.type !== "story");
+          if (unknownIds.length > 0)
+            throw new OpenServiceUnknownStoryIdsError({ unknownIds });
+          ctx.self.setState((state) => {
+            applyPublishedReview(state, { ...review, createdAt: Date.now() });
+          });
+        }
+      },
+      acceptPending: {
+        handler: async (_input, ctx) => {
+          ctx.self.setState((state) => {
+            applyAcceptPending(state);
+          });
+        }
+      },
+      markStale: {
+        handler: async (change, ctx) => {
+          ctx.self.setState((state) => {
+            applyMarkStale(state, change);
+          });
+        }
+      },
+      dismissReview: {
+        handler: async (_input, ctx) => {
+          ctx.self.setState((state) => {
+            applyDismiss(state);
+          });
+        }
+      }
+    }
+  });
+}
+function subscribeReviewToModuleGraphChanges() {
+  let review = getService("core/review", { internal: !0 });
+  getService("core/module-graph", { internal: !0 }).queries.graphChangedAt.subscribe(void 0, ({ data: changedAt }) => {
+    changedAt !== void 0 && review.commands.markStale({ changedAt });
+  });
+}
+
+// src/shared/open-service/services/story-docs/definition.ts
+import * as v3 from "valibot";
+import { defineService as defineService3 } from "@aussieljk/forkbook/open-service";
+var storyDocsInputSchema = v3.object({ id: v3.string() }), storyDocsErrorSchema = v3.object({
+  name: v3.string(),
+  message: v3.string()
+}), storyDocSchema = v3.object({
+  id: v3.string(),
+  name: v3.string(),
+  snippet: v3.optional(v3.string()),
+  description: v3.optional(v3.string()),
+  summary: v3.optional(v3.string()),
+  warning: v3.optional(v3.string()),
+  error: v3.optional(storyDocsErrorSchema)
+}), storyDocsPayloadSchema = v3.object({
+  id: v3.string(),
+  name: v3.string(),
+  path: v3.string(),
+  import: v3.optional(v3.string()),
+  stories: v3.record(v3.string(), storyDocSchema),
+  error: v3.optional(storyDocsErrorSchema)
+}), storyDocsOutputSchema = v3.optional(storyDocsPayloadSchema), storyDocsServiceDef = defineService3({
+  id: "core/story-docs",
+  internal: !0,
+  description: "Story documentation (snippets, descriptions, imports) keyed by component id.",
+  initialState: { components: {} },
+  queries: {
+    storyDocs: {
+      description: "Returns the story-docs payload for one component id, or undefined when not loaded.",
+      input: storyDocsInputSchema,
+      output: storyDocsOutputSchema,
+      handler: (input, ctx) => Object.hasOwn(ctx.self.state.components, input.id) ? ctx.self.state.components[input.id] : void 0,
+      load: async (input, ctx) => {
+        await ctx.self.commands.extractStoryDocs(input);
+      },
+      staticPath: (input) => storyDocsQueryStaticPath(input.id)
+    },
+    storyDocsForAllComponents: {
+      description: "Returns story-docs payloads for every component in the story index.",
+      input: v3.void(),
+      output: v3.record(v3.string(), storyDocsPayloadSchema),
+      handler: (_input, ctx) => ctx.self.state.components,
+      load: async (_input, ctx) => {
+        await ctx.self.commands.extractAllStoryDocs(void 0);
+      }
+    }
+  },
+  commands: {
+    extractStoryDocs: {
+      description: "Resolves the story entry for a component id, runs the registered provider chain, writes the result into state, and returns it (or undefined when no provider produced story docs).",
+      input: storyDocsInputSchema,
+      output: storyDocsOutputSchema
+    },
+    extractAllStoryDocs: {
+      description: "Extracts story docs for every component id in the story index by invoking `extractStoryDocs` for each.",
+      input: v3.undefined(),
+      output: v3.void()
+    }
+  }
+});
+
+// src/shared/open-service/services/story-docs/server.ts
+function storyDocFromFile(entry, result) {
+  if (result.status === "rejected")
+    return { id: entry.id, name: entry.name, error: toExtractionError(result.reason) };
+  let story = result.value?.stories[entry.id];
+  return story?.snippet === void 0 ? story : { ...story, snippet: prependImportToSnippet(result.value?.import, story.snippet) };
+}
+function withStoriesFromEveryFile(provider) {
+  return async ({ entry, storyEntries }) => {
+    let fileEntries = [
+      ...new Map(storyEntries.map((storyEntry) => [storyEntry.importPath, storyEntry])).values()
+    ];
+    if (fileEntries.length < 2)
+      return provider({ entry });
+    let results = await Promise.allSettled(
+      fileEntries.map((fileEntry) => provider({ entry: fileEntry }))
+    ), resultByFile = Object.fromEntries(
+      fileEntries.map((fileEntry, index) => [fileEntry.importPath, results[index]])
+    ), selected = resultByFile[entry.importPath];
+    if (selected.status === "rejected")
+      throw selected.reason;
+    if (!selected.value)
+      return;
+    let { import: _import, ...component } = selected.value;
+    return {
+      ...component,
+      stories: Object.fromEntries(
+        storyEntries.flatMap((storyEntry) => {
+          let story = storyDocFromFile(storyEntry, resultByFile[storyEntry.importPath]);
+          return story ? [[storyEntry.id, story]] : [];
+        })
+      )
+    };
+  };
+}
+function registerStoryDocsService(options) {
+  return registerExtractionService(storyDocsServiceDef, {
+    getIndex: options.getIndex,
+    provider: withStoriesFromEveryFile(options.storyDocsProvider),
+    buildErrorPayload: ({ id, entry, error }) => ({
+      id,
+      name: entry.title,
+      path: getStoryImportPathFromEntry(entry) ?? entry.importPath,
+      stories: {},
+      error
+    }),
+    queryName: "storyDocs",
+    extractCommand: "extractStoryDocs",
+    extractAllCommand: "extractAllStoryDocs"
+  });
+}
+function subscribeStoryDocsToModuleGraphChanges(options) {
+  subscribeExtractionServiceToModuleGraphChanges(storyDocsServiceDef, {
+    ...options,
+    queryName: "storyDocs",
+    extractCommand: "extractStoryDocs"
+  });
+}
+
+// src/core-server/presets/common-preset.ts
+import * as pathe from "pathe";
+import { isAbsolute as isAbsolute2, join as join4 } from "pathe";
+import { dedent } from "ts-dedent";
+
+// src/core-server/server-channel/ai-setup-channel.ts
+import {
+  AI_SETUP_ANALYTICS_REQUEST,
+  AI_SETUP_ANALYTICS_RESPONSE
+} from "@aussieljk/forkbook/internal/core-events";
+import {
+  getLastEvents,
+  getStorybookMetadata,
+  isStoryCreatedByAISetup,
+  telemetry
+} from "@aussieljk/forkbook/internal/telemetry";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/core-server/utils/wait-for-idle-vitest.ts
+async function waitForIdleVitest(maxWaitMs = 1800 * 1e3, pollIntervalMs = 60 * 1e3) {
+  let deadline = Date.now() + maxWaitMs;
+  for (; Date.now() < deadline; ) {
+    try {
+      let state = fullTestProviderStore.getFullState();
+      if (!Object.values(state).some((s) => s === "test-provider-state:running"))
+        return !0;
+    } catch {
+      return !0;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+  }
+  return !1;
+}
+
+// src/core-server/server-channel/ai-setup-channel.ts
+function initAIAnalyticsChannel(channel, options, getStoryIndexGeneratorPromise) {
+  return channel.on(AI_SETUP_ANALYTICS_REQUEST, async () => {
+    let stats = {}, runId;
+    try {
+      let lastEvents = await getLastEvents(), lastAISetup = lastEvents?.["ai-setup"], lastSetupStoryScoringRun = lastEvents?.["ai-setup-final-scoring"];
+      if (runId = await getAiSetupRunId(options.configDir), !lastAISetup || lastSetupStoryScoringRun && lastSetupStoryScoringRun.body.payload.runId === lastAISetup.body.payload.runId)
+        return;
+      let metadata = await getStorybookMetadata(options.configDir), isReactStorybook = metadata?.renderer?.includes("@aussieljk/forkbook/react"), hasVitestAddon = !!metadata?.addons && Object.keys(metadata.addons).some(
+        (addonKey) => addonKey.includes("@aussieljk/forkbook/addon-vitest")
+      );
+      if (!isReactStorybook || !hasVitestAddon)
+        return;
+      if (!await waitForIdleVitest()) {
+        logger2.debug("AI_SETUP_ANALYTICS_REQUEST timed out waiting for vitest to be available.");
+        return;
+      }
+      let generatorPromise = getStoryIndexGeneratorPromise?.();
+      if (!generatorPromise) {
+        logger2.debug(
+          "AI_SETUP_ANALYTICS_REQUEST could not proceed as the index generator is not ready."
+        );
+        return;
+      }
+      let indexAndStats = await (await generatorPromise).getIndexAndStats();
+      if (!indexAndStats) {
+        logger2.debug("AI_SETUP_ANALYTICS_REQUEST could not proceed as the index is not ready.");
+        return;
+      }
+      let aiStoryFiles = /* @__PURE__ */ new Set(), aiStoryCount = 0;
+      for (let entry of Object.values(indexAndStats.storyIndex.entries))
+        isStoryCreatedByAISetup(entry) && (aiStoryFiles.add(entry.importPath), aiStoryCount++);
+      if (aiStoryFiles.size > 0) {
+        let aiTestRunResult = await runStoryTests([...aiStoryFiles]);
+        telemetry("ai-setup-final-scoring", {
+          stats: {
+            fileCount: aiStoryFiles.size,
+            storyCount: aiStoryCount,
+            testRunDuration: aiTestRunResult.duration
+          },
+          runId,
+          results: aiTestRunResult.summary,
+          ...aiTestRunResult.runError ? { runError: aiTestRunResult.runError } : {}
+        });
+      } else
+        telemetry("ai-setup-final-scoring", {
+          stats: {
+            fileCount: 0,
+            storyCount: 0,
+            testRunDuration: 0
+          },
+          runId,
+          runError: "No stories found that were generated by ai setup"
+        });
+    } catch {
+      telemetry("ai-setup-final-scoring", {
+        stats,
+        runId,
+        runError: "Unknown error during AI story scoring"
+      });
+    } finally {
+      channel.emit(AI_SETUP_ANALYTICS_RESPONSE);
+    }
+  }), channel;
+}
+
+// src/core-server/server-channel/ghost-stories-channel.ts
+import {
+  GHOST_STORIES_REQUEST,
+  GHOST_STORIES_RESPONSE
+} from "@aussieljk/forkbook/internal/core-events";
+import {
+  getLastEvents as getLastEvents2,
+  getStorybookMetadata as getStorybookMetadata2,
+  telemetry as telemetry2
+} from "@aussieljk/forkbook/internal/telemetry";
+var SkipGhostStoriesTelemetry = class extends Error {
+};
+function initGhostStoriesChannel(channel, options) {
+  return channel.on(GHOST_STORIES_REQUEST, async () => {
+    let stats = {}, aiSetupRunId = await getAiSetupRunId(options.configDir);
+    try {
+      await telemetry2("ghost-stories", async () => {
+        try {
+          let ghostRunStart = Date.now(), lastEvents = await getLastEvents2(), lastInit = lastEvents?.init, lastAISetup = lastEvents?.["ai-setup"], lastSetupStoryScoringRun = lastEvents?.["ai-setup-final-scoring"], lastGhostStoriesRun = lastEvents?.["ghost-stories"];
+          if (!(lastAISetup ?? lastInit))
+            throw new SkipGhostStoriesTelemetry();
+          if (lastGhostStoriesRun && lastSetupStoryScoringRun.body.payload.runId === lastAISetup.body.payload.runId)
+            throw new SkipGhostStoriesTelemetry();
+          let metadata = await getStorybookMetadata2(options.configDir), isReactStorybook = metadata?.renderer?.includes("@aussieljk/forkbook/react"), hasVitestAddon = !!metadata?.addons && Object.keys(metadata.addons).some(
+            (addonKey) => addonKey.includes("@aussieljk/forkbook/addon-vitest")
+          );
+          if (!isReactStorybook || !hasVitestAddon)
+            throw new SkipGhostStoriesTelemetry();
+          if (!await waitForIdleVitest())
+            return {
+              stats,
+              aiSetupRunId,
+              runError: "Vitest busy, couldn't run ghost stories"
+            };
+          let candidateAnalysisStart = Date.now(), candidatesResult = await getComponentCandidates();
+          if (stats.candidateAnalysisDuration = Date.now() - candidateAnalysisStart, stats.globMatchCount = candidatesResult.globMatchCount, stats.analyzedCount = candidatesResult.analyzedCount ?? 0, stats.avgComplexity = candidatesResult.avgComplexity ?? 0, stats.candidateCount = candidatesResult.candidates.length, candidatesResult.error)
+            return stats.totalRunDuration = Date.now() - ghostRunStart, {
+              stats,
+              aiSetupRunId,
+              runError: candidatesResult.error
+            };
+          if (candidatesResult.candidates.length === 0)
+            return stats.totalRunDuration = Date.now() - ghostRunStart, {
+              stats,
+              aiSetupRunId,
+              runError: "No candidates found"
+            };
+          let testRunResult = await runStoryTests(candidatesResult.candidates, {
+            ghostRun: !0
+          });
+          return stats.totalRunDuration = Date.now() - ghostRunStart, stats.testRunDuration = testRunResult.duration, testRunResult.runError ? {
+            stats,
+            aiSetupRunId,
+            runError: testRunResult.runError
+          } : {
+            stats,
+            aiSetupRunId,
+            results: testRunResult.summary
+          };
+        } catch (error) {
+          if (error instanceof SkipGhostStoriesTelemetry)
+            throw error;
+          return {
+            stats,
+            aiSetupRunId,
+            runError: "Unknown error during ghost run"
+          };
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof SkipGhostStoriesTelemetry))
+        throw error;
+    } finally {
+      channel.emit(GHOST_STORIES_RESPONSE);
+    }
+  }), channel;
+}
+
+// src/core-server/server-channel/open-in-editor-channel.ts
+var import_launch_editor = __toESM(require_launch_editor(), 1);
+import {
+  OPEN_IN_EDITOR_REQUEST,
+  OPEN_IN_EDITOR_RESPONSE
+} from "@aussieljk/forkbook/internal/core-events";
+import { telemetry as telemetry3 } from "@aussieljk/forkbook/internal/telemetry";
+async function initOpenInEditorChannel(channel) {
+  return channel.on(OPEN_IN_EDITOR_REQUEST, async (payload) => {
+    let sendTelemetry = (data) => {
+      telemetry3("open-in-editor", data);
+    };
+    try {
+      let { file: targetFile, line, column } = payload;
+      if (!targetFile)
+        throw new Error("No file was provided to open");
+      let location = typeof line == "number" ? `${targetFile}:${line}${typeof column == "number" ? `:${column}` : ""}` : targetFile;
+      await new Promise((resolve2, reject) => {
+        (0, import_launch_editor.default)(location, void 0, (_fileName, errorMessage) => {
+          errorMessage ? reject(new Error(errorMessage)) : resolve2();
+        });
+      }), channel.emit(OPEN_IN_EDITOR_RESPONSE, {
+        file: targetFile,
+        line,
+        column,
+        error: null
+      }), sendTelemetry({ success: !0 });
+    } catch (e) {
+      let error = e?.message || "Failed to open in editor";
+      channel.emit(OPEN_IN_EDITOR_RESPONSE, {
+        error,
+        ...payload
+      }), sendTelemetry({ success: !1, error });
+    }
+  }), channel;
+}
+
+// src/core-server/server-channel/telemetry-channel.ts
+import {
+  AI_PROMPT_NUDGE,
+  PREVIEW_INITIALIZED,
+  SHARE_ISOLATE_MODE,
+  SIDEBAR_FILTER_CHANGED
+} from "@aussieljk/forkbook/internal/core-events";
+import {
+  getLastEvents as getLastEvents3,
+  getSessionId,
+  telemetry as telemetry4
+} from "@aussieljk/forkbook/internal/telemetry";
+var makePayload = (userAgent, lastInit, sessionId) => {
+  let payload = {
+    userAgent,
+    timeSinceInit: void 0
+  };
+  return sessionId && lastInit?.body?.sessionId === sessionId && (payload.timeSinceInit = Date.now() - lastInit.timestamp), payload;
+};
+function initTelemetryChannel(channel) {
+  channel.on(PREVIEW_INITIALIZED, async ({ userAgent }) => {
+    try {
+      let sessionId = await getSessionId(), lastEvents = await getLastEvents3(), lastInit = lastEvents.init;
+      if (!lastEvents["preview-first-load"]) {
+        let payload = makePayload(userAgent, lastInit, sessionId);
+        telemetry4("preview-first-load", payload);
+      }
+    } catch {
+    }
+  }), channel.on(SHARE_ISOLATE_MODE, async () => {
+    telemetry4("share", { action: "isolate-mode-opened" });
+  }), channel.on(SIDEBAR_FILTER_CHANGED, (payload) => {
+    telemetry4("sidebar-filter", payload);
+  }), channel.on(AI_PROMPT_NUDGE, async ({ id, origin }) => {
+    telemetry4("ai-prompt-nudge", { id, origin });
+  }), channel.on(REVIEW_EVENTS.PAGEVIEW, ({ page, reviewCreatedAt }) => {
+    telemetry4("review", { action: "pageview", source: "mcp-review", page, reviewCreatedAt });
+  });
+}
+
+// src/core-server/utils/constants.ts
+import { join } from "pathe";
+var defaultStaticDirs = [
+  {
+    from: join(resolvePackageDir("@aussieljk/forkbook"), "assets/browser"),
+    to: "/sb-common-assets"
+  }
+], defaultFavicon = join(
+  resolvePackageDir("@aussieljk/forkbook"),
+  "assets/browser/favicon.svg"
+);
+
+// src/core-server/utils/save-story/save-story.ts
+import { writeFile } from "node:fs/promises";
+import { basename, isAbsolute, join as join2, relative } from "node:path";
+import { types as t4 } from "@aussieljk/forkbook/internal/babel";
+import { formatFileContent, getProjectRoot } from "@aussieljk/forkbook/internal/common";
+import {
+  SAVE_STORY_REQUEST,
+  SAVE_STORY_RESPONSE,
+  STORY_RENDERED
+} from "@aussieljk/forkbook/internal/core-events";
+import { storyNameFromExport, toId } from "@aussieljk/forkbook/internal/csf/csf-utils";
+import { printCsf, readCsf } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+import { isExampleStoryId, telemetry as telemetry5 } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/core-server/utils/save-story/duplicate-story-with-new-name.ts
+import { types as t, traverse } from "@aussieljk/forkbook/internal/babel";
+
+// src/core-server/utils/save-story/utils.ts
+var SaveStoryError = class extends Error {
+};
+
+// src/core-server/utils/save-story/duplicate-story-with-new-name.ts
+var duplicateStoryWithNewName = (csfFile, storyName, newStoryName) => {
+  let node = csfFile._storyExports[storyName], cloned = t.cloneNode(node);
+  if (!cloned)
+    throw new SaveStoryError("cannot clone Node");
+  let found = !1;
+  if (traverse(cloned, {
+    Identifier(path) {
+      found || path.node.name === storyName && (found = !0, path.node.name = newStoryName);
+    },
+    ObjectProperty(path) {
+      let key = path.get("key");
+      key.isIdentifier() && key.node.name === "args" && path.remove();
+    },
+    noScope: !0
+  }), !(t.isCallExpression(cloned.init) && t.isMemberExpression(cloned.init.callee) && t.isIdentifier(cloned.init.callee.property) && cloned.init.callee.property.name === "story") && (t.isArrowFunctionExpression(cloned.init) || t.isCallExpression(cloned.init)))
+    throw new SaveStoryError("Creating a new story based on a CSF2 story is not supported");
+  return traverse(csfFile._ast, {
+    Program(path) {
+      path.pushContainer(
+        "body",
+        t.exportNamedDeclaration(t.variableDeclaration("const", [cloned]))
+      );
+    }
+  }), cloned;
+};
+
+// src/core-server/utils/save-story/update-args-in-csf-file.ts
+import { types as t3, traverse as traverse2 } from "@aussieljk/forkbook/internal/babel";
+
+// src/core-server/utils/save-story/valueToAST.ts
+import { parser, types as t2 } from "@aussieljk/forkbook/internal/babel";
+function valueToAST(literal) {
+  if (literal === null)
+    return t2.nullLiteral();
+  switch (typeof literal) {
+    case "function":
+      return parser.parse(literal.toString(), {
+        allowReturnOutsideFunction: !0,
+        allowSuperOutsideMethod: !0
+      }).program.body[0]?.expression;
+    case "number":
+      return t2.numericLiteral(literal);
+    case "string":
+      return t2.stringLiteral(literal);
+    case "boolean":
+      return t2.booleanLiteral(literal);
+    case "undefined":
+      return t2.identifier("undefined");
+    default:
+      return Array.isArray(literal) ? t2.arrayExpression(literal.map(valueToAST)) : t2.objectExpression(
+        Object.keys(literal).filter((k) => typeof literal[k] < "u").map((k) => {
+          let value = literal[k];
+          return t2.objectProperty(t2.stringLiteral(k), valueToAST(value));
+        })
+      );
+  }
+}
+
+// src/core-server/utils/save-story/update-args-in-csf-file.ts
+var updateArgsInCsfFile = async (node, input) => {
+  let found = !1, args = Object.fromEntries(
+    Object.entries(input).map(([k, v4]) => {
+      if (!t3.isValidIdentifier(k, !1))
+        throw new SaveStoryError(`Invalid arg name: ${JSON.stringify(k)}`);
+      return [k, valueToAST(v4)];
+    })
+  );
+  if (!(t3.isCallExpression(node) && t3.isMemberExpression(node.callee) && t3.isIdentifier(node.callee.property) && node.callee.property.name === "story") && (t3.isArrowFunctionExpression(node) || t3.isCallExpression(node)))
+    throw new SaveStoryError("Updating a CSF2 story is not supported");
+  if (t3.isObjectExpression(node)) {
+    let properties = node.properties, argsProperty = properties.find((property) => {
+      if (t3.isObjectProperty(property)) {
+        let key = property.key;
+        return t3.isIdentifier(key) && key.name === "args";
+      }
+      return !1;
+    });
+    if (argsProperty) {
+      if (t3.isObjectProperty(argsProperty)) {
+        let a = argsProperty.value;
+        if (t3.isObjectExpression(a)) {
+          a.properties.forEach((p) => {
+            if (t3.isObjectProperty(p)) {
+              let key = p.key;
+              t3.isIdentifier(key) && key.name in args && (p.value = args[key.name], delete args[key.name]);
+            }
+          });
+          let remainder = Object.entries(args);
+          Object.keys(args).length && remainder.forEach(([key, value]) => {
+            a.properties.push(t3.objectProperty(t3.identifier(key), value));
+          });
+        }
+      }
+    } else
+      properties.unshift(
+        t3.objectProperty(
+          t3.identifier("args"),
+          t3.objectExpression(
+            Object.entries(args).map(([key, value]) => t3.objectProperty(t3.identifier(key), value))
+          )
+        )
+      );
+    return;
+  }
+  traverse2(node, {
+    ObjectExpression(path) {
+      if (found)
+        return;
+      found = !0;
+      let argsProperty = path.get("properties").find((property) => {
+        if (property.isObjectProperty()) {
+          let key = property.get("key");
+          return key.isIdentifier() && key.node.name === "args";
+        }
+        return !1;
+      });
+      if (argsProperty) {
+        if (argsProperty.isObjectProperty()) {
+          let a = argsProperty.get("value");
+          if (a.isObjectExpression()) {
+            a.traverse({
+              ObjectProperty(p) {
+                let key = p.get("key");
+                key.isIdentifier() && key.node.name in args && (p.get("value").replaceWith(args[key.node.name]), delete args[key.node.name]);
+              },
+              noScope: !0
+            });
+            let remainder = Object.entries(args);
+            Object.keys(args).length && remainder.forEach(([key, value]) => {
+              a.pushContainer("properties", t3.objectProperty(t3.identifier(key), value));
+            });
+          }
+        }
+      } else
+        path.unshiftContainer(
+          "properties",
+          t3.objectProperty(
+            t3.identifier("args"),
+            t3.objectExpression(
+              Object.entries(args).map(([key, value]) => t3.objectProperty(t3.identifier(key), value))
+            )
+          )
+        );
+    },
+    noScope: !0
+  });
+};
+
+// src/core-server/utils/save-story/save-story.ts
+var parseArgs = (args) => JSON.parse(args, (_, value) => value === "__sb_empty_function_arg__" ? () => {
+} : value), removeExtraNewlines = (code, name) => {
+  let anything = "([\\s\\S])", newline = "(\\r\\n|\\r|\\n)", closing = newline + "};" + newline, regex = new RegExp(
+    // Looks for an export by the given name, considers the first closing brace on its own line
+    // to be the end of the story definition.
+    `^(?<before>${anything}*)(?<story>export const ${name} =${anything}+?${closing})(?<after>${anything}*)$`
+  ), { before, story, after } = code.match(regex)?.groups || {};
+  return story ? before + story.replaceAll(/(\r\n|\r|\n)(\r\n|\r|\n)([ \t]*[a-z0-9_]+): /gi, "$2$3:") + after : code;
+};
+function initializeSaveStory(channel, options) {
+  channel.on(SAVE_STORY_REQUEST, async ({ id, payload }) => {
+    let { csfId, importPath, args, name } = payload, newStoryId, newStoryName, sourceFileName, sourceFilePath, sourceStoryName;
+    try {
+      if (name && !t4.isValidIdentifier(name))
+        throw new SaveStoryError(`Invalid story name: ${JSON.stringify(name)}`);
+      sourceFileName = basename(importPath), sourceFilePath = join2(process.cwd(), importPath);
+      let pathFromProjectRoot = relative(getProjectRoot(), sourceFilePath);
+      if (isAbsolute(pathFromProjectRoot) || // Windows strips trailing dots from path segments, so `...` is not a plain name there.
+      pathFromProjectRoot.split(/[\\/]/).some((segment) => /^\.{2,}$/.test(segment)))
+        throw new SaveStoryError("Invalid importPath: must resolve within the project root.");
+      let csf = await readCsf(sourceFilePath, {
+        makeTitle: (userTitle) => userTitle || "myTitle"
+      }), parsed = csf.parse(), stories = Object.entries(parsed._stories), [componentId, storyId] = csfId.split("--");
+      newStoryName = name && storyNameFromExport(name), newStoryId = newStoryName && toId(componentId, newStoryName);
+      let [storyName] = stories.find(([key, value]) => value.id.endsWith(`--${storyId}`)) || [];
+      if (!storyName)
+        throw new SaveStoryError("Source story not found.");
+      if (name && csf.getStoryExport(name))
+        throw new SaveStoryError("Story already exists.");
+      sourceStoryName = storyNameFromExport(storyName), await updateArgsInCsfFile(
+        name ? duplicateStoryWithNewName(parsed, storyName, name) : csf.getStoryExport(storyName),
+        args ? parseArgs(args) : {}
+      );
+      let code = await formatFileContent(
+        sourceFilePath,
+        removeExtraNewlines(printCsf(csf).code, name || storyName)
+      );
+      await Promise.all([
+        new Promise((resolve2) => {
+          channel.on(STORY_RENDERED, resolve2), setTimeout(() => resolve2(channel.off(STORY_RENDERED, resolve2)), 3e3);
+        }),
+        writeFile(sourceFilePath, code)
+      ]), channel.emit(SAVE_STORY_RESPONSE, {
+        id,
+        success: !0,
+        payload: {
+          csfId,
+          newStoryId,
+          newStoryName,
+          newStoryExportName: name,
+          sourceFileContent: code,
+          sourceFileName,
+          sourceStoryName,
+          sourceStoryExportName: storyName
+        },
+        error: null
+      }), isExampleStoryId(newStoryId ?? csfId) || await telemetry5("save-story", {
+        action: name ? "createStory" : "updateStory",
+        success: !0
+      });
+    } catch (error) {
+      channel.emit(SAVE_STORY_RESPONSE, {
+        id,
+        success: !1,
+        error: error instanceof SaveStoryError ? error.message : "Unknown error"
+      }), logger3.error(
+        `Error writing to ${sourceFilePath}:
+${error.stack || error.message || error.toString()}`
+      ), error instanceof SaveStoryError || await telemetry5("save-story", {
+        action: name ? "createStory" : "updateStory",
+        success: !1,
+        error
+      });
+    }
+  });
+}
+
+// src/core-server/utils/whats-new.ts
+import { findConfigFile, loadMainConfig } from "@aussieljk/forkbook/internal/common";
+import {
+  REQUEST_WHATS_NEW_DATA,
+  RESULT_WHATS_NEW_DATA,
+  SET_WHATS_NEW_CACHE,
+  TELEMETRY_ERROR,
+  TOGGLE_WHATS_NEW_NOTIFICATIONS
+} from "@aussieljk/forkbook/internal/core-events";
+import { readConfig, writeConfig } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger4 } from "@aussieljk/forkbook/internal/node-logger";
+import { telemetry as telemetry6 } from "@aussieljk/forkbook/internal/telemetry";
+var WHATS_NEW_CACHE = "whats-new-cache", WHATS_NEW_URL = "https://storybook.js.org/whats-new/v1";
+function initializeWhatsNew(channel, options) {
+  channel.on(SET_WHATS_NEW_CACHE, async (data) => {
+    let cache = await options.cache.get(WHATS_NEW_CACHE).catch((e) => (logger4.verbose(e), {}));
+    await options.cache.set(WHATS_NEW_CACHE, { ...cache, ...data });
+  }), channel.on(REQUEST_WHATS_NEW_DATA, async () => {
+    try {
+      let post = await fetch(WHATS_NEW_URL).then(async (response) => {
+        if (response.ok)
+          return response.json();
+        throw response;
+      }), disableWhatsNewNotifications = (await loadMainConfig({ configDir: options.configDir })).core?.disableWhatsNewNotifications === !0, cache = await options.cache.get(WHATS_NEW_CACHE) ?? {}, data = {
+        ...post,
+        status: "SUCCESS",
+        postIsRead: post.url === cache.lastReadPost,
+        showNotification: post.url !== cache.lastDismissedPost && post.url !== cache.lastReadPost,
+        disableWhatsNewNotifications
+      };
+      channel.emit(RESULT_WHATS_NEW_DATA, { data });
+    } catch (e) {
+      logger4.verbose(e instanceof Error ? e.message : String(e)), channel.emit(RESULT_WHATS_NEW_DATA, {
+        data: { status: "ERROR" }
+      });
+    }
+  }), channel.on(
+    TOGGLE_WHATS_NEW_NOTIFICATIONS,
+    async ({ disableWhatsNewNotifications }) => {
+      try {
+        let mainPath = findConfigFile("main", options.configDir);
+        invariant(mainPath, `unable to find Forkbook main file in ${options.configDir}`);
+        let main = await readConfig(mainPath);
+        if (!main._exportsObject)
+          throw new Error(
+            "Unable to parse Forkbook main file while trying to read 'core' property"
+          );
+        main.set(["core", "disableWhatsNewNotifications"], disableWhatsNewNotifications), await writeConfig(main, mainPath), await telemetry6("core-config", { disableWhatsNewNotifications });
+      } catch (error) {
+        invariant(error instanceof Error), await sendTelemetryError(error, "core-config", {
+          cliOptions: options,
+          presetOptions: {
+            ...options,
+            corePresets: [],
+            overridePresets: []
+          },
+          skipPrompt: !0
+        });
+      }
+    }
+  ), channel.on(TELEMETRY_ERROR, async (error) => {
+    await sendTelemetryError(error, "browser", {
+      cliOptions: options,
+      presetOptions: {
+        ...options,
+        corePresets: [],
+        overridePresets: []
+      },
+      skipPrompt: !0
+    });
+  });
+}
+
+// src/core-server/presets/common-preset.ts
+var interpolate = (string4, data = {}) => Object.entries(data).reduce((acc, [k, v4]) => acc.replace(new RegExp(`%${k}%`, "g"), v4), string4), staticDirs = async (values = []) => [
+  ...defaultStaticDirs,
+  ...values
+], favicon = async (value, options) => {
+  if (value)
+    return value;
+  let staticDirsValue = await options.presets.apply("staticDirs"), faviconPaths = (staticDirsValue ? staticDirsValue.map((dir) => typeof dir == "string" ? dir : `${dir.from}:${dir.to}`) : []).map((dir) => {
+    let results = [], normalizedDir = staticDirsValue && !isAbsolute2(dir) ? getDirectoryFromWorkingDir({
+      configDir: options.configDir,
+      workingDir: process.cwd(),
+      directory: dir
+    }) : dir, { staticPath, targetEndpoint } = parseStaticDir(normalizedDir);
+    return ["/favicon.svg", "/favicon.ico"].includes(targetEndpoint) && results.push(staticPath), targetEndpoint === "/" && (results.push(join4(staticPath, "favicon.svg")), results.push(join4(staticPath, "favicon.ico"))), results.filter((path) => existsSync2(path));
+  }).reduce((l1, l2) => l1.concat(l2), []);
+  return faviconPaths.length > 1 && logger5.debug(dedent`
+      Looks like multiple favicons were detected. Using the first one.
+
+      ${faviconPaths.join(", ")}
+    `), faviconPaths[0] || defaultFavicon;
+}, babel = async (_, options) => {
+  let { presets } = options, babelDefault = await presets.apply("babelDefault", {}, options) ?? {}, presetConfig = {
+    targets: {
+      // This is the same browser supports that we use to bundle our manager and preview code.
+      chrome: 100,
+      safari: 15,
+      firefox: 91
+    }
+  };
+  return options?.features && "babelRemoveBugfixes" in options.features && options.features.babelRemoveBugfixes || (presetConfig.bugfixes = !0), {
+    ...babelDefault,
+    // This override makes sure that we will never transpile babel further down then the browsers that storybook supports.
+    // This is needed to support the mount property of the context described here:
+    // https://storybook.js.org/docs/writing-tests/interaction-testing#run-code-before-each-story-in-a-file
+    overrides: [
+      ...babelDefault?.overrides ?? [],
+      {
+        include: /\.(story|stories)\.[cm]?[jt]sx?$/,
+        presets: [["@babel/preset-env", presetConfig]]
+      }
+    ]
+  };
+}, title = (previous, options) => previous || options.packageJson?.name || !1, logLevel = (previous, options) => previous || options.loglevel || "info", previewHead = async (base, { configDir, presets }) => {
+  let interpolations = await presets.apply("env");
+  return getPreviewHeadTemplate(configDir, interpolations);
+}, env = async () => {
+  let { raw } = await loadEnvs({ production: !0 });
+  return raw;
+}, previewBody = async (base, { configDir, presets }) => {
+  let interpolations = await presets.apply("env");
+  return getPreviewBodyTemplate(configDir, interpolations);
+}, typescript = () => ({
+  check: !1
+}), experimental_serverAPI = (extension, options) => {
+  let removeAddon = removeAddonBase, packageManager = JsPackageManagerFactory.getPackageManager({
+    configDir: options.configDir
+  });
+  return removeAddon = async (id, opts) => (await telemetry7("remove", { addon: id, source: "api" }), removeAddonBase(id, { ...opts, packageManager })), { ...extension, removeAddon };
+}, core = async (existing, options) => ({
+  ...existing,
+  channelOptions: {
+    ...existing?.channelOptions ?? {},
+    ...options.configType === "DEVELOPMENT" ? { wsToken: getWsToken() } : {}
+  },
+  disableTelemetry: options.disableTelemetry || optionalEnvToBoolean(process.env.FORKBOOK_DISABLE_TELEMETRY),
+  enableCrashReports: options.enableCrashReports || optionalEnvToBoolean(process.env.FORKBOOK_ENABLE_CRASH_REPORTS)
+}), babelPresetEnvMajor = getBabelPresetEnvMajor(), features = async (existing, options) => ({
+  ...existing,
+  actions: !0,
+  argTypeTargetsV7: !0,
+  babelRemoveBugfixes: babelPresetEnvMajor ? babelPresetEnvMajor >= 8 : !1,
+  backgrounds: !0,
+  componentsManifest: !1,
+  experimentalChunkedPreviewRuntime: !1,
+  controls: !0,
+  disallowImplicitActionsInRenderV8: !0,
+  docgenServer: await options.presets.apply("isDocgenProviderEnabled", !1),
+  highlight: !0,
+  interactions: !0,
+  measure: !0,
+  outline: !0,
+  viewport: !0
+}), csfIndexer = {
+  test: STORY_FILE_TEST_REGEXP,
+  createIndex: async (fileName, options) => {
+    let code = (await readFile(fileName, "utf-8")).toString();
+    return code.trim().length === 0 ? (logger5.debug(`The file ${fileName} is empty. Skipping indexing.`), []) : loadCsf(code, { ...options, fileName }).parse().indexInputs;
+  }
+}, experimental_indexers = (existingIndexers) => [csfIndexer].concat(existingIndexers || []), frameworkOptions = async (_, options) => {
+  let config = await options.presets.apply("framework");
+  return typeof config == "string" ? {} : typeof config > "u" ? null : config.options;
+}, managerHead = async (_, options) => {
+  let location = join4(options.configDir, "manager-head.html");
+  if (existsSync2(location)) {
+    let contents = readFile(location, { encoding: "utf8" }), interpolations = options.presets.apply("env");
+    return interpolate(await contents, await interpolations);
+  }
+  return "";
+}, channelToken = async (value) => value, experimental_serverChannel = async (channel, options) => (initAIAnalyticsChannel(channel, options, () => storyIndexGeneratorPromise), initializeWhatsNew(channel, options), initializeSaveStory(channel, options), initGhostStoriesChannel(channel, options), initOpenInEditorChannel(channel), initTelemetryChannel(channel), channel), resolvedReact = async (existing) => {
+  try {
+    return {
+      ...existing,
+      react: resolvePackageDir("react"),
+      reactDom: resolvePackageDir("react-dom")
+    };
+  } catch {
+    return existing;
+  }
+}, managerEntries = async (existing) => [
+  pathe.join(
+    resolvePackageDir("@aussieljk/forkbook"),
+    "dist/core-server/presets/common-manager.js"
+  ),
+  ...existing || []
+];
+async function getHeadlessChangeDetectionAdapter(options) {
+  try {
+    let core2 = await options.presets.apply("core", {});
+    if (!core2?.builder)
+      return;
+    let resolvedPreviewBuilder = typeof core2.builder == "string" ? core2.builder : core2.builder.name;
+    return await (await getPreviewBuilder(resolvedPreviewBuilder)).changeDetectionAdapter?.(options);
+  } catch (error) {
+    logger5.warn("Change detection: adapter initialisation failed"), logger5.debug(error instanceof Error ? error.stack ?? error.message : String(error));
+    return;
+  }
+}
+var devServerSubscriptions = [];
+globalThis.FORKBOOK_SERVICES_LOADED = globalThis.FORKBOOK_SERVICES_LOADED ?? !1;
+var services = async (_value, options) => {
+  if (globalThis.FORKBOOK_SERVICES_LOADED)
+    throw new OpenServiceServicesAppliedTwiceError();
+  globalThis.FORKBOOK_SERVICES_LOADED = !0;
+  let getIndex = () => options.presets.apply("storyIndexGenerator").then((generator) => generator.getIndex());
+  registerModuleGraphService({
+    channel: options.channel,
+    getIndex,
+    workingDir: process.cwd(),
+    presets: options.presets,
+    getAdapter: () => getHeadlessChangeDetectionAdapter(options),
+    getChangeDetectionReadiness
+  });
+  let features2 = await options.presets.apply("features"), storyIndex = { getIndex }, gitDiffProvider = new GitDiffProvider(process.cwd());
+  if (registerToolset(
+    createStoriesToolset({
+      storyIndex,
+      git: {
+        getRepoRoot: () => gitDiffProvider.getRepoRoot(),
+        getChangedFiles: () => gitDiffProvider.getChangedFiles()
+      },
+      changeStatuses: { getAll: getSyncedStatuses },
+      // Real paths, because git reports the repo root as one; on Windows the cwd can differ in case.
+      storybookDirs: {
+        configDir: realpathSync.native(pathe.resolve(options.configDir)),
+        getStaticDirs: async () => (await options.presets.apply("staticDirs") ?? []).flatMap((staticDir) => {
+          try {
+            return [realpathSync.native(mapStaticDir(staticDir, options.configDir).staticPath)];
+          } catch {
+            return [];
+          }
+        })
+      }
+    })
+  ), registerReviewService({
+    getIndex
+  }), devServerSubscriptions.push(subscribeReviewToModuleGraphChanges), registerToolset(reviewToolset), features2?.docgenServer) {
+    let [docgenDescriptors, storyDocsProvider] = await Promise.all([
+      options.presets.apply("experimental_docgenProvider", []),
+      options.presets.apply(
+        "experimental_storyDocsProvider",
+        async () => {
+        }
+      )
+    ]), docgenWorker = docgenDescriptors.length > 0 ? createDocgenWorkerClient(docgenDescriptors) : void 0;
+    docgenWorker && (registerDocgenService({
+      getIndex,
+      docgenProvider: (input) => docgenWorker.extract(input.entry)
+    }), devServerSubscriptions.push(
+      () => subscribeDocgenToModuleGraphChanges({ getIndex, workingDir: process.cwd() })
+    )), registerStoryDocsService({
+      getIndex,
+      storyDocsProvider
+    }), devServerSubscriptions.push(
+      () => subscribeStoryDocsToModuleGraphChanges({ getIndex, workingDir: process.cwd() })
+    );
+  }
+  let localDocsAccess = createLocalDocsAccess({
+    storyIndex,
+    getManifests: () => loadManifests(options.presets)
+  }), refs = await getRefsFromConfig(options);
+  registerToolset(
+    createDocsToolset(
+      refs.length > 0 ? {
+        sources: createCompositionDocsSources({
+          sources: [{ id: "local", title: "Local" }, ...refs],
+          manifestProvider: sourceUrlManifestProvider,
+          localAccess: localDocsAccess
+        })
+      } : { docsAccess: localDocsAccess }
+    )
+  );
+}, experimental_devServer = async (app, options) => {
+  await applyServicesPresetOnce(options.presets);
+  for (let subscribe of devServerSubscriptions.splice(0))
+    subscribe();
+  return app;
+}, storyIndexGeneratorPromise, storyIndexGenerator = async (_, options) => storyIndexGeneratorPromise || (storyIndexGeneratorPromise = (async () => {
+  let workingDir = process.cwd(), configDir = options.configDir, stories = await options.presets.apply("stories"), normalizedStories = normalizeStories(stories, {
+    configDir,
+    workingDir
+  }), [indexers, docs, features2] = await Promise.all([
+    options.presets.apply("experimental_indexers", []),
+    options.presets.apply("docs"),
+    options.presets.apply("features")
+  ]), generator = new StoryIndexGenerator(normalizedStories, {
+    workingDir,
+    configDir,
+    indexers,
+    docs,
+    features: features2,
+    storySorts: await options.presets.apply("storySorts", [])
+  });
+  return await generator.initialize(), generator;
+})(), storyIndexGeneratorPromise);
+export {
+  babel,
+  channelToken,
+  core,
+  csfIndexer,
+  env,
+  experimental_devServer,
+  experimental_indexers,
+  experimental_serverAPI,
+  experimental_serverChannel,
+  favicon,
+  features,
+  frameworkOptions,
+  logLevel,
+  managerEntries,
+  managerHead,
+  previewBody,
+  previewHead,
+  resolvedReact,
+  services,
+  staticDirs,
+  storyIndexGenerator,
+  title,
+  typescript
+};