@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_node-chunks/chunk-UMUBKI6E.js

@@ -0,0 +1,3787 @@
+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 {
+  require_dist
+} from "./chunk-JGGFYIG5.js";
+import {
+  cache,
+  up as up3
+} from "./chunk-UVINFLGY.js";
+import {
+  FORKBOOK_PACKAGE_PATTERNS,
+  FORKBOOK_RERUN_INSTRUCTION,
+  JsPackageManager,
+  defaultConfigDir,
+  extractFrameworkPackageName,
+  frameworkPackages,
+  getAddonNames,
+  getAgeInMinutes,
+  getConfigInfo,
+  getErrorLogs,
+  getInterpretedFile,
+  getLatestStableVersionAdheringToMinimumAgeGate,
+  getPrettyPackageManagerName,
+  getStorybookRerunCommand,
+  hasStorybookMinimumAgeExclusions,
+  loadMainConfig,
+  normalizeAddonName,
+  parsePackageData,
+  parsePackageTimeMap,
+  parsePositiveIntegerConfigValue,
+  parseReleaseTime,
+  validateConfigurationFiles,
+  versions_default,
+  withForkbookFramework
+} from "./chunk-GRBLDJCR.js";
+import {
+  createModuleResolver,
+  isSelfContained,
+  parseReferenceModule,
+  resolveReferencedValue,
+  sourceOf,
+  unwrapExpression
+} from "./chunk-YZFWBA5L.js";
+import {
+  stripJsonComments
+} from "./chunk-SIEXZVCR.js";
+import {
+  logger
+} from "./chunk-6LMWA44H.js";
+import {
+  STORY_FILE_TEST_REGEXP,
+  execa,
+  execaCommandSync,
+  execaNode,
+  getStoryImportPathFromEntry
+} from "./chunk-MK2KYAI6.js";
+import {
+  BUN_LOCKFILE,
+  BUN_LOCKFILE_BINARY,
+  NPM_LOCKFILE,
+  PNPM_LOCKFILE,
+  YARN_LOCKFILE,
+  getProjectRoot,
+  normalizeStoryPath,
+  require_picomatch
+} from "./chunk-SLWQNBGO.js";
+import {
+  any,
+  from,
+  up,
+  up2
+} from "./chunk-JDXXX6LB.js";
+import {
+  importModule,
+  resolveModulePath,
+  resolvePackageDir,
+  safeResolveModule
+} from "./chunk-F3ZFKBHY.js";
+import {
+  jsModuleExtensions,
+  jsTsSourceExtensions
+} from "./chunk-TNJIXE37.js";
+import {
+  ExecaCommandFailedError,
+  PackageInstallDependencyConflictError,
+  PackageInstallFailedError,
+  PackageInstallMissingManifestError,
+  PackageManagerBinaryNotFoundError,
+  PlaywrightInstallFailedError,
+  PnpmIgnoredBuildsError,
+  PnpmNoTtyModulesDirError,
+  StorybookError
+} from "./chunk-U5W53R2J.js";
+import {
+  require_picocolors
+} from "./chunk-2BUPBPFB.js";
+import {
+  slash
+} from "./chunk-DC7DKR5K.js";
+import {
+  globSync
+} from "./chunk-ZMAMXQKP.js";
+import {
+  __toESM
+} from "./chunk-CXRU72ET.js";
+
+// src/common/presets.ts
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+import { CriticalPresetLoadError } from "@aussieljk/forkbook/internal/server-errors";
+import { readFileSync } from "node:fs";
+import { isAbsolute, join, parse, resolve } from "pathe";
+import { dedent } from "ts-dedent";
+
+// src/common/utils/strip-abs-node-modules-path.ts
+import { posix, sep } from "node:path";
+function normalizePath(id) {
+  return posix.normalize(slash(id));
+}
+function stripAbsNodeModulesPath(absPath) {
+  let splits = absPath.split(`node_modules${sep}`);
+  return normalizePath(splits[splits.length - 1]);
+}
+
+// src/common/presets.ts
+var isObject = (val) => val != null && typeof val == "object" && Array.isArray(val) === !1, isFunction = (val) => typeof val == "function";
+function resolvePresetFunction(input, presetOptions, storybookOptions) {
+  return isFunction(input) ? [...input({ ...storybookOptions, ...presetOptions })] : Array.isArray(input) ? [...input] : [];
+}
+function readAddonManifest(dir) {
+  try {
+    let { name, exports } = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    return { name: typeof name == "string" && name !== "" ? name : void 0, exports };
+  } catch {
+    return;
+  }
+}
+var resolveAddonName = (configDir, name, options) => {
+  let resolved = safeResolveModule({ specifier: name, parent: configDir });
+  if (resolved && parse(name).name === "preset")
+    return {
+      type: "presets",
+      name: resolved
+    };
+  let manifest = isAbsolute(name) ? readAddonManifest(name) : void 0, exportsSpecifier = manifest?.exports ? manifest.name : void 0, resolveEntryFile = (entry) => (exportsSpecifier ? safeResolveModule({ specifier: `${exportsSpecifier}/${entry}`, parent: name }) : void 0) ?? safeResolveModule({ specifier: join(name, entry), parent: configDir }), presetFile = resolveEntryFile("preset"), managerFile = resolveEntryFile("manager"), previewFile = resolveEntryFile("preview");
+  if (managerFile || previewFile || presetFile) {
+    let previewAnnotations = [];
+    if (previewFile) {
+      let parsedPreviewFile = stripAbsNodeModulesPath(previewFile);
+      parsedPreviewFile !== previewFile ? previewAnnotations.push({
+        bare: parsedPreviewFile,
+        absolute: previewFile
+      }) : previewAnnotations.push(previewFile);
+    }
+    return {
+      type: "virtual",
+      name,
+      presets: presetFile ? [{ name: presetFile, options }] : [],
+      managerEntries: managerFile ? [managerFile] : [],
+      previewAnnotations
+    };
+  }
+  if (resolved)
+    return {
+      type: "presets",
+      name: resolved
+    };
+}, map = ({ configDir }) => (item) => {
+  let options = isObject(item) && item.options || void 0, name = isObject(item) ? item.name : item, resolved;
+  try {
+    resolved = resolveAddonName(configDir, name, options);
+  } catch {
+    logger2.error(
+      `Addon value should end in /manager or /preview or /register OR it should be a valid preset https://storybook.js.org/docs/addons/writing-presets/
+${item}`
+    );
+    return;
+  }
+  if (!resolved) {
+    let packageName = isAbsolute(name) ? readAddonManifest(name)?.name : void 0;
+    logger2.warn(
+      packageName ? dedent`
+              Could not resolve addon "${packageName}", skipping.
+              It is installed at ${name}, but none of its preset, manager or preview entry points could be resolved.
+              If your main config wraps it in getAbsolutePath(), try referencing "${packageName}" directly instead.
+            ` : `Could not resolve addon "${name}", skipping. Is it installed?`
+    );
+    return;
+  }
+  return {
+    ...options ? { options } : {},
+    ...resolved
+  };
+};
+async function getContent(input, configDir) {
+  if (input.type === "virtual") {
+    let { type, name: name2, ...rest } = input;
+    return rest;
+  }
+  let name = input.name ? input.name : input;
+  return importModule(safeResolveModule({ specifier: name, parent: configDir }) ?? name);
+}
+async function loadPreset(input, level, storybookOptions) {
+  let presetName = input.name ? input.name : input;
+  try {
+    let presetOptions = input.options ? input.options : {}, contents = await getContent(input, storybookOptions.configDir);
+    if (typeof contents == "function" && (contents = contents(storybookOptions, presetOptions)), Array.isArray(contents))
+      return await loadPresets(contents, level + 1, storybookOptions);
+    if (isObject(contents)) {
+      let {
+        addons: addonsInput = [],
+        presets: presetsInput = [],
+        ...rest
+      } = withForkbookFramework(contents), filter = (i) => !0;
+      storybookOptions.isCritical !== !0 && (storybookOptions.build?.test?.disabledAddons?.length || 0) > 0 && (filter = (i) => {
+        let name = i.name ? i.name : i;
+        return !storybookOptions.build?.test?.disabledAddons?.find((n) => name.includes(n));
+      });
+      let subPresets = resolvePresetFunction(
+        presetsInput,
+        presetOptions,
+        storybookOptions
+      ).filter(filter), subAddons = resolvePresetFunction(addonsInput, presetOptions, storybookOptions).filter(
+        filter
+      );
+      return [
+        ...await loadPresets([...subPresets], level + 1, storybookOptions),
+        ...await loadPresets(
+          [...subAddons.map(map(storybookOptions))].filter(Boolean),
+          level + 1,
+          storybookOptions
+        ),
+        {
+          name: presetName,
+          preset: rest,
+          options: presetOptions
+        }
+      ];
+    }
+    throw new Error(dedent`
+      ${input} is not a valid preset
+    `);
+  } catch (error) {
+    if (storybookOptions?.isCritical)
+      throw new CriticalPresetLoadError({
+        error,
+        presetName
+      });
+    let warning = level > 0 ? `  Failed to load preset: ${JSON.stringify(input)} on level ${level}` : `  Failed to load preset: ${JSON.stringify(input)}`;
+    return logger2.warn(warning), logger2.error(error), [];
+  }
+}
+async function loadPresets(presets, level, storybookOptions) {
+  return !presets || !Array.isArray(presets) || !presets.length ? [] : (await Promise.all(
+    presets.map(async (preset) => loadPreset(preset, level, storybookOptions))
+  )).reduce((acc, loaded) => acc.concat(loaded), []);
+}
+function applyPresets(presets, extension, config, args, storybookOptions) {
+  let presetResult = new Promise((res) => res(config));
+  return presets.length ? presets.reduce((accumulationPromise, { preset, options }) => {
+    let change = preset[extension];
+    if (!change)
+      return accumulationPromise;
+    if (typeof change == "function") {
+      let extensionFn = change, context = {
+        preset,
+        combinedOptions: {
+          ...storybookOptions,
+          ...args,
+          ...options,
+          presetsList: presets,
+          presets: {
+            apply: async (ext, c, a = {}) => applyPresets(presets, ext, c, a, storybookOptions)
+          }
+        }
+      };
+      return accumulationPromise.then(
+        (newConfig) => extensionFn.call(context.preset, newConfig, context.combinedOptions)
+      );
+    }
+    return accumulationPromise.then((newConfig) => Array.isArray(newConfig) && Array.isArray(change) ? [...newConfig, ...change] : isObject(newConfig) && isObject(change) ? { ...newConfig, ...change } : change);
+  }, presetResult) : presetResult;
+}
+async function getPresets(presets, storybookOptions) {
+  let loadedPresets = await loadPresets(presets, 0, storybookOptions);
+  return {
+    apply: async (extension, config, args = {}) => applyPresets(loadedPresets, extension, config, args, storybookOptions)
+  };
+}
+async function loadAllPresets(options) {
+  let { corePresets = [], overridePresets = [], ...restOptions } = options;
+  validateConfigurationFiles(options.configDir);
+  let mainUrl = getInterpretedFile(resolve(options.configDir, "main")), presetsConfig = [...corePresets, mainUrl, ...overridePresets];
+  return getPresets(presetsConfig, restOptions);
+}
+
+// src/common/utils/file-cache.ts
+import { createHash, randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/common/utils/write-file-with-retry.ts
+import { writeFile } from "node:fs/promises";
+async function writeFileWithRetry(file, data, options) {
+  for (let attempt = 1; attempt <= 5; attempt++)
+    try {
+      await writeFile(file, data, options);
+      return;
+    } catch (err) {
+      if (attempt < 5 && err instanceof Error && "code" in err && err.code === "EBUSY")
+        await new Promise((resolve7) => setTimeout(resolve7, 100));
+      else
+        throw err;
+    }
+}
+
+// src/common/utils/file-cache.ts
+var FileSystemCache = class {
+  constructor(options = {}) {
+    this.prefix = (options.ns || options.prefix || "") + "-", this.hash_alg = options.hash_alg || "sha256", this.cache_dir = options.basePath || join2(tmpdir(), randomBytes(15).toString("base64").replace(/\//g, "-")), this.ttl = options.ttl || 0, createHash(this.hash_alg), mkdirSync(this.cache_dir, { recursive: !0 });
+  }
+  generateHash(name) {
+    return join2(this.cache_dir, this.prefix + createHash(this.hash_alg).update(name).digest("hex"));
+  }
+  isExpired(parsed, now) {
+    return parsed.ttl != null && now > parsed.ttl;
+  }
+  parseCacheData(data, fallback) {
+    let parsed = JSON.parse(data);
+    return this.isExpired(parsed, Date.now()) ? fallback : parsed.content;
+  }
+  parseSetData(key, data, opts = {}) {
+    let ttl = opts.ttl ?? this.ttl;
+    return JSON.stringify({ key, content: data, ...ttl && { ttl: Date.now() + ttl * 1e3 } });
+  }
+  async get(name, fallback) {
+    try {
+      let data = await readFile(this.generateHash(name), "utf8");
+      return this.parseCacheData(data, fallback);
+    } catch {
+      return fallback;
+    }
+  }
+  getSync(name, fallback) {
+    try {
+      let data = readFileSync2(this.generateHash(name), "utf8");
+      return this.parseCacheData(data, fallback);
+    } catch {
+      return fallback;
+    }
+  }
+  async set(name, data, orgOpts = {}) {
+    let opts = typeof orgOpts == "number" ? { ttl: orgOpts } : orgOpts;
+    await mkdir(this.cache_dir, { recursive: !0 }), await writeFileWithRetry(this.generateHash(name), this.parseSetData(name, data, opts), {
+      encoding: opts.encoding || "utf8"
+    });
+  }
+  setSync(name, data, orgOpts = {}) {
+    let opts = typeof orgOpts == "number" ? { ttl: orgOpts } : orgOpts;
+    mkdirSync(this.cache_dir, { recursive: !0 }), writeFileSync(this.generateHash(name), this.parseSetData(name, data, opts), {
+      encoding: opts.encoding || "utf8"
+    });
+  }
+  async setMany(items, options) {
+    await Promise.all(items.map((item) => this.set(item.key, item.content ?? item.value, options)));
+  }
+  setManySync(items, options) {
+    items.forEach((item) => this.setSync(item.key, item.content ?? item.value, options));
+  }
+  async remove(name) {
+    await rm(this.generateHash(name), { force: !0 });
+  }
+  removeSync(name) {
+    rmSync(this.generateHash(name), { force: !0 });
+  }
+  async clear() {
+    let files = await readdir(this.cache_dir);
+    await Promise.all(
+      files.filter((f) => f.startsWith(this.prefix)).map((f) => rm(join2(this.cache_dir, f), { force: !0 }))
+    );
+  }
+  clearSync() {
+    readdirSync(this.cache_dir).filter((f) => f.startsWith(this.prefix)).forEach((f) => rmSync(join2(this.cache_dir, f), { force: !0 }));
+  }
+  async getAll() {
+    let now = Date.now(), files = await readdir(this.cache_dir);
+    return (await Promise.all(
+      files.filter((f) => f.startsWith(this.prefix)).map((f) => readFile(join2(this.cache_dir, f), "utf8"))
+    )).map((data) => JSON.parse(data)).filter((entry) => entry.content && !this.isExpired(entry, now));
+  }
+  async load() {
+    return {
+      files: (await this.getAll()).map((entry) => ({
+        path: this.generateHash(entry.key),
+        value: entry.content,
+        key: entry.key
+      }))
+    };
+  }
+};
+function createFileSystemCache(options) {
+  return new FileSystemCache(options);
+}
+
+// src/common/utils/resolve-path-in-sb-cache.ts
+import { join as join3 } from "node:path";
+function resolvePathInStorybookCache(fileOrDirectoryName, sub = "default") {
+  let cacheDirectory = cache("storybook");
+  cacheDirectory ||= join3(process.cwd(), "node_modules", ".cache", "storybook");
+  let version = versions_default["@aussieljk/forkbook"] || "unknown";
+  return join3(cacheDirectory, version, sub, fileOrDirectoryName);
+}
+
+// src/common/utils/cache.ts
+var cache2 = createFileSystemCache({
+  basePath: resolvePathInStorybookCache("dev-server"),
+  ns: "storybook"
+  // Optional. A grouping namespace for items.
+});
+
+// src/common/utils/cli.ts
+import { createWriteStream, mkdirSync as mkdirSync2 } from "node:fs";
+import { copyFile, readFile as readFile2, realpath, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import os from "node:os";
+import { join as join4 } from "node:path";
+
+// ../../node_modules/crypto-random-string/index.js
+import { promisify } from "util";
+import crypto from "crypto";
+var randomBytesAsync = promisify(crypto.randomBytes), urlSafeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".split(""), numericCharacters = "0123456789".split(""), distinguishableCharacters = "CDEHKMPRTUWXY012458".split(""), asciiPrintableCharacters = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~".split(""), alphanumericCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split(""), generateForCustomCharacters = (length, characters) => {
+  let characterCount = characters.length, maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1, entropyLength = 2 * Math.ceil(1.1 * length), string = "", stringLength = 0;
+  for (; stringLength < length; ) {
+    let entropy = crypto.randomBytes(entropyLength), entropyPosition = 0;
+    for (; entropyPosition < entropyLength && stringLength < length; ) {
+      let entropyValue = entropy.readUInt16LE(entropyPosition);
+      entropyPosition += 2, !(entropyValue > maxValidSelector) && (string += characters[entropyValue % characterCount], stringLength++);
+    }
+  }
+  return string;
+}, generateForCustomCharactersAsync = async (length, characters) => {
+  let characterCount = characters.length, maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1, entropyLength = 2 * Math.ceil(1.1 * length), string = "", stringLength = 0;
+  for (; stringLength < length; ) {
+    let entropy = await randomBytesAsync(entropyLength), entropyPosition = 0;
+    for (; entropyPosition < entropyLength && stringLength < length; ) {
+      let entropyValue = entropy.readUInt16LE(entropyPosition);
+      entropyPosition += 2, !(entropyValue > maxValidSelector) && (string += characters[entropyValue % characterCount], stringLength++);
+    }
+  }
+  return string;
+}, generateRandomBytes = (byteLength, type, length) => crypto.randomBytes(byteLength).toString(type).slice(0, length), generateRandomBytesAsync = async (byteLength, type, length) => (await randomBytesAsync(byteLength)).toString(type).slice(0, length), allowedTypes = /* @__PURE__ */ new Set([
+  void 0,
+  "hex",
+  "base64",
+  "url-safe",
+  "numeric",
+  "distinguishable",
+  "ascii-printable",
+  "alphanumeric"
+]), createGenerator = (generateForCustomCharacters2, generateRandomBytes2) => ({ length, type, characters }) => {
+  if (!(length >= 0 && Number.isFinite(length)))
+    throw new TypeError("Expected a `length` to be a non-negative finite number");
+  if (type !== void 0 && characters !== void 0)
+    throw new TypeError("Expected either `type` or `characters`");
+  if (characters !== void 0 && typeof characters != "string")
+    throw new TypeError("Expected `characters` to be string");
+  if (!allowedTypes.has(type))
+    throw new TypeError(`Unknown type: ${type}`);
+  if (type === void 0 && characters === void 0 && (type = "hex"), type === "hex" || type === void 0 && characters === void 0)
+    return generateRandomBytes2(Math.ceil(length * 0.5), "hex", length);
+  if (type === "base64")
+    return generateRandomBytes2(Math.ceil(length * 0.75), "base64", length);
+  if (type === "url-safe")
+    return generateForCustomCharacters2(length, urlSafeCharacters);
+  if (type === "numeric")
+    return generateForCustomCharacters2(length, numericCharacters);
+  if (type === "distinguishable")
+    return generateForCustomCharacters2(length, distinguishableCharacters);
+  if (type === "ascii-printable")
+    return generateForCustomCharacters2(length, asciiPrintableCharacters);
+  if (type === "alphanumeric")
+    return generateForCustomCharacters2(length, alphanumericCharacters);
+  if (characters.length === 0)
+    throw new TypeError("Expected `characters` string length to be greater than or equal to 1");
+  if (characters.length > 65536)
+    throw new TypeError("Expected `characters` string length to be less or equal to 65536");
+  return generateForCustomCharacters2(length, characters.split(""));
+}, cryptoRandomString = createGenerator(generateForCustomCharacters, generateRandomBytes);
+cryptoRandomString.async = createGenerator(generateForCustomCharactersAsync, generateRandomBytesAsync);
+var crypto_random_string_default = cryptoRandomString;
+
+// ../../node_modules/unique-string/index.js
+function uniqueString() {
+  return crypto_random_string_default({ length: 32 });
+}
+
+// src/common/satellite-addons.ts
+var satellite_addons_default = [
+  "@storybook/addon-coverage",
+  // Storybook for React Native related packages
+  "@storybook/addon-ondevice-actions",
+  "@storybook/addon-ondevice-backgrounds",
+  "@storybook/addon-ondevice-controls",
+  "@storybook/addon-ondevice-notes",
+  "@storybook/react-native"
+];
+
+// src/common/utils/cli.ts
+var tempDir = () => realpath(os.tmpdir()), getPath = async (prefix = "") => join4(await tempDir(), prefix + uniqueString());
+async function temporaryDirectory({ prefix = "" } = {}) {
+  let directory = await getPath(prefix);
+  return mkdirSync2(directory), directory;
+}
+async function temporaryFile({ name, extension } = {}) {
+  if (name) {
+    if (extension != null)
+      throw new Error("The `name` and `extension` options are mutually exclusive");
+    return join4(await temporaryDirectory(), name);
+  }
+  return await getPath() + (extension == null ? "" : "." + extension.replace(/^\./, ""));
+}
+function parseList(str) {
+  return str.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function getEnvConfig(program, configEnv) {
+  Object.keys(configEnv).forEach((fieldName) => {
+    let envVarName = configEnv[fieldName], envVarValue = process.env[envVarName];
+    envVarValue && (program[fieldName] = envVarValue);
+  });
+}
+var createLogStream = async (logFileName = "storybook.log") => {
+  let finalLogPath = join4(process.cwd(), logFileName), temporaryLogPath = await temporaryFile({ name: logFileName }), logStream = createWriteStream(temporaryLogPath, { encoding: "utf8" });
+  return new Promise((resolve7, reject) => {
+    logStream.once("open", () => {
+      let clearLogFile = async () => writeFile2(temporaryLogPath, ""), removeLogFile = async () => rm2(temporaryLogPath, { recursive: !0, force: !0 });
+      resolve7({ logStream, moveLogFile: async () => copyFile(temporaryLogPath, finalLogPath).then(removeLogFile), clearLogFile, removeLogFile, readLogFile: async () => readFile2(temporaryLogPath, { encoding: "utf8" }) });
+    }), logStream.once("error", reject);
+  });
+}, isCorePackage = (pkg) => pkg === "@aussieljk/forkbook" || pkg.startsWith("@aussieljk/forkbook/"), isSatelliteAddon = (pkg) => satellite_addons_default.includes(pkg);
+
+// src/common/utils/check-addon-order.ts
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+var predicateFor = (addon) => (entry) => {
+  let name = entry.name || entry;
+  return name && name.replaceAll(/(\\){1,2}/g, "/").includes(addon);
+}, isCorrectOrder = (addons, before, after) => {
+  let essentialsIndex = addons.findIndex(predicateFor("@storybook/addon-essentials")), beforeIndex = addons.findIndex(predicateFor(before.name)), afterIndex = addons.findIndex(predicateFor(after.name));
+  return beforeIndex === -1 && before.inEssentials && (beforeIndex = essentialsIndex), afterIndex === -1 && after.inEssentials && (afterIndex = essentialsIndex), beforeIndex !== -1 && afterIndex !== -1 && beforeIndex <= afterIndex;
+}, checkAddonOrder = async ({ before, after, configFile, getConfig }) => {
+  try {
+    let config = await getConfig(configFile);
+    if (!config?.addons) {
+      logger3.warn("Unable to find 'addons' config in main Forkbook config");
+      return;
+    }
+    if (!isCorrectOrder(config.addons, before, after)) {
+      let orEssentials = " (or '@storybook/addon-essentials')", beforeText = `'${before.name}'${before.inEssentials ? orEssentials : ""}`, afterText = `'${after.name}'${after.inEssentials ? orEssentials : ""}`;
+      logger3.warn(
+        `Expected ${beforeText} to be listed before ${afterText} in main Forkbook config.`
+      );
+    }
+  } catch {
+    logger3.warn(`Unable to load config file: ${configFile}`);
+  }
+};
+
+// src/common/utils/find-storybook-package-root.ts
+import { readFileSync as readFileSync3, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join as join5, normalize } from "pathe";
+var ownDir = normalize(dirname(fileURLToPath(import.meta.url)));
+function findStorybookPackageRoot() {
+  let dir = ownDir;
+  for (; ; ) {
+    if (readManifestName(dir) === "@aussieljk/forkbook")
+      try {
+        return normalize(realpathSync(dir));
+      } catch {
+        return;
+      }
+    let parent = dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+function readManifestName(dir) {
+  try {
+    let manifest = JSON.parse(readFileSync3(join5(dir, "package.json"), "utf-8"));
+    return typeof manifest.name == "string" ? manifest.name : void 0;
+  } catch {
+    return;
+  }
+}
+
+// src/common/utils/common-glob-options.ts
+var NODE_MODULES_RE = /node_modules/, commonGlobOptions = (glob) => NODE_MODULES_RE.test(glob) ? {} : { ignore: ["**/node_modules/**"] };
+
+// src/common/utils/deep-merge.ts
+function deepMerge(target, source) {
+  let result = { ...target };
+  for (let key in source)
+    source[key] !== void 0 && source[key] !== null && (typeof source[key] == "object" && !Array.isArray(source[key]) && typeof target[key] == "object" && !Array.isArray(target[key]) && target[key] !== null ? result[key] = deepMerge(target[key], source[key]) : result[key] = source[key]);
+  return result;
+}
+
+// src/common/utils/get-builder-options.ts
+async function getBuilderOptions(options) {
+  let framework = await options.presets.apply("framework", {}, options);
+  if (typeof framework != "string" && framework?.options?.builder)
+    return framework.options.builder;
+  let { builder } = await options.presets.apply("core", {}, options);
+  return typeof builder != "string" && builder?.options ? builder.options : {};
+}
+
+// src/common/utils/get-storybook-version-specifier-from-ancestry.ts
+var PKG_PR_NEW_CLI_SPECIFIER_IN_TEXT_RE = /https?:\/\/[^/\s'"]*pkg\.pr\.new\/(?:[^@\s/]+\/[^@\s/]+\/)?(?:create-storybook|storybook)@[^\s'"]+/, PACKAGE_AT_SPECIFIER_RE = /\s(?:create-storybook|storybook)@([^\s'"]+)/, stripQuotedUrls = (command) => command.replace(/['"](https?:\/\/[^'"]+)['"]/g, "$1"), getStorybookVersionSpecifierFromAncestry = (ancestry) => {
+  for (let ancestor of ancestry.toReversed()) {
+    let command = ancestor.command;
+    if (!command)
+      continue;
+    let normalized = stripQuotedUrls(command), pkgPrNewMatch = normalized.match(PKG_PR_NEW_CLI_SPECIFIER_IN_TEXT_RE);
+    if (pkgPrNewMatch)
+      return pkgPrNewMatch[0];
+    let packageAtMatch = normalized.match(PACKAGE_AT_SPECIFIER_RE);
+    if (packageAtMatch)
+      return packageAtMatch[1];
+  }
+};
+
+// src/common/utils/resolve-storybook-version-specifier.ts
+var FORKBOOK_VERSION_SPECIFIER_ENV = "FORKBOOK_VERSION_SPECIFIER", resolveStorybookVersionSpecifier = (ancestry = [], env = process.env) => {
+  let fromEnv = env[FORKBOOK_VERSION_SPECIFIER_ENV]?.trim();
+  return fromEnv || getStorybookVersionSpecifierFromAncestry(ancestry);
+};
+
+// src/common/utils/get-storybook-refs.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+
+// src/common/utils/read-dependency-manifest.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join6 } from "node:path";
+import { logger as logger4 } from "@aussieljk/forkbook/internal/node-logger";
+var readDependencyManifest = async (directory, dependency) => {
+  let subpath = from(directory, join6(dependency, "package.json"), !0);
+  if (subpath)
+    try {
+      let manifest = JSON.parse(await readFile3(subpath, { encoding: "utf8" }));
+      if (manifest?.name)
+        return manifest;
+    } catch {
+    }
+  let entry = from(directory, dependency, !0);
+  if (!entry) {
+    logger4.debug(`readDependencyManifest: could not resolve "${dependency}"`);
+    return;
+  }
+  let dir = dirname2(entry);
+  for (; ; ) {
+    try {
+      let manifest = JSON.parse(await readFile3(join6(dir, "package.json"), { encoding: "utf8" }));
+      if (manifest?.name)
+        return manifest;
+    } catch {
+    }
+    let parent = dirname2(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+};
+
+// src/common/utils/get-storybook-refs.ts
+var getAutoRefs = async (options) => {
+  let location = up3({ cwd: options.configDir, last: getProjectRoot() });
+  if (!location)
+    return {};
+  let directory = dirname3(location), { dependencies = [], devDependencies = [] } = JSON.parse(await readFile4(location, { encoding: "utf8" })) || {}, deps = Object.keys({ ...dependencies, ...devDependencies });
+  return (await Promise.all(
+    deps.map(async (d) => {
+      let manifest = await readDependencyManifest(directory, d);
+      if (manifest?.storybook?.url)
+        return { id: manifest.name, ...manifest.storybook, version: manifest.version };
+    })
+  )).filter(Boolean).reduce(
+    (acc, cur) => ({
+      ...acc,
+      [cur.id]: {
+        id: cur.id.toLowerCase(),
+        url: stripTrailingSlash(cur.url),
+        title: cur.title,
+        version: cur.version
+      }
+    }),
+    {}
+  );
+}, checkRef = async (url) => {
+  try {
+    let { ok, status } = await fetch(`${url}/iframe.html`);
+    if (!ok || status !== 200)
+      return !1;
+    let data = await fetch(`${url}/iframe.html`, {
+      headers: { Accept: "application/json" }
+    });
+    return data.ok ? !(await data.json().catch(() => ({}))).loginUrl : !0;
+  } catch {
+    return !1;
+  }
+}, stripTrailingSlash = (url) => url.replace(/\/$/, ""), toTitle = (input) => {
+  let result = input.replace(/[A-Z]/g, (f) => ` ${f}`).replace(/[-_][A-Z]/gi, (f) => ` ${f.toUpperCase()}`).replace(/-/g, " ").replace(/_/g, " ");
+  return `${result.substring(0, 1).toUpperCase()}${result.substring(1)}`.trim();
+};
+async function getRefs(options) {
+  if (options.test)
+    return {};
+  let refs = await options.presets.apply("refs", await getAutoRefs(options));
+  return Object.entries(refs).forEach(([key, value]) => {
+    if (value.disable) {
+      delete refs[key];
+      return;
+    }
+    refs[key.toLowerCase()] = {
+      ...value,
+      id: key.toLowerCase(),
+      title: value.title || toTitle(value.id || key),
+      url: stripTrailingSlash(value.url)
+    };
+  }), await Promise.all(
+    Object.entries(refs).map(async ([k, value]) => {
+      let ok = await checkRef(value.url);
+      refs[k] = { ...value, type: ok ? "server-checked" : "unknown" };
+    })
+  ), refs;
+}
+
+// src/common/utils/glob-to-regexp.ts
+var pico = __toESM(require_picomatch(), 1);
+function globToRegexp(glob) {
+  let regex = pico.makeRe(glob, {
+    fastpaths: !1,
+    noglobstar: !1,
+    bash: !1
+  });
+  if (!regex.source.startsWith("^"))
+    throw new Error(`Invalid glob: >> ${glob} >> ${regex}`);
+  return glob.startsWith("./") ? new RegExp(
+    ["^\\.", glob.startsWith("./**") ? "" : "[\\\\/]", regex.source.substring(1)].join("")
+  ) : regex;
+}
+
+// src/common/utils/interpolate.ts
+var interpolate = (template, bindings) => Object.entries(bindings).reduce((acc, [k, v]) => {
+  let escapedString = v.replace(/\\/g, "/").replace(/\$/g, "$$$");
+  return acc.replace(new RegExp(`{{${k}}}`, "g"), escapedString);
+}, template);
+
+// src/common/utils/load-manager-or-addons-file.ts
+import { resolve as resolve2 } from "node:path";
+import { logger as logger5 } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent as dedent2 } from "ts-dedent";
+function loadManagerOrAddonsFile({ configDir }) {
+  let storybookCustomAddonsPath = getInterpretedFile(resolve2(configDir, "addons")), storybookCustomManagerPath = getInterpretedFile(resolve2(configDir, "manager"));
+  if ((storybookCustomAddonsPath || storybookCustomManagerPath) && logger5.step("Loading custom manager config"), storybookCustomAddonsPath && storybookCustomManagerPath)
+    throw new Error(dedent2`
+      You have both a "addons.js" and a "manager.js", remove the "addons.js" file from your configDir (${resolve2(
+      configDir,
+      "addons"
+    )})`);
+  return storybookCustomManagerPath || storybookCustomAddonsPath;
+}
+
+// src/common/utils/load-preview-or-config-file.ts
+import { resolve as resolve3 } from "node:path";
+import { dedent as dedent3 } from "ts-dedent";
+function loadPreviewOrConfigFile({ configDir }) {
+  let storybookConfigPath = getInterpretedFile(resolve3(configDir, "config")), storybookPreviewPath = getInterpretedFile(resolve3(configDir, "preview"));
+  if (storybookConfigPath && storybookPreviewPath)
+    throw new Error(dedent3`
+      You have both a "config.js" and a "preview.js", remove the "config.js" file from your configDir (${resolve3(
+      configDir,
+      "config"
+    )})`);
+  return storybookPreviewPath || storybookConfigPath;
+}
+
+// src/common/utils/log-config.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+function logConfig(caption, config) {
+  console.log(import_picocolors.default.cyan(String(caption))), console.dir(config, { depth: null });
+}
+
+// src/common/utils/normalize-stories.ts
+var pico2 = __toESM(require_picomatch(), 1);
+import { lstatSync } from "node:fs";
+import { basename, dirname as dirname4, relative, resolve as resolve4 } from "node:path";
+import { InvalidStoriesEntryError } from "@aussieljk/forkbook/internal/server-errors";
+var DEFAULT_TITLE_PREFIX = "", DEFAULT_FILES_PATTERN = "**/*.@(mdx|stories.@(js|jsx|mjs|ts|tsx))", isDirectory = (configDir, entry) => {
+  try {
+    return lstatSync(resolve4(configDir, entry)).isDirectory();
+  } catch {
+    return !1;
+  }
+}, getDirectoryFromWorkingDir = ({
+  configDir,
+  workingDir,
+  directory
+}) => {
+  let directoryFromConfig = resolve4(configDir, directory), directoryFromWorking = relative(workingDir, directoryFromConfig);
+  return normalizeStoryPath(directoryFromWorking);
+}, normalizeStoriesEntry = (entry, { configDir, workingDir, defaultFilesPattern = DEFAULT_FILES_PATTERN }) => {
+  let specifierWithoutMatcher;
+  if (typeof entry == "string") {
+    let globResult = pico2.scan(entry);
+    if (globResult.isGlob) {
+      let directory2 = globResult.prefix + globResult.base, files2 = globResult.glob;
+      specifierWithoutMatcher = {
+        titlePrefix: DEFAULT_TITLE_PREFIX,
+        directory: directory2,
+        files: files2
+      };
+    } else isDirectory(configDir, entry) ? specifierWithoutMatcher = {
+      titlePrefix: DEFAULT_TITLE_PREFIX,
+      directory: entry,
+      files: defaultFilesPattern
+    } : specifierWithoutMatcher = {
+      titlePrefix: DEFAULT_TITLE_PREFIX,
+      directory: dirname4(entry),
+      files: basename(entry)
+    };
+  } else
+    specifierWithoutMatcher = {
+      titlePrefix: DEFAULT_TITLE_PREFIX,
+      files: defaultFilesPattern,
+      ...entry
+    };
+  let files = slash(specifierWithoutMatcher.files), { directory: directoryRelativeToConfig } = specifierWithoutMatcher, directory = slash(
+    getDirectoryFromWorkingDir({
+      configDir,
+      workingDir,
+      directory: directoryRelativeToConfig
+    })
+  ).replace(/\/$/, ""), importPathMatcher = globToRegexp(`${directory}/${files}`);
+  return {
+    ...specifierWithoutMatcher,
+    directory,
+    importPathMatcher
+  };
+}, normalizeStories = (entries, options) => {
+  if (!entries || Array.isArray(entries) && entries.length === 0)
+    throw new InvalidStoriesEntryError();
+  return entries.map((entry) => normalizeStoriesEntry(entry, options));
+};
+
+// src/common/utils/readTemplate.ts
+import { readFile as readFile5 } from "node:fs/promises";
+async function readTemplate(filename) {
+  return readFile5(filename, {
+    encoding: "utf8"
+  });
+}
+
+// src/common/utils/resolve-meta-component.ts
+import { types as t } from "@aussieljk/forkbook/internal/babel";
+var unwrapComponentExpression = (node) => {
+  let unwrapped = unwrapExpression(node);
+  return t.isTSInstantiationExpression(unwrapped) ? unwrapComponentExpression(unwrapped.expression) : unwrapped;
+};
+function createMetaComponentResolver(options = {}) {
+  let resolver = createModuleResolver({
+    extensions: [...options.extensions ?? [], ...jsTsSourceExtensions],
+    mainFields: ["module", "main"],
+    tsconfig: "auto"
+  }), resolveFile = (fromFile, specifier) => {
+    try {
+      return resolver.resolveFileSync(fromFile, specifier);
+    } catch {
+      return;
+    }
+  }, resolveModule = (fromFile, specifier) => {
+    let filePath = resolveFile(fromFile, specifier);
+    return filePath ? parseReferenceModule(filePath) : void 0;
+  }, fromIdentifier = (module, localName) => {
+    let binding = findImport(module.program, localName);
+    if (binding.kind === "unsupported" || binding.kind === "namespace")
+      return { reason: "no-component-import" };
+    if (binding.kind === "local")
+      return { component: { localName, exportName: localName, path: module.filePath } };
+    let { importId, exportName } = binding;
+    return {
+      component: { localName, importId, exportName, path: resolveFile(module.filePath, importId) }
+    };
+  };
+  return function(csf, storyPath) {
+    let node = csf._metaAnnotations.component;
+    if (!node)
+      return { reason: "no-meta-component" };
+    let storyModule = { program: csf._file.path, filePath: storyPath }, expression = unwrapComponentExpression(node);
+    if (t.isIdentifier(expression))
+      return fromIdentifier(storyModule, expression.name);
+    if (t.isMemberExpression(expression) && !expression.computed && t.isIdentifier(expression.object) && t.isIdentifier(expression.property)) {
+      let namespace = findImport(csf._file.path, expression.object.name);
+      if (namespace.kind === "namespace") {
+        let exportName = expression.property.name;
+        return {
+          component: {
+            localName: exportName,
+            importId: namespace.importId,
+            exportName,
+            path: resolveFile(storyPath, namespace.importId)
+          }
+        };
+      }
+    }
+    let referenced = resolveReferencedValue(
+      {
+        ...storyModule,
+        resolveModule,
+        externalize: (n) => isSelfContained(n) ? n : void 0
+      },
+      expression
+    );
+    if (referenced) {
+      let value = unwrapComponentExpression(referenced.node);
+      if (t.isIdentifier(value))
+        return fromIdentifier(referenced.ctx, value.name);
+    }
+    return { reason: "unreadable-component-expression", expression: sourceOf(node) };
+  };
+}
+function findImport(program, localName) {
+  for (let statement of program.get("body"))
+    if (statement.isImportDeclaration())
+      for (let specifier of statement.node.specifiers) {
+        if (specifier.local.name !== localName)
+          continue;
+        if (statement.node.importKind === "type")
+          return { kind: "unsupported" };
+        let importId = statement.node.source.value;
+        return t.isImportNamespaceSpecifier(specifier) ? { kind: "namespace", importId } : t.isImportDefaultSpecifier(specifier) ? { kind: "import", importId, exportName: "default" } : specifier.importKind === "type" ? { kind: "unsupported" } : {
+          kind: "import",
+          importId,
+          exportName: t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value
+        };
+      }
+  return { kind: "local" };
+}
+
+// src/common/utils/subcomponents.ts
+import { types as t2 } from "@aussieljk/forkbook/internal/babel";
+function extractDeclaredSubcomponents(csf) {
+  let rawSubcomponents = unwrapSubcomponentNode(
+    csf._metaAnnotations.subcomponents,
+    csf._ast.program
+  );
+  return !rawSubcomponents || !t2.isObjectExpression(rawSubcomponents) ? [] : rawSubcomponents.properties.flatMap((property) => {
+    if (!t2.isObjectProperty(property))
+      return [];
+    let name = getObjectKeyName(property.key), directComponentName = getComponentExpressionName(property.value), componentExpression = unwrapSubcomponentNode(property.value, csf._ast.program), componentName = getComponentExpressionName(componentExpression) ?? directComponentName;
+    return name && componentName ? [{ name, componentName }] : [];
+  });
+}
+function findVariableInitialization(identifier, program) {
+  for (let node of program.body) {
+    let declaration = (t2.isVariableDeclaration(node) ? node.declarations : t2.isExportNamedDeclaration(node) && t2.isVariableDeclaration(node.declaration) ? node.declaration.declarations : void 0)?.find(
+      (decl) => t2.isVariableDeclarator(decl) && t2.isIdentifier(decl.id) && decl.id.name === identifier
+    );
+    if (declaration?.init && t2.isExpression(declaration.init))
+      return declaration.init;
+  }
+}
+function unwrapSubcomponentNode(node, program, visitedIdentifiers = /* @__PURE__ */ new Set()) {
+  let current = node;
+  for (; current; ) {
+    if (t2.isIdentifier(current)) {
+      if (visitedIdentifiers.has(current.name))
+        return;
+      visitedIdentifiers.add(current.name), current = findVariableInitialization(current.name, program);
+      continue;
+    }
+    if (t2.isParenthesizedExpression(current) || t2.isTSAsExpression(current) || t2.isTSSatisfiesExpression(current) || t2.isTSNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return current;
+  }
+}
+function getObjectKeyName(key) {
+  if (t2.isIdentifier(key))
+    return key.name;
+  if (t2.isStringLiteral(key))
+    return key.value;
+}
+function getComponentExpressionName(node) {
+  if (node) {
+    if (t2.isIdentifier(node))
+      return node.name;
+    if (t2.isMemberExpression(node) && !node.computed) {
+      let objectName = getComponentExpressionName(node.object), propertyName = getComponentExpressionName(node.property);
+      return objectName && propertyName ? `${objectName}.${propertyName}` : void 0;
+    }
+  }
+}
+
+// src/common/utils/remove.ts
+import { readConfig, writeConfig } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger6 } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent as dedent4 } from "ts-dedent";
+async function removeAddon(addon, options) {
+  let { packageManager, skipInstall } = options, { mainConfigPath, configDir } = getConfigInfo(options.configDir);
+  if (typeof configDir > "u")
+    throw new Error(dedent4`
+      Unable to find storybook config directory
+    `);
+  if (!mainConfigPath) {
+    logger6.error("Unable to find storybook main.js config");
+    return;
+  }
+  let main = await readConfig(mainConfigPath);
+  logger6.debug(`Uninstalling ${addon}`), await packageManager.removeDependencies([addon]), skipInstall || await packageManager.installDependencies();
+  try {
+    let entries = (main.getNamesFromPath(["addons"]) ?? []).filter(
+      (name) => normalizeAddonName(name) === addon
+    );
+    entries.length > 0 && (logger6.debug(`Removing '${addon}' from main.js addons field.`), entries.forEach((entry) => main.removeEntryFromArray(["addons"], entry)), await writeConfig(main));
+  } catch (err) {
+    logger6.warn(`Failed to remove '${addon}' from main.js addons field. ${String(err)}`);
+  }
+}
+
+// src/common/utils/symlinks.ts
+function isPreservingSymlinks() {
+  let { NODE_OPTIONS, NODE_PRESERVE_SYMLINKS } = process.env;
+  return !!NODE_PRESERVE_SYMLINKS || NODE_OPTIONS?.includes("--preserve-symlinks");
+}
+
+// src/common/utils/template.ts
+import { existsSync, readFileSync as readFileSync4 } from "node:fs";
+import { join as join7, resolve as resolve5 } from "pathe";
+var interpolate2 = (string, data = {}) => Object.entries(data).reduce((acc, [k, v]) => acc.replace(new RegExp(`%${k}%`, "g"), v), string);
+function getPreviewBodyTemplate(configDirPath, interpolations) {
+  let base = readFileSync4(
+    join7(resolvePackageDir("@aussieljk/forkbook"), "assets/server/base-preview-body.html"),
+    "utf8"
+  ), bodyHtmlPath = resolve5(configDirPath, "preview-body.html"), result = base;
+  return existsSync(bodyHtmlPath) && (result = readFileSync4(bodyHtmlPath, "utf8") + result), interpolate2(result, interpolations);
+}
+function getPreviewHeadTemplate(configDirPath, interpolations) {
+  let base = readFileSync4(
+    join7(resolvePackageDir("@aussieljk/forkbook"), "assets/server/base-preview-head.html"),
+    "utf8"
+  ), headHtmlPath = resolve5(configDirPath, "preview-head.html"), result = base;
+  return existsSync(headHtmlPath) && (result += readFileSync4(headHtmlPath, "utf8")), interpolate2(result, interpolations);
+}
+
+// src/common/utils/tsconfig.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5, statSync } from "node:fs";
+import { basename as basename2, dirname as dirname5, extname, relative as relative2, resolve as resolve6 } from "node:path";
+var import_picomatch = __toESM(require_picomatch(), 1);
+var TSCONFIG_CANDIDATES = ["tsconfig.json", "tsconfig.base.json", "tsconfig.app.json"], DEFAULT_EXCLUDE_PATTERNS = ["node_modules", "bower_components", "jspm_packages"], findTsconfigPath = (cwd) => {
+  let projectRoot = getProjectRoot();
+  for (let candidate of TSCONFIG_CANDIDATES) {
+    let found = up2(candidate, { cwd, last: projectRoot });
+    if (found)
+      return found;
+  }
+}, findTsconfigPathForFile = (cwd, filePath) => {
+  let rootTsconfigPath = findTsconfigPath(cwd);
+  if (!rootTsconfigPath)
+    return;
+  let absoluteFilePath = resolve6(filePath), matchingConfigs = collectTsconfigEntries(rootTsconfigPath, /* @__PURE__ */ new Set()).filter(
+    (entry) => tsconfigIncludesFile(entry, absoluteFilePath)
+  );
+  return matchingConfigs.sort((left, right) => compareTsconfigEntries(absoluteFilePath, left, right)), matchingConfigs[0]?.path ?? rootTsconfigPath;
+}, findTsconfigPathForPath = (path) => isDirectoryPath(path) ? findTsconfigPath(path) : findTsconfigPathForFile(dirname5(path), path), getTsconfigPathsBaseDir = (configPath) => {
+  let normalizedConfigPath = resolve6(configPath), resolved = resolvePathsBase(normalizedConfigPath, /* @__PURE__ */ new Set());
+  return resolved.absoluteBaseUrl ?? resolved.pathsBasePath ?? dirname5(normalizedConfigPath);
+};
+function resolvePathsBase(configPath, seen) {
+  let normalizedConfigPath = resolve6(configPath);
+  if (seen.has(normalizedConfigPath))
+    return {};
+  seen.add(normalizedConfigPath);
+  let config = readTsconfigConfig(normalizedConfigPath);
+  if (!config)
+    return {};
+  let inherited = {};
+  for (let extendsPath of getExtendsPaths(normalizedConfigPath, config)) {
+    let base = resolvePathsBase(extendsPath, seen);
+    inherited = {
+      absoluteBaseUrl: base.absoluteBaseUrl ?? inherited.absoluteBaseUrl,
+      pathsBasePath: base.pathsBasePath ?? inherited.pathsBasePath
+    };
+  }
+  let ownBaseUrl = config.compilerOptions?.baseUrl, ownPaths = config.compilerOptions?.paths;
+  return {
+    absoluteBaseUrl: typeof ownBaseUrl == "string" && ownBaseUrl.length > 0 ? resolve6(dirname5(normalizedConfigPath), ownBaseUrl) : inherited.absoluteBaseUrl,
+    pathsBasePath: ownPaths != null && typeof ownPaths == "object" ? dirname5(normalizedConfigPath) : inherited.pathsBasePath
+  };
+}
+function isDirectoryPath(path) {
+  try {
+    if (existsSync2(path))
+      return statSync(path).isDirectory();
+  } catch {
+  }
+  return extname(path) === "";
+}
+function collectTsconfigEntries(configPath, seen) {
+  let normalizedConfigPath = resolve6(configPath);
+  if (seen.has(normalizedConfigPath))
+    return [];
+  seen.add(normalizedConfigPath);
+  let config = readTsconfigConfig(normalizedConfigPath);
+  return config ? [
+    { path: normalizedConfigPath, config },
+    ...getReferencedTsconfigPaths(normalizedConfigPath, config).flatMap(
+      (referencePath) => collectTsconfigEntries(referencePath, seen)
+    )
+  ] : [];
+}
+function getReferencedTsconfigPaths(configPath, config) {
+  return (Array.isArray(config.references) ? config.references : []).map((reference) => reference.path).filter((referencePath) => typeof referencePath == "string").map((referencePath) => resolve6(dirname5(configPath), referencePath)).flatMap((referencePath) => resolveReferenceConfigPaths(referencePath));
+}
+function resolveReferenceConfigPaths(referencePath) {
+  return referencePath.endsWith(".json") ? [referencePath] : TSCONFIG_CANDIDATES.map((candidate) => resolve6(referencePath, candidate));
+}
+function tsconfigIncludesFile(entry, filePath) {
+  let configDir = dirname5(entry.path), relativeFilePath = normalizePath2(relative2(configDir, filePath));
+  if (relativeFilePath.startsWith("../") || relativeFilePath === ".." || isReferencesShell(entry.config))
+    return !1;
+  let ownership = resolveOwnershipSpec(entry.path, entry.config, /* @__PURE__ */ new Set());
+  if (ownership.files && ownership.files.length > 0) {
+    let normalizedFilePath = normalizePath2(filePath);
+    return ownership.files.some(
+      (candidatePath) => normalizePath2(resolve6(configDir, candidatePath)) === normalizedFilePath
+    );
+  }
+  let includePatterns = getIncludePatterns(ownership, entry.config);
+  if (includePatterns.length === 0)
+    return !1;
+  let excludePatterns = [
+    ...DEFAULT_EXCLUDE_PATTERNS,
+    ...(ownership.exclude ?? []).map(normalizeTsconfigPattern)
+  ];
+  return matchesPatterns(relativeFilePath, excludePatterns) ? !1 : matchesPatterns(relativeFilePath, includePatterns);
+}
+function resolveOwnershipSpec(configPath, config, seen) {
+  let normalizedConfigPath = resolve6(configPath);
+  if (seen.has(normalizedConfigPath))
+    return {};
+  seen.add(normalizedConfigPath);
+  let ownership = {};
+  for (let extendsPath of getExtendsPaths(normalizedConfigPath, config)) {
+    let baseConfig = readTsconfigConfig(extendsPath);
+    if (!baseConfig)
+      continue;
+    let baseOwnership = resolveOwnershipSpec(extendsPath, baseConfig, seen);
+    ownership = mergeOwnershipSpec(
+      ownership,
+      rebaseOwnershipSpec(baseOwnership, dirname5(extendsPath), dirname5(normalizedConfigPath))
+    );
+  }
+  return mergeOwnershipSpec(ownership, ownOwnershipSpec(config));
+}
+function getExtendsPaths(configPath, config) {
+  return (typeof config.extends == "string" ? [config.extends] : Array.isArray(config.extends) ? config.extends.filter((value) => typeof value == "string") : []).map((extendsPath) => resolveExtendsPath(configPath, extendsPath));
+}
+function resolveExtendsPath(configPath, extendsPath) {
+  let resolved = resolve6(dirname5(configPath), extendsPath);
+  if (existsSync2(resolved))
+    return resolved;
+  if (!resolved.endsWith(".json")) {
+    let withJson = `${resolved}.json`;
+    if (existsSync2(withJson))
+      return withJson;
+  }
+  return resolved;
+}
+function ownOwnershipSpec(config) {
+  let ownership = {};
+  return config.files !== void 0 && (ownership.files = asStringArray(config.files).map(normalizePath2)), config.include !== void 0 && (ownership.include = asStringArray(config.include).map(normalizePath2)), config.exclude !== void 0 && (ownership.exclude = asStringArray(config.exclude).map(normalizePath2)), ownership;
+}
+function mergeOwnershipSpec(base, overlay) {
+  return {
+    files: overlay.files !== void 0 ? overlay.files : base.files,
+    include: overlay.include !== void 0 ? overlay.include : base.include,
+    exclude: overlay.exclude !== void 0 ? overlay.exclude : base.exclude
+  };
+}
+function rebaseOwnershipSpec(ownership, fromDir, toDir) {
+  return {
+    files: ownership.files?.map((pattern) => rebasePattern(pattern, fromDir, toDir)),
+    include: ownership.include?.map((pattern) => rebasePattern(pattern, fromDir, toDir)),
+    exclude: ownership.exclude?.map((pattern) => rebasePattern(pattern, fromDir, toDir))
+  };
+}
+function rebasePattern(pattern, fromDir, toDir) {
+  return normalizePath2(relative2(toDir, resolve6(fromDir, pattern)));
+}
+function isReferencesShell(config) {
+  if (!Array.isArray(config.references))
+    return !1;
+  let hasOwnFiles = Array.isArray(config.files) && config.files.length > 0, hasOwnInclude = Array.isArray(config.include) && config.include.length > 0;
+  return !hasOwnFiles && !hasOwnInclude;
+}
+function getIncludePatterns(ownership, leafConfig) {
+  return ownership.include && ownership.include.length > 0 ? ownership.include.map(normalizeTsconfigPattern) : ownership.files && ownership.files.length > 0 ? ownership.files.map(normalizePath2) : Array.isArray(leafConfig.files) && leafConfig.files.length === 0 && !ownership.include ? [] : ["**/*"];
+}
+function compareTsconfigEntries(filePath, left, right) {
+  let leftDir = dirname5(left.path), rightDir = dirname5(right.path), leftDepth = normalizePath2(relative2(leftDir, filePath)).split("/").length, rightDepth = normalizePath2(relative2(rightDir, filePath)).split("/").length;
+  if (leftDepth !== rightDepth)
+    return leftDepth - rightDepth;
+  let leftIsPrimaryTsconfig = basename2(left.path) === "tsconfig.json" ? 1 : 0;
+  return (basename2(right.path) === "tsconfig.json" ? 1 : 0) - leftIsPrimaryTsconfig;
+}
+function readTsconfigConfig(configPath) {
+  try {
+    let content = readFileSync5(configPath, "utf-8");
+    return JSON.parse(stripJsonComments(content, { trailingCommas: !0 }));
+  } catch {
+    return;
+  }
+}
+function matchesPatterns(filePath, patterns) {
+  return patterns.some((pattern) => (0, import_picomatch.default)(pattern, { dot: !0 })(filePath));
+}
+function normalizeTsconfigPattern(pattern) {
+  let normalizedPattern = normalizePath2(pattern);
+  return normalizedPattern.endsWith("/") ? `${normalizedPattern}**/*` : !import_picomatch.default.scan(normalizedPattern).isGlob && !/\.[^/]+$/.test(normalizedPattern) ? `${normalizedPattern}/**/*` : normalizedPattern;
+}
+function normalizePath2(value) {
+  return value.replaceAll("\\", "/");
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item == "string") : [];
+}
+
+// src/common/utils/validate-config.ts
+import {
+  CouldNotEvaluateFrameworkError,
+  InvalidFrameworkNameError,
+  MissingFrameworkFieldError
+} from "@aussieljk/forkbook/internal/server-errors";
+var rendererNames = ["react", "@aussieljk/forkbook/react"];
+function validateFrameworkName(frameworkName) {
+  if (!frameworkName)
+    throw new MissingFrameworkFieldError();
+  if (rendererNames.includes(frameworkName))
+    throw new InvalidFrameworkNameError({ frameworkName });
+  let normalizedFrameworkName = extractFrameworkPackageName(frameworkName);
+  if (!Object.keys(frameworkPackages).includes(normalizedFrameworkName))
+    try {
+      resolveModulePath(`${frameworkName}/preset`, {
+        extensions: [...jsModuleExtensions],
+        conditions: ["node", "import", "require"]
+      });
+    } catch {
+      throw new CouldNotEvaluateFrameworkError({ frameworkName });
+    }
+}
+
+// src/common/utils/babel.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { createRequire } from "node:module";
+import { logger as logger7 } from "@aussieljk/forkbook/internal/node-logger";
+var require2 = createRequire(import.meta.url), getBabelPresetEnvMajor = () => {
+  try {
+    let pkgPath = require2.resolve("@babel/preset-env/package.json"), { version } = JSON.parse(readFileSync6(pkgPath, "utf8")), parsed = Number.parseInt(version, 10);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  } catch {
+    logger7.debug(
+      "Could not determine @babel/preset-env version in use. In case of runtime errors with @babel/preset-env, you may need to set the babelRemoveBugfixes feature flag in your `main.ts` file."
+    );
+    return;
+  }
+};
+
+// src/common/utils/formatter.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
+import { parse as parse2 } from "jsonc-parser";
+import { format } from "oxfmt";
+var CONFIG_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
+async function formatCode(filePath, content, options = {}) {
+  try {
+    let { code, errors } = await format(filePath, content, options);
+    return errors.length > 0 ? content : code;
+  } catch {
+    return content;
+  }
+}
+async function formatFileContent(filePath, content) {
+  let configPath = any(CONFIG_FILES, { cwd: dirname6(filePath) });
+  if (!configPath)
+    return content;
+  let { $schema, ignorePatterns, overrides, ...options } = parse2(
+    readFileSync7(configPath, "utf8")
+  );
+  return formatCode(filePath, content, options);
+}
+
+// src/common/utils/get-story-id.ts
+import { relative as relative3 } from "node:path";
+import { normalizeStories as normalizeStories2, normalizeStoryPath as normalizeStoryPath2 } from "@aussieljk/forkbook/internal/common";
+import { sanitize as sanitize2, storyNameFromExport, toId } from "@aussieljk/forkbook/internal/csf/csf-utils";
+import { dedent as dedent5 } from "ts-dedent";
+
+// src/shared/story-index/autoTitle.ts
+var sanitize = (parts) => {
+  if (parts.length === 0)
+    return parts;
+  let last = parts[parts.length - 1], lastStripped = last?.replace(/(?:[.](?:story|stories))?([.][^.]+)$/i, "");
+  if (parts.length === 1)
+    return [lastStripped];
+  let nextToLast = parts[parts.length - 2];
+  return lastStripped && nextToLast && lastStripped.toLowerCase() === nextToLast.toLowerCase() ? [...parts.slice(0, -2), lastStripped] : lastStripped && (/^(story|stories)([.][^.]+)$/i.test(last) || /^index$/i.test(lastStripped)) ? parts.slice(0, -1) : [...parts.slice(0, -1), lastStripped];
+};
+function pathJoin(paths) {
+  return paths.flatMap((p) => p.split("/")).filter(Boolean).join("/");
+}
+var userOrAutoTitleFromSpecifier = (fileName, entry, userTitle) => {
+  let { directory, importPathMatcher, titlePrefix = "" } = entry || {}, normalizedFileName = slash(String(fileName));
+  if (importPathMatcher.exec(normalizedFileName)) {
+    if (!userTitle) {
+      let suffix = normalizedFileName.replace(directory, ""), parts = pathJoin([titlePrefix, suffix]).split("/");
+      return parts = sanitize(parts), parts.join("/");
+    }
+    return titlePrefix ? pathJoin([titlePrefix, userTitle]) : userTitle;
+  }
+};
+
+// src/common/utils/posix.ts
+import { posix as posixPath, sep as sep2 } from "node:path";
+var posix2 = (localPath, seperator = sep2) => localPath.split(seperator).filter(Boolean).join(posixPath.sep);
+
+// src/common/utils/get-story-id.ts
+async function getStoryId(data, options) {
+  let stories = await options.presets.apply("stories", [], options), autoTitle = getStoryTitle({
+    ...data,
+    stories,
+    configDir: options.configDir
+  });
+  if (autoTitle === void 0)
+    throw new Error(dedent5`
+    The new story file was successfully generated, but we are unable to index it. Please ensure that the new Story file is matched by the 'stories' glob pattern in your Forkbook configuration.
+    `);
+  let storyName = storyNameFromExport(data.exportedStoryName), storyId = toId(autoTitle, storyName), kind = sanitize2(autoTitle);
+  return { storyId, kind };
+}
+function getStoryTitle({
+  storyFilePath,
+  configDir,
+  stories,
+  workingDir = process.cwd(),
+  userTitle
+}) {
+  let normalizedStories = normalizeStories2(stories, {
+    configDir,
+    workingDir
+  }), relativePath = relative3(workingDir, storyFilePath), importPath = posix2(normalizeStoryPath2(relativePath));
+  return normalizedStories.map((normalizeStory) => userOrAutoTitleFromSpecifier(importPath, normalizeStory, userTitle)).filter(Boolean)[0];
+}
+
+// src/common/utils/lazy-docgen-middleware.ts
+function createLazyDocgenMiddleware({
+  storyFileTest = STORY_FILE_TEST_REGEXP,
+  createManager,
+  extract
+}) {
+  let managerPromise, getManager = () => managerPromise ??= createManager();
+  return (nextDocgen) => async (input) => {
+    let storyImportPath = getStoryImportPathFromEntry(input.entry);
+    if (!storyImportPath || !storyFileTest.test(storyImportPath))
+      return nextDocgen(input);
+    let manager = await getManager();
+    if (!manager)
+      return nextDocgen(input);
+    let ours = await extract(manager, input);
+    return ours ? { ...await nextDocgen(input), ...ours } : nextDocgen(input);
+  };
+}
+
+// src/common/utils/sync-main-preview-addons.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import { types as t3 } from "@aussieljk/forkbook/internal/babel";
+import {
+  isCsfFactoryPreview,
+  readConfig as readConfig2,
+  writeConfig as writeConfig2
+} from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger8 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/common/utils/get-addon-annotations.ts
+import { createRequire as createRequire2 } from "node:module";
+function getAnnotationsName(addonName) {
+  return addonName.replace(/^@storybook\//, "").split(/[^a-zA-Z0-9]+/).map(
+    (word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  ).join("").replace(/^./, (char) => char.toLowerCase());
+}
+async function getAddonAnnotations(addon, configDir) {
+  let data = {
+    // core addons will have a function as default export in index entrypoint
+    importPath: addon,
+    importName: getAnnotationsName(addon),
+    isCoreAddon: isCorePackage(addon)
+  };
+  data.isCoreAddon || (data.importPath = `${addon}/preview`);
+  try {
+    createRequire2(import.meta.url).resolve(`${addon}/preview`, { paths: [configDir] });
+  } catch {
+    return null;
+  }
+  return data;
+}
+
+// src/common/utils/sync-main-preview-addons.ts
+async function syncStorybookAddons(mainConfig, previewConfigPath, configDir) {
+  let previewConfig = await readConfig2(previewConfigPath), modifiedConfig = await syncPreviewAddonsWithMainConfig(
+    mainConfig,
+    previewConfig,
+    configDir
+  );
+  await writeConfig2(modifiedConfig);
+}
+async function syncPreviewAddonsWithMainConfig(mainConfig, previewConfig, configDir) {
+  if (!isCsfFactoryPreview(previewConfig))
+    return previewConfig;
+  let existingAddons = previewConfig.getFieldNode(["addons"]);
+  existingAddons || previewConfig.set(["addons"], []);
+  let addons = getAddonNames(mainConfig);
+  if (!addons)
+    return previewConfig;
+  let syncedAddons = [];
+  for (let addon of addons) {
+    let annotations = await getAddonAnnotations(addon, configDir);
+    if (annotations) {
+      if (previewConfig._ast.program.body.find(
+        (node) => t3.isImportDeclaration(node) && node.source.value === annotations.importPath
+      ))
+        continue;
+      (!existingAddons || t3.isArrayExpression(existingAddons) && !existingAddons.elements.some(
+        (element) => t3.isIdentifier(element) && element.name === annotations.importName
+      )) && (syncedAddons.push(addon), annotations.isCoreAddon ? (previewConfig.setImport(annotations.importName, annotations.importPath), previewConfig.appendNodeToArray(
+        ["addons"],
+        t3.callExpression(t3.identifier(annotations.importName), [])
+      )) : (previewConfig.setImport({ namespace: annotations.importName }, annotations.importPath), previewConfig.appendNodeToArray(["addons"], t3.identifier(annotations.importName))));
+    }
+  }
+  return syncedAddons.length > 0 && logger8.log(
+    `Synchronizing addons from main config in ${import_picocolors2.default.cyan(previewConfig.fileName)}:
+${syncedAddons.map(import_picocolors2.default.magenta).join(", ")}`
+  ), previewConfig;
+}
+
+// src/common/utils/setup-addon-in-config.ts
+import { writeConfig as writeConfig3 } from "@aussieljk/forkbook/internal/csf-tools";
+
+// src/common/utils/wrap-getAbsolutePath-utils.ts
+import { types as t4 } from "@aussieljk/forkbook/internal/babel";
+var PREFERRED_GET_ABSOLUTE_PATH_WRAPPER_NAME = "getAbsolutePath", ALTERNATIVE_GET_ABSOLUTE_PATH_WRAPPER_NAME = "wrapForPnp";
+function doesVariableOrFunctionDeclarationExist(node, name) {
+  return t4.isVariableDeclaration(node) && node.declarations.length === 1 && t4.isVariableDeclarator(node.declarations[0]) && t4.isIdentifier(node.declarations[0].id) && node.declarations[0].id?.name === name || t4.isFunctionDeclaration(node) && t4.isIdentifier(node.id) && node.id.name === name;
+}
+function getReferenceToGetAbsolutePathWrapper(config, value) {
+  return t4.callExpression(
+    t4.identifier(getAbsolutePathWrapperName(config) ?? PREFERRED_GET_ABSOLUTE_PATH_WRAPPER_NAME),
+    [t4.stringLiteral(value)]
+  );
+}
+function getAbsolutePathWrapperName(config) {
+  let declarationName = config.getBodyDeclarations().flatMap(
+    (node) => doesVariableOrFunctionDeclarationExist(node, ALTERNATIVE_GET_ABSOLUTE_PATH_WRAPPER_NAME) ? [ALTERNATIVE_GET_ABSOLUTE_PATH_WRAPPER_NAME] : doesVariableOrFunctionDeclarationExist(node, PREFERRED_GET_ABSOLUTE_PATH_WRAPPER_NAME) ? [PREFERRED_GET_ABSOLUTE_PATH_WRAPPER_NAME] : []
+  );
+  return declarationName.length ? declarationName[0] : null;
+}
+function isGetAbsolutePathWrapperNecessary(node, cb = () => {
+}) {
+  if (t4.isStringLiteral(node))
+    return cb(node), !0;
+  if (t4.isObjectExpression(node)) {
+    let nameProperty = node.properties.find(
+      (property) => t4.isObjectProperty(property) && t4.isIdentifier(property.key) && property.key.name === "name"
+    );
+    if (nameProperty && t4.isStringLiteral(nameProperty.value))
+      return cb(nameProperty), !0;
+  }
+  return t4.isArrayExpression(node) && node.elements.some((element) => element && isGetAbsolutePathWrapperNecessary(element)) ? (cb(node), !0) : !1;
+}
+function getFieldsForGetAbsolutePathWrapper(config) {
+  let frameworkNode = config.getFieldNode(["framework"]), builderNode = config.getFieldNode(["core", "builder"]), rendererNode = config.getFieldNode(["core", "renderer"]), addons = config.getFieldNode(["addons"]);
+  return [
+    ...frameworkNode ? [frameworkNode] : [],
+    ...builderNode ? [builderNode] : [],
+    ...rendererNode ? [rendererNode] : [],
+    ...addons && t4.isArrayExpression(addons) ? [addons] : []
+  ];
+}
+function getAbsolutePathWrapperAsCallExpression(isConfigTypescript, names = { dirname: "dirname", fileURLToPath: "fileURLToPath" }) {
+  let parameter = "value";
+  for (; Object.values(names).includes(parameter); )
+    parameter = `_${parameter}`;
+  let functionDeclaration = {
+    ...t4.functionDeclaration(
+      t4.identifier(PREFERRED_GET_ABSOLUTE_PATH_WRAPPER_NAME),
+      [
+        {
+          ...t4.identifier(parameter),
+          ...isConfigTypescript ? { typeAnnotation: t4.tsTypeAnnotation(t4.tSStringKeyword()) } : {}
+        }
+      ],
+      t4.blockStatement([
+        t4.returnStatement(
+          t4.callExpression(t4.identifier(names.dirname), [
+            t4.callExpression(t4.identifier(names.fileURLToPath), [
+              t4.callExpression(
+                t4.memberExpression(
+                  t4.metaProperty(t4.identifier("import"), t4.identifier("meta")),
+                  t4.identifier("resolve")
+                ),
+                [
+                  t4.templateLiteral(
+                    [
+                      t4.templateElement({ raw: "" }),
+                      t4.templateElement({ raw: "/package.json" }, !0)
+                    ],
+                    [t4.identifier(parameter)]
+                  )
+                ]
+              )
+            ])
+          ])
+        )
+      ])
+    ),
+    ...isConfigTypescript ? { returnType: t4.tSTypeAnnotation(t4.tsAnyKeyword()) } : {}
+  };
+  return t4.addComment(
+    functionDeclaration,
+    "leading",
+    `*
+ * This function is used to resolve the absolute path of a package.
+ * It is needed in projects that are set up within a monorepo.
+`
+  ), functionDeclaration;
+}
+function wrapValueWithGetAbsolutePathWrapper(config, node) {
+  isGetAbsolutePathWrapperNecessary(node, (n) => {
+    if (t4.isStringLiteral(n)) {
+      let wrapperNode = getReferenceToGetAbsolutePathWrapper(config, n.value);
+      Object.keys(n).forEach((k) => {
+        delete n[k];
+      }), Object.keys(wrapperNode).forEach((k) => {
+        n[k] = wrapperNode[k];
+      });
+    }
+    t4.isObjectProperty(n) && t4.isStringLiteral(n.value) && (n.value = getReferenceToGetAbsolutePathWrapper(config, n.value.value)), t4.isArrayExpression(n) && n.elements.forEach((element) => {
+      element && isGetAbsolutePathWrapperNecessary(element) && wrapValueWithGetAbsolutePathWrapper(config, element);
+    });
+  });
+}
+var topLevelNames = (node) => t4.isImportDeclaration(node) ? node.specifiers.map((specifier) => specifier.local.name) : t4.isExportNamedDeclaration(node) && node.declaration ? topLevelNames(node.declaration) : t4.isVariableDeclaration(node) ? node.declarations.flatMap(({ id }) => Object.keys(t4.getBindingIdentifiers(id))) : (t4.isFunctionDeclaration(node) || t4.isClassDeclaration(node)) && node.id ? [node.id.name] : [];
+function ensureNamedImport(config, imported, source) {
+  let { body } = config._ast.program;
+  for (let node of body)
+    if (t4.isImportDeclaration(node) && node.source.value.replace(/^node:/, "") === source.replace(/^node:/, "")) {
+      let existing = node.specifiers.find(
+        (specifier) => t4.isImportSpecifier(specifier) && (t4.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value) === imported
+      );
+      if (existing)
+        return existing.local.name;
+    }
+  let taken = new Set(body.flatMap(topLevelNames));
+  if (!taken.has(imported))
+    return config.setImport([imported], source), imported;
+  let local = `${source.replace(/^node:/, "")}${imported[0].toUpperCase()}${imported.slice(1)}`;
+  for (; taken.has(local); )
+    local = `_${local}`;
+  return body.unshift(
+    t4.importDeclaration(
+      [t4.importSpecifier(t4.identifier(local), t4.identifier(imported))],
+      t4.stringLiteral(source)
+    )
+  ), local;
+}
+
+// src/common/utils/setup-addon-in-config.ts
+async function setupAddonInConfig({
+  addonName,
+  previewConfigPath,
+  configDir,
+  mainConfigCSFFile
+}) {
+  if (mainConfigCSFFile.getFieldNode(["addons"]) && getAbsolutePathWrapperName(mainConfigCSFFile) !== null) {
+    let addonNode = mainConfigCSFFile.valueToNode(addonName);
+    mainConfigCSFFile.appendNodeToArray(["addons"], addonNode), wrapValueWithGetAbsolutePathWrapper(mainConfigCSFFile, addonNode);
+  } else
+    mainConfigCSFFile.appendValueToArray(["addons"], addonName);
+  await writeConfig3(mainConfigCSFFile);
+  try {
+    let newMainConfig = await loadMainConfig({ configDir, skipCache: !0 });
+    previewConfigPath && await syncStorybookAddons(newMainConfig, previewConfigPath, configDir);
+  } catch {
+  }
+}
+
+// src/common/js-package-manager/JsPackageManagerFactory.ts
+import { existsSync as existsSync5, readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename3, join as join14, parse as parse3, relative as relative4 } from "node:path";
+
+// src/common/utils/command.ts
+import { logger as logger9, prompt } from "@aussieljk/forkbook/internal/node-logger";
+import { existsSync as existsSync3 } from "node:fs";
+import { delimiter, join as join8 } from "node:path";
+
+// src/common/utils/categorize-execa-error.ts
+var PACKAGE_MANAGER_COMMANDS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]), PACKAGE_INSTALL_ARGS = /* @__PURE__ */ new Set(["install", "add", "ci", "i"]);
+function extractExecaCommandErrorData(error, context) {
+  let structured = error, args = context.args ?? [], logs = getErrorLogs(error);
+  return logs === "[object Object]" && (logs = ""), {
+    command: context.command,
+    args,
+    exitCode: structured.exitCode ?? structured.code,
+    signal: structured.signal,
+    logs,
+    packageManagerErrorCode: extractPackageManagerErrorCode(logs)
+  };
+}
+function extractPackageManagerErrorCode(logs) {
+  let npmMatch = logs.match(/npm\s+(?:ERR!|error)\s+code\s+([A-Z0-9_]+)/i);
+  if (npmMatch)
+    return npmMatch[1];
+  let pnpmMatch = logs.match(/(ERR_PNPM_[A-Z0-9_]+)/);
+  if (pnpmMatch)
+    return pnpmMatch[1];
+}
+function isPlaywrightInstall(args) {
+  let joined = args.join(" ");
+  return joined.includes("playwright") && joined.includes("install");
+}
+function isPackageManagerCommand(command) {
+  let normalizedCommand = command.replace(/\.(cmd|exe|ps1)$/i, "");
+  return PACKAGE_MANAGER_COMMANDS.has(normalizedCommand);
+}
+function isPackageInstall(command, args) {
+  return isPackageManagerCommand(command) ? args.some((arg) => PACKAGE_INSTALL_ARGS.has(arg)) : !1;
+}
+function isBinaryNotFound(data) {
+  let logs = data.logs.toLowerCase();
+  return data.exitCode === 127 || logs.includes("enoent") && logs.includes("spawn") || logs.includes("command not found") || logs.includes("couldn't find the binary") || logs.includes("is not recognized as an internal or external command") || logs.includes("err_pnpm_recursive_exec_first_fail");
+}
+function isMissingPackageManifest(data) {
+  let logs = data.logs;
+  return data.packageManagerErrorCode === "ENOENT" && logs.includes("package.json") || logs.includes("ERR_PNPM_NO_PKG_MANIFEST");
+}
+function isDependencyConflict(data) {
+  return data.packageManagerErrorCode === "ERESOLVE";
+}
+function isPnpmIgnoredBuilds(data) {
+  return data.packageManagerErrorCode === "ERR_PNPM_IGNORED_BUILDS" || data.logs.includes("Ignored build scripts");
+}
+function isPnpmNoTtyModulesDir(data) {
+  return data.packageManagerErrorCode === "ERR_PNPM_ABORTED_REMOVE_MODULES_DIR_NO_TTY";
+}
+function categorizeExecaError(error, context) {
+  if (error instanceof StorybookError)
+    return error;
+  let data = extractExecaCommandErrorData(error, context), { command, args } = data;
+  return isPlaywrightInstall(args) ? new PlaywrightInstallFailedError({ ...data, cause: error }) : isBinaryNotFound(data) && isPackageManagerCommand(command) ? new PackageManagerBinaryNotFoundError({ ...data, cause: error }) : isPackageInstall(command, args) ? isDependencyConflict(data) ? new PackageInstallDependencyConflictError({ ...data, cause: error }) : isMissingPackageManifest(data) ? new PackageInstallMissingManifestError({ ...data, cause: error }) : isPnpmIgnoredBuilds(data) ? new PnpmIgnoredBuildsError({ ...data, cause: error }) : isPnpmNoTtyModulesDir(data) ? new PnpmNoTtyModulesDirError({ ...data, cause: error }) : new PackageInstallFailedError({ ...data, cause: error }) : new ExecaCommandFailedError({ ...data, cause: error });
+}
+
+// src/common/utils/command.ts
+var COMMON_ENV_VARS = {
+  COREPACK_ENABLE_STRICT: "0",
+  COREPACK_ENABLE_AUTO_PIN: "0",
+  NO_UPDATE_NOTIFIER: "true"
+};
+function attachCategorizedExecaFailureHandler(execaProcess, context) {
+  let categorize = (error) => categorizeExecaError(error, context), originalThen = execaProcess.then.bind(execaProcess), originalCatch = execaProcess.catch.bind(execaProcess);
+  execaProcess.then = ((onFulfilled, onRejected) => originalThen(
+    onFulfilled,
+    typeof onRejected == "function" ? (error) => onRejected(categorize(error)) : (error) => {
+      throw categorize(error);
+    }
+  )), execaProcess.catch = ((onRejected) => originalCatch((error) => {
+    throw categorize(error);
+  }).catch(typeof onRejected == "function" ? onRejected : void 0));
+}
+function getExecaOptions({
+  stdio,
+  cwd,
+  env,
+  signal,
+  ...execaOptions
+}) {
+  return {
+    cwd,
+    stdio: stdio ?? prompt.getPreferredStdio(),
+    encoding: "utf8",
+    cleanup: !0,
+    env: {
+      ...COMMON_ENV_VARS,
+      ...env
+    },
+    ...signal && { cancelSignal: signal },
+    // Map signal to cancelSignal for execa v9
+    ...execaOptions
+  };
+}
+function executeCommand(options) {
+  let { command, args = [], ignoreError = !1 } = options;
+  logger9.debug(`Executing command: ${command} ${args.join(" ")}`);
+  let commandVariations = resolveCommand(command), execaProcess = tryCommandVariations(commandVariations, args, getExecaOptions(options));
+  return ignoreError ? execaProcess.catch(() => {
+  }) : attachCategorizedExecaFailureHandler(execaProcess, { command, args }), execaProcess;
+}
+function executeCommandSync(options) {
+  let { command, args = [], ignoreError = !1 } = options;
+  try {
+    let commandVariations = resolveCommand(command);
+    return tryCommandVariationsSync(
+      commandVariations,
+      args,
+      getExecaOptions(options)
+    );
+  } catch (err) {
+    if (!ignoreError)
+      throw categorizeExecaError(err, { command, args });
+    return "";
+  }
+}
+function executeNodeCommand({
+  scriptPath,
+  args,
+  options
+}) {
+  return execaNode(scriptPath, args, {
+    ...options
+  });
+}
+function isCommandNotFoundError(error) {
+  return error ? (error.stderr || "").includes("is not recognized as an internal or external command") : !1;
+}
+function shouldRetry(error, isLastVariation) {
+  return isCommandNotFoundError(error) && !isLastVariation;
+}
+function isExecutableInPath(command) {
+  return (process.env.PATH || "").split(delimiter).some((dir) => existsSync3(join8(dir, command)));
+}
+function tryCommandVariations(commandVariations, args, options) {
+  if (commandVariations.length <= 1)
+    return execa(commandVariations[0], args, options);
+  for (let cmd of commandVariations.slice(0, -1))
+    if (isExecutableInPath(cmd))
+      return logger9.debug(`Resolved command variation: ${cmd}`), execa(cmd, args, options);
+  return execa(commandVariations[commandVariations.length - 1], args, options);
+}
+function tryCommandVariationsSync(commandVariations, args, options) {
+  let lastError;
+  for (let i = 0; i < commandVariations.length; i++) {
+    let cmd = commandVariations[i];
+    try {
+      let commandResult = execaCommandSync([cmd, ...args].join(" "), options);
+      return typeof commandResult.stdout == "string" ? commandResult.stdout : "";
+    } catch (error) {
+      if (lastError = error, !shouldRetry(error, i === commandVariations.length - 1))
+        throw error;
+      logger9.debug(`Command "${cmd}" not found, trying next variation...`);
+    }
+  }
+  throw lastError;
+}
+function resolveCommand(command) {
+  let WINDOWS_SHIM_COMMANDS = /* @__PURE__ */ new Set([
+    "npm",
+    "npx",
+    "pnpm",
+    "yarn",
+    "ng"
+    // Anything installed via node_modules/.bin (vite, eslint, prettier, etc)
+    // can be added here as needed. Do NOT list native executables.
+  ]);
+  return process.platform !== "win32" ? [command] : WINDOWS_SHIM_COMMANDS.has(command) ? [`${command}.cmd`, `${command}.exe`, `${command}.ps1`, command] : [command];
+}
+
+// src/common/js-package-manager/BUNProxy.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join9 } from "node:path";
+import { logger as logger10, prompt as prompt2 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  FindPackageVersionsError,
+  MinimumReleaseAgeHandledError
+} from "@aussieljk/forkbook/internal/server-errors";
+import sort from "semver/functions/sort.js";
+import { dedent as dedent6 } from "ts-dedent";
+var BUNProxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "bun" /* BUN */;
+  }
+  async initPackageJson() {
+    return executeCommand({ command: "bun", args: ["init"] });
+  }
+  getCommandName() {
+    return "bun";
+  }
+  getInstallCommand(deps, dev) {
+    return `bun add ${dev ? "-D " : ""}${deps.join(" ")}`;
+  }
+  getRunStorybookCommand() {
+    return "bun run storybook";
+  }
+  getRunCommand(command) {
+    return `bun run ${command}`;
+  }
+  getRemoteRunCommand(args) {
+    return `bunx ${args.join(" ")}`;
+  }
+  getPackageCommand(args) {
+    return `bunx ${args.join(" ")}`;
+  }
+  async getModulePackageJSON(packageName) {
+    let wantedPath = join9("node_modules", packageName, "package.json"), packageJsonPath = up2(wantedPath, {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    return packageJsonPath ? JSON.parse(readFileSync8(packageJsonPath, "utf-8")) : null;
+  }
+  getInstallArgs() {
+    return this.installArgs || (this.installArgs = []), this.installArgs;
+  }
+  runPackageCommand(options) {
+    return executeCommand({
+      command: "bunx",
+      ...options
+    });
+  }
+  runInternalCommand(command, args, cwd, stdio) {
+    return executeCommand({
+      command: "bun",
+      args: [command, ...args],
+      cwd: cwd ?? this.cwd,
+      stdio
+    });
+  }
+  async findInstallations(pattern, { depth = 99 } = {}) {
+    let exec = async ({ packageDepth }) => executeCommand({
+      command: "npm",
+      args: ["ls", "--json", `--depth=${packageDepth}`],
+      cwd: this.cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: {
+        FORCE_COLOR: "false"
+      }
+    });
+    try {
+      let result = await await exec({ packageDepth: depth }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = JSON.parse(commandResult);
+      return this.mapDependencies(parsedOutput, pattern);
+    } catch {
+      try {
+        let result = await await exec({ packageDepth: 0 }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = JSON.parse(commandResult);
+        return this.mapDependencies(parsedOutput, pattern);
+      } catch (err) {
+        logger10.debug(
+          `An issue occurred while trying to find dependencies metadata using npm: ${err}`
+        );
+        return;
+      }
+    }
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      overrides: {
+        ...packageJson.overrides,
+        ...versions
+      }
+    };
+  }
+  runInstall(options) {
+    return executeCommand({
+      command: "bun",
+      args: ["install", ...this.getInstallArgs(), ...options?.force ? ["--force"] : []],
+      cwd: this.cwd,
+      stdio: prompt2.getPreferredStdio()
+    });
+  }
+  async installDependencies(options) {
+    try {
+      await super.installDependencies(options);
+    } catch (error) {
+      let logs = getErrorLogs(error);
+      if (logs.includes("minimum-release-age") || logs.includes("minimum release age")) {
+        let handledError = new MinimumReleaseAgeHandledError({
+          packageManagerName: "bun",
+          minimumReleaseAgeConfigName: "minimumReleaseAge",
+          minimumReleaseAgeConfigDocs: "https://bun.com/docs/pm/cli/install#minimum-release-age",
+          minimumReleaseAgeExclusionsConfigName: "minimumReleaseAgeExcludes",
+          failedPackage: this.extractMinimumReleaseAgePackage(logs),
+          cause: error
+        });
+        throw logger10.error(handledError.message), handledError;
+      }
+      throw error;
+    }
+  }
+  async precheckStorybookPackageInstall({
+    storybookVersion,
+    nonInteractive
+  }) {
+    let bunfig = this.readBunfig(), minimumReleaseAgeSeconds = this.getMinimumReleaseAgeSeconds(bunfig);
+    if (!minimumReleaseAgeSeconds || hasStorybookMinimumAgeExclusions(this.getMinimumReleaseAgeExcludes(bunfig ?? "")))
+      return;
+    let timeMap = await this.getPackageTimeMap("@aussieljk/forkbook");
+    if (!timeMap)
+      return;
+    let releaseTime = timeMap[storybookVersion];
+    if (!releaseTime)
+      return;
+    let publishedAt = parseReleaseTime(releaseTime);
+    if (!publishedAt || Math.floor((Date.now() - publishedAt.getTime()) / 1e3) >= minimumReleaseAgeSeconds)
+      return;
+    let compatibleVersion = getLatestStableVersionAdheringToMinimumAgeGate(
+      timeMap,
+      Math.ceil(minimumReleaseAgeSeconds / 60)
+    );
+    if (nonInteractive) {
+      this.updateMinimumReleaseAgeExcludes(), logger10.info(
+        dedent6`
+          bun minimumReleaseAge would block storybook@${storybookVersion} from being installed because it was released within the configured minimumReleaseAge window, so Forkbook updated minimumReleaseAgeExcludes for this project automatically.
+
+          Added patterns: storybook, @storybook/*, eslint-plugin-storybook
+
+          Read more:
+          - https://bun.com/docs/pm/cli/install#minimum-release-age
+        `
+      );
+      return;
+    }
+    logger10.warn(
+      `bun minimumReleaseAge will block storybook@${storybookVersion} from being installed because it was released within the disallowed immaturity window.`
+    );
+    let rerunError = new MinimumReleaseAgeHandledError({
+      message: this.createMinimumReleaseAgeRerunMessage({
+        currentVersion: storybookVersion,
+        compatibleVersion
+      })
+    });
+    if (await prompt2.select(
+      {
+        message: "How would you like to proceed?",
+        options: [
+          {
+            label: "Update bunfig.toml to exclude Forkbook packages from minimumReleaseAge",
+            value: "exclude"
+          },
+          {
+            label: compatibleVersion ? `Stop now and rerun with the most recent allowed release: storybook@${compatibleVersion}` : "Stop now and rerun with an older stable Forkbook release later",
+            value: "rerun"
+          }
+        ]
+      },
+      {
+        onCancel: () => {
+          throw logger10.error(rerunError.message), rerunError;
+        }
+      }
+    ) === "exclude") {
+      this.updateMinimumReleaseAgeExcludes();
+      return;
+    }
+    throw logger10.error(rerunError.message), rerunError;
+  }
+  async getRegistryURL() {
+    let result = await executeCommand({
+      command: "npm",
+      cwd: this.cwd,
+      // "npm config" commands are not allowed in workspaces per default
+      // https://github.com/npm/cli/issues/6099#issuecomment-1847584792
+      args: ["config", "get", "registry", "--workspaces=false", "--include-workspace-root"]
+    }), url = (typeof result.stdout == "string" ? result.stdout : "").trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    return installAsDevDependencies && (args = ["-D", ...args]), executeCommand({
+      command: "bun",
+      args: ["add", ...args, ...this.getInstallArgs()],
+      stdio: "pipe",
+      cwd: this.primaryPackageJson.operationDir
+    });
+  }
+  async runGetVersions(packageName, fetchAllVersions) {
+    let args = fetchAllVersions ? ["versions", "--json"] : ["version"];
+    try {
+      let result = await executeCommand({
+        command: "npm",
+        cwd: this.cwd,
+        args: ["info", packageName, ...args]
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = fetchAllVersions ? JSON.parse(commandResult) : commandResult.trim();
+      if (parsedOutput.error?.summary)
+        throw parsedOutput.error.summary;
+      return parsedOutput;
+    } catch (error) {
+      throw new FindPackageVersionsError({
+        error,
+        packageManager: "NPM",
+        packageName
+      });
+    }
+  }
+  /**
+   * @param input The output of `npm ls --json`
+   * @param pattern A list of package names to filter the result. * can be used as a placeholder
+   */
+  mapDependencies(input, pattern) {
+    let acc = {}, existingVersions = {}, duplicatedDependencies = {}, recurse = ([name, packageInfo]) => {
+      if (!name || !pattern.some((p) => new RegExp(`^${p.replace(/\*/g, ".*")}$`).test(name)))
+        return;
+      let value = {
+        version: packageInfo.version,
+        location: ""
+      };
+      existingVersions[name]?.includes(value.version) || (acc[name] ? acc[name].push(value) : acc[name] = [value], existingVersions[name] = sort([...existingVersions[name] || [], value.version]), existingVersions[name].length > 1 && (duplicatedDependencies[name] = existingVersions[name])), packageInfo.dependencies && Object.entries(packageInfo.dependencies).forEach(recurse);
+    };
+    return Object.entries(input.dependencies).forEach(recurse), {
+      dependencies: acc,
+      duplicatedDependencies,
+      infoCommand: "npm ls --depth=1",
+      dedupeCommand: "npm dedupe"
+    };
+  }
+  getMinimumReleaseAgeSeconds(bunfig = this.readBunfig()) {
+    if (!bunfig)
+      return null;
+    let match = bunfig.match(/^minimumReleaseAge\s*=\s*(\d+)\s*$/m);
+    if (!match)
+      return null;
+    let parsedValue = Number.parseInt(match[1], 10);
+    return Number.isFinite(parsedValue) && parsedValue > 0 ? parsedValue : null;
+  }
+  async getPackageTimeMap(packageName) {
+    let result = await executeCommand({
+      command: "npm",
+      cwd: this.cwd,
+      args: ["info", packageName, "time", "--json"],
+      stdio: "pipe"
+    }), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    return normalizedValue ? parsePackageTimeMap(JSON.parse(normalizedValue)) : null;
+  }
+  createMinimumReleaseAgeRerunMessage({
+    currentVersion,
+    compatibleVersion
+  }) {
+    let rerunCommand = getStorybookRerunCommand(compatibleVersion);
+    return dedent6`
+      bun minimumReleaseAge blocked storybook@${currentVersion} from being installed.
+
+      ${FORKBOOK_RERUN_INSTRUCTION}
+      ${rerunCommand}
+
+      Read more:
+      - https://bun.com/docs/pm/cli/install#minimum-release-age
+    `;
+  }
+  updateMinimumReleaseAgeExcludes() {
+    let bunfigPath = join9(this.cwd, "bunfig.toml"), currentContent = this.readBunfig() ?? "", lineEnding = currentContent.includes(`\r
+`) ? `\r
+` : `
+`, replacement = [
+      "minimumReleaseAgeExcludes = [",
+      ...Array.from(
+        /* @__PURE__ */ new Set([...this.getMinimumReleaseAgeExcludes(currentContent), ...FORKBOOK_PACKAGE_PATTERNS])
+      ).map((pattern) => `  "${pattern}",`),
+      "]"
+    ].join(lineEnding), installSectionRange = this.getTomlSectionRange(currentContent, "install"), nextContent = installSectionRange ? [
+      currentContent.slice(0, installSectionRange.start),
+      this.updateMinimumReleaseAgeExcludesInContent(
+        currentContent.slice(installSectionRange.start, installSectionRange.end),
+        replacement,
+        lineEnding
+      ),
+      currentContent.slice(installSectionRange.end)
+    ].join("") : this.updateMinimumReleaseAgeExcludesInContent(currentContent, replacement, lineEnding);
+    writeFileSync2(bunfigPath, nextContent);
+  }
+  updateMinimumReleaseAgeExcludesInContent(content, replacement, lineEnding) {
+    return content.match(/^minimumReleaseAgeExcludes\s*=\s*\[[\s\S]*?\]/m) ? content.replace(/^minimumReleaseAgeExcludes\s*=\s*\[[\s\S]*?\]/m, replacement) : content.match(/^minimumReleaseAge\s*=\s*.+$/m) ? content.replace(
+      /^minimumReleaseAge\s*=\s*.+$/m,
+      (minimumReleaseAgeLine) => `${minimumReleaseAgeLine}${lineEnding}${replacement}`
+    ) : `${content}${content.trim().length > 0 ? `${lineEnding}${lineEnding}` : ""}${replacement}${lineEnding}`;
+  }
+  getTomlSectionRange(content, sectionName) {
+    let escapedSectionName = sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), sectionMatch = new RegExp(`^\\[${escapedSectionName}\\]\\s*$`, "m").exec(content);
+    if (!sectionMatch || sectionMatch.index === void 0)
+      return null;
+    let nextSectionHeader = /^\[[^\]]+\]\s*$/gm;
+    nextSectionHeader.lastIndex = sectionMatch.index + sectionMatch[0].length;
+    let nextSectionMatch = nextSectionHeader.exec(content);
+    return {
+      start: sectionMatch.index,
+      end: nextSectionMatch?.index ?? content.length
+    };
+  }
+  getMinimumReleaseAgeExcludes(bunfig) {
+    let match = bunfig.match(/^minimumReleaseAgeExcludes\s*=\s*\[([\s\S]*?)\]/m);
+    return match ? Array.from(match[1].matchAll(/"([^"]+)"/g), (entry) => entry[1]) : [];
+  }
+  readBunfig() {
+    try {
+      return readFileSync8(join9(this.cwd, "bunfig.toml"), "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  extractMinimumReleaseAgePackage(logs) {
+    let exactVersionMatch = logs.match(
+      /Version\s+"((?:@[^/\s"]+\/)?[^@\s"]+@[^\s"]+)"\s+was published within minimum release age/
+    );
+    if (exactVersionMatch)
+      return exactVersionMatch[1];
+    let rangedSpecifierMatch = logs.match(
+      /No version matching\s+"((?:@[^/\s"]+\/)?[^\s"]+)"\s+found for specifier\s+"([^"]+)"\s+\(blocked by minimum-release-age:/
+    );
+    if (rangedSpecifierMatch) {
+      let [, packageName2, specifier] = rangedSpecifierMatch;
+      return `${packageName2}@${specifier}`;
+    }
+    let failedToResolveMatch = logs.match(
+      /error:\s+((?:@[^/\s]+\/)?[^@\s]+@[^\s]+)\s+failed to resolve/
+    );
+    if (failedToResolveMatch)
+      return failedToResolveMatch[1];
+    let match = logs.match(/((?:@[^/\s]+\/)?[^@\s]+)@([^\s"']+)/);
+    if (!match)
+      return null;
+    let [, packageName, version] = match;
+    return `${packageName}@${version}`;
+  }
+};
+
+// src/common/js-package-manager/NPMProxy.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname7, join as join10 } from "node:path";
+import { logger as logger11, prompt as prompt3 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  FindPackageVersionsError as FindPackageVersionsError2,
+  MinimumReleaseAgeHandledError as MinimumReleaseAgeHandledError2
+} from "@aussieljk/forkbook/internal/server-errors";
+import sort2 from "semver/functions/sort.js";
+import { dedent as dedent7 } from "ts-dedent";
+var NPM_CONFIG_WORKSPACE_ARGS = ["--workspaces=false", "--include-workspace-root"];
+var NPMProxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "npm" /* NPM */;
+  }
+  getCommandName() {
+    return "npm";
+  }
+  getInstallCommand(deps, dev) {
+    return `npm install ${dev ? "-D " : ""}${deps.join(" ")}`;
+  }
+  getRunCommand(command) {
+    return `npm run ${command}`;
+  }
+  async getModulePackageJSON(packageName) {
+    let wantedPath = join10("node_modules", packageName, "package.json"), packageJsonPath = up2(wantedPath, {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    return packageJsonPath ? JSON.parse(readFileSync9(packageJsonPath, "utf-8")) : null;
+  }
+  getInstallArgs() {
+    return this.installArgs || (this.installArgs = []), this.installArgs;
+  }
+  getPackageCommand(args) {
+    return `npx ${args.join(" ")}`;
+  }
+  getRemoteRunCommand(args) {
+    return `npx ${args.join(" ")}`;
+  }
+  runPackageCommand({
+    useRemotePkg = !1,
+    ...options
+  }) {
+    return executeCommand({
+      command: "npx",
+      ...options,
+      ...useRemotePkg && { env: { npm_config_yes: "true", ...options.env } }
+    });
+  }
+  runInternalCommand(command, args, cwd, stdio) {
+    return executeCommand({
+      command: "npm",
+      args: [command, ...args],
+      cwd: cwd ?? this.cwd,
+      stdio
+    });
+  }
+  async findInstallations(pattern, { depth = 99 } = {}) {
+    let exec = ({ packageDepth }) => executeCommand({
+      command: "npm",
+      args: ["ls", "--json", `--depth=${packageDepth}`],
+      env: {
+        FORCE_COLOR: "false"
+      },
+      cwd: this.instanceDir,
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    try {
+      let childProcess = await exec({ packageDepth: depth }), commandResult = typeof childProcess.stdout == "string" ? childProcess.stdout : "", parsedOutput = JSON.parse(commandResult);
+      return this.mapDependencies(parsedOutput, pattern);
+    } catch {
+      try {
+        let childProcess = await exec({ packageDepth: 0 }), commandResult = typeof childProcess.stdout == "string" ? childProcess.stdout : "", parsedOutput = JSON.parse(commandResult);
+        return this.mapDependencies(parsedOutput, pattern);
+      } catch (e) {
+        logger11.debug(`Error finding installations for ${pattern.join(", ")}: ${String(e)}`);
+        return;
+      }
+    }
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      overrides: {
+        ...packageJson.overrides,
+        ...versions
+      }
+    };
+  }
+  runInstall(options) {
+    let packageJsonPath = this.packageJsonPaths[0], workspacePackageJsonPath = this.packageJsonPaths.find((ancestorPath) => {
+      let workspaces = JsPackageManager.getPackageJson(ancestorPath).workspaces, patterns = Array.isArray(workspaces) ? workspaces : workspaces?.packages;
+      return packageJsonPath && patterns?.length && globSync(
+        patterns.filter((pattern) => !pattern.startsWith("!")).map((pattern) => `${pattern}/package.json`),
+        {
+          cwd: dirname7(ancestorPath),
+          absolute: !0,
+          ignore: patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => `${pattern.slice(1)}/package.json`)
+        }
+      ).includes(packageJsonPath);
+    });
+    return executeCommand({
+      command: "npm",
+      args: ["install", ...this.getInstallArgs(), ...options?.force ? ["--force"] : []],
+      cwd: workspacePackageJsonPath ? dirname7(workspacePackageJsonPath) : this.cwd,
+      stdio: prompt3.getPreferredStdio()
+    });
+  }
+  async installDependencies(options) {
+    try {
+      await super.installDependencies(options);
+    } catch (error) {
+      let logs = getErrorLogs(error);
+      if (logs.match(/npm\s+(ERR!|error)\s+code\s+ETARGET/i) && logs.includes("with a date before")) {
+        let handledError = new MinimumReleaseAgeHandledError2({
+          packageManagerName: "npm",
+          minimumReleaseAgeConfigName: "min-release-age",
+          minimumReleaseAgeConfigDocs: "https://docs.npmjs.com/cli/v11/using-npm/config#min-release-age",
+          failedPackage: this.extractMinimumReleaseAgePackage(logs),
+          cause: error
+        });
+        throw logger11.error(handledError.message), handledError;
+      }
+      throw error;
+    }
+  }
+  async precheckStorybookPackageInstall({
+    storybookVersion
+  }) {
+    let minimumReleaseAgeDays = await this.getMinimumReleaseAge();
+    if (!minimumReleaseAgeDays)
+      return;
+    let timeMap = await this.getPackageTimeMap("@aussieljk/forkbook");
+    if (!timeMap)
+      return;
+    let releaseTime = timeMap[storybookVersion];
+    if (!releaseTime)
+      return;
+    let publishedAt = parseReleaseTime(releaseTime);
+    if (!publishedAt || getAgeInMinutes(publishedAt, /* @__PURE__ */ new Date()) / 1440 >= minimumReleaseAgeDays)
+      return;
+    let compatibleVersion = getLatestStableVersionAdheringToMinimumAgeGate(
+      timeMap,
+      minimumReleaseAgeDays * 24 * 60
+    ), error = new MinimumReleaseAgeHandledError2({
+      message: this.createMinimumReleaseAgeRerunMessage({
+        currentVersion: storybookVersion,
+        compatibleVersion
+      })
+    });
+    throw logger11.error(error.message), error;
+  }
+  async getRegistryURL() {
+    let result = await executeCommand({
+      command: "npm",
+      // "npm config" commands are not allowed in workspaces per default
+      // https://github.com/npm/cli/issues/6099#issuecomment-1847584792
+      args: ["config", "get", "registry", ...NPM_CONFIG_WORKSPACE_ARGS]
+    }), url = (typeof result.stdout == "string" ? result.stdout : "").trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    return installAsDevDependencies && (args = ["-D", ...args]), executeCommand({
+      command: "npm",
+      args: ["install", ...args, ...this.getInstallArgs()],
+      stdio: prompt3.getPreferredStdio(),
+      cwd: this.primaryPackageJson.operationDir
+    });
+  }
+  async runGetVersions(packageName, fetchAllVersions) {
+    let args = fetchAllVersions ? ["versions", "--json"] : ["version"];
+    try {
+      let result = await executeCommand({
+        command: "npm",
+        args: ["info", packageName, ...args]
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = fetchAllVersions ? JSON.parse(commandResult) : commandResult.trim();
+      if (parsedOutput.error?.summary)
+        throw parsedOutput.error.summary;
+      return parsedOutput;
+    } catch (error) {
+      throw new FindPackageVersionsError2({
+        error,
+        packageManager: "NPM",
+        packageName
+      });
+    }
+  }
+  /**
+   * @param input The output of `npm ls --json`
+   * @param pattern A list of package names to filter the result. * can be used as a placeholder
+   */
+  mapDependencies(input, pattern) {
+    let acc = {}, existingVersions = {}, duplicatedDependencies = {}, recurse = ([name, packageInfo]) => {
+      if (!name || !pattern.some((p) => new RegExp(`^${p.replace(/\*/g, ".*")}$`).test(name)))
+        return;
+      let value = {
+        version: packageInfo.version,
+        location: ""
+      };
+      existingVersions[name]?.includes(value.version) || (acc[name] ? acc[name].push(value) : acc[name] = [value], existingVersions[name] = sort2([...existingVersions[name] || [], value.version]), existingVersions[name].length > 1 && (duplicatedDependencies[name] = existingVersions[name])), packageInfo.dependencies && Object.entries(packageInfo.dependencies).forEach(recurse);
+    };
+    return Object.entries(input.dependencies).forEach(recurse), {
+      dependencies: acc,
+      duplicatedDependencies,
+      infoCommand: "npm ls --depth=1",
+      dedupeCommand: "npm dedupe"
+    };
+  }
+  async getMinimumReleaseAge() {
+    let result = await executeCommand({
+      command: "npm",
+      args: ["config", "get", "min-release-age", ...NPM_CONFIG_WORKSPACE_ARGS],
+      cwd: this.cwd,
+      stdio: "pipe"
+    });
+    return parsePositiveIntegerConfigValue(
+      typeof result.stdout == "string" ? result.stdout : void 0
+    );
+  }
+  async getPackageTimeMap(packageName) {
+    let result = await executeCommand({
+      command: "npm",
+      args: ["info", packageName, "time", "--json"],
+      cwd: this.cwd,
+      stdio: "pipe"
+    }), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    return normalizedValue ? parsePackageTimeMap(JSON.parse(normalizedValue)) : null;
+  }
+  createMinimumReleaseAgeRerunMessage({
+    currentVersion,
+    compatibleVersion
+  }) {
+    let rerunCommand = getStorybookRerunCommand(compatibleVersion);
+    return dedent7`
+      npm min-release-age blocked storybook@${currentVersion} from being installed.
+
+      ${FORKBOOK_RERUN_INSTRUCTION}
+      ${rerunCommand}
+
+      Read more:
+      - https://docs.npmjs.com/cli/v11/using-npm/config#min-release-age
+    `;
+  }
+  extractMinimumReleaseAgePackage(logs) {
+    let exactVersionMatch = logs.match(
+      /No matching version found for\s+((?:@[^/\s]+\/)?[^@\s]+)@([^\s]+)\s+with a date before/i
+    );
+    if (exactVersionMatch) {
+      let [, packageName2, version2] = exactVersionMatch;
+      return `${packageName2}@${version2}`;
+    }
+    let scopedMatch = logs.match(/((?:@[^/\s]+\/)?[^@\s]+)@([^\s"']+)/);
+    if (!scopedMatch)
+      return null;
+    let [, packageName, version] = scopedMatch;
+    return `${packageName}@${version}`;
+  }
+};
+
+// src/common/js-package-manager/PNPMProxy.ts
+import { existsSync as existsSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+import { logger as logger12, prompt as prompt4 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  FindPackageVersionsError as FindPackageVersionsError3,
+  MinimumReleaseAgeHandledError as MinimumReleaseAgeHandledError3
+} from "@aussieljk/forkbook/internal/server-errors";
+var import_yaml = __toESM(require_dist(), 1);
+import { coerce, gte } from "semver";
+import { dedent as dedent8 } from "ts-dedent";
+var PNPM_ALLOW_BUILD_DLX_MIN = "10.2.0", PNPMProxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "pnpm" /* PNPM */;
+  }
+  /** Cached `pnpm --version` output; `undefined` until read, `null` if lookup failed. */
+  #pnpmVersion;
+  detectWorkspaceRoot() {
+    let pnpmWorkspaceYaml = `${process.cwd()}/pnpm-workspace.yaml`;
+    return existsSync4(pnpmWorkspaceYaml);
+  }
+  getCommandName() {
+    return "pnpm";
+  }
+  getInstallCommand(deps, dev) {
+    return `pnpm add ${dev ? "-D " : ""}${deps.join(" ")}`;
+  }
+  getRunCommand(command) {
+    return `pnpm run ${command}`;
+  }
+  async getPnpmVersion() {
+    return this.#readPnpmVersion() ?? "";
+  }
+  #readPnpmVersion() {
+    if (this.#pnpmVersion !== void 0)
+      return this.#pnpmVersion;
+    try {
+      logger12.debug("Executing command: pnpm --version");
+      let stdout = executeCommandSync({
+        cwd: this.cwd,
+        command: "pnpm",
+        args: ["--version"],
+        stdio: "pipe"
+      });
+      this.#pnpmVersion = stdout.trim();
+    } catch {
+      this.#pnpmVersion = null;
+    }
+    return this.#pnpmVersion;
+  }
+  #pnpmGte(minimum) {
+    let version = coerce(this.#readPnpmVersion());
+    return version != null && gte(version, minimum);
+  }
+  /**
+   * `pnpm add` at a workspace root needs `-w` (pnpm 8 and 9 reject it otherwise), but `pnpm install
+   * -w` skips every other workspace project from pnpm 9 on.
+   */
+  getInstallArgs(command) {
+    return command === "add" && this.detectWorkspaceRoot() ? ["-w"] : [];
+  }
+  getPackageCommand(args) {
+    return `pnpm exec ${args.join(" ")}`;
+  }
+  getRemoteRunCommand(args) {
+    return `pnpm ${this.#pnpmGte(PNPM_ALLOW_BUILD_DLX_MIN) ? "--allow-build=esbuild " : ""}dlx ${args.join(" ")}`;
+  }
+  runPackageCommand({
+    args,
+    useRemotePkg = !1,
+    ...options
+  }) {
+    let pnpmArgs = useRemotePkg ? [
+      ...this.#pnpmGte(PNPM_ALLOW_BUILD_DLX_MIN) ? ["--allow-build=esbuild"] : [],
+      "dlx",
+      ...args
+    ] : ["exec", ...args];
+    return executeCommand({
+      command: "pnpm",
+      args: pnpmArgs,
+      ...options
+    });
+  }
+  runInternalCommand(command, args, cwd, stdio) {
+    return executeCommand({
+      command: "pnpm",
+      args: [command, ...args],
+      cwd: cwd ?? this.cwd,
+      stdio
+    });
+  }
+  async getRegistryURL() {
+    let childProcess = await executeCommand({
+      command: "npm",
+      cwd: this.cwd,
+      args: ["config", "get", "registry", "--workspaces=false", "--include-workspace-root"]
+    }), url = (typeof childProcess.stdout == "string" ? childProcess.stdout : "").trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  async findInstallations(pattern, { depth = 99 } = {}) {
+    try {
+      let args = ["list", pattern.map((p) => `"${p}"`).join(" "), "--json", `--depth=${depth}`], childProcess = await executeCommand({
+        command: "pnpm",
+        shell: !0,
+        args,
+        env: {
+          FORCE_COLOR: "false"
+        },
+        cwd: this.instanceDir
+      }), commandResult = typeof childProcess.stdout == "string" ? childProcess.stdout : "", parsedOutput = JSON.parse(commandResult);
+      return this.mapDependencies(parsedOutput, pattern);
+    } catch (e) {
+      logger12.debug(`Error finding installations for ${pattern.join(", ")}: ${String(e)}`);
+      return;
+    }
+  }
+  async getModulePackageJSON(packageName) {
+    let wantedPath = join11("node_modules", packageName, "package.json"), packageJsonPath = up2(wantedPath, {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    return packageJsonPath ? JSON.parse(readFileSync10(packageJsonPath, "utf-8")) : null;
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      overrides: {
+        ...packageJson.overrides,
+        ...versions
+      }
+    };
+  }
+  async getDeclaredVersionSpecifier(packageName) {
+    let specifier = await super.getDeclaredVersionSpecifier(packageName);
+    if (specifier)
+      return specifier;
+    let catalogName = this.#getCatalogName(this.getAllDependencies()[packageName]);
+    if (catalogName === null)
+      return null;
+    let workspace = this.#readWorkspaceYaml();
+    if (!workspace)
+      return null;
+    let version = workspace.doc.getIn([
+      ...this.#catalogKeyPath(workspace.doc, catalogName),
+      packageName
+    ]);
+    return typeof version == "string" || typeof version == "number" ? String(version) : null;
+  }
+  applyVersionToRelatedPackages(packages, version, anchorPackage) {
+    let catalogName = this.#getCatalogName(this.getAllDependencies()[anchorPackage]);
+    return catalogName !== null && this.#registerCatalogEntries(packages, version, anchorPackage, catalogName) ? packages.map((pkg) => `${pkg}@catalog:${catalogName}`) : super.applyVersionToRelatedPackages(packages, version, anchorPackage);
+  }
+  /**
+   * If `specifier` is a pnpm catalog reference (`catalog:` / `catalog:<name>`), return the catalog
+   * name (`''` for the default catalog); otherwise return null.
+   */
+  #getCatalogName(specifier) {
+    let match = specifier?.match(/^catalog:(.*)$/);
+    return match ? match[1].trim() : null;
+  }
+  /**
+   * Locate and parse the `pnpm-workspace.yaml` that governs this project's catalogs, walking up
+   * from the package.json we operate on. Returns null when the file is missing or malformed.
+   */
+  #readWorkspaceYaml() {
+    let path = up2("pnpm-workspace.yaml", {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    if (!path)
+      return null;
+    try {
+      let doc = (0, import_yaml.parseDocument)(readFileSync10(path, "utf8"));
+      if (doc.errors.length > 0)
+        throw doc.errors[0];
+      return { path, doc };
+    } catch (e) {
+      return logger12.debug(`Could not read pnpm workspace file ${path}: ${String(e)}`), null;
+    }
+  }
+  /**
+   * The key path within a parsed `pnpm-workspace.yaml` for a catalog. Named catalogs live under
+   * `catalogs.<name>`. The default catalog (referenced as `catalog:` or `catalog:default`) may be
+   * defined either as top-level `catalog` or as `catalogs.default` — defining both is a pnpm config
+   * error, so follow whichever form the workspace already uses.
+   */
+  #catalogKeyPath(doc, catalogName) {
+    return catalogName && catalogName !== "default" ? ["catalogs", catalogName] : doc.hasIn(["catalogs", "default"]) ? ["catalogs", "default"] : ["catalog"];
+  }
+  /**
+   * Register `packages` in the same catalog as `anchorPackage`, editing `pnpm-workspace.yaml` via
+   * the `yaml` document API so the user's comments and formatting are preserved. The pnpm CLI can't
+   * do this: `pnpm config set` rejects scoped keys and `pnpm add --save-catalog` writes a resolved
+   * direct version whenever the requested range doesn't match an existing entry. Entries the user
+   * already pinned are never overridden. Returns whether the entries are now present, i.e. whether
+   * `catalog:` references to them will resolve.
+   */
+  #registerCatalogEntries(packages, version, anchorPackage, catalogName) {
+    let workspace = this.#readWorkspaceYaml();
+    if (!workspace)
+      return logger12.warn(
+        `Could not read pnpm-workspace.yaml to register catalog entries for: ${packages.join(", ")}`
+      ), !1;
+    try {
+      let keyPath = this.#catalogKeyPath(workspace.doc, catalogName), anchorVersion = workspace.doc.getIn([...keyPath, anchorPackage]), entryVersion = typeof anchorVersion == "string" || typeof anchorVersion == "number" ? String(anchorVersion) : version, changed = !1;
+      for (let pkg of packages)
+        workspace.doc.getIn([...keyPath, pkg]) === void 0 && (workspace.doc.setIn([...keyPath, pkg], entryVersion), changed = !0);
+      return changed && writeFileSync3(workspace.path, workspace.doc.toString(), "utf8"), !0;
+    } catch (e) {
+      return logger12.warn(`Could not update pnpm catalog in ${workspace.path}: ${String(e)}`), !1;
+    }
+  }
+  runInstall(options) {
+    return executeCommand({
+      command: "pnpm",
+      args: ["install", ...this.getInstallArgs("install"), ...options?.force ? ["--force"] : []],
+      stdio: prompt4.getPreferredStdio(),
+      cwd: this.cwd
+    });
+  }
+  async installDependencies(options) {
+    try {
+      await super.installDependencies(options);
+    } catch (error) {
+      let logs = getErrorLogs(error);
+      if (logs.includes("ERR_PNPM_NO_MATURE_MATCHING_VERSION")) {
+        let handledError = new MinimumReleaseAgeHandledError3({
+          packageManagerName: "pnpm",
+          minimumReleaseAgeConfigName: "minimumReleaseAge",
+          minimumReleaseAgeConfigDocs: "https://pnpm.io/settings#minimumreleaseage",
+          minimumReleaseAgeExclusionsConfigName: "minimumReleaseAgeExclude",
+          minimumReleaseAgeExclusionsConfigDocs: "https://pnpm.io/settings#minimumreleaseageexclude",
+          failedPackage: this.extractFailedPackage(logs),
+          cause: error
+        });
+        throw logger12.error(handledError.message), handledError;
+      }
+      throw error;
+    }
+  }
+  async precheckStorybookPackageInstall({
+    storybookVersion,
+    nonInteractive
+  }) {
+    let minimumReleaseAge = await this.getMinimumReleaseAge();
+    if (!minimumReleaseAge || hasStorybookMinimumAgeExclusions(await this.getMinimumReleaseAgeExclude()))
+      return;
+    let publishedAt = await this.getPackageReleaseTime("@aussieljk/forkbook", storybookVersion);
+    if (!publishedAt || getAgeInMinutes(publishedAt, /* @__PURE__ */ new Date()) >= minimumReleaseAge)
+      return;
+    let compatibleVersion = await this.getLatestStableVersionAdheringToMinimumReleaseAge(
+      "@aussieljk/forkbook",
+      minimumReleaseAge
+    );
+    if (nonInteractive) {
+      await this.updateMinimumReleaseAgeExclude(), logger12.info(
+        dedent8`
+          pnpm minimumReleaseAge would block storybook@${storybookVersion} from being installed because it was released within the configured minimumReleaseAge window, so Forkbook updated minimumReleaseAgeExclude for this project automatically.
+
+          Added patterns: storybook, @storybook/*, eslint-plugin-storybook
+
+          Read more:
+          - https://pnpm.io/settings#minimumreleaseage
+          - https://pnpm.io/settings#minimumreleaseageexclude
+        `
+      );
+      return;
+    }
+    logger12.warn(
+      `pnpm minimumReleaseAge will block storybook@${storybookVersion} from being installed because it was published within the configured minimum-release-age window.`
+    );
+    let rerunError = new MinimumReleaseAgeHandledError3({
+      message: this.createMinimumReleaseAgeRerunMessage({
+        currentVersion: storybookVersion,
+        compatibleVersion
+      })
+    });
+    if (await prompt4.select(
+      {
+        message: "How would you like to proceed?",
+        options: [
+          {
+            label: "Update pnpm config to exclude Forkbook packages",
+            value: "exclude"
+          },
+          {
+            label: compatibleVersion ? `Stop now and rerun with the most recent allowed release: storybook@${compatibleVersion}` : "Stop now and rerun with an older stable Forkbook release later",
+            value: "rerun"
+          }
+        ]
+      },
+      {
+        onCancel: () => {
+          throw logger12.error(rerunError.message), rerunError;
+        }
+      }
+    ) === "exclude") {
+      await this.updateMinimumReleaseAgeExclude();
+      return;
+    }
+    throw logger12.error(rerunError.message), rerunError;
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    installAsDevDependencies && (args = ["-D", ...args]);
+    let commandArgs = ["add", ...args, ...this.getInstallArgs("add")];
+    return executeCommand({
+      command: "pnpm",
+      args: commandArgs,
+      stdio: prompt4.getPreferredStdio(),
+      cwd: this.primaryPackageJson.operationDir
+    });
+  }
+  async runGetVersions(packageName, fetchAllVersions) {
+    let args = fetchAllVersions ? ["versions", "--json"] : ["version"];
+    try {
+      let result = await executeCommand({
+        command: "pnpm",
+        args: ["info", packageName, ...args]
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = fetchAllVersions ? JSON.parse(commandResult) : commandResult.trim();
+      if (parsedOutput.error?.summary)
+        throw parsedOutput.error.summary;
+      return parsedOutput;
+    } catch (error) {
+      throw new FindPackageVersionsError3({
+        error,
+        packageManager: "PNPM",
+        packageName
+      });
+    }
+  }
+  mapDependencies(input, pattern) {
+    let acc = {}, existingVersions = {}, duplicatedDependencies = {}, items = input.reduce((curr, item) => {
+      let { devDependencies, dependencies, peerDependencies } = item, allDependencies = { ...devDependencies, ...dependencies, ...peerDependencies };
+      return Object.assign(curr, allDependencies);
+    }, {}), recurse = ([name, packageInfo]) => {
+      if (!name || !pattern.some((p) => new RegExp(`^${p.replace(/\*/g, ".*")}$`).test(name)))
+        return;
+      let value = {
+        version: packageInfo.version,
+        location: ""
+      };
+      existingVersions[name]?.includes(value.version) || (acc[name] ? acc[name].push(value) : acc[name] = [value], existingVersions[name] = [...existingVersions[name] || [], value.version], existingVersions[name].length > 1 && (duplicatedDependencies[name] = existingVersions[name])), packageInfo.dependencies && Object.entries(packageInfo.dependencies).forEach(recurse);
+    };
+    return Object.entries(items).forEach(recurse), {
+      dependencies: acc,
+      duplicatedDependencies,
+      infoCommand: "pnpm list --depth=1",
+      dedupeCommand: "pnpm dedupe"
+    };
+  }
+  extractFailedPackage(logs) {
+    let match = logs.match(
+      /Version\s+([^\s]+)\s+\([^)]*\)\s+of\s+((?:@[^/\s]+\/)?[^\s]+)\s+does not meet the minimumReleaseAge constraint/
+    );
+    if (!match)
+      return null;
+    let [, version, packageName] = match;
+    return `${packageName}@${version}`;
+  }
+  async getMinimumReleaseAge() {
+    let result = await this.runInternalCommand(
+      "config",
+      ["get", "minimumReleaseAge"],
+      void 0,
+      "pipe"
+    );
+    return parsePositiveIntegerConfigValue(
+      typeof result.stdout == "string" ? result.stdout : void 0
+    );
+  }
+  async getPackageReleaseTime(packageName, version) {
+    let result = await this.runInternalCommand(
+      "view",
+      ["--json", packageName, "time"],
+      void 0,
+      "pipe"
+    ), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    if (!normalizedValue)
+      return null;
+    let timeMap = parsePackageTimeMap(JSON.parse(normalizedValue));
+    return parseReleaseTime(timeMap?.[version]);
+  }
+  async getLatestStableVersionAdheringToMinimumReleaseAge(packageName, minimumReleaseAgeMinutes, now = /* @__PURE__ */ new Date()) {
+    let result = await this.runInternalCommand(
+      "view",
+      ["--json", packageName, "time"],
+      void 0,
+      "pipe"
+    ), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    if (!normalizedValue)
+      return null;
+    let timeMap = parsePackageTimeMap(JSON.parse(normalizedValue));
+    return timeMap ? getLatestStableVersionAdheringToMinimumAgeGate(timeMap, minimumReleaseAgeMinutes, now) : null;
+  }
+  createMinimumReleaseAgeRerunMessage({
+    currentVersion,
+    compatibleVersion
+  }) {
+    let rerunCommand = getStorybookRerunCommand(compatibleVersion);
+    return dedent8`
+      pnpm minimumReleaseAge blocked storybook@${currentVersion} from being installed.
+
+      ${FORKBOOK_RERUN_INSTRUCTION}
+      ${rerunCommand}
+
+      Read more:
+      - https://pnpm.io/settings#minimumreleaseage
+    `;
+  }
+  async updateMinimumReleaseAgeExclude() {
+    let currentMinimumReleaseAgeExclude = await this.getMinimumReleaseAgeExclude(), nextMinimumReleaseAgeExclude = Array.from(
+      /* @__PURE__ */ new Set([...currentMinimumReleaseAgeExclude, ...FORKBOOK_PACKAGE_PATTERNS])
+    );
+    await prompt4.executeTaskWithSpinner(
+      () => this.runInternalCommand(
+        "config",
+        [
+          "set",
+          "--location=project",
+          "--json",
+          "minimumReleaseAgeExclude",
+          JSON.stringify(nextMinimumReleaseAgeExclude)
+        ],
+        void 0,
+        "pipe"
+      ),
+      {
+        id: "update-pnpm-minimum-release-age-exclude",
+        intro: "Updating pnpm minimumReleaseAgeExclude...",
+        error: "Failed to update pnpm minimumReleaseAgeExclude.",
+        success: "Updated pnpm minimumReleaseAgeExclude"
+      }
+    );
+  }
+  async getMinimumReleaseAgeExclude() {
+    let result = await this.runInternalCommand(
+      "config",
+      ["get", "minimumReleaseAgeExclude", "--json"],
+      void 0,
+      "pipe"
+    ), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    if (!normalizedValue || normalizedValue === "undefined" || normalizedValue === "null")
+      return [];
+    let parsedValue = JSON.parse(normalizedValue);
+    return Array.isArray(parsedValue) ? parsedValue.filter(
+      (value) => typeof value == "string" && value.length > 0
+    ) : [];
+  }
+};
+
+// src/common/js-package-manager/Yarn1Proxy.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+import { join as join12 } from "node:path";
+import process2 from "node:process";
+import { logger as logger13, prompt as prompt5 } from "@aussieljk/forkbook/internal/node-logger";
+import { FindPackageVersionsError as FindPackageVersionsError4 } from "@aussieljk/forkbook/internal/server-errors";
+var Yarn1Proxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "yarn1" /* YARN1 */;
+  }
+  getInstallArgs() {
+    return this.installArgs || (this.installArgs = process2.env.CI ? [] : ["--ignore-workspace-root-check"]), this.installArgs;
+  }
+  getCommandName() {
+    return "yarn";
+  }
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+  getInstallCommand(deps, dev) {
+    return `yarn add ${dev ? "-D " : ""}${deps.join(" ")}`;
+  }
+  getPackageCommand(args) {
+    let [command, ...rest] = args;
+    return `yarn exec ${command} -- ${rest.join(" ")}`;
+  }
+  getRemoteRunCommand(args) {
+    return `npx ${args.join(" ")}`;
+  }
+  runPackageCommand({
+    args,
+    useRemotePkg = !1,
+    ...options
+  }) {
+    let [command, ...rest] = args;
+    return executeCommand({
+      ...options,
+      ...useRemotePkg ? { command: "npx", args, env: { npm_config_yes: "true", ...options.env } } : { command: "yarn", args: ["exec", command, "--", ...rest] }
+    });
+  }
+  runInternalCommand(command, args, cwd, stdio) {
+    return executeCommand({
+      command: "yarn",
+      args: [command, ...args],
+      cwd: cwd ?? this.cwd,
+      stdio
+    });
+  }
+  async getModulePackageJSON(packageName) {
+    let wantedPath = join12("node_modules", packageName, "package.json"), packageJsonPath = up2(wantedPath, {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    return packageJsonPath ? JSON.parse(readFileSync11(packageJsonPath, "utf-8")) : null;
+  }
+  async getRegistryURL() {
+    let childProcess = await executeCommand({
+      command: "yarn",
+      args: ["config", "get", "registry"]
+    }), url = (typeof childProcess.stdout == "string" ? childProcess.stdout : "").trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  async findInstallations(pattern, { depth = 99 } = {}) {
+    let yarnArgs = ["list", "--pattern", pattern.map((p) => `"${p}"`).join(" "), "--json"];
+    depth !== 0 && yarnArgs.push("--recursive");
+    try {
+      let result = await executeCommand({
+        command: "yarn",
+        args: yarnArgs.concat(pattern),
+        shell: !0,
+        env: {
+          FORCE_COLOR: "false"
+        },
+        cwd: this.instanceDir
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = JSON.parse(commandResult);
+      return this.mapDependencies(parsedOutput, pattern);
+    } catch (e) {
+      logger13.debug(`Error finding installations for ${pattern.join(", ")}: ${String(e)}`);
+      return;
+    }
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      resolutions: {
+        ...packageJson.resolutions,
+        ...versions
+      }
+    };
+  }
+  runInstall(options) {
+    return executeCommand({
+      command: "yarn",
+      args: ["install", ...this.getInstallArgs(), ...options?.force ? ["--force"] : []],
+      stdio: prompt5.getPreferredStdio(),
+      cwd: this.cwd
+    });
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    return installAsDevDependencies && (args = ["-D", ...args]), executeCommand({
+      command: "yarn",
+      args: ["add", ...this.getInstallArgs(), ...args],
+      stdio: prompt5.getPreferredStdio(),
+      cwd: this.primaryPackageJson.operationDir
+    });
+  }
+  async runGetVersions(packageName, fetchAllVersions) {
+    let taggedPackage = packageName.match(/^(.*)@(next)$/), args = [
+      taggedPackage ? "dist-tags" : fetchAllVersions ? "versions" : "version",
+      "--json"
+    ];
+    try {
+      let result = await executeCommand({
+        command: "yarn",
+        args: ["info", taggedPackage?.[1] ?? packageName, ...args]
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "", parsedOutput = JSON.parse(commandResult);
+      if (parsedOutput.type === "inspect") {
+        if (taggedPackage && typeof parsedOutput.data == "object") {
+          let version = parsedOutput.data[taggedPackage[2]];
+          if (typeof version == "string")
+            return version;
+          throw new Error(`Yarn did not provide the ${taggedPackage[2]} dist-tag.`);
+        }
+        return parsedOutput.data;
+      }
+      throw new Error("Yarn did not provide an output with type 'inspect'.");
+    } catch (error) {
+      throw new FindPackageVersionsError4({
+        error,
+        packageManager: "Yarn 1",
+        packageName
+      });
+    }
+  }
+  mapDependencies(input, pattern) {
+    if (input.type === "tree") {
+      let { trees } = input.data, acc = {}, existingVersions = {}, duplicatedDependencies = {}, recurse = (tree) => {
+        let { children } = tree, { name, value } = parsePackageData(tree.name);
+        !name || !pattern.some((p) => new RegExp(`^${p.replace(/\*/g, ".*")}$`).test(name)) || (existingVersions[name]?.includes(value.version) || (acc[name] ? acc[name].push(value) : acc[name] = [value], existingVersions[name] = [...existingVersions[name] || [], value.version], existingVersions[name].length > 1 && (duplicatedDependencies[name] = existingVersions[name])), children.forEach(recurse));
+      };
+      return trees.forEach(recurse), {
+        dependencies: acc,
+        duplicatedDependencies,
+        infoCommand: "yarn why",
+        dedupeCommand: "yarn dedupe"
+      };
+    }
+    throw new Error("Something went wrong while parsing yarn output");
+  }
+};
+
+// src/common/js-package-manager/Yarn2Proxy.ts
+import { readFileSync as readFileSync12 } from "node:fs";
+import { join as join13 } from "node:path";
+import { prompt as prompt6 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  FindPackageVersionsError as FindPackageVersionsError5,
+  MinimumReleaseAgeHandledError as MinimumReleaseAgeHandledError4
+} from "@aussieljk/forkbook/internal/server-errors";
+import { dedent as dedent9 } from "ts-dedent";
+var Yarn2Proxy = class extends JsPackageManager {
+  constructor() {
+    super(...arguments);
+    this.type = "yarn2" /* YARN2 */;
+  }
+  getInstallArgs() {
+    return this.installArgs || (this.installArgs = []), this.installArgs;
+  }
+  getCommandName() {
+    return "yarn";
+  }
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+  getInstallCommand(deps, dev) {
+    return `yarn add ${dev ? "-D " : ""}${deps.join(" ")}`;
+  }
+  getPackageCommand(args) {
+    return `yarn exec ${args.join(" ")}`;
+  }
+  getRemoteRunCommand(args) {
+    return `yarn dlx ${args.join(" ")}`;
+  }
+  runPackageCommand({
+    args,
+    useRemotePkg = !1,
+    ...options
+  }) {
+    return executeCommand({
+      command: "yarn",
+      args: [useRemotePkg ? "dlx" : "exec", ...args],
+      ...options
+    });
+  }
+  runInternalCommand(command, args, cwd, stdio) {
+    return executeCommand({
+      command: "yarn",
+      args: [command, ...args],
+      cwd: cwd ?? this.cwd,
+      stdio
+    });
+  }
+  async findInstallations(pattern, { depth = 99 } = {}) {
+    let yarnArgs = ["info", "--name-only"];
+    depth !== 0 && yarnArgs.push("--recursive");
+    try {
+      let childProcess = await executeCommand({
+        command: "yarn",
+        args: yarnArgs.concat(pattern),
+        env: {
+          FORCE_COLOR: "false"
+        },
+        cwd: this.instanceDir
+      }), commandResult = typeof childProcess.stdout == "string" ? childProcess.stdout : "";
+      return logger.debug(`Installation found for ${pattern.join(", ")}: ${commandResult}`), this.mapDependencies(commandResult, pattern);
+    } catch (e) {
+      logger.debug(`Error finding installations for ${pattern.join(", ")}: ${String(e)}`);
+      return;
+    }
+  }
+  async getModulePackageJSON(packageName) {
+    let wantedPath = join13("node_modules", packageName, "package.json"), packageJsonPath = up2(wantedPath, {
+      cwd: this.primaryPackageJson.operationDir,
+      last: getProjectRoot()
+    });
+    return packageJsonPath ? JSON.parse(readFileSync12(packageJsonPath, "utf-8")) : null;
+  }
+  getResolutions(packageJson, versions) {
+    return {
+      resolutions: {
+        ...packageJson.resolutions,
+        ...versions
+      }
+    };
+  }
+  runInstall() {
+    return executeCommand({
+      command: "yarn",
+      args: ["install", ...this.getInstallArgs()],
+      cwd: this.cwd,
+      stdio: prompt6.getPreferredStdio()
+    });
+  }
+  async installDependencies(options) {
+    try {
+      await super.installDependencies(options);
+    } catch (error) {
+      let logs = getErrorLogs(error);
+      if (logs.includes("YN0016") && logs.includes("quarantined")) {
+        let handledError = new MinimumReleaseAgeHandledError4({
+          packageManagerName: "yarn",
+          minimumReleaseAgeConfigName: "npmMinimalAgeGate",
+          minimumReleaseAgeConfigDocs: "https://yarnpkg.com/configuration/yarnrc#npmMinimalAgeGate",
+          minimumReleaseAgeExclusionsConfigName: "npmPreapprovedPackages",
+          minimumReleaseAgeExclusionsConfigDocs: "https://yarnpkg.com/configuration/yarnrc#npmPreapprovedPackages",
+          failedPackage: this.extractQuarantinedPackage(logs),
+          cause: error
+        });
+        throw logger.error(handledError.message), handledError;
+      }
+      throw error;
+    }
+  }
+  async precheckStorybookPackageInstall({
+    storybookVersion,
+    nonInteractive
+  }) {
+    let minimumAgeGate = await this.getMinimumAgeGate();
+    if (!minimumAgeGate || hasStorybookMinimumAgeExclusions(await this.getPreapprovedPackages()))
+      return;
+    let timeMap = await this.getPackageTimeMap("@aussieljk/forkbook");
+    if (!timeMap)
+      return;
+    let releaseTime = timeMap[storybookVersion];
+    if (!releaseTime)
+      return;
+    let publishedAt = parseReleaseTime(releaseTime);
+    if (!publishedAt || getAgeInMinutes(publishedAt, /* @__PURE__ */ new Date()) >= minimumAgeGate)
+      return;
+    let compatibleVersion = getLatestStableVersionAdheringToMinimumAgeGate(
+      timeMap,
+      minimumAgeGate
+    );
+    if (nonInteractive) {
+      await this.updatePreapprovedPackages(), logger.info(
+        dedent9`
+          yarn npmMinimalAgeGate would block storybook@${storybookVersion} from being installed because it was released within the configured npmMinimalAgeGate window, so Forkbook updated npmPreapprovedPackages for this project automatically.
+
+          Added patterns: storybook, @storybook/*, eslint-plugin-storybook
+
+          Read more:
+          - https://yarnpkg.com/configuration/yarnrc#npmMinimalAgeGate
+          - https://yarnpkg.com/configuration/yarnrc#npmPreapprovedPackages
+        `
+      );
+      return;
+    }
+    logger.warn(
+      `yarn npmMinimalAgeGate will block storybook@${storybookVersion} from being installed because it was published within the configured minimum-release-age window.`
+    );
+    let rerunError = new MinimumReleaseAgeHandledError4({
+      message: this.createMinimalAgeGateRerunMessage({
+        currentVersion: storybookVersion,
+        compatibleVersion
+      })
+    });
+    if (await prompt6.select(
+      {
+        message: "How would you like to proceed?",
+        options: [
+          {
+            label: "Update yarn config to preapprove Forkbook packages",
+            value: "exclude"
+          },
+          {
+            label: compatibleVersion ? `Stop now and rerun with the most recent allowed release: storybook@${compatibleVersion}` : "Stop now and rerun with an older stable Forkbook release later",
+            value: "rerun"
+          }
+        ]
+      },
+      {
+        onCancel: () => {
+          throw logger.error(rerunError.message), rerunError;
+        }
+      }
+    ) === "exclude") {
+      await this.updatePreapprovedPackages();
+      return;
+    }
+    throw logger.error(rerunError.message), rerunError;
+  }
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+    return installAsDevDependencies && (args = ["-D", ...args]), executeCommand({
+      command: "yarn",
+      args: ["add", ...this.getInstallArgs(), ...args],
+      stdio: prompt6.getPreferredStdio(),
+      cwd: this.primaryPackageJson.operationDir
+    });
+  }
+  async getRegistryURL() {
+    let result = await executeCommand({
+      command: "yarn",
+      args: ["config", "get", "npmRegistryServer"]
+    }), url = (typeof result.stdout == "string" ? result.stdout : "").trim();
+    return url === "undefined" ? void 0 : url;
+  }
+  async runGetVersions(packageName, fetchAllVersions) {
+    let field = fetchAllVersions ? "versions" : "version", args = ["--fields", field, "--json"];
+    try {
+      let result = await executeCommand({
+        command: "yarn",
+        args: ["npm", "info", packageName, ...args]
+      }), commandResult = typeof result.stdout == "string" ? result.stdout : "";
+      return JSON.parse(commandResult)[field];
+    } catch (error) {
+      throw new FindPackageVersionsError5({
+        error,
+        packageManager: "Yarn Berry",
+        packageName
+      });
+    }
+  }
+  mapDependencies(input, pattern) {
+    let lines = input.split(`
+`), acc = {}, existingVersions = {}, duplicatedDependencies = {};
+    return lines.forEach((packageName) => {
+      if (logger.debug(`Processing package ${packageName}`), !packageName || !pattern.some((p) => new RegExp(`${p.replace(/\*/g, ".*")}`).test(packageName)))
+        return;
+      let { name, value } = parsePackageData(packageName.replaceAll('"', ""));
+      logger.debug(`Package ${name} found with version ${value.version}`), existingVersions[name]?.includes(value.version) || (acc[name] ? acc[name].push(value) : acc[name] = [value], existingVersions[name] = [...existingVersions[name] || [], value.version], existingVersions[name].length > 1 && (duplicatedDependencies[name] = existingVersions[name]));
+    }), {
+      dependencies: acc,
+      duplicatedDependencies,
+      infoCommand: "yarn why",
+      dedupeCommand: "yarn dedupe"
+    };
+  }
+  extractQuarantinedPackage(logs) {
+    let match = logs.match(
+      /│\s+((?:@[^/\s]+\/)?[^@\s]+)@npm:([^:\s]+):\s+All versions satisfying/
+    );
+    if (!match)
+      return null;
+    let [, packageName, version] = match;
+    return `${packageName}@${version}`;
+  }
+  async getMinimumAgeGate() {
+    try {
+      let result = await this.runInternalCommand(
+        "config",
+        ["get", "npmMinimalAgeGate"],
+        void 0,
+        "pipe"
+      );
+      return parsePositiveIntegerConfigValue(
+        typeof result.stdout == "string" ? result.stdout : void 0
+      );
+    } catch {
+      return null;
+    }
+  }
+  async getPackageTimeMap(packageName) {
+    let result = await this.runInternalCommand(
+      "npm",
+      ["info", packageName, "--fields", "time", "--json"],
+      void 0,
+      "pipe"
+    ), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+    return normalizedValue ? parsePackageTimeMap(JSON.parse(normalizedValue)?.time) : null;
+  }
+  createMinimalAgeGateRerunMessage({
+    currentVersion,
+    compatibleVersion
+  }) {
+    let rerunCommand = getStorybookRerunCommand(compatibleVersion);
+    return dedent9`
+      yarn npmMinimalAgeGate blocked storybook@${currentVersion} from being installed.
+
+      ${FORKBOOK_RERUN_INSTRUCTION}
+      ${rerunCommand}
+
+      Read more:
+      - https://yarnpkg.com/configuration/yarnrc#npmMinimalAgeGate
+    `;
+  }
+  async updatePreapprovedPackages() {
+    let currentPreapprovedPackages = await this.getPreapprovedPackages(), nextPreapprovedPackages = Array.from(
+      /* @__PURE__ */ new Set([...currentPreapprovedPackages, ...FORKBOOK_PACKAGE_PATTERNS])
+    );
+    await prompt6.executeTaskWithSpinner(
+      () => this.runInternalCommand(
+        "config",
+        ["set", "npmPreapprovedPackages", "--json", JSON.stringify(nextPreapprovedPackages)],
+        void 0,
+        "pipe"
+      ),
+      {
+        id: "update-yarn-npm-preapproved-packages",
+        intro: "Updating yarn npmPreapprovedPackages...",
+        error: "Failed to update yarn npmPreapprovedPackages.",
+        success: "Updated yarn npmPreapprovedPackages"
+      }
+    );
+  }
+  async getPreapprovedPackages() {
+    try {
+      let result = await this.runInternalCommand(
+        "config",
+        ["get", "npmPreapprovedPackages"],
+        void 0,
+        "pipe"
+      ), normalizedValue = typeof result.stdout == "string" ? result.stdout.trim() : "";
+      return normalizedValue ? this.parsePreapprovedPackages(normalizedValue) : [];
+    } catch {
+      return [];
+    }
+  }
+  parsePreapprovedPackages(value) {
+    try {
+      let parsedValue = JSON.parse(value);
+      return Array.isArray(parsedValue) ? parsedValue.filter(
+        (entry) => typeof entry == "string" && entry.length > 0
+      ) : [];
+    } catch {
+      return Array.from(value.matchAll(/['"]([^'"\n]+)['"]/g), (match) => match[1]);
+    }
+  }
+};
+
+// src/common/js-package-manager/JsPackageManagerFactory.ts
+var JsPackageManagerFactory = class {
+  static {
+    /** Cache for package manager instances */
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /** Generate a cache key based on the parameters */
+  static getCacheKey(force, configDir = defaultConfigDir(), cwd = process.cwd(), storiesPaths) {
+    return JSON.stringify({ force: force || null, configDir, cwd, storiesPaths });
+  }
+  /** Clear the package manager cache */
+  static clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Determine which package manager type to use based on lockfiles, commands, and environment
+   *
+   * @param cwd - Current working directory
+   * @returns Package manager type as string: 'npm', 'pnpm', 'bun', 'yarn1', or 'yarn2'
+   * @throws Error if no usable package manager is found
+   */
+  static getPackageManagerType(cwd = process.cwd()) {
+    let root = getProjectRoot(), closestLockfilePath = [
+      up2(YARN_LOCKFILE, { cwd, last: root }),
+      up2(PNPM_LOCKFILE, { cwd, last: root }),
+      up2(NPM_LOCKFILE, { cwd, last: root }),
+      up2(BUN_LOCKFILE, { cwd, last: root }),
+      up2(BUN_LOCKFILE_BINARY, { cwd, last: root })
+    ].filter(Boolean).sort((a, b) => {
+      let dirA = parse3(a).dir, dirB = parse3(b).dir, compare = relative4(dirA, dirB);
+      return dirA === dirB ? 0 : compare.startsWith("..") ? -1 : 1;
+    })[0], closestLockfile = closestLockfilePath && basename3(closestLockfilePath), yarnVersion = getYarnVersion(cwd);
+    if (yarnVersion && closestLockfile === YARN_LOCKFILE)
+      return yarnVersion === 1 ? "yarn1" /* YARN1 */ : "yarn2" /* YARN2 */;
+    if (hasPNPM(cwd) && closestLockfile === PNPM_LOCKFILE)
+      return "pnpm" /* PNPM */;
+    let isNPMCommandOk = hasNPM(cwd);
+    if (isNPMCommandOk && closestLockfile === NPM_LOCKFILE)
+      return "npm" /* NPM */;
+    if (hasBun(cwd) && (closestLockfile === BUN_LOCKFILE || closestLockfile === BUN_LOCKFILE_BINARY))
+      return "bun" /* BUN */;
+    let inferredPackageManager = this.inferPackageManagerFromUserAgent();
+    if (inferredPackageManager && inferredPackageManager in this.PROXY_MAP)
+      return inferredPackageManager;
+    if (isNPMCommandOk)
+      return "npm" /* NPM */;
+    throw new Error("Unable to find a usable package manager within NPM, PNPM, Yarn and Yarn 2");
+  }
+  static getPackageManager({
+    force,
+    configDir = defaultConfigDir(),
+    storiesPaths,
+    ignoreCache = !1
+  } = {}, cwd = process.cwd()) {
+    let cacheKey = this.getCacheKey(force, configDir, cwd, storiesPaths), cached = this.cache.get(cacheKey);
+    if (cached && !ignoreCache)
+      return cached;
+    if (force && force in this.PROXY_MAP) {
+      let packageManager2 = new this.PROXY_MAP[force]({
+        cwd,
+        configDir,
+        storiesPaths
+      });
+      return this.cache.set(cacheKey, packageManager2), packageManager2;
+    }
+    let packageManagerType = this.getPackageManagerType(cwd), packageManager = new this.PROXY_MAP[packageManagerType]({ cwd, configDir, storiesPaths });
+    return this.cache.set(cacheKey, packageManager), packageManager;
+  }
+  static {
+    /** Look up map of package manager proxies by name */
+    this.PROXY_MAP = {
+      npm: NPMProxy,
+      pnpm: PNPMProxy,
+      yarn1: Yarn1Proxy,
+      yarn2: Yarn2Proxy,
+      bun: BUNProxy
+    };
+  }
+  /**
+   * Infer the package manager based on the command the user is running. Each package manager sets
+   * the `npm_config_user_agent` environment variable with its name and version e.g. "npm/7.24.0"
+   * Which is really useful when invoking commands via npx/pnpx/yarn create/etc.
+   */
+  static inferPackageManagerFromUserAgent() {
+    let userAgent = process.env.npm_config_user_agent;
+    if (userAgent) {
+      let packageSpec = userAgent.split(" ")[0], [pkgMgrName, pkgMgrVersion] = packageSpec.split("/");
+      if (pkgMgrName === "pnpm")
+        return "pnpm" /* PNPM */;
+      if (pkgMgrName === "npm")
+        return "npm" /* NPM */;
+      if (pkgMgrName === "yarn")
+        return pkgMgrVersion?.startsWith("1.") ? "yarn1" /* YARN1 */ : "yarn2" /* YARN2 */;
+    }
+  }
+};
+function hasNPM(cwd) {
+  try {
+    return executeCommandSync({
+      command: "npm",
+      args: ["--version"],
+      cwd,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter(([, value]) => value !== void 0)
+      )
+    }), !0;
+  } catch {
+    return !1;
+  }
+}
+function hasBun(cwd) {
+  try {
+    return executeCommandSync({
+      command: "bun",
+      args: ["--version"],
+      cwd,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter(([, value]) => value !== void 0)
+      )
+    }), !0;
+  } catch {
+    return !1;
+  }
+}
+function hasPNPM(cwd) {
+  try {
+    return executeCommandSync({
+      command: "pnpm",
+      args: ["--version"],
+      cwd,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter(([, value]) => value !== void 0)
+      )
+    }), !0;
+  } catch {
+    return !1;
+  }
+}
+function getYarnVersionFromPackageJson(cwd, root) {
+  let effectiveRoot = root ?? getProjectRoot(), directories = up(cwd ?? process.cwd(), { last: effectiveRoot });
+  for (let dir of directories) {
+    let packageJsonPath = join14(dir, "package.json");
+    if (existsSync5(packageJsonPath))
+      try {
+        let packageManager = JSON.parse(readFileSync13(packageJsonPath, "utf-8")).packageManager;
+        if (typeof packageManager == "string") {
+          let match = packageManager.match(/^yarn@(\d+)\./);
+          if (match)
+            return match[1] === "1" ? 1 : 2;
+        }
+      } catch {
+      }
+  }
+}
+function hasYarnBerryConfig(cwd, root) {
+  return up2(".yarnrc.yml", { cwd, last: root }) !== void 0;
+}
+function getYarnVersion(cwd) {
+  let root = getProjectRoot(), versionFromPackageJson = getYarnVersionFromPackageJson(cwd, root);
+  if (versionFromPackageJson !== void 0)
+    return versionFromPackageJson;
+  let hasBerryConfig = hasYarnBerryConfig(cwd, root);
+  try {
+    let yarnVersion = executeCommandSync({
+      command: "yarn",
+      args: ["--version"],
+      cwd,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter(([, value]) => value !== void 0)
+      )
+    });
+    return /^1\./.test(yarnVersion.trim()) ? hasBerryConfig ? 2 : 1 : 2;
+  } catch {
+    return hasBerryConfig ? 2 : void 0;
+  }
+}
+
+// src/common/js-package-manager/warnOnYarn1.ts
+import { once } from "@aussieljk/forkbook/internal/node-logger";
+var PACKAGE_MANAGER_INSTALL_DOCS_URL = "https://storybook.js.org/docs/get-started/install";
+function warnOnYarn1(packageManagerType) {
+  if (packageManagerType === "yarn1" /* YARN1 */)
+    try {
+      once.warn(
+        `${getPrettyPackageManagerName(packageManagerType)} is supported on a best-effort basis. Forkbook works best with npm, pnpm, or Yarn Berry. For more information, see: ${PACKAGE_MANAGER_INSTALL_DOCS_URL}`
+      );
+    } catch {
+    }
+}
+
+// src/common/utils/scan-and-transform-files.ts
+import { logger as logger14, prompt as prompt7 } from "@aussieljk/forkbook/internal/node-logger";
+async function scanAndTransformFiles({
+  promptMessage = "Enter a custom glob pattern to scan (or press enter to use default):",
+  defaultGlob = "**/*.{mjs,cjs,js,jsx,ts,tsx,mdx}",
+  dryRun = !1,
+  force = !1,
+  transformFn,
+  transformOptions
+}) {
+  let glob = force ? defaultGlob : await prompt7.text({
+    message: promptMessage,
+    initialValue: defaultGlob
+  });
+  logger14.log("Scanning for affected files...");
+  let globby = (await import("./globby-OEMHPBFY.js")).globby, sourceFiles = await globby([glob], {
+    ...commonGlobOptions(""),
+    ignore: ["**/node_modules/**"],
+    dot: !0,
+    cwd: getProjectRoot(),
+    absolute: !0
+  });
+  return logger14.log(`Scanning ${sourceFiles.length} files...`), transformFn(sourceFiles, transformOptions, dryRun);
+}
+
+// src/common/utils/transform-imports.ts
+function transformImports(source, renamedImports) {
+  let hasChanges = !1, transformed = source;
+  for (let [from2, to] of Object.entries(renamedImports)) {
+    let regex = new RegExp(`(['"])${from2}(/.*)?\\1`, "g");
+    regex.test(transformed) && (transformed = transformed.replace(regex, `$1${to}$2$1`), hasChanges = !0);
+  }
+  return hasChanges ? transformed : null;
+}
+
+// src/common/utils/file-lock.ts
+import { logger as logger15 } from "@aussieljk/forkbook/internal/node-logger";
+import { randomUUID } from "node:crypto";
+import { readFileSync as readFileSync14, rmSync as rmSync2 } from "node:fs";
+import { mkdir as mkdir2, open, readFile as readFile6, rm as rm3, stat, utimes } from "node:fs/promises";
+import { dirname as dirname8 } from "node:path";
+var POLL_INTERVAL_MS = 50, DEFAULT_STALE_AFTER_MS = 3e4, DEFAULT_WAIT_BUDGET_MS = 2e4, MALFORMED_LOCK_GRACE_MS = 5e3, errorCode = (error) => typeof error == "object" && error !== null && "code" in error ? error.code : void 0, delay = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms)), isProcessAlive = (pid) => {
+  try {
+    return process.kill(pid, 0), !0;
+  } catch (error) {
+    return errorCode(error) !== "ESRCH";
+  }
+}, readPayload = async (lockPath) => {
+  try {
+    return JSON.parse(await readFile6(lockPath, "utf8"));
+  } catch {
+    return;
+  }
+}, tryAcquire = async (lockPath) => {
+  await mkdir2(dirname8(lockPath), { recursive: !0 });
+  let handle;
+  try {
+    handle = await open(lockPath, "wx");
+  } catch (error) {
+    if (errorCode(error) === "EEXIST")
+      return;
+    throw error;
+  }
+  let payload = { token: randomUUID(), pid: process.pid };
+  try {
+    await handle.writeFile(JSON.stringify(payload));
+  } catch (error) {
+    throw await handle.close(), await rm3(lockPath, { force: !0 }).catch(() => {
+    }), error;
+  }
+  return await handle.close(), payload.token;
+}, breakStaleLock = async (lockPath, staleAfterMs) => {
+  let stats;
+  try {
+    stats = await stat(lockPath);
+  } catch (error) {
+    return errorCode(error) === "ENOENT";
+  }
+  let payload = await readPayload(lockPath), holderPid = typeof payload?.pid == "number" ? payload.pid : void 0, age = Date.now() - stats.mtimeMs;
+  return (holderPid !== void 0 ? !isProcessAlive(holderPid) || age > staleAfterMs : age > MALFORMED_LOCK_GRACE_MS) ? ((await readPayload(lockPath))?.token !== payload?.token || (await rm3(lockPath, { force: !0 }), logger15.debug(`Cleared an abandoned lock at ${lockPath} (holder pid ${holderPid ?? "unknown"})`)), !0) : !1;
+}, releaseIfOurs = (lockPath, token) => {
+  try {
+    JSON.parse(readFileSync14(lockPath, "utf8"))?.token === token && rmSync2(lockPath, { force: !0 });
+  } catch {
+  }
+}, holdLock = (lockPath, token, staleAfterMs) => {
+  let removeSync = () => releaseIfOurs(lockPath, token);
+  process.once("exit", removeSync);
+  let heartbeat = setInterval(
+    () => {
+      let now = /* @__PURE__ */ new Date();
+      utimes(lockPath, now, now).catch(() => {
+      });
+    },
+    Math.max(10, staleAfterMs / 3)
+  );
+  return heartbeat.unref?.(), () => {
+    clearInterval(heartbeat), process.off("exit", removeSync), removeSync();
+  };
+}, withFileLock = async (lockPath, run, {
+  waitBudgetMs = DEFAULT_WAIT_BUDGET_MS,
+  staleAfterMs = DEFAULT_STALE_AFTER_MS
+} = {}) => {
+  let deadline = Date.now() + waitBudgetMs;
+  for (; ; ) {
+    let token = await tryAcquire(lockPath);
+    if (token !== void 0) {
+      let release = holdLock(lockPath, token, staleAfterMs);
+      try {
+        return await run(), "ran";
+      } finally {
+        release();
+      }
+    }
+    let retryImmediately = await breakStaleLock(lockPath, staleAfterMs);
+    if (Date.now() >= deadline)
+      return "busy";
+    retryImmediately || await delay(POLL_INTERVAL_MS);
+  }
+};
+
+// src/common/utils/process-ancestry.ts
+import { execSync } from "node:child_process";
+import os2 from "node:os";
+var UNIX_TIMEOUT = 5e3, WINDOWS_TIMEOUT = 1e4, MAX_DEPTH = 1e3, EXEC_STDIO = ["ignore", "pipe", "ignore"];
+function getProcessInfoUnix(pid) {
+  try {
+    let output = execSync(`ps -p ${pid} -o pid=,ppid=,command=`, {
+      encoding: "utf8",
+      timeout: UNIX_TIMEOUT,
+      stdio: EXEC_STDIO
+    }).trim();
+    if (!output)
+      return null;
+    let [pidStr, ppidStr, ...commandParts] = output.split(/\s+/), parsedPid = pidStr ? parseInt(pidStr, 10) : NaN, parsedPpid = ppidStr ? parseInt(ppidStr, 10) : NaN;
+    return Number.isNaN(parsedPid) || Number.isNaN(parsedPpid) ? null : {
+      pid: parsedPid,
+      ppid: parsedPpid,
+      command: commandParts.join(" ") || void 0
+    };
+  } catch (error) {
+    return error instanceof Error && error.message.includes("timeout") && console.warn(`Process lookup timed out for PID ${pid}`), null;
+  }
+}
+function getProcessInfoWindows(pid) {
+  try {
+    let output = execSync(
+      `wmic process where (ProcessId=${pid}) get ProcessId,ParentProcessId,CommandLine /format:csv`,
+      {
+        encoding: "utf8",
+        timeout: WINDOWS_TIMEOUT,
+        stdio: EXEC_STDIO
+      }
+    );
+    if (!output)
+      return null;
+    let fields = output.split(`
+`).filter((line) => line.trim() && !line.startsWith("Node")).pop()?.split(",");
+    if (!fields || fields.length < 4)
+      return null;
+    let [_node, commandLine, parentPid, thisPid] = fields, parsedPid = thisPid ? parseInt(thisPid.trim(), 10) : NaN, parsedPpid = parentPid ? parseInt(parentPid.trim(), 10) : NaN;
+    return Number.isNaN(parsedPid) || Number.isNaN(parsedPpid) ? null : {
+      pid: parsedPid,
+      ppid: parsedPpid,
+      command: commandLine?.trim() || void 0
+    };
+  } catch (error) {
+    return error instanceof Error && error.message.includes("timeout") && console.warn(`Process lookup timed out for PID ${pid}`), null;
+  }
+}
+function walkAncestry(startPid, getProcessInfo, isRootPpid) {
+  let result = [], visited = /* @__PURE__ */ new Set(), currentPid = startPid, maxDepth = MAX_DEPTH;
+  for (; currentPid && maxDepth > 0 && !visited.has(currentPid); ) {
+    visited.add(currentPid);
+    let info = getProcessInfo(currentPid);
+    if (!info || isRootPpid(info.ppid))
+      break;
+    result.push(info), currentPid = info.ppid, maxDepth -= 1;
+  }
+  return maxDepth === 0 && console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`), result;
+}
+function getProcessAncestry(pid = process.pid) {
+  if (typeof pid != "number" || !Number.isInteger(pid) || pid <= 0)
+    throw new Error("PID must be a positive integer");
+  return os2.platform() === "win32" ? walkAncestry(pid, getProcessInfoWindows, (ppid) => ppid === 0 || ppid === 4) : walkAncestry(pid, getProcessInfoUnix, (ppid) => ppid === 0 || ppid === 1);
+}
+
+export {
+  resolveAddonName,
+  loadPreset,
+  getPresets,
+  loadAllPresets,
+  FileSystemCache,
+  createFileSystemCache,
+  resolvePathInStorybookCache,
+  cache2 as cache,
+  temporaryDirectory,
+  temporaryFile,
+  parseList,
+  getEnvConfig,
+  createLogStream,
+  isCorePackage,
+  isSatelliteAddon,
+  checkAddonOrder,
+  findStorybookPackageRoot,
+  commonGlobOptions,
+  deepMerge,
+  getBuilderOptions,
+  getStorybookVersionSpecifierFromAncestry,
+  FORKBOOK_VERSION_SPECIFIER_ENV,
+  resolveStorybookVersionSpecifier,
+  readDependencyManifest,
+  getAutoRefs,
+  checkRef,
+  toTitle,
+  getRefs,
+  globToRegexp,
+  interpolate,
+  loadManagerOrAddonsFile,
+  loadPreviewOrConfigFile,
+  logConfig,
+  DEFAULT_FILES_PATTERN,
+  getDirectoryFromWorkingDir,
+  normalizeStoriesEntry,
+  normalizeStories,
+  readTemplate,
+  createMetaComponentResolver,
+  extractDeclaredSubcomponents,
+  removeAddon,
+  isPreservingSymlinks,
+  getPreviewBodyTemplate,
+  getPreviewHeadTemplate,
+  findTsconfigPath,
+  findTsconfigPathForFile,
+  findTsconfigPathForPath,
+  getTsconfigPathsBaseDir,
+  validateFrameworkName,
+  getBabelPresetEnvMajor,
+  formatCode,
+  formatFileContent,
+  userOrAutoTitleFromSpecifier,
+  posix2 as posix,
+  getStoryId,
+  getStoryTitle,
+  createLazyDocgenMiddleware,
+  syncStorybookAddons,
+  syncPreviewAddonsWithMainConfig,
+  doesVariableOrFunctionDeclarationExist,
+  getAbsolutePathWrapperName,
+  isGetAbsolutePathWrapperNecessary,
+  getFieldsForGetAbsolutePathWrapper,
+  getAbsolutePathWrapperAsCallExpression,
+  wrapValueWithGetAbsolutePathWrapper,
+  ensureNamedImport,
+  setupAddonInConfig,
+  executeCommand,
+  executeCommandSync,
+  executeNodeCommand,
+  JsPackageManagerFactory,
+  warnOnYarn1,
+  scanAndTransformFiles,
+  transformImports,
+  withFileLock,
+  getProcessAncestry
+};