@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,2102 @@
+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 {
+  postInstall
+} from "./chunk-XHL2LVBM.js";
+import {
+  RN_STORYBOOK_DIR,
+  applyPreviewImportsMap
+} from "./chunk-SWO5CDYU.js";
+import {
+  any,
+  up2 as up
+} from "./chunk-JDXXX6LB.js";
+import {
+  invariant
+} from "./chunk-34EO2PUT.js";
+import {
+  resolvePackageDir
+} from "./chunk-F3ZFKBHY.js";
+
+// src/create/initiate.ts
+import { resolve as resolve3 } from "node:path";
+import { installSkills, supportsSkills, supportsAiSetup } from "@aussieljk/forkbook/internal/cli";
+import {
+  PackageManagerName as PackageManagerName2,
+  cache,
+  executeCommand as executeCommand3
+} from "@aussieljk/forkbook/internal/common";
+import { getServerPort, withTelemetry } from "@aussieljk/forkbook/internal/core-server";
+import { logTracker as logTracker2, logger as logger14 } from "@aussieljk/forkbook/internal/node-logger";
+import { telemetry as telemetry4 } from "@aussieljk/forkbook/internal/telemetry";
+import { Feature as Feature6 } from "@aussieljk/forkbook/internal/types";
+
+// src/create/commands/PreflightCheckCommand.ts
+import {
+  JsPackageManagerFactory,
+  PackageManagerName,
+  getPrettyPackageManagerName,
+  resolveStorybookVersionSpecifier,
+  isCI,
+  invalidateProjectRootCache,
+  warnOnYarn1,
+  getProcessAncestry as getProcessAncestry2
+} from "@aussieljk/forkbook/internal/common";
+import { CLI_COLORS, logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+import { MinimumReleaseAgeHandledError } from "@aussieljk/forkbook/internal/server-errors";
+import { dedent } from "ts-dedent";
+
+// src/create/scaffold-new-project.ts
+import { readdirSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { executeCommand } from "@aussieljk/forkbook/internal/common";
+import { logger, prompt } from "@aussieljk/forkbook/internal/node-logger";
+import { GenerateNewProjectOnInitError } from "@aussieljk/forkbook/internal/server-errors";
+import { telemetry as telemetry2 } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/create/prompt-cancel.ts
+var createPromptCancelOptions = (telemetryService, promptName) => ({
+  async onCancel() {
+    let timeout, timeoutPromise = new Promise((resolve4) => {
+      timeout = setTimeout(resolve4, 2e3), timeout.unref?.();
+    });
+    try {
+      await Promise.race([
+        telemetryService.trackPromptCancel(promptName).catch(() => {
+        }),
+        timeoutPromise
+      ]);
+    } finally {
+      timeout !== void 0 && clearTimeout(timeout);
+    }
+    process.exit(0);
+  }
+});
+
+// src/create/services/TelemetryService.ts
+import {
+  getProcessAncestry,
+  getStorybookVersionSpecifierFromAncestry
+} from "@aussieljk/forkbook/internal/common";
+import { telemetry } from "@aussieljk/forkbook/internal/telemetry";
+import { Feature } from "@aussieljk/forkbook/internal/types";
+
+// src/create/services/VersionService.ts
+import { versions } from "@aussieljk/forkbook/internal/common";
+import { lt, prerelease } from "semver";
+var VersionService = class {
+  /** Get the current Forkbook version */
+  getCurrentVersion() {
+    return versions["@aussieljk/forkbook"];
+  }
+  /** Get the latest Forkbook version from the package manager */
+  async getLatestVersion(packageManager) {
+    return packageManager.latestVersion("@aussieljk/forkbook");
+  }
+  /** Check if the current version is a prerelease version */
+  isPrerelease(version) {
+    return !!prerelease(version);
+  }
+  /** Check if the current version is outdated compared to the latest version */
+  isOutdated(currentVersion, latestVersion) {
+    return lt(currentVersion, latestVersion);
+  }
+  /** Extract CLI integration from process ancestry. Detects if Forkbook was invoked via vike. */
+  getCliIntegrationFromAncestry(ancestry) {
+    return ancestry.some((ancestor) => ancestor.command?.includes("vike")) ? "vike" : void 0;
+  }
+  /** Get version info including current, latest, and prerelease status */
+  async getVersionInfo(packageManager) {
+    let currentVersion = this.getCurrentVersion(), latestVersion = await this.getLatestVersion(packageManager), isPrereleaseVersion = this.isPrerelease(currentVersion), isOutdatedVersion = latestVersion && !isPrereleaseVersion ? this.isOutdated(currentVersion, latestVersion) : !1;
+    return {
+      currentVersion,
+      latestVersion,
+      isPrerelease: isPrereleaseVersion,
+      isOutdated: isOutdatedVersion
+    };
+  }
+};
+
+// src/create/services/TelemetryService.ts
+var TelemetryService = class {
+  constructor() {
+    this.versionService = new VersionService();
+  }
+  /** Track install type selection */
+  async trackInstallType(installType) {
+    await telemetry("init-step", {
+      step: "install-type",
+      installType
+    });
+  }
+  /** Track when a user accepts the AI setup nudge prompt */
+  async trackAiSetupNudge(context) {
+    await telemetry("ai-prompt-nudge", {
+      id: "setup",
+      origin: "init",
+      context
+    });
+  }
+  /** Track Playwright prompt decision (install | skip | aborted) */
+  async trackPlaywrightPromptDecision(result) {
+    await telemetry("init-step", {
+      step: "playwright-install",
+      result
+    });
+  }
+  /** Track the outcome of the official Forkbook skills install step */
+  async trackSkills(result) {
+    await telemetry("init-step", {
+      step: "skills",
+      ...result
+    });
+  }
+  /** Track the main init event with all metadata */
+  async trackInit(data, options = {}) {
+    await telemetry("init", data, { configDir: options.configDir });
+  }
+  /** Track empty directory scaffolding event */
+  async trackScaffolded(data) {
+    await telemetry("scaffolded-empty", data);
+  }
+  /**
+   * Track init with complete context including version and CLI integration from ancestry This
+   * method encapsulates all telemetry gathering and tracking logic
+   */
+  async trackInitWithContext(projectType, selectedFeatures, configDir) {
+    let versionSpecifier, cliIntegration;
+    try {
+      let ancestry = getProcessAncestry();
+      versionSpecifier = getStorybookVersionSpecifierFromAncestry(ancestry), cliIntegration = this.versionService.getCliIntegrationFromAncestry(ancestry);
+    } catch {
+    }
+    let telemetryFeatures = {
+      dev: !0,
+      // Always true during init
+      docs: selectedFeatures.has(Feature.DOCS),
+      test: selectedFeatures.has(Feature.TEST),
+      ai: selectedFeatures.has(Feature.AI)
+    };
+    await this.trackInit(
+      {
+        projectType,
+        features: telemetryFeatures,
+        versionSpecifier,
+        cliIntegration
+      },
+      { configDir }
+    );
+  }
+  async trackPromptCancel(prompt10) {
+    await telemetry(
+      "canceled",
+      { eventType: "init", prompt: prompt10 },
+      { stripMetadata: !0, immediate: !0 }
+    );
+  }
+};
+
+// src/create/scaffold-new-project.ts
+var SUPPORTED_PROJECTS = {
+  "react-vite-ts": {
+    displayName: {
+      type: "React",
+      builder: "Vite",
+      language: "TS"
+    },
+    createScript: {
+      npm: "npm create vite@latest . -- --template react-ts",
+      yarn: "yarn create vite . --template react-ts",
+      pnpm: "pnpm create vite@latest . --template react-ts"
+    }
+  },
+  "nextjs-ts": {
+    displayName: {
+      type: "Next.js",
+      language: "TS"
+    },
+    createScript: {
+      npm: 'npm create next-app . -- --turbopack --typescript --use-npm --eslint --tailwind --no-app --import-alias="@/*" --src-dir --no-react-compiler',
+      // yarn doesn't support version ranges, so we have to use npx
+      yarn: 'npx create-next-app . --turbopack --typescript --use-yarn --eslint --tailwind --no-app --import-alias="@/*" --src-dir --no-react-compiler',
+      pnpm: 'pnpm create next-app . --turbopack --typescript --use-pnpm --eslint --tailwind --no-app --import-alias="@/*" --src-dir --no-react-compiler'
+    }
+  }
+}, packageManagerToCoercedName = (packageManager) => {
+  switch (packageManager) {
+    case "npm":
+      return "npm";
+    case "pnpm":
+      return "pnpm";
+    default:
+      return "yarn";
+  }
+}, buildProjectDisplayNameForPrint = ({ displayName }) => {
+  let { type, builder, language } = displayName;
+  return `${type} ${builder ? `+ ${builder} ` : ""}(${language})`;
+}, scaffoldNewProject = async (packageManager, telemetryService = new TelemetryService()) => {
+  let packageManagerName = packageManagerToCoercedName(packageManager), projectStrategy;
+  process.env.FORKBOOK_INIT_EMPTY_TYPE && (projectStrategy = process.env.FORKBOOK_INIT_EMPTY_TYPE), projectStrategy || (projectStrategy = await prompt.select(
+    {
+      message: "Empty directory detected:",
+      options: [
+        ...Object.entries(SUPPORTED_PROJECTS).map(([key, value]) => ({
+          label: buildProjectDisplayNameForPrint(value),
+          value: key
+        })),
+        {
+          label: "Other",
+          value: "other",
+          hint: "To install Forkbook on another framework, first generate a project with that framework and then rerun this command."
+        }
+      ]
+    },
+    createPromptCancelOptions(telemetryService, "empty-directory")
+  )), projectStrategy === "other" && (await telemetry2(
+    "exit",
+    { eventType: "init", reason: "scaffold-other" },
+    { stripMetadata: !0, immediate: !0 }
+  ), logger.warn(
+    "To install Forkbook on another framework, first generate a project with that framework and then rerun this command."
+  ), logger.outro("Exiting..."), process.exit(1));
+  let projectStrategyConfig = SUPPORTED_PROJECTS[projectStrategy], projectDisplayName = buildProjectDisplayNameForPrint(projectStrategyConfig), createScript = projectStrategyConfig.createScript[packageManagerName], spinner = prompt.spinner({
+    id: "create-new-project"
+  });
+  spinner.start(`Creating a new "${projectDisplayName}" project with ${packageManagerName}...`);
+  let targetDir = process.cwd();
+  try {
+    await rm(`${targetDir}/.cache`, { recursive: !0, force: !0 });
+  } catch {
+  }
+  try {
+    await rm(`${targetDir}/node_modules`, { recursive: !0, force: !0 });
+  } catch {
+  }
+  try {
+    spinner.message(`Executing ${createScript}`), await executeCommand({
+      command: createScript,
+      shell: !0,
+      stdio: "pipe",
+      cwd: targetDir
+    });
+  } catch (e) {
+    throw spinner.error(
+      `Failed to create a new "${projectDisplayName}" project with ${packageManagerName}`
+    ), new GenerateNewProjectOnInitError({
+      error: e,
+      packageManager: packageManagerName,
+      projectType: projectStrategy
+    });
+  }
+  spinner.stop(`${projectDisplayName} project with ${packageManagerName} created successfully!`), await telemetry2("scaffolded-empty", {
+    packageManager: packageManagerName,
+    projectType: projectStrategy
+  });
+}, FILES_TO_IGNORE = [
+  ".git",
+  ".gitignore",
+  ".DS_Store",
+  ".cache",
+  "node_modules",
+  ".yarnrc.yml",
+  ".yarn"
+], currentDirectoryIsEmpty = () => {
+  let cwdFolderEntries = readdirSync(process.cwd());
+  return cwdFolderEntries.length === 0 || cwdFolderEntries.every((entry) => FILES_TO_IGNORE.includes(entry));
+};
+
+// src/create/services/FeatureCompatibilityService.ts
+import { AddonVitestService } from "@aussieljk/forkbook/internal/cli";
+var FeatureCompatibilityService = class {
+  constructor(packageManager, addonVitestService = new AddonVitestService(packageManager)) {
+    this.packageManager = packageManager;
+    this.addonVitestService = addonVitestService;
+  }
+  /**
+   * Validate all compatibility checks for test feature
+   *
+   * @param packageManager - Package manager instance
+   * @param framework - Detected framework (e.g., 'nextjs', 'react-vite')
+   * @param builder - Detected builder (e.g. SupportedBuilder.Vite)
+   * @param directory - Project root directory
+   * @returns Compatibility result with reasons if incompatible
+   */
+  async validateTestFeatureCompatibility(framework, builder, directory) {
+    let compatibilityResult = await this.addonVitestService.validateCompatibility({
+      framework,
+      builder,
+      projectRoot: directory
+    });
+    return compatibilityResult.compatible ? { compatible: !0 } : compatibilityResult;
+  }
+};
+
+// src/create/services/AddonService.ts
+import { getPackageDetails } from "@aussieljk/forkbook/internal/common";
+import { Feature as Feature2 } from "@aussieljk/forkbook/internal/types";
+var AddonService = class {
+  /** Get addons based on selected features */
+  getAddonsForFeatures(features) {
+    let addons = [];
+    return features.has(Feature2.TEST) && addons.push("@aussieljk/forkbook/addon-vitest"), features.has(Feature2.A11Y) && addons.push("@aussieljk/forkbook/addon-a11y"), features.has(Feature2.DOCS) && addons.push("@aussieljk/forkbook/addon-docs"), addons;
+  }
+  /** Strip version numbers from addon names */
+  stripVersions(addons) {
+    return addons.map((addon) => getPackageDetails(addon)[0]);
+  }
+  /** Configure addons for the project */
+  configureAddons(features, extraAddons = []) {
+    let addonsForMain = this.stripVersions(extraAddons).filter(Boolean), addonPackages = extraAddons.filter(Boolean);
+    return {
+      addonsForMain,
+      addonPackages
+    };
+  }
+};
+
+// src/create/commands/PreflightCheckCommand.ts
+var PreflightCheckCommand = class {
+  /** Execute preflight checks */
+  constructor(versionService = new VersionService(), telemetryService = new TelemetryService()) {
+    this.versionService = versionService;
+    this.telemetryService = telemetryService;
+  }
+  async execute(options) {
+    if (options.storybookVersionSpecifier === void 0)
+      try {
+        options.storybookVersionSpecifier = resolveStorybookVersionSpecifier(getProcessAncestry2());
+      } catch {
+      }
+    let isEmptyDirProject = options.force !== !0 && currentDirectoryIsEmpty(), packageManagerType = JsPackageManagerFactory.getPackageManagerType();
+    isEmptyDirProject && ((options.packageManager ? options.packageManager === PackageManagerName.YARN1 : packageManagerType === PackageManagerName.YARN1) && (logger2.warn("Empty directory with yarn1 is unsupported. Falling back to npm."), packageManagerType = PackageManagerName.NPM, options.packageManager = packageManagerType), logger2.intro(CLI_COLORS.info("Initializing a new project")), await scaffoldNewProject(packageManagerType, this.telemetryService), logger2.outro(CLI_COLORS.info("Project created successfully")), invalidateProjectRootCache()), logger2.intro(CLI_COLORS.info("Initializing Forkbook"));
+    let packageManager = JsPackageManagerFactory.getPackageManager({
+      force: options.packageManager
+    });
+    logger2.info(`Package manager: ${getPrettyPackageManagerName(packageManager.type)}`), warnOnYarn1(packageManager.type), isEmptyDirProject && !options.skipInstall && await packageManager.installDependencies(), this.checkPackageNameConflict(packageManager), await this.displayVersionInfo(packageManager);
+    try {
+      await packageManager.precheckStorybookPackageInstall({
+        storybookVersion: this.versionService.getCurrentVersion(),
+        nonInteractive: !!options.yes || !process.stdout.isTTY || !!isCI()
+      });
+    } catch (error) {
+      if (error instanceof MinimumReleaseAgeHandledError)
+        throw error;
+      logger2.debug(`Skipping minimum-release-age precheck after an unexpected failure: ${error}`);
+    }
+    return { packageManager, isEmptyProject: isEmptyDirProject };
+  }
+  /**
+   * Warn when the project's package.json "name" is "@aussieljk/forkbook", which shadows
+   * the real storybook package in workspaces.
+   *
+   * See: https://github.com/storybookjs/storybook/issues/28725
+   */
+  checkPackageNameConflict(packageManager) {
+    packageManager.primaryPackageJson.packageJson.name === "@aussieljk/forkbook" && logger2.warn(dedent`
+        Your package.json "name" field is set to "@aussieljk/forkbook".
+
+        In npm, pnpm, or yarn workspaces this creates a symlink at
+        node_modules/storybook that shadows the real Forkbook package,
+        causing "Cannot find module @aussieljk/forkbook/internal/..." errors.
+
+        Please rename the "name" field in your package.json to something
+        other than "@aussieljk/forkbook" (e.g. "my-storybook", "docs", "@myorg/storybook").
+      `);
+  }
+  /** Display version information and warnings */
+  async displayVersionInfo(packageManager) {
+    let { currentVersion, latestVersion, isPrerelease, isOutdated } = await this.versionService.getVersionInfo(packageManager);
+    isOutdated && !isPrerelease ? logger2.warn(dedent`
+          This version is behind the latest release, which is: ${latestVersion}!
+          You likely ran the init command through npx, which can use a locally cached version.
+          
+          To get the latest, please run: ${CLI_COLORS.cta("npx storybook@latest init")}
+          You may want to ${CLI_COLORS.cta("CTRL+C")} to stop, and run with the latest version instead.
+        `) : isPrerelease ? logger2.warn(`This is a pre-release version: ${currentVersion}`) : logger2.info(`Adding Forkbook version ${currentVersion} to your project`);
+  }
+}, executePreflightCheck = async (options) => new PreflightCheckCommand().execute(options);
+
+// src/create/commands/ProjectDetectionCommand.ts
+import { logger as logger4, prompt as prompt2 } from "@aussieljk/forkbook/internal/node-logger";
+import { telemetry as telemetry3 } from "@aussieljk/forkbook/internal/telemetry";
+import { SupportedLanguage } from "@aussieljk/forkbook/internal/types";
+import { dedent as dedent3 } from "ts-dedent";
+
+// src/create/services/ProjectTypeService.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  ProjectType,
+  detectIncompatiblePackageVersions,
+  detectLanguage
+} from "@aussieljk/forkbook/internal/cli";
+import { HandledError, getProjectRoot } from "@aussieljk/forkbook/internal/common";
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+import { NxProjectDetectedError } from "@aussieljk/forkbook/internal/server-errors";
+import { dedent as dedent2 } from "ts-dedent";
+var ProjectTypeService = class {
+  constructor(jsPackageManager) {
+    this.jsPackageManager = jsPackageManager;
+  }
+  /** Sorted configuration to match a Forkbook preset template */
+  getSupportedTemplates() {
+    return [
+      {
+        preset: ProjectType.NEXTJS,
+        dependencies: ["next"],
+        matcherFunction: ({ dependencies }) => dependencies?.every(Boolean) ?? !0
+      },
+      {
+        preset: ProjectType.REACT_NATIVE,
+        dependencies: ["react-native", "react-native-scripts", "expo"],
+        peerDependencies: ["react-native", "react-native-scripts", "expo"],
+        matcherFunction: ({ dependencies, peerDependencies }) => (dependencies?.some(Boolean) || peerDependencies?.some(Boolean)) ?? !1
+      },
+      // DO NOT MOVE ANY TEMPLATES BELOW THIS LINE
+      // React is part of every Template, after Forkbook is initialized once
+      {
+        preset: ProjectType.REACT,
+        dependencies: ["react"],
+        peerDependencies: ["react"],
+        matcherFunction: ({ dependencies, peerDependencies }) => (dependencies?.some(Boolean) || peerDependencies?.some(Boolean)) ?? !1
+      }
+    ];
+  }
+  isStorybookInstantiated(configDir = resolve(process.cwd(), ".forkbook")) {
+    return existsSync(configDir);
+  }
+  async validateProvidedType(projectTypeProvided) {
+    if (Object.values(ProjectType).filter(
+      (t2) => !["undetected", "unsupported", "nx"].includes(String(t2))
+    ).includes(projectTypeProvided))
+      return projectTypeProvided;
+    throw logger3.error(`The provided project type ${projectTypeProvided} was not recognized by Forkbook`), new HandledError(`Unknown project type supplied: ${projectTypeProvided}`);
+  }
+  async autoDetectProjectType() {
+    try {
+      let detectedType = await this.detectProjectType();
+      if (detectedType === ProjectType.UNDETECTED || detectedType === null)
+        throw logger3.error(dedent2`
+          Unable to initialize Forkbook in this directory.
+
+          Forkbook couldn't detect a supported framework or configuration for your project. Make sure you're inside a React, Next.js or React Native project and that its dependencies are installed.
+
+          Tips:
+          - Run init in an empty directory or create a new framework app first.
+          - If this directory contains unrelated files, try a new directory for Forkbook.
+        `), new HandledError("Forkbook failed to detect your project type");
+      if (detectedType === ProjectType.NX)
+        throw new NxProjectDetectedError();
+      return detectedType;
+    } catch (err) {
+      throw err instanceof HandledError || err instanceof NxProjectDetectedError ? err : (logger3.error(String(err)), new HandledError(err instanceof Error ? err.message : String(err)));
+    }
+  }
+  async detectLanguage() {
+    return detectLanguage(this.jsPackageManager);
+  }
+  /** Check installed tooling versions for TypeScript compatibility constraints */
+  async detectIncompatiblePackageVersions() {
+    return detectIncompatiblePackageVersions(this.jsPackageManager);
+  }
+  async detectProjectType() {
+    try {
+      if (this.isNxProject())
+        return ProjectType.NX;
+      let { packageJson } = this.jsPackageManager.primaryPackageJson;
+      return this.detectFrameworkPreset(packageJson);
+    } catch {
+      return ProjectType.UNDETECTED;
+    }
+  }
+  detectFrameworkPreset(packageJson) {
+    let result = [...this.getSupportedTemplates(), this.getUnsupportedTemplate()].find(
+      (framework) => this.getProjectType(packageJson, framework) !== null
+    );
+    return result ? result.preset : ProjectType.UNDETECTED;
+  }
+  /** Template that matches unsupported frameworks */
+  getUnsupportedTemplate() {
+    return {
+      preset: ProjectType.UNSUPPORTED,
+      dependencies: {},
+      matcherFunction: ({ dependencies }) => dependencies?.some(Boolean) ?? !1
+    };
+  }
+  getProjectType(packageJson, framework) {
+    let matcher = {
+      dependencies: [!1],
+      peerDependencies: [!1],
+      files: [!1]
+    }, { preset, files, dependencies, peerDependencies, matcherFunction } = framework, dependencySearches = [];
+    Array.isArray(dependencies) ? dependencySearches = dependencies.map((name) => [name, void 0]) : typeof dependencies == "object" && (dependencySearches = Object.entries(dependencies)), dependencySearches.length > 0 && (matcher.dependencies = dependencySearches.map(
+      ([name, matchFn]) => this.hasDependency(packageJson, name, matchFn)
+    ));
+    let peerDependencySearches = [];
+    return Array.isArray(peerDependencies) ? peerDependencySearches = peerDependencies.map((name) => [name, void 0]) : typeof peerDependencies == "object" && (peerDependencySearches = Object.entries(peerDependencies)), peerDependencySearches.length > 0 && (matcher.peerDependencies = peerDependencySearches.map(
+      ([name, matchFn]) => this.hasPeerDependency(packageJson, name, matchFn)
+    )), Array.isArray(files) && files.length > 0 && (matcher.files = files.map((name) => existsSync(name))), matcherFunction(matcher) ? preset : null;
+  }
+  hasDependency(packageJson, name, matcher) {
+    let version = packageJson.dependencies?.[name] || packageJson.devDependencies?.[name];
+    return version && typeof matcher == "function" ? matcher(version) : !!version;
+  }
+  hasPeerDependency(packageJson, name, matcher) {
+    let version = packageJson.peerDependencies?.[name];
+    return version && typeof matcher == "function" ? matcher(version) : !!version;
+  }
+  isNxProject() {
+    return up("nx.json", { last: getProjectRoot() });
+  }
+};
+
+// src/create/commands/ProjectDetectionCommand.ts
+var ProjectDetectionCommand = class {
+  constructor(options, jsPackageManager, projectTypeService = new ProjectTypeService(jsPackageManager), telemetryService = new TelemetryService()) {
+    this.options = options;
+    this.projectTypeService = projectTypeService;
+    this.telemetryService = telemetryService;
+  }
+  /** Execute project type detection */
+  async execute() {
+    let projectType, projectTypeProvided = this.options.type;
+    projectTypeProvided ? (projectType = await this.projectTypeService.validateProvidedType(projectTypeProvided), logger4.step(`Installing Forkbook for user specified project type: ${projectTypeProvided}`)) : (projectType = await this.projectTypeService.autoDetectProjectType(), logger4.debug(`Project type detected: ${projectType}`)), await this.checkExistingInstallation();
+    let language = this.options.language || await this.detectAndReportLanguage();
+    return { projectType, language };
+  }
+  /** Detect language and warn about incompatible packages */
+  async detectAndReportLanguage() {
+    let language = await this.projectTypeService.detectLanguage();
+    if (language === SupportedLanguage.JAVASCRIPT) {
+      let incompatibleReasons = await this.projectTypeService.detectIncompatiblePackageVersions();
+      incompatibleReasons.length > 0 && logger4.warn(
+        `Populating with JavaScript examples due to incompatible package versions:
+${incompatibleReasons.map((r) => `  - ${r}`).join(`
+`)}`
+      );
+    }
+    return language;
+  }
+  /** Check if Forkbook is already installed and handle force option */
+  async checkExistingInstallation() {
+    let storybookInstantiated = this.projectTypeService.isStorybookInstantiated(), options = this.options;
+    options.force !== !0 && options.yes !== !0 && storybookInstantiated && (await prompt2.confirm(
+      {
+        message: dedent3`We found a .forkbook config directory in your project.
+We assume that Forkbook is already instantiated for your project. Do you still want to continue and force the initialization?`
+      },
+      createPromptCancelOptions(this.telemetryService, "force-on-existing-installation")
+    ) || options.yes ? options.force = !0 : (await telemetry3(
+      "exit",
+      { eventType: "init", reason: "existing-installation" },
+      { stripMetadata: !0, immediate: !0 }
+    ), process.exit(0)));
+  }
+}, executeProjectDetection = (packageManager, options) => new ProjectDetectionCommand(options, packageManager).execute();
+
+// src/create/commands/FrameworkDetectionCommand.ts
+import { logger as logger6 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/create/generators/GeneratorRegistry.ts
+import { logger as logger5 } from "@aussieljk/forkbook/internal/node-logger";
+var GeneratorRegistry = class {
+  constructor() {
+    this.generators = /* @__PURE__ */ new Map();
+  }
+  /** Register a generator for a specific project type */
+  register(generator) {
+    let { metadata } = generator;
+    this.generators.has(metadata.projectType) && logger5.warn(
+      `Generator for project type ${metadata.projectType} is already registered. Overwriting.`
+    ), this.generators.set(metadata.projectType, generator);
+  }
+  /** Get a generator for a specific project type */
+  get(projectType) {
+    return this.generators.get(projectType);
+  }
+}, generatorRegistry = new GeneratorRegistry();
+
+// src/create/services/FrameworkDetectionService.ts
+import { getProjectRoot as getProjectRoot2 } from "@aussieljk/forkbook/internal/common";
+import { prompt as prompt3 } from "@aussieljk/forkbook/internal/node-logger";
+import { SupportedBuilder, SupportedFramework } from "@aussieljk/forkbook/internal/types";
+var viteConfigFiles = ["vite.config.ts", "vite.config.js", "vite.config.mjs"], FrameworkDetectionService = class {
+  constructor(jsPackageManager, telemetryService = new TelemetryService()) {
+    this.jsPackageManager = jsPackageManager;
+    this.telemetryService = telemetryService;
+  }
+  detectFramework(renderer, builder) {
+    if (Object.values(SupportedFramework).includes(renderer))
+      return renderer;
+    let maybeFramework = `${renderer}-${builder}`;
+    if (Object.values(SupportedFramework).includes(maybeFramework))
+      return maybeFramework;
+    throw new Error(`Could not find framework for renderer: ${renderer} and builder: ${builder}`);
+  }
+  async detectBuilder() {
+    let viteConfig = any(viteConfigFiles, { last: getProjectRoot2() }), dependencies = this.jsPackageManager.getAllDependencies();
+    return viteConfig || dependencies.vite ? SupportedBuilder.VITE : prompt3.select(
+      {
+        message: "We were not able to detect the right builder for your project. Please select one:",
+        options: [{ label: "Vite", value: SupportedBuilder.VITE }]
+      },
+      createPromptCancelOptions(this.telemetryService, "builder-selection")
+    );
+  }
+};
+
+// src/create/commands/FrameworkDetectionCommand.ts
+var FrameworkDetectionCommand = class {
+  constructor(packageManager, frameworkDetectionService = new FrameworkDetectionService(packageManager)) {
+    this.frameworkDetectionService = frameworkDetectionService;
+  }
+  async execute(projectType, options) {
+    let generatorModule = generatorRegistry.get(projectType);
+    if (!generatorModule)
+      throw new Error(`No generator found for project type: ${projectType}`);
+    let { metadata } = generatorModule, builder;
+    options.builder ? builder = options.builder : metadata.builderOverride ? builder = metadata.builderOverride : builder = await this.frameworkDetectionService.detectBuilder();
+    let renderer = metadata.renderer, framework = metadata.framework !== void 0 ? metadata.framework : this.frameworkDetectionService.detectFramework(renderer, builder);
+    return framework && logger6.step(`Framework detected: ${framework}`), {
+      framework,
+      renderer,
+      builder
+    };
+  }
+}, executeFrameworkDetection = (projectType, packageManager, options) => new FrameworkDetectionCommand(packageManager).execute(projectType, options);
+
+// src/create/commands/UserPreferencesCommand.ts
+import { isCI as isCI2 } from "@aussieljk/forkbook/internal/common";
+import { logger as logger7, prompt as prompt4 } from "@aussieljk/forkbook/internal/node-logger";
+import { Feature as Feature3 } from "@aussieljk/forkbook/internal/types";
+import { dedent as dedent4 } from "ts-dedent";
+var UserPreferencesCommand = class {
+  constructor(commandOptions, telemetryService = new TelemetryService()) {
+    this.commandOptions = commandOptions;
+    this.telemetryService = telemetryService;
+  }
+  /** Execute user preferences gathering */
+  async execute(options) {
+    let skipPrompt = !(process.stdout.isTTY && !isCI2()) || !!this.commandOptions.yes, commandOptionsFeatures = this.handleCommandOptionsFeatureFlag();
+    if (commandOptionsFeatures)
+      return { selectedFeatures: commandOptionsFeatures };
+    let installType = this.commandOptions.features ? "recommended" : await this.promptInstallType(skipPrompt, options.isTestFeatureAvailable), useAi = options.isAiAvailable ? await this.promptAiSetup(skipPrompt, options.isAiSetupAvailable) : !1;
+    return { selectedFeatures: this.determineFeatures(
+      installType,
+      options.isTestFeatureAvailable,
+      useAi,
+      options.isAiSetupAvailable
+    ) };
+  }
+  handleCommandOptionsFeatureFlag() {
+    return this.commandOptions.features && this.commandOptions.features?.length > 0 ? (logger7.warn(dedent4`
+        Skipping feature validation as these features were explicitly selected:
+        ${Array.from(this.commandOptions.features).join(", ")}
+      `), new Set(this.commandOptions.features)) : this.commandOptions.features?.length === 0 ? (logger7.warn(dedent4`
+        All features have been disabled via --no-features flag.
+      `), /* @__PURE__ */ new Set()) : null;
+  }
+  /** Prompt user for install type */
+  async promptInstallType(skipPrompt, isTestFeatureAvailable) {
+    let installType = "recommended", recommendedLabel = isTestFeatureAvailable ? "Recommended: Component development, docs, and testing features." : "Recommended: Component development and docs";
+    return skipPrompt || (installType = await prompt4.select(
+      {
+        message: "What configuration should we install?",
+        options: [
+          {
+            label: recommendedLabel,
+            value: "recommended"
+          },
+          {
+            label: "Minimal: Just the essentials for component development.",
+            value: "light"
+          }
+        ]
+      },
+      createPromptCancelOptions(this.telemetryService, "install-type")
+    )), await this.telemetryService.trackInstallType(installType), installType;
+  }
+  /** Determine features based on install type and user status */
+  determineFeatures(installType, isTestFeatureAvailable, useAi, isAiSetupAvailable) {
+    let features = /* @__PURE__ */ new Set();
+    return installType === "recommended" && (features.add(Feature3.DOCS), features.add(Feature3.A11Y), isTestFeatureAvailable && features.add(Feature3.TEST)), useAi && features.add(Feature3.AI), useAi && isAiSetupAvailable && isTestFeatureAvailable && features.add(Feature3.TEST), features;
+  }
+  /** Prompt user about AI-assisted Forkbook setup */
+  async promptAiSetup(skipPrompt, isAiSetupAvailable) {
+    let useAi = skipPrompt ? !0 : await prompt4.confirm(
+      {
+        message: isAiSetupAvailable ? "Do you want AI features, like skills and prompts, in your Forkbook?" : "Do you want AI features, like skills, in your Forkbook?",
+        initialValue: !0
+      },
+      createPromptCancelOptions(this.telemetryService, "ai-setup")
+    );
+    return useAi && isAiSetupAvailable && await this.telemetryService.trackAiSetupNudge({ skipPrompt }), useAi;
+  }
+}, executeUserPreferences = ({
+  options,
+  ...restOptions
+}) => new UserPreferencesCommand(options).execute(restOptions);
+
+// src/create/generators/baseGenerator.ts
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  configureEslintPlugin,
+  copyTemplateFiles,
+  extractEslintInfo
+} from "@aussieljk/forkbook/internal/cli";
+import {
+  frameworkPackages,
+  getPackageDetails as getPackageDetails2,
+  isCI as isCI3,
+  isCorePackage
+} from "@aussieljk/forkbook/internal/common";
+import { prompt as prompt5 } from "@aussieljk/forkbook/internal/node-logger";
+import { SupportedFramework as SupportedFramework2, SupportedLanguage as SupportedLanguage3 } from "@aussieljk/forkbook/internal/types";
+import { dedent as dedent6 } from "ts-dedent";
+
+// src/create/generators/configure.ts
+import { stat, writeFile } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+import { logger as logger8 } from "@aussieljk/forkbook/internal/node-logger";
+import { Feature as Feature4, SupportedLanguage as SupportedLanguage2, SupportedRenderer } from "@aussieljk/forkbook/internal/types";
+import { dedent as dedent5 } from "ts-dedent";
+var pathExists = async (path3) => stat(path3).then(() => !0).catch(() => !1);
+async function configureMain({
+  addons,
+  extensions = ["js", "jsx", "mjs", "ts", "tsx"],
+  storybookConfigFolder,
+  language,
+  frameworkPackage,
+  prefixes = [],
+  features,
+  ...custom
+}) {
+  let srcPath = resolve2(storybookConfigFolder, "../src"), prefix = await pathExists(srcPath) ? "../src" : "../stories", stories = features.has(Feature4.DOCS) ? [`${prefix}/**/*.mdx`] : [];
+  stories.push(`${prefix}/**/*.stories.@(${extensions.join("|")})`);
+  let config = {
+    stories,
+    addons,
+    ...custom
+  }, isTypescript = language === SupportedLanguage2.TYPESCRIPT, mainConfigTemplate = dedent5`<<import>><<prefix>>const config<<type>> = <<mainContents>>;
+    export default config;`;
+  frameworkPackage || (mainConfigTemplate = mainConfigTemplate.replace("<<import>>", "").replace("<<type>>", ""), logger8.warn("Could not find framework package name"));
+  let mainContents = JSON.stringify(config, null, 2).replace(/['"]%%/g, "").replace(/%%['"]/g, ""), imports = [], finalPrefixes = [...prefixes];
+  custom.framework.includes("path.dirname(") && imports.push("import path from 'node:path';"), isTypescript ? imports.push(`import type { StorybookConfig } from '${frameworkPackage}';`) : finalPrefixes.push(`/** @type { import('${frameworkPackage}').StorybookConfig } */`);
+  let mainJsContents = "";
+  mainJsContents = mainConfigTemplate.replace("<<import>>", `${imports.join(`
+
+`)}
+
+`).replace("<<prefix>>", finalPrefixes.length > 0 ? `${finalPrefixes.join(`
+
+`)}
+` : "").replace("<<type>>", isTypescript ? ": StorybookConfig" : "").replace("<<mainContents>>", mainContents);
+  let mainPath = `./${storybookConfigFolder}/main.${isTypescript ? "ts" : "js"}`;
+  return await writeFile(mainPath, mainJsContents, { encoding: "utf8" }), { mainPath };
+}
+async function configurePreview(options) {
+  let { prefix: frameworkPrefix = "" } = options.frameworkPreviewParts || {}, isTypescript = options.language === SupportedLanguage2.TYPESCRIPT, isJsx = [SupportedRenderer.REACT, SupportedRenderer.REACT_NATIVE].includes(
+    options.renderer
+  ), previewConfigPath = `./${options.storybookConfigFolder}/preview.${isTypescript ? "ts" : "js"}${isJsx ? "x" : ""}`;
+  if (await pathExists(previewConfigPath))
+    return { previewConfigPath };
+  let frameworkPackage = options.frameworkPackage, prefix = [
+    isTypescript && frameworkPackage ? `import type { Preview } from '${frameworkPackage}'` : "",
+    frameworkPrefix
+  ].filter(Boolean).join(`
+`), preview = "";
+  return preview = dedent5`
+    ${prefix}${prefix.length > 0 ? `
+` : ""}
+    ${!isTypescript && frameworkPackage ? `/** @type { import('${frameworkPackage}').Preview } */
+` : ""}const preview${isTypescript ? ": Preview" : ""} = {
+      parameters: {
+        controls: {
+          matchers: {
+           color: /(background|color)$/i,
+           date: /Date$/i,
+          },
+        },
+      },
+    };
+    
+    export default preview;
+    `.replace(`  
+`, "").trim(), await writeFile(previewConfigPath, preview, { encoding: "utf8" }), { previewConfigPath };
+}
+
+// src/create/generators/baseGenerator.ts
+var defaultOptions = {
+  extraPackages: [],
+  extraAddons: [],
+  staticDir: void 0,
+  addScripts: !0,
+  addComponents: !0,
+  extraMain: void 0,
+  extensions: void 0,
+  componentsDestinationPath: void 0,
+  storybookConfigFolder: ".forkbook",
+  installFrameworkPackages: !0
+}, getPackageByValue = (type, value, packages) => {
+  let foundPackage = value ? Object.entries(packages).find(([key, pkgValue]) => pkgValue === value)?.[0] : void 0;
+  if (foundPackage)
+    return foundPackage;
+  throw new Error(
+    dedent6`
+      Could not find ${type} package for ${value}.
+      Make sure this package exists, and if it does, please file an issue as this might be a bug in Forkbook.
+    `
+  );
+}, applyGetAbsolutePathWrapper = (packageName) => isCorePackage(packageName) ? packageName : `%%getAbsolutePath('${packageName}')%%`, applyAddonGetAbsolutePathWrapper = (pkg) => {
+  if (typeof pkg == "string")
+    return applyGetAbsolutePathWrapper(pkg);
+  let obj = { ...pkg };
+  return obj.name = applyGetAbsolutePathWrapper(pkg.name), obj;
+}, getFrameworkDetails = ({
+  framework,
+  shouldApplyRequireWrapperOnPackageNames
+}) => {
+  let frameworkPackage = getPackageByValue("framework", framework, frameworkPackages), frameworkPackagePath = shouldApplyRequireWrapperOnPackageNames ? applyGetAbsolutePathWrapper(frameworkPackage) : frameworkPackage;
+  return {
+    frameworkPackage,
+    frameworkPackagePath
+  };
+}, hasFrameworkTemplates = (framework) => framework ? [
+  SupportedFramework2.NEXTJS_VITE,
+  SupportedFramework2.REACT_VITE
+].includes(framework) : !1;
+async function baseGenerator(packageManager, npmOptions, {
+  language,
+  builder,
+  framework,
+  renderer,
+  features,
+  dependencyCollector,
+  storybookVersionSpecifier
+}, _options) {
+  let options = { ...defaultOptions, ..._options }, shouldApplyRequireWrapperOnPackageNames = packageManager.isStorybookInMonorepo(), taskLog = prompt5.taskLog({
+    id: "base-generator",
+    title: "Generating Forkbook configuration"
+  }), { frameworkPackagePath, frameworkPackage } = getFrameworkDetails({
+    framework,
+    shouldApplyRequireWrapperOnPackageNames
+  }), {
+    extraAddons = [],
+    extraPackages,
+    staticDir,
+    addScripts,
+    addComponents,
+    extraMain,
+    extensions,
+    storybookConfigFolder,
+    componentsDestinationPath,
+    installFrameworkPackages
+  } = {
+    ...defaultOptions,
+    ...options
+  }, addonManager = new AddonService(), { addonsForMain: addons, addonPackages } = addonManager.configureAddons(
+    features,
+    extraAddons
+  ), { packageJson } = packageManager.primaryPackageJson, installedDependencies = new Set(
+    Object.keys({ ...packageJson.dependencies, ...packageJson.devDependencies })
+  ), extraPackagesToInstall = typeof extraPackages == "function" ? await extraPackages({
+    builder
+  }) : extraPackages, allPackages = [
+    "@aussieljk/forkbook",
+    ...installFrameworkPackages ? [frameworkPackage] : [],
+    ...addonPackages,
+    ...extraPackagesToInstall || []
+  ].filter((pkg) => pkg && (pkg === "@aussieljk/forkbook" || !isCorePackage(pkg))), packagesToInstall = [...new Set(allPackages)].filter(
+    (packageToInstall) => !installedDependencies.has(getPackageDetails2(packageToInstall)[0])
+  ), eslintPluginPackage = null;
+  try {
+    if (!isCI3()) {
+      let { hasEslint, isStorybookPluginInstalled, isFlatConfig, eslintConfigFile } = (
+        // TODO: Investigate why packageManager type does not match on CI
+        await extractEslintInfo(packageManager)
+      );
+      hasEslint && !isStorybookPluginInstalled && (eslintPluginPackage = "eslint-plugin-storybook", packagesToInstall.push(eslintPluginPackage), taskLog.message("- Configuring ESLint plugin"), await configureEslintPlugin({
+        eslintConfigFile,
+        // TODO: Investigate why packageManager type does not match on CI
+        packageManager,
+        isFlatConfig
+      }));
+    }
+  } catch {
+  }
+  let versionedPackages = await packageManager.getVersionedPackages(
+    packagesToInstall,
+    { storybookVersionSpecifier }
+  );
+  versionedPackages.length > 0 && (npmOptions.type === "devDependencies" ? dependencyCollector.addDevDependencies(versionedPackages) : dependencyCollector.addDependencies(versionedPackages)), await mkdir(`./${storybookConfigFolder}`, { recursive: !0 });
+  let prefixes = shouldApplyRequireWrapperOnPackageNames ? [
+    'import { dirname } from "path"',
+    'import { fileURLToPath } from "url"',
+    language === SupportedLanguage3.JAVASCRIPT ? dedent6`/**
+            * This function is used to resolve the absolute path of a package.
+            * It is needed in projects that are set up within a monorepo.
+            */
+            function getAbsolutePath(value) {
+              return dirname(fileURLToPath(import.meta.resolve(\`\${value}/package.json\`)))
+            }` : dedent6`/**
+          * This function is used to resolve the absolute path of a package.
+          * It is needed in projects that are set up within a monorepo.
+          */
+          function getAbsolutePath(value: string) {
+            return dirname(fileURLToPath(import.meta.resolve(\`\${value}/package.json\`)))
+          }`
+  ] : [], configurationFileExtension = language === SupportedLanguage3.TYPESCRIPT ? "ts" : "js";
+  if (taskLog.message(`- Configuring main.${configurationFileExtension}`), await configureMain({
+    framework: frameworkPackagePath,
+    features,
+    frameworkPackage,
+    prefixes,
+    storybookConfigFolder,
+    addons: shouldApplyRequireWrapperOnPackageNames ? addons.map((addon) => applyAddonGetAbsolutePathWrapper(addon)) : addons,
+    extensions,
+    language,
+    ...staticDir ? { staticDirs: [join("..", staticDir)] } : null,
+    ...extraMain
+  }), taskLog.message(`- Configuring preview.${configurationFileExtension}`), await configurePreview({
+    frameworkPreviewParts: _options.frameworkPreviewParts,
+    storybookConfigFolder,
+    language,
+    frameworkPackage,
+    renderer
+  }), addScripts && (taskLog.message("- Adding Forkbook command to package.json"), packageManager.addStorybookCommandInScripts({
+    port: 6006
+  })), addComponents) {
+    let templateLocation = hasFrameworkTemplates(framework) ? framework : renderer;
+    invariant(templateLocation, `Could not find template location for ${framework} or ${renderer}`), taskLog.message("- Copying framework templates"), await copyTemplateFiles({
+      templateLocation,
+      packageManager,
+      language,
+      destination: componentsDestinationPath,
+      commonAssetsDir: join(
+        resolvePackageDir("@aussieljk/forkbook"),
+        "assets/create/rendererAssets/common"
+      ),
+      features
+    });
+  }
+  return taskLog.success("Forkbook configuration generated", { showLog: !0 }), {
+    configDir: storybookConfigFolder,
+    storybookCommand: _options.storybookCommand,
+    shouldRunDev: _options.shouldRunDev
+  };
+}
+
+// src/create/commands/GeneratorExecutionCommand.ts
+var GeneratorExecutionCommand = class {
+  /** Execute generator for the detected project type */
+  constructor(dependencyCollector, jsPackageManager, addonService = new AddonService(), telemetryService = new TelemetryService()) {
+    this.dependencyCollector = dependencyCollector;
+    this.jsPackageManager = jsPackageManager;
+    this.addonService = addonService;
+    this.telemetryService = telemetryService;
+    /** Execute the project-specific generator */
+    this.executeProjectGenerator = async ({
+      projectType,
+      frameworkInfo,
+      options,
+      selectedFeatures,
+      language
+    }) => {
+      let generator = generatorRegistry.get(projectType);
+      if (!generator)
+        throw new Error(`No generator found for project type: ${projectType}`);
+      let npmOptions = {
+        type: "devDependencies",
+        skipInstall: options.skipInstall
+      }, generatorModule = generator, frameworkOptions = await generatorModule.configure(this.jsPackageManager, {
+        framework: frameworkInfo.framework,
+        renderer: frameworkInfo.renderer,
+        builder: frameworkInfo.builder,
+        language,
+        storybookVersionSpecifier: options.storybookVersionSpecifier,
+        telemetryService: this.telemetryService,
+        linkable: !!options.linkable,
+        features: selectedFeatures,
+        dependencyCollector: this.dependencyCollector,
+        yes: options.yes
+      }), generatorOptions = {
+        language,
+        builder: frameworkInfo.builder,
+        framework: frameworkInfo.framework,
+        renderer: frameworkInfo.renderer,
+        storybookVersionSpecifier: options.storybookVersionSpecifier,
+        linkable: !!options.linkable,
+        yes: !!options.yes,
+        projectType,
+        features: selectedFeatures,
+        dependencyCollector: this.dependencyCollector
+      }, postInstall2 = generatorModule.postInstall ? async () => {
+        await generatorModule.postInstall?.({ packageManager: this.jsPackageManager });
+      } : void 0;
+      if (frameworkOptions.skipGenerator)
+        return generatorModule.postConfigure && await generatorModule.postConfigure({ packageManager: this.jsPackageManager }), {
+          shouldRunDev: frameworkOptions.shouldRunDev,
+          storybookCommand: frameworkOptions.storybookCommand,
+          extraAddons: [],
+          postInstall: postInstall2
+        };
+      let extraAddons = this.addonService.getAddonsForFeatures(selectedFeatures), generatorResult = await baseGenerator(
+        this.jsPackageManager,
+        npmOptions,
+        generatorOptions,
+        {
+          ...frameworkOptions,
+          extraAddons: [...frameworkOptions.extraAddons ?? [], ...extraAddons]
+        }
+      );
+      return generatorModule.postConfigure && await generatorModule.postConfigure({ packageManager: this.jsPackageManager }), {
+        ...generatorResult,
+        extraAddons,
+        postInstall: postInstall2
+      };
+    };
+  }
+  async execute({
+    projectType,
+    options,
+    frameworkInfo,
+    selectedFeatures,
+    language
+  }) {
+    let { postInstall: postInstall2, ...generatorResult } = await this.executeProjectGenerator({
+      projectType,
+      frameworkInfo,
+      options,
+      selectedFeatures,
+      language
+    });
+    return {
+      ...generatorResult,
+      configDir: "configDir" in generatorResult ? generatorResult.configDir : void 0,
+      storybookCommand: generatorResult.storybookCommand !== void 0 ? generatorResult.storybookCommand : this.jsPackageManager.getRunCommand("forkbook"),
+      /**
+       * Hook to run after dependencies are installed. Optional — only the generators that need to do
+       * something after `installDependencies` will set this.
+       */
+      postInstall: postInstall2
+    };
+  }
+}, executeGeneratorExecution = ({
+  dependencyCollector,
+  packageManager,
+  ...options
+}) => new GeneratorExecutionCommand(dependencyCollector, packageManager).execute(options);
+
+// src/create/commands/AddonConfigurationCommand.ts
+import { AddonVitestService as AddonVitestService2 } from "@aussieljk/forkbook/internal/cli";
+import { CLI_COLORS as CLI_COLORS2, logger as logger9, prompt as prompt6 } from "@aussieljk/forkbook/internal/node-logger";
+import { ErrorCollector } from "@aussieljk/forkbook/internal/telemetry";
+import { dedent as dedent7 } from "ts-dedent";
+var ADDON_INSTALLATION_INSTRUCTIONS = {
+  "@aussieljk/forkbook/addon-vitest": "https://storybook.js.org/docs/writing-tests/integrations/vitest-addon#manual-setup-advanced"
+}, AddonConfigurationCommand = class {
+  constructor(packageManager, commandOptions, addonVitestService = new AddonVitestService2(packageManager), telemetryService = new TelemetryService()) {
+    this.packageManager = packageManager;
+    this.commandOptions = commandOptions;
+    this.addonVitestService = addonVitestService;
+    this.telemetryService = telemetryService;
+  }
+  /** Execute addon configuration */
+  async execute({
+    addons,
+    configDir
+  }) {
+    if (!configDir || addons.length === 0)
+      return { status: "success" };
+    try {
+      let { hasFailures, addonResults } = await this.configureAddons(configDir, addons);
+      if (addonResults.has("@aussieljk/forkbook/addon-vitest")) {
+        let { result } = await this.addonVitestService.installPlaywright({
+          yes: this.commandOptions.yes,
+          useRemotePkg: !!this.commandOptions.skipInstall
+        });
+        await this.telemetryService.trackPlaywrightPromptDecision(result);
+      }
+      return hasFailures && this.logManualAddonInstructions(
+        addons.filter((addon) => addonResults.get(addon)?.result === "failed")
+      ), { status: hasFailures ? "failed" : "success" };
+    } catch (e) {
+      return logger9.error("Unexpected error during addon configuration:"), logger9.error(e), { status: "failed" };
+    }
+  }
+  getAddonsWithInstructions(addons) {
+    return addons.filter((addon) => ADDON_INSTALLATION_INSTRUCTIONS[addon]);
+  }
+  logManualAddonInstructions(addons) {
+    let addonsWithInstructions = this.getAddonsWithInstructions(addons);
+    addonsWithInstructions.length > 0 && logger9.warn(dedent7`
+      The following addons couldn't be configured:
+
+      ${addonsWithInstructions.map((addon) => {
+      let manualInstructionLink = ADDON_INSTALLATION_INSTRUCTIONS[addon];
+      return `- ${addon}: ${manualInstructionLink}`;
+    }).join(`
+`)}
+
+      ${addonsWithInstructions.length > 0 ? "Please follow each addon's configuration instructions manually." : ""}
+      `);
+  }
+  /** Configure test addons */
+  async configureAddons(configDir, addons) {
+    let { postinstallAddon } = await import("./postinstallAddon-GYGMWDL6.js"), task = prompt6.taskLog({
+      id: "configure-addons",
+      title: "Configuring addons..."
+    }), addonResults = /* @__PURE__ */ new Map();
+    for (let addon of addons)
+      try {
+        task.message(`Configuring ${addon}...`);
+        let options = {
+          packageManager: this.packageManager.type,
+          configDir,
+          yes: !0,
+          skipInstall: !0,
+          // Dependencies were installed in the preceding init step (unless the
+          // user opted out), so nested `storybook` invocations can run the local
+          // binary instead of fetching an ephemeral copy via dlx/npx.
+          useRemotePkg: !!this.commandOptions.skipInstall,
+          skipDependencyManagement: !0,
+          logger: logger9,
+          prompt: prompt6
+        };
+        addon === "@aussieljk/forkbook/addon-vitest" ? await postInstall(options) : await postinstallAddon(addon, options), task.message(`${addon} configured
+`), addonResults.set(addon, null);
+      } catch (e) {
+        logger9.debug(e), ErrorCollector.addError(e), addonResults.set(addon, e);
+      }
+    let hasFailures = [...addonResults.values()].some((result) => result !== null);
+    return hasFailures ? task.error("Failed to configure addons") : task.success("Addons configured successfully"), addons.forEach((addon, index) => {
+      let error = addonResults.get(addon);
+      logger9.log(CLI_COLORS2.muted(error ? `\u274C ${addon}` : `\u2705 ${addon}`), {
+        spacing: index === 0 ? 1 : 0
+      });
+    }), { hasFailures, addonResults };
+  }
+}, executeAddonConfiguration = ({
+  packageManager,
+  options,
+  ...rest
+}) => new AddonConfigurationCommand(packageManager, options).execute(rest);
+
+// src/create/commands/DependencyInstallationCommand.ts
+import { AddonVitestService as AddonVitestService3 } from "@aussieljk/forkbook/internal/cli";
+import { logger as logger10, prompt as prompt7 } from "@aussieljk/forkbook/internal/node-logger";
+import { MinimumReleaseAgeHandledError as MinimumReleaseAgeHandledError2 } from "@aussieljk/forkbook/internal/server-errors";
+import { ErrorCollector as ErrorCollector2 } from "@aussieljk/forkbook/internal/telemetry";
+import { Feature as Feature5 } from "@aussieljk/forkbook/internal/types";
+var DependencyInstallationCommand = class {
+  constructor(dependencyCollector, packageManager, addonVitestService = new AddonVitestService3(packageManager)) {
+    this.dependencyCollector = dependencyCollector;
+    this.packageManager = packageManager;
+    this.addonVitestService = addonVitestService;
+  }
+  /** Execute dependency installation */
+  async execute({
+    skipInstall = !1,
+    selectedFeatures
+  }) {
+    if (await this.collectAddonDependencies(selectedFeatures), !this.dependencyCollector.hasPackages() && skipInstall)
+      return { status: "success" };
+    let { dependencies, devDependencies } = this.dependencyCollector.getAllPackages(), task = prompt7.taskLog({
+      id: "adding-dependencies",
+      title: "Adding dependencies to package.json"
+    });
+    if (dependencies.length > 0 && (task.message(`Adding dependencies:
+` + dependencies.map((dep) => `- ${dep}`).join(`
+`)), await this.packageManager.addDependencies(
+      { type: "dependencies", skipInstall: !0 },
+      dependencies
+    )), devDependencies.length > 0 && (task.message(
+      `Adding devDependencies:
+` + devDependencies.map((dep) => `- ${dep}`).join(`
+`)
+    ), await this.packageManager.addDependencies(
+      { type: "devDependencies", skipInstall: !0 },
+      devDependencies
+    )), task.success("Dependencies added to package.json", { showLog: !0 }), !skipInstall && this.dependencyCollector.hasPackages())
+      try {
+        await this.packageManager.installDependencies();
+      } catch (err) {
+        if (err instanceof MinimumReleaseAgeHandledError2)
+          throw err;
+        return ErrorCollector2.addError(err), { status: "failed" };
+      }
+    return { status: "success" };
+  }
+  /**
+   * Collect addon dependencies (the caller adds them to package.json and installs them afterwards).
+   * For pnpm catalog workspaces this also registers the derived entries in pnpm-workspace.yaml so
+   * the subsequent install can resolve their `catalog:` specifiers.
+   */
+  async collectAddonDependencies(selectedFeatures) {
+    try {
+      if (selectedFeatures.has(Feature5.TEST)) {
+        let vitestDeps = await this.addonVitestService.collectDependencies();
+        this.dependencyCollector.addDevDependencies(vitestDeps);
+      }
+    } catch (err) {
+      logger10.warn(`Failed to collect addon dependencies: ${err}`);
+    }
+  }
+}, executeDependencyInstallation = ({
+  dependencyCollector,
+  packageManager,
+  ...props
+}) => new DependencyInstallationCommand(dependencyCollector, packageManager).execute(props);
+
+// src/create/commands/FinalizationCommand.ts
+import fs from "node:fs/promises";
+import { getProjectRoot as getProjectRoot3 } from "@aussieljk/forkbook/internal/common";
+import { CLI_COLORS as CLI_COLORS3, logTracker, logger as logger11 } from "@aussieljk/forkbook/internal/node-logger";
+import { ErrorCollector as ErrorCollector3 } from "@aussieljk/forkbook/internal/telemetry";
+import { dedent as dedent8 } from "ts-dedent";
+var FinalizationCommand = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /** Execute finalization steps */
+  async execute({ storybookCommand }) {
+    await this.updateGitignore(), ErrorCollector3.getErrors().length > 0 ? await this.printFailureMessage(storybookCommand) : this.printSuccessMessage(storybookCommand);
+  }
+  /** Update .gitignore with Forkbook-specific entries */
+  async updateGitignore() {
+    let foundGitIgnoreFile = up(".gitignore"), rootDirectory = getProjectRoot3();
+    if (!foundGitIgnoreFile || !foundGitIgnoreFile.includes(rootDirectory))
+      return;
+    let contents = await fs.readFile(foundGitIgnoreFile, "utf-8"), hasStorybookLog = contents.includes("*storybook.log"), hasStorybookStatic = contents.includes("storybook-static"), linesToAdd = [
+      hasStorybookLog ? "" : "*storybook.log",
+      hasStorybookStatic ? "" : "storybook-static"
+    ].filter(Boolean).join(`
+`);
+    linesToAdd && await fs.appendFile(foundGitIgnoreFile, `
+${linesToAdd}
+`);
+  }
+  async printFailureMessage(storybookCommand) {
+    logger11.warn(
+      "Forkbook setup completed, but some non-blocking errors occurred. Please check the log file below for details."
+    ), this.printNextSteps(storybookCommand);
+    try {
+      let logFile = await logTracker.writeToFile(this.options.logfile);
+      logger11.warn(`Debug logs are written to: ${logFile}`);
+    } catch {
+    }
+  }
+  getSetupSkillPromptText() {
+    return `Run \`${this.options.setupSkillCommand}\` and follow its instructions precisely.`;
+  }
+  printSuccessMessage(storybookCommand) {
+    this.options.showAgentFollowUp ? logger11.step(
+      CLI_COLORS3.storybook(
+        dedent8`Forkbook is installed but is not entirely set up yet.
+          To finish setting up, now run \`${this.options.setupSkillCommand}\` and follow its instructions precisely.`
+      )
+    ) : logger11.step(CLI_COLORS3.success("Forkbook was successfully installed in your project!")), this.printNextSteps(storybookCommand);
+  }
+  printNextSteps(storybookCommand) {
+    storybookCommand && logger11.log(`To run Forkbook, run ${CLI_COLORS3.cta(storybookCommand)}. CTRL+C to stop.`), this.options.showAiInstructions ? logger11.log(dedent8`
+      Official documentation reference: ${CLI_COLORS3.cta("https://storybook.js.org/llms.txt")}
+    `) : logger11.log(dedent8`
+      Want to learn more about Forkbook? ${CLI_COLORS3.cta("https://storybook.js.org/")}
+      Having trouble or want to chat? ${CLI_COLORS3.cta("https://discord.gg/storybook/")}
+    `), this.options.showAiInstructions && logger11.step(dedent8`To finalize setting up with AI, paste this prompt to your AI agent:
+
+        ${CLI_COLORS3.storybook(this.getSetupSkillPromptText())}
+      `);
+  }
+}, executeFinalization = ({
+  logfile,
+  showAgentFollowUp,
+  showAiInstructions,
+  setupSkillCommand,
+  ...params
+}) => new FinalizationCommand({
+  logfile,
+  showAgentFollowUp,
+  showAiInstructions,
+  setupSkillCommand
+}).execute(params);
+
+// src/create/dependency-collector.ts
+var DependencyCollector = class {
+  constructor() {
+    this.packages = /* @__PURE__ */ new Map([
+      ["dependencies", /* @__PURE__ */ new Map()],
+      ["devDependencies", /* @__PURE__ */ new Map()]
+    ]);
+  }
+  /** Add development dependencies */
+  addDevDependencies(packageNames) {
+    this.add("devDependencies", packageNames);
+  }
+  /** Add regular dependencies */
+  addDependencies(packageNames) {
+    this.add("dependencies", packageNames);
+  }
+  /** Get all packages across all types */
+  getAllPackages() {
+    return {
+      dependencies: this.getDependencies(),
+      devDependencies: this.getDevDependencies()
+    };
+  }
+  /** Check if collector has any packages */
+  hasPackages() {
+    return this.packages.get("dependencies").size > 0 || this.packages.get("devDependencies").size > 0;
+  }
+  /** Get all version conflicts across all dependency types */
+  getVersionConflicts() {
+    let conflicts = [];
+    for (let [type, typeMap] of this.packages.entries()) {
+      let packageNames = /* @__PURE__ */ new Map();
+      typeMap.forEach((version, name) => {
+        let versions2 = packageNames.get(name) || [];
+        versions2.push(version), packageNames.set(name, versions2);
+      }), packageNames.forEach((versions2, name) => {
+        versions2.length > 1 && new Set(versions2).size > 1 && conflicts.push({
+          packageName: name,
+          existingVersion: versions2[0],
+          newVersion: versions2[versions2.length - 1],
+          type
+        });
+      });
+    }
+    return conflicts;
+  }
+  /** Merge dependencies from another collector */
+  merge(other) {
+    let { dependencies, devDependencies } = other.getAllPackages();
+    this.addDependencies(dependencies), this.addDevDependencies(devDependencies);
+  }
+  /** Validate that all packages have valid version specifiers */
+  validate() {
+    let errors = [];
+    for (let [type, typeMap] of this.packages.entries())
+      typeMap.forEach((version, name) => {
+        (!name || name.trim() === "") && errors.push(`Invalid package name in ${type}: empty or whitespace`), version === "" && errors.push(`Package ${name} in ${type} has empty version`);
+      });
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /** Get count of packages by type */
+  getPackageCount(type) {
+    return type ? this.packages.get(type).size : this.packages.get("dependencies").size + this.packages.get("devDependencies").size;
+  }
+  /**
+   * Add packages to the collector
+   *
+   * @param type - The dependency type (dependencies or devDependencies)
+   * @param packageNames - Array of package names, optionally with version specifiers (e.g.,
+   *   'react@18.0.0')
+   */
+  add(type, packageNames) {
+    let typeMap = this.packages.get(type);
+    for (let pkg of packageNames) {
+      let { name, version } = this.parsePackage(pkg);
+      typeMap.has(name) ? version && typeMap.set(name, version) : typeMap.set(name, version || "latest");
+    }
+  }
+  /** Get all packages with their versions for a specific type */
+  getPackages(type) {
+    let typeMap = this.packages.get(type);
+    return Array.from(typeMap.entries()).map(
+      ([name, version]) => version === "latest" ? name : `${name}@${version}`
+    );
+  }
+  /** Get all development dependencies */
+  getDevDependencies() {
+    return this.getPackages("devDependencies");
+  }
+  /** Get all regular dependencies */
+  getDependencies() {
+    return this.getPackages("dependencies");
+  }
+  /**
+   * Parse a package string into name and version
+   *
+   * @param pkg - Package string (e.g., 'react@18.0.0' or 'react')
+   */
+  parsePackage(pkg) {
+    let scopedMatch = pkg.match(/^(@[^@]+\/[^@]+)(?:@(.+))?$/);
+    if (scopedMatch)
+      return {
+        name: scopedMatch[1],
+        version: scopedMatch[2]
+      };
+    let regularMatch = pkg.match(/^([^@]+)(?:@(.+))?$/);
+    return regularMatch ? {
+      name: regularMatch[1],
+      version: regularMatch[2]
+    } : { name: pkg };
+  }
+};
+
+// src/create/generators/NEXTJS/index.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { ProjectType as ProjectType2 } from "@aussieljk/forkbook/internal/cli";
+import {
+  SupportedBuilder as SupportedBuilder2,
+  SupportedFramework as SupportedFramework3,
+  SupportedRenderer as SupportedRenderer2
+} from "@aussieljk/forkbook/internal/types";
+var NEXTJS_default = {
+  metadata: {
+    projectType: ProjectType2.NEXTJS,
+    renderer: SupportedRenderer2.REACT,
+    framework: SupportedFramework3.NEXTJS_VITE,
+    builderOverride: SupportedBuilder2.VITE
+  },
+  configure: async () => {
+    let staticDir;
+    return existsSync2(join2(process.cwd(), "public")) && (staticDir = "public"), {
+      staticDir,
+      extraPackages: ["vite"]
+    };
+  }
+};
+
+// src/create/generators/REACT/index.ts
+import { ProjectType as ProjectType3 } from "@aussieljk/forkbook/internal/cli";
+import { SupportedLanguage as SupportedLanguage4, SupportedRenderer as SupportedRenderer3 } from "@aussieljk/forkbook/internal/types";
+var REACT_default = {
+  metadata: {
+    projectType: ProjectType3.REACT,
+    renderer: SupportedRenderer3.REACT
+  },
+  configure: async (packageManager, { language }) => ({
+    extraPackages: language === SupportedLanguage4.JAVASCRIPT ? ["prop-types"] : []
+  })
+};
+
+// src/create/generators/REACT_NATIVE/index.ts
+import { join as join4 } from "node:path";
+import { ProjectType as ProjectType4, copyTemplateFiles as copyTemplateFiles2 } from "@aussieljk/forkbook/internal/cli";
+import { executeCommand as executeCommand2 } from "@aussieljk/forkbook/internal/common";
+import { CLI_COLORS as CLI_COLORS4, logger as logger13, prompt as prompt9 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  SupportedBuilder as SupportedBuilder3,
+  SupportedLanguage as SupportedLanguage6,
+  SupportedRenderer as SupportedRenderer4
+} from "@aussieljk/forkbook/internal/types";
+import { dedent as dedent9 } from "ts-dedent";
+
+// src/create/generators/REACT_NATIVE/generateEntrypoint.ts
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "node:fs/promises";
+import path, { join as join3 } from "node:path";
+import { SupportedLanguage as SupportedLanguage5 } from "@aussieljk/forkbook/internal/types";
+var ENTRYPOINT_TEMPLATE_DIR = join3(
+  resolvePackageDir("@aussieljk/forkbook"),
+  "assets/create/templates/react-native"
+), getEntrypointExtension = (language) => language === SupportedLanguage5.TYPESCRIPT ? "ts" : "js", getEntrypointTemplatePath = (templateVariant = "default") => join3(ENTRYPOINT_TEMPLATE_DIR, templateVariant === "expo" ? "index.expo.js" : "index.js"), generateReactNativeEntrypoint = async ({
+  language,
+  templateVariant = "default",
+  cwd = process.cwd()
+}) => {
+  let extension = getEntrypointExtension(language), templatePath = getEntrypointTemplatePath(templateVariant), targetDir = path.join(cwd, RN_STORYBOOK_DIR), targetPath = path.join(targetDir, `index.${extension}`), templateContents = await readFile(templatePath, "utf-8");
+  return await mkdir2(targetDir, { recursive: !0 }), await writeFile2(targetPath, templateContents, "utf-8"), {
+    targetPath,
+    extension
+  };
+};
+
+// src/create/generators/REACT_NATIVE/generateScripts.ts
+var STORYBOOK_ENV_ASSIGNMENT = "STORYBOOK_ENABLED=true", STORYBOOK_ENV_PREFIX = `cross-env ${STORYBOOK_ENV_ASSIGNMENT}`, STORYBOOK_ENV_PATTERN = /(?:^|\s)STORYBOOK_ENABLED=/, CROSS_ENV_PREFIX_PATTERN = /^(cross-env(?:-shell)?\s+)/, withStorybookEnv = (scriptValue) => {
+  let normalizedScriptValue = scriptValue.trim();
+  return STORYBOOK_ENV_PATTERN.test(normalizedScriptValue) ? normalizedScriptValue : CROSS_ENV_PREFIX_PATTERN.test(normalizedScriptValue) ? normalizedScriptValue.replace(
+    CROSS_ENV_PREFIX_PATTERN,
+    `$1${STORYBOOK_ENV_ASSIGNMENT} `
+  ) : `${STORYBOOK_ENV_PREFIX} ${normalizedScriptValue}`.trim();
+}, deriveStorybookPlatformScripts = (scripts) => {
+  let scriptsToAdd = {}, missingBaseScripts = [], iosScript = typeof scripts?.ios == "string" ? scripts.ios.trim() : "";
+  iosScript ? scriptsToAdd["storybook:ios"] = withStorybookEnv(iosScript) : missingBaseScripts.push("ios");
+  let androidScript = typeof scripts?.android == "string" ? scripts.android.trim() : "";
+  return androidScript ? scriptsToAdd["storybook:android"] = withStorybookEnv(androidScript) : missingBaseScripts.push("android"), { scriptsToAdd, missingBaseScripts };
+};
+
+// src/create/generators/REACT_NATIVE/metroConfig.ts
+import { access, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import path2 from "node:path";
+import { parser, recast, types as t } from "@aussieljk/forkbook/internal/babel";
+import { logger as logger12, prompt as prompt8 } from "@aussieljk/forkbook/internal/node-logger";
+var METRO_CONFIG_CANDIDATES = ["metro.config.ts", "metro.config.js", "metro.config.cjs"], METRO_SETUP_DOCS_LINK = "https://storybookjs.github.io/react-native/docs/intro/configuration/metro-configuration", METRO_FALLBACK_COMMENT_MARKER = "storybook-react-native-metro-codemod-fallback", EXPO_CREATE_METRO_COMMAND = {
+  command: "expo",
+  args: ["customize", "metro.config.js"]
+}, STORYBOOK_PACKAGE_PATTERNS = [
+  "'@storybook/",
+  // @storybook/* scoped packages (single-quoted)
+  '"@storybook/',
+  // @storybook/* scoped packages (double-quoted)
+  "'storybook'",
+  // bare 'storybook' package specifier
+  '"storybook"',
+  // bare "storybook" package specifier
+  "'storybook/",
+  // storybook/* sub-path (single-quoted)
+  '"storybook/'
+  // storybook/* sub-path (double-quoted)
+], hasStorybookPackage = (value) => value === "storybook" || value.startsWith("@storybook/") || value.startsWith("storybook/"), isAstNode = (value) => !!value && typeof value == "object" && "type" in value, getRequirePackageFromCallExpression = (callExpression) => {
+  if (t.isIdentifier(callExpression.callee, { name: "require" })) {
+    let [firstArgument] = callExpression.arguments;
+    return t.isStringLiteral(firstArgument) ? firstArgument.value : null;
+  }
+  if (t.isMemberExpression(callExpression.callee) && t.isCallExpression(callExpression.callee.object)) {
+    let objectCall = callExpression.callee.object;
+    if (!t.isIdentifier(objectCall.callee, { name: "require" }))
+      return null;
+    let [firstArgument] = objectCall.arguments;
+    return t.isStringLiteral(firstArgument) ? firstArgument.value : null;
+  }
+  return null;
+}, statementContainsStorybookCall = (statement) => {
+  let visited = /* @__PURE__ */ new WeakSet(), queue = [statement];
+  for (; queue.length > 0; ) {
+    let current = queue.pop();
+    if (!(!current || typeof current != "object") && !visited.has(current)) {
+      if (visited.add(current), isAstNode(current) && t.isCallExpression(current)) {
+        let packageName = getRequirePackageFromCallExpression(current);
+        if (packageName && hasStorybookPackage(packageName))
+          return !0;
+      }
+      if (Array.isArray(current)) {
+        queue.push(...current);
+        continue;
+      }
+      for (let value of Object.values(current))
+        value && (typeof value == "object" || Array.isArray(value)) && queue.push(value);
+    }
+  }
+  return !1;
+}, isModuleExportsTarget = (left) => t.isMemberExpression(left) && t.isIdentifier(left.object, { name: "module" }) && t.isIdentifier(left.property, { name: "exports" }), isWithStorybookCall = (node, withStorybookLocalName) => t.isCallExpression(node) && t.isIdentifier(node.callee, { name: withStorybookLocalName }), parseConfig = (source) => recast.parse(source, {
+  parser: {
+    parse(code) {
+      return parser.parse(code, {
+        sourceType: "unambiguous",
+        plugins: ["jsx", "typescript", "decorators-legacy", "classProperties"]
+      });
+    }
+  }
+}), usesEsmSyntax = (program) => program.body.some(
+  (node) => t.isImportDeclaration(node) || t.isExportDefaultDeclaration(node) || t.isExportNamedDeclaration(node) || t.isExportAllDeclaration(node)
+), containsStorybookImport = (source) => {
+  try {
+    let ast = parseConfig(source);
+    for (let statement of ast.program.body)
+      if (t.isImportDeclaration(statement) && hasStorybookPackage(statement.source.value) || t.isExportNamedDeclaration(statement) && statement.source && hasStorybookPackage(statement.source.value) || statementContainsStorybookCall(statement))
+        return !0;
+  } catch {
+    return STORYBOOK_PACKAGE_PATTERNS.some((pattern) => source.includes(pattern));
+  }
+  return !1;
+}, hasWithStorybookBinding = (program) => {
+  for (let statement of program.body) {
+    if (t.isImportDeclaration(statement) && statement.source.value === "@storybook/react-native/withStorybook") {
+      let withStorybookSpecifier = statement.specifiers.find(
+        (specifier) => t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported, { name: "withStorybook" })
+      );
+      if (withStorybookSpecifier && t.isImportSpecifier(withStorybookSpecifier))
+        return withStorybookSpecifier.local.name;
+    }
+    if (t.isVariableDeclaration(statement))
+      for (let declaration of statement.declarations) {
+        if (!t.isObjectPattern(declaration.id) || !t.isCallExpression(declaration.init) || !t.isIdentifier(declaration.init.callee, { name: "require" }))
+          continue;
+        let [firstArgument] = declaration.init.arguments;
+        if (t.isStringLiteral(firstArgument) && firstArgument.value === "@storybook/react-native/withStorybook") {
+          for (let property of declaration.id.properties)
+            if (t.isObjectProperty(property) && t.isIdentifier(property.key, { name: "withStorybook" }) && t.isIdentifier(property.value))
+              return property.value.name;
+        }
+      }
+  }
+}, getBodyInsertionIndex = (program) => {
+  for (let i = 0; i < program.body.length; i++) {
+    let statement = program.body[i];
+    if (!(t.isExpressionStatement(statement) && t.isStringLiteral(statement.expression)))
+      return i;
+  }
+  return program.body.length;
+}, shiftFileLeadingComments = (fromNode, toNode) => {
+  let from = fromNode, to = toNode, isFileLeading = (c) => typeof c.start == "number" && c.start === 0;
+  if (Array.isArray(from.comments)) {
+    let fileLeading = from.comments.filter((c) => c.leading && isFileLeading(c));
+    fileLeading.length > 0 && (to.comments = [...fileLeading, ...to.comments ?? []], from.comments = from.comments.filter((c) => !(c.leading && isFileLeading(c))));
+  }
+  if (Array.isArray(from.leadingComments)) {
+    let fileLeading = from.leadingComments.filter(isFileLeading);
+    fileLeading.length > 0 && (to.leadingComments = [...fileLeading, ...to.leadingComments ?? []], from.leadingComments = from.leadingComments.filter((c) => !isFileLeading(c)));
+  }
+}, injectWithStorybookImport = (program, useEsmImport) => {
+  if (useEsmImport) {
+    let importDeclaration = t.importDeclaration(
+      [t.importSpecifier(t.identifier("withStorybook"), t.identifier("withStorybook"))],
+      t.stringLiteral("@storybook/react-native/withStorybook")
+    ), lastImportIndex = [...program.body].reverse().findIndex((statement) => t.isImportDeclaration(statement));
+    if (lastImportIndex === -1) {
+      let insertAt2 = getBodyInsertionIndex(program), nodeAtInsert2 = program.body[insertAt2];
+      nodeAtInsert2 && shiftFileLeadingComments(nodeAtInsert2, importDeclaration), program.body.splice(insertAt2, 0, importDeclaration);
+      return;
+    }
+    let insertAfter = program.body.length - lastImportIndex;
+    program.body.splice(insertAfter, 0, importDeclaration);
+    return;
+  }
+  let requireDeclaration = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      t.objectPattern([
+        t.objectProperty(t.identifier("withStorybook"), t.identifier("withStorybook"), !1, !0)
+      ]),
+      t.callExpression(t.identifier("require"), [
+        t.stringLiteral("@storybook/react-native/withStorybook")
+      ])
+    )
+  ]), insertAt = getBodyInsertionIndex(program), nodeAtInsert = program.body[insertAt];
+  nodeAtInsert && shiftFileLeadingComments(nodeAtInsert, requireDeclaration), program.body.splice(insertAt, 0, requireDeclaration);
+}, prependMetroFallbackComment = (source) => source.includes(METRO_FALLBACK_COMMENT_MARKER) ? source : `/**
+ * ${METRO_FALLBACK_COMMENT_MARKER}
+ * Storybook could not automatically update this Metro config file.
+ * Please follow the manual setup instructions:
+ * ${METRO_SETUP_DOCS_LINK}
+ */
+${source}`, transformMetroConfigSource = (source, filePath) => {
+  let ast = parseConfig(source), program = ast.program, withStorybookLocalName = hasWithStorybookBinding(program) ?? "withStorybook", matchedExport = !1, changed = !1;
+  for (let statement of program.body) {
+    if (t.isExpressionStatement(statement) && t.isAssignmentExpression(statement.expression)) {
+      if (!isModuleExportsTarget(statement.expression.left))
+        continue;
+      if (matchedExport = !0, isWithStorybookCall(statement.expression.right, withStorybookLocalName))
+        return { action: "already-configured" };
+      statement.expression.right = t.callExpression(t.identifier(withStorybookLocalName), [
+        statement.expression.right
+      ]), changed = !0;
+      continue;
+    }
+    if (t.isExportDefaultDeclaration(statement)) {
+      if (matchedExport = !0, t.isFunctionDeclaration(statement.declaration)) {
+        let functionExpression = t.functionExpression(
+          statement.declaration.id,
+          statement.declaration.params,
+          statement.declaration.body,
+          statement.declaration.generator,
+          statement.declaration.async
+        );
+        functionExpression.returnType = statement.declaration.returnType ?? null, functionExpression.typeParameters = statement.declaration.typeParameters ?? null, statement.declaration = t.callExpression(t.identifier(withStorybookLocalName), [
+          functionExpression
+        ]), changed = !0;
+        continue;
+      }
+      if (!t.isExpression(statement.declaration))
+        return { action: "unsupported" };
+      if (isWithStorybookCall(statement.declaration, withStorybookLocalName))
+        return { action: "already-configured" };
+      statement.declaration = t.callExpression(t.identifier(withStorybookLocalName), [
+        statement.declaration
+      ]), changed = !0;
+    }
+  }
+  if (!matchedExport)
+    return { action: "unsupported" };
+  if (!changed)
+    return { action: "already-configured" };
+  if (!hasWithStorybookBinding(program)) {
+    let shouldUseEsmImport = usesEsmSyntax(program) || filePath.endsWith(".mjs");
+    injectWithStorybookImport(program, shouldUseEsmImport);
+  }
+  return {
+    action: "updated",
+    code: recast.print(ast, {
+      quote: "single",
+      trailingComma: !0,
+      tabWidth: 2,
+      wrapColumn: 100
+    }).code
+  };
+}, pathExists2 = async (value) => {
+  try {
+    return await access(value), !0;
+  } catch {
+    return !1;
+  }
+}, detectMetroCandidates = async () => {
+  let candidates = [];
+  for (let fileName of METRO_CONFIG_CANDIDATES) {
+    let absolutePath = path2.resolve(process.cwd(), fileName);
+    await pathExists2(absolutePath) && candidates.push(absolutePath);
+  }
+  return candidates;
+}, createExpoMetroConfigHelper = async (packageManager) => {
+  try {
+    return await packageManager.runPackageCommand({
+      args: [EXPO_CREATE_METRO_COMMAND.command, ...EXPO_CREATE_METRO_COMMAND.args],
+      cwd: process.cwd()
+    }), !0;
+  } catch (error) {
+    return logger12.warn(`Failed to create Expo Metro config automatically: ${String(error)}`), !1;
+  }
+}, resolveMetroConfigPath = async ({
+  packageManager,
+  yes
+}) => {
+  let candidates = await detectMetroCandidates();
+  if (candidates.length === 0 && packageManager.getDependencyVersion("expo") && await createExpoMetroConfigHelper(packageManager) && (candidates = await detectMetroCandidates()), candidates.length === 1)
+    return candidates[0];
+  if (candidates.length > 1) {
+    if (yes)
+      return logger12.warn(
+        `Multiple Metro config files detected. Non-interactive mode selected ${path2.relative(
+          process.cwd(),
+          candidates[0]
+        )}.`
+      ), candidates[0];
+    let selected = await prompt8.select({
+      message: "Multiple Metro config files found. Which one should Storybook update?",
+      options: candidates.map((candidate) => ({
+        label: path2.relative(process.cwd(), candidate),
+        value: candidate
+      }))
+    });
+    return String(selected);
+  }
+  if (yes)
+    return null;
+  let answer = await prompt8.text({
+    message: "No Metro config file was found. Enter the path to your Metro config file to update, or leave blank to skip."
+  }), normalized = String(answer || "").trim();
+  if (!normalized)
+    return null;
+  let resolved = path2.isAbsolute(normalized) ? normalized : path2.resolve(process.cwd(), normalized.replace(/^\.\//, ""));
+  return await pathExists2(resolved) ? resolved : (logger12.warn(`Provided Metro config path does not exist: ${normalized}`), null);
+}, runMetroCodemodOrFallback = async ({
+  packageManager,
+  yes
+}) => {
+  let filePath = await resolveMetroConfigPath({ packageManager, yes });
+  if (!filePath)
+    return {
+      status: "skipped-missing-file",
+      notes: ["No Metro config file was selected for automatic modification."]
+    };
+  let source = await readFile2(filePath, "utf-8");
+  if (containsStorybookImport(source))
+    return {
+      status: "skipped-existing-storybook-import",
+      filePath,
+      notes: ["Storybook import detected in Metro config; leaving file unchanged."]
+    };
+  try {
+    let transformResult = transformMetroConfigSource(source, filePath);
+    if (transformResult.action === "already-configured")
+      return {
+        status: "already-configured",
+        filePath,
+        notes: ["Metro config already appears to be wrapped with withStorybook."]
+      };
+    if (transformResult.action === "unsupported") {
+      let fallbackSource = prependMetroFallbackComment(source);
+      return fallbackSource !== source && await writeFile3(filePath, fallbackSource, "utf-8"), {
+        status: "fallback-commented",
+        filePath,
+        notes: ["Could not apply automated codemod; added guidance comment at top of file."]
+      };
+    }
+    return transformResult.code !== source && await writeFile3(filePath, transformResult.code, "utf-8"), {
+      status: "updated",
+      filePath,
+      notes: ["Metro config was updated with withStorybook wrapper."]
+    };
+  } catch (error) {
+    let fallbackSource = prependMetroFallbackComment(source);
+    return fallbackSource !== source && await writeFile3(filePath, fallbackSource, "utf-8"), {
+      status: "fallback-commented",
+      filePath,
+      notes: [`Metro codemod encountered an error: ${String(error)}`]
+    };
+  }
+};
+
+// src/create/generators/REACT_NATIVE/index.ts
+var lastMetroCodemodResult, lastScriptDerivationResult, detectReactNativeEntrypointTemplateVariant = (allDependencies) => allDependencies.expo || allDependencies["expo-router"] ? "expo" : "default", fixExpoDependencyVersions = async () => {
+  let task = prompt9.taskLog({
+    id: "expo-install-fix",
+    title: "Aligning Expo SDK dependency versions with `npx expo install --fix`"
+  });
+  try {
+    let result = await executeCommand2({
+      command: "npx",
+      args: ["expo", "install", "--fix"],
+      stdio: "pipe"
+    });
+    result.stdout && task.message(String(result.stdout)), task.success("Expo SDK dependency versions aligned", { showLog: !0 });
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    task.error("Could not run `npx expo install --fix` automatically"), logger13.warn(
+      dedent9`
+        Could not automatically align Expo SDK package versions.
+
+        To avoid runtime warnings such as "Native module is null, cannot access legacy storage",
+        run the following command in your project root:
+
+          ${CLI_COLORS4.cta("npx expo install --fix")}
+
+        Reason: ${message}
+      `
+    );
+  }
+}, REACT_NATIVE_default = {
+  metadata: {
+    projectType: ProjectType4.REACT_NATIVE,
+    renderer: SupportedRenderer4.REACT,
+    builderOverride: SupportedBuilder3.VITE,
+    framework: null
+  },
+  configure: async (packageManager, context) => {
+    let missingReactDom = !packageManager.getDependencyVersion("react-dom"), reactVersion = packageManager.getDependencyVersion("react"), dependencyCollector = context.dependencyCollector, peerDependencies = [
+      "react-native-safe-area-context",
+      "@react-native-async-storage/async-storage",
+      "@expo/ui",
+      "expo-symbols"
+    ].filter((dep) => !packageManager.getDependencyVersion(dep)), existingScripts = packageManager.primaryPackageJson.packageJson.scripts, scriptDerivationResult = deriveStorybookPlatformScripts(
+      existingScripts
+    );
+    lastScriptDerivationResult = scriptDerivationResult;
+    let needsCrossEnv = Object.keys(scriptDerivationResult.scriptsToAdd).length > 0 && !packageManager.getDependencyVersion("cross-env"), packagesToResolve = [
+      ...peerDependencies,
+      ...needsCrossEnv ? ["cross-env"] : [],
+      "@storybook/addon-ondevice-controls",
+      "@storybook/addon-ondevice-actions",
+      "@storybook/react-native",
+      "@storybook/react-native-ui-lite",
+      "storybook"
+    ], packages = [
+      ...await packageManager.getVersionedPackages(packagesToResolve, {
+        storybookVersionSpecifier: context.storybookVersionSpecifier
+      }),
+      ...missingReactDom && reactVersion ? [`react-dom@${reactVersion}`] : []
+    ];
+    if (dependencyCollector.addDependencies(packages), packageManager.addScripts({
+      ...scriptDerivationResult.scriptsToAdd
+    }), context.framework == null) {
+      let { packageJson, operationDir } = packageManager.primaryPackageJson;
+      applyPreviewImportsMap(packageJson, join4(RN_STORYBOOK_DIR, "preview.tsx"), operationDir) && packageManager.writePackageJson(packageJson, operationDir);
+    }
+    await copyTemplateFiles2({
+      packageManager,
+      templateLocation: SupportedRenderer4.REACT_NATIVE,
+      language: SupportedLanguage6.TYPESCRIPT,
+      destination: RN_STORYBOOK_DIR,
+      features: context.features
+    }), await generateReactNativeEntrypoint({ language: context.language }), lastMetroCodemodResult = await runMetroCodemodOrFallback({
+      packageManager,
+      yes: !!context.yes
+    });
+    let templateVariant = detectReactNativeEntrypointTemplateVariant(packageManager.getAllDependencies());
+    return await generateReactNativeEntrypoint({
+      language: context.language,
+      templateVariant
+    }), {
+      // Signal to skip baseGenerator by returning minimal config
+      storybookConfigFolder: RN_STORYBOOK_DIR,
+      skipGenerator: !0,
+      storybookCommand: null,
+      shouldRunDev: !1
+      // React Native is started via platform scripts (see postConfigure), not `storybook dev`
+    };
+  },
+  postInstall: async ({ packageManager }) => {
+    detectReactNativeEntrypointTemplateVariant(packageManager.getAllDependencies()) === "expo" && await fixExpoDependencyVersions();
+  },
+  postConfigure: ({ packageManager }) => {
+    let platformRunGuidance = (() => {
+      let scriptNames = Object.keys(lastScriptDerivationResult?.scriptsToAdd ?? {});
+      return scriptNames.length === 0 ? "No platform launch scripts could be generated automatically." : scriptNames.map((scriptName) => packageManager.getRunCommand(scriptName)).join(`
+      `);
+    })(), scriptWarningSummary = (() => {
+      let missing = lastScriptDerivationResult?.missingBaseScripts ?? [];
+      return missing.length === 0 ? null : `Could not infer ${missing.join(", ")} app scripts from package.json. To launch Storybook manually, set STORYBOOK_ENABLED=true when running your app scripts.`;
+    })(), metroCodemodSummary = lastMetroCodemodResult ? lastMetroCodemodResult.status === "updated" ? "Metro config was updated automatically with withStorybook(...)." : lastMetroCodemodResult.status === "already-configured" ? "Metro config already appears to be configured for Storybook." : lastMetroCodemodResult.status === "skipped-existing-storybook-import" ? "Metro config already contains Storybook imports, so auto-modification was skipped." : lastMetroCodemodResult.status === "fallback-commented" ? "Metro config could not be transformed automatically; guidance was added to your Metro config file." : "No Metro config file was selected; please update Metro manually." : "Metro config could not be evaluated automatically.", metroStatus = lastMetroCodemodResult?.status, showWithStorybookManualSnippet = !lastMetroCodemodResult || metroStatus === "fallback-commented" || metroStatus === "skipped-missing-file", mayNeedFollowUp = !!scriptWarningSummary || showWithStorybookManualSnippet;
+    logger13.log(dedent9`
+      ${CLI_COLORS4.success("Storybook for React Native has been configured.")}
+
+      ${mayNeedFollowUp ? `${CLI_COLORS4.info("If anything below could not be applied automatically, follow the guidance or the docs link.")}
+` : ""}
+      Storybook run scripts:
+
+      ${CLI_COLORS4.cta(" " + platformRunGuidance + " ")}
+
+      Metro config status:
+
+      ${CLI_COLORS4.info(" " + metroCodemodSummary + " ")}
+
+      ${showWithStorybookManualSnippet ? dedent9`
+      If your Metro config still needs wiring, wrap the default export with withStorybook:
+
+      ${CLI_COLORS4.info(" const { withStorybook } = require('@storybook/react-native/withStorybook'); ")}
+      ${CLI_COLORS4.info(" module.exports = withStorybook(defaultConfig); ")}
+      ` : ""}
+      ${scriptWarningSummary ? `${CLI_COLORS4.warning(scriptWarningSummary)}
+` : ""}
+
+      For more details go to:
+      ${METRO_SETUP_DOCS_LINK}
+    `);
+  }
+};
+
+// src/create/generators/registerGenerators.ts
+var setOfGenerators = /* @__PURE__ */ new Set([
+  REACT_default,
+  REACT_NATIVE_default,
+  NEXTJS_default
+]);
+function registerAllGenerators() {
+  setOfGenerators.forEach((generator) => {
+    generatorRegistry.register(generator);
+  });
+}
+
+// src/create/initiate.ts
+async function checkFeatureSupport(packageManager, framework, builder, renderer) {
+  return {
+    isTestFeatureAvailable: (await new FeatureCompatibilityService(packageManager).validateTestFeatureCompatibility(
+      framework,
+      builder,
+      process.cwd()
+    )).compatible,
+    isAiAvailable: supportsSkills(renderer, framework),
+    isAiSetupAvailable: supportsAiSetup(renderer, builder, framework)
+  };
+}
+async function doInitiate(options) {
+  options.agent && (options.yes = !0);
+  let telemetryService = new TelemetryService();
+  registerAllGenerators();
+  let dependencyCollector = new DependencyCollector(), { packageManager, isEmptyProject } = await executePreflightCheck(options), { projectType, language } = await executeProjectDetection(packageManager, options), { framework, builder, renderer } = await executeFrameworkDetection(
+    projectType,
+    packageManager,
+    options
+  ), { isTestFeatureAvailable, isAiAvailable, isAiSetupAvailable } = await checkFeatureSupport(
+    packageManager,
+    framework,
+    builder,
+    renderer
+  ), { selectedFeatures } = await executeUserPreferences({
+    options,
+    framework,
+    builder,
+    renderer,
+    isTestFeatureAvailable,
+    // Skip AI feature recommendation when scaffolding into an empty directory,
+    // since the user hasn't yet committed to a project setup where AI tooling adds value.
+    isAiAvailable: isAiAvailable && !isEmptyProject,
+    isAiSetupAvailable
+  });
+  selectedFeatures.has(Feature6.AI) && !isAiAvailable && (logger14.warn(
+    "The AI features are not available for this framework yet, so the Forkbook skills are not installed."
+  ), selectedFeatures.delete(Feature6.AI));
+  let { configDir, storybookCommand, shouldRunDev, extraAddons, postInstall: postInstall2 } = await executeGeneratorExecution({
+    projectType,
+    packageManager,
+    frameworkInfo: { builder, framework, renderer },
+    options,
+    dependencyCollector,
+    selectedFeatures,
+    language
+  }), dependencyInstallationResult = await executeDependencyInstallation({
+    packageManager,
+    dependencyCollector,
+    skipInstall: !!options.skipInstall,
+    selectedFeatures
+  });
+  if (dependencyCollector = null, postInstall2 && !options.skipInstall && dependencyInstallationResult.status === "success")
+    try {
+      await postInstall2();
+    } catch (err) {
+      logger14.warn(`Post-install step failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  await executeAddonConfiguration({
+    packageManager,
+    addons: extraAddons,
+    configDir,
+    options
+  });
+  let hasAiFeature = selectedFeatures.has(Feature6.AI);
+  return hasAiFeature && await telemetryService.trackSkills(
+    await installSkills({ packageManager, source: "ai-feature" })
+  ), configDir && isAiSetupAvailable && (await cache.set("ai-init-opt-in", {
+    timestamp: Date.now(),
+    configDir: resolve3(configDir),
+    answer: hasAiFeature
+  }).catch(() => {
+  }), await telemetry4("ai-init-opt-in", {
+    answer: hasAiFeature
+  }).catch(() => {
+  })), await executeFinalization({
+    showAgentFollowUp: !!options.agent && hasAiFeature && isAiSetupAvailable,
+    showAiInstructions: hasAiFeature && isAiSetupAvailable,
+    logfile: options.logfile,
+    storybookCommand,
+    setupSkillCommand: packageManager.getPackageCommand(["forkbook", "skills", "setup"])
+  }), await telemetryService.trackInitWithContext(projectType, selectedFeatures, configDir), {
+    shouldRunDev: !!options.dev && !options.skipInstall && shouldRunDev !== !1 && dependencyInstallationResult.status === "success",
+    packageManager,
+    storybookCommand
+  };
+}
+var handleCommandFailure = async (logFilePath) => {
+  let logFile = await logTracker2.writeToFile(logFilePath);
+  logger14.error("Forkbook encountered an error during initialization"), logger14.log(`Debug logs are written to: ${logFile}`), logger14.outro("Forkbook exited with an error"), process.exit(1);
+};
+async function initiate(options) {
+  let initiateResult = await withTelemetry(
+    "init",
+    {
+      cliOptions: options,
+      printError: (err) => !err.handled && logger14.error(err),
+      // enable telemetry if nothing else specified in env var or CLI options
+      fallbackTelemetryState: !0
+    },
+    async () => {
+      let result = await doInitiate(options);
+      return logger14.outro(""), result;
+    }
+  ).catch(() => handleCommandFailure(options.logfile));
+  !options.agent && initiateResult?.shouldRunDev && await runStorybookDev(initiateResult);
+}
+async function runStorybookDev(result) {
+  let { packageManager, storybookCommand } = result;
+  if (storybookCommand)
+    try {
+      let parts = storybookCommand.split(" ");
+      packageManager.type === "npm" && parts.push("--silent"), (packageManager.type === PackageManagerName2.NPM || packageManager.type === PackageManagerName2.BUN) && parts.push("--");
+      let defaultPort = 6006, availablePort = await getServerPort(defaultPort);
+      availablePort !== defaultPort && parts.push("-p", `${availablePort}`), parts.push("--quiet");
+      let [command, ...args] = [...parts];
+      await executeCommand3({
+        command,
+        args,
+        stdio: "inherit"
+      });
+    } catch {
+    }
+}
+
+export {
+  doInitiate,
+  initiate
+};